← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Lib/test/test_dbm.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_dbm.py
 
1
#! /usr/bin/env python
 
2
"""Test script for the dbm.open function based on testdumbdbm.py"""
 
3
 
 
4
import os
 
5
import unittest
 
6
import dbm
 
7
import glob
 
8
import test.support
 
9
 
 
10
_fname = test.support.TESTFN
 
11
 
 
12
#
 
13
# Iterates over every database module supported by dbm currently available,
 
14
# setting dbm to use each in turn, and yielding that module
 
15
#
 
16
def dbm_iterator():
 
17
    for name in dbm._names:
 
18
        try:
 
19
            mod = __import__(name, fromlist=['open'])
 
20
        except ImportError:
 
21
            continue
 
22
        dbm._modules[name] = mod
 
23
        yield mod
 
24
 
 
25
#
 
26
# Clean up all scratch databases we might have created during testing
 
27
#
 
28
def delete_files():
 
29
    # we don't know the precise name the underlying database uses
 
30
    # so we use glob to locate all names
 
31
    for f in glob.glob(_fname + "*"):
 
32
        test.support.unlink(f)
 
33
 
 
34
 
 
35
class AnyDBMTestCase(unittest.TestCase):
 
36
    _dict = {'0': b'',
 
37
             'a': b'Python:',
 
38
             'b': b'Programming',
 
39
             'c': b'the',
 
40
             'd': b'way',
 
41
             'f': b'Guido',
 
42
             'g': b'intended',
 
43
             }
 
44
 
 
45
    def init_db(self):
 
46
        f = dbm.open(_fname, 'n')
 
47
        for k in self._dict:
 
48
            f[k.encode("ascii")] = self._dict[k]
 
49
        f.close()
 
50
 
 
51
    def keys_helper(self, f):
 
52
        keys = sorted(k.decode("ascii") for k in f.keys())
 
53
        dkeys = sorted(self._dict.keys())
 
54
        self.assertEqual(keys, dkeys)
 
55
        return keys
 
56
 
 
57
    def test_error(self):
 
58
        self.assert_(issubclass(self.module.error, IOError))
 
59
 
 
60
    def test_anydbm_not_existing(self):
 
61
        self.assertRaises(dbm.error, dbm.open, _fname)
 
62
 
 
63
    def test_anydbm_creation(self):
 
64
        f = dbm.open(_fname, 'c')
 
65
        self.assertEqual(list(f.keys()), [])
 
66
        for key in self._dict:
 
67
            f[key.encode("ascii")] = self._dict[key]
 
68
        self.read_helper(f)
 
69
        f.close()
 
70
 
 
71
    def test_anydbm_modification(self):
 
72
        self.init_db()
 
73
        f = dbm.open(_fname, 'c')
 
74
        self._dict['g'] = f[b'g'] = b"indented"
 
75
        self.read_helper(f)
 
76
        f.close()
 
77
 
 
78
    def test_anydbm_read(self):
 
79
        self.init_db()
 
80
        f = dbm.open(_fname, 'r')
 
81
        self.read_helper(f)
 
82
        f.close()
 
83
 
 
84
    def test_anydbm_keys(self):
 
85
        self.init_db()
 
86
        f = dbm.open(_fname, 'r')
 
87
        keys = self.keys_helper(f)
 
88
        f.close()
 
89
 
 
90
    def test_anydbm_access(self):
 
91
        self.init_db()
 
92
        f = dbm.open(_fname, 'r')
 
93
        key = "a".encode("ascii")
 
94
        assert(key in f)
 
95
        assert(f[key] == b"Python:")
 
96
        f.close()
 
97
 
 
98
    def read_helper(self, f):
 
99
        keys = self.keys_helper(f)
 
100
        for key in self._dict:
 
101
            self.assertEqual(self._dict[key], f[key.encode("ascii")])
 
102
 
 
103
    def tearDown(self):
 
104
        delete_files()
 
105
 
 
106
    def setUp(self):
 
107
        dbm._defaultmod = self.module
 
108
        delete_files()
 
109
 
 
110
 
 
111
class WhichDBTestCase(unittest.TestCase):
 
112
    # Actual test methods are added to namespace after class definition.
 
113
    def __init__(self, *args):
 
114
        unittest.TestCase.__init__(self, *args)
 
115
 
 
116
    def test_whichdb(self):
 
117
        for module in dbm_iterator():
 
118
            # Check whether whichdb correctly guesses module name
 
119
            # for databases opened with "module" module.
 
120
            # Try with empty files first
 
121
            name = module.__name__
 
122
            if name == 'dbm.dumb':
 
123
                continue   # whichdb can't support dbm.dumb
 
124
            test.support.unlink(_fname)
 
125
            f = module.open(_fname, 'c')
 
126
            f.close()
 
127
            self.assertEqual(name, dbm.whichdb(_fname))
 
128
            # Now add a key
 
129
            f = module.open(_fname, 'w')
 
130
            f[b"1"] = b"1"
 
131
            # and test that we can find it
 
132
            self.assertTrue(b"1" in f)
 
133
            # and read it
 
134
            self.assertTrue(f[b"1"] == b"1")
 
135
            f.close()
 
136
            self.assertEqual(name, dbm.whichdb(_fname))
 
137
 
 
138
    def tearDown(self):
 
139
        delete_files()
 
140
 
 
141
    def setUp(self):
 
142
        delete_files()
 
143
        self.filename = test.support.TESTFN
 
144
        self.d = dbm.open(self.filename, 'c')
 
145
        self.d.close()
 
146
 
 
147
    def test_keys(self):
 
148
        self.d = dbm.open(self.filename, 'c')
 
149
        self.assertEqual(self.d.keys(), [])
 
150
        a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')]
 
151
        for k, v in a:
 
152
            self.d[k] = v
 
153
        self.assertEqual(sorted(self.d.keys()), sorted(k for (k, v) in a))
 
154
        for k, v in a:
 
155
            self.assert_(k in self.d)
 
156
            self.assertEqual(self.d[k], v)
 
157
        self.assert_(b'xxx' not in self.d)
 
158
        self.assertRaises(KeyError, lambda: self.d[b'xxx'])
 
159
        self.d.close()
 
160
 
 
161
 
 
162
def test_main():
 
163
    classes = [WhichDBTestCase]
 
164
    for mod in dbm_iterator():
 
165
        classes.append(type("TestCase-" + mod.__name__, (AnyDBMTestCase,),
 
166
                            {'module': mod}))
 
167
    test.support.run_unittest(*classes)
 
168
 
 
169
if __name__ == "__main__":
 
170
    test_main()