Debian Codegraph @

Lib/test/test_dbm_gnu.py

raw
1 import os
2 import unittest
3 from test import support
4 from test.support import cpython_only, import_helper
5 from test.support.os_helper import (TESTFN, TESTFN_NONASCII, FakePath,
6 create_empty_file, temp_dir, unlink)
7
8 gdbm = import_helper.import_module("dbm.gnu") # skip if not supported
9
10 filename = TESTFN
11
12 class TestGdbm(unittest.TestCase):
13 @staticmethod
14 def setUpClass():
15 if support.verbose:
16 try:
17 from _gdbm import _GDBM_VERSION as version
18 except ImportError:
19 pass
20 else:
21 print(f"gdbm version: {version}")
22
23 def setUp(self):
24 self.g = None
25
26 def tearDown(self):
27 if self.g is not None:
28 self.g.close()
29 unlink(filename)
30
31 @cpython_only
32 def test_disallow_instantiation(self):
33 # Ensure that the type disallows instantiation (bpo-43916)
34 self.g = gdbm.open(filename, 'c')
35 support.check_disallow_instantiation(self, type(self.g))
36
37 def test_key_methods(self):
38 self.g = gdbm.open(filename, 'c')
39 self.assertEqual(self.g.keys(), [])
40 self.g['a'] = 'b'
41 self.g['12345678910'] = '019237410982340912840198242'
42 self.g[b'bytes'] = b'data'
43 key_set = set(self.g.keys())
44 self.assertEqual(key_set, set([b'a', b'bytes', b'12345678910']))
45 self.assertIn('a', self.g)
46 self.assertIn(b'a', self.g)
47 self.assertEqual(self.g[b'bytes'], b'data')
48 key = self.g.firstkey()
49 while key:
50 self.assertIn(key, key_set)
51 key_set.remove(key)
52 key = self.g.nextkey(key)
53 # get() and setdefault() work as in the dict interface
54 self.assertEqual(self.g.get(b'a'), b'b')
55 self.assertIsNone(self.g.get(b'xxx'))
56 self.assertEqual(self.g.get(b'xxx', b'foo'), b'foo')
57 with self.assertRaises(KeyError):
58 self.g['xxx']
59 self.assertEqual(self.g.setdefault(b'xxx', b'foo'), b'foo')
60 self.assertEqual(self.g[b'xxx'], b'foo')
61
62 def test_error_conditions(self):
63 # Try to open a non-existent database.
64 unlink(filename)
65 self.assertRaises(gdbm.error, gdbm.open, filename, 'r')
66 # Try to access a closed database.
67 self.g = gdbm.open(filename, 'c')
68 self.g.close()
69 self.assertRaises(gdbm.error, lambda: self.g['a'])
70 # try pass an invalid open flag
71 self.assertRaises(gdbm.error, lambda: gdbm.open(filename, 'rx').close())
72
73 def test_flags(self):
74 # Test the flag parameter open() by trying all supported flag modes.
75 all = set(gdbm.open_flags)
76 # Test standard flags (presumably "crwn").
77 modes = all - set('fsu')
78 for mode in sorted(modes): # put "c" mode first
79 self.g = gdbm.open(filename, mode)
80 self.g.close()
81
82 # Test additional flags (presumably "fsu").
83 flags = all - set('crwn')
84 for mode in modes:
85 for flag in flags:
86 self.g = gdbm.open(filename, mode + flag)
87 self.g.close()
88
89 def test_reorganize(self):
90 self.g = gdbm.open(filename, 'c')
91 size0 = os.path.getsize(filename)
92
93 # bpo-33901: on macOS with gdbm 1.15, an empty database uses 16 MiB
94 # and adding an entry of 10,000 B has no effect on the file size.
95 # Add size0 bytes to make sure that the file size changes.
96 value_size = max(size0, 10000)
97 self.g['x'] = 'x' * value_size
98 size1 = os.path.getsize(filename)
99 self.assertGreater(size1, size0)
100
101 del self.g['x']
102 # 'size' is supposed to be the same even after deleting an entry.
103 self.assertEqual(os.path.getsize(filename), size1)
104
105 self.g.reorganize()
106 size2 = os.path.getsize(filename)
107 self.assertLess(size2, size1)
108 self.assertGreaterEqual(size2, size0)
109
110 def test_context_manager(self):
111 with gdbm.open(filename, 'c') as db:
112 db["gdbm context manager"] = "context manager"
113
114 with gdbm.open(filename, 'r') as db:
115 self.assertEqual(list(db.keys()), [b"gdbm context manager"])
116
117 with self.assertRaises(gdbm.error) as cm:
118 db.keys()
119 self.assertEqual(str(cm.exception),
120 "GDBM object has already been closed")
121
122 def test_bool_empty(self):
123 with gdbm.open(filename, 'c') as db:
124 self.assertFalse(bool(db))
125
126 def test_bool_not_empty(self):
127 with gdbm.open(filename, 'c') as db:
128 db['a'] = 'b'
129 self.assertTrue(bool(db))
130
131 def test_bool_on_closed_db_raises(self):
132 with gdbm.open(filename, 'c') as db:
133 db['a'] = 'b'
134 self.assertRaises(gdbm.error, bool, db)
135
136 def test_bytes(self):
137 with gdbm.open(filename, 'c') as db:
138 db[b'bytes key \xbd'] = b'bytes value \xbd'
139 with gdbm.open(filename, 'r') as db:
140 self.assertEqual(list(db.keys()), [b'bytes key \xbd'])
141 self.assertTrue(b'bytes key \xbd' in db)
142 self.assertEqual(db[b'bytes key \xbd'], b'bytes value \xbd')
143
144 def test_unicode(self):
145 with gdbm.open(filename, 'c') as db:
146 db['Unicode key \U0001f40d'] = 'Unicode value \U0001f40d'
147 with gdbm.open(filename, 'r') as db:
148 self.assertEqual(list(db.keys()), ['Unicode key \U0001f40d'.encode()])
149 self.assertTrue('Unicode key \U0001f40d'.encode() in db)
150 self.assertTrue('Unicode key \U0001f40d' in db)
151 self.assertEqual(db['Unicode key \U0001f40d'.encode()],
152 'Unicode value \U0001f40d'.encode())
153 self.assertEqual(db['Unicode key \U0001f40d'],
154 'Unicode value \U0001f40d'.encode())
155
156 def test_write_readonly_file(self):
157 with gdbm.open(filename, 'c') as db:
158 db[b'bytes key'] = b'bytes value'
159 with gdbm.open(filename, 'r') as db:
160 with self.assertRaises(gdbm.error):
161 del db[b'not exist key']
162 with self.assertRaises(gdbm.error):
163 del db[b'bytes key']
164 with self.assertRaises(gdbm.error):
165 db[b'not exist key'] = b'not exist value'
166
167 @unittest.skipUnless(TESTFN_NONASCII,
168 'requires OS support of non-ASCII encodings')
169 def test_nonascii_filename(self):
170 filename = TESTFN_NONASCII
171 self.addCleanup(unlink, filename)
172 with gdbm.open(filename, 'c') as db:
173 db[b'key'] = b'value'
174 self.assertTrue(os.path.exists(filename))
175 with gdbm.open(filename, 'r') as db:
176 self.assertEqual(list(db.keys()), [b'key'])
177 self.assertTrue(b'key' in db)
178 self.assertEqual(db[b'key'], b'value')
179
180 def test_nonexisting_file(self):
181 nonexisting_file = 'nonexisting-file'
182 with self.assertRaises(gdbm.error) as cm:
183 gdbm.open(nonexisting_file)
184 self.assertIn(nonexisting_file, str(cm.exception))
185 self.assertEqual(cm.exception.filename, nonexisting_file)
186
187 def test_open_with_pathlib_path(self):
188 gdbm.open(FakePath(filename), "c").close()
189
190 def test_open_with_bytes_path(self):
191 gdbm.open(os.fsencode(filename), "c").close()
192
193 def test_open_with_pathlib_bytes_path(self):
194 gdbm.open(FakePath(os.fsencode(filename)), "c").close()
195
196 def test_clear(self):
197 kvs = [('foo', 'bar'), ('1234', '5678')]
198 with gdbm.open(filename, 'c') as db:
199 for k, v in kvs:
200 db[k] = v
201 self.assertIn(k, db)
202 self.assertEqual(len(db), len(kvs))
203
204 db.clear()
205 for k, v in kvs:
206 self.assertNotIn(k, db)
207 self.assertEqual(len(db), 0)
208
209 @support.run_with_locale(
210 'LC_ALL',
211 'fr_FR.iso88591', 'ja_JP.sjis', 'zh_CN.gbk',
212 'fr_FR.utf8', 'en_US.utf8',
213 '',
214 )
215 def test_localized_error(self):
216 with temp_dir() as d:
217 create_empty_file(os.path.join(d, 'test'))
218 self.assertRaises(gdbm.error, gdbm.open, filename, 'r')
219
220
221 if __name__ == '__main__':
222 unittest.main()