python · orenmn · Mar 10, 2017 · Mar 11, 2017 · Mar 11, 2017 · Mar 11, 2017
diff --git a/Lib/test/datetimetester.py b/Lib/test/datetimetester.py
@@ -711,6 +711,15 @@ def test_overflow(self):
         self.assertRaises(OverflowError, day.__truediv__, 1e-10)
         self.assertRaises(OverflowError, day.__truediv__, 9e-10)
 
+        # test overflow in timedelta constructor
+        self.assertRaises(OverflowError, timedelta, -1 << 1000)
+        self.assertRaises(OverflowError, timedelta, -999999999, 0, -1)
+        # no tests here for getting timedelta.min and timedelta.max from
+        # timedelta constructor, as these are already tested in
+        # test_resolution_info.
+        self.assertRaises(OverflowError, timedelta, 1e9)
+        self.assertRaises(OverflowError, timedelta, 1 << 1000)
+
     @support.requires_IEEE_754
     def _test_overflow_special(self):
         day = timedelta(1)

diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py
@@ -1140,6 +1140,24 @@ def test_mul(self):
         # but either raises a MemoryError, or succeeds (if you have 54TiB)
         #self.checkraises(OverflowError, 10000*'abc', '__mul__', 2000000000)
 
+    @support.cpython_only
+    def test_mul_c_limits(self):
+        from _testcapi import PY_SSIZE_T_MAX, PY_SSIZE_T_MIN
+
+        # the following tests also test sequence_repeat in Objects/abstract.c
+        self.checkraises(OverflowError, '', '__mul__', -1 << 1000)
+        self.checkraises(OverflowError, '', '__mul__', PY_SSIZE_T_MIN - 1)
+        self.checkequal('', 'a', '__mul__', PY_SSIZE_T_MIN)
+        self.checkequal('', '', '__mul__', PY_SSIZE_T_MAX)
+        self.checkraises(OverflowError, '', '__mul__', PY_SSIZE_T_MAX + 1)
+        self.checkraises(OverflowError, '', '__mul__', 1 << 1000)
+
+        # result's length can't be bigger than PY_SSIZE_T_MAX
+        self.checkraises(OverflowError,
+                         'ab', '__mul__', PY_SSIZE_T_MAX // 2 + 1)
+        self.checkraises(OverflowError,
+                         'ab' * 0x1000, '__mul__', PY_SSIZE_T_MAX)
+
     def test_join(self):
         # join now works with any sequence type
         # moved here, because the argument order is
@@ -1237,6 +1255,14 @@ def test_formatting_c_limits(self):
                          (PY_SSIZE_T_MAX + 1, ''))
         self.checkraises(OverflowError, '%.*f', '__mod__',
                          (INT_MAX + 1, 1. / 7))
+
+        self.checkraises(OverflowError, '%c', '__mod__', -1 << 1000)
+        self.checkraises(OverflowError, '%c', '__mod__', -1)
+        self.checkequal('c=\x00', 'c=%c', '__mod__', 0)
+        self.checkequal('c=\U0010ffff', 'c=%c', '__mod__', 0x10ffff)
+        self.checkraises(OverflowError, '%c', '__mod__', 0x110000)
+        self.checkraises(OverflowError, '%c', '__mod__', 1 << 1000)
+
         # Issue 15989
         self.checkraises(OverflowError, '%*s', '__mod__',
                          (SIZE_MAX + 1, ''))

diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
@@ -17,7 +17,7 @@
 import test.support
 import test.string_tests
 import test.list_tests
-from test.support import bigaddrspacetest, MAX_Py_ssize_t
+from test.support import bigaddrspacetest, MAX_Py_ssize_t, cpython_only
 
 
 if sys.flags.bytes_warning:
@@ -104,6 +104,16 @@ def test_from_ssize(self):
         self.assertEqual(self.type2test(b'0'), b'0')
         self.assertRaises(OverflowError, self.type2test, sys.maxsize + 1)
 
+    @cpython_only
+    def test_from_ssize_c_limits(self):
+        from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
+
+        self.assertRaises(OverflowError, self.type2test, -1 << 1000)
+        self.assertRaises(OverflowError, self.type2test, PY_SSIZE_T_MIN - 1)
+        self.assertRaises(ValueError, self.type2test, PY_SSIZE_T_MIN)
+        self.assertRaises(OverflowError, self.type2test, PY_SSIZE_T_MAX + 1)
+        self.assertRaises(OverflowError, self.type2test, 1 << 1000)
+
     def test_constructor_type_errors(self):
         self.assertRaises(TypeError, self.type2test, 0.0)
         class C:
@@ -905,6 +915,16 @@ def ptr_formatter(ptr):
         self.assertRaises(OverflowError,
                           PyBytes_FromFormat, b'%c', c_int(256))
 
+        self.assertRaises(OverflowError, b'%c'.__mod__, -1 << 1000)
+        self.assertRaises(OverflowError, b'%c'.__mod__, 1 << 1000)
+
+        self.assertRaises(OverflowError, b'%c'.__mod__, Indexable(-1 << 1000))
+        self.assertRaises(OverflowError, b'%c'.__mod__, Indexable(-1))
+        self.assertEqual(b'c=%c' % Indexable(0), b'c=\0')
+        self.assertEqual(b'c=%c' % Indexable(255), b'c=\xff')
+        self.assertRaises(OverflowError, b'%c'.__mod__, Indexable(256))
+        self.assertRaises(OverflowError, b'%c'.__mod__, Indexable(1 << 1000))
+
     def test_bytes_blocking(self):
         class IterationBlocked(list):
             __bytes__ = None

diff --git a/Lib/test/test_curses.py b/Lib/test/test_curses.py
@@ -15,7 +15,7 @@
 import tempfile
 import unittest
 
-from test.support import requires, import_module, verbose
+from test.support import requires, import_module, verbose, cpython_only
 
 # Optionally test curses module.  This currently requires that the
 # 'curses' resource be given on the regrtest command line using the -u
@@ -194,6 +194,24 @@ def test_window_funcs(self):
         self.assertRaises(ValueError, stdscr.instr, -2)
         self.assertRaises(ValueError, stdscr.instr, 2, 3, -2)
 
+    @cpython_only
+    def test_getstr_and_instr_c_limits(self):
+        from _testcapi import INT_MIN, INT_MAX
+
+        for meth in [self.stdscr.getstr, self.stdscr.instr]:
+            self.assertRaises(OverflowError, meth, -1 << 1000)
+            self.assertRaises(OverflowError, meth, 1, 1, -1 << 1000)
+            self.assertRaises(OverflowError, meth, INT_MIN - 1)
+            self.assertRaises(OverflowError, meth, 1, 1, INT_MIN - 1)
+            self.assertRaises(ValueError, meth, INT_MIN)
+            self.assertRaises(ValueError, meth, 1, 1, INT_MIN)
+            self.assertRaises(ValueError, meth, -1)
+            self.assertRaises(ValueError, meth, 1, 1, -1)
+            self.assertRaises(OverflowError, meth, INT_MAX + 1)
+            self.assertRaises(OverflowError, meth, 1, 1, INT_MAX + 1)
+            self.assertRaises(OverflowError, meth, 1 << 1000)
+            self.assertRaises(OverflowError, meth, 1, 1, 1 << 1000)
+
 
     def test_module_funcs(self):
         "Test module-level functions"
@@ -259,6 +277,18 @@ def test_colors_funcs(self):
     def test_keyname(self):
         curses.keyname(13)
 
+    @cpython_only
+    @requires_curses_func('keyname')
+    def test_keyname_c_limits(self):
+        from _testcapi import INT_MIN, INT_MAX
+
+        self.assertRaises(OverflowError, curses.keyname, -1 << 1000)
+        self.assertRaises(OverflowError, curses.keyname, INT_MIN - 1)
+        self.assertRaises(ValueError, curses.keyname, INT_MIN)
+        self.assertRaises(ValueError, curses.keyname, -1)
+        self.assertRaises(OverflowError, curses.keyname, INT_MAX + 1)
+        self.assertRaises(OverflowError, curses.keyname, 1 << 1000)
+
     @requires_curses_func('has_key')
     def test_has_key(self):
         curses.has_key(13)

diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py
@@ -140,10 +140,12 @@ def test_b(self):
             self.assertEqual(1, getargs_b(BadInt2()))
         self.assertEqual(0, getargs_b(BadInt3()))
 
+        self.assertRaises(OverflowError, getargs_b, -1 << 1000)
         self.assertRaises(OverflowError, getargs_b, -1)
         self.assertEqual(0, getargs_b(0))
         self.assertEqual(UCHAR_MAX, getargs_b(UCHAR_MAX))
         self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1)
+        self.assertRaises(OverflowError, getargs_b, 1 << 1000)
 
         self.assertEqual(42, getargs_b(42))
         self.assertRaises(OverflowError, getargs_b, VERY_LARGE)
@@ -239,10 +241,12 @@ def test_h(self):
             self.assertEqual(1, getargs_h(BadInt2()))
         self.assertEqual(0, getargs_h(BadInt3()))
 
+        self.assertRaises(OverflowError, getargs_h, -1 << 1000)
         self.assertRaises(OverflowError, getargs_h, SHRT_MIN-1)
         self.assertEqual(SHRT_MIN, getargs_h(SHRT_MIN))
         self.assertEqual(SHRT_MAX, getargs_h(SHRT_MAX))
         self.assertRaises(OverflowError, getargs_h, SHRT_MAX+1)
+        self.assertRaises(OverflowError, getargs_h, 1 << 1000)
 
         self.assertEqual(42, getargs_h(42))
         self.assertRaises(OverflowError, getargs_h, VERY_LARGE)
@@ -258,10 +262,12 @@ def test_i(self):
             self.assertEqual(1, getargs_i(BadInt2()))
         self.assertEqual(0, getargs_i(BadInt3()))
 
+        self.assertRaises(OverflowError, getargs_i, -1 << 1000)
         self.assertRaises(OverflowError, getargs_i, INT_MIN-1)
         self.assertEqual(INT_MIN, getargs_i(INT_MIN))
         self.assertEqual(INT_MAX, getargs_i(INT_MAX))
         self.assertRaises(OverflowError, getargs_i, INT_MAX+1)
+        self.assertRaises(OverflowError, getargs_i, 1 << 1000)
 
         self.assertEqual(42, getargs_i(42))
         self.assertRaises(OverflowError, getargs_i, VERY_LARGE)

diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py
@@ -873,6 +873,29 @@ def test_pbkdf2_hmac_py(self):
     def test_pbkdf2_hmac_c(self):
         self._test_pbkdf2_hmac(c_hashlib.pbkdf2_hmac)
 
+    @unittest.skipUnless(hasattr(c_hashlib, 'pbkdf2_hmac'),
+                     '   test requires OpenSSL > 1.0')
+    @support.cpython_only
+    def test_pbkdf2_hmac_c_limits(self):
+        from _testcapi import LONG_MIN, INT_MAX
+        # test iterations limits
+        self.assertRaises(OverflowError, c_hashlib.pbkdf2_hmac,
+                          'sha1', b'pass', b'salt', -1 << 1000)
+        self.assertRaises(OverflowError, c_hashlib.pbkdf2_hmac,
+                          'sha1', b'pass', b'salt', LONG_MIN - 1)
+        self.assertRaises(ValueError, c_hashlib.pbkdf2_hmac,
+                          'sha1', b'pass', b'salt', LONG_MIN)
+        self.assertRaises(OverflowError, c_hashlib.pbkdf2_hmac,
+                          'sha1', b'pass', b'salt', INT_MAX + 1)
+        self.assertRaises(OverflowError, c_hashlib.pbkdf2_hmac,
+                          'sha1', b'pass', b'salt', 1 << 1000)
+        # test dklen limits
+        self.assertRaises(ValueError, c_hashlib.pbkdf2_hmac,
+                          'sha1', b'pass', b'salt', 1, -1 << 1000)
+        self.assertRaises(OverflowError, c_hashlib.pbkdf2_hmac,
+                          'sha1', b'pass', b'salt', 1, INT_MAX + 1)
+        self.assertRaises(OverflowError, c_hashlib.pbkdf2_hmac,
+                          'sha1', b'pass', b'salt', 1, 1 << 1000)
 
     @unittest.skipUnless(hasattr(c_hashlib, 'scrypt'),
                      '   test requires OpenSSL > 1.1')

diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
@@ -712,6 +712,14 @@ def test__format__(self):
                 self.assertEqual(format(value, format_spec),
                                  format(float(value), format_spec))
 
+        # test 'c' specifier limits
+        self.assertRaises(OverflowError, format, -1 << 1000, 'c')
+        self.assertRaises(OverflowError, format, -1, 'c')
+        self.assertEqual(format(0, 'c'), '\x00')
+        self.assertEqual(format(0x10ffff, 'c'), '\U0010ffff')
+        self.assertRaises(OverflowError, format, 0x110000, 'c')
+        self.assertRaises(OverflowError, format, 1 << 1000, 'c')
+
     def test_nan_inf(self):
         self.assertRaises(OverflowError, int, float('inf'))
         self.assertRaises(OverflowError, int, float('-inf'))
@@ -921,6 +929,26 @@ def test_huge_lshift_of_zero(self):
         with self.assertRaises(OverflowError):
             0 << (sys.maxsize + 1)
 
+    def test_negative_shift_count(self):
+        with self.assertRaises(ValueError):
+            42 << -3
+        with self.assertRaises(ValueError):
+            42 >> -3
+
+    @support.cpython_only
+    def test_shift_c_limits(self):
+        from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
+
+        for zero_shifter in [(0).__lshift__, (0).__rshift__]:
+            self.assertRaises(OverflowError, zero_shifter, -1 << 1000)
+            self.assertRaises(OverflowError, zero_shifter, PY_SSIZE_T_MIN - 1)
+            self.assertRaises(ValueError, zero_shifter, PY_SSIZE_T_MIN)
+            self.assertRaises(ValueError, zero_shifter, -1)
+            self.assertEqual(zero_shifter(0), 0)
+            self.assertEqual(zero_shifter(PY_SSIZE_T_MAX), 0)
+            self.assertRaises(OverflowError, zero_shifter, PY_SSIZE_T_MAX + 1)
+            self.assertRaises(OverflowError, zero_shifter, 1 << 1000)
+
     def test_small_ints(self):
         for i in range(-5, 257):
             self.assertIs(i, i + 0)

diff --git a/Lib/test/test_lzma.py b/Lib/test/test_lzma.py
@@ -7,7 +7,7 @@
 import unittest
 
 from test.support import (
-    _4G, TESTFN, import_module, bigmemtest, run_unittest, unlink
+    _4G, TESTFN, import_module, bigmemtest, run_unittest, unlink, cpython_only
 )
 
 lzma = import_module("lzma")
@@ -58,6 +58,18 @@ def test_simple_bad_args(self):
         lzd.decompress(empty)
         self.assertRaises(EOFError, lzd.decompress, b"quux")
 
+    @cpython_only
+    def test_INT_TYPE_CONVERTER_FUNC_macro(self):
+        # test the macro by testing uint32_converter, which is created
+        # by using the macro, and is later used to convert the preset
+        # argument of LZMACompressor.
+        self.assertRaises(OverflowError, LZMACompressor, preset=-1 << 1000)
+        self.assertRaises(OverflowError, LZMACompressor, preset=-1)
+        LZMACompressor(preset=0)
+        self.assertRaises(LZMAError, LZMACompressor, preset=(1 << 32) - 1)
+        self.assertRaises(OverflowError, LZMACompressor, preset=1 << 32)
+        self.assertRaises(OverflowError, LZMACompressor, preset=1 << 1000)
+
     def test_bad_filter_spec(self):
         self.assertRaises(TypeError, LZMACompressor, filters=[b"wobsite"])
         self.assertRaises(ValueError, LZMACompressor, filters=[{"xyzzy": 3}])

diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py
@@ -778,6 +778,20 @@ def test_cow_mutable(self):
         memio = self.ioclass(ba)
         self.assertEqual(sys.getrefcount(ba), old_rc)
 
+    @support.cpython_only
+    def test_truncate_c_limits(self):
+        from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
+        memio = self.ioclass()
+
+        self.assertRaises(OverflowError, memio.truncate, -1 << 1000)
+        self.assertRaises(OverflowError, memio.truncate, PY_SSIZE_T_MIN - 1)
+        self.assertRaises(ValueError, memio.truncate, PY_SSIZE_T_MIN)
+        self.assertRaises(ValueError, memio.truncate, -1)
+        memio.truncate(0)
+        memio.truncate(PY_SSIZE_T_MAX)
+        self.assertRaises(OverflowError, memio.truncate, PY_SSIZE_T_MAX + 1)
+        self.assertRaises(OverflowError, memio.truncate, 1 << 1000)
+
 class CStringIOTest(PyStringIOTest):
     ioclass = io.StringIO
     UnsupportedOperation = io.UnsupportedOperation
@@ -825,6 +839,20 @@ def test_setstate(self):
         memio.close()
         self.assertRaises(ValueError, memio.__setstate__, ("closed", "", 0, None))
 
+    @support.cpython_only
+    def test_truncate_c_limits(self):
+        from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
+        memio = self.ioclass()
+
+        self.assertRaises(OverflowError, memio.truncate, -1 << 1000)
+        self.assertRaises(OverflowError, memio.truncate, PY_SSIZE_T_MIN - 1)
+        self.assertRaises(ValueError, memio.truncate, PY_SSIZE_T_MIN)
+        self.assertRaises(ValueError, memio.truncate, -1)
+        memio.truncate(0)
+        memio.truncate(PY_SSIZE_T_MAX)
+        self.assertRaises(OverflowError, memio.truncate, PY_SSIZE_T_MAX + 1)
+        self.assertRaises(OverflowError, memio.truncate, 1 << 1000)
+
 
 class CStringIOPickleTest(PyStringIOPickleTest):
     UnsupportedOperation = io.UnsupportedOperation

diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
@@ -417,6 +417,30 @@ def test_anonymous(self):
             m[x] = b
             self.assertEqual(m[x], b)
 
+    def test_bad_length(self):
+        self.assertRaises(OverflowError, mmap.mmap, -1, -1 << 1000)
+        self.assertRaises(OverflowError, mmap.mmap, -1, -1)
+
+    @cpython_only
+    def test_constructor_c_limits(self):
+        from _testcapi import INT_MIN, INT_MAX, PY_SSIZE_T_MAX
+
+        # test overflow values of arguments that are stored in the
+        # same C types on Unix and on Windows:
+        # fileno
+        self.assertRaises(OverflowError, mmap.mmap, -1 << 1000, 16)
+        self.assertRaises(OverflowError, mmap.mmap, INT_MIN - 1, 16)
+        self.assertRaises(OverflowError, mmap.mmap, INT_MAX + 1, 16)
+        self.assertRaises(OverflowError, mmap.mmap, 1 << 1000, 16)
+        # length
+        self.assertRaises(OverflowError, mmap.mmap, -1, PY_SSIZE_T_MAX + 1)
+        self.assertRaises(OverflowError, mmap.mmap, -1, 1 << 1000)
+        # access
+        self.assertRaises(OverflowError, mmap.mmap, -1, 16, access=-1 << 1000)
+        self.assertRaises(OverflowError, mmap.mmap, -1, 16, access=INT_MIN - 1)
+        self.assertRaises(OverflowError, mmap.mmap, -1, 16, access=INT_MAX + 1)
+        self.assertRaises(OverflowError, mmap.mmap, -1, 16, access=1 << 1000)
+
     def test_read_all(self):
         m = mmap.mmap(-1, 16)
         self.addCleanup(m.close)
@@ -446,6 +470,19 @@ def test_read_invalid_arg(self):
         self.assertRaises(TypeError, m.read, 5.5)
         self.assertRaises(TypeError, m.read, [1, 2, 3])
 
+    @cpython_only
+    def test_read_c_limits(self):
+        from _testcapi import PY_SSIZE_T_MAX, PY_SSIZE_T_MIN
+        m = mmap.mmap(-1, 16)
+        self.addCleanup(m.close)
+
+        self.assertRaises(OverflowError, m.read, -1 << 1000)
+        self.assertRaises(OverflowError, m.read, PY_SSIZE_T_MIN - 1)
+        m.read(PY_SSIZE_T_MIN)
+        m.read(PY_SSIZE_T_MAX)
+        self.assertRaises(OverflowError, m.read, PY_SSIZE_T_MAX + 1)
+        self.assertRaises(OverflowError, m.read, 1 << 1000)
+
     def test_extended_getslice(self):
         # Test extended slicing by comparing with list slicing.
         s = bytes(reversed(range(256)))