Lib/test/test_userdict.py

   1 # Check every path through every method of UserDict
   2
   3 import test.test_support, unittest
   4
   5 import UserDict
   6
   7 class TestMappingProtocol(unittest.TestCase):
   8     # This base class can be used to check that an object conforms to the
   9     # mapping protocol
  10
  11     # Functions that can be useful to override to adapt to dictionary
  12     # semantics
  13     _tested_class = dict   # which class is being tested
  14
  15     def _reference(self):
  16         """Return a dictionary of values which are invariant by storage
  17         in the object under test."""
  18         return {1:2, "key1":"value1", "key2":(1,2,3)}
  19     def _empty_mapping(self):
  20         """Return an empty mapping object"""
  21         return self._tested_class()
  22     def _full_mapping(self, data):
  23         """Return a mapping object with the value contained in data
  24         dictionary"""
  25         x = self._empty_mapping()
  26         for key, value in data.items():
  27             x[key] = value
  28         return x
  29
  30     def __init__(self, *args, **kw):
  31         unittest.TestCase.__init__(self, *args, **kw)
  32         self.reference = self._reference().copy()
  33         key, value = self.reference.popitem()
  34         self.other = {key:value}
  35
  36     def test_read(self):
  37         # Test for read only operations on mapping
  38         p = self._empty_mapping()
  39         p1 = dict(p) #workaround for singleton objects
  40         d = self._full_mapping(self.reference)
  41         if d is p:
  42             p = p1
  43         #Indexing
  44         for key, value in self.reference.items():
  45             self.assertEqual(d[key], value)
  46         knownkey = self.other.keys()[0]
  47         self.failUnlessRaises(KeyError, lambda:d[knownkey])
  48         #len
  49         self.assertEqual(len(p), 0)
  50         self.assertEqual(len(d), len(self.reference))
  51         #has_key
  52         for k in self.reference:
  53             self.assert_(d.has_key(k))
  54             self.assert_(k in d)
  55         for k in self.other:
  56             self.failIf(d.has_key(k))
  57             self.failIf(k in d)
  58         #cmp
  59         self.assertEqual(cmp(p,p), 0)
  60         self.assertEqual(cmp(d,d), 0)
  61         self.assertEqual(cmp(p,d), -1)
  62         self.assertEqual(cmp(d,p), 1)
  63         #__non__zero__
  64         if p: self.fail("Empty mapping must compare to False")
  65         if not d: self.fail("Full mapping must compare to True")
  66         # keys(), items(), iterkeys() ...
  67         def check_iterandlist(iter, lst, ref):
  68             self.assert_(hasattr(iter, 'next'))
  69             self.assert_(hasattr(iter, '__iter__'))
  70             x = list(iter)
  71             x.sort()
  72             lst.sort()
  73             ref.sort()
  74             self.assert_(x==lst==ref)
  75         check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys())
  76         check_iterandlist(iter(d), d.keys(), self.reference.keys())
  77         check_iterandlist(d.itervalues(), d.values(), self.reference.values())
  78         check_iterandlist(d.iteritems(), d.items(), self.reference.items())
  79         #get
  80         key, value = d.iteritems().next()
  81         knownkey, knownvalue = self.other.iteritems().next()
  82         self.assertEqual(d.get(key, knownvalue), value)
  83         self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
  84         self.failIf(knownkey in d)
  85
  86     def test_write(self):
  87         # Test for write operations on mapping
  88         p = self._empty_mapping()
  89         #Indexing
  90         for key, value in self.reference.items():
  91             p[key] = value
  92             self.assertEqual(p[key], value)
  93         for key in self.reference.keys():
  94             del p[key]
  95             self.failUnlessRaises(KeyError, lambda:p[key])
  96         p = self._empty_mapping()
  97         #update
  98         p.update(self.reference)
  99         self.assertEqual(dict(p), self.reference)
 100         d = self._full_mapping(self.reference)
 101         #setdefaullt
 102         key, value = d.iteritems().next()
 103         knownkey, knownvalue = self.other.iteritems().next()
 104         self.assertEqual(d.setdefault(key, knownvalue), value)
 105         self.assertEqual(d[key], value)
 106         self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue)
 107         self.assertEqual(d[knownkey], knownvalue)
 108         #pop
 109         self.assertEqual(d.pop(knownkey), knownvalue)
 110         self.failIf(knownkey in d)
 111         self.assertRaises(KeyError, d.pop, knownkey)
 112         default = 909
 113         d[knownkey] = knownvalue
 114         self.assertEqual(d.pop(knownkey, default), knownvalue)
 115         self.failIf(knownkey in d)
 116         self.assertEqual(d.pop(knownkey, default), default)
 117         #popitem
 118         key, value = d.popitem()
 119         self.failIf(key in d)
 120         self.assertEqual(value, self.reference[key])
 121         p=self._empty_mapping()
 122         self.assertRaises(KeyError, p.popitem)
 123
 124 d0 = {}
 125 d1 = {"one": 1}
 126 d2 = {"one": 1, "two": 2}
 127 d3 = {"one": 1, "two": 3, "three": 5}
 128 d4 = {"one": None, "two": None}
 129 d5 = {"one": 1, "two": 1}
 130
 131 class UserDictTest(TestMappingProtocol):
 132     _tested_class = UserDict.IterableUserDict
 133
 134     def test_all(self):
 135         # Test constructors
 136         u = UserDict.UserDict()
 137         u0 = UserDict.UserDict(d0)
 138         u1 = UserDict.UserDict(d1)
 139         u2 = UserDict.IterableUserDict(d2)
 140
 141         uu = UserDict.UserDict(u)
 142         uu0 = UserDict.UserDict(u0)
 143         uu1 = UserDict.UserDict(u1)
 144         uu2 = UserDict.UserDict(u2)
 145
 146         # keyword arg constructor
 147         self.assertEqual(UserDict.UserDict(one=1, two=2), d2)
 148         # item sequence constructor
 149         self.assertEqual(UserDict.UserDict([('one',1), ('two',2)]), d2)
 150         self.assertEqual(UserDict.UserDict(dict=[('one',1), ('two',2)]), d2)
 151         # both together
 152         self.assertEqual(UserDict.UserDict([('one',1), ('two',2)], two=3, three=5), d3)
 153
 154         # alternate constructor
 155         self.assertEqual(UserDict.UserDict.fromkeys('one two'.split()), d4)
 156         self.assertEqual(UserDict.UserDict().fromkeys('one two'.split()), d4)
 157         self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5)
 158         self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5)
 159         self.assert_(u1.fromkeys('one two'.split()) is not u1)
 160         self.assert_(isinstance(u1.fromkeys('one two'.split()), UserDict.UserDict))
 161         self.assert_(isinstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict))
 162
 163         # Test __repr__
 164         self.assertEqual(str(u0), str(d0))
 165         self.assertEqual(repr(u1), repr(d1))
 166         self.assertEqual(`u2`, `d2`)
 167
 168         # Test __cmp__ and __len__
 169         all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
 170         for a in all:
 171             for b in all:
 172                 self.assertEqual(cmp(a, b), cmp(len(a), len(b)))
 173
 174         # Test __getitem__
 175         self.assertEqual(u2["one"], 1)
 176         self.assertRaises(KeyError, u1.__getitem__, "two")
 177
 178         # Test __setitem__
 179         u3 = UserDict.UserDict(u2)
 180         u3["two"] = 2
 181         u3["three"] = 3
 182
 183         # Test __delitem__
 184         del u3["three"]
 185         self.assertRaises(KeyError, u3.__delitem__, "three")
 186
 187         # Test clear
 188         u3.clear()
 189         self.assertEqual(u3, {})
 190
 191         # Test copy()
 192         u2a = u2.copy()
 193         self.assertEqual(u2a, u2)
 194         u2b = UserDict.UserDict(x=42, y=23)
 195         u2c = u2b.copy() # making a copy of a UserDict is special cased
 196         self.assertEqual(u2b, u2c)
 197
 198         class MyUserDict(UserDict.UserDict):
 199             def display(self): print self
 200
 201         m2 = MyUserDict(u2)
 202         m2a = m2.copy()
 203         self.assertEqual(m2a, m2)
 204
 205         # SF bug #476616 -- copy() of UserDict subclass shared data
 206         m2['foo'] = 'bar'
 207         self.assertNotEqual(m2a, m2)
 208
 209         # Test keys, items, values
 210         self.assertEqual(u2.keys(), d2.keys())
 211         self.assertEqual(u2.items(), d2.items())
 212         self.assertEqual(u2.values(), d2.values())
 213
 214         # Test has_key and "in".
 215         for i in u2.keys():
 216             self.assert_(u2.has_key(i))
 217             self.assert_(i in u2)
 218             self.assertEqual(u1.has_key(i), d1.has_key(i))
 219             self.assertEqual(i in u1, i in d1)
 220             self.assertEqual(u0.has_key(i), d0.has_key(i))
 221             self.assertEqual(i in u0, i in d0)
 222
 223         # Test update
 224         t = UserDict.UserDict()
 225         t.update(u2)
 226         self.assertEqual(t, u2)
 227         class Items:
 228             def items(self):
 229                 return (("x", 42), ("y", 23))
 230         t = UserDict.UserDict()
 231         t.update(Items())
 232         self.assertEqual(t, {"x": 42, "y": 23})
 233
 234         # Test get
 235         for i in u2.keys():
 236             self.assertEqual(u2.get(i), u2[i])
 237             self.assertEqual(u1.get(i), d1.get(i))
 238             self.assertEqual(u0.get(i), d0.get(i))
 239
 240         # Test "in" iteration.
 241         for i in xrange(20):
 242             u2[i] = str(i)
 243         ikeys = []
 244         for k in u2:
 245             ikeys.append(k)
 246         ikeys.sort()
 247         keys = u2.keys()
 248         keys.sort()
 249         self.assertEqual(ikeys, keys)
 250
 251         # Test setdefault
 252         t = UserDict.UserDict()
 253         self.assertEqual(t.setdefault("x", 42), 42)
 254         self.assert_(t.has_key("x"))
 255         self.assertEqual(t.setdefault("x", 23), 42)
 256
 257         # Test pop
 258         t = UserDict.UserDict(x=42)
 259         self.assertEqual(t.pop("x"), 42)
 260         self.assertRaises(KeyError, t.pop, "x")
 261         self.assertEqual(t.pop("x", 1), 1)
 262         t["x"] = 42
 263         self.assertEqual(t.pop("x", 1), 42)
 264
 265         # Test popitem
 266         t = UserDict.UserDict(x=42)
 267         self.assertEqual(t.popitem(), ("x", 42))
 268         self.assertRaises(KeyError, t.popitem)
 269
 270 ##########################
 271 # Test Dict Mixin
 272
 273 class SeqDict(UserDict.DictMixin):
 274     """Dictionary lookalike implemented with lists.
 275
 276     Used to test and demonstrate DictMixin
 277     """
 278     def __init__(self):
 279         self.keylist = []
 280         self.valuelist = []
 281     def __getitem__(self, key):
 282         try:
 283             i = self.keylist.index(key)
 284         except ValueError:
 285             raise KeyError
 286         return self.valuelist[i]
 287     def __setitem__(self, key, value):
 288         try:
 289             i = self.keylist.index(key)
 290             self.valuelist[i] = value
 291         except ValueError:
 292             self.keylist.append(key)
 293             self.valuelist.append(value)
 294     def __delitem__(self, key):
 295         try:
 296             i = self.keylist.index(key)
 297         except ValueError:
 298             raise KeyError
 299         self.keylist.pop(i)
 300         self.valuelist.pop(i)
 301     def keys(self):
 302         return list(self.keylist)
 303
 304 class UserDictMixinTest(TestMappingProtocol):
 305     _tested_class = SeqDict
 306
 307     def test_all(self):
 308         ## Setup test and verify working of the test class
 309
 310         # check init
 311         s = SeqDict()
 312
 313         # exercise setitem
 314         s[10] = 'ten'
 315         s[20] = 'twenty'
 316         s[30] = 'thirty'
 317
 318         # exercise delitem
 319         del s[20]
 320         # check getitem and setitem
 321         self.assertEqual(s[10], 'ten')
 322         # check keys() and delitem
 323         self.assertEqual(s.keys(), [10, 30])
 324
 325         ## Now, test the DictMixin methods one by one
 326         # has_key
 327         self.assert_(s.has_key(10))
 328         self.assert_(not s.has_key(20))
 329
 330         # __contains__
 331         self.assert_(10 in s)
 332         self.assert_(20 not in s)
 333
 334         # __iter__
 335         self.assertEqual([k for k in s], [10, 30])
 336
 337         # __len__
 338         self.assertEqual(len(s), 2)
 339
 340         # iteritems
 341         self.assertEqual(list(s.iteritems()), [(10,'ten'), (30, 'thirty')])
 342
 343         # iterkeys
 344         self.assertEqual(list(s.iterkeys()), [10, 30])
 345
 346         # itervalues
 347         self.assertEqual(list(s.itervalues()), ['ten', 'thirty'])
 348
 349         # values
 350         self.assertEqual(s.values(), ['ten', 'thirty'])
 351
 352         # items
 353         self.assertEqual(s.items(), [(10,'ten'), (30, 'thirty')])
 354
 355         # get
 356         self.assertEqual(s.get(10), 'ten')
 357         self.assertEqual(s.get(15,'fifteen'), 'fifteen')
 358         self.assertEqual(s.get(15), None)
 359
 360         # setdefault
 361         self.assertEqual(s.setdefault(40, 'forty'), 'forty')
 362         self.assertEqual(s.setdefault(10, 'null'), 'ten')
 363         del s[40]
 364
 365         # pop
 366         self.assertEqual(s.pop(10), 'ten')
 367         self.assert_(10 not in s)
 368         s[10] = 'ten'
 369         self.assertEqual(s.pop("x", 1), 1)
 370         s["x"] = 42
 371         self.assertEqual(s.pop("x", 1), 42)
 372
 373         # popitem
 374         k, v = s.popitem()
 375         self.assert_(k not in s)
 376         s[k] = v
 377
 378         # clear
 379         s.clear()
 380         self.assertEqual(len(s), 0)
 381
 382         # empty popitem
 383         self.assertRaises(KeyError, s.popitem)
 384
 385         # update
 386         s.update({10: 'ten', 20:'twenty'})
 387         self.assertEqual(s[10], 'ten')
 388         self.assertEqual(s[20], 'twenty')
 389
 390         # cmp
 391         self.assertEqual(s, {10: 'ten', 20:'twenty'})
 392         t = SeqDict()
 393         t[20] = 'twenty'
 394         t[10] = 'ten'
 395         self.assertEqual(s, t)
 396
 397 def test_main():
 398     suite = unittest.TestSuite()
 399     suite.addTest(unittest.makeSuite(TestMappingProtocol))
 400     suite.addTest(unittest.makeSuite(UserDictTest))
 401     suite.addTest(unittest.makeSuite(UserDictMixinTest))
 402     test.test_support.run_suite(suite)
 403
 404 if __name__ == "__main__":
 405     test_main()