1 # Check every path through every method of UserDict 2 3 from test import test_support, mapping_tests 4 import UserDict 5 import warnings 6 7 d0 = {} 8 d1 = {"one": 1} 9 d2 = {"one": 1, "two": 2} 10 d3 = {"one": 1, "two": 3, "three": 5} 11 d4 = {"one": None, "two": None} 12 d5 = {"one": 1, "two": 1} 13 14 class UserDictTest(mapping_tests.TestHashMappingProtocol): 15 type2test = UserDict.IterableUserDict 16 17 def test_all(self): 18 # Test constructors 19 u = UserDict.UserDict() 20 u0 = UserDict.UserDict(d0) 21 u1 = UserDict.UserDict(d1) 22 u2 = UserDict.IterableUserDict(d2) 23 24 uu = UserDict.UserDict(u) 25 uu0 = UserDict.UserDict(u0) 26 uu1 = UserDict.UserDict(u1) 27 uu2 = UserDict.UserDict(u2) 28 29 # keyword arg constructor 30 self.assertEqual(UserDict.UserDict(one=1, two=2), d2) 31 # item sequence constructor 32 self.assertEqual(UserDict.UserDict([('one',1), ('two',2)]), d2) 33 with test_support.check_warnings((".*'dict'.*", 34 PendingDeprecationWarning)): 35 self.assertEqual(UserDict.UserDict(dict=[('one',1), ('two',2)]), d2) 36 # both together 37 self.assertEqual(UserDict.UserDict([('one',1), ('two',2)], two=3, three=5), d3) 38 39 # alternate constructor 40 self.assertEqual(UserDict.UserDict.fromkeys('one two'.split()), d4) 41 self.assertEqual(UserDict.UserDict().fromkeys('one two'.split()), d4) 42 self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5) 43 self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5) 44 self.assertTrue(u1.fromkeys('one two'.split()) is not u1) 45 self.assertIsInstance(u1.fromkeys('one two'.split()), UserDict.UserDict) 46 self.assertIsInstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict) 47 48 # Test __repr__ 49 self.assertEqual(str(u0), str(d0)) 50 self.assertEqual(repr(u1), repr(d1)) 51 self.assertEqual(repr(u2), repr(d2)) 52 53 # Test __cmp__ and __len__ 54 all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2] 55 for a in all: 56 for b in all: 57 self.assertEqual(cmp(a, b), cmp(len(a), len(b))) 58 59 # Test __getitem__ 60 self.assertEqual(u2["one"], 1) 61 self.assertRaises(KeyError, u1.__getitem__, "two") 62 63 # Test __setitem__ 64 u3 = UserDict.UserDict(u2) 65 u3["two"] = 2 66 u3["three"] = 3 67 68 # Test __delitem__ 69 del u3["three"] 70 self.assertRaises(KeyError, u3.__delitem__, "three") 71 72 # Test clear 73 u3.clear() 74 self.assertEqual(u3, {}) 75 76 # Test copy() 77 u2a = u2.copy() 78 self.assertEqual(u2a, u2) 79 u2b = UserDict.UserDict(x=42, y=23) 80 u2c = u2b.copy() # making a copy of a UserDict is special cased 81 self.assertEqual(u2b, u2c) 82 83 class MyUserDict(UserDict.UserDict): 84 def display(self): print self 85 86 m2 = MyUserDict(u2) 87 m2a = m2.copy() 88 self.assertEqual(m2a, m2) 89 90 # SF bug #476616 -- copy() of UserDict subclass shared data 91 m2['foo'] = 'bar' 92 self.assertNotEqual(m2a, m2) 93 94 # Test keys, items, values 95 self.assertEqual(u2.keys(), d2.keys()) 96 self.assertEqual(u2.items(), d2.items()) 97 self.assertEqual(u2.values(), d2.values()) 98 99 # Test has_key and "in". 100 for i in u2.keys(): 101 self.assertIn(i, u2) 102 self.assertEqual(i in u1, i in d1) 103 self.assertEqual(i in u0, i in d0) 104 with test_support.check_py3k_warnings(): 105 self.assertTrue(u2.has_key(i)) 106 self.assertEqual(u1.has_key(i), d1.has_key(i)) 107 self.assertEqual(u0.has_key(i), d0.has_key(i)) 108 109 # Test update 110 t = UserDict.UserDict() 111 t.update(u2) 112 self.assertEqual(t, u2) 113 class Items: 114 def items(self): 115 return (("x", 42), ("y", 23)) 116 t = UserDict.UserDict() 117 t.update(Items()) 118 self.assertEqual(t, {"x": 42, "y": 23}) 119 120 # Test get 121 for i in u2.keys(): 122 self.assertEqual(u2.get(i), u2[i]) 123 self.assertEqual(u1.get(i), d1.get(i)) 124 self.assertEqual(u0.get(i), d0.get(i)) 125 126 # Test "in" iteration. 127 for i in xrange(20): 128 u2[i] = str(i) 129 ikeys = [] 130 for k in u2: 131 ikeys.append(k) 132 keys = u2.keys() 133 self.assertEqual(set(ikeys), set(keys)) 134 135 # Test setdefault 136 t = UserDict.UserDict() 137 self.assertEqual(t.setdefault("x", 42), 42) 138 self.assertTrue(t.has_key("x")) 139 self.assertEqual(t.setdefault("x", 23), 42) 140 141 # Test pop 142 t = UserDict.UserDict(x=42) 143 self.assertEqual(t.pop("x"), 42) 144 self.assertRaises(KeyError, t.pop, "x") 145 self.assertEqual(t.pop("x", 1), 1) 146 t["x"] = 42 147 self.assertEqual(t.pop("x", 1), 42) 148 149 # Test popitem 150 t = UserDict.UserDict(x=42) 151 self.assertEqual(t.popitem(), ("x", 42)) 152 self.assertRaises(KeyError, t.popitem) 153 154 def test_init(self): 155 for kw in 'self', 'other', 'iterable': 156 self.assertEqual(list(UserDict.UserDict(**{kw: 42}).items()), 157 [(kw, 42)]) 158 self.assertEqual(list(UserDict.UserDict({}, dict=42).items()), 159 [('dict', 42)]) 160 self.assertEqual(list(UserDict.UserDict({}, dict=None).items()), 161 [('dict', None)]) 162 with test_support.check_warnings((".*'dict'.*", 163 PendingDeprecationWarning)): 164 self.assertEqual(list(UserDict.UserDict(dict={'a': 42}).items()), 165 [('a', 42)]) 166 self.assertRaises(TypeError, UserDict.UserDict, 42) 167 self.assertRaises(TypeError, UserDict.UserDict, (), ()) 168 self.assertRaises(TypeError, UserDict.UserDict.__init__) 169 170 def test_update(self): 171 for kw in 'self', 'other', 'iterable': 172 d = UserDict.UserDict() 173 d.update(**{kw: 42}) 174 self.assertEqual(list(d.items()), [(kw, 42)]) 175 d = UserDict.UserDict() 176 with test_support.check_warnings((".*'dict'.*", 177 PendingDeprecationWarning)): 178 d.update(dict={'a': 42}) 179 self.assertEqual(list(d.items()), [('a', 42)]) 180 self.assertRaises(TypeError, UserDict.UserDict().update, 42) 181 self.assertRaises(TypeError, UserDict.UserDict().update, {}, {}) 182 self.assertRaises(TypeError, UserDict.UserDict.update) 183 184 def test_missing(self): 185 # Make sure UserDict doesn't have a __missing__ method 186 self.assertEqual(hasattr(UserDict, "__missing__"), False) 187 # Test several cases: 188 # (D) subclass defines __missing__ method returning a value 189 # (E) subclass defines __missing__ method raising RuntimeError 190 # (F) subclass sets __missing__ instance variable (no effect) 191 # (G) subclass doesn't define __missing__ at all 192 class D(UserDict.UserDict): 193 def __missing__(self, key): 194 return 42 195 d = D({1: 2, 3: 4}) 196 self.assertEqual(d[1], 2) 197 self.assertEqual(d[3], 4) 198 self.assertNotIn(2, d) 199 self.assertNotIn(2, d.keys()) 200 self.assertEqual(d[2], 42) 201 class E(UserDict.UserDict): 202 def __missing__(self, key): 203 raise RuntimeError(key) 204 e = E() 205 try: 206 e[42] 207 except RuntimeError, err: 208 self.assertEqual(err.args, (42,)) 209 else: 210 self.fail("e[42] didn't raise RuntimeError") 211 class F(UserDict.UserDict): 212 def __init__(self): 213 # An instance variable __missing__ should have no effect 214 self.__missing__ = lambda key: None 215 UserDict.UserDict.__init__(self) 216 f = F() 217 try: 218 f[42] 219 except KeyError, err: 220 self.assertEqual(err.args, (42,)) 221 else: 222 self.fail("f[42] didn't raise KeyError") 223 class G(UserDict.UserDict): 224 pass 225 g = G() 226 try: 227 g[42] 228 except KeyError, err: 229 self.assertEqual(err.args, (42,)) 230 else: 231 self.fail("g[42] didn't raise KeyError") 232 233 ########################## 234 # Test Dict Mixin 235 236 class SeqDict(UserDict.DictMixin): 237 """Dictionary lookalike implemented with lists. 238 239 Used to test and demonstrate DictMixin 240 """ 241 def __init__(self, other=None, **kwargs): 242 self.keylist = [] 243 self.valuelist = [] 244 if other is not None: 245 for (key, value) in other: 246 self[key] = value 247 for (key, value) in kwargs.iteritems(): 248 self[key] = value 249 def __getitem__(self, key): 250 try: 251 i = self.keylist.index(key) 252 except ValueError: 253 raise KeyError 254 return self.valuelist[i] 255 def __setitem__(self, key, value): 256 try: 257 i = self.keylist.index(key) 258 self.valuelist[i] = value 259 except ValueError: 260 self.keylist.append(key) 261 self.valuelist.append(value) 262 def __delitem__(self, key): 263 try: 264 i = self.keylist.index(key) 265 except ValueError: 266 raise KeyError 267 self.keylist.pop(i) 268 self.valuelist.pop(i) 269 def keys(self): 270 return list(self.keylist) 271 def copy(self): 272 d = self.__class__() 273 for key, value in self.iteritems(): 274 d[key] = value 275 return d 276 @classmethod 277 def fromkeys(cls, keys, value=None): 278 d = cls() 279 for key in keys: 280 d[key] = value 281 return d 282 283 class UserDictMixinTest(mapping_tests.TestMappingProtocol): 284 type2test = SeqDict 285 286 def test_all(self): 287 ## Setup test and verify working of the test class 288 289 # check init 290 s = SeqDict() 291 292 # exercise setitem 293 s[10] = 'ten' 294 s[20] = 'twenty' 295 s[30] = 'thirty' 296 297 # exercise delitem 298 del s[20] 299 # check getitem and setitem 300 self.assertEqual(s[10], 'ten') 301 # check keys() and delitem 302 self.assertEqual(s.keys(), [10, 30]) 303 304 ## Now, test the DictMixin methods one by one 305 # has_key 306 self.assertTrue(s.has_key(10)) 307 self.assertTrue(not s.has_key(20)) 308 309 # __contains__ 310 self.assertIn(10, s) 311 self.assertNotIn(20, s) 312 313 # __iter__ 314 self.assertEqual([k for k in s], [10, 30]) 315 316 # __len__ 317 self.assertEqual(len(s), 2) 318 319 # iteritems 320 self.assertEqual(list(s.iteritems()), [(10,'ten'), (30, 'thirty')]) 321 322 # iterkeys 323 self.assertEqual(list(s.iterkeys()), [10, 30]) 324 325 # itervalues 326 self.assertEqual(list(s.itervalues()), ['ten', 'thirty']) 327 328 # values 329 self.assertEqual(s.values(), ['ten', 'thirty']) 330 331 # items 332 self.assertEqual(s.items(), [(10,'ten'), (30, 'thirty')]) 333 334 # get 335 self.assertEqual(s.get(10), 'ten') 336 self.assertEqual(s.get(15,'fifteen'), 'fifteen') 337 self.assertEqual(s.get(15), None) 338 339 # setdefault 340 self.assertEqual(s.setdefault(40, 'forty'), 'forty') 341 self.assertEqual(s.setdefault(10, 'null'), 'ten') 342 del s[40] 343 344 # pop 345 self.assertEqual(s.pop(10), 'ten') 346 self.assertNotIn(10, s) 347 s[10] = 'ten' 348 self.assertEqual(s.pop("x", 1), 1) 349 s["x"] = 42 350 self.assertEqual(s.pop("x", 1), 42) 351 352 # popitem 353 k, v = s.popitem() 354 self.assertNotIn(k, s) 355 s[k] = v 356 357 # clear 358 s.clear() 359 self.assertEqual(len(s), 0) 360 361 # empty popitem 362 self.assertRaises(KeyError, s.popitem) 363 364 # update 365 s.update({10: 'ten', 20:'twenty'}) 366 self.assertEqual(s[10], 'ten') 367 self.assertEqual(s[20], 'twenty') 368 369 # cmp 370 self.assertEqual(s, {10: 'ten', 20:'twenty'}) 371 t = SeqDict() 372 t[20] = 'twenty' 373 t[10] = 'ten' 374 self.assertEqual(s, t) 375 376 def test_main(): 377 test_support.run_unittest( 378 UserDictTest, 379 UserDictMixinTest 380 ) 381 382 if __name__ == "__main__": 383 test_main() 384
