1 import unittest

     2 from test import test_support

     3 

     4 import sys, UserDict, cStringIO

     5 

     6 

     7 class DictTest(unittest.TestCase):

     8     def test_constructor(self):

     9         # calling built-in types without argument must return empty

    10         self.assertEqual(dict(), {})

    11         self.assert_(dict() is not {})

    12 

    13     def test_bool(self):

    14         self.assert_(not {})

    15         self.assert_({1: 2})

    16         self.assert_(bool({}) is False)

    17         self.assert_(bool({1: 2}) is True)

    18 

    19     def test_keys(self):

    20         d = {}

    21         self.assertEqual(d.keys(), [])

    22         d = {'a': 1, 'b': 2}

    23         k = d.keys()

    24         self.assert_(d.has_key('a'))

    25         self.assert_(d.has_key('b'))

    26 

    27         self.assertRaises(TypeError, d.keys, None)

    28 

    29     def test_values(self):

    30         d = {}

    31         self.assertEqual(d.values(), [])

    32         d = {1:2}

    33         self.assertEqual(d.values(), [2])

    34 

    35         self.assertRaises(TypeError, d.values, None)

    36 

    37     def test_items(self):

    38         d = {}

    39         self.assertEqual(d.items(), [])

    40 

    41         d = {1:2}

    42         self.assertEqual(d.items(), [(1, 2)])

    43 

    44         self.assertRaises(TypeError, d.items, None)

    45 

    46     def test_has_key(self):

    47         d = {}

    48         self.assert_(not d.has_key('a'))

    49         d = {'a': 1, 'b': 2}

    50         k = d.keys()

    51         k.sort()

    52         self.assertEqual(k, ['a', 'b'])

    53 

    54         self.assertRaises(TypeError, d.has_key)

    55 

    56     def test_contains(self):

    57         d = {}

    58         self.assert_(not ('a' in d))

    59         self.assert_('a' not in d)

    60         d = {'a': 1, 'b': 2}

    61         self.assert_('a' in d)

    62         self.assert_('b' in d)

    63         self.assert_('c' not in d)

    64 

    65         self.assertRaises(TypeError, d.__contains__)

    66 

    67     def test_len(self):

    68         d = {}

    69         self.assertEqual(len(d), 0)

    70         d = {'a': 1, 'b': 2}

    71         self.assertEqual(len(d), 2)

    72 

    73     def test_getitem(self):

    74         d = {'a': 1, 'b': 2}

    75         self.assertEqual(d['a'], 1)

    76         self.assertEqual(d['b'], 2)

    77         d['c'] = 3

    78         d['a'] = 4

    79         self.assertEqual(d['c'], 3)

    80         self.assertEqual(d['a'], 4)

    81         del d['b']

    82         self.assertEqual(d, {'a': 4, 'c': 3})

    83 

    84         self.assertRaises(TypeError, d.__getitem__)

    85 

    86         class BadEq(object):

    87             def __eq__(self, other):

    88                 raise Exc()

    89 

    90         d = {}

    91         d[BadEq()] = 42

    92         self.assertRaises(KeyError, d.__getitem__, 23)

    93 

    94         class Exc(Exception): pass

    95 

    96         class BadHash(object):

    97             fail = False

    98             def __hash__(self):

    99                 if self.fail:

   100                     raise Exc()

   101                 else:

   102                     return 42

   103 

   104         x = BadHash()

   105         d[x] = 42

   106         x.fail = True

   107         self.assertRaises(Exc, d.__getitem__, x)

   108 

   109     def test_clear(self):

   110         d = {1:1, 2:2, 3:3}

   111         d.clear()

   112         self.assertEqual(d, {})

   113 

   114         self.assertRaises(TypeError, d.clear, None)

   115 

   116     def test_update(self):

   117         d = {}

   118         d.update({1:100})

   119         d.update({2:20})

   120         d.update({1:1, 2:2, 3:3})

   121         self.assertEqual(d, {1:1, 2:2, 3:3})

   122 

   123         d.update()

   124         self.assertEqual(d, {1:1, 2:2, 3:3})

   125 

   126         self.assertRaises((TypeError, AttributeError), d.update, None)

   127 

   128         class SimpleUserDict:

   129             def __init__(self):

   130                 self.d = {1:1, 2:2, 3:3}

   131             def keys(self):

   132                 return self.d.keys()

   133             def __getitem__(self, i):

   134                 return self.d[i]

   135         d.clear()

   136         d.update(SimpleUserDict())

   137         self.assertEqual(d, {1:1, 2:2, 3:3})

   138 

   139         class Exc(Exception): pass

   140 

   141         d.clear()

   142         class FailingUserDict:

   143             def keys(self):

   144                 raise Exc

   145         self.assertRaises(Exc, d.update, FailingUserDict())

   146 

   147         class FailingUserDict:

   148             def keys(self):

   149                 class BogonIter:

   150                     def __init__(self):

   151                         self.i = 1

   152                     def __iter__(self):

   153                         return self

   154                     def next(self):

   155                         if self.i:

   156                             self.i = 0

   157                             return 'a'

   158                         raise Exc

   159                 return BogonIter()

   160             def __getitem__(self, key):

   161                 return key

   162         self.assertRaises(Exc, d.update, FailingUserDict())

   163 

   164         class FailingUserDict:

   165             def keys(self):

   166                 class BogonIter:

   167                     def __init__(self):

   168                         self.i = ord('a')

   169                     def __iter__(self):

   170                         return self

   171                     def next(self):

   172                         if self.i <= ord('z'):

   173                             rtn = chr(self.i)

   174                             self.i += 1

   175                             return rtn

   176                         raise StopIteration

   177                 return BogonIter()

   178             def __getitem__(self, key):

   179                 raise Exc

   180         self.assertRaises(Exc, d.update, FailingUserDict())

   181 

   182         class badseq(object):

   183             def __iter__(self):

   184                 return self

   185             def next(self):

   186                 raise Exc()

   187 

   188         self.assertRaises(Exc, {}.update, badseq())

   189 

   190         self.assertRaises(ValueError, {}.update, [(1, 2, 3)])

   191 

   192     def test_fromkeys(self):

   193         self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None})

   194         d = {}

   195         self.assert_(not(d.fromkeys('abc') is d))

   196         self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})

   197         self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})

   198         self.assertEqual(d.fromkeys([]), {})

   199         def g():

   200             yield 1

   201         self.assertEqual(d.fromkeys(g()), {1:None})

   202         self.assertRaises(TypeError, {}.fromkeys, 3)

   203         class dictlike(dict): pass

   204         self.assertEqual(dictlike.fromkeys('a'), {'a':None})

   205         self.assertEqual(dictlike().fromkeys('a'), {'a':None})

   206         self.assert_(type(dictlike.fromkeys('a')) is dictlike)

   207         self.assert_(type(dictlike().fromkeys('a')) is dictlike)

   208         class mydict(dict):

   209             def __new__(cls):

   210                 return UserDict.UserDict()

   211         ud = mydict.fromkeys('ab')

   212         self.assertEqual(ud, {'a':None, 'b':None})

   213         self.assert_(isinstance(ud, UserDict.UserDict))

   214         self.assertRaises(TypeError, dict.fromkeys)

   215 

   216         class Exc(Exception): pass

   217 

   218         class baddict1(dict):

   219             def __init__(self):

   220                 raise Exc()

   221 

   222         self.assertRaises(Exc, baddict1.fromkeys, [1])

   223 

   224         class BadSeq(object):

   225             def __iter__(self):

   226                 return self

   227             def next(self):

   228                 raise Exc()

   229 

   230         self.assertRaises(Exc, dict.fromkeys, BadSeq())

   231 

   232         class baddict2(dict):

   233             def __setitem__(self, key, value):

   234                 raise Exc()

   235 

   236         self.assertRaises(Exc, baddict2.fromkeys, [1])

   237 

   238     def test_copy(self):

   239         d = {1:1, 2:2, 3:3}

   240         self.assertEqual(d.copy(), {1:1, 2:2, 3:3})

   241         self.assertEqual({}.copy(), {})

   242         self.assertRaises(TypeError, d.copy, None)

   243 

   244     def test_get(self):

   245         d = {}

   246         self.assert_(d.get('c') is None)

   247         self.assertEqual(d.get('c', 3), 3)

   248         d = {'a' : 1, 'b' : 2}

   249         self.assert_(d.get('c') is None)

   250         self.assertEqual(d.get('c', 3), 3)

   251         self.assertEqual(d.get('a'), 1)

   252         self.assertEqual(d.get('a', 3), 1)

   253         self.assertRaises(TypeError, d.get)

   254         self.assertRaises(TypeError, d.get, None, None, None)

   255 

   256     def test_setdefault(self):

   257         # dict.setdefault()

   258         d = {}

   259         self.assert_(d.setdefault('key0') is None)

   260         d.setdefault('key0', [])

   261         self.assert_(d.setdefault('key0') is None)

   262         d.setdefault('key', []).append(3)

   263         self.assertEqual(d['key'][0], 3)

   264         d.setdefault('key', []).append(4)

   265         self.assertEqual(len(d['key']), 2)

   266         self.assertRaises(TypeError, d.setdefault)

   267 

   268         class Exc(Exception): pass

   269 

   270         class BadHash(object):

   271             fail = False

   272             def __hash__(self):

   273                 if self.fail:

   274                     raise Exc()

   275                 else:

   276                     return 42

   277 

   278         x = BadHash()

   279         d[x] = 42

   280         x.fail = True

   281         self.assertRaises(Exc, d.setdefault, x, [])

   282 

   283     def test_popitem(self):

   284         # dict.popitem()

   285         for copymode in -1, +1:

   286             # -1: b has same structure as a

   287             # +1: b is a.copy()

   288             for log2size in range(12):

   289                 size = 2**log2size

   290                 a = {}

   291                 b = {}

   292                 for i in range(size):

   293                     a[repr(i)] = i

   294                     if copymode < 0:

   295                         b[repr(i)] = i

   296                 if copymode > 0:

   297                     b = a.copy()

   298                 for i in range(size):

   299                     ka, va = ta = a.popitem()

   300                     self.assertEqual(va, int(ka))

   301                     kb, vb = tb = b.popitem()

   302                     self.assertEqual(vb, int(kb))

   303                     self.assert_(not(copymode < 0 and ta != tb))

   304                 self.assert_(not a)

   305                 self.assert_(not b)

   306 

   307         d = {}

   308         self.assertRaises(KeyError, d.popitem)

   309 

   310     def test_pop(self):

   311         # Tests for pop with specified key

   312         d = {}

   313         k, v = 'abc', 'def'

   314         d[k] = v

   315         self.assertRaises(KeyError, d.pop, 'ghi')

   316 

   317         self.assertEqual(d.pop(k), v)

   318         self.assertEqual(len(d), 0)

   319 

   320         self.assertRaises(KeyError, d.pop, k)

   321 

   322         # verify longs/ints get same value when key > 32 bits (for 64-bit archs)

   323         # see SF bug #689659

   324         x = 4503599627370496L

   325         y = 4503599627370496

   326         h = {x: 'anything', y: 'something else'}

   327         self.assertEqual(h[x], h[y])

   328 

   329         self.assertEqual(d.pop(k, v), v)

   330         d[k] = v

   331         self.assertEqual(d.pop(k, 1), v)

   332 

   333         self.assertRaises(TypeError, d.pop)

   334 

   335         class Exc(Exception): pass

   336 

   337         class BadHash(object):

   338             fail = False

   339             def __hash__(self):

   340                 if self.fail:

   341                     raise Exc()

   342                 else:

   343                     return 42

   344 

   345         x = BadHash()

   346         d[x] = 42

   347         x.fail = True

   348         self.assertRaises(Exc, d.pop, x)

   349 

   350     def test_mutatingiteration(self):

   351         d = {}

   352         d[1] = 1

   353         try:

   354             for i in d:

   355                 d[i+1] = 1

   356         except RuntimeError:

   357             pass

   358         else:

   359             self.fail("changing dict size during iteration doesn't raise Error")

   360 

   361     def test_repr(self):

   362         d = {}

   363         self.assertEqual(repr(d), '{}')

   364         d[1] = 2

   365         self.assertEqual(repr(d), '{1: 2}')

   366         d = {}

   367         d[1] = d

   368         self.assertEqual(repr(d), '{1: {...}}')

   369 

   370         class Exc(Exception): pass

   371 

   372         class BadRepr(object):

   373             def __repr__(self):

   374                 raise Exc()

   375 

   376         d = {1: BadRepr()}

   377         self.assertRaises(Exc, repr, d)

   378 

   379     def test_le(self):

   380         self.assert_(not ({} < {}))

   381         self.assert_(not ({1: 2} < {1L: 2L}))

   382 

   383         class Exc(Exception): pass

   384 

   385         class BadCmp(object):

   386             def __eq__(self, other):

   387                 raise Exc()

   388 

   389         d1 = {BadCmp(): 1}

   390         d2 = {1: 1}

   391         try:

   392             d1 < d2

   393         except Exc:

   394             pass

   395         else:

   396             self.fail("< didn't raise Exc")

   397 

   398     def test_missing(self):

   399         # Make sure dict doesn't have a __missing__ method

   400         self.assertEqual(hasattr(dict, "__missing__"), False)

   401         self.assertEqual(hasattr({}, "__missing__"), False)

   402         # Test several cases:

   403         # (D) subclass defines __missing__ method returning a value

   404         # (E) subclass defines __missing__ method raising RuntimeError

   405         # (F) subclass sets __missing__ instance variable (no effect)

   406         # (G) subclass doesn't define __missing__ at a all

   407         class D(dict):

   408             def __missing__(self, key):

   409                 return 42

   410         d = D({1: 2, 3: 4})

   411         self.assertEqual(d[1], 2)

   412         self.assertEqual(d[3], 4)

   413         self.assert_(2 not in d)

   414         self.assert_(2 not in d.keys())

   415         self.assertEqual(d[2], 42)

   416         class E(dict):

   417             def __missing__(self, key):

   418                 raise RuntimeError(key)

   419         e = E()

   420         try:

   421             e[42]

   422         except RuntimeError, err:

   423             self.assertEqual(err.args, (42,))

   424         else:

   425             self.fail("e[42] didn't raise RuntimeError")

   426         class F(dict):

   427             def __init__(self):

   428                 # An instance variable __missing__ should have no effect

   429                 self.__missing__ = lambda key: None

   430         f = F()

   431         try:

   432             f[42]

   433         except KeyError, err:

   434             self.assertEqual(err.args, (42,))

   435         else:

   436             self.fail("f[42] didn't raise KeyError")

   437         class G(dict):

   438             pass

   439         g = G()

   440         try:

   441             g[42]

   442         except KeyError, err:

   443             self.assertEqual(err.args, (42,))

   444         else:

   445             self.fail("g[42] didn't raise KeyError")

   446 

   447     def test_tuple_keyerror(self):

   448         # SF #1576657

   449         d = {}

   450         try:

   451             d[(1,)]

   452         except KeyError, e:

   453             self.assertEqual(e.args, ((1,),))

   454         else:

   455             self.fail("missing KeyError")

   456 

   457 

   458 from test import mapping_tests

   459 

   460 class GeneralMappingTests(mapping_tests.BasicTestMappingProtocol):

   461     type2test = dict

   462 

   463 class Dict(dict):

   464     pass

   465 

   466 class SubclassMappingTests(mapping_tests.BasicTestMappingProtocol):

   467     type2test = Dict

   468 

   469 def test_main():

   470     test_support.run_unittest(

   471         DictTest,

   472         GeneralMappingTests,

   473         SubclassMappingTests,

   474     )

   475 

   476 if __name__ == "__main__":

   477     test_main()