diff options
Diffstat (limited to 'Lib/test/test_bigmem.py')
| -rw-r--r-- | Lib/test/test_bigmem.py | 241 |
1 files changed, 125 insertions, 116 deletions
diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py index 91c62af9e3..e2cf45df4e 100644 --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@ -9,7 +9,7 @@ high memory limit to regrtest, with the -M option. """ from test import support -from test.support import bigmemtest, _1G, _2G, _4G, precisionbigmemtest +from test.support import bigmemtest, _1G, _2G, _4G import unittest import operator @@ -50,11 +50,11 @@ import functools # 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 bigmem decorators speak 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 passed-in -# 'size', and don't rely on the size being very large. Also, +# - 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. @@ -67,7 +67,7 @@ character_size = 4 if sys.maxunicode > 0xFFFF else 2 class BaseStrTest: - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_capitalize(self, size): _ = self.from_latin1 SUBSTR = self.from_latin1(' abc def ghi') @@ -77,7 +77,7 @@ class BaseStrTest: SUBSTR.capitalize()) self.assertEqual(caps.lstrip(_('-')), SUBSTR) - @bigmemtest(minsize=_2G + 10, memuse=1) + @bigmemtest(size=_2G + 10, memuse=1) def test_center(self, size): SUBSTR = self.from_latin1(' abc def ghi') s = SUBSTR.center(size) @@ -88,7 +88,7 @@ class BaseStrTest: self.assertEqual(s[lpadsize:-rpadsize], SUBSTR) self.assertEqual(s.strip(), SUBSTR.strip()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_count(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -100,7 +100,7 @@ class BaseStrTest: self.assertEqual(s.count(_('i')), 1) self.assertEqual(s.count(_('j')), 0) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_endswith(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -112,7 +112,7 @@ class BaseStrTest: 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): _ = self.from_latin1 s = _('-') * size @@ -125,7 +125,7 @@ class BaseStrTest: self.assertEqual(len(s), size - remainder) self.assertEqual(len(s.strip(_(' '))), 0) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_find(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -142,7 +142,7 @@ class BaseStrTest: sublen + size + SUBSTR.find(_('i'))) self.assertEqual(s.find(_('j')), -1) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_index(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -159,7 +159,7 @@ class BaseStrTest: sublen + size + SUBSTR.index(_('i'))) self.assertRaises(ValueError, s.index, _('j')) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isalnum(self, size): _ = self.from_latin1 SUBSTR = _('123456') @@ -168,7 +168,7 @@ class BaseStrTest: s += _('.') self.assertFalse(s.isalnum()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isalpha(self, size): _ = self.from_latin1 SUBSTR = _('zzzzzzz') @@ -177,7 +177,7 @@ class BaseStrTest: s += _('.') self.assertFalse(s.isalpha()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isdigit(self, size): _ = self.from_latin1 SUBSTR = _('123456') @@ -186,7 +186,7 @@ class BaseStrTest: s += _('z') self.assertFalse(s.isdigit()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_islower(self, size): _ = self.from_latin1 chars = _(''.join( @@ -197,7 +197,7 @@ class BaseStrTest: s += _('A') self.assertFalse(s.islower()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isspace(self, size): _ = self.from_latin1 whitespace = _(' \f\n\r\t\v') @@ -207,7 +207,7 @@ class BaseStrTest: s += _('j') self.assertFalse(s.isspace()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_istitle(self, size): _ = self.from_latin1 SUBSTR = _('123456') @@ -218,7 +218,7 @@ class BaseStrTest: s += _('aA') self.assertFalse(s.istitle()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_isupper(self, size): _ = self.from_latin1 chars = _(''.join( @@ -229,7 +229,7 @@ class BaseStrTest: s += _('a') self.assertFalse(s.isupper()) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_join(self, size): _ = self.from_latin1 s = _('A') * size @@ -239,7 +239,7 @@ class BaseStrTest: self.assertTrue(x.startswith(_('aaaaaA'))) self.assertTrue(x.endswith(_('Abbbbb'))) - @bigmemtest(minsize=_2G + 10, memuse=1) + @bigmemtest(size=_2G + 10, memuse=1) def test_ljust(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -248,7 +248,7 @@ class BaseStrTest: 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): _ = self.from_latin1 s = _('A') * size @@ -256,7 +256,7 @@ class BaseStrTest: self.assertEqual(len(s), size) self.assertEqual(s.count(_('a')), size) - @bigmemtest(minsize=_2G + 10, memuse=1) + @bigmemtest(size=_2G + 10, memuse=1) def test_lstrip(self, size): _ = self.from_latin1 SUBSTR = _('abc def ghi') @@ -271,7 +271,7 @@ class BaseStrTest: 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): _ = self.from_latin1 replacement = _('a') @@ -284,7 +284,7 @@ class BaseStrTest: self.assertEqual(s.count(replacement), 4) self.assertEqual(s[-10:], _(' aaaa')) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_rfind(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -300,7 +300,7 @@ class BaseStrTest: SUBSTR.rfind(_('i'))) self.assertEqual(s.rfind(_('j')), -1) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_rindex(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -319,7 +319,7 @@ class BaseStrTest: SUBSTR.rindex(_('i'))) self.assertRaises(ValueError, s.rindex, _('j')) - @bigmemtest(minsize=_2G + 10, memuse=1) + @bigmemtest(size=_2G + 10, memuse=1) def test_rjust(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -328,7 +328,7 @@ class BaseStrTest: 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): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -346,7 +346,7 @@ class BaseStrTest: # 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 @@ -372,7 +372,7 @@ class BaseStrTest: # 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): _ = self.from_latin1 s = _(' a') * size + _(' ') @@ -384,7 +384,7 @@ class BaseStrTest: self.assertEqual(len(l), size + 1) 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 @@ -398,7 +398,7 @@ class BaseStrTest: for item in l: self.assertEqual(item, expected) - @bigmemtest(minsize=_2G, memuse=2) + @bigmemtest(size=_2G, memuse=2) def test_startswith(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') @@ -407,7 +407,7 @@ class BaseStrTest: 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): _ = self.from_latin1 SUBSTR = _(' abc def ghi ') @@ -419,7 +419,7 @@ class BaseStrTest: 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): _ = self.from_latin1 SUBSTR = _("aBcDeFG12.'\xa9\x00") @@ -431,7 +431,7 @@ class BaseStrTest: 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): _ = self.from_latin1 SUBSTR = _('SpaaHAaaAaham') @@ -440,7 +440,7 @@ class BaseStrTest: 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): _ = self.from_latin1 SUBSTR = _('aZz.z.Aaz.') @@ -463,7 +463,7 @@ class BaseStrTest: 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): _ = self.from_latin1 s = _('a') * size @@ -471,7 +471,7 @@ class BaseStrTest: self.assertEqual(len(s), size) self.assertEqual(s.count(_('A')), size) - @bigmemtest(minsize=_2G + 20, memuse=1) + @bigmemtest(size=_2G + 20, memuse=1) def test_zfill(self, size): _ = self.from_latin1 SUBSTR = _('-568324723598234') @@ -483,7 +483,7 @@ class BaseStrTest: # 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): _ = self.from_latin1 s = _('.') * size @@ -494,7 +494,7 @@ class BaseStrTest: # 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): _ = self.from_latin1 s = _('.') * size @@ -503,7 +503,7 @@ class BaseStrTest: self.assertEqual(len(s), 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): _ = self.from_latin1 SUBSTR = _('0123456789') @@ -537,7 +537,7 @@ class BaseStrTest: 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): _ = self.from_latin1 SUBSTR = _('0123456789') @@ -551,7 +551,7 @@ class BaseStrTest: s += _('a') self.assertTrue(_('a') in s) - @bigmemtest(minsize=_2G + 10, memuse=2) + @bigmemtest(size=_2G + 10, memuse=2) def test_compare(self, size): _ = self.from_latin1 s1 = _('-') * size @@ -564,7 +564,7 @@ class BaseStrTest: 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 @@ -615,46 +615,36 @@ class StrTest(unittest.TestCase, BaseStrTest): getattr(type(self), name).memuse = memuse # the utf8 encoder preallocates big time (4x the number of characters) - @bigmemtest(minsize=_2G + 2, memuse=character_size + 4) + @bigmemtest(size=_2G + 2, memuse=character_size + 4) def test_encode(self, size): return self.basic_encode_test(size, 'utf-8') - @precisionbigmemtest(size=_4G // 6 + 2, memuse=character_size + 1) + @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 - @precisionbigmemtest(size=_4G // 5 + 70, memuse=character_size + 1) + @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 - @precisionbigmemtest(size=_4G // 4 + 5, memuse=character_size + 4) + @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 - @precisionbigmemtest(size=_2G - 1, memuse=character_size + 1) + @bigmemtest(size=_2G - 1, memuse=character_size + 1) def test_encode_ascii(self, size): return self.basic_encode_test(size, 'ascii', c='A') - @precisionbigmemtest(size=_4G // 5, memuse=character_size * (6 + 1)) - def test_unicode_repr_overflow(self, size): - try: - s = "\uDCBA"*size - r = repr(s) - except MemoryError: - pass # acceptable on 32-bit - else: - self.assertTrue(s == eval(r)) - - @bigmemtest(minsize=_2G + 10, memuse=character_size * 2) + @bigmemtest(size=_2G + 10, memuse=character_size * 2) def test_format(self, size): s = '-' * size sf = '%s' % (s,) @@ -675,7 +665,7 @@ class StrTest(unittest.TestCase, BaseStrTest): self.assertEqual(s.count('.'), 3) self.assertEqual(s.count('-'), size * 2) - @bigmemtest(minsize=_2G + 10, memuse=character_size * 2) + @bigmemtest(size=_2G + 10, memuse=character_size * 2) def test_repr_small(self, size): s = '-' * size s = repr(s) @@ -696,7 +686,7 @@ class StrTest(unittest.TestCase, BaseStrTest): self.assertEqual(s.count('\\'), size) self.assertEqual(s.count('0'), size * 2) - @bigmemtest(minsize=_2G + 10, memuse=character_size * 5) + @bigmemtest(size=_2G + 10, memuse=character_size * 5) def test_repr_large(self, size): s = '\x00' * size s = repr(s) @@ -706,27 +696,46 @@ class StrTest(unittest.TestCase, BaseStrTest): self.assertEqual(s.count('\\'), size) self.assertEqual(s.count('0'), size * 2) - @bigmemtest(minsize=2**32 / 5, memuse=character_size * 7) + @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. - s = "\uDCBA" * size - for f in (repr, ascii): - r = f(s) - self.assertTrue(len(r) > size) - self.assertTrue(r.endswith(r"\udcba'"), r[-10:]) - del r + 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(minsize=2**32 / 5, memuse=4 + character_size * 9) + @bigmemtest(size=_2G // 5 + 1, memuse=4 + character_size * 9) def test_unicode_repr_wide(self, size): - s = "\U0001DCBA" * size - for f in (repr, ascii): - r = f(s) - self.assertTrue(len(r) > size) - self.assertTrue(r.endswith(r"\U0001dcba'"), r[-12:]) - del r + 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): @@ -734,7 +743,7 @@ class BytesTest(unittest.TestCase, BaseStrTest): def from_latin1(self, s): return s.encode("latin-1") - @bigmemtest(minsize=_2G + 2, memuse=1 + character_size) + @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) @@ -745,7 +754,7 @@ class BytearrayTest(unittest.TestCase, BaseStrTest): def from_latin1(self, s): return bytearray(s.encode("latin-1")) - @bigmemtest(minsize=_2G + 2, memuse=1 + character_size) + @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) @@ -764,7 +773,7 @@ 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 = ('',) * size t2 = ('',) * size @@ -787,15 +796,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) @@ -803,7 +812,7 @@ class TupleTest(unittest.TestCase): self.assertFalse((1, 2, 3, 4, 5) in t) self.assertFalse(0 in t) - @bigmemtest(minsize=_2G + 10, memuse=8) + @bigmemtest(size=_2G + 10, memuse=8) def test_hash(self, size): t1 = (0,) * size h1 = hash(t1) @@ -811,7 +820,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) @@ -836,19 +845,19 @@ 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: @@ -862,7 +871,7 @@ 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: @@ -885,11 +894,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 * character_size) + @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 * character_size) + @bigmemtest(size=_2G + 2, memuse=8 + 3 * character_size) def test_repr_large(self, size): return self.basic_test_repr(size) @@ -900,7 +909,7 @@ 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 = [''] * size l2 = [''] * size @@ -923,11 +932,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) @@ -938,15 +947,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) @@ -954,12 +963,12 @@ class ListTest(unittest.TestCase): self.assertFalse([1, 2, 3, 4, 5] in l) self.assertFalse(0 in 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) @@ -1023,11 +1032,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) @@ -1043,11 +1052,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) @@ -1060,17 +1069,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 * character_size) + @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 * character_size) + @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()) @@ -1078,7 +1087,7 @@ 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) @@ -1091,15 +1100,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=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 = [1, 2, 3, 4, 5] * size size *= 5 @@ -1110,7 +1119,7 @@ class ListTest(unittest.TestCase): 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") @@ -1129,7 +1138,7 @@ 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 = ["a", "b", "c", "d", "e"] * size size *= 5 @@ -1153,7 +1162,7 @@ class ListTest(unittest.TestCase): 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) @@ -1173,7 +1182,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() @@ -1181,7 +1190,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() |