LEFT | RIGHT |
(no file at all) | |
| 1 from test import support |
| 2 import os |
| 3 import unittest |
| 4 from test.support import verbose, TESTFN, run_unittest, unlink |
| 5 from collections import MutableMapping, KeysView, ItemsView, ValuesView |
| 6 |
| 7 |
| 8 # We need three dbm objects at most at the same time to test. |
| 9 filenames = filename, filename2, filenam3 = TESTFN, TESTFN + '2', TESTFN + '3' |
| 10 |
| 11 |
| 12 class TestDbmBase(unittest.TestCase): |
| 13 |
| 14 _module = None |
| 15 |
| 16 def __init__(self, *args): |
| 17 super().__init__(*args) |
| 18 self.openner = lambda x=filename: self._module.open(x, 'c') |
| 19 |
| 20 def setUp(self): |
| 21 self.d, self.d2, self.d3 = None, None, None |
| 22 |
| 23 def _delete_db(self, file_name=filename): |
| 24 for suffix in ['', '.pag', '.dir', '.dat', '.db']: |
| 25 support.unlink(file_name + suffix) |
| 26 |
| 27 def tearDown(self): |
| 28 for d in (self.d, self.d2, self.d3): |
| 29 if d is not None: |
| 30 self.d.close() |
| 31 for fn in filenames: |
| 32 self._delete_db(fn) |
| 33 |
| 34 def test_get(self): |
| 35 self.d = self.openner() |
| 36 self.d['a'] = 'b' |
| 37 self.assertEqual(self.d.get('a'), b'b') |
| 38 self.assertEqual(self.d.get(b'a'), b'b') |
| 39 self.assertEqual(self.d.get('a', None), b'b') |
| 40 self.assertIsNone(self.d.get('b')) |
| 41 self.assertIsNone(self.d.get(b'b')) |
| 42 self.assertEqual(self.d.get('b', 'c'), 'c') |
| 43 |
| 44 def test_contains(self): |
| 45 self.d = self.openner() |
| 46 self.d['a'] = 'b' |
| 47 self.assertIn('a', self.d) |
| 48 self.assertIn(b'a', self.d) |
| 49 self.assertNotIn('b', self.d) |
| 50 |
| 51 def test_items(self): |
| 52 self.d = self.openner() |
| 53 self.assertEqual(self.d.items(), set()) |
| 54 self.assertEqual(len(self.d.items()), 0) |
| 55 self.assertNotIn(('a', 'b'), self.d.items()) |
| 56 self.d['a'] = 'b' |
| 57 self.d['c'] = 'd' |
| 58 self.assertIn(('a', b'b'), self.d.items()) |
| 59 self.assertIn((b'a', b'b'), self.d.items()) |
| 60 self.assertIn((b'a', 'b'), self.d.items()) |
| 61 self.assertIn(('a', 'b'), self.d.items()) |
| 62 self.assertNotIn((b'a', 'c'), self.d.items()) |
| 63 self.assertNotIn(('a', 'c'), self.d.items()) |
| 64 self.assertNotIn(('a', None), self.d.items()) |
| 65 self.assertEqual(self.d.items(), set(((b'a', b'b'), (b'c', b'd')))) |
| 66 self.assertEqual(len(self.d.items()), 2) |
| 67 |
| 68 def test_items_set_operations(self): |
| 69 self.d, self.d2, self.d3 = map(self.openner, filenames) |
| 70 self.d.update({'a': '1', 'b': '2'}) |
| 71 self.d2.update({'a': '2', 'b': '2'}) |
| 72 self.d3.update({'d': '4', 'e': '5'}) |
| 73 self.assertEqual( |
| 74 self.d.items() & self.d.items(), {(b'a', b'1'), (b'b', b'2')}) |
| 75 self.assertEqual(self.d.items() & self.d2.items(), {(b'b', b'2')}) |
| 76 self.assertEqual(self.d.items() & self.d3.items(), set()) |
| 77 self.assertEqual(self.d.items() & set(self.d.items()), |
| 78 {(b'a', b'1'), (b'b', b'2')}) |
| 79 self.assertEqual(self.d.items() & set(self.d2.items()), {(b'b', b'2')}) |
| 80 self.assertEqual(self.d.items() & set(self.d3.items()), set()) |
| 81 |
| 82 self.assertEqual(self.d.items() | self.d.items(), |
| 83 {(b'a', b'1'), (b'b', b'2')}) |
| 84 self.assertEqual(self.d.items() | self.d2.items(), |
| 85 {(b'a', b'1'), (b'a', b'2'), (b'b', b'2')}) |
| 86 self.assertEqual(self.d.items() | self.d3.items(), |
| 87 {(b'a', b'1'), (b'b', b'2'), (b'd', b'4'), (b'e', b'5')
}) |
| 88 self.assertEqual(self.d.items() | set(self.d.items()), |
| 89 {(b'a', b'1'), (b'b', b'2')}) |
| 90 self.assertEqual(self.d.items() | set(self.d2.items()), |
| 91 {(b'a', b'1'), (b'a', b'2'), (b'b', b'2')}) |
| 92 self.assertEqual(self.d.items() | set(self.d3.items()), |
| 93 {(b'a', b'1'), (b'b', b'2'), (b'd', b'4'), (b'e', b'5')
}) |
| 94 |
| 95 self.assertEqual(self.d.items() ^ self.d.items(), set()) |
| 96 self.assertEqual(self.d.items() ^ self.d2.items(), |
| 97 {(b'a', b'1'), (b'a', b'2')}) |
| 98 self.assertEqual(self.d.items() ^ self.d3.items(), |
| 99 {(b'a', b'1'), (b'b', b'2'), (b'd', b'4'), (b'e', b'5')
}) |
| 100 |
| 101 self.assertFalse(self.d.items().isdisjoint(self.d.items())) |
| 102 self.assertFalse(self.d.items().isdisjoint(self.d2.items())) |
| 103 self.assertFalse(self.d.items().isdisjoint(list(self.d2.items()))) |
| 104 self.assertFalse(self.d.items().isdisjoint(set(self.d2.items()))) |
| 105 self.assertTrue(self.d.items().isdisjoint({'x', 'y', 'z'})) |
| 106 self.assertTrue(self.d.items().isdisjoint(['x', 'y', 'z'])) |
| 107 self.assertTrue(self.d.items().isdisjoint(set(['x', 'y', 'z']))) |
| 108 self.assertTrue(self.d.items().isdisjoint(set(['x', 'y']))) |
| 109 self.assertTrue(self.d.items().isdisjoint({})) |
| 110 self.assertTrue(self.d.items().isdisjoint(self.d3.items())) |
| 111 |
| 112 self.d.clear() |
| 113 self.assertTrue(self.d.items().isdisjoint(set())) |
| 114 self.assertTrue(self.d.items().isdisjoint([])) |
| 115 self.assertTrue(self.d.items().isdisjoint(self.d.items())) |
| 116 self.assertTrue(self.d.items().isdisjoint([1])) |
| 117 |
| 118 def test_pop(self): |
| 119 self.d = self.openner() |
| 120 ar = self.d.pop('a') |
| 121 self.assertIsNone(self.d.pop('a')) |
| 122 self.d['a'] = 'b' |
| 123 self.d['c'] = 'd' |
| 124 self.assertIsNone(self.d.pop('e')) |
| 125 self.assertEqual(self.d.keys(), set((b'a', b'c'))) |
| 126 self.assertIsNone(self.d.pop('e', None)) |
| 127 self.assertEqual(self.d.keys(), set((b'a', b'c'))) |
| 128 self.assertEqual(self.d.pop('a'), b'b') |
| 129 self.assertEqual(set(self.d.keys()), {b'c'}) |
| 130 self.assertEqual(self.d.pop('c', None), b'd') |
| 131 self.assertEqual(self.d.keys(), set()) |
| 132 |
| 133 def test_popitem(self): |
| 134 self.d = self.openner() |
| 135 self.assertRaises(KeyError, self.d.popitem) |
| 136 self.d['a'] = 'b' |
| 137 self.assertEqual(self.d.popitem(), (b'a', b'b')) |
| 138 self.assertEqual(len(self.d), 0) |
| 139 self.assertRaises(KeyError, self.d.popitem) |
| 140 |
| 141 def test_clear(self): |
| 142 self.d = self.openner() |
| 143 self.assertEqual(self.d.keys(), set()) |
| 144 self.d['a'] = 'b' |
| 145 self.d['c'] = 'c' |
| 146 self.d.clear() |
| 147 self.assertEqual(self.d.keys(), set()) |
| 148 |
| 149 def test_iteration(self): |
| 150 self.d = self.openner() |
| 151 self.assertEqual(self.d.keys(), set()) |
| 152 self.assertRaises(StopIteration, next, iter(self.d)) |
| 153 self.d['a'] = 'b' |
| 154 self.d['c'] = 'd' |
| 155 gi = iter(self.d) |
| 156 self.assertEqual(set((next(gi), next(gi))), set((b'a', b'c'))) |
| 157 self.assertRaises(StopIteration, next, gi) |
| 158 |
| 159 def test_keys(self): |
| 160 self.d = self.openner() |
| 161 self.assertEqual(self.d.keys(), set()) |
| 162 self.assertEqual(len(self.d.keys()), 0) |
| 163 self.d['a'] = 'b' |
| 164 self.d[b'bytes'] = b'data' |
| 165 self.d['12345678910'] = '019237410982340912840198242' |
| 166 self.assertEqual(len(self.d.keys()), 3) |
| 167 self.assertIn(b'a', self.d) |
| 168 self.assertNotIn(b'b', self.d) |
| 169 self.assertEqual(self.d[b'bytes'], b'data') |
| 170 |
| 171 def test_keys_set_operations(self): |
| 172 self.d, self.d2, self.d3 = map(self.openner, filenames) |
| 173 self.d.update({'a': '1', 'b': '2'}) |
| 174 self.d2.update({'b': '3', 'c': '2'}) |
| 175 self.d3.update({'d': '4', 'e': '5'}) |
| 176 self.assertEqual(self.d.keys() & self.d.keys(), {b'a', b'b'}) |
| 177 self.assertEqual(self.d.keys() & self.d2.keys(), {b'b'}) |
| 178 self.assertEqual(self.d.keys() & self.d3.keys(), set()) |
| 179 self.assertEqual(self.d.keys() & set(self.d.keys()), {b'a', b'b'}) |
| 180 self.assertEqual(self.d.keys() & set(self.d2.keys()), {b'b'}) |
| 181 self.assertEqual(self.d.keys() & set(self.d3.keys()), set()) |
| 182 |
| 183 self.assertEqual(self.d.keys() | self.d.keys(), {b'a', b'b'}) |
| 184 self.assertEqual(self.d.keys() | self.d2.keys(), {b'a', b'b', b'c'}) |
| 185 self.assertEqual(self.d.keys() | self.d3.keys(), {b'a', b'b', b'd', b'e'
}) |
| 186 self.assertEqual(self.d.keys() | set(self.d.keys()), {b'a', b'b'}) |
| 187 self.assertEqual(self.d.keys() | set(self.d2.keys()), {b'a', b'b', b'c'}
) |
| 188 self.assertEqual(self.d.keys() | set(self.d3.keys()), |
| 189 {b'a', b'b', b'd', b'e'}) |
| 190 |
| 191 self.assertEqual(self.d.keys() ^ self.d.keys(), set()) |
| 192 self.assertEqual(self.d.keys() ^ self.d2.keys(), {b'a', b'c'}) |
| 193 self.assertEqual(self.d.keys() ^ self.d3.keys(), {b'a', b'b', b'd', b'e'
}) |
| 194 self.assertEqual(self.d.keys() ^ set(self.d.keys()), set()) |
| 195 self.assertEqual(self.d.keys() ^ set(self.d2.keys()), {b'a', b'c'}) |
| 196 self.assertEqual(self.d.keys() ^ set(self.d3.keys()), |
| 197 {b'a', b'b', b'd', b'e'}) |
| 198 |
| 199 self.assertFalse(self.d.keys().isdisjoint(self.d.keys())) |
| 200 self.assertFalse(self.d.keys().isdisjoint(self.d2.keys())) |
| 201 self.assertFalse(self.d.keys().isdisjoint(list(self.d2.keys()))) |
| 202 self.assertFalse(self.d.keys().isdisjoint(set(self.d2.keys()))) |
| 203 self.assertTrue(self.d.keys().isdisjoint({b'x', b'y', b'z'})) |
| 204 self.assertTrue(self.d.keys().isdisjoint([b'x', b'y', b'z'])) |
| 205 self.assertTrue(self.d.keys().isdisjoint(set([b'x', b'y', b'z']))) |
| 206 self.assertTrue(self.d.keys().isdisjoint(set([b'x', b'y']))) |
| 207 self.assertTrue(self.d.keys().isdisjoint([b'x', b'y'])) |
| 208 self.assertTrue(self.d.keys().isdisjoint({})) |
| 209 self.assertTrue(self.d.keys().isdisjoint(self.d3.keys())) |
| 210 |
| 211 self.d.clear() |
| 212 self.assertTrue(self.d.keys().isdisjoint(set())) |
| 213 self.assertTrue(self.d.keys().isdisjoint([])) |
| 214 self.assertTrue(self.d.keys().isdisjoint(self.d.keys())) |
| 215 self.assertTrue(self.d.keys().isdisjoint(['1'])) |
| 216 |
| 217 def test_keys_richcompare(self): |
| 218 self.d, self.d2 = map(self.openner, filenames[:2]) |
| 219 self.d['a'] = 'a' |
| 220 self.d2['a'] = 'a' |
| 221 keys1, keys2 = self.d.keys(), self.d2.keys() |
| 222 self.assertEqual(keys1, keys2) |
| 223 self.d['b'] = 'b' |
| 224 self.assertNotEqual(keys1, keys2) |
| 225 self.assertGreater(keys1, keys2) |
| 226 self.assertGreaterEqual(keys1, keys2) |
| 227 self.assertLess(keys2, keys1) |
| 228 self.assertLessEqual(keys2, keys1) |
| 229 |
| 230 def test_values(self): |
| 231 self.d = self.openner() |
| 232 self.assertEqual(set(self.d.values()), set()) |
| 233 self.assertEqual(len(self.d.values()), 0) |
| 234 self.d['a'] = 'b' |
| 235 self.d['c'] = 'd' |
| 236 self.assertSameElements((b'b', b'd'), self.d.values()) |
| 237 self.assertEqual(len(self.d.values()), 2) |
| 238 |
| 239 def test_abc(self): |
| 240 self.d = self.openner() |
| 241 self.assertIsInstance(self.d, MutableMapping) |
| 242 self.assertIsInstance(self.d.keys(), KeysView) |
| 243 self.assertIsInstance(self.d.values(), ValuesView) |
| 244 self.assertIsInstance(self.d.items(), ItemsView) |
| 245 |
| 246 def test_update1(self): |
| 247 self.d = self.openner() |
| 248 self.assertEqual(self.d.keys(), set()) |
| 249 self.d['a'] = 'a' |
| 250 self.d.update({'b':'b', 'c':'c'}) |
| 251 self.assertRaises(TypeError, self.d.update, None) |
| 252 self.assertRaises(TypeError, self.d.update, {1:1}) |
| 253 self.assertRaises(TypeError, self.d.update, {'b':1}) |
| 254 self.assertEqual(self.d.items(), set(((b'a', b'a'), (b'b', b'b'), |
| 255 (b'c', b'c')))) |
| 256 |
| 257 def test_update2(self): |
| 258 self.d = self.openner() |
| 259 self.assertEqual(self.d.keys(), set()) |
| 260 self.d['a'] = 'a' |
| 261 class Other(): |
| 262 def __init__(self, dic): |
| 263 self._dict = dic |
| 264 def keys(self): |
| 265 return self._dict.keys() |
| 266 def __getitem__(self, key): |
| 267 return self._dict[key] |
| 268 |
| 269 self.d.update(Other({'b':'b', 'c':'c'})) |
| 270 self.assertEqual(self.d.items(), set(((b'a', b'a'), (b'b', b'b'), |
| 271 (b'c', b'c')))) |
| 272 |
| 273 def test_update3(self): |
| 274 self.d = self.openner() |
| 275 self.assertEqual(self.d.keys(), set()) |
| 276 self.d['a'] = 'a' |
| 277 self.d.update({b'b':b'b', b'c':b'c'}.items()) |
| 278 self.assertEqual(self.d.items(), set(((b'a', b'a'), (b'b', b'b'), |
| 279 (b'c', b'c')))) |
| 280 |
| 281 def test_error_conditions(self): |
| 282 # Try to open a non-existent database. |
| 283 self._delete_db() |
| 284 self.assertRaises(self._module.error, self._module.open, filename, 'r') |
| 285 # Try to access a closed database. |
| 286 self.d = self.openner() |
| 287 self.d.close() |
| 288 self.assertRaises(self._module.error, lambda: self.d['a']) |
| 289 # try pass an invalid open flag |
| 290 self.assertRaises(self._module.error, |
| 291 lambda: self._module.open(filename, 'rx').close()) |
LEFT | RIGHT |