Start fixing test_bigmem:

- bigmemtest is replaced by precisionbigmemtest
- add a poor man's watchdog thread to print memory consumption

diff --cc Lib/test/pickletester.py
index ca464574bdd1cf56b18c1580297b46882571c316,49be72047d019f4ee30df25b81f0786fd5b75aa3..061bce924e1a0a9a8d8b6175c4735369c9bdf031
--- 1/Lib/test/pickletester.py
--- 2/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/support.py
Simple merge

diff --cc Lib/test/test_bigmem.py
index 91c62af9e3f339a59d53d98d38c243f0e6632c86,f3c6ebbf05fae5831519116cbd20a7fc6da636e8..e2cf45df4eef80ac58ddfe0c927a45f4d30d3418
--- 1/Lib/test/test_bigmem.py
--- 2/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 d0032387e972c6896724d9207db6e5a0d502ac09,be3558050be54c168ba38192bf5c53f869e0ba1a..c324fb13baca645b50589c0f5028d1e0df6ad0dd
--- 1/Lib/test/test_bz2.py
--- 2/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"

diff --cc Lib/test/test_zlib.py
Simple merge