# Check every path through every method of UserDict
from test
import test_support
, mapping_tests
d2
= {"one": 1, "two": 2}
d3
= {"one": 1, "two": 3, "three": 5}
d4
= {"one": None, "two": None}
d5
= {"one": 1, "two": 1}
class UserDictTest(mapping_tests
.TestHashMappingProtocol
):
type2test
= UserDict
.IterableUserDict
u0
= UserDict
.UserDict(d0
)
u1
= UserDict
.UserDict(d1
)
u2
= UserDict
.IterableUserDict(d2
)
uu
= UserDict
.UserDict(u
)
uu0
= UserDict
.UserDict(u0
)
uu1
= UserDict
.UserDict(u1
)
uu2
= UserDict
.UserDict(u2
)
# keyword arg constructor
self
.assertEqual(UserDict
.UserDict(one
=1, two
=2), d2
)
# item sequence constructor
self
.assertEqual(UserDict
.UserDict([('one',1), ('two',2)]), d2
)
self
.assertEqual(UserDict
.UserDict(dict=[('one',1), ('two',2)]), d2
)
self
.assertEqual(UserDict
.UserDict([('one',1), ('two',2)], two
=3, three
=5), d3
)
self
.assertEqual(UserDict
.UserDict
.fromkeys('one two'.split()), d4
)
self
.assertEqual(UserDict
.UserDict().fromkeys('one two'.split()), d4
)
self
.assertEqual(UserDict
.UserDict
.fromkeys('one two'.split(), 1), d5
)
self
.assertEqual(UserDict
.UserDict().fromkeys('one two'.split(), 1), d5
)
self
.assert_(u1
.fromkeys('one two'.split()) is not u1
)
self
.assert_(isinstance(u1
.fromkeys('one two'.split()), UserDict
.UserDict
))
self
.assert_(isinstance(u2
.fromkeys('one two'.split()), UserDict
.IterableUserDict
))
self
.assertEqual(str(u0
), str(d0
))
self
.assertEqual(repr(u1
), repr(d1
))
self
.assertEqual(`u2`
, `d2`
)
# Test __cmp__ and __len__
all
= [d0
, d1
, d2
, u
, u0
, u1
, u2
, uu
, uu0
, uu1
, uu2
]
self
.assertEqual(cmp(a
, b
), cmp(len(a
), len(b
)))
self
.assertEqual(u2
["one"], 1)
self
.assertRaises(KeyError, u1
.__getitem__
, "two")
u3
= UserDict
.UserDict(u2
)
self
.assertRaises(KeyError, u3
.__delitem__
, "three")
self
.assertEqual(u2a
, u2
)
u2b
= UserDict
.UserDict(x
=42, y
=23)
u2c
= u2b
.copy() # making a copy of a UserDict is special cased
self
.assertEqual(u2b
, u2c
)
class MyUserDict(UserDict
.UserDict
):
def display(self
): print self
self
.assertEqual(m2a
, m2
)
# SF bug #476616 -- copy() of UserDict subclass shared data
self
.assertNotEqual(m2a
, m2
)
# Test keys, items, values
self
.assertEqual(u2
.keys(), d2
.keys())
self
.assertEqual(u2
.items(), d2
.items())
self
.assertEqual(u2
.values(), d2
.values())
self
.assert_(u2
.has_key(i
))
self
.assertEqual(u1
.has_key(i
), d1
.has_key(i
))
self
.assertEqual(i
in u1
, i
in d1
)
self
.assertEqual(u0
.has_key(i
), d0
.has_key(i
))
self
.assertEqual(i
in u0
, i
in d0
)
return (("x", 42), ("y", 23))
self
.assertEqual(t
, {"x": 42, "y": 23})
self
.assertEqual(u2
.get(i
), u2
[i
])
self
.assertEqual(u1
.get(i
), d1
.get(i
))
self
.assertEqual(u0
.get(i
), d0
.get(i
))
self
.assertEqual(set(ikeys
), set(keys
))
self
.assertEqual(t
.setdefault("x", 42), 42)
self
.assert_(t
.has_key("x"))
self
.assertEqual(t
.setdefault("x", 23), 42)
t
= UserDict
.UserDict(x
=42)
self
.assertEqual(t
.pop("x"), 42)
self
.assertRaises(KeyError, t
.pop
, "x")
self
.assertEqual(t
.pop("x", 1), 1)
self
.assertEqual(t
.pop("x", 1), 42)
t
= UserDict
.UserDict(x
=42)
self
.assertEqual(t
.popitem(), ("x", 42))
self
.assertRaises(KeyError, t
.popitem
)
##########################
class SeqDict(UserDict
.DictMixin
):
"""Dictionary lookalike implemented with lists.
Used to test and demonstrate DictMixin
def __init__(self
, other
=None, **kwargs
):
for (key
, value
) in other
:
for (key
, value
) in kwargs
.iteritems():
def __getitem__(self
, key
):
i
= self
.keylist
.index(key
)
def __setitem__(self
, key
, value
):
i
= self
.keylist
.index(key
)
self
.valuelist
[i
] = value
self
.valuelist
.append(value
)
def __delitem__(self
, key
):
i
= self
.keylist
.index(key
)
return list(self
.keylist
)
for key
, value
in self
.iteritems():
def fromkeys(cls
, keys
, value
=None):
fromkeys
= classmethod(fromkeys
)
class UserDictMixinTest(mapping_tests
.TestMappingProtocol
):
## Setup test and verify working of the test class
# check getitem and setitem
self
.assertEqual(s
[10], 'ten')
# check keys() and delitem
self
.assertEqual(s
.keys(), [10, 30])
## Now, test the DictMixin methods one by one
self
.assert_(s
.has_key(10))
self
.assert_(not s
.has_key(20))
self
.assert_(20 not in s
)
self
.assertEqual([k
for k
in s
], [10, 30])
self
.assertEqual(len(s
), 2)
self
.assertEqual(list(s
.iteritems()), [(10,'ten'), (30, 'thirty')])
self
.assertEqual(list(s
.iterkeys()), [10, 30])
self
.assertEqual(list(s
.itervalues()), ['ten', 'thirty'])
self
.assertEqual(s
.values(), ['ten', 'thirty'])
self
.assertEqual(s
.items(), [(10,'ten'), (30, 'thirty')])
self
.assertEqual(s
.get(10), 'ten')
self
.assertEqual(s
.get(15,'fifteen'), 'fifteen')
self
.assertEqual(s
.get(15), None)
self
.assertEqual(s
.setdefault(40, 'forty'), 'forty')
self
.assertEqual(s
.setdefault(10, 'null'), 'ten')
self
.assertEqual(s
.pop(10), 'ten')
self
.assert_(10 not in s
)
self
.assertEqual(s
.pop("x", 1), 1)
self
.assertEqual(s
.pop("x", 1), 42)
self
.assertEqual(len(s
), 0)
self
.assertRaises(KeyError, s
.popitem
)
s
.update({10: 'ten', 20:'twenty'})
self
.assertEqual(s
[10], 'ten')
self
.assertEqual(s
[20], 'twenty')
self
.assertEqual(s
, {10: 'ten', 20:'twenty'})
test_support
.run_unittest(
if __name__
== "__main__":