Lib/test/test_userdict.py

   1 # Check every path through every method of UserDict
   2
   3 from test.test_support import verify, verbose
   4 from UserDict import UserDict, IterableUserDict
   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 # Test constructors
  14
  15 u = UserDict()
  16 u0 = UserDict(d0)
  17 u1 = UserDict(d1)
  18 u2 = IterableUserDict(d2)
  19
  20 uu = UserDict(u)
  21 uu0 = UserDict(u0)
  22 uu1 = UserDict(u1)
  23 uu2 = UserDict(u2)
  24
  25 verify(UserDict(one=1, two=2) == d2)            # keyword arg constructor
  26 verify(UserDict([('one',1), ('two',2)]) == d2)  # item sequence constructor
  27 verify(UserDict(dict=[('one',1), ('two',2)]) == d2)
  28 verify(UserDict([('one',1), ('two',2)], two=3, three=5) == d3) # both together
  29
  30 verify(UserDict.fromkeys('one two'.split()) == d4)  # alternate constructor
  31 verify(UserDict().fromkeys('one two'.split()) == d4)
  32 verify(UserDict.fromkeys('one two'.split(), 1) == d5)
  33 verify(UserDict().fromkeys('one two'.split(), 1) == d5)
  34 verify(u1.fromkeys('one two'.split()) is not u1)
  35 verify(isinstance(u1.fromkeys('one two'.split()), UserDict))
  36 verify(isinstance(u2.fromkeys('one two'.split()), IterableUserDict))
  37
  38 # Test __repr__
  39
  40 verify(str(u0) == str(d0))
  41 verify(repr(u1) == repr(d1))
  42 verify(`u2` == `d2`)
  43
  44 # Test __cmp__ and __len__
  45
  46 all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
  47 for a in all:
  48     for b in all:
  49         verify(cmp(a, b) == cmp(len(a), len(b)))
  50
  51 # Test __getitem__
  52
  53 verify(u2["one"] == 1)
  54 try:
  55     u1["two"]
  56 except KeyError:
  57     pass
  58 else:
  59     verify(0, "u1['two'] shouldn't exist")
  60
  61 # Test __setitem__
  62
  63 u3 = UserDict(u2)
  64 u3["two"] = 2
  65 u3["three"] = 3
  66
  67 # Test __delitem__
  68
  69 del u3["three"]
  70 try:
  71     del u3["three"]
  72 except KeyError:
  73     pass
  74 else:
  75     verify(0, "u3['three'] shouldn't exist")
  76
  77 # Test clear
  78
  79 u3.clear()
  80 verify(u3 == {})
  81
  82 # Test copy()
  83
  84 u2a = u2.copy()
  85 verify(u2a == u2)
  86
  87 class MyUserDict(UserDict):
  88     def display(self): print self
  89
  90 m2 = MyUserDict(u2)
  91 m2a = m2.copy()
  92 verify(m2a == m2)
  93
  94 # SF bug #476616 -- copy() of UserDict subclass shared data
  95 m2['foo'] = 'bar'
  96 verify(m2a != m2)
  97
  98 # Test keys, items, values
  99
 100 verify(u2.keys() == d2.keys())
 101 verify(u2.items() == d2.items())
 102 verify(u2.values() == d2.values())
 103
 104 # Test has_key and "in".
 105
 106 for i in u2.keys():
 107     verify(u2.has_key(i) == 1)
 108     verify((i in u2) == 1)
 109     verify(u1.has_key(i) == d1.has_key(i))
 110     verify((i in u1) == (i in d1))
 111     verify(u0.has_key(i) == d0.has_key(i))
 112     verify((i in u0) == (i in d0))
 113
 114 # Test update
 115
 116 t = UserDict()
 117 t.update(u2)
 118 verify(t == u2)
 119
 120 # Test get
 121
 122 for i in u2.keys():
 123     verify(u2.get(i) == u2[i])
 124     verify(u1.get(i) == d1.get(i))
 125     verify(u0.get(i) == d0.get(i))
 126
 127 # Test "in" iteration.
 128 for i in xrange(20):
 129     u2[i] = str(i)
 130 ikeys = []
 131 for k in u2:
 132     ikeys.append(k)
 133 ikeys.sort()
 134 keys = u2.keys()
 135 keys.sort()
 136 verify(ikeys == keys)
 137
 138 ##########################
 139 # Test Dict Mixin
 140
 141 from UserDict import DictMixin
 142
 143 class SeqDict(DictMixin):
 144     """Dictionary lookalike implemented with lists.
 145
 146     Used to test and demonstrate DictMixin
 147     """
 148     def __init__(self):
 149         self.keylist = []
 150         self.valuelist = []
 151     def __getitem__(self, key):
 152         try:
 153             i = self.keylist.index(key)
 154         except ValueError:
 155             raise KeyError
 156         return self.valuelist[i]
 157     def __setitem__(self, key, value):
 158         try:
 159             i = self.keylist.index(key)
 160             self.valuelist[i] = value
 161         except ValueError:
 162             self.keylist.append(key)
 163             self.valuelist.append(value)
 164     def __delitem__(self, key):
 165         try:
 166             i = self.keylist.index(key)
 167         except ValueError:
 168             raise KeyError
 169         self.keylist.pop(i)
 170         self.valuelist.pop(i)
 171     def keys(self):
 172         return list(self.keylist)
 173
 174 ## Setup test and verify working of the test class
 175 s = SeqDict()                   # check init
 176 s[10] = 'ten'                   # exercise setitem
 177 s[20] = 'twenty'
 178 s[30] = 'thirty'
 179 del s[20]                       # exercise delitem
 180 verify(s[10] == 'ten')          # check getitem and setitem
 181 verify(s.keys() == [10, 30])    # check keys() and delitem
 182
 183 ## Now, test the DictMixin methods one by one
 184 verify(s.has_key(10))                                       # has_key
 185 verify(not s.has_key(20))
 186
 187 verify(10 in s)                                             # __contains__
 188 verify(20 not in s)
 189
 190 verify([k for k in s] == [10, 30])                          # __iter__
 191
 192 verify(len(s) == 2)                                         # __len__
 193
 194 verify(list(s.iteritems()) == [(10,'ten'), (30, 'thirty')]) # iteritems
 195
 196 verify(list(s.iterkeys()) == [10, 30])                      # iterkeys
 197
 198 verify(list(s.itervalues()) == ['ten', 'thirty'])           # itervalues
 199
 200 verify(s.values() == ['ten', 'thirty'])                     # values
 201
 202 verify(s.items() == [(10,'ten'), (30, 'thirty')])           # items
 203
 204 verify(s.get(10) == 'ten')                                  # get
 205 verify(s.get(15,'fifteen') == 'fifteen')
 206 verify(s.get(15) == None)
 207
 208 verify(s.setdefault(40, 'forty') == 'forty')                # setdefault
 209 verify(s.setdefault(10, 'null') == 'ten')
 210 del s[40]
 211
 212 verify(s.pop(10) == 'ten')                                  # pop
 213 verify(10 not in s)
 214 s[10] = 'ten'
 215
 216 k, v = s.popitem()                                          # popitem
 217 verify(k not in s)
 218 s[k] = v
 219
 220 s.clear()                                                   # clear
 221 verify(len(s) == 0)
 222
 223 try:                                                        # empty popitem
 224     s.popitem()
 225 except KeyError:
 226     pass
 227 else:
 228     verify(0, "popitem from an empty list should raise KeyError")
 229
 230 s.update({10: 'ten', 20:'twenty'})                          # update
 231 verify(s[10]=='ten' and s[20]=='twenty')
 232
 233 verify(s == {10: 'ten', 20:'twenty'})                       # cmp
 234 t = SeqDict()
 235 t[20] = 'twenty'
 236 t[10] = 'ten'
 237 verify(s == t)