1 # Check every path through every method of UserDict
4 from test
import test_support
, mapping_tests
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}
14 class UserDictTest(mapping_tests
.TestHashMappingProtocol
):
15 type2test
= UserDict
.IterableUserDict
19 u
= UserDict
.UserDict()
20 u0
= UserDict
.UserDict(d0
)
21 u1
= UserDict
.UserDict(d1
)
22 u2
= UserDict
.IterableUserDict(d2
)
24 uu
= UserDict
.UserDict(u
)
25 uu0
= UserDict
.UserDict(u0
)
26 uu1
= UserDict
.UserDict(u1
)
27 uu2
= UserDict
.UserDict(u2
)
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 self
.assertEqual(UserDict
.UserDict(dict=[('one',1), ('two',2)]), d2
)
35 self
.assertEqual(UserDict
.UserDict([('one',1), ('two',2)], two
=3, three
=5), d3
)
37 # alternate constructor
38 self
.assertEqual(UserDict
.UserDict
.fromkeys('one two'.split()), d4
)
39 self
.assertEqual(UserDict
.UserDict().fromkeys('one two'.split()), d4
)
40 self
.assertEqual(UserDict
.UserDict
.fromkeys('one two'.split(), 1), d5
)
41 self
.assertEqual(UserDict
.UserDict().fromkeys('one two'.split(), 1), d5
)
42 self
.assert_(u1
.fromkeys('one two'.split()) is not u1
)
43 self
.assert_(isinstance(u1
.fromkeys('one two'.split()), UserDict
.UserDict
))
44 self
.assert_(isinstance(u2
.fromkeys('one two'.split()), UserDict
.IterableUserDict
))
47 self
.assertEqual(str(u0
), str(d0
))
48 self
.assertEqual(repr(u1
), repr(d1
))
49 self
.assertEqual(`u2`
, `d2`
)
51 # Test __cmp__ and __len__
52 all
= [d0
, d1
, d2
, u
, u0
, u1
, u2
, uu
, uu0
, uu1
, uu2
]
55 self
.assertEqual(cmp(a
, b
), cmp(len(a
), len(b
)))
58 self
.assertEqual(u2
["one"], 1)
59 self
.assertRaises(KeyError, u1
.__getitem__
, "two")
62 u3
= UserDict
.UserDict(u2
)
68 self
.assertRaises(KeyError, u3
.__delitem__
, "three")
72 self
.assertEqual(u3
, {})
76 self
.assertEqual(u2a
, u2
)
77 u2b
= UserDict
.UserDict(x
=42, y
=23)
78 u2c
= u2b
.copy() # making a copy of a UserDict is special cased
79 self
.assertEqual(u2b
, u2c
)
81 class MyUserDict(UserDict
.UserDict
):
82 def display(self
): print self
86 self
.assertEqual(m2a
, m2
)
88 # SF bug #476616 -- copy() of UserDict subclass shared data
90 self
.assertNotEqual(m2a
, m2
)
92 # Test keys, items, values
93 self
.assertEqual(u2
.keys(), d2
.keys())
94 self
.assertEqual(u2
.items(), d2
.items())
95 self
.assertEqual(u2
.values(), d2
.values())
97 # Test has_key and "in".
99 self
.assert_(u2
.has_key(i
))
100 self
.assert_(i
in u2
)
101 self
.assertEqual(u1
.has_key(i
), d1
.has_key(i
))
102 self
.assertEqual(i
in u1
, i
in d1
)
103 self
.assertEqual(u0
.has_key(i
), d0
.has_key(i
))
104 self
.assertEqual(i
in u0
, i
in d0
)
107 t
= UserDict
.UserDict()
109 self
.assertEqual(t
, u2
)
112 return (("x", 42), ("y", 23))
113 t
= UserDict
.UserDict()
115 self
.assertEqual(t
, {"x": 42, "y": 23})
119 self
.assertEqual(u2
.get(i
), u2
[i
])
120 self
.assertEqual(u1
.get(i
), d1
.get(i
))
121 self
.assertEqual(u0
.get(i
), d0
.get(i
))
123 # Test "in" iteration.
130 self
.assertEqual(set(ikeys
), set(keys
))
133 t
= UserDict
.UserDict()
134 self
.assertEqual(t
.setdefault("x", 42), 42)
135 self
.assert_(t
.has_key("x"))
136 self
.assertEqual(t
.setdefault("x", 23), 42)
139 t
= UserDict
.UserDict(x
=42)
140 self
.assertEqual(t
.pop("x"), 42)
141 self
.assertRaises(KeyError, t
.pop
, "x")
142 self
.assertEqual(t
.pop("x", 1), 1)
144 self
.assertEqual(t
.pop("x", 1), 42)
147 t
= UserDict
.UserDict(x
=42)
148 self
.assertEqual(t
.popitem(), ("x", 42))
149 self
.assertRaises(KeyError, t
.popitem
)
151 ##########################
154 class SeqDict(UserDict
.DictMixin
):
155 """Dictionary lookalike implemented with lists.
157 Used to test and demonstrate DictMixin
159 def __init__(self
, other
=None, **kwargs
):
162 if other
is not None:
163 for (key
, value
) in other
:
165 for (key
, value
) in kwargs
.iteritems():
167 def __getitem__(self
, key
):
169 i
= self
.keylist
.index(key
)
172 return self
.valuelist
[i
]
173 def __setitem__(self
, key
, value
):
175 i
= self
.keylist
.index(key
)
176 self
.valuelist
[i
] = value
178 self
.keylist
.append(key
)
179 self
.valuelist
.append(value
)
180 def __delitem__(self
, key
):
182 i
= self
.keylist
.index(key
)
186 self
.valuelist
.pop(i
)
188 return list(self
.keylist
)
191 for key
, value
in self
.iteritems():
195 def fromkeys(cls
, keys
, value
=None):
201 class UserDictMixinTest(mapping_tests
.TestMappingProtocol
):
205 ## Setup test and verify working of the test class
217 # check getitem and setitem
218 self
.assertEqual(s
[10], 'ten')
219 # check keys() and delitem
220 self
.assertEqual(s
.keys(), [10, 30])
222 ## Now, test the DictMixin methods one by one
224 self
.assert_(s
.has_key(10))
225 self
.assert_(not s
.has_key(20))
228 self
.assert_(10 in s
)
229 self
.assert_(20 not in s
)
232 self
.assertEqual([k
for k
in s
], [10, 30])
235 self
.assertEqual(len(s
), 2)
238 self
.assertEqual(list(s
.iteritems()), [(10,'ten'), (30, 'thirty')])
241 self
.assertEqual(list(s
.iterkeys()), [10, 30])
244 self
.assertEqual(list(s
.itervalues()), ['ten', 'thirty'])
247 self
.assertEqual(s
.values(), ['ten', 'thirty'])
250 self
.assertEqual(s
.items(), [(10,'ten'), (30, 'thirty')])
253 self
.assertEqual(s
.get(10), 'ten')
254 self
.assertEqual(s
.get(15,'fifteen'), 'fifteen')
255 self
.assertEqual(s
.get(15), None)
258 self
.assertEqual(s
.setdefault(40, 'forty'), 'forty')
259 self
.assertEqual(s
.setdefault(10, 'null'), 'ten')
263 self
.assertEqual(s
.pop(10), 'ten')
264 self
.assert_(10 not in s
)
266 self
.assertEqual(s
.pop("x", 1), 1)
268 self
.assertEqual(s
.pop("x", 1), 42)
272 self
.assert_(k
not in s
)
277 self
.assertEqual(len(s
), 0)
280 self
.assertRaises(KeyError, s
.popitem
)
283 s
.update({10: 'ten', 20:'twenty'})
284 self
.assertEqual(s
[10], 'ten')
285 self
.assertEqual(s
[20], 'twenty')
288 self
.assertEqual(s
, {10: 'ten', 20:'twenty'})
292 self
.assertEqual(s
, t
)
295 test_support
.run_unittest(
300 if __name__
== "__main__":