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/mapping_tests.py

    r2 r391  
    22import unittest
    33import UserDict
     4import test_support
    45
    56
    … …  
    5152            self.assertEqual(d[key], value)
    5253        knownkey = self.other.keys()[0]
    53         self.failUnlessRaises(KeyError, lambda:d[knownkey])
     54        self.assertRaises(KeyError, lambda:d[knownkey])
    5455        #len
    5556        self.assertEqual(len(p), 0)
    5657        self.assertEqual(len(d), len(self.reference))
     58        #in
     59        for k in self.reference:
     60            self.assertIn(k, d)
     61        for k in self.other:
     62            self.assertNotIn(k, d)
    5763        #has_key
    58         for k in self.reference:
    59             self.assert_(d.has_key(k))
    60             self.assert_(k in d)
    61         for k in self.other:
    62             self.failIf(d.has_key(k))
    63             self.failIf(k in d)
     64        with test_support.check_py3k_warnings(quiet=True):
     65            for k in self.reference:
     66                self.assertTrue(d.has_key(k))
     67            for k in self.other:
     68                self.assertFalse(d.has_key(k))
    6469        #cmp
    6570        self.assertEqual(cmp(p,p), 0)
    … …  
    7277        # keys(), items(), iterkeys() ...
    7378        def check_iterandlist(iter, lst, ref):
    74             self.assert_(hasattr(iter, 'next'))
    75             self.assert_(hasattr(iter, '__iter__'))
     79            self.assertTrue(hasattr(iter, 'next'))
     80            self.assertTrue(hasattr(iter, '__iter__'))
    7681            x = list(iter)
    77             self.assert_(set(x)==set(lst)==set(ref))
     82            self.assertTrue(set(x)==set(lst)==set(ref))
    7883        check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys())
    7984        check_iterandlist(iter(d), d.keys(), self.reference.keys())
    … …  
    8590        self.assertEqual(d.get(key, knownvalue), value)
    8691        self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
    87         self.failIf(knownkey in d)
     92        self.assertNotIn(knownkey, d)
    8893
    8994    def test_write(self):
    … …  
    96101        for key in self.reference.keys():
    97102            del p[key]
    98             self.failUnlessRaises(KeyError, lambda:p[key])
     103            self.assertRaises(KeyError, lambda:p[key])
    99104        p = self._empty_mapping()
    100105        #update
    … …  
    115120        #pop
    116121        self.assertEqual(d.pop(knownkey), knownvalue)
    117         self.failIf(knownkey in d)
     122        self.assertNotIn(knownkey, d)
    118123        self.assertRaises(KeyError, d.pop, knownkey)
    119124        default = 909
    120125        d[knownkey] = knownvalue
    121126        self.assertEqual(d.pop(knownkey, default), knownvalue)
    122         self.failIf(knownkey in d)
     127        self.assertNotIn(knownkey, d)
    123128        self.assertEqual(d.pop(knownkey, default), default)
    124129        #popitem
    125130        key, value = d.popitem()
    126         self.failIf(key in d)
     131        self.assertNotIn(key, d)
    127132        self.assertEqual(value, self.reference[key])
    128133        p=self._empty_mapping()
    … …  
    133138
    134139    def test_bool(self):
    135         self.assert_(not self._empty_mapping())
    136         self.assert_(self.reference)
    137         self.assert_(bool(self._empty_mapping()) is False)
    138         self.assert_(bool(self.reference) is True)
     140        self.assertTrue(not self._empty_mapping())
     141        self.assertTrue(self.reference)
     142        self.assertTrue(bool(self._empty_mapping()) is False)
     143        self.assertTrue(bool(self.reference) is True)
    139144
    140145    def test_keys(self):
    … …  
    142147        self.assertEqual(d.keys(), [])
    143148        d = self.reference
    144         self.assert_(self.inmapping.keys()[0] in d.keys())
    145         self.assert_(self.other.keys()[0] not in d.keys())
     149        self.assertIn(self.inmapping.keys()[0], d.keys())
     150        self.assertNotIn(self.other.keys()[0], d.keys())
    146151        self.assertRaises(TypeError, d.keys, None)
    147152
    … …  
    205210        i1 = d.items()
    206211        i2 = self.reference.items()
    207         i1.sort()
    208         i2.sort()
     212
     213        def safe_sort_key(kv):
     214            k, v = kv
     215            return id(type(k)), id(type(v)), k, v
     216        i1.sort(key=safe_sort_key)
     217        i2.sort(key=safe_sort_key)
    209218        self.assertEqual(i1, i2)
    210219
    … …  
    269278    def test_get(self):
    270279        d = self._empty_mapping()
    271         self.assert_(d.get(self.other.keys()[0]) is None)
     280        self.assertTrue(d.get(self.other.keys()[0]) is None)
    272281        self.assertEqual(d.get(self.other.keys()[0], 3), 3)
    273282        d = self.reference
    274         self.assert_(d.get(self.other.keys()[0]) is None)
     283        self.assertTrue(d.get(self.other.keys()[0]) is None)
    275284        self.assertEqual(d.get(self.other.keys()[0], 3), 3)
    276285        self.assertEqual(d.get(self.inmapping.keys()[0]), self.inmapping.values()[0])
    … …  
    303312    def test_constructor(self):
    304313        BasicTestMappingProtocol.test_constructor(self)
    305         self.assert_(self._empty_mapping() is not self._empty_mapping())
     314        self.assertTrue(self._empty_mapping() is not self._empty_mapping())
    306315        self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2})
    307316
    308317    def test_bool(self):
    309318        BasicTestMappingProtocol.test_bool(self)
    310         self.assert_(not self._empty_mapping())
    311         self.assert_(self._full_mapping({"x": "y"}))
    312         self.assert_(bool(self._empty_mapping()) is False)
    313         self.assert_(bool(self._full_mapping({"x": "y"})) is True)
     319        self.assertTrue(not self._empty_mapping())
     320        self.assertTrue(self._full_mapping({"x": "y"}))
     321        self.assertTrue(bool(self._empty_mapping()) is False)
     322        self.assertTrue(bool(self._full_mapping({"x": "y"})) is True)
    314323
    315324    def test_keys(self):
    … …  
    319328        d = self._full_mapping({'a': 1, 'b': 2})
    320329        k = d.keys()
    321         self.assert_('a' in k)
    322         self.assert_('b' in k)
    323         self.assert_('c' not in k)
     330        self.assertIn('a', k)
     331        self.assertIn('b', k)
     332        self.assertNotIn('c', k)
    324333
    325334    def test_values(self):
    … …  
    336345    def test_has_key(self):
    337346        d = self._empty_mapping()
    338         self.assert_(not d.has_key('a'))
     347        self.assertTrue(not d.has_key('a'))
    339348        d = self._full_mapping({'a': 1, 'b': 2})
    340349        k = d.keys()
    341         k.sort()
     350        k.sort(key=lambda k: (id(type(k)), k))
    342351        self.assertEqual(k, ['a', 'b'])
    343352
    … …  
    346355    def test_contains(self):
    347356        d = self._empty_mapping()
    348         self.assert_(not ('a' in d))
    349         self.assert_('a' not in d)
     357        self.assertNotIn('a', d)
     358        self.assertTrue(not ('a' in d))
     359        self.assertTrue('a' not in d)
    350360        d = self._full_mapping({'a': 1, 'b': 2})
    351         self.assert_('a' in d)
    352         self.assert_('b' in d)
    353         self.assert_('c' not in d)
     361        self.assertIn('a', d)
     362        self.assertIn('b', d)
     363        self.assertNotIn('c', d)
    354364
    355365        self.assertRaises(TypeError, d.__contains__)
    … …  
    430440        self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
    431441        d = self._empty_mapping()
    432         self.assert_(not(d.fromkeys('abc') is d))
     442        self.assertTrue(not(d.fromkeys('abc') is d))
    433443        self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
    434444        self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0})
    … …  
    441451        self.assertEqual(dictlike.fromkeys('a'), {'a':None})
    442452        self.assertEqual(dictlike().fromkeys('a'), {'a':None})
    443         self.assert_(dictlike.fromkeys('a').__class__ is dictlike)
    444         self.assert_(dictlike().fromkeys('a').__class__ is dictlike)
     453        self.assertTrue(dictlike.fromkeys('a').__class__ is dictlike)
     454        self.assertTrue(dictlike().fromkeys('a').__class__ is dictlike)
    445455        # FIXME: the following won't work with UserDict, because it's an old style class
    446         # self.assert_(type(dictlike.fromkeys('a')) is dictlike)
     456        # self.assertTrue(type(dictlike.fromkeys('a')) is dictlike)
    447457        class mydict(self.type2test):
    448458            def __new__(cls):
    … …  
    451461        self.assertEqual(ud, {'a':None, 'b':None})
    452462        # FIXME: the following won't work with UserDict, because it's an old style class
    453         # self.assert_(isinstance(ud, UserDict.UserDict))
     463        # self.assertIsInstance(ud, UserDict.UserDict)
    454464        self.assertRaises(TypeError, dict.fromkeys)
    455465
    … …  
    481491        d = self._empty_mapping()
    482492        self.assertEqual(d.copy(), d)
    483         self.assert_(isinstance(d.copy(), d.__class__))
     493        self.assertIsInstance(d.copy(), d.__class__)
    484494        self.assertRaises(TypeError, d.copy, None)
    485495
    … …  
    487497        BasicTestMappingProtocol.test_get(self)
    488498        d = self._empty_mapping()
    489         self.assert_(d.get('c') is None)
     499        self.assertTrue(d.get('c') is None)
    490500        self.assertEqual(d.get('c', 3), 3)
    491501        d = self._full_mapping({'a' : 1, 'b' : 2})
    492         self.assert_(d.get('c') is None)
     502        self.assertTrue(d.get('c') is None)
    493503        self.assertEqual(d.get('c', 3), 3)
    494504        self.assertEqual(d.get('a'), 1)
    … …  
    498508        BasicTestMappingProtocol.test_setdefault(self)
    499509        d = self._empty_mapping()
    500         self.assert_(d.setdefault('key0') is None)
     510        self.assertTrue(d.setdefault('key0') is None)
    501511        d.setdefault('key0', [])
    502         self.assert_(d.setdefault('key0') is None)
     512        self.assertTrue(d.setdefault('key0') is None)
    503513        d.setdefault('key', []).append(3)
    504514        self.assertEqual(d['key'][0], 3)
    … …  
    526536                    kb, vb = tb = b.popitem()
    527537                    self.assertEqual(vb, int(kb))
    528                     self.assert_(not(copymode < 0 and ta != tb))
    529                 self.assert_(not a)
    530                 self.assert_(not b)
     538                    self.assertTrue(not(copymode < 0 and ta != tb))
     539                self.assertTrue(not a)
     540                self.assertTrue(not b)
    531541
    532542    def test_pop(self):
    … …  
    586596        ud = mydict.fromkeys('ab')
    587597        self.assertEqual(ud, {'a':None, 'b':None})
    588         self.assert_(isinstance(ud, UserDict.UserDict))
     598        self.assertIsInstance(ud, UserDict.UserDict)
    589599
    590600    def test_pop(self):
    … …  
    637647
    638648    def test_le(self):
    639         self.assert_(not (self._empty_mapping() < self._empty_mapping()))
    640         self.assert_(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L})))
     649        self.assertTrue(not (self._empty_mapping() < self._empty_mapping()))
     650        self.assertTrue(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L})))
    641651
    642652        class Exc(Exception): pass
Note: See TracChangeset for help on using the changeset viewer.