e13829caec9dfdbe5db63293665bb36dcade294c
from test
import test_support
import sys
, UserDict
, cStringIO
class DictTest(unittest
.TestCase
):
def test_constructor(self
):
# calling built-in types without argument must return empty
self
.assertEqual(dict(), {})
self
.assert_(dict() is not {})
self
.assert_(bool({}) is False)
self
.assert_(bool({1: 2}) is True)
self
.assertEqual(d
.keys(), [])
self
.assert_(d
.has_key('a'))
self
.assert_(d
.has_key('b'))
self
.assertRaises(TypeError, d
.keys
, None)
self
.assertEqual(d
.values(), [])
self
.assertEqual(d
.values(), [2])
self
.assertRaises(TypeError, d
.values
, None)
self
.assertEqual(d
.items(), [])
self
.assertEqual(d
.items(), [(1, 2)])
self
.assertRaises(TypeError, d
.items
, None)
self
.assert_(not d
.has_key('a'))
self
.assertEqual(k
, ['a', 'b'])
self
.assertRaises(TypeError, d
.has_key
)
self
.assert_(not ('a' in d
))
self
.assert_('a' not in d
)
self
.assert_('c' not in d
)
self
.assertRaises(TypeError, d
.__contains
__)
self
.assertEqual(len(d
), 0)
self
.assertEqual(len(d
), 2)
self
.assertEqual(d
['a'], 1)
self
.assertEqual(d
['b'], 2)
self
.assertEqual(d
['c'], 3)
self
.assertEqual(d
['a'], 4)
self
.assertEqual(d
, {'a': 4, 'c': 3})
self
.assertRaises(TypeError, d
.__getitem
__)
self
.assertRaises(KeyError, d
.__getitem
__, 23)
class Exc(Exception): pass
self
.assertRaises(Exc
, d
.__getitem
__, x
)
self
.assertRaises(TypeError, d
.clear
, None)
d
.update({1:1, 2:2, 3:3})
self
.assertEqual(d
, {1:1, 2:2, 3:3})
self
.assertEqual(d
, {1:1, 2:2, 3:3})
self
.assertRaises((TypeError, AttributeError), d
.update
, None)
def __getitem__(self
, i
):
d
.update(SimpleUserDict())
self
.assertEqual(d
, {1:1, 2:2, 3:3})
class Exc(Exception): pass
self
.assertRaises(Exc
, d
.update
, FailingUserDict())
def __getitem__(self
, key
):
self
.assertRaises(Exc
, d
.update
, FailingUserDict())
def __getitem__(self
, key
):
self
.assertRaises(Exc
, d
.update
, FailingUserDict())
self
.assertRaises(Exc
, {}.update
, badseq())
self
.assertRaises(ValueError, {}.update
, [(1, 2, 3)])
self
.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
self
.assert_(not(d
.fromkeys('abc') is d
))
self
.assertEqual(d
.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
self
.assertEqual(d
.fromkeys((4,5),0), {4:0, 5:0})
self
.assertEqual(d
.fromkeys([]), {})
self
.assertEqual(d
.fromkeys(g()), {1:None})
self
.assertRaises(TypeError, {}.fromkeys
, 3)
class dictlike(dict): pass
self
.assertEqual(dictlike
.fromkeys('a'), {'a':None})
self
.assertEqual(dictlike().fromkeys('a'), {'a':None})
self
.assert_(type(dictlike
.fromkeys('a')) is dictlike
)
self
.assert_(type(dictlike().fromkeys('a')) is dictlike
)
return UserDict
.UserDict()
ud
= mydict
.fromkeys('ab')
self
.assertEqual(ud
, {'a':None, 'b':None})
self
.assert_(isinstance(ud
, UserDict
.UserDict
))
self
.assertRaises(TypeError, dict.fromkeys
)
class Exc(Exception): pass
self
.assertRaises(Exc
, baddict1
.fromkeys
, [1])
self
.assertRaises(Exc
, dict.fromkeys
, BadSeq())
def __setitem__(self
, key
, value
):
self
.assertRaises(Exc
, baddict2
.fromkeys
, [1])
self
.assertEqual(d
.copy(), {1:1, 2:2, 3:3})
self
.assertEqual({}.copy(), {})
self
.assertRaises(TypeError, d
.copy
, None)
self
.assert_(d
.get('c') is None)
self
.assertEqual(d
.get('c', 3), 3)
self
.assert_(d
.get('c') is None)
self
.assertEqual(d
.get('c', 3), 3)
self
.assertEqual(d
.get('a'), 1)
self
.assertEqual(d
.get('a', 3), 1)
self
.assertRaises(TypeError, d
.get
)
self
.assertRaises(TypeError, d
.get
, None, None, None)
def test_setdefault(self
):
self
.assert_(d
.setdefault('key0') is None)
self
.assert_(d
.setdefault('key0') is None)
d
.setdefault('key', []).append(3)
self
.assertEqual(d
['key'][0], 3)
d
.setdefault('key', []).append(4)
self
.assertEqual(len(d
['key']), 2)
self
.assertRaises(TypeError, d
.setdefault
)
class Exc(Exception): pass
self
.assertRaises(Exc
, d
.setdefault
, x
, [])
# -1: b has same structure as a
for log2size
in range(12):
ka
, va
= ta
= a
.popitem()
self
.assertEqual(va
, int(ka
))
kb
, vb
= tb
= b
.popitem()
self
.assertEqual(vb
, int(kb
))
self
.assert_(not(copymode
< 0 and ta
!= tb
))
self
.assertRaises(KeyError, d
.popitem
)
# Tests for pop with specified key
self
.assertRaises(KeyError, d
.pop
, 'ghi')
self
.assertEqual(d
.pop(k
), v
)
self
.assertEqual(len(d
), 0)
self
.assertRaises(KeyError, d
.pop
, k
)
# verify longs/ints get same value when key > 32 bits (for 64-bit archs)
h
= {x
: 'anything', y
: 'something else'}
self
.assertEqual(h
[x
], h
[y
])
self
.assertEqual(d
.pop(k
, v
), v
)
self
.assertEqual(d
.pop(k
, 1), v
)
self
.assertRaises(TypeError, d
.pop
)
class Exc(Exception): pass
self
.assertRaises(Exc
, d
.pop
, x
)
def test_mutatingiteration(self
):
self
.fail("changing dict size during iteration doesn't raise Error")
self
.assertEqual(repr(d
), '{}')
self
.assertEqual(repr(d
), '{1: 2}')
self
.assertEqual(repr(d
), '{1: {...}}')
class Exc(Exception): pass
self
.assertRaises(Exc
, repr, d
)
self
.assert_(not ({} < {}))
self
.assert_(not ({1: 2} < {1L: 2L}))
class Exc(Exception): pass
self
.fail("< didn't raise Exc")
class GeneralMappingTests(mapping_tests
.BasicTestMappingProtocol
):
class SubclassMappingTests(mapping_tests
.BasicTestMappingProtocol
):
test_support
.run_unittest(
if __name__
== "__main__":