import unittest
import tempfile
import sys
import select
import re
import contextlib
import socket
import array
import _testcapi
from _testcapi import (UCHAR_MAX, SHRT_MAX, SHRT_MIN, USHRT_MAX, INT_MAX,
                       INT_MIN, UINT_MAX, LONG_MAX, LONG_MIN, ULONG_MAX,
                       ULLONG_MAX, PY_SSIZE_T_MAX, PY_SSIZE_T_MIN)

UINT32_MAX = (1 << 32) - 1

class MyPatchesTester(unittest.TestCase):
    ##### begin Modules/_blake2/blake2b_impl.c and
    ##### Modules/_blake2/blake2b_impl.c tests
    # py_blake2b_new_impl and py_blake2s_new_impl
    def test_py_blake2b_new_impl_and_py_blake2s_new_impl(self):
        import hashlib

        for curBlake2 in [hashlib.blake2b, hashlib.blake2s]:
            for outOfRangeInt in [-1 << 1000, -1, ULONG_MAX + 1, 1 << 1000]:
                with self.assertRaisesRegex(OverflowError,
                                            r'leaf_size does not fit in C '
                                            r'unsigned long'):
                    curBlake2(leaf_size=outOfRangeInt)

            if ULONG_MAX >= 1 << 32:
                for tooLargeInt in [1 << 32, ULONG_MAX]:
                    with self.assertRaisesRegex(OverflowError,
                                                r'leaf_size is too large'):
                        curBlake2(leaf_size=tooLargeInt)
    ##### end Modules/_blake2/blake2b_impl.c and
    ##### Modules/_blake2/blake2b_impl.c tests


    ##### begin Modules/_csv.c tests
    # _set_int (which is called by dialect_new)
    def test_set_int(self):
        import _csv

        for outOfRangeInt in [1 << 1000, -1 << 1000,
                              INT_MAX + 1, INT_MIN - 1]:
            with self.assertRaisesRegex(ValueError,
                                        r'"quoting" value does not fit in C '
                                        r'int'):
                _csv.Dialect(quoting=outOfRangeInt)
    ##### end Modules/_csv.c tests


    ##### begin Modules/_cursesmodule.c tests
    try:
        import curses
    except ImportError:
        pass
    else:
        @contextlib.contextmanager
        def cursesContext(self):
            import curses

            if not sys.__stdout__.isatty():
                self.tmp = tempfile.TemporaryFile()
                fd = self.tmp.fileno()
            else:
                self.tmp = None
                fd = sys.__stdout__.fileno()
            curses.setupterm(fd=fd)

            self.stdscr = curses.initscr()
            curses.savetty()

            yield

            curses.resetty()
            curses.endwin()

            if self.tmp:
                self.tmp.close()
                del self.tmp

        # PyCursesWindow_GetStr and PyCursesWindow_InStr
        def test_getstr_and_instr(self):
            with self.cursesContext():
                for meth in [self.stdscr.getstr, self.stdscr.instr]:
                    for outOfRangeInt in [-1 << 1000, INT_MIN - 1,
                                          INT_MAX + 1, 1 << 1000]:
                        with self.assertRaisesRegex(OverflowError,
                                                    re.escape('{}() argument '
                                                              'out of range'
                                                              ''.format(meth.__name__))):
                            meth(outOfRangeInt)
                        with self.assertRaisesRegex(OverflowError,
                                                    re.escape('{}() argument '
                                                              'out of range'
                                                              ''.format(meth.__name__))):
                            meth(1, outOfRangeInt)
                        with self.assertRaisesRegex(OverflowError,
                                                    re.escape('{}() argument '
                                                              'out of range'
                                                              ''.format(meth.__name__))):
                            meth(1, 1, outOfRangeInt)

                    for negativeInt in [-1, INT_MIN]:
                        with self.assertRaisesRegex(ValueError,
                                                    r"{}: 'n' must be "
                                                    r"nonnegative"
                                                    "".format(meth.__name__)):
                            meth(negativeInt)
                        with self.assertRaisesRegex(ValueError,
                                                    r"{}: 'n' must be "
                                                    r"nonnegative"
                                                    "".format(meth.__name__)):
                            meth(1, 1, negativeInt)

        # PyCurses_KeyName
        def test_keyname(self):
            import curses

            with self.cursesContext():
                for outOfRangeInt in [-1 << 1000, INT_MIN - 1,
                                      INT_MAX + 1, 1 << 1000]:
                    with self.assertRaisesRegex(OverflowError,
                                                re.escape('keyname() argument '
                                                          'out of range')):
                        curses.keyname(outOfRangeInt)

                for negativeInt in [-1, INT_MIN]:
                    with self.assertRaisesRegex(ValueError,
                                                r"keyname: key number must "
                                                r"be nonnegative"):
                        curses.keyname(negativeInt)
    ##### end Modules/_cursesmodule.c tests


    ##### begin Modules/_datetimemodule.c tests
    # microseconds_to_delta_ex (which is called by delta_new)
    def test_timedelta__new__(self):
        import datetime

        for outOfRangeInt in [1 << 1000, -1 << 1000,
                              INT_MAX + 1, INT_MIN - 1]:
            with self.assertRaisesRegex(OverflowError,
                                        r'normalized days does not fit in C '
                                        r'int'):
                datetime.timedelta(outOfRangeInt)

        # verify OverflowError('normalized days too large to fit in C int')
        # is not raised
        for badMagnitudeDays in [INT_MAX, INT_MIN]:
            with self.assertRaisesRegex(OverflowError,
                                        r'days=-?\d+; must have magnitude '
                                        r'<= \d+'):
                datetime.timedelta(badMagnitudeDays)
    ##### end Modules/_datetimemodule.c tests


    ##### begin Modules/_hashopenssl.c tests
    # pbkdf2_hmac
    def test_pbkdf2_hmac(self):
        import _hashlib

        for tooLargeInt in [INT_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'key length is too large.'):
                _hashlib.pbkdf2_hmac('sha256', b'password', b'salt',
                                     iterations=1, dklen=tooLargeInt)

        for tooSmallInt in [-1 << 1000, 0]:
            with self.assertRaisesRegex(ValueError,
                                        r'key length must be greater than 0.'):
                _hashlib.pbkdf2_hmac('sha256', b'password', b'salt',
                                     iterations=1, dklen=tooSmallInt)

        # verify neither OverflowError('key length is too large.')
        # nor ValueError('key length must be greater than 0.')
        # is raised
        _hashlib.pbkdf2_hmac('sha256', b'password', b'salt',
                             iterations=1, dklen=1)
        if 'win32' == sys.platform:
            with self.assertRaisesRegex(OverflowError,
                                        r'byte string is too large'):
                _hashlib.pbkdf2_hmac('sha256', b'password', b'salt',
                                     iterations=1, dklen=INT_MAX)
        elif 'linux' == sys.platform:
            with self.assertRaises(MemoryError):
                _hashlib.pbkdf2_hmac('sha256', b'password', b'salt',
                                     iterations=1, dklen=INT_MAX)
    ##### end Modules/_hashopenssl.c tests


    ##### begin Modules/_io/bytesio.c and Modules/_io/stringio.c tests
    # _io_BytesIO_truncate_impl and _io_StringIO_truncate_impl
    def test_BytesIO_and_StringIO_truncate(self):
        import io
        for memio in [io.BytesIO(), io.StringIO()]:
            for outOfRangeInt in [-1 << 1000, PY_SSIZE_T_MIN - 1,
                                  PY_SSIZE_T_MAX + 1, 1 << 1000]:
                with self.assertRaisesRegex(OverflowError,
                                            r'truncate: size value does not '
                                            r'fit in C Py_ssize_t'):
                    memio.truncate(outOfRangeInt)

            for negativeInt in [PY_SSIZE_T_MIN, -1]:
                with self.assertRaisesRegex(ValueError,
                                            r'truncate: negative size value '
                                            r'{}'.format(negativeInt)):
                    memio.truncate(negativeInt)
    ##### end Modules/_io/bytesio.c and Modules/_io/stringio.c tests


    ##### begin Modules/_lzmamodule.c tests
    # INT_TYPE_CONVERTER_FUNC (used to create uint32_converter,
    # which is called by Compressor_init)
    def test_LZMACompressor(self):
        import lzma

        for outOfRangeInt in [-1 << 1000, -1, UINT32_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int does not fit in C '
                                        r'uint32_t'):
                lzma.LZMACompressor(preset=outOfRangeInt)
    ##### end Modules/_lzmamodule.c tests


    ##### begin Modules/_sre.c tests
    # _sre_compile_impl
    def test_compile(self):
        import _sre

        for outOfRangeInt in [-1 << 1000, -1, 1 << 32, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'regular expression code out of '
                                        r'range'):
                _sre.compile('a', 1, [outOfRangeInt], 1, 1, 1)
    ##### end Modules/_sre.c tests


    ##### begin Modules/_stat.c tests
    # _PyLong_AsMode_t (which is called by stat_S_IMODE)
    def test_S_IMODE(self):
        import stat

        for outOfRangeInt in [-1 << 1000, -1, ULONG_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int does not fit in C mode_t'):
                stat.S_IMODE(outOfRangeInt)
    ##### end Modules/_stat.c tests


    ##### begin Modules/arraymodule.c tests
    # II_setitem
    def test_II_setitem(self):
        arr = array.array('I')

        for outOfRangeInt in [-1 << 1000, -1, ULONG_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        re.escape("array('I').__setitem__() "
                                                  "value argument does not "
                                                  "fit in C unsigned int")):
                arr.append(outOfRangeInt)

        if LONG_MAX > UINT_MAX:
            for tooLargeInt in [UINT_MAX + 1, ULONG_MAX]:
                with self.assertRaisesRegex(OverflowError,
                                            re.escape("array('I').__setitem__() "
                                                      "value argument too large "
                                                      "to convert to C unsigned "
                                                      "int")):
                    arr.append(tooLargeInt)

    # LL_setitem
    def test_LL_setitem(self):
        arr = array.array('L')

        for outOfRangeInt in [-1 << 1000, -1, ULONG_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        re.escape("array('L').__setitem__() "
                                                  "value argument does not "
                                                  "fit in C unsigned long")):
                arr.append(outOfRangeInt)

    # QQ_setitem
    def test_QQ_setitem(self):
        arr = array.array('Q')

        for outOfRangeInt in [-1 << 1000, -1, ULLONG_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        re.escape("array('Q').__setitem__() "
                                                  "value argument does not "
                                                  "fit in C unsigned long "
                                                  "long")):
                arr.append(outOfRangeInt)
    ##### end Modules/arraymodule.c tests


    ##### begin Modules/mmapmodule.c tests
    # mmap_read_method
    def test_mmap_read_method(self):
        import mmap

        m = mmap.mmap(-1, 16)
        self.addCleanup(m.close)

        for outOfRangeInt in [-1 << 1000, PY_SSIZE_T_MIN - 1,
                              PY_SSIZE_T_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'read count does not fit in C '
                                        r'Py_ssize_t'):
                m.read(outOfRangeInt)
    ##### end Modules/mmapmodule.c tests


    ##### begin Modules/posixmodule.c tests
    try:
        import posix
    except ImportError:
        pass
    else:
        # convert_sched_param (called by clinic generated code for
        # os_sched_setparam_impl)
        def test_convert_sched_param(self):
            import posix

            for outOfRangeInt in [1 << 1000, -1 << 1000,
                                  INT_MAX + 1, INT_MIN - 1]:
                schedParam = posix.sched_param(outOfRangeInt)
                with self.assertRaisesRegex(OverflowError,
                                            r'sched_priority value does not '
                                            r'fit in C int'):
                    posix.sched_setparam(0, schedParam)

        # os_sched_setaffinity_impl
        def test_sched_setaffinity(self):
            import posix

            for negativeCpuNum in [-1 << 1000, -1]:
                with self.assertRaisesRegex(ValueError,
                                            r'negative CPU number'):
                    posix.sched_setaffinity(0, [negativeCpuNum])

            for tooLargeCpuNum in [INT_MAX, 1 << 1000]:
                with self.assertRaisesRegex(OverflowError,
                                            r'CPU number too large'):
                    posix.sched_setaffinity(0, [tooLargeCpuNum])
    ##### end Modules/posixmodule.c tests


    ##### begin Modules/selectmodule.c tests
    # poll_register, poll_modify, and internal_devpoll_register
    # (which is called by devpoll_register and devpoll_modify)
    def test_devpoll_and_poll_register_and_modify(self):
        if hasattr(select, 'poll'):
            self._test_register_and_modify(select.poll())
        if hasattr(select, 'devpoll'):
            self._test_register_and_modify(select.devpoll())

    def _test_register_and_modify(self, pollster):
        for outOfRangeInt in [-1 << 1000, -1, USHRT_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r': eventmask value does not fit in '
                                        r'C unsigned short'):
                pollster.register(0, outOfRangeInt)
            with self.assertRaisesRegex(OverflowError,
                                        r': eventmask value does not fit in '
                                        r'C unsigned short'):
                pollster.modify(1, outOfRangeInt)
    ##### end Modules/selectmodule.c tests


    ##### begin Modules/socketmodule.c tests
    # socket_ntohl
    def test_ntohl(self):
        for outOfRangeInt in [-1 << 1000, -1, ULONG_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'ntohl: Python int does not fit in '
                                        r'C 32-bit unsigned integer'):
                socket.ntohl(outOfRangeInt)

        if UINT32_MAX < ULONG_MAX:
            for tooLargeInt in [UINT32_MAX + 1, ULONG_MAX]:
                with self.assertRaisesRegex(OverflowError,
                                            r'ntohl: Python int too large to '
                                            r'convert to C 32-bit unsigned '
                                            r'integer'):
                    socket.ntohl(tooLargeInt)

    # socket_htonl
    def test_htonl(self):
        for outOfRangeInt in [-1 << 1000, -1, ULONG_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'htonl: Python int does not fit in '
                                        r'C 32-bit unsigned integer'):
                socket.htonl(outOfRangeInt)

        if UINT32_MAX < ULONG_MAX:
            for tooLargeInt in [UINT32_MAX + 1, ULONG_MAX]:
                with self.assertRaisesRegex(OverflowError,
                                            r'htonl: Python int too large to '
                                            r'convert to C 32-bit unsigned '
                                            r'integer'):
                    socket.htonl(tooLargeInt)

    # socket_getnameinfo
    def test_getnameinfo(self):
        for outOfRangeInt in [-1 << 1000, INT_MIN - 1,
                              INT_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        re.escape('getnameinfo() argument '
                                                  'out of range')):
                socket.getnameinfo(('127.0.0.1', outOfRangeInt), 0)

        for inRangeInt in [INT_MIN, -1, 1 << 16, INT_MAX]:
            with self.assertRaisesRegex(OverflowError,
                                        re.escape('getnameinfo: port must '
                                                  'be 0-65535.')):
                socket.getnameinfo(('127.0.0.1', inRangeInt), 0)
    ##### end Modules/sockettmodule.c tests


    ##### begin Objects/abstract.c tests
    # sequence_repeat (which is called by PyNumber_Multiply)
    # (here, sequence_repeat calls unicode_repeat (which is in
    # unicodeobject.c))
    def test_sequence_repeat(self):
        for outOfRangeInt in [-1 << 1000, PY_SSIZE_T_MIN - 1,
                              PY_SSIZE_T_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'sequence repeat count does not fit '
                                        r'in C Py_ssize_t'):
                'aa' * outOfRangeInt

        # verify OverflowError('sequence repeat count does not fit
        # in C Py_ssize_t') is not raised
        'aa' * PY_SSIZE_T_MIN
        '' * PY_SSIZE_T_MAX

        with self.assertRaisesRegex(OverflowError,
                                    r'repeated string is too long'):
            'aa' * PY_SSIZE_T_MAX
    ##### end Objects/abstract.c tests


    ##### begin Objects/bytearrayobject.c and Objects/bytesobject.c tests
    # bytearray_init and bytes_new
    def test_bytearray_init_and_bytes_new(self):
        for bytesType in (bytes, bytearray):
            for outOfRangeInt in [-1 << 1000, PY_SSIZE_T_MIN - 1,
                                  PY_SSIZE_T_MAX + 1, 1 << 1000]:
                with self.assertRaisesRegex(OverflowError,
                                            r': count does not fit in C '
                                            r'Py_ssize_t'):
                    bytesType(outOfRangeInt)

            for negativeInt in [PY_SSIZE_T_MIN, -1]:
                with self.assertRaisesRegex(ValueError,
                                            r': negative count'):
                    bytesType(negativeInt)
    ##### end Objects/bytearrayobject.c and Objects/bytesobject.c tests


    ##### begin Objects/longobject.c tests
    # long_rshift and long_lshift
    def test_long_rshift_and_long_lshift(self):
        for zeroShifter in [(0).__lshift__, (0).__rshift__]:
            for outOfRangeInt in [-1 << 1000, PY_SSIZE_T_MIN - 1,
                                  PY_SSIZE_T_MAX + 1, 1 << 1000]:
                with self.assertRaisesRegex(OverflowError,
                                            r'shift count does not fit in C '
                                            r'Py_ssize_t'):
                    zeroShifter(outOfRangeInt)

            for negativeInt in [-1, PY_SSIZE_T_MIN]:
                with self.assertRaisesRegex(ValueError,
                                            r"shift count can't be negative"):
                    zeroShifter(negativeInt)

    # PyLong_AsLong
    def test_PyLong_AsLong(self):
        for tooSmallInt in [LONG_MIN - 1, -1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too small to convert to '
                                        r'C long'):
                _testcapi.getargs_l(tooSmallInt)

        for tooLargeInt in [LONG_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too large to convert to '
                                        r'C long'):
                _testcapi.getargs_l(tooLargeInt)

    # _PyLong_AsInt
    def test_PyLong_AsInt(self):
        for tooSmallInt in [INT_MIN - 1, -1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too small to convert to C '
                                        r'int'):
                _testcapi.getargs_i(tooSmallInt)

        for tooLargeInt in [INT_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too large to convert to '
                                        r'C int'):
                _testcapi.getargs_i(tooLargeInt)

    # PyLong_AsSsize_t
    def test_PyLong_AsSsize_t(self):
        for tooSmallInt in [PY_SSIZE_T_MIN - 1, -1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too small to convert to '
                                        r'C Py_ssize_t'):
                _testcapi.getargs_n(tooSmallInt)

        for tooLargeInt in [PY_SSIZE_T_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too large to convert to '
                                        r'C Py_ssize_t'):
                _testcapi.getargs_n(tooLargeInt)
    ##### end Objects/longobject.c tests


    ##### begin Objects/unicodeobject.c tests
    # formatchar
    def test_formatchar(self):
        for outOfRangeInt in [-1 << 1000, -1, 0x110000, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        re.escape('%c arg not in '
                                                  'range(0x110000)')):
                '%c' % outOfRangeInt
    ##### end Objects/unicodeobject.c tests


    ##### begin Python/formatter_unicode.c tests
    # format_long_internal
    def test_int__format__(self):
        for outOfRangeInt in [-1 << 1000, -1, 0x110000, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        re.escape('%c arg not in '
                                                  'range(0x110000)')):
                format(outOfRangeInt, 'c')
    ##### end Python/formatter_unicode.c tests


    ##### begin Python/getargs.c tests
    # convertsimple (parsing format code 'b')
    def test_getargs_b(self):
        for tooLargeInt in [UCHAR_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too large to convert '
                                        r'to C unsigned char'):
                _testcapi.getargs_b(tooLargeInt)

        for negativeInt in [-1 << 1000, -1]:
            with self.assertRaisesRegex(OverflowError,
                                        r"can't convert negative Python int "
                                        r"to C unsigned char"):
                _testcapi.getargs_b(negativeInt)

    # convertsimple (parsing format code 'h')
    def test_getargs_h(self):
        for tooLargeInt in [SHRT_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too large to convert '
                                        r'to C short'):
                _testcapi.getargs_h(tooLargeInt)

        for tooSmallInt in [-1 << 1000, SHRT_MIN - 1]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too small to convert '
                                        r'to C short'):
                _testcapi.getargs_h(tooSmallInt)

    # convertsimple (parsing format code 'i')
    def test_getargs_i(self):
        for tooLargeInt in [INT_MAX + 1, 1 << 1000]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too large to convert '
                                        r'to C int'):
                _testcapi.getargs_i(tooLargeInt)

        for tooSmallInt in [-1 << 1000, INT_MIN - 1]:
            with self.assertRaisesRegex(OverflowError,
                                        r'Python int too small to convert '
                                        r'to C int'):
                _testcapi.getargs_i(tooSmallInt)
    ##### end Python/getargs.c tests


if __name__ == '__main__':
    unittest.main()