Lib/test/test_userdict.py

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