Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/test/test_dict.py

    r2 r391  
    1010        # calling built-in types without argument must return empty
    1111        self.assertEqual(dict(), {})
    12         self.assert_(dict() is not {})
     12        self.assertIsNot(dict(), {})
    1313
    1414    def test_literal_constructor(self):
    15         # check literal constructor for different sized dicts (to exercise the BUILD_MAP oparg
     15        # check literal constructor for different sized dicts
     16        # (to exercise the BUILD_MAP oparg).
    1617        for n in (0, 1, 6, 256, 400):
    17             items = [(''.join([random.choice(string.letters)
    18                                for j in range(8)]),
    19                       i)
     18            items = [(''.join(random.sample(string.letters, 8)), i)
    2019                     for i in range(n)]
    2120            random.shuffle(items)
    22             dictliteral = '{' + ', '.join('%r: %d' % item for item in items) + '}'
     21            formatted_items = ('{!r}: {:d}'.format(k, v) for k, v in items)
     22            dictliteral = '{' + ', '.join(formatted_items) + '}'
    2323            self.assertEqual(eval(dictliteral), dict(items))
    2424
    2525    def test_bool(self):
    26         self.assert_(not {})
    27         self.assert_({1: 2})
    28         self.assert_(bool({}) is False)
    29         self.assert_(bool({1: 2}) is True)
     26        self.assertIs(not {}, True)
     27        self.assertTrue({1: 2})
     28        self.assertIs(bool({}), False)
     29        self.assertIs(bool({1: 2}), True)
    3030
    3131    def test_keys(self):
    … …  
    3434        d = {'a': 1, 'b': 2}
    3535        k = d.keys()
    36         self.assert_(d.has_key('a'))
    37         self.assert_(d.has_key('b'))
    38 
     36        self.assertEqual(set(k), {'a', 'b'})
     37        self.assertIn('a', k)
     38        self.assertIn('b', k)
     39        self.assertTrue(d.has_key('a'))
     40        self.assertTrue(d.has_key('b'))
    3941        self.assertRaises(TypeError, d.keys, None)
    4042
    … …  
    5860    def test_has_key(self):
    5961        d = {}
    60         self.assert_(not d.has_key('a'))
     62        self.assertFalse(d.has_key('a'))
    6163        d = {'a': 1, 'b': 2}
    6264        k = d.keys()
    … …  
    6870    def test_contains(self):
    6971        d = {}
    70         self.assert_(not ('a' in d))
    71         self.assert_('a' not in d)
     72        self.assertNotIn('a', d)
     73        self.assertFalse('a' in d)
     74        self.assertTrue('a' not in d)
    7275        d = {'a': 1, 'b': 2}
    73         self.assert_('a' in d)
    74         self.assert_('b' in d)
    75         self.assert_('c' not in d)
     76        self.assertIn('a', d)
     77        self.assertIn('b', d)
     78        self.assertNotIn('c', d)
    7679
    7780        self.assertRaises(TypeError, d.__contains__)
    … …  
    207210        self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
    208211        d = {}
    209         self.assert_(not(d.fromkeys('abc') is d))
     212        self.assertIsNot(d.fromkeys('abc'), d)
    210213        self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
    211214        self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})
    … …  
    218221        self.assertEqual(dictlike.fromkeys('a'), {'a':None})
    219222        self.assertEqual(dictlike().fromkeys('a'), {'a':None})
    220         self.assert_(type(dictlike.fromkeys('a')) is dictlike)
    221         self.assert_(type(dictlike().fromkeys('a')) is dictlike)
     223        self.assertIsInstance(dictlike.fromkeys('a'), dictlike)
     224        self.assertIsInstance(dictlike().fromkeys('a'), dictlike)
    222225        class mydict(dict):
    223226            def __new__(cls):
    … …  
    225228        ud = mydict.fromkeys('ab')
    226229        self.assertEqual(ud, {'a':None, 'b':None})
    227         self.assert_(isinstance(ud, UserDict.UserDict))
     230        self.assertIsInstance(ud, UserDict.UserDict)
    228231        self.assertRaises(TypeError, dict.fromkeys)
    229232
    … …  
    254257        self.assertEqual(dict.fromkeys(d, 0), dict(zip(range(6), [0]*6)))
    255258
     259        class baddict3(dict):
     260            def __new__(cls):
     261                return d
     262        d = {i : i for i in range(10)}
     263        res = d.copy()
     264        res.update(a=None, b=None, c=None)
     265        self.assertEqual(baddict3.fromkeys({"a", "b", "c"}), res)
     266
    256267    def test_copy(self):
    257268        d = {1:1, 2:2, 3:3}
    … …  
    262273    def test_get(self):
    263274        d = {}
    264         self.assert_(d.get('c') is None)
     275        self.assertIs(d.get('c'), None)
    265276        self.assertEqual(d.get('c', 3), 3)
    266         d = {'a' : 1, 'b' : 2}
    267         self.assert_(d.get('c') is None)
     277        d = {'a': 1, 'b': 2}
     278        self.assertIs(d.get('c'), None)
    268279        self.assertEqual(d.get('c', 3), 3)
    269280        self.assertEqual(d.get('a'), 1)
    … …  
    275286        # dict.setdefault()
    276287        d = {}
    277         self.assert_(d.setdefault('key0') is None)
     288        self.assertIs(d.setdefault('key0'), None)
    278289        d.setdefault('key0', [])
    279         self.assert_(d.setdefault('key0') is None)
     290        self.assertIs(d.setdefault('key0'), None)
    280291        d.setdefault('key', []).append(3)
    281292        self.assertEqual(d['key'][0], 3)
    … …  
    298309        x.fail = True
    299310        self.assertRaises(Exc, d.setdefault, x, [])
     311
     312    def test_setdefault_atomic(self):
     313        # Issue #13521: setdefault() calls __hash__ and __eq__ only once.
     314        class Hashed(object):
     315            def __init__(self):
     316                self.hash_count = 0
     317                self.eq_count = 0
     318            def __hash__(self):
     319                self.hash_count += 1
     320                return 42
     321            def __eq__(self, other):
     322                self.eq_count += 1
     323                return id(self) == id(other)
     324        hashed1 = Hashed()
     325        y = {hashed1: 5}
     326        hashed2 = Hashed()
     327        y.setdefault(hashed2, [])
     328        self.assertEqual(hashed1.hash_count, 1)
     329        self.assertEqual(hashed2.hash_count, 1)
     330        self.assertEqual(hashed1.eq_count + hashed2.eq_count, 1)
    300331
    301332    def test_popitem(self):
    … …  
    319350                    kb, vb = tb = b.popitem()
    320351                    self.assertEqual(vb, int(kb))
    321                     self.assert_(not(copymode < 0 and ta != tb))
    322                 self.assert_(not a)
    323                 self.assert_(not b)
     352                    self.assertFalse(copymode < 0 and ta != tb)
     353                self.assertFalse(a)
     354                self.assertFalse(b)
    324355
    325356        d = {}
    … …  
    338369        self.assertRaises(KeyError, d.pop, k)
    339370
    340         # verify longs/ints get same value when key > 32 bits (for 64-bit archs)
    341         # see SF bug #689659
     371        # verify longs/ints get same value when key > 32 bits
     372        # (for 64-bit archs).  See SF bug #689659.
    342373        x = 4503599627370496L
    343374        y = 4503599627370496
    … …  
    367398
    368399    def test_mutatingiteration(self):
     400        # changing dict size during iteration
    369401        d = {}
    370402        d[1] = 1
    371         try:
     403        with self.assertRaises(RuntimeError):
    372404            for i in d:
    373405                d[i+1] = 1
    374         except RuntimeError:
    375             pass
    376         else:
    377             self.fail("changing dict size during iteration doesn't raise Error")
    378406
    379407    def test_repr(self):
    … …  
    396424
    397425    def test_le(self):
    398         self.assert_(not ({} < {}))
    399         self.assert_(not ({1: 2} < {1L: 2L}))
     426        self.assertFalse({} < {})
     427        self.assertFalse({1: 2} < {1L: 2L})
    400428
    401429        class Exc(Exception): pass
    … …  
    409437        d1 = {BadCmp(): 1}
    410438        d2 = {1: 1}
    411         try:
     439
     440        with self.assertRaises(Exc):
    412441            d1 < d2
    413         except Exc:
    414             pass
    415         else:
    416             self.fail("< didn't raise Exc")
    417442
    418443    def test_missing(self):
    419444        # Make sure dict doesn't have a __missing__ method
    420         self.assertEqual(hasattr(dict, "__missing__"), False)
    421         self.assertEqual(hasattr({}, "__missing__"), False)
     445        self.assertFalse(hasattr(dict, "__missing__"))
     446        self.assertFalse(hasattr({}, "__missing__"))
    422447        # Test several cases:
    423448        # (D) subclass defines __missing__ method returning a value
    … …  
    431456        self.assertEqual(d[1], 2)
    432457        self.assertEqual(d[3], 4)
    433         self.assert_(2 not in d)
    434         self.assert_(2 not in d.keys())
     458        self.assertNotIn(2, d)
     459        self.assertNotIn(2, d.keys())
    435460        self.assertEqual(d[2], 42)
     461
    436462        class E(dict):
    437463            def __missing__(self, key):
    438464                raise RuntimeError(key)
    439465        e = E()
    440         try:
     466        with self.assertRaises(RuntimeError) as c:
    441467            e[42]
    442         except RuntimeError, err:
    443             self.assertEqual(err.args, (42,))
    444         else:
    445             self.fail("e[42] didn't raise RuntimeError")
     468        self.assertEqual(c.exception.args, (42,))
     469
    446470        class F(dict):
    447471            def __init__(self):
    … …  
    449473                self.__missing__ = lambda key: None
    450474        f = F()
    451         try:
     475        with self.assertRaises(KeyError) as c:
    452476            f[42]
    453         except KeyError, err:
    454             self.assertEqual(err.args, (42,))
    455         else:
    456             self.fail("f[42] didn't raise KeyError")
     477        self.assertEqual(c.exception.args, (42,))
     478
    457479        class G(dict):
    458480            pass
    459481        g = G()
    460         try:
     482        with self.assertRaises(KeyError) as c:
    461483            g[42]
    462         except KeyError, err:
    463             self.assertEqual(err.args, (42,))
    464         else:
    465             self.fail("g[42] didn't raise KeyError")
     484        self.assertEqual(c.exception.args, (42,))
    466485
    467486    def test_tuple_keyerror(self):
    468487        # SF #1576657
    469488        d = {}
    470         try:
     489        with self.assertRaises(KeyError) as c:
    471490            d[(1,)]
    472         except KeyError, e:
    473             self.assertEqual(e.args, ((1,),))
    474         else:
    475             self.fail("missing KeyError")
     491        self.assertEqual(c.exception.args, ((1,),))
    476492
    477493    def test_bad_key(self):
    … …  
    501517                     'd.pop(x2)',
    502518                     'd.update({x2: 2})']:
    503             try:
     519            with self.assertRaises(CustomException):
    504520                exec stmt in locals()
    505             except CustomException:
    506                 pass
    507             else:
    508                 self.fail("Statement didn't raise exception")
    509521
    510522    def test_resize1(self):
    … …  
    549561        # Bug #3537: if an empty but presized dict with a size larger
    550562        # than 7 was in the freelist, it triggered an assertion failure
    551         try:
    552             d = {'a': 1/0, 'b': None, 'c': None, 'd': None, 'e': None,
     563        with self.assertRaises(ZeroDivisionError):
     564            d = {'a': 1 // 0, 'b': None, 'c': None, 'd': None, 'e': None,
    553565                 'f': None, 'g': None, 'h': None}
    554         except ZeroDivisionError:
    555             pass
    556566        d = {}
    557567
    … …  
    568578            del obj, container
    569579            gc.collect()
    570             self.assert_(ref() is None, "Cycle was not collected")
     580            self.assertIs(ref(), None, "Cycle was not collected")
     581
     582    def _not_tracked(self, t):
     583        # Nested containers can take several collections to untrack
     584        gc.collect()
     585        gc.collect()
     586        self.assertFalse(gc.is_tracked(t), t)
     587
     588    def _tracked(self, t):
     589        self.assertTrue(gc.is_tracked(t), t)
     590        gc.collect()
     591        gc.collect()
     592        self.assertTrue(gc.is_tracked(t), t)
     593
     594    @test_support.cpython_only
     595    def test_track_literals(self):
     596        # Test GC-optimization of dict literals
     597        x, y, z, w = 1.5, "a", (1, None), []
     598
     599        self._not_tracked({})
     600        self._not_tracked({x:(), y:x, z:1})
     601        self._not_tracked({1: "a", "b": 2})
     602        self._not_tracked({1: 2, (None, True, False, ()): int})
     603        self._not_tracked({1: object()})
     604
     605        # Dicts with mutable elements are always tracked, even if those
     606        # elements are not tracked right now.
     607        self._tracked({1: []})
     608        self._tracked({1: ([],)})
     609        self._tracked({1: {}})
     610        self._tracked({1: set()})
     611
     612    @test_support.cpython_only
     613    def test_track_dynamic(self):
     614        # Test GC-optimization of dynamically-created dicts
     615        class MyObject(object):
     616            pass
     617        x, y, z, w, o = 1.5, "a", (1, object()), [], MyObject()
     618
     619        d = dict()
     620        self._not_tracked(d)
     621        d[1] = "a"
     622        self._not_tracked(d)
     623        d[y] = 2
     624        self._not_tracked(d)
     625        d[z] = 3
     626        self._not_tracked(d)
     627        self._not_tracked(d.copy())
     628        d[4] = w
     629        self._tracked(d)
     630        self._tracked(d.copy())
     631        d[4] = None
     632        self._not_tracked(d)
     633        self._not_tracked(d.copy())
     634
     635        # dd isn't tracked right now, but it may mutate and therefore d
     636        # which contains it must be tracked.
     637        d = dict()
     638        dd = dict()
     639        d[1] = dd
     640        self._not_tracked(dd)
     641        self._tracked(d)
     642        dd[1] = d
     643        self._tracked(dd)
     644
     645        d = dict.fromkeys([x, y, z])
     646        self._not_tracked(d)
     647        dd = dict()
     648        dd.update(d)
     649        self._not_tracked(dd)
     650        d = dict.fromkeys([x, y, z, o])
     651        self._tracked(d)
     652        dd = dict()
     653        dd.update(d)
     654        self._tracked(dd)
     655
     656        d = dict(x=x, y=y, z=z)
     657        self._not_tracked(d)
     658        d = dict(x=x, y=y, z=z, w=w)
     659        self._tracked(d)
     660        d = dict()
     661        d.update(x=x, y=y, z=z)
     662        self._not_tracked(d)
     663        d.update(w=w)
     664        self._tracked(d)
     665
     666        d = dict([(x, y), (z, 1)])
     667        self._not_tracked(d)
     668        d = dict([(x, y), (z, w)])
     669        self._tracked(d)
     670        d = dict()
     671        d.update([(x, y), (z, 1)])
     672        self._not_tracked(d)
     673        d.update([(x, y), (z, w)])
     674        self._tracked(d)
     675
     676    @test_support.cpython_only
     677    def test_track_subtypes(self):
     678        # Dict subtypes are always tracked
     679        class MyDict(dict):
     680            pass
     681        self._tracked(MyDict())
    571682
    572683
    … …  
    583694
    584695def test_main():
    585     test_support.run_unittest(
    586         DictTest,
    587         GeneralMappingTests,
    588         SubclassMappingTests,
    589     )
     696    with test_support.check_py3k_warnings(
     697        ('dict(.has_key..| inequality comparisons) not supported in 3.x',
     698         DeprecationWarning)):
     699        test_support.run_unittest(
     700            DictTest,
     701            GeneralMappingTests,
     702            SubclassMappingTests,
     703        )
    590704
    591705if __name__ == "__main__":
Note: See TracChangeset for help on using the changeset viewer.