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

    r2 r391  
    1414#    value has been created. Use 'del s' before the create_largestring call.
    1515#
    16 #  - Do *not* compare large objects using assertEquals or similar. It's a
     16#  - Do *not* compare large objects using assertEqual or similar. It's a
    1717#    lengty operation and the errormessage will be utterly useless due to
    1818#    its size. To make sure whether a result has the right contents, better
    … …  
    4040        s = '-' * size + SUBSTR
    4141        caps = s.capitalize()
    42         self.assertEquals(caps[-len(SUBSTR):],
     42        self.assertEqual(caps[-len(SUBSTR):],
    4343                         SUBSTR.capitalize())
    44         self.assertEquals(caps.lstrip('-'), SUBSTR)
     44        self.assertEqual(caps.lstrip('-'), SUBSTR)
    4545
    4646    @bigmemtest(minsize=_2G + 10, memuse=1)
    … …  
    4848        SUBSTR = ' abc def ghi'
    4949        s = SUBSTR.center(size)
    50         self.assertEquals(len(s), size)
     50        self.assertEqual(len(s), size)
    5151        lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2
    5252        if len(s) % 2:
    5353            lpadsize += 1
    54         self.assertEquals(s[lpadsize:-rpadsize], SUBSTR)
    55         self.assertEquals(s.strip(), SUBSTR.strip())
     54        self.assertEqual(s[lpadsize:-rpadsize], SUBSTR)
     55        self.assertEqual(s.strip(), SUBSTR.strip())
    5656
    5757    @precisionbigmemtest(size=_2G - 1, memuse=1)
    … …  
    6363            pass # acceptable on 32-bit
    6464        else:
    65             self.assertEquals(len(s), size)
     65            self.assertEqual(len(s), size)
    6666            lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2
    6767            if len(s) % 2:
    6868                lpadsize += 1
    69             self.assertEquals(s[lpadsize:-rpadsize], SUBSTR)
    70             self.assertEquals(s.strip(), SUBSTR.strip())
     69            self.assertEqual(s[lpadsize:-rpadsize], SUBSTR)
     70            self.assertEqual(s.strip(), SUBSTR.strip())
    7171            del s
    7272
    … …  
    7575        SUBSTR = ' abc def ghi'
    7676        s = '.' * size + SUBSTR
    77         self.assertEquals(s.count('.'), size)
     77        self.assertEqual(s.count('.'), size)
    7878        s += '.'
    79         self.assertEquals(s.count('.'), size + 1)
    80         self.assertEquals(s.count(' '), 3)
    81         self.assertEquals(s.count('i'), 1)
    82         self.assertEquals(s.count('j'), 0)
     79        self.assertEqual(s.count('.'), size + 1)
     80        self.assertEqual(s.count(' '), 3)
     81        self.assertEqual(s.count('i'), 1)
     82        self.assertEqual(s.count('j'), 0)
    8383
    8484    @bigmemtest(minsize=_2G + 2, memuse=3)
    8585    def test_decode(self, size):
    8686        s = '.' * size
    87         self.assertEquals(len(s.decode('utf-8')), size)
     87        self.assertEqual(len(s.decode('utf-8')), size)
    8888
    8989    def basic_encode_test(self, size, enc, c=u'.', expectedsize=None):
    … …  
    9292
    9393        s = c * size
    94         self.assertEquals(len(s.encode(enc)), expectedsize)
     94        self.assertEqual(len(s.encode(enc)), expectedsize)
    9595
    9696    @bigmemtest(minsize=_2G + 2, memuse=3)
    … …  
    9898        return self.basic_encode_test(size, 'utf-8')
    9999
    100     @precisionbigmemtest(size=_4G / 6 + 2, memuse=2)
     100    @precisionbigmemtest(size=_4G // 6 + 2, memuse=2)
    101101    def test_encode_raw_unicode_escape(self, size):
    102102        try:
    … …  
    105105            pass # acceptable on 32-bit
    106106
    107     @precisionbigmemtest(size=_4G / 5 + 70, memuse=3)
     107    @precisionbigmemtest(size=_4G // 5 + 70, memuse=3)
    108108    def test_encode_utf7(self, size):
    109109        try:
    … …  
    112112            pass # acceptable on 32-bit
    113113
    114     @precisionbigmemtest(size=_4G / 4 + 5, memuse=6)
     114    @precisionbigmemtest(size=_4G // 4 + 5, memuse=6)
    115115    def test_encode_utf32(self, size):
    116116        try:
    … …  
    119119            pass # acceptable on 32-bit
    120120
    121     @precisionbigmemtest(size=_2G-1, memuse=2)
     121    @precisionbigmemtest(size=_2G-1, memuse=4)
    122122    def test_decodeascii(self, size):
    123123        return self.basic_encode_test(size, 'ascii', c='A')
    124124
    125     @precisionbigmemtest(size=_4G / 5, memuse=6+2)
     125    @precisionbigmemtest(size=_4G // 5, memuse=6+2)
    126126    def test_unicode_repr_oflw(self, size):
     127        self.skipTest("test crashes - see issue #14904")
    127128        try:
    128129            s = u"\uAAAA"*size
    … …  
    131132            pass # acceptable on 32-bit
    132133        else:
    133             self.failUnless(s == eval(r))
     134            self.assertTrue(s == eval(r))
    134135
    135136    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    137138        SUBSTR = ' abc def ghi'
    138139        s = '-' * size + SUBSTR
    139         self.failUnless(s.endswith(SUBSTR))
    140         self.failUnless(s.endswith(s))
     140        self.assertTrue(s.endswith(SUBSTR))
     141        self.assertTrue(s.endswith(s))
    141142        s2 = '...' + s
    142         self.failUnless(s2.endswith(s))
    143         self.failIf(s.endswith('a' + SUBSTR))
    144         self.failIf(SUBSTR.endswith(s))
     143        self.assertTrue(s2.endswith(s))
     144        self.assertFalse(s.endswith('a' + SUBSTR))
     145        self.assertFalse(SUBSTR.endswith(s))
    145146
    146147    @bigmemtest(minsize=_2G + 10, memuse=2)
    … …  
    148149        s = '-' * size
    149150        tabsize = 8
    150         self.assertEquals(s.expandtabs(), s)
     151        self.assertEqual(s.expandtabs(), s)
    151152        del s
    152153        slen, remainder = divmod(size, tabsize)
    153154        s = '       \t' * slen
    154155        s = s.expandtabs(tabsize)
    155         self.assertEquals(len(s), size - remainder)
    156         self.assertEquals(len(s.strip(' ')), 0)
     156        self.assertEqual(len(s), size - remainder)
     157        self.assertEqual(len(s.strip(' ')), 0)
    157158
    158159    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    161162        sublen = len(SUBSTR)
    162163        s = ''.join([SUBSTR, '-' * size, SUBSTR])
    163         self.assertEquals(s.find(' '), 0)
    164         self.assertEquals(s.find(SUBSTR), 0)
    165         self.assertEquals(s.find(' ', sublen), sublen + size)
    166         self.assertEquals(s.find(SUBSTR, len(SUBSTR)), sublen + size)
    167         self.assertEquals(s.find('i'), SUBSTR.find('i'))
    168         self.assertEquals(s.find('i', sublen),
     164        self.assertEqual(s.find(' '), 0)
     165        self.assertEqual(s.find(SUBSTR), 0)
     166        self.assertEqual(s.find(' ', sublen), sublen + size)
     167        self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + size)
     168        self.assertEqual(s.find('i'), SUBSTR.find('i'))
     169        self.assertEqual(s.find('i', sublen),
    169170                         sublen + size + SUBSTR.find('i'))
    170         self.assertEquals(s.find('i', size),
     171        self.assertEqual(s.find('i', size),
    171172                         sublen + size + SUBSTR.find('i'))
    172         self.assertEquals(s.find('j'), -1)
     173        self.assertEqual(s.find('j'), -1)
    173174
    174175    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    177178        sublen = len(SUBSTR)
    178179        s = ''.join([SUBSTR, '-' * size, SUBSTR])
    179         self.assertEquals(s.index(' '), 0)
    180         self.assertEquals(s.index(SUBSTR), 0)
    181         self.assertEquals(s.index(' ', sublen), sublen + size)
    182         self.assertEquals(s.index(SUBSTR, sublen), sublen + size)
    183         self.assertEquals(s.index('i'), SUBSTR.index('i'))
    184         self.assertEquals(s.index('i', sublen),
     180        self.assertEqual(s.index(' '), 0)
     181        self.assertEqual(s.index(SUBSTR), 0)
     182        self.assertEqual(s.index(' ', sublen), sublen + size)
     183        self.assertEqual(s.index(SUBSTR, sublen), sublen + size)
     184        self.assertEqual(s.index('i'), SUBSTR.index('i'))
     185        self.assertEqual(s.index('i', sublen),
    185186                         sublen + size + SUBSTR.index('i'))
    186         self.assertEquals(s.index('i', size),
     187        self.assertEqual(s.index('i', size),
    187188                         sublen + size + SUBSTR.index('i'))
    188189        self.assertRaises(ValueError, s.index, 'j')
    … …  
    192193        SUBSTR = '123456'
    193194        s = 'a' * size + SUBSTR
    194         self.failUnless(s.isalnum())
     195        self.assertTrue(s.isalnum())
    195196        s += '.'
    196         self.failIf(s.isalnum())
     197        self.assertFalse(s.isalnum())
    197198
    198199    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    200201        SUBSTR = 'zzzzzzz'
    201202        s = 'a' * size + SUBSTR
    202         self.failUnless(s.isalpha())
     203        self.assertTrue(s.isalpha())
    203204        s += '.'
    204         self.failIf(s.isalpha())
     205        self.assertFalse(s.isalpha())
    205206
    206207    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    208209        SUBSTR = '123456'
    209210        s = '9' * size + SUBSTR
    210         self.failUnless(s.isdigit())
     211        self.assertTrue(s.isdigit())
    211212        s += 'z'
    212         self.failIf(s.isdigit())
     213        self.assertFalse(s.isdigit())
    213214
    214215    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    217218        repeats = size // len(chars) + 2
    218219        s = chars * repeats
    219         self.failUnless(s.islower())
     220        self.assertTrue(s.islower())
    220221        s += 'A'
    221         self.failIf(s.islower())
     222        self.assertFalse(s.islower())
    222223
    223224    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    226227        repeats = size // len(whitespace) + 2
    227228        s = whitespace * repeats
    228         self.failUnless(s.isspace())
     229        self.assertTrue(s.isspace())
    229230        s += 'j'
    230         self.failIf(s.isspace())
     231        self.assertFalse(s.isspace())
    231232
    232233    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    234235        SUBSTR = '123456'
    235236        s = ''.join(['A', 'a' * size, SUBSTR])
    236         self.failUnless(s.istitle())
     237        self.assertTrue(s.istitle())
    237238        s += 'A'
    238         self.failUnless(s.istitle())
     239        self.assertTrue(s.istitle())
    239240        s += 'aA'
    240         self.failIf(s.istitle())
     241        self.assertFalse(s.istitle())
    241242
    242243    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    245246        repeats = size // len(chars) + 2
    246247        s = chars * repeats
    247         self.failUnless(s.isupper())
     248        self.assertTrue(s.isupper())
    248249        s += 'a'
    249         self.failIf(s.isupper())
     250        self.assertFalse(s.isupper())
    250251
    251252    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    253254        s = 'A' * size
    254255        x = s.join(['aaaaa', 'bbbbb'])
    255         self.assertEquals(x.count('a'), 5)
    256         self.assertEquals(x.count('b'), 5)
    257         self.failUnless(x.startswith('aaaaaA'))
    258         self.failUnless(x.endswith('Abbbbb'))
     256        self.assertEqual(x.count('a'), 5)
     257        self.assertEqual(x.count('b'), 5)
     258        self.assertTrue(x.startswith('aaaaaA'))
     259        self.assertTrue(x.endswith('Abbbbb'))
    259260
    260261    @bigmemtest(minsize=_2G + 10, memuse=1)
    … …  
    262263        SUBSTR = ' abc def ghi'
    263264        s = SUBSTR.ljust(size)
    264         self.failUnless(s.startswith(SUBSTR + '  '))
    265         self.assertEquals(len(s), size)
    266         self.assertEquals(s.strip(), SUBSTR.strip())
     265        self.assertTrue(s.startswith(SUBSTR + '  '))
     266        self.assertEqual(len(s), size)
     267        self.assertEqual(s.strip(), SUBSTR.strip())
    267268
    268269    @bigmemtest(minsize=_2G + 10, memuse=2)
    … …  
    270271        s = 'A' * size
    271272        s = s.lower()
    272         self.assertEquals(len(s), size)
    273         self.assertEquals(s.count('a'), size)
     273        self.assertEqual(len(s), size)
     274        self.assertEqual(s.count('a'), size)
    274275
    275276    @bigmemtest(minsize=_2G + 10, memuse=1)
    … …  
    277278        SUBSTR = 'abc def ghi'
    278279        s = SUBSTR.rjust(size)
    279         self.assertEquals(len(s), size)
    280         self.assertEquals(s.lstrip(), SUBSTR.lstrip())
     280        self.assertEqual(len(s), size)
     281        self.assertEqual(s.lstrip(), SUBSTR.lstrip())
    281282        del s
    282283        s = SUBSTR.ljust(size)
    283         self.assertEquals(len(s), size)
     284        self.assertEqual(len(s), size)
    284285        stripped = s.lstrip()
    285         self.failUnless(stripped is s)
     286        self.assertTrue(stripped is s)
    286287
    287288    @bigmemtest(minsize=_2G + 10, memuse=2)
    … …  
    290291        s = ' ' * size
    291292        s = s.replace(' ', replacement)
    292         self.assertEquals(len(s), size)
    293         self.assertEquals(s.count(replacement), size)
     293        self.assertEqual(len(s), size)
     294        self.assertEqual(s.count(replacement), size)
    294295        s = s.replace(replacement, ' ', size - 4)
    295         self.assertEquals(len(s), size)
    296         self.assertEquals(s.count(replacement), 4)
    297         self.assertEquals(s[-10:], '      aaaa')
     296        self.assertEqual(len(s), size)
     297        self.assertEqual(s.count(replacement), 4)
     298        self.assertEqual(s[-10:], '      aaaa')
    298299
    299300    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    302303        sublen = len(SUBSTR)
    303304        s = ''.join([SUBSTR, '-' * size, SUBSTR])
    304         self.assertEquals(s.rfind(' '), sublen + size + SUBSTR.rfind(' '))
    305         self.assertEquals(s.rfind(SUBSTR), sublen + size)
    306         self.assertEquals(s.rfind(' ', 0, size), SUBSTR.rfind(' '))
    307         self.assertEquals(s.rfind(SUBSTR, 0, sublen + size), 0)
    308         self.assertEquals(s.rfind('i'), sublen + size + SUBSTR.rfind('i'))
    309         self.assertEquals(s.rfind('i', 0, sublen), SUBSTR.rfind('i'))
    310         self.assertEquals(s.rfind('i', 0, sublen + size),
    311                           SUBSTR.rfind('i'))
    312         self.assertEquals(s.rfind('j'), -1)
     305        self.assertEqual(s.rfind(' '), sublen + size + SUBSTR.rfind(' '))
     306        self.assertEqual(s.rfind(SUBSTR), sublen + size)
     307        self.assertEqual(s.rfind(' ', 0, size), SUBSTR.rfind(' '))
     308        self.assertEqual(s.rfind(SUBSTR, 0, sublen + size), 0)
     309        self.assertEqual(s.rfind('i'), sublen + size + SUBSTR.rfind('i'))
     310        self.assertEqual(s.rfind('i', 0, sublen), SUBSTR.rfind('i'))
     311        self.assertEqual(s.rfind('i', 0, sublen + size),
     312                         SUBSTR.rfind('i'))
     313        self.assertEqual(s.rfind('j'), -1)
    313314
    314315    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    317318        sublen = len(SUBSTR)
    318319        s = ''.join([SUBSTR, '-' * size, SUBSTR])
    319         self.assertEquals(s.rindex(' '),
     320        self.assertEqual(s.rindex(' '),
    320321                          sublen + size + SUBSTR.rindex(' '))
    321         self.assertEquals(s.rindex(SUBSTR), sublen + size)
    322         self.assertEquals(s.rindex(' ', 0, sublen + size - 1),
    323                           SUBSTR.rindex(' '))
    324         self.assertEquals(s.rindex(SUBSTR, 0, sublen + size), 0)
    325         self.assertEquals(s.rindex('i'),
    326                           sublen + size + SUBSTR.rindex('i'))
    327         self.assertEquals(s.rindex('i', 0, sublen), SUBSTR.rindex('i'))
    328         self.assertEquals(s.rindex('i', 0, sublen + size),
    329                           SUBSTR.rindex('i'))
     322        self.assertEqual(s.rindex(SUBSTR), sublen + size)
     323        self.assertEqual(s.rindex(' ', 0, sublen + size - 1),
     324                         SUBSTR.rindex(' '))
     325        self.assertEqual(s.rindex(SUBSTR, 0, sublen + size), 0)
     326        self.assertEqual(s.rindex('i'),
     327                         sublen + size + SUBSTR.rindex('i'))
     328        self.assertEqual(s.rindex('i', 0, sublen), SUBSTR.rindex('i'))
     329        self.assertEqual(s.rindex('i', 0, sublen + size),
     330                         SUBSTR.rindex('i'))
    330331        self.assertRaises(ValueError, s.rindex, 'j')
    331332
    … …  
    334335        SUBSTR = ' abc def ghi'
    335336        s = SUBSTR.ljust(size)
    336         self.failUnless(s.startswith(SUBSTR + '  '))
    337         self.assertEquals(len(s), size)
    338         self.assertEquals(s.strip(), SUBSTR.strip())
     337        self.assertTrue(s.startswith(SUBSTR + '  '))
     338        self.assertEqual(len(s), size)
     339        self.assertEqual(s.strip(), SUBSTR.strip())
    339340
    340341    @bigmemtest(minsize=_2G + 10, memuse=1)
    … …  
    342343        SUBSTR = ' abc def ghi'
    343344        s = SUBSTR.ljust(size)
    344         self.assertEquals(len(s), size)
    345         self.assertEquals(s.rstrip(), SUBSTR.rstrip())
     345        self.assertEqual(len(s), size)
     346        self.assertEqual(s.rstrip(), SUBSTR.rstrip())
    346347        del s
    347348        s = SUBSTR.rjust(size)
    348         self.assertEquals(len(s), size)
     349        self.assertEqual(len(s), size)
    349350        stripped = s.rstrip()
    350         self.failUnless(stripped is s)
     351        self.assertTrue(stripped is s)
    351352
    352353    # The test takes about size bytes to build a string, and then about
    … …  
    361362        s = SUBSTR * chunksize
    362363        l = s.split()
    363         self.assertEquals(len(l), chunksize)
    364         self.assertEquals(set(l), set(['a']))
     364        self.assertEqual(len(l), chunksize)
     365        self.assertEqual(set(l), set(['a']))
    365366        del l
    366367        l = s.split('a')
    367         self.assertEquals(len(l), chunksize + 1)
    368         self.assertEquals(set(l), set(['', ' ' * chunksize]))
     368        self.assertEqual(len(l), chunksize + 1)
     369        self.assertEqual(set(l), set(['', ' ' * chunksize]))
    369370
    370371    # Allocates a string of twice size (and briefly two) and a list of
    … …  
    378379        s = ' a' * size + ' '
    379380        l = s.split()
    380         self.assertEquals(len(l), size)
    381         self.assertEquals(set(l), set(['a']))
     381        self.assertEqual(len(l), size)
     382        self.assertEqual(set(l), set(['a']))
    382383        del l
    383384        l = s.split('a')
    384         self.assertEquals(len(l), size + 1)
    385         self.assertEquals(set(l), set([' ']))
     385        self.assertEqual(len(l), size + 1)
     386        self.assertEqual(set(l), set([' ']))
    386387
    387388    @bigmemtest(minsize=_2G, memuse=2.1)
    … …  
    393394        s = SUBSTR * chunksize
    394395        l = s.splitlines()
    395         self.assertEquals(len(l), chunksize * 2)
    396         self.assertEquals(set(l), set([' ' * chunksize]))
     396        self.assertEqual(len(l), chunksize * 2)
     397        self.assertEqual(set(l), set([' ' * chunksize]))
    397398
    398399    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    400401        SUBSTR = ' abc def ghi'
    401402        s = '-' * size + SUBSTR
    402         self.failUnless(s.startswith(s))
    403         self.failUnless(s.startswith('-' * size))
    404         self.failIf(s.startswith(SUBSTR))
     403        self.assertTrue(s.startswith(s))
     404        self.assertTrue(s.startswith('-' * size))
     405        self.assertFalse(s.startswith(SUBSTR))
    405406
    406407    @bigmemtest(minsize=_2G, memuse=1)
    … …  
    408409        SUBSTR = '   abc def ghi   '
    409410        s = SUBSTR.rjust(size)
    410         self.assertEquals(len(s), size)
    411         self.assertEquals(s.strip(), SUBSTR.strip())
     411        self.assertEqual(len(s), size)
     412        self.assertEqual(s.strip(), SUBSTR.strip())
    412413        del s
    413414        s = SUBSTR.ljust(size)
    414         self.assertEquals(len(s), size)
    415         self.assertEquals(s.strip(), SUBSTR.strip())
     415        self.assertEqual(len(s), size)
     416        self.assertEqual(s.strip(), SUBSTR.strip())
    416417
    417418    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    422423        s = SUBSTR * repeats
    423424        s = s.swapcase()
    424         self.assertEquals(len(s), sublen * repeats)
    425         self.assertEquals(s[:sublen * 3], SUBSTR.swapcase() * 3)
    426         self.assertEquals(s[-sublen * 3:], SUBSTR.swapcase() * 3)
     425        self.assertEqual(len(s), sublen * repeats)
     426        self.assertEqual(s[:sublen * 3], SUBSTR.swapcase() * 3)
     427        self.assertEqual(s[-sublen * 3:], SUBSTR.swapcase() * 3)
    427428
    428429    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    431432        s = SUBSTR * (size // len(SUBSTR) + 2)
    432433        s = s.title()
    433         self.failUnless(s.startswith((SUBSTR * 3).title()))
    434         self.failUnless(s.endswith(SUBSTR.lower() * 3))
     434        self.assertTrue(s.startswith((SUBSTR * 3).title()))
     435        self.assertTrue(s.endswith(SUBSTR.lower() * 3))
    435436
    436437    @bigmemtest(minsize=_2G, memuse=2)
    … …  
    442443        s = SUBSTR * repeats
    443444        s = s.translate(trans)
    444         self.assertEquals(len(s), repeats * sublen)
    445         self.assertEquals(s[:sublen], SUBSTR.translate(trans))
    446         self.assertEquals(s[-sublen:], SUBSTR.translate(trans))
    447         self.assertEquals(s.count('.'), 0)
    448         self.assertEquals(s.count('!'), repeats * 2)
    449         self.assertEquals(s.count('z'), repeats * 3)
     445        self.assertEqual(len(s), repeats * sublen)
     446        self.assertEqual(s[:sublen], SUBSTR.translate(trans))
     447        self.assertEqual(s[-sublen:], SUBSTR.translate(trans))
     448        self.assertEqual(s.count('.'), 0)
     449        self.assertEqual(s.count('!'), repeats * 2)
     450        self.assertEqual(s.count('z'), repeats * 3)
    450451
    451452    @bigmemtest(minsize=_2G + 5, memuse=2)
    … …  
    453454        s = 'a' * size
    454455        s = s.upper()
    455         self.assertEquals(len(s), size)
    456         self.assertEquals(s.count('A'), size)
     456        self.assertEqual(len(s), size)
     457        self.assertEqual(s.count('A'), size)
    457458
    458459    @bigmemtest(minsize=_2G + 20, memuse=1)
    … …  
    460461        SUBSTR = '-568324723598234'
    461462        s = SUBSTR.zfill(size)
    462         self.failUnless(s.endswith('0' + SUBSTR[1:]))
    463         self.failUnless(s.startswith('-0'))
    464         self.assertEquals(len(s), size)
    465         self.assertEquals(s.count('0'), size - len(SUBSTR))
     463        self.assertTrue(s.endswith('0' + SUBSTR[1:]))
     464        self.assertTrue(s.startswith('-0'))
     465        self.assertEqual(len(s), size)
     466        self.assertEqual(s.count('0'), size - len(SUBSTR))
    466467
    467468    @bigmemtest(minsize=_2G + 10, memuse=2)
    … …  
    469470        s = '-' * size
    470471        sf = '%s' % (s,)
    471         self.failUnless(s == sf)
     472        self.assertTrue(s == sf)
    472473        del sf
    473474        sf = '..%s..' % (s,)
    474         self.assertEquals(len(sf), len(s) + 4)
    475         self.failUnless(sf.startswith('..-'))
    476         self.failUnless(sf.endswith('-..'))
     475        self.assertEqual(len(sf), len(s) + 4)
     476        self.assertTrue(sf.startswith('..-'))
     477        self.assertTrue(sf.endswith('-..'))
    477478        del s, sf
    478479
    … …  
    482483        del edge
    483484        s = s % '...'
    484         self.assertEquals(len(s), size * 2 + 3)
    485         self.assertEquals(s.count('.'), 3)
    486         self.assertEquals(s.count('-'), size * 2)
    487 
    488     @bigmemtest(minsize=_2G + 10, memuse=2)
     485        self.assertEqual(len(s), size * 2 + 3)
     486        self.assertEqual(s.count('.'), 3)
     487        self.assertEqual(s.count('-'), size * 2)
     488
     489    @bigmemtest(minsize=_2G + 10, memuse=5)
    489490    def test_repr_small(self, size):
    490491        s = '-' * size
    491492        s = repr(s)
    492         self.assertEquals(len(s), size + 2)
    493         self.assertEquals(s[0], "'")
    494         self.assertEquals(s[-1], "'")
    495         self.assertEquals(s.count('-'), size)
     493        self.assertEqual(len(s), size + 2)
     494        self.assertEqual(s[0], "'")
     495        self.assertEqual(s[-1], "'")
     496        self.assertEqual(s.count('-'), size)
    496497        del s
    497498        # repr() will create a string four times as large as this 'binary
    498499        # string', but we don't want to allocate much more than twice
    499500        # size in total.  (We do extra testing in test_repr_large())
    500         size = size // 5 * 2
    501501        s = '\x00' * size
    502502        s = repr(s)
    503         self.assertEquals(len(s), size * 4 + 2)
    504         self.assertEquals(s[0], "'")
    505         self.assertEquals(s[-1], "'")
    506         self.assertEquals(s.count('\\'), size)
    507         self.assertEquals(s.count('0'), size * 2)
     503        self.assertEqual(len(s), size * 4 + 2)
     504        self.assertEqual(s[0], "'")
     505        self.assertEqual(s[-1], "'")
     506        self.assertEqual(s.count('\\'), size)
     507        self.assertEqual(s.count('0'), size * 2)
    508508
    509509    @bigmemtest(minsize=_2G + 10, memuse=5)
    … …  
    511511        s = '\x00' * size
    512512        s = repr(s)
    513         self.assertEquals(len(s), size * 4 + 2)
    514         self.assertEquals(s[0], "'")
    515         self.assertEquals(s[-1], "'")
    516         self.assertEquals(s.count('\\'), size)
    517         self.assertEquals(s.count('0'), size * 2)
    518 
    519     @bigmemtest(minsize=2**32 / 5, memuse=6+2)
     513        self.assertEqual(len(s), size * 4 + 2)
     514        self.assertEqual(s[0], "'")
     515        self.assertEqual(s[-1], "'")
     516        self.assertEqual(s.count('\\'), size)
     517        self.assertEqual(s.count('0'), size * 2)
     518
     519    @bigmemtest(minsize=2**32 // 5, memuse=6+2)
    520520    def test_unicode_repr(self, size):
    521521        s = u"\uAAAA" * size
    522         self.failUnless(len(repr(s)) > size)
     522        self.assertTrue(len(repr(s)) > size)
    523523
    524524    # This test is meaningful even with size < 2G, as long as the
    … …  
    527527    def test_concat(self, size):
    528528        s = '.' * size
    529         self.assertEquals(len(s), size)
     529        self.assertEqual(len(s), size)
    530530        s = s + s
    531         self.assertEquals(len(s), size * 2)
    532         self.assertEquals(s.count('.'), size * 2)
     531        self.assertEqual(len(s), size * 2)
     532        self.assertEqual(s.count('.'), size * 2)
    533533
    534534    # This test is meaningful even with size < 2G, as long as the
    … …  
    537537    def test_repeat(self, size):
    538538        s = '.' * size
    539         self.assertEquals(len(s), size)
     539        self.assertEqual(len(s), size)
    540540        s = s * 2
    541         self.assertEquals(len(s), size * 2)
    542         self.assertEquals(s.count('.'), size * 2)
    543 
    544     @bigmemtest(minsize=_2G + 20, memuse=1)
     541        self.assertEqual(len(s), size * 2)
     542        self.assertEqual(s.count('.'), size * 2)
     543
     544    @bigmemtest(minsize=_2G + 20, memuse=2)
    545545    def test_slice_and_getitem(self, size):
    546546        SUBSTR = '0123456789'
    … …  
    550550        stepsize = stepsize - (stepsize % sublen)
    551551        for i in range(0, len(s) - stepsize, stepsize):
    552             self.assertEquals(s[i], SUBSTR[0])
    553             self.assertEquals(s[i:i + sublen], SUBSTR)
    554             self.assertEquals(s[i:i + sublen:2], SUBSTR[::2])
     552            self.assertEqual(s[i], SUBSTR[0])
     553            self.assertEqual(s[i:i + sublen], SUBSTR)
     554            self.assertEqual(s[i:i + sublen:2], SUBSTR[::2])
    555555            if i > 0:
    556                 self.assertEquals(s[i + sublen - 1:i - 1:-3],
    557                                   SUBSTR[sublen::-3])
     556                self.assertEqual(s[i + sublen - 1:i - 1:-3],
     557                                 SUBSTR[sublen::-3])
    558558        # Make sure we do some slicing and indexing near the end of the
    559559        # string, too.
    560         self.assertEquals(s[len(s) - 1], SUBSTR[-1])
    561         self.assertEquals(s[-1], SUBSTR[-1])
    562         self.assertEquals(s[len(s) - 10], SUBSTR[0])
    563         self.assertEquals(s[-sublen], SUBSTR[0])
    564         self.assertEquals(s[len(s):], '')
    565         self.assertEquals(s[len(s) - 1:], SUBSTR[-1])
    566         self.assertEquals(s[-1:], SUBSTR[-1])
    567         self.assertEquals(s[len(s) - sublen:], SUBSTR)
    568         self.assertEquals(s[-sublen:], SUBSTR)
    569         self.assertEquals(len(s[:]), len(s))
    570         self.assertEquals(len(s[:len(s) - 5]), len(s) - 5)
    571         self.assertEquals(len(s[5:-5]), len(s) - 10)
     560        self.assertEqual(s[len(s) - 1], SUBSTR[-1])
     561        self.assertEqual(s[-1], SUBSTR[-1])
     562        self.assertEqual(s[len(s) - 10], SUBSTR[0])
     563        self.assertEqual(s[-sublen], SUBSTR[0])
     564        self.assertEqual(s[len(s):], '')
     565        self.assertEqual(s[len(s) - 1:], SUBSTR[-1])
     566        self.assertEqual(s[-1:], SUBSTR[-1])
     567        self.assertEqual(s[len(s) - sublen:], SUBSTR)
     568        self.assertEqual(s[-sublen:], SUBSTR)
     569        self.assertEqual(len(s[:]), len(s))
     570        self.assertEqual(len(s[:len(s) - 5]), len(s) - 5)
     571        self.assertEqual(len(s[5:-5]), len(s) - 10)
    572572
    573573        self.assertRaises(IndexError, operator.getitem, s, len(s))
    … …  
    581581        s = ''.join([edge, SUBSTR, edge])
    582582        del edge
    583         self.failUnless(SUBSTR in s)
    584         self.failIf(SUBSTR * 2 in s)
    585         self.failUnless('-' in s)
    586         self.failIf('a' in s)
     583        self.assertIn(SUBSTR, s)
     584        self.assertNotIn(SUBSTR * 2, s)
     585        self.assertIn('-', s)
     586        self.assertNotIn('a', s)
    587587        s += 'a'
    588         self.failUnless('a' in s)
     588        self.assertIn('a', s)
    589589
    590590    @bigmemtest(minsize=_2G + 10, memuse=2)
    … …  
    592592        s1 = '-' * size
    593593        s2 = '-' * size
    594         self.failUnless(s1 == s2)
     594        self.assertTrue(s1 == s2)
    595595        del s2
    596596        s2 = s1 + 'a'
    597         self.failIf(s1 == s2)
     597        self.assertFalse(s1 == s2)
    598598        del s2
    599599        s2 = '.' * size
    600         self.failIf(s1 == s2)
     600        self.assertFalse(s1 == s2)
    601601
    602602    @bigmemtest(minsize=_2G + 10, memuse=1)
    … …  
    612612        del s
    613613        s = '\x00' * (size + 1)
    614         self.failIf(h1 == hash(s))
     614        self.assertFalse(h1 == hash(s))
    615615
    616616class TupleTest(unittest.TestCase):
    … …  
    629629        t1 = (u'',) * size
    630630        t2 = (u'',) * size
    631         self.failUnless(t1 == t2)
     631        self.assertTrue(t1 == t2)
    632632        del t2
    633633        t2 = (u'',) * (size + 1)
    634         self.failIf(t1 == t2)
     634        self.assertFalse(t1 == t2)
    635635        del t2
    636636        t2 = (1,) * size
    637         self.failIf(t1 == t2)
     637        self.assertFalse(t1 == t2)
    638638
    639639    # Test concatenating into a single tuple of more than 2G in length,
    … …  
    644644    def basic_concat_test(self, size):
    645645        t = ((),) * size
    646         self.assertEquals(len(t), size)
     646        self.assertEqual(len(t), size)
    647647        t = t + t
    648         self.assertEquals(len(t), size * 2)
     648        self.assertEqual(len(t), size * 2)
    649649
    650650    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
    … …  
    659659    def test_contains(self, size):
    660660        t = (1, 2, 3, 4, 5) * size
    661         self.assertEquals(len(t), size * 5)
    662         self.failUnless(5 in t)
    663         self.failIf((1, 2, 3, 4, 5) in t)
    664         self.failIf(0 in t)
     661        self.assertEqual(len(t), size * 5)
     662        self.assertIn(5, t)
     663        self.assertNotIn((1, 2, 3, 4, 5), t)
     664        self.assertNotIn(0, t)
    665665
    666666    @bigmemtest(minsize=_2G + 10, memuse=8)
    … …  
    670670        del t1
    671671        t2 = (0,) * (size + 1)
    672         self.failIf(h1 == hash(t2))
     672        self.assertFalse(h1 == hash(t2))
    673673
    674674    @bigmemtest(minsize=_2G + 10, memuse=8)
    675675    def test_index_and_slice(self, size):
    676676        t = (None,) * size
    677         self.assertEquals(len(t), size)
    678         self.assertEquals(t[-1], None)
    679         self.assertEquals(t[5], None)
    680         self.assertEquals(t[size - 1], None)
     677        self.assertEqual(len(t), size)
     678        self.assertEqual(t[-1], None)
     679        self.assertEqual(t[5], None)
     680        self.assertEqual(t[size - 1], None)
    681681        self.assertRaises(IndexError, operator.getitem, t, size)
    682         self.assertEquals(t[:5], (None,) * 5)
    683         self.assertEquals(t[-5:], (None,) * 5)
    684         self.assertEquals(t[20:25], (None,) * 5)
    685         self.assertEquals(t[-25:-20], (None,) * 5)
    686         self.assertEquals(t[size - 5:], (None,) * 5)
    687         self.assertEquals(t[size - 5:size], (None,) * 5)
    688         self.assertEquals(t[size - 6:size - 2], (None,) * 4)
    689         self.assertEquals(t[size:size], ())
    690         self.assertEquals(t[size:size+5], ())
     682        self.assertEqual(t[:5], (None,) * 5)
     683        self.assertEqual(t[-5:], (None,) * 5)
     684        self.assertEqual(t[20:25], (None,) * 5)
     685        self.assertEqual(t[-25:-20], (None,) * 5)
     686        self.assertEqual(t[size - 5:], (None,) * 5)
     687        self.assertEqual(t[size - 5:size], (None,) * 5)
     688        self.assertEqual(t[size - 6:size - 2], (None,) * 4)
     689        self.assertEqual(t[size:size], ())
     690        self.assertEqual(t[size:size+5], ())
    691691
    692692    # Like test_concat, split in two.
    693693    def basic_test_repeat(self, size):
    694694        t = ('',) * size
    695         self.assertEquals(len(t), size)
     695        self.assertEqual(len(t), size)
    696696        t = t * 2
    697         self.assertEquals(len(t), size * 2)
     697        self.assertEqual(len(t), size * 2)
    698698
    699699    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
    … …  
    718718            count = 0
    719719            for item in t:
    720                 self.assertEquals(item, count)
     720                self.assertEqual(item, count)
    721721                count += 1
    722             self.assertEquals(count, size)
     722            self.assertEqual(count, size)
    723723
    724724    @precisionbigmemtest(size=_1G - 25, memuse=9)
    … …  
    728728            count = 0
    729729            for item in t:
    730                 self.assertEquals(item, count)
     730                self.assertEqual(item, count)
    731731                count += 1
    732             self.assertEquals(count, size)
     732            self.assertEqual(count, size)
    733733        except MemoryError:
    734734            pass # acceptable, expected on 32-bit
    … …  
    739739        s = repr(t)
    740740        # The repr of a tuple of 0's is exactly three times the tuple length.
    741         self.assertEquals(len(s), size * 3)
    742         self.assertEquals(s[:5], '(0, 0')
    743         self.assertEquals(s[-5:], '0, 0)')
    744         self.assertEquals(s.count('0'), size)
     741        self.assertEqual(len(s), size * 3)
     742        self.assertEqual(s[:5], '(0, 0')
     743        self.assertEqual(s[-5:], '0, 0)')
     744        self.assertEqual(s.count('0'), size)
    745745
    746746    @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3)
    … …  
    763763        l1 = [u''] * size
    764764        l2 = [u''] * size
    765         self.failUnless(l1 == l2)
     765        self.assertTrue(l1 == l2)
    766766        del l2
    767767        l2 = [u''] * (size + 1)
    768         self.failIf(l1 == l2)
     768        self.assertFalse(l1 == l2)
    769769        del l2
    770770        l2 = [2] * size
    771         self.failIf(l1 == l2)
     771        self.assertFalse(l1 == l2)
    772772
    773773    # Test concatenating into a single list of more than 2G in length,
    … …  
    778778    def basic_test_concat(self, size):
    779779        l = [[]] * size
    780         self.assertEquals(len(l), size)
     780        self.assertEqual(len(l), size)
    781781        l = l + l
    782         self.assertEquals(len(l), size * 2)
     782        self.assertEqual(len(l), size * 2)
    783783
    784784    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
    … …  
    793793        l = [sys.stdout] * size
    794794        l += l
    795         self.assertEquals(len(l), size * 2)
    796         self.failUnless(l[0] is l[-1])
    797         self.failUnless(l[size - 1] is l[size + 1])
     795        self.assertEqual(len(l), size * 2)
     796        self.assertTrue(l[0] is l[-1])
     797        self.assertTrue(l[size - 1] is l[size + 1])
    798798
    799799    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
    … …  
    808808    def test_contains(self, size):
    809809        l = [1, 2, 3, 4, 5] * size
    810         self.assertEquals(len(l), size * 5)
    811         self.failUnless(5 in l)
    812         self.failIf([1, 2, 3, 4, 5] in l)
    813         self.failIf(0 in l)
     810        self.assertEqual(len(l), size * 5)
     811        self.assertIn(5, l)
     812        self.assertNotIn([1, 2, 3, 4, 5], l)
     813        self.assertNotIn(0, l)
    814814
    815815    @bigmemtest(minsize=_2G + 10, memuse=8)
    816816    def test_hash(self, size):
    817817        l = [0] * size
    818         self.failUnlessRaises(TypeError, hash, l)
     818        self.assertRaises(TypeError, hash, l)
    819819
    820820    @bigmemtest(minsize=_2G + 10, memuse=8)
    821821    def test_index_and_slice(self, size):
    822822        l = [None] * size
    823         self.assertEquals(len(l), size)
    824         self.assertEquals(l[-1], None)
    825         self.assertEquals(l[5], None)
    826         self.assertEquals(l[size - 1], None)
     823        self.assertEqual(len(l), size)
     824        self.assertEqual(l[-1], None)
     825        self.assertEqual(l[5], None)
     826        self.assertEqual(l[size - 1], None)
    827827        self.assertRaises(IndexError, operator.getitem, l, size)
    828         self.assertEquals(l[:5], [None] * 5)
    829         self.assertEquals(l[-5:], [None] * 5)
    830         self.assertEquals(l[20:25], [None] * 5)
    831         self.assertEquals(l[-25:-20], [None] * 5)
    832         self.assertEquals(l[size - 5:], [None] * 5)
    833         self.assertEquals(l[size - 5:size], [None] * 5)
    834         self.assertEquals(l[size - 6:size - 2], [None] * 4)
    835         self.assertEquals(l[size:size], [])
    836         self.assertEquals(l[size:size+5], [])
     828        self.assertEqual(l[:5], [None] * 5)
     829        self.assertEqual(l[-5:], [None] * 5)
     830        self.assertEqual(l[20:25], [None] * 5)
     831        self.assertEqual(l[-25:-20], [None] * 5)
     832        self.assertEqual(l[size - 5:], [None] * 5)
     833        self.assertEqual(l[size - 5:size], [None] * 5)
     834        self.assertEqual(l[size - 6:size - 2], [None] * 4)
     835        self.assertEqual(l[size:size], [])
     836        self.assertEqual(l[size:size+5], [])
    837837
    838838        l[size - 2] = 5
    839         self.assertEquals(len(l), size)
    840         self.assertEquals(l[-3:], [None, 5, None])
    841         self.assertEquals(l.count(5), 1)
     839        self.assertEqual(len(l), size)
     840        self.assertEqual(l[-3:], [None, 5, None])
     841        self.assertEqual(l.count(5), 1)
    842842        self.assertRaises(IndexError, operator.setitem, l, size, 6)
    843         self.assertEquals(len(l), size)
     843        self.assertEqual(len(l), size)
    844844
    845845        l[size - 7:] = [1, 2, 3, 4, 5]
    846846        size -= 2
    847         self.assertEquals(len(l), size)
    848         self.assertEquals(l[-7:], [None, None, 1, 2, 3, 4, 5])
     847        self.assertEqual(len(l), size)
     848        self.assertEqual(l[-7:], [None, None, 1, 2, 3, 4, 5])
    849849
    850850        l[:7] = [1, 2, 3, 4, 5]
    851851        size -= 2
    852         self.assertEquals(len(l), size)
    853         self.assertEquals(l[:7], [1, 2, 3, 4, 5, None, None])
     852        self.assertEqual(len(l), size)
     853        self.assertEqual(l[:7], [1, 2, 3, 4, 5, None, None])
    854854
    855855        del l[size - 1]
    856856        size -= 1
    857         self.assertEquals(len(l), size)
    858         self.assertEquals(l[-1], 4)
     857        self.assertEqual(len(l), size)
     858        self.assertEqual(l[-1], 4)
    859859
    860860        del l[-2:]
    861861        size -= 2
    862         self.assertEquals(len(l), size)
    863         self.assertEquals(l[-1], 2)
     862        self.assertEqual(len(l), size)
     863        self.assertEqual(l[-1], 2)
    864864
    865865        del l[0]
    866866        size -= 1
    867         self.assertEquals(len(l), size)
    868         self.assertEquals(l[0], 2)
     867        self.assertEqual(len(l), size)
     868        self.assertEqual(l[0], 2)
    869869
    870870        del l[:2]
    871871        size -= 2
    872         self.assertEquals(len(l), size)
    873         self.assertEquals(l[0], 4)
     872        self.assertEqual(len(l), size)
     873        self.assertEqual(l[0], 4)
    874874
    875875    # Like test_concat, split in two.
    876876    def basic_test_repeat(self, size):
    877877        l = [] * size
    878         self.failIf(l)
     878        self.assertFalse(l)
    879879        l = [''] * size
    880         self.assertEquals(len(l), size)
     880        self.assertEqual(len(l), size)
    881881        l = l * 2
    882         self.assertEquals(len(l), size * 2)
     882        self.assertEqual(len(l), size * 2)
    883883
    884884    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
    … …  
    893893        l = ['']
    894894        l *= size
    895         self.assertEquals(len(l), size)
    896         self.failUnless(l[0] is l[-1])
     895        self.assertEqual(len(l), size)
     896        self.assertTrue(l[0] is l[-1])
    897897        del l
    898898
    899899        l = [''] * size
    900900        l *= 2
    901         self.assertEquals(len(l), size * 2)
    902         self.failUnless(l[size - 1] is l[-1])
     901        self.assertEqual(len(l), size * 2)
     902        self.assertTrue(l[size - 1] is l[-1])
    903903
    904904    @bigmemtest(minsize=_2G // 2 + 2, memuse=16)
    … …  
    914914        s = repr(l)
    915915        # The repr of a list of 0's is exactly three times the list length.
    916         self.assertEquals(len(s), size * 3)
    917         self.assertEquals(s[:5], '[0, 0')
    918         self.assertEquals(s[-5:], '0, 0]')
    919         self.assertEquals(s.count('0'), size)
     916        self.assertEqual(len(s), size * 3)
     917        self.assertEqual(s[:5], '[0, 0')
     918        self.assertEqual(s[-5:], '0, 0]')
     919        self.assertEqual(s.count('0'), size)
    920920
    921921    @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3)
    … …  
    933933        l = [object()] * size
    934934        l.append(object())
    935         self.assertEquals(len(l), size+1)
    936         self.failUnless(l[-3] is l[-2])
    937         self.failIf(l[-2] is l[-1])
     935        self.assertEqual(len(l), size+1)
     936        self.assertTrue(l[-3] is l[-2])
     937        self.assertFalse(l[-2] is l[-1])
    938938
    939939    @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
    940940    def test_count(self, size):
    941941        l = [1, 2, 3, 4, 5] * size
    942         self.assertEquals(l.count(1), size)
    943         self.assertEquals(l.count("1"), 0)
     942        self.assertEqual(l.count(1), size)
     943        self.assertEqual(l.count("1"), 0)
    944944
    945945    def basic_test_extend(self, size):
    946946        l = [file] * size
    947947        l.extend(l)
    948         self.assertEquals(len(l), size * 2)
    949         self.failUnless(l[0] is l[-1])
    950         self.failUnless(l[size - 1] is l[size + 1])
     948        self.assertEqual(len(l), size * 2)
     949        self.assertTrue(l[0] is l[-1])
     950        self.assertTrue(l[size - 1] is l[size + 1])
    951951
    952952    @bigmemtest(minsize=_2G // 2 + 2, memuse=16)
    … …  
    962962        l = [1L, 2L, 3L, 4L, 5L] * size
    963963        size *= 5
    964         self.assertEquals(l.index(1), 0)
    965         self.assertEquals(l.index(5, size - 5), size - 1)
    966         self.assertEquals(l.index(5, size - 5, size), size - 1)
     964        self.assertEqual(l.index(1), 0)
     965        self.assertEqual(l.index(5, size - 5), size - 1)
     966        self.assertEqual(l.index(5, size - 5, size), size - 1)
    967967        self.assertRaises(ValueError, l.index, 1, size - 4, size)
    968968        self.assertRaises(ValueError, l.index, 6L)
    … …  
    974974        l.insert(size - 1, "A")
    975975        size += 1
    976         self.assertEquals(len(l), size)
    977         self.assertEquals(l[-3:], [1.0, "A", 1.0])
     976        self.assertEqual(len(l), size)
     977        self.assertEqual(l[-3:], [1.0, "A", 1.0])
    978978
    979979        l.insert(size + 1, "B")
    980980        size += 1
    981         self.assertEquals(len(l), size)
    982         self.assertEquals(l[-3:], ["A", 1.0, "B"])
     981        self.assertEqual(len(l), size)
     982        self.assertEqual(l[-3:], ["A", 1.0, "B"])
    983983
    984984        l.insert(1, "C")
    985985        size += 1
    986         self.assertEquals(len(l), size)
    987         self.assertEquals(l[:3], [1.0, "C", 1.0])
    988         self.assertEquals(l[size - 3:], ["A", 1.0, "B"])
     986        self.assertEqual(len(l), size)
     987        self.assertEqual(l[:3], [1.0, "C", 1.0])
     988        self.assertEqual(l[size - 3:], ["A", 1.0, "B"])
    989989
    990990    @bigmemtest(minsize=_2G // 5 + 4, memuse=8 * 5)
    … …  
    992992        l = [u"a", u"b", u"c", u"d", u"e"] * size
    993993        size *= 5
    994         self.assertEquals(len(l), size)
     994        self.assertEqual(len(l), size)
    995995
    996996        item = l.pop()
    997997        size -= 1
    998         self.assertEquals(len(l), size)
    999         self.assertEquals(item, u"e")
    1000         self.assertEquals(l[-2:], [u"c", u"d"])
     998        self.assertEqual(len(l), size)
     999        self.assertEqual(item, u"e")
     1000        self.assertEqual(l[-2:], [u"c", u"d"])
    10011001
    10021002        item = l.pop(0)
    10031003        size -= 1
    1004         self.assertEquals(len(l), size)
    1005         self.assertEquals(item, u"a")
    1006         self.assertEquals(l[:2], [u"b", u"c"])
     1004        self.assertEqual(len(l), size)
     1005        self.assertEqual(item, u"a")
     1006        self.assertEqual(l[:2], [u"b", u"c"])
    10071007
    10081008        item = l.pop(size - 2)
    10091009        size -= 1
    1010         self.assertEquals(len(l), size)
    1011         self.assertEquals(item, u"c")
    1012         self.assertEquals(l[-2:], [u"b", u"d"])
     1010        self.assertEqual(len(l), size)
     1011        self.assertEqual(item, u"c")
     1012        self.assertEqual(l[-2:], [u"b", u"d"])
    10131013
    10141014    @bigmemtest(minsize=_2G + 10, memuse=8)
    10151015    def test_remove(self, size):
    10161016        l = [10] * size
    1017         self.assertEquals(len(l), size)
     1017        self.assertEqual(len(l), size)
    10181018
    10191019        l.remove(10)
    10201020        size -= 1
    1021         self.assertEquals(len(l), size)
     1021        self.assertEqual(len(l), size)
    10221022
    10231023        # Because of the earlier l.remove(), this append doesn't trigger
    … …  
    10251025        l.append(5)
    10261026        size += 1
    1027         self.assertEquals(len(l), size)
    1028         self.assertEquals(l[-2:], [10, 5])
     1027        self.assertEqual(len(l), size)
     1028        self.assertEqual(l[-2:], [10, 5])
    10291029        l.remove(5)
    10301030        size -= 1
    1031         self.assertEquals(len(l), size)
    1032         self.assertEquals(l[-2:], [10, 10])
     1031        self.assertEqual(len(l), size)
     1032        self.assertEqual(l[-2:], [10, 10])
    10331033
    10341034    @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
    … …  
    10361036        l = [1, 2, 3, 4, 5] * size
    10371037        l.reverse()
    1038         self.assertEquals(len(l), size * 5)
    1039         self.assertEquals(l[-5:], [5, 4, 3, 2, 1])
    1040         self.assertEquals(l[:5], [5, 4, 3, 2, 1])
     1038        self.assertEqual(len(l), size * 5)
     1039        self.assertEqual(l[-5:], [5, 4, 3, 2, 1])
     1040        self.assertEqual(l[:5], [5, 4, 3, 2, 1])
    10411041
    10421042    @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
    … …  
    10441044        l = [1, 2, 3, 4, 5] * size
    10451045        l.sort()
    1046         self.assertEquals(len(l), size * 5)
    1047         self.assertEquals(l.count(1), size)
    1048         self.assertEquals(l[:10], [1] * 10)
    1049         self.assertEquals(l[-10:], [5] * 10)
     1046        self.assertEqual(len(l), size * 5)
     1047        self.assertEqual(l.count(1), size)
     1048        self.assertEqual(l[:10], [1] * 10)
     1049        self.assertEqual(l[-10:], [5] * 10)
    10501050
    10511051class BufferTest(unittest.TestCase):
    … …  
    10541054    def test_repeat(self, size):
    10551055        try:
    1056             b = buffer("AAAA")*size
     1056            with test_support.check_py3k_warnings():
     1057                b = buffer("AAAA")*size
    10571058        except MemoryError:
    10581059            pass # acceptable on 32-bit
    … …  
    10601061            count = 0
    10611062            for c in b:
    1062                 self.assertEquals(c, 'A')
     1063                self.assertEqual(c, 'A')
    10631064                count += 1
    1064             self.assertEquals(count, size*4)
     1065            self.assertEqual(count, size*4)
    10651066
    10661067def test_main():
Note: See TracChangeset for help on using the changeset viewer.