From: Antoine Pitrou Date: Tue, 4 Oct 2011 08:28:37 +0000 (+0200) Subject: Start fixing test_bigmem: X-Git-Tag: v3.3.0a1~1344 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=1a3ff48c55fcb4dd8151750976242d83a84a09b0;p=thirdparty%2FPython%2Fcpython.git Start fixing test_bigmem: - bigmemtest is replaced by precisionbigmemtest - add a poor man's watchdog thread to print memory consumption --- 1a3ff48c55fcb4dd8151750976242d83a84a09b0 diff --cc Lib/test/pickletester.py index ca464574bdd1,49be72047d01..061bce924e1a --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@@ -8,8 -7,8 +8,8 @@@ import weakre from http.cookies import SimpleCookie from test.support import ( - TestFailed, TESTFN, run_with_locale, + TestFailed, TESTFN, run_with_locale, no_tracing, - _2G, _4G, precisionbigmemtest, + _2G, _4G, bigmemtest, ) from pickle import bytes_types diff --cc Lib/test/test_bigmem.py index 91c62af9e3f3,f3c6ebbf05fa..e2cf45df4eef --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@@ -1,15 -1,5 +1,15 @@@ +"""Bigmem tests - tests for the 32-bit boundary in containers. + +These tests try to exercise the 32-bit boundary that is sometimes, if +rarely, exceeded in practice, but almost never tested. They are really only +meaningful on 64-bit builds on machines with a *lot* of memory, but the +tests are always run, usually with very low memory limits to make sure the +tests themselves don't suffer from bitrot. To run them for real, pass a +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 @@@ -544,14 -519,14 +544,14 @@@ class BaseStrTest 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) + self.assertTrue(SUBSTR in s) + self.assertFalse(SUBSTR * 2 in s) + self.assertTrue(_('-') in s) + self.assertFalse(_('a') in s) s += _('a') - self.assertIn(_('a'), s) + 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 @@@ -732,9 -716,9 +741,9 @@@ class StrTest(unittest.TestCase, BaseSt class BytesTest(unittest.TestCase, BaseStrTest): def from_latin1(self, s): - return s.encode("latin1") + 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) @@@ -743,9 -727,9 +752,9 @@@ class BytearrayTest(unittest.TestCase, BaseStrTest): def from_latin1(self, s): - return bytearray(s.encode("latin1")) + 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) @@@ -799,11 -783,11 +808,11 @@@ class TupleTest(unittest.TestCase) def test_contains(self, size): t = (1, 2, 3, 4, 5) * size self.assertEqual(len(t), size * 5) - self.assertIn(5, t) - self.assertNotIn((1, 2, 3, 4, 5), t) - self.assertNotIn(0, t) + self.assertTrue(5 in t) + 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) @@@ -950,11 -934,11 +959,11 @@@ class ListTest(unittest.TestCase) def test_contains(self, size): l = [1, 2, 3, 4, 5] * size self.assertEqual(len(l), size * 5) - self.assertIn(5, l) - self.assertNotIn([1, 2, 3, 4, 5], l) - self.assertNotIn(0, l) + self.assertTrue(5 in l) + 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) diff --cc Lib/test/test_bz2.py index d0032387e972,be3558050be5..c324fb13baca --- a/Lib/test/test_bz2.py +++ b/Lib/test/test_bz2.py @@@ -1,6 -1,6 +1,6 @@@ #!/usr/bin/env python3 from test import support - from test.support import TESTFN, precisionbigmemtest, _4G -from test.support import TESTFN ++from test.support import TESTFN, bigmemtest, _4G import unittest from io import BytesIO @@@ -497,23 -313,6 +497,23 @@@ class BZ2CompressorTest(BaseTest) data += bz2c.flush() self.assertEqual(self.decompress(data), self.TEXT) - @precisionbigmemtest(size=_4G + 100, memuse=2) ++ @bigmemtest(size=_4G + 100, memuse=2) + def testCompress4G(self, size): + # "Test BZ2Compressor.compress()/flush() with >4GiB input" + bz2c = BZ2Compressor() + data = b"x" * size + try: + compressed = bz2c.compress(data) + compressed += bz2c.flush() + finally: + data = None # Release memory + data = bz2.decompress(compressed) + try: + self.assertEqual(len(data), size) + self.assertEqual(len(data.strip(b"x")), 0) + finally: + data = None + class BZ2DecompressorTest(BaseTest): def test_Constructor(self): self.assertRaises(TypeError, BZ2Decompressor, 42) @@@ -548,22 -351,6 +548,22 @@@ text = bz2d.decompress(self.DATA) self.assertRaises(EOFError, bz2d.decompress, b"anything") - @precisionbigmemtest(size=_4G + 100, memuse=3) ++ @bigmemtest(size=_4G + 100, memuse=3) + def testDecompress4G(self, size): + # "Test BZ2Decompressor.decompress() with >4GiB input" + blocksize = 10 * 1024 * 1024 + block = random.getrandbits(blocksize * 8).to_bytes(blocksize, 'little') + try: + data = block * (size // blocksize + 1) + compressed = bz2.compress(data) + bz2d = BZ2Decompressor() + decompressed = bz2d.decompress(compressed) + self.assertTrue(decompressed == data) + finally: + data = None + compressed = None + decompressed = None + class FuncTest(BaseTest): "Test module functions"