diff options
Diffstat (limited to 'Lib/test/test_bigmem.py')
| -rw-r--r-- | Lib/test/test_bigmem.py | 917 |
1 files changed, 514 insertions, 403 deletions
diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py index c41c3730631..f3c6ebbf05f 100644 --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@ -1,10 +1,10 @@ -from test import test_support -from test.test_support import bigmemtest, _1G, _2G, _4G, precisionbigmemtest +from test import support +from test.support import bigmemtest, _1G, _2G, _4G import unittest import operator -import string import sys +import functools # Bigmem testing houserules: # @@ -14,7 +14,7 @@ import sys # value has been created. Use 'del s' before the create_largestring call. # # - Do *not* compare large objects using assertEqual or similar. It's a -# lengty operation and the errormessage will be utterly useless due to +# lengthy operation and the errormessage will be utterly useless due to # its size. To make sure whether a result has the right contents, better # to use the strip or count methods, or compare meaningful slices. # @@ -25,27 +25,36 @@ import sys # a large object, make the subobject of a length that is not a power of # 2. That way, int-wrapping problems are more easily detected. # -# - While the bigmemtest decorator speaks of 'minsize', all tests will -# actually be called with a much smaller number too, in the normal -# test run (5Kb currently.) This is so the tests themselves get frequent -# testing. Consequently, always make all large allocations based on the +# - Despite the bigmemtest decorator, all tests will actually be called +# with a much smaller number too, in the normal test run (5Kb currently.) +# This is so the tests themselves get frequent testing. +# Consequently, always make all large allocations based on the # passed-in 'size', and don't rely on the size being very large. Also, # memuse-per-size should remain sane (less than a few thousand); if your # test uses more, adjust 'size' upward, instead. -class StrTest(unittest.TestCase): - @bigmemtest(minsize=_2G, memuse=2) +# BEWARE: it seems that one failing test can yield other subsequent tests to +# fail as well. I do not know whether it is due to memory fragmentation +# issues, or other specifics of the platform malloc() routine. + +character_size = 4 if sys.maxunicode > 0xFFFF else 2 + + +class BaseStrTest: + + @bigmemtest(size=_2G, memuse=2) def test_capitalize(self, size): - SUBSTR = ' abc def ghi' - s = '-' * size + SUBSTR + _ = self.from_latin1 + SUBSTR = self.from_latin1(' abc def ghi') + s = _('-') * size + SUBSTR caps = s.capitalize() self.assertEqual(caps[-len(SUBSTR):], SUBSTR.capitalize()) - self.assertEqual(caps.lstrip('-'), SUBSTR) + self.assertEqual(caps.lstrip(_('-')), SUBSTR) - @bigmemtest(minsize=_2G + 10, memuse=1) + @bigmemtest(size=_2G + 10, memuse=1) def test_center(self, size): - SUBSTR = ' abc def ghi' + SUBSTR = self.from_latin1(' abc def ghi') s = SUBSTR.center(size) self.assertEqual(len(s), size) lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2 @@ -54,319 +63,283 @@ class StrTest(unittest.TestCase): self.assertEqual(s[lpadsize:-rpadsize], SUBSTR) self.assertEqual(s.strip(), SUBSTR.strip()) - @precisionbigmemtest(size=_2G - 1, memuse=1) - def test_center_unicode(self, size): - SUBSTR = u' abc def ghi' - try: - s = SUBSTR.center(size) - except OverflowError: - pass # acceptable on 32-bit - else: - self.assertEqual(len(s), size) - lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2 - if len(s) % 2: - lpadsize += 1 - self.assertEqual(s[lpadsize:-rpadsize], SUBSTR) - self.assertEqual(s.strip(), SUBSTR.strip()) - del s - - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_count(self, size): - SUBSTR = ' abc def ghi' - s = '.' * size + SUBSTR - self.assertEqual(s.count('.'), size) - s += '.' - self.assertEqual(s.count('.'), size + 1) - self.assertEqual(s.count(' '), 3) - self.assertEqual(s.count('i'), 1) - self.assertEqual(s.count('j'), 0) - - @bigmemtest(minsize=_2G + 2, memuse=3) - def test_decode(self, size): - s = '.' * size - self.assertEqual(len(s.decode('utf-8')), size) - - def basic_encode_test(self, size, enc, c=u'.', expectedsize=None): - if expectedsize is None: - expectedsize = size - - s = c * size - self.assertEqual(len(s.encode(enc)), expectedsize) - - @bigmemtest(minsize=_2G + 2, memuse=3) - def test_encode(self, size): - return self.basic_encode_test(size, 'utf-8') - - @precisionbigmemtest(size=_4G // 6 + 2, memuse=2) - def test_encode_raw_unicode_escape(self, size): - try: - return self.basic_encode_test(size, 'raw_unicode_escape') - except MemoryError: - pass # acceptable on 32-bit - - @precisionbigmemtest(size=_4G // 5 + 70, memuse=3) - def test_encode_utf7(self, size): - try: - return self.basic_encode_test(size, 'utf7') - except MemoryError: - pass # acceptable on 32-bit - - @precisionbigmemtest(size=_4G // 4 + 5, memuse=6) - def test_encode_utf32(self, size): - try: - return self.basic_encode_test(size, 'utf32', expectedsize=4*size+4) - except MemoryError: - pass # acceptable on 32-bit - - @precisionbigmemtest(size=_2G-1, memuse=4) - def test_decodeascii(self, size): - return self.basic_encode_test(size, 'ascii', c='A') - - @precisionbigmemtest(size=_4G // 5, memuse=6+2) - def test_unicode_repr_oflw(self, size): - self.skipTest("test crashes - see issue #14904") - try: - s = u"\uAAAA"*size - r = repr(s) - except MemoryError: - pass # acceptable on 32-bit - else: - self.assertTrue(s == eval(r)) - - @bigmemtest(minsize=_2G, memuse=2) + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') + s = _('.') * size + SUBSTR + self.assertEqual(s.count(_('.')), size) + s += _('.') + self.assertEqual(s.count(_('.')), size + 1) + self.assertEqual(s.count(_(' ')), 3) + self.assertEqual(s.count(_('i')), 1) + self.assertEqual(s.count(_('j')), 0) + + @bigmemtest(size=_2G, memuse=2) def test_endswith(self, size): - SUBSTR = ' abc def ghi' - s = '-' * size + SUBSTR + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') + s = _('-') * size + SUBSTR self.assertTrue(s.endswith(SUBSTR)) self.assertTrue(s.endswith(s)) - s2 = '...' + s + s2 = _('...') + s self.assertTrue(s2.endswith(s)) - self.assertFalse(s.endswith('a' + SUBSTR)) + self.assertFalse(s.endswith(_('a') + SUBSTR)) self.assertFalse(SUBSTR.endswith(s)) - @bigmemtest(minsize=_2G + 10, memuse=2) + @bigmemtest(size=_2G + 10, memuse=2) def test_expandtabs(self, size): - s = '-' * size + _ = self.from_latin1 + s = _('-') * size tabsize = 8 self.assertEqual(s.expandtabs(), s) del s slen, remainder = divmod(size, tabsize) - s = ' \t' * slen + s = _(' \t') * slen s = s.expandtabs(tabsize) self.assertEqual(len(s), size - remainder) - self.assertEqual(len(s.strip(' ')), 0) + self.assertEqual(len(s.strip(_(' '))), 0) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_find(self, size): - SUBSTR = ' abc def ghi' + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) - s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEqual(s.find(' '), 0) + s = _('').join([SUBSTR, _('-') * size, SUBSTR]) + self.assertEqual(s.find(_(' ')), 0) self.assertEqual(s.find(SUBSTR), 0) - self.assertEqual(s.find(' ', sublen), sublen + size) + self.assertEqual(s.find(_(' '), sublen), sublen + size) self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + size) - self.assertEqual(s.find('i'), SUBSTR.find('i')) - self.assertEqual(s.find('i', sublen), - sublen + size + SUBSTR.find('i')) - self.assertEqual(s.find('i', size), - sublen + size + SUBSTR.find('i')) - self.assertEqual(s.find('j'), -1) - - @bigmemtest(minsize=_2G, memuse=2) + self.assertEqual(s.find(_('i')), SUBSTR.find(_('i'))) + self.assertEqual(s.find(_('i'), sublen), + sublen + size + SUBSTR.find(_('i'))) + self.assertEqual(s.find(_('i'), size), + sublen + size + SUBSTR.find(_('i'))) + self.assertEqual(s.find(_('j')), -1) + + @bigmemtest(size=_2G, memuse=2) def test_index(self, size): - SUBSTR = ' abc def ghi' + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) - s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEqual(s.index(' '), 0) + s = _('').join([SUBSTR, _('-') * size, SUBSTR]) + self.assertEqual(s.index(_(' ')), 0) self.assertEqual(s.index(SUBSTR), 0) - self.assertEqual(s.index(' ', sublen), sublen + size) + self.assertEqual(s.index(_(' '), sublen), sublen + size) self.assertEqual(s.index(SUBSTR, sublen), sublen + size) - self.assertEqual(s.index('i'), SUBSTR.index('i')) - self.assertEqual(s.index('i', sublen), - sublen + size + SUBSTR.index('i')) - self.assertEqual(s.index('i', size), - sublen + size + SUBSTR.index('i')) - self.assertRaises(ValueError, s.index, 'j') - - @bigmemtest(minsize=_2G, memuse=2) + self.assertEqual(s.index(_('i')), SUBSTR.index(_('i'))) + self.assertEqual(s.index(_('i'), sublen), + sublen + size + SUBSTR.index(_('i'))) + self.assertEqual(s.index(_('i'), size), + sublen + size + SUBSTR.index(_('i'))) + self.assertRaises(ValueError, s.index, _('j')) + + @bigmemtest(size=_2G, memuse=2) def test_isalnum(self, size): - SUBSTR = '123456' - s = 'a' * size + SUBSTR + _ = self.from_latin1 + SUBSTR = _('123456') + s = _('a') * size + SUBSTR self.assertTrue(s.isalnum()) - s += '.' + s += _('.') self.assertFalse(s.isalnum()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isalpha(self, size): - SUBSTR = 'zzzzzzz' - s = 'a' * size + SUBSTR + _ = self.from_latin1 + SUBSTR = _('zzzzzzz') + s = _('a') * size + SUBSTR self.assertTrue(s.isalpha()) - s += '.' + s += _('.') self.assertFalse(s.isalpha()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isdigit(self, size): - SUBSTR = '123456' - s = '9' * size + SUBSTR + _ = self.from_latin1 + SUBSTR = _('123456') + s = _('9') * size + SUBSTR self.assertTrue(s.isdigit()) - s += 'z' + s += _('z') self.assertFalse(s.isdigit()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_islower(self, size): - chars = ''.join([ chr(c) for c in range(255) if not chr(c).isupper() ]) + _ = self.from_latin1 + chars = _(''.join( + chr(c) for c in range(255) if not chr(c).isupper())) repeats = size // len(chars) + 2 s = chars * repeats self.assertTrue(s.islower()) - s += 'A' + s += _('A') self.assertFalse(s.islower()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isspace(self, size): - whitespace = ' \f\n\r\t\v' + _ = self.from_latin1 + whitespace = _(' \f\n\r\t\v') repeats = size // len(whitespace) + 2 s = whitespace * repeats self.assertTrue(s.isspace()) - s += 'j' + s += _('j') self.assertFalse(s.isspace()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_istitle(self, size): - SUBSTR = '123456' - s = ''.join(['A', 'a' * size, SUBSTR]) + _ = self.from_latin1 + SUBSTR = _('123456') + s = _('').join([_('A'), _('a') * size, SUBSTR]) self.assertTrue(s.istitle()) - s += 'A' + s += _('A') self.assertTrue(s.istitle()) - s += 'aA' + s += _('aA') self.assertFalse(s.istitle()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isupper(self, size): - chars = ''.join([ chr(c) for c in range(255) if not chr(c).islower() ]) + _ = self.from_latin1 + chars = _(''.join( + chr(c) for c in range(255) if not chr(c).islower())) repeats = size // len(chars) + 2 s = chars * repeats self.assertTrue(s.isupper()) - s += 'a' + s += _('a') self.assertFalse(s.isupper()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_join(self, size): - s = 'A' * size - x = s.join(['aaaaa', 'bbbbb']) - self.assertEqual(x.count('a'), 5) - self.assertEqual(x.count('b'), 5) - self.assertTrue(x.startswith('aaaaaA')) - self.assertTrue(x.endswith('Abbbbb')) - - @bigmemtest(minsize=_2G + 10, memuse=1) + _ = self.from_latin1 + s = _('A') * size + x = s.join([_('aaaaa'), _('bbbbb')]) + self.assertEqual(x.count(_('a')), 5) + self.assertEqual(x.count(_('b')), 5) + self.assertTrue(x.startswith(_('aaaaaA'))) + self.assertTrue(x.endswith(_('Abbbbb'))) + + @bigmemtest(size=_2G + 10, memuse=1) def test_ljust(self, size): - SUBSTR = ' abc def ghi' + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) - self.assertTrue(s.startswith(SUBSTR + ' ')) + self.assertTrue(s.startswith(SUBSTR + _(' '))) self.assertEqual(len(s), size) self.assertEqual(s.strip(), SUBSTR.strip()) - @bigmemtest(minsize=_2G + 10, memuse=2) + @bigmemtest(size=_2G + 10, memuse=2) def test_lower(self, size): - s = 'A' * size + _ = self.from_latin1 + s = _('A') * size s = s.lower() self.assertEqual(len(s), size) - self.assertEqual(s.count('a'), size) + self.assertEqual(s.count(_('a')), size) - @bigmemtest(minsize=_2G + 10, memuse=1) + @bigmemtest(size=_2G + 10, memuse=1) def test_lstrip(self, size): - SUBSTR = 'abc def ghi' + _ = self.from_latin1 + SUBSTR = _('abc def ghi') s = SUBSTR.rjust(size) self.assertEqual(len(s), size) self.assertEqual(s.lstrip(), SUBSTR.lstrip()) del s s = SUBSTR.ljust(size) self.assertEqual(len(s), size) - stripped = s.lstrip() - self.assertTrue(stripped is s) + # Type-specific optimization + if isinstance(s, (str, bytes)): + stripped = s.lstrip() + self.assertTrue(stripped is s) - @bigmemtest(minsize=_2G + 10, memuse=2) + @bigmemtest(size=_2G + 10, memuse=2) def test_replace(self, size): - replacement = 'a' - s = ' ' * size - s = s.replace(' ', replacement) + _ = self.from_latin1 + replacement = _('a') + s = _(' ') * size + s = s.replace(_(' '), replacement) self.assertEqual(len(s), size) self.assertEqual(s.count(replacement), size) - s = s.replace(replacement, ' ', size - 4) + s = s.replace(replacement, _(' '), size - 4) self.assertEqual(len(s), size) self.assertEqual(s.count(replacement), 4) - self.assertEqual(s[-10:], ' aaaa') + self.assertEqual(s[-10:], _(' aaaa')) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_rfind(self, size): - SUBSTR = ' abc def ghi' + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) - s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEqual(s.rfind(' '), sublen + size + SUBSTR.rfind(' ')) + s = _('').join([SUBSTR, _('-') * size, SUBSTR]) + self.assertEqual(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' '))) self.assertEqual(s.rfind(SUBSTR), sublen + size) - self.assertEqual(s.rfind(' ', 0, size), SUBSTR.rfind(' ')) + self.assertEqual(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' '))) self.assertEqual(s.rfind(SUBSTR, 0, sublen + size), 0) - self.assertEqual(s.rfind('i'), sublen + size + SUBSTR.rfind('i')) - self.assertEqual(s.rfind('i', 0, sublen), SUBSTR.rfind('i')) - self.assertEqual(s.rfind('i', 0, sublen + size), - SUBSTR.rfind('i')) - self.assertEqual(s.rfind('j'), -1) + self.assertEqual(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('i'), 0, sublen), SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('i'), 0, sublen + size), + SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('j')), -1) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_rindex(self, size): - SUBSTR = ' abc def ghi' + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) - s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEqual(s.rindex(' '), - sublen + size + SUBSTR.rindex(' ')) + s = _('').join([SUBSTR, _('-') * size, SUBSTR]) + self.assertEqual(s.rindex(_(' ')), + sublen + size + SUBSTR.rindex(_(' '))) self.assertEqual(s.rindex(SUBSTR), sublen + size) - self.assertEqual(s.rindex(' ', 0, sublen + size - 1), - SUBSTR.rindex(' ')) + self.assertEqual(s.rindex(_(' '), 0, sublen + size - 1), + SUBSTR.rindex(_(' '))) self.assertEqual(s.rindex(SUBSTR, 0, sublen + size), 0) - self.assertEqual(s.rindex('i'), - sublen + size + SUBSTR.rindex('i')) - self.assertEqual(s.rindex('i', 0, sublen), SUBSTR.rindex('i')) - self.assertEqual(s.rindex('i', 0, sublen + size), - SUBSTR.rindex('i')) - self.assertRaises(ValueError, s.rindex, 'j') - - @bigmemtest(minsize=_2G + 10, memuse=1) + self.assertEqual(s.rindex(_('i')), + sublen + size + SUBSTR.rindex(_('i'))) + self.assertEqual(s.rindex(_('i'), 0, sublen), SUBSTR.rindex(_('i'))) + self.assertEqual(s.rindex(_('i'), 0, sublen + size), + SUBSTR.rindex(_('i'))) + self.assertRaises(ValueError, s.rindex, _('j')) + + @bigmemtest(size=_2G + 10, memuse=1) def test_rjust(self, size): - SUBSTR = ' abc def ghi' + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) - self.assertTrue(s.startswith(SUBSTR + ' ')) + self.assertTrue(s.startswith(SUBSTR + _(' '))) self.assertEqual(len(s), size) self.assertEqual(s.strip(), SUBSTR.strip()) - @bigmemtest(minsize=_2G + 10, memuse=1) + @bigmemtest(size=_2G + 10, memuse=1) def test_rstrip(self, size): - SUBSTR = ' abc def ghi' + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) self.assertEqual(len(s), size) self.assertEqual(s.rstrip(), SUBSTR.rstrip()) del s s = SUBSTR.rjust(size) self.assertEqual(len(s), size) - stripped = s.rstrip() - self.assertTrue(stripped is s) + # Type-specific optimization + if isinstance(s, (str, bytes)): + stripped = s.rstrip() + self.assertTrue(stripped is s) # The test takes about size bytes to build a string, and then about # sqrt(size) substrings of sqrt(size) in size and a list to # hold sqrt(size) items. It's close but just over 2x size. - @bigmemtest(minsize=_2G, memuse=2.1) + @bigmemtest(size=_2G, memuse=2.1) def test_split_small(self, size): + _ = self.from_latin1 # Crudely calculate an estimate so that the result of s.split won't # take up an inordinate amount of memory chunksize = int(size ** 0.5 + 2) - SUBSTR = 'a' + ' ' * chunksize + SUBSTR = _('a') + _(' ') * chunksize s = SUBSTR * chunksize l = s.split() self.assertEqual(len(l), chunksize) - self.assertEqual(set(l), set(['a'])) + expected = _('a') + for item in l: + self.assertEqual(item, expected) del l - l = s.split('a') + l = s.split(_('a')) self.assertEqual(len(l), chunksize + 1) - self.assertEqual(set(l), set(['', ' ' * chunksize])) + expected = _(' ') * chunksize + for item in filter(None, l): + self.assertEqual(item, expected) # Allocates a string of twice size (and briefly two) and a list of # size. Because of internal affairs, the s.split() call produces a @@ -374,39 +347,45 @@ class StrTest(unittest.TestCase): # suffer for the list size. (Otherwise, it'd cost another 48 times # size in bytes!) Nevertheless, a list of size takes # 8*size bytes. - @bigmemtest(minsize=_2G + 5, memuse=10) + @bigmemtest(size=_2G + 5, memuse=10) def test_split_large(self, size): - s = ' a' * size + ' ' + _ = self.from_latin1 + s = _(' a') * size + _(' ') l = s.split() self.assertEqual(len(l), size) - self.assertEqual(set(l), set(['a'])) + self.assertEqual(set(l), set([_('a')])) del l - l = s.split('a') + l = s.split(_('a')) self.assertEqual(len(l), size + 1) - self.assertEqual(set(l), set([' '])) + self.assertEqual(set(l), set([_(' ')])) - @bigmemtest(minsize=_2G, memuse=2.1) + @bigmemtest(size=_2G, memuse=2.1) def test_splitlines(self, size): + _ = self.from_latin1 # Crudely calculate an estimate so that the result of s.split won't # take up an inordinate amount of memory chunksize = int(size ** 0.5 + 2) // 2 - SUBSTR = ' ' * chunksize + '\n' + ' ' * chunksize + '\r\n' + SUBSTR = _(' ') * chunksize + _('\n') + _(' ') * chunksize + _('\r\n') s = SUBSTR * chunksize l = s.splitlines() self.assertEqual(len(l), chunksize * 2) - self.assertEqual(set(l), set([' ' * chunksize])) + expected = _(' ') * chunksize + for item in l: + self.assertEqual(item, expected) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_startswith(self, size): - SUBSTR = ' abc def ghi' - s = '-' * size + SUBSTR + _ = self.from_latin1 + SUBSTR = _(' abc def ghi') + s = _('-') * size + SUBSTR self.assertTrue(s.startswith(s)) - self.assertTrue(s.startswith('-' * size)) + self.assertTrue(s.startswith(_('-') * size)) self.assertFalse(s.startswith(SUBSTR)) - @bigmemtest(minsize=_2G, memuse=1) + @bigmemtest(size=_2G, memuse=1) def test_strip(self, size): - SUBSTR = ' abc def ghi ' + _ = self.from_latin1 + SUBSTR = _(' abc def ghi ') s = SUBSTR.rjust(size) self.assertEqual(len(s), size) self.assertEqual(s.strip(), SUBSTR.strip()) @@ -415,9 +394,10 @@ class StrTest(unittest.TestCase): self.assertEqual(len(s), size) self.assertEqual(s.strip(), SUBSTR.strip()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_swapcase(self, size): - SUBSTR = "aBcDeFG12.'\xa9\x00" + _ = self.from_latin1 + SUBSTR = _("aBcDeFG12.'\xa9\x00") sublen = len(SUBSTR) repeats = size // sublen + 2 s = SUBSTR * repeats @@ -426,18 +406,27 @@ class StrTest(unittest.TestCase): self.assertEqual(s[:sublen * 3], SUBSTR.swapcase() * 3) self.assertEqual(s[-sublen * 3:], SUBSTR.swapcase() * 3) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_title(self, size): - SUBSTR = 'SpaaHAaaAaham' + _ = self.from_latin1 + SUBSTR = _('SpaaHAaaAaham') s = SUBSTR * (size // len(SUBSTR) + 2) s = s.title() self.assertTrue(s.startswith((SUBSTR * 3).title())) self.assertTrue(s.endswith(SUBSTR.lower() * 3)) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_translate(self, size): - trans = string.maketrans('.aZ', '-!$') - SUBSTR = 'aZz.z.Aaz.' + _ = self.from_latin1 + SUBSTR = _('aZz.z.Aaz.') + if isinstance(SUBSTR, str): + trans = { + ord(_('.')): _('-'), + ord(_('a')): _('!'), + ord(_('Z')): _('$'), + } + else: + trans = bytes.maketrans(b'.aZ', b'-!$') sublen = len(SUBSTR) repeats = size // sublen + 2 s = SUBSTR * repeats @@ -445,105 +434,54 @@ class StrTest(unittest.TestCase): self.assertEqual(len(s), repeats * sublen) self.assertEqual(s[:sublen], SUBSTR.translate(trans)) self.assertEqual(s[-sublen:], SUBSTR.translate(trans)) - self.assertEqual(s.count('.'), 0) - self.assertEqual(s.count('!'), repeats * 2) - self.assertEqual(s.count('z'), repeats * 3) + self.assertEqual(s.count(_('.')), 0) + self.assertEqual(s.count(_('!')), repeats * 2) + self.assertEqual(s.count(_('z')), repeats * 3) - @bigmemtest(minsize=_2G + 5, memuse=2) + @bigmemtest(size=_2G + 5, memuse=2) def test_upper(self, size): - s = 'a' * size + _ = self.from_latin1 + s = _('a') * size s = s.upper() self.assertEqual(len(s), size) - self.assertEqual(s.count('A'), size) + self.assertEqual(s.count(_('A')), size) - @bigmemtest(minsize=_2G + 20, memuse=1) + @bigmemtest(size=_2G + 20, memuse=1) def test_zfill(self, size): - SUBSTR = '-568324723598234' + _ = self.from_latin1 + SUBSTR = _('-568324723598234') s = SUBSTR.zfill(size) - self.assertTrue(s.endswith('0' + SUBSTR[1:])) - self.assertTrue(s.startswith('-0')) + self.assertTrue(s.endswith(_('0') + SUBSTR[1:])) + self.assertTrue(s.startswith(_('-0'))) self.assertEqual(len(s), size) - self.assertEqual(s.count('0'), size - len(SUBSTR)) - - @bigmemtest(minsize=_2G + 10, memuse=2) - def test_format(self, size): - s = '-' * size - sf = '%s' % (s,) - self.assertTrue(s == sf) - del sf - sf = '..%s..' % (s,) - self.assertEqual(len(sf), len(s) + 4) - self.assertTrue(sf.startswith('..-')) - self.assertTrue(sf.endswith('-..')) - del s, sf - - size //= 2 - edge = '-' * size - s = ''.join([edge, '%s', edge]) - del edge - s = s % '...' - self.assertEqual(len(s), size * 2 + 3) - self.assertEqual(s.count('.'), 3) - self.assertEqual(s.count('-'), size * 2) - - @bigmemtest(minsize=_2G + 10, memuse=5) - def test_repr_small(self, size): - s = '-' * size - s = repr(s) - self.assertEqual(len(s), size + 2) - self.assertEqual(s[0], "'") - self.assertEqual(s[-1], "'") - self.assertEqual(s.count('-'), size) - del s - # repr() will create a string four times as large as this 'binary - # string', but we don't want to allocate much more than twice - # size in total. (We do extra testing in test_repr_large()) - s = '\x00' * size - s = repr(s) - self.assertEqual(len(s), size * 4 + 2) - self.assertEqual(s[0], "'") - self.assertEqual(s[-1], "'") - self.assertEqual(s.count('\\'), size) - self.assertEqual(s.count('0'), size * 2) - - @bigmemtest(minsize=_2G + 10, memuse=5) - def test_repr_large(self, size): - s = '\x00' * size - s = repr(s) - self.assertEqual(len(s), size * 4 + 2) - self.assertEqual(s[0], "'") - self.assertEqual(s[-1], "'") - self.assertEqual(s.count('\\'), size) - self.assertEqual(s.count('0'), size * 2) - - @bigmemtest(minsize=2**32 // 5, memuse=6+2) - def test_unicode_repr(self, size): - s = u"\uAAAA" * size - self.assertTrue(len(repr(s)) > size) + self.assertEqual(s.count(_('0')), size - len(SUBSTR)) # This test is meaningful even with size < 2G, as long as the # doubled string is > 2G (but it tests more if both are > 2G :) - @bigmemtest(minsize=_1G + 2, memuse=3) + @bigmemtest(size=_1G + 2, memuse=3) def test_concat(self, size): - s = '.' * size + _ = self.from_latin1 + s = _('.') * size self.assertEqual(len(s), size) s = s + s self.assertEqual(len(s), size * 2) - self.assertEqual(s.count('.'), size * 2) + self.assertEqual(s.count(_('.')), size * 2) # This test is meaningful even with size < 2G, as long as the # repeated string is > 2G (but it tests more if both are > 2G :) - @bigmemtest(minsize=_1G + 2, memuse=3) + @bigmemtest(size=_1G + 2, memuse=3) def test_repeat(self, size): - s = '.' * size + _ = self.from_latin1 + s = _('.') * size self.assertEqual(len(s), size) s = s * 2 self.assertEqual(len(s), size * 2) - self.assertEqual(s.count('.'), size * 2) + self.assertEqual(s.count(_('.')), size * 2) - @bigmemtest(minsize=_2G + 20, memuse=2) + @bigmemtest(size=_2G + 20, memuse=2) def test_slice_and_getitem(self, size): - SUBSTR = '0123456789' + _ = self.from_latin1 + SUBSTR = _('0123456789') sublen = len(SUBSTR) s = SUBSTR * (size // sublen) stepsize = len(s) // 100 @@ -561,9 +499,9 @@ class StrTest(unittest.TestCase): self.assertEqual(s[-1], SUBSTR[-1]) self.assertEqual(s[len(s) - 10], SUBSTR[0]) self.assertEqual(s[-sublen], SUBSTR[0]) - self.assertEqual(s[len(s):], '') - self.assertEqual(s[len(s) - 1:], SUBSTR[-1]) - self.assertEqual(s[-1:], SUBSTR[-1]) + self.assertEqual(s[len(s):], _('')) + self.assertEqual(s[len(s) - 1:], SUBSTR[-1:]) + self.assertEqual(s[-1:], SUBSTR[-1:]) self.assertEqual(s[len(s) - sublen:], SUBSTR) self.assertEqual(s[-sublen:], SUBSTR) self.assertEqual(len(s[:]), len(s)) @@ -574,32 +512,34 @@ class StrTest(unittest.TestCase): self.assertRaises(IndexError, operator.getitem, s, len(s) + 1) self.assertRaises(IndexError, operator.getitem, s, len(s) + 1<<31) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_contains(self, size): - SUBSTR = '0123456789' - edge = '-' * (size // 2) - s = ''.join([edge, SUBSTR, edge]) + _ = self.from_latin1 + SUBSTR = _('0123456789') + edge = _('-') * (size // 2) + s = _('').join([edge, SUBSTR, edge]) del edge self.assertIn(SUBSTR, s) self.assertNotIn(SUBSTR * 2, s) - self.assertIn('-', s) - self.assertNotIn('a', s) - s += 'a' - self.assertIn('a', s) + self.assertIn(_('-'), s) + self.assertNotIn(_('a'), s) + s += _('a') + self.assertIn(_('a'), s) - @bigmemtest(minsize=_2G + 10, memuse=2) + @bigmemtest(size=_2G + 10, memuse=2) def test_compare(self, size): - s1 = '-' * size - s2 = '-' * size - self.assertTrue(s1 == s2) + _ = self.from_latin1 + s1 = _('-') * size + s2 = _('-') * size + self.assertEqual(s1, s2) del s2 - s2 = s1 + 'a' + s2 = s1 + _('a') self.assertFalse(s1 == s2) del s2 - s2 = '.' * size + s2 = _('.') * size self.assertFalse(s1 == s2) - @bigmemtest(minsize=_2G + 10, memuse=1) + @bigmemtest(size=_2G + 10, memuse=1) def test_hash(self, size): # Not sure if we can do any meaningful tests here... Even if we # start relying on the exact algorithm used, the result will be @@ -607,12 +547,196 @@ class StrTest(unittest.TestCase): # test is dodgy (there's no *guarantee* that the two things should # have a different hash, even if they, in the current # implementation, almost always do.) - s = '\x00' * size + _ = self.from_latin1 + s = _('\x00') * size h1 = hash(s) del s - s = '\x00' * (size + 1) + s = _('\x00') * (size + 1) self.assertFalse(h1 == hash(s)) + +class StrTest(unittest.TestCase, BaseStrTest): + + def from_latin1(self, s): + return s + + def basic_encode_test(self, size, enc, c='.', expectedsize=None): + if expectedsize is None: + expectedsize = size + + try: + s = c * size + self.assertEqual(len(s.encode(enc)), expectedsize) + finally: + s = None + + def setUp(self): + # HACK: adjust memory use of tests inherited from BaseStrTest + # according to character size. + self._adjusted = {} + for name in dir(BaseStrTest): + if not name.startswith('test_'): + continue + meth = getattr(type(self), name) + try: + memuse = meth.memuse + except AttributeError: + continue + meth.memuse = character_size * memuse + self._adjusted[name] = memuse + + def tearDown(self): + for name, memuse in self._adjusted.items(): + getattr(type(self), name).memuse = memuse + + # the utf8 encoder preallocates big time (4x the number of characters) + @bigmemtest(size=_2G + 2, memuse=character_size + 4) + def test_encode(self, size): + return self.basic_encode_test(size, 'utf-8') + + @bigmemtest(size=_4G // 6 + 2, memuse=character_size + 1) + def test_encode_raw_unicode_escape(self, size): + try: + return self.basic_encode_test(size, 'raw_unicode_escape') + except MemoryError: + pass # acceptable on 32-bit + + @bigmemtest(size=_4G // 5 + 70, memuse=character_size + 1) + def test_encode_utf7(self, size): + try: + return self.basic_encode_test(size, 'utf7') + except MemoryError: + pass # acceptable on 32-bit + + @bigmemtest(size=_4G // 4 + 5, memuse=character_size + 4) + def test_encode_utf32(self, size): + try: + return self.basic_encode_test(size, 'utf32', expectedsize=4*size+4) + except MemoryError: + pass # acceptable on 32-bit + + @bigmemtest(size=_2G - 1, memuse=character_size + 1) + def test_encode_ascii(self, size): + return self.basic_encode_test(size, 'ascii', c='A') + + @bigmemtest(size=_2G + 10, memuse=character_size * 2) + def test_format(self, size): + s = '-' * size + sf = '%s' % (s,) + self.assertEqual(s, sf) + del sf + sf = '..%s..' % (s,) + self.assertEqual(len(sf), len(s) + 4) + self.assertTrue(sf.startswith('..-')) + self.assertTrue(sf.endswith('-..')) + del s, sf + + size //= 2 + edge = '-' * size + s = ''.join([edge, '%s', edge]) + del edge + s = s % '...' + self.assertEqual(len(s), size * 2 + 3) + self.assertEqual(s.count('.'), 3) + self.assertEqual(s.count('-'), size * 2) + + @bigmemtest(size=_2G + 10, memuse=character_size * 2) + def test_repr_small(self, size): + s = '-' * size + s = repr(s) + self.assertEqual(len(s), size + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('-'), size) + del s + # repr() will create a string four times as large as this 'binary + # string', but we don't want to allocate much more than twice + # size in total. (We do extra testing in test_repr_large()) + size = size // 5 * 2 + s = '\x00' * size + s = repr(s) + self.assertEqual(len(s), size * 4 + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('\\'), size) + self.assertEqual(s.count('0'), size * 2) + + @bigmemtest(size=_2G + 10, memuse=character_size * 5) + def test_repr_large(self, size): + s = '\x00' * size + s = repr(s) + self.assertEqual(len(s), size * 4 + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('\\'), size) + self.assertEqual(s.count('0'), size * 2) + + @bigmemtest(size=_2G // 5 + 1, memuse=character_size * 7) + def test_unicode_repr(self, size): + # Use an assigned, but not printable code point. + # It is in the range of the low surrogates \uDC00-\uDFFF. + char = "\uDCBA" + s = char * size + try: + for f in (repr, ascii): + r = f(s) + self.assertEqual(len(r), 2 + (len(f(char)) - 2) * size) + self.assertTrue(r.endswith(r"\udcba'"), r[-10:]) + r = None + finally: + r = s = None + + # The character takes 4 bytes even in UCS-2 builds because it will + # be decomposed into surrogates. + @bigmemtest(size=_2G // 5 + 1, memuse=4 + character_size * 9) + def test_unicode_repr_wide(self, size): + char = "\U0001DCBA" + s = char * size + try: + for f in (repr, ascii): + r = f(s) + self.assertEqual(len(r), 2 + (len(f(char)) - 2) * size) + self.assertTrue(r.endswith(r"\U0001dcba'"), r[-12:]) + r = None + finally: + r = s = None + + @bigmemtest(size=_4G // 5, memuse=character_size * (6 + 1)) + def _test_unicode_repr_overflow(self, size): + # XXX not sure what this test is about + char = "\uDCBA" + s = char * size + try: + r = repr(s) + self.assertTrue(s == eval(r)) + finally: + r = s = None + + +class BytesTest(unittest.TestCase, BaseStrTest): + + def from_latin1(self, s): + return s.encode("latin1") + + @bigmemtest(size=_2G + 2, memuse=1 + character_size) + def test_decode(self, size): + s = self.from_latin1('.') * size + self.assertEqual(len(s.decode('utf-8')), size) + + +class BytearrayTest(unittest.TestCase, BaseStrTest): + + def from_latin1(self, s): + return bytearray(s.encode("latin1")) + + @bigmemtest(size=_2G + 2, memuse=1 + character_size) + def test_decode(self, size): + s = self.from_latin1('.') * size + self.assertEqual(len(s.decode('utf-8')), size) + + test_hash = None + test_split_large = None + class TupleTest(unittest.TestCase): # Tuples have a small, fixed-sized head and an array of pointers to @@ -624,13 +748,13 @@ class TupleTest(unittest.TestCase): # having more than 2<<31 references to any given object. Hence the # use of different types of objects as contents in different tests. - @bigmemtest(minsize=_2G + 2, memuse=16) + @bigmemtest(size=_2G + 2, memuse=16) def test_compare(self, size): - t1 = (u'',) * size - t2 = (u'',) * size - self.assertTrue(t1 == t2) + t1 = ('',) * size + t2 = ('',) * size + self.assertEqual(t1, t2) del t2 - t2 = (u'',) * (size + 1) + t2 = ('',) * (size + 1) self.assertFalse(t1 == t2) del t2 t2 = (1,) * size @@ -647,15 +771,15 @@ class TupleTest(unittest.TestCase): t = t + t self.assertEqual(len(t), size * 2) - @bigmemtest(minsize=_2G // 2 + 2, memuse=24) + @bigmemtest(size=_2G // 2 + 2, memuse=24) def test_concat_small(self, size): return self.basic_concat_test(size) - @bigmemtest(minsize=_2G + 2, memuse=24) + @bigmemtest(size=_2G + 2, memuse=24) def test_concat_large(self, size): return self.basic_concat_test(size) - @bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5) + @bigmemtest(size=_2G // 5 + 10, memuse=8 * 5) def test_contains(self, size): t = (1, 2, 3, 4, 5) * size self.assertEqual(len(t), size * 5) @@ -663,7 +787,7 @@ class TupleTest(unittest.TestCase): self.assertNotIn((1, 2, 3, 4, 5), t) self.assertNotIn(0, t) - @bigmemtest(minsize=_2G + 10, memuse=8) + @bigmemtest(size=_2G + 10, memuse=8) def test_hash(self, size): t1 = (0,) * size h1 = hash(t1) @@ -671,7 +795,7 @@ class TupleTest(unittest.TestCase): t2 = (0,) * (size + 1) self.assertFalse(h1 == hash(t2)) - @bigmemtest(minsize=_2G + 10, memuse=8) + @bigmemtest(size=_2G + 10, memuse=8) def test_index_and_slice(self, size): t = (None,) * size self.assertEqual(len(t), size) @@ -696,22 +820,23 @@ class TupleTest(unittest.TestCase): t = t * 2 self.assertEqual(len(t), size * 2) - @bigmemtest(minsize=_2G // 2 + 2, memuse=24) + @bigmemtest(size=_2G // 2 + 2, memuse=24) def test_repeat_small(self, size): return self.basic_test_repeat(size) - @bigmemtest(minsize=_2G + 2, memuse=24) + @bigmemtest(size=_2G + 2, memuse=24) def test_repeat_large(self, size): return self.basic_test_repeat(size) - @bigmemtest(minsize=_1G - 1, memuse=12) + @bigmemtest(size=_1G - 1, memuse=12) def test_repeat_large_2(self, size): return self.basic_test_repeat(size) - @precisionbigmemtest(size=_1G - 1, memuse=9) + @bigmemtest(size=_1G - 1, memuse=9) def test_from_2G_generator(self, size): + self.skipTest("test needs much more memory than advertised, see issue5438") try: - t = tuple(xrange(size)) + t = tuple(range(size)) except MemoryError: pass # acceptable on 32-bit else: @@ -721,10 +846,11 @@ class TupleTest(unittest.TestCase): count += 1 self.assertEqual(count, size) - @precisionbigmemtest(size=_1G - 25, memuse=9) + @bigmemtest(size=_1G - 25, memuse=9) def test_from_almost_2G_generator(self, size): + self.skipTest("test needs much more memory than advertised, see issue5438") try: - t = tuple(xrange(size)) + t = tuple(range(size)) count = 0 for item in t: self.assertEqual(item, count) @@ -743,11 +869,11 @@ class TupleTest(unittest.TestCase): self.assertEqual(s[-5:], '0, 0)') self.assertEqual(s.count('0'), size) - @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3) + @bigmemtest(size=_2G // 3 + 2, memuse=8 + 3 * character_size) def test_repr_small(self, size): return self.basic_test_repr(size) - @bigmemtest(minsize=_2G + 2, memuse=8 + 3) + @bigmemtest(size=_2G + 2, memuse=8 + 3 * character_size) def test_repr_large(self, size): return self.basic_test_repr(size) @@ -758,13 +884,13 @@ class ListTest(unittest.TestCase): # lists hold references to various objects to test their refcount # limits. - @bigmemtest(minsize=_2G + 2, memuse=16) + @bigmemtest(size=_2G + 2, memuse=16) def test_compare(self, size): - l1 = [u''] * size - l2 = [u''] * size - self.assertTrue(l1 == l2) + l1 = [''] * size + l2 = [''] * size + self.assertEqual(l1, l2) del l2 - l2 = [u''] * (size + 1) + l2 = [''] * (size + 1) self.assertFalse(l1 == l2) del l2 l2 = [2] * size @@ -781,11 +907,11 @@ class ListTest(unittest.TestCase): l = l + l self.assertEqual(len(l), size * 2) - @bigmemtest(minsize=_2G // 2 + 2, memuse=24) + @bigmemtest(size=_2G // 2 + 2, memuse=24) def test_concat_small(self, size): return self.basic_test_concat(size) - @bigmemtest(minsize=_2G + 2, memuse=24) + @bigmemtest(size=_2G + 2, memuse=24) def test_concat_large(self, size): return self.basic_test_concat(size) @@ -796,15 +922,15 @@ class ListTest(unittest.TestCase): self.assertTrue(l[0] is l[-1]) self.assertTrue(l[size - 1] is l[size + 1]) - @bigmemtest(minsize=_2G // 2 + 2, memuse=24) + @bigmemtest(size=_2G // 2 + 2, memuse=24) def test_inplace_concat_small(self, size): return self.basic_test_inplace_concat(size) - @bigmemtest(minsize=_2G + 2, memuse=24) + @bigmemtest(size=_2G + 2, memuse=24) def test_inplace_concat_large(self, size): return self.basic_test_inplace_concat(size) - @bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5) + @bigmemtest(size=_2G // 5 + 10, memuse=8 * 5) def test_contains(self, size): l = [1, 2, 3, 4, 5] * size self.assertEqual(len(l), size * 5) @@ -812,12 +938,12 @@ class ListTest(unittest.TestCase): self.assertNotIn([1, 2, 3, 4, 5], l) self.assertNotIn(0, l) - @bigmemtest(minsize=_2G + 10, memuse=8) + @bigmemtest(size=_2G + 10, memuse=8) def test_hash(self, size): l = [0] * size self.assertRaises(TypeError, hash, l) - @bigmemtest(minsize=_2G + 10, memuse=8) + @bigmemtest(size=_2G + 10, memuse=8) def test_index_and_slice(self, size): l = [None] * size self.assertEqual(len(l), size) @@ -881,11 +1007,11 @@ class ListTest(unittest.TestCase): l = l * 2 self.assertEqual(len(l), size * 2) - @bigmemtest(minsize=_2G // 2 + 2, memuse=24) + @bigmemtest(size=_2G // 2 + 2, memuse=24) def test_repeat_small(self, size): return self.basic_test_repeat(size) - @bigmemtest(minsize=_2G + 2, memuse=24) + @bigmemtest(size=_2G + 2, memuse=24) def test_repeat_large(self, size): return self.basic_test_repeat(size) @@ -901,11 +1027,11 @@ class ListTest(unittest.TestCase): self.assertEqual(len(l), size * 2) self.assertTrue(l[size - 1] is l[-1]) - @bigmemtest(minsize=_2G // 2 + 2, memuse=16) + @bigmemtest(size=_2G // 2 + 2, memuse=16) def test_inplace_repeat_small(self, size): return self.basic_test_inplace_repeat(size) - @bigmemtest(minsize=_2G + 2, memuse=16) + @bigmemtest(size=_2G + 2, memuse=16) def test_inplace_repeat_large(self, size): return self.basic_test_inplace_repeat(size) @@ -918,17 +1044,17 @@ class ListTest(unittest.TestCase): self.assertEqual(s[-5:], '0, 0]') self.assertEqual(s.count('0'), size) - @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3) + @bigmemtest(size=_2G // 3 + 2, memuse=8 + 3 * character_size) def test_repr_small(self, size): return self.basic_test_repr(size) - @bigmemtest(minsize=_2G + 2, memuse=8 + 3) + @bigmemtest(size=_2G + 2, memuse=8 + 3 * character_size) def test_repr_large(self, size): return self.basic_test_repr(size) # list overallocates ~1/8th of the total size (on first expansion) so # the single list.append call puts memuse at 9 bytes per size. - @bigmemtest(minsize=_2G, memuse=9) + @bigmemtest(size=_2G, memuse=9) def test_append(self, size): l = [object()] * size l.append(object()) @@ -936,39 +1062,39 @@ class ListTest(unittest.TestCase): self.assertTrue(l[-3] is l[-2]) self.assertFalse(l[-2] is l[-1]) - @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) + @bigmemtest(size=_2G // 5 + 2, memuse=8 * 5) def test_count(self, size): l = [1, 2, 3, 4, 5] * size self.assertEqual(l.count(1), size) self.assertEqual(l.count("1"), 0) def basic_test_extend(self, size): - l = [file] * size + l = [object] * size l.extend(l) self.assertEqual(len(l), size * 2) self.assertTrue(l[0] is l[-1]) self.assertTrue(l[size - 1] is l[size + 1]) - @bigmemtest(minsize=_2G // 2 + 2, memuse=16) + @bigmemtest(size=_2G // 2 + 2, memuse=16) def test_extend_small(self, size): return self.basic_test_extend(size) - @bigmemtest(minsize=_2G + 2, memuse=16) + @bigmemtest(size=_2G + 2, memuse=16) def test_extend_large(self, size): return self.basic_test_extend(size) - @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) + @bigmemtest(size=_2G // 5 + 2, memuse=8 * 5) def test_index(self, size): - l = [1L, 2L, 3L, 4L, 5L] * size + l = [1, 2, 3, 4, 5] * size size *= 5 self.assertEqual(l.index(1), 0) self.assertEqual(l.index(5, size - 5), size - 1) self.assertEqual(l.index(5, size - 5, size), size - 1) self.assertRaises(ValueError, l.index, 1, size - 4, size) - self.assertRaises(ValueError, l.index, 6L) + self.assertRaises(ValueError, l.index, 6) # This tests suffers from overallocation, just like test_append. - @bigmemtest(minsize=_2G + 10, memuse=9) + @bigmemtest(size=_2G + 10, memuse=9) def test_insert(self, size): l = [1.0] * size l.insert(size - 1, "A") @@ -987,31 +1113,31 @@ class ListTest(unittest.TestCase): self.assertEqual(l[:3], [1.0, "C", 1.0]) self.assertEqual(l[size - 3:], ["A", 1.0, "B"]) - @bigmemtest(minsize=_2G // 5 + 4, memuse=8 * 5) + @bigmemtest(size=_2G // 5 + 4, memuse=8 * 5) def test_pop(self, size): - l = [u"a", u"b", u"c", u"d", u"e"] * size + l = ["a", "b", "c", "d", "e"] * size size *= 5 self.assertEqual(len(l), size) item = l.pop() size -= 1 self.assertEqual(len(l), size) - self.assertEqual(item, u"e") - self.assertEqual(l[-2:], [u"c", u"d"]) + self.assertEqual(item, "e") + self.assertEqual(l[-2:], ["c", "d"]) item = l.pop(0) size -= 1 self.assertEqual(len(l), size) - self.assertEqual(item, u"a") - self.assertEqual(l[:2], [u"b", u"c"]) + self.assertEqual(item, "a") + self.assertEqual(l[:2], ["b", "c"]) item = l.pop(size - 2) size -= 1 self.assertEqual(len(l), size) - self.assertEqual(item, u"c") - self.assertEqual(l[-2:], [u"b", u"d"]) + self.assertEqual(item, "c") + self.assertEqual(l[-2:], ["b", "d"]) - @bigmemtest(minsize=_2G + 10, memuse=8) + @bigmemtest(size=_2G + 10, memuse=8) def test_remove(self, size): l = [10] * size self.assertEqual(len(l), size) @@ -1031,7 +1157,7 @@ class ListTest(unittest.TestCase): self.assertEqual(len(l), size) self.assertEqual(l[-2:], [10, 10]) - @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) + @bigmemtest(size=_2G // 5 + 2, memuse=8 * 5) def test_reverse(self, size): l = [1, 2, 3, 4, 5] * size l.reverse() @@ -1039,7 +1165,7 @@ class ListTest(unittest.TestCase): self.assertEqual(l[-5:], [5, 4, 3, 2, 1]) self.assertEqual(l[:5], [5, 4, 3, 2, 1]) - @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) + @bigmemtest(size=_2G // 5 + 2, memuse=8 * 5) def test_sort(self, size): l = [1, 2, 3, 4, 5] * size l.sort() @@ -1048,26 +1174,11 @@ class ListTest(unittest.TestCase): self.assertEqual(l[:10], [1] * 10) self.assertEqual(l[-10:], [5] * 10) -class BufferTest(unittest.TestCase): - - @precisionbigmemtest(size=_1G, memuse=4) - def test_repeat(self, size): - try: - with test_support.check_py3k_warnings(): - b = buffer("AAAA")*size - except MemoryError: - pass # acceptable on 32-bit - else: - count = 0 - for c in b: - self.assertEqual(c, 'A') - count += 1 - self.assertEqual(count, size*4) - def test_main(): - test_support.run_unittest(StrTest, TupleTest, ListTest, BufferTest) + support.run_unittest(StrTest, BytesTest, BytearrayTest, + TupleTest, ListTest) if __name__ == '__main__': if len(sys.argv) > 1: - test_support.set_memlimit(sys.argv[1]) + support.set_memlimit(sys.argv[1]) test_main() |