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_set.py

    r2 r391  
     1
    12import unittest
    23from test import test_support
    … …  
    67import copy
    78import pickle
    8 import os
    99from random import randrange, shuffle
    1010import sys
    … …  
    4949    def test_new_or_init(self):
    5050        self.assertRaises(TypeError, self.thetype, [], 2)
     51        self.assertRaises(TypeError, set().__init__, a=1)
    5152
    5253    def test_uniquification(self):
    … …  
    6566        self.assertRaises(TypeError, self.s.__contains__, [[]])
    6667        s = self.thetype([frozenset(self.letters)])
    67         self.assert_(self.thetype(self.letters) in s)
     68        self.assertIn(self.thetype(self.letters), s)
    6869
    6970    def test_union(self):
    … …  
    129130                    expected = f(s1, s2)
    130131                    self.assertEqual(actual, expected)
    131                     self.assert_(actual is True or actual is False)
     132                    self.assertTrue(actual is True or actual is False)
    132133
    133134    def test_and(self):
    … …  
    212213    def test_sub_and_super(self):
    213214        p, q, r = map(self.thetype, ['ab', 'abcde', 'def'])
    214         self.assert_(p < q)
    215         self.assert_(p <= q)
    216         self.assert_(q <= q)
    217         self.assert_(q > p)
    218         self.assert_(q >= p)
    219         self.failIf(q < r)
    220         self.failIf(q <= r)
    221         self.failIf(q > r)
    222         self.failIf(q >= r)
    223         self.assert_(set('a').issubset('abc'))
    224         self.assert_(set('abc').issuperset('a'))
    225         self.failIf(set('a').issubset('cbs'))
    226         self.failIf(set('cbs').issuperset('a'))
     215        self.assertTrue(p < q)
     216        self.assertTrue(p <= q)
     217        self.assertTrue(q <= q)
     218        self.assertTrue(q > p)
     219        self.assertTrue(q >= p)
     220        self.assertFalse(q < r)
     221        self.assertFalse(q <= r)
     222        self.assertFalse(q > r)
     223        self.assertFalse(q >= r)
     224        self.assertTrue(set('a').issubset('abc'))
     225        self.assertTrue(set('abc').issuperset('a'))
     226        self.assertFalse(set('a').issubset('cbs'))
     227        self.assertFalse(set('cbs').issuperset('a'))
    227228
    228229    def test_pickling(self):
    … …  
    272273        f=set()
    273274        f.add(s)
    274         self.assert_(s in f)
     275        self.assertIn(s, f)
    275276        f.remove(s)
    276277        f.add(s)
    … …  
    338339        del obj, container
    339340        gc.collect()
    340         self.assert_(ref() is None, "Cycle was not collected")
     341        self.assertTrue(ref() is None, "Cycle was not collected")
    341342
    342343class TestSet(TestJointOps):
    … …  
    372373    def test_add(self):
    373374        self.s.add('Q')
    374         self.assert_('Q' in self.s)
     375        self.assertIn('Q', self.s)
    375376        dup = self.s.copy()
    376377        self.s.add('Q')
    … …  
    380381    def test_remove(self):
    381382        self.s.remove('a')
    382         self.assert_('a' not in self.s)
     383        self.assertNotIn('a', self.s)
    383384        self.assertRaises(KeyError, self.s.remove, 'Q')
    384385        self.assertRaises(TypeError, self.s.remove, [])
    385386        s = self.thetype([frozenset(self.word)])
    386         self.assert_(self.thetype(self.word) in s)
     387        self.assertIn(self.thetype(self.word), s)
    387388        s.remove(self.thetype(self.word))
    388         self.assert_(self.thetype(self.word) not in s)
     389        self.assertNotIn(self.thetype(self.word), s)
    389390        self.assertRaises(KeyError, self.s.remove, self.thetype(self.word))
    390391
    … …  
    405406            self.s.remove(key)
    406407        except KeyError as e:
    407             self.assert_(e.args[0] is key,
     408            self.assertTrue(e.args[0] is key,
    408409                         "KeyError should be {0}, not {1}".format(key,
    409410                                                                  e.args[0]))
    … …  
    413414    def test_discard(self):
    414415        self.s.discard('a')
    415         self.assert_('a' not in self.s)
     416        self.assertNotIn('a', self.s)
    416417        self.s.discard('Q')
    417418        self.assertRaises(TypeError, self.s.discard, [])
    418419        s = self.thetype([frozenset(self.word)])
    419         self.assert_(self.thetype(self.word) in s)
     420        self.assertIn(self.thetype(self.word), s)
    420421        s.discard(self.thetype(self.word))
    421         self.assert_(self.thetype(self.word) not in s)
     422        self.assertNotIn(self.thetype(self.word), s)
    422423        s.discard(self.thetype(self.word))
    423424
    … …  
    425426        for i in xrange(len(self.s)):
    426427            elem = self.s.pop()
    427             self.assert_(elem not in self.s)
     428            self.assertNotIn(elem, self.s)
    428429        self.assertRaises(KeyError, self.s.pop)
    429430
    … …  
    432433        self.assertEqual(retval, None)
    433434        for c in (self.word + self.otherword):
    434             self.assert_(c in self.s)
     435            self.assertIn(c, self.s)
    435436        self.assertRaises(PassThru, self.s.update, check_pass_thru())
    436437        self.assertRaises(TypeError, self.s.update, [[]])
    … …  
    450451        self.s |= set(self.otherword)
    451452        for c in (self.word + self.otherword):
    452             self.assert_(c in self.s)
     453            self.assertIn(c, self.s)
    453454
    454455    def test_intersection_update(self):
    … …  
    457458        for c in (self.word + self.otherword):
    458459            if c in self.otherword and c in self.word:
    459                 self.assert_(c in self.s)
     460                self.assertIn(c, self.s)
    460461            else:
    461                 self.assert_(c not in self.s)
     462                self.assertNotIn(c, self.s)
    462463        self.assertRaises(PassThru, self.s.intersection_update, check_pass_thru())
    463464        self.assertRaises(TypeError, self.s.intersection_update, [[]])
    … …  
    477478        for c in (self.word + self.otherword):
    478479            if c in self.otherword and c in self.word:
    479                 self.assert_(c in self.s)
     480                self.assertIn(c, self.s)
    480481            else:
    481                 self.assert_(c not in self.s)
     482                self.assertNotIn(c, self.s)
    482483
    483484    def test_difference_update(self):
    … …  
    486487        for c in (self.word + self.otherword):
    487488            if c in self.word and c not in self.otherword:
    488                 self.assert_(c in self.s)
     489                self.assertIn(c, self.s)
    489490            else:
    490                 self.assert_(c not in self.s)
     491                self.assertNotIn(c, self.s)
    491492        self.assertRaises(PassThru, self.s.difference_update, check_pass_thru())
    492493        self.assertRaises(TypeError, self.s.difference_update, [[]])
    … …  
    514515        for c in (self.word + self.otherword):
    515516            if c in self.word and c not in self.otherword:
    516                 self.assert_(c in self.s)
     517                self.assertIn(c, self.s)
    517518            else:
    518                 self.assert_(c not in self.s)
     519                self.assertNotIn(c, self.s)
    519520
    520521    def test_symmetric_difference_update(self):
    … …  
    523524        for c in (self.word + self.otherword):
    524525            if (c in self.word) ^ (c in self.otherword):
    525                 self.assert_(c in self.s)
     526                self.assertIn(c, self.s)
    526527            else:
    527                 self.assert_(c not in self.s)
     528                self.assertNotIn(c, self.s)
    528529        self.assertRaises(PassThru, self.s.symmetric_difference_update, check_pass_thru())
    529530        self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
    … …  
    538539        for c in (self.word + self.otherword):
    539540            if (c in self.word) ^ (c in self.otherword):
    540                 self.assert_(c in self.s)
     541                self.assertIn(c, self.s)
    541542            else:
    542                 self.assert_(c not in self.s)
     543                self.assertNotIn(c, self.s)
    543544
    544545    def test_inplace_on_self(self):
    … …  
    564565    if hasattr(set, "test_c_api"):
    565566        def test_c_api(self):
    566             self.assertEqual(set('abc').test_c_api(), True)
     567            self.assertEqual(set().test_c_api(), True)
    567568
    568569class SetSubclass(set):
    … …  
    687688            self.assertEqual(repr(self.set), self.repr)
    688689
     690    def check_repr_against_values(self):
     691        text = repr(self.set)
     692        self.assertTrue(text.startswith('{'))
     693        self.assertTrue(text.endswith('}'))
     694
     695        result = text[1:-1].split(', ')
     696        result.sort()
     697        sorted_repr_values = [repr(value) for value in self.values]
     698        sorted_repr_values.sort()
     699        self.assertEqual(result, sorted_repr_values)
     700
    689701    def test_print(self):
    690702        fo = open(test_support.TESTFN, "wb")
    … …  
    750762        self.assertEqual(result, empty_set)
    751763
    752     def checkempty_symmetric_difference(self):
     764    def test_empty_symmetric_difference(self):
    753765        result = self.set ^ empty_set
    754766        self.assertEqual(result, self.set)
    … …  
    768780    def test_iteration(self):
    769781        for v in self.set:
    770             self.assert_(v in self.values)
     782            self.assertIn(v, self.values)
    771783        setiter = iter(self.set)
    772784        # note: __length_hint__ is an internal undocumented API,
    … …  
    803815
    804816    def test_in(self):
    805         self.failUnless(3 in self.set)
     817        self.assertIn(3, self.set)
    806818
    807819    def test_not_in(self):
    808         self.failUnless(2 not in self.set)
     820        self.assertNotIn(2, self.set)
    809821
    810822#------------------------------------------------------------------------------
    … …  
    820832
    821833    def test_in(self):
    822         self.failUnless((0, "zero") in self.set)
     834        self.assertIn((0, "zero"), self.set)
    823835
    824836    def test_not_in(self):
    825         self.failUnless(9 not in self.set)
     837        self.assertNotIn(9, self.set)
    826838
    827839#------------------------------------------------------------------------------
    … …  
    835847        self.length = 3
    836848        self.repr   = None
     849
     850#------------------------------------------------------------------------------
     851
     852class TestBasicOpsString(TestBasicOps):
     853    def setUp(self):
     854        self.case   = "string set"
     855        self.values = ["a", "b", "c"]
     856        self.set    = set(self.values)
     857        self.dup    = set(self.values)
     858        self.length = 3
     859
     860    def test_repr(self):
     861        self.check_repr_against_values()
     862
     863#------------------------------------------------------------------------------
     864
     865class TestBasicOpsUnicode(TestBasicOps):
     866    def setUp(self):
     867        self.case   = "unicode set"
     868        self.values = [u"a", u"b", u"c"]
     869        self.set    = set(self.values)
     870        self.dup    = set(self.values)
     871        self.length = 3
     872
     873    def test_repr(self):
     874        self.check_repr_against_values()
     875
     876#------------------------------------------------------------------------------
     877
     878class TestBasicOpsMixedStringUnicode(TestBasicOps):
     879    def setUp(self):
     880        self.case   = "string and bytes set"
     881        self.values = ["a", "b", u"a", u"b"]
     882        self.set    = set(self.values)
     883        self.dup    = set(self.values)
     884        self.length = 4
     885
     886    def test_repr(self):
     887        with test_support.check_warnings():
     888            self.check_repr_against_values()
    837889
    838890#==============================================================================
    … …  
    11151167        self.assertEqual(len(popped), len(self.values))
    11161168        for v in self.values:
    1117             self.failUnless(v in popped)
     1169            self.assertIn(v, popped)
    11181170
    11191171    def test_update_empty_tuple(self):
    … …  
    13471399        self.otherIsIterable = False
    13481400
     1401    def test_ge_gt_le_lt(self):
     1402        with test_support.check_py3k_warnings():
     1403            super(TestOnlySetsOperator, self).test_ge_gt_le_lt()
     1404
    13491405#------------------------------------------------------------------------------
    13501406
    … …  
    13791435
    13801436    def test_copy(self):
    1381         dup = self.set.copy()
    1382         dup_list = list(dup); dup_list.sort()
    1383         set_list = list(self.set); set_list.sort()
    1384         self.assertEqual(len(dup_list), len(set_list))
    1385         for i in range(len(dup_list)):
    1386             self.failUnless(dup_list[i] is set_list[i])
     1437        dup = list(self.set.copy())
     1438        self.assertEqual(len(dup), len(self.set))
     1439        for el in self.set:
     1440            self.assertIn(el, dup)
     1441            pos = dup.index(el)
     1442            self.assertIs(el, dup.pop(pos))
     1443        self.assertFalse(dup)
    13871444
    13881445    def test_deep_copy(self):
    13891446        dup = copy.deepcopy(self.set)
    1390         ##print type(dup), repr(dup)
    1391         dup_list = list(dup); dup_list.sort()
    1392         set_list = list(self.set); set_list.sort()
    1393         self.assertEqual(len(dup_list), len(set_list))
    1394         for i in range(len(dup_list)):
    1395             self.assertEqual(dup_list[i], set_list[i])
     1447        self.assertSetEqual(dup, self.set)
    13961448
    13971449#------------------------------------------------------------------------------
    … …  
    14341486    def test_binopsVsSubsets(self):
    14351487        a, b = self.a, self.b
    1436         self.assert_(a - b < a)
    1437         self.assert_(b - a < b)
    1438         self.assert_(a & b < a)
    1439         self.assert_(a & b < b)
    1440         self.assert_(a | b > a)
    1441         self.assert_(a | b > b)
    1442         self.assert_(a ^ b < a | b)
     1488        self.assertTrue(a - b < a)
     1489        self.assertTrue(b - a < b)
     1490        self.assertTrue(a & b < a)
     1491        self.assertTrue(a & b < b)
     1492        self.assertTrue(a | b > a)
     1493        self.assertTrue(a | b > b)
     1494        self.assertTrue(a ^ b < a | b)
    14431495
    14441496    def test_commutativity(self):
    … …  
    15531605            for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
    15541606                for g in (G, I, Ig, S, L, R):
    1555                     self.assertEqual(sorted(cons(g(s))), sorted(g(s)))
     1607                    self.assertSetEqual(cons(g(s)), set(g(s)))
    15561608                self.assertRaises(TypeError, cons , X(s))
    15571609                self.assertRaises(TypeError, cons , N(s))
    … …  
    15681620                        self.assertEqual(actual, expected)
    15691621                    else:
    1570                         self.assertEqual(sorted(actual), sorted(expected))
     1622                        self.assertSetEqual(actual, expected)
    15711623                self.assertRaises(TypeError, meth, X(s))
    15721624                self.assertRaises(TypeError, meth, N(s))
    … …  
    15821634                    getattr(s, methname)(list(g(data)))
    15831635                    getattr(t, methname)(g(data))
    1584                     self.assertEqual(sorted(s), sorted(t))
     1636                    self.assertSetEqual(s, t)
    15851637
    15861638                self.assertRaises(TypeError, getattr(set('january'), methname), X(data))
    15871639                self.assertRaises(TypeError, getattr(set('january'), methname), N(data))
    15881640                self.assertRaises(ZeroDivisionError, getattr(set('january'), methname), E(data))
     1641
     1642class bad_eq:
     1643    def __eq__(self, other):
     1644        if be_bad:
     1645            set2.clear()
     1646            raise ZeroDivisionError
     1647        return self is other
     1648    def __hash__(self):
     1649        return 0
     1650
     1651class bad_dict_clear:
     1652    def __eq__(self, other):
     1653        if be_bad:
     1654            dict2.clear()
     1655        return self is other
     1656    def __hash__(self):
     1657        return 0
     1658
     1659class TestWeirdBugs(unittest.TestCase):
     1660    def test_8420_set_merge(self):
     1661        # This used to segfault
     1662        global be_bad, set2, dict2
     1663        be_bad = False
     1664        set1 = {bad_eq()}
     1665        set2 = {bad_eq() for i in range(75)}
     1666        be_bad = True
     1667        self.assertRaises(ZeroDivisionError, set1.update, set2)
     1668
     1669        be_bad = False
     1670        set1 = {bad_dict_clear()}
     1671        dict2 = {bad_dict_clear(): None}
     1672        be_bad = True
     1673        set1.symmetric_difference_update(dict2)
    15891674
    15901675# Application tests (based on David Eppstein's graph recipes ====================================
    … …  
    16891774            self.assertEqual(len(edge), 2)      # Two cube vertices define an edge
    16901775            for cubevert in edge:
    1691                 self.assert_(cubevert in g)
     1776                self.assertIn(cubevert, g)
    16921777
    16931778
    … …  
    16951780
    16961781def test_main(verbose=None):
    1697     from test import test_sets
    16981782    test_classes = (
    16991783        TestSet,
    … …  
    17301814        TestVariousIteratorArgs,
    17311815        TestGraphs,
     1816        TestWeirdBugs,
    17321817        )
    17331818
Note: See TracChangeset for help on using the changeset viewer.