diff options
47 files changed, 142 insertions, 150 deletions
diff --git a/Doc/library/itertools.rst b/Doc/library/itertools.rst index 7c7442b..54b52e4 100644 --- a/Doc/library/itertools.rst +++ b/Doc/library/itertools.rst @@ -235,7 +235,7 @@ loops that truncate the stream. def islice(iterable, *args): s = slice(*args) - it = iter(range(s.start or 0, s.stop or sys.maxint, s.step or 1)) + it = iter(range(s.start or 0, s.stop or sys.maxsize, s.step or 1)) nexti = next(it) for i, element in enumerate(iterable): if i == nexti: diff --git a/Doc/library/sys.rst b/Doc/library/sys.rst index 97f94aa..3fc86e4 100644 --- a/Doc/library/sys.rst +++ b/Doc/library/sys.rst @@ -365,11 +365,12 @@ always available. etc.) -.. data:: maxint +.. data:: maxsize - The largest positive integer supported by Python's regular integer type. This - is at least 2\*\*31-1. The largest negative integer is ``-maxint-1`` --- the - asymmetry results from the use of 2's complement binary arithmetic. + An integer giving the size of ``Py_ssize_t``. It's usually 2**31-1 on a 32 + bit platform and 2**63-1 on a 64bit platform. + + ..versionadded:: 3.0 .. data:: maxunicode diff --git a/Include/longobject.h b/Include/longobject.h index e1ee5ee..d48552c 100644 --- a/Include/longobject.h +++ b/Include/longobject.h @@ -31,8 +31,6 @@ PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *); cleanup to keep the extra information. [CH] */ #define PyLong_AS_LONG(op) PyLong_AsLong(op) -PyAPI_FUNC(long) PyInt_GetMax(void); - /* Used by socketmodule.c */ #if SIZEOF_SOCKET_T <= SIZEOF_LONG #define PyLong_FromSocket_t(fd) PyLong_FromLong((SOCKET_T)(fd)) diff --git a/Lib/UserString.py b/Lib/UserString.py index a11717c..a8b805f 100755 --- a/Lib/UserString.py +++ b/Lib/UserString.py @@ -85,7 +85,7 @@ class UserString: def capitalize(self): return self.__class__(self.data.capitalize()) def center(self, width, *args): return self.__class__(self.data.center(width, *args)) - def count(self, sub, start=0, end=sys.maxint): + def count(self, sub, start=0, end=sys.maxsize): if isinstance(sub, UserString): sub = sub.data return self.data.count(sub, start, end) @@ -105,15 +105,15 @@ class UserString: return self.__class__(self.data.encode(encoding)) else: return self.__class__(self.data.encode()) - def endswith(self, suffix, start=0, end=sys.maxint): + def endswith(self, suffix, start=0, end=sys.maxsize): return self.data.endswith(suffix, start, end) def expandtabs(self, tabsize=8): return self.__class__(self.data.expandtabs(tabsize)) - def find(self, sub, start=0, end=sys.maxint): + def find(self, sub, start=0, end=sys.maxsize): if isinstance(sub, UserString): sub = sub.data return self.data.find(sub, start, end) - def index(self, sub, start=0, end=sys.maxint): + def index(self, sub, start=0, end=sys.maxsize): return self.data.index(sub, start, end) def isalpha(self): return self.data.isalpha() def isalnum(self): return self.data.isalnum() @@ -137,9 +137,9 @@ class UserString: if isinstance(new, UserString): new = new.data return self.__class__(self.data.replace(old, new, maxsplit)) - def rfind(self, sub, start=0, end=sys.maxint): + def rfind(self, sub, start=0, end=sys.maxsize): return self.data.rfind(sub, start, end) - def rindex(self, sub, start=0, end=sys.maxint): + def rindex(self, sub, start=0, end=sys.maxsize): return self.data.rindex(sub, start, end) def rjust(self, width, *args): return self.__class__(self.data.rjust(width, *args)) @@ -151,7 +151,7 @@ class UserString: def rsplit(self, sep=None, maxsplit=-1): return self.data.rsplit(sep, maxsplit) def splitlines(self, keepends=0): return self.data.splitlines(keepends) - def startswith(self, prefix, start=0, end=sys.maxint): + def startswith(self, prefix, start=0, end=sys.maxsize): return self.data.startswith(prefix, start, end) def strip(self, chars=None): return self.__class__(self.data.strip(chars)) def swapcase(self): return self.__class__(self.data.swapcase()) diff --git a/Lib/_abcoll.py b/Lib/_abcoll.py index 122aac0..36d39cf 100644 --- a/Lib/_abcoll.py +++ b/Lib/_abcoll.py @@ -246,7 +246,7 @@ class Set(metaclass=ABCMeta): freedom for __eq__ or __hash__. We match the algorithm used by the built-in frozenset type. """ - MAX = sys.maxint + MAX = sys.maxsize MASK = 2 * MAX + 1 n = len(self) h = 1927868237 * (n + 1) diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py index e1c9d84..f7d0970 100644 --- a/Lib/ctypes/__init__.py +++ b/Lib/ctypes/__init__.py @@ -348,8 +348,8 @@ class CDLL(object): def __repr__(self): return "<%s '%s', handle %x at %x>" % \ (self.__class__.__name__, self._name, - (self._handle & (_sys.maxint*2 + 1)), - id(self) & (_sys.maxint*2 + 1)) + (self._handle & (_sys.maxsize*2 + 1)), + id(self) & (_sys.maxsize*2 + 1)) def __getattr__(self, name): if name.startswith('__') and name.endswith('__'): diff --git a/Lib/ctypes/util.py b/Lib/ctypes/util.py index f02b547..629e383 100644 --- a/Lib/ctypes/util.py +++ b/Lib/ctypes/util.py @@ -98,7 +98,7 @@ elif os.name == "posix": nums.insert(0, int(parts.pop())) except ValueError: pass - return nums or [ sys.maxint ] + return nums or [ sys.maxsize ] def find_library(name): ename = re.escape(name) diff --git a/Lib/email/generator.py b/Lib/email/generator.py index d46549c..ada14df 100644 --- a/Lib/email/generator.py +++ b/Lib/email/generator.py @@ -307,13 +307,13 @@ class DecodedGenerator(Generator): # Helper -_width = len(repr(sys.maxint-1)) +_width = len(repr(sys.maxsize-1)) _fmt = '%%0%dd' % _width def _make_boundary(text=None): # Craft a random boundary. If text is given, ensure that the chosen # boundary doesn't appear in the text. - token = random.randrange(sys.maxint) + token = random.randrange(sys.maxsize) boundary = ('=' * 15) + (_fmt % token) + '==' if text is None: return boundary diff --git a/Lib/gzip.py b/Lib/gzip.py index a044087..917c3f5 100644 --- a/Lib/gzip.py +++ b/Lib/gzip.py @@ -409,7 +409,7 @@ class GzipFile: def readline(self, size=-1): if size < 0: - size = sys.maxint + size = sys.maxsize readsize = self.min_readsize else: readsize = size @@ -441,7 +441,7 @@ class GzipFile: def readlines(self, sizehint=0): # Negative numbers result in reading all the lines if sizehint <= 0: - sizehint = sys.maxint + sizehint = sys.maxsize L = [] while sizehint > 0: line = self.readline() diff --git a/Lib/inspect.py b/Lib/inspect.py index 994dbdc..c0db4bc 100644 --- a/Lib/inspect.py +++ b/Lib/inspect.py @@ -320,7 +320,7 @@ def getdoc(object): return None else: # Find minimum indentation of any non-blank lines after first line. - margin = sys.maxint + margin = sys.maxsize for line in lines[1:]: content = len(line.lstrip()) if content: @@ -329,7 +329,7 @@ def getdoc(object): # Remove indentation. if lines: lines[0] = lines[0].lstrip() - if margin < sys.maxint: + if margin < sys.maxsize: for i in range(1, len(lines)): lines[i] = lines[i][margin:] # Remove any trailing or leading blank lines. while lines and not lines[-1]: diff --git a/Lib/mhlib.py b/Lib/mhlib.py index 955862b..b428439 100644 --- a/Lib/mhlib.py +++ b/Lib/mhlib.py @@ -365,7 +365,7 @@ class Folder: try: count = int(tail) except (ValueError, OverflowError): - # Can't use sys.maxint because of i+count below + # Can't use sys.maxsize because of i+count below count = len(all) try: anchor = self._parseindex(head, all) @@ -428,7 +428,7 @@ class Folder: try: return int(seq) except (OverflowError, ValueError): - return sys.maxint + return sys.maxsize if seq in ('cur', '.'): return self.getcurrent() if seq == 'first': diff --git a/Lib/sre_parse.py b/Lib/sre_parse.py index fa0b8aa..a04c343 100644 --- a/Lib/sre_parse.py +++ b/Lib/sre_parse.py @@ -152,7 +152,7 @@ class SubPattern: REPEATCODES = (MIN_REPEAT, MAX_REPEAT) for op, av in self.data: if op is BRANCH: - i = sys.maxint + i = sys.maxsize j = 0 for av in av[1]: l, h = av.getwidth() @@ -177,7 +177,7 @@ class SubPattern: hi = hi + 1 elif op == SUCCESS: break - self.width = int(min(lo, sys.maxint)), int(min(hi, sys.maxint)) + self.width = int(min(lo, sys.maxsize)), int(min(hi, sys.maxsize)) return self.width class Tokenizer: diff --git a/Lib/subprocess.py b/Lib/subprocess.py index d134c3a..56e05a3 100644 --- a/Lib/subprocess.py +++ b/Lib/subprocess.py @@ -344,7 +344,7 @@ _active = [] def _cleanup(): for inst in _active[:]: - res = inst.poll(_deadstate=sys.maxint) + res = inst.poll(_deadstate=sys.maxsize) if res is not None and res >= 0: try: _active.remove(inst) @@ -562,7 +562,7 @@ class Popen(object): # We didn't get to successfully create a child process. return # In case the child hasn't been waited on, check if it's done. - self.poll(_deadstate=sys.maxint) + self.poll(_deadstate=sys.maxsize) if self.returncode is None and _active is not None: # Child is still running, keep us alive until we can wait on it. _active.append(self) diff --git a/Lib/test/buffer_tests.py b/Lib/test/buffer_tests.py index db27759..8696eab 100644 --- a/Lib/test/buffer_tests.py +++ b/Lib/test/buffer_tests.py @@ -172,9 +172,9 @@ class MixinBytesBufferCommonTests(object): self.assertRaises(TypeError, self.marshal(b'hello').expandtabs, 42, 42) # This test is only valid when sizeof(int) == sizeof(void*) == 4. - if sys.maxint < (1 << 32) and struct.calcsize('P') == 4: + if sys.maxsize < (1 << 32) and struct.calcsize('P') == 4: self.assertRaises(OverflowError, - self.marshal(b'\ta\n\tb').expandtabs, sys.maxint) + self.marshal(b'\ta\n\tb').expandtabs, sys.maxsize) def test_title(self): self.assertEqual(b' Hello ', self.marshal(b' hello ').title()) diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py index 2c961ce..4317316 100644 --- a/Lib/test/list_tests.py +++ b/Lib/test/list_tests.py @@ -388,8 +388,8 @@ class CommonTest(seq_tests.CommonTest): self.assertEqual(a.index(0, -3), 3) self.assertEqual(a.index(0, 3, 4), 3) self.assertEqual(a.index(0, -3, -2), 3) - self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2) - self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint) + self.assertEqual(a.index(0, -4*sys.maxsize, 4*sys.maxsize), 2) + self.assertRaises(ValueError, a.index, 0, 4*sys.maxsize,-4*sys.maxsize) self.assertRaises(ValueError, a.index, 2, 0, -10) a.remove(0) self.assertRaises(ValueError, a.index, 2, 0, 4) diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py index b20f599..5ac2bdc 100644 --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -493,7 +493,7 @@ class AbstractPickleTests(unittest.TestCase): def test_ints(self): import sys for proto in protocols: - n = sys.maxint + n = sys.maxsize while n: for expected in (-n, n): s = self.dumps(expected, proto) diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py index f4569ab..16f4d3d 100755 --- a/Lib/test/regrtest.py +++ b/Lib/test/regrtest.py @@ -140,7 +140,7 @@ import traceback # putting them in test_grammar.py has no effect: warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning, ".*test.test_grammar$") -if sys.maxint > 0x7fffffff: +if sys.maxsize > 0x7fffffff: # Also suppress them in <string>, because for 64-bit platforms, # that's where test_grammar.py hides them. warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning, diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py index 909f947..80fe475 100644 --- a/Lib/test/string_tests.py +++ b/Lib/test/string_tests.py @@ -265,9 +265,9 @@ class BaseTest(unittest.TestCase): self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42) # This test is only valid when sizeof(int) == sizeof(void*) == 4. - if sys.maxint < (1 << 32) and struct.calcsize('P') == 4: + if sys.maxsize < (1 << 32) and struct.calcsize('P') == 4: self.checkraises(OverflowError, - '\ta\n\tb', 'expandtabs', sys.maxint) + '\ta\n\tb', 'expandtabs', sys.maxsize) def test_split(self): # by a char @@ -278,7 +278,7 @@ class BaseTest(unittest.TestCase): self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 3) self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 4) self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', - sys.maxint-2) + sys.maxsize-2) self.checkequal(['a|b|c|d'], 'a|b|c|d', 'split', '|', 0) self.checkequal(['a', '', 'b||c||d'], 'a||b||c||d', 'split', '|', 2) self.checkequal(['endcase ', ''], 'endcase |', 'split', '|') @@ -297,7 +297,7 @@ class BaseTest(unittest.TestCase): self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 3) self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 4) self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', - sys.maxint-10) + sys.maxsize-10) self.checkequal(['a//b//c//d'], 'a//b//c//d', 'split', '//', 0) self.checkequal(['a', '', 'b////c////d'], 'a////b////c////d', 'split', '//', 2) self.checkequal(['endcase ', ''], 'endcase test', 'split', 'test') @@ -334,7 +334,7 @@ class BaseTest(unittest.TestCase): self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 3) self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 4) self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', - sys.maxint-100) + sys.maxsize-100) self.checkequal(['a|b|c|d'], 'a|b|c|d', 'rsplit', '|', 0) self.checkequal(['a||b||c', '', 'd'], 'a||b||c||d', 'rsplit', '|', 2) self.checkequal(['', ' begincase'], '| begincase', 'rsplit', '|') @@ -354,7 +354,7 @@ class BaseTest(unittest.TestCase): self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 3) self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 4) self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', - sys.maxint-5) + sys.maxsize-5) self.checkequal(['a//b//c//d'], 'a//b//c//d', 'rsplit', '//', 0) self.checkequal(['a////b////c', '', 'd'], 'a////b////c////d', 'rsplit', '//', 2) self.checkequal(['', ' begincase'], 'test begincase', 'rsplit', 'test') @@ -392,7 +392,7 @@ class BaseTest(unittest.TestCase): EQ("", "", "replace", "A", "") EQ("", "", "replace", "A", "A") EQ("", "", "replace", "", "", 100) - EQ("", "", "replace", "", "", sys.maxint) + EQ("", "", "replace", "", "", sys.maxsize) # interleave (from=="", 'to' gets inserted everywhere) EQ("A", "A", "replace", "", "") @@ -401,7 +401,7 @@ class BaseTest(unittest.TestCase): EQ("*-#A*-#", "A", "replace", "", "*-#") EQ("*-A*-A*-", "AA", "replace", "", "*-") EQ("*-A*-A*-", "AA", "replace", "", "*-", -1) - EQ("*-A*-A*-", "AA", "replace", "", "*-", sys.maxint) + EQ("*-A*-A*-", "AA", "replace", "", "*-", sys.maxsize) EQ("*-A*-A*-", "AA", "replace", "", "*-", 4) EQ("*-A*-A*-", "AA", "replace", "", "*-", 3) EQ("*-A*-A", "AA", "replace", "", "*-", 2) @@ -412,7 +412,7 @@ class BaseTest(unittest.TestCase): EQ("", "A", "replace", "A", "") EQ("", "AAA", "replace", "A", "") EQ("", "AAA", "replace", "A", "", -1) - EQ("", "AAA", "replace", "A", "", sys.maxint) + EQ("", "AAA", "replace", "A", "", sys.maxsize) EQ("", "AAA", "replace", "A", "", 4) EQ("", "AAA", "replace", "A", "", 3) EQ("A", "AAA", "replace", "A", "", 2) @@ -421,7 +421,7 @@ class BaseTest(unittest.TestCase): EQ("", "AAAAAAAAAA", "replace", "A", "") EQ("BCD", "ABACADA", "replace", "A", "") EQ("BCD", "ABACADA", "replace", "A", "", -1) - EQ("BCD", "ABACADA", "replace", "A", "", sys.maxint) + EQ("BCD", "ABACADA", "replace", "A", "", sys.maxsize) EQ("BCD", "ABACADA", "replace", "A", "", 5) EQ("BCD", "ABACADA", "replace", "A", "", 4) EQ("BCDA", "ABACADA", "replace", "A", "", 3) @@ -444,7 +444,7 @@ class BaseTest(unittest.TestCase): EQ("thaet", "thaet", "replace", "the", "") EQ("here and re", "here and there", "replace", "the", "") EQ("here and re and re", "here and there and there", - "replace", "the", "", sys.maxint) + "replace", "the", "", sys.maxsize) EQ("here and re and re", "here and there and there", "replace", "the", "", -1) EQ("here and re and re", "here and there and there", @@ -469,7 +469,7 @@ class BaseTest(unittest.TestCase): # single character replace in place (len(from)==len(to)==1) EQ("Who goes there?", "Who goes there?", "replace", "o", "o") EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O") - EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", sys.maxint) + EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", sys.maxsize) EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", -1) EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 3) EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 2) @@ -486,7 +486,7 @@ class BaseTest(unittest.TestCase): # substring replace in place (len(from)==len(to) > 1) EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**") - EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", sys.maxint) + EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", sys.maxsize) EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", -1) EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 4) EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 3) @@ -500,7 +500,7 @@ class BaseTest(unittest.TestCase): # replace single character (len(from)==1, len(to)>1) EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK") EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", -1) - EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", sys.maxint) + EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", sys.maxsize) EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", 2) EQ("ReyKKjavik", "Reykjavik", "replace", "k", "KK", 1) EQ("Reykjavik", "Reykjavik", "replace", "k", "KK", 0) @@ -512,7 +512,7 @@ class BaseTest(unittest.TestCase): EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", "replace", "spam", "ham") EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", - "replace", "spam", "ham", sys.maxint) + "replace", "spam", "ham", sys.maxsize) EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", "replace", "spam", "ham", -1) EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam", @@ -567,7 +567,7 @@ class BaseTest(unittest.TestCase): def test_replace_overflow(self): # Check for overflow checking on 32 bit machines - if sys.maxint != 2147483647 or struct.calcsize("P") > 4: + if sys.maxsize != 2147483647 or struct.calcsize("P") > 4: return A2_16 = "A" * (2**16) self.checkraises(OverflowError, A2_16, "replace", "", A2_16) @@ -631,7 +631,7 @@ class CommonTest(BaseTest): self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 3) self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 4) self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, - sys.maxint-1) + sys.maxsize-1) self.checkequal(['a b c d'], 'a b c d', 'split', None, 0) self.checkequal(['a b c d'], ' a b c d', 'split', None, 0) self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2) @@ -662,7 +662,7 @@ class CommonTest(BaseTest): self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 3) self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 4) self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, - sys.maxint-20) + sys.maxsize-20) self.checkequal(['a b c d'], 'a b c d', 'rsplit', None, 0) self.checkequal(['a b c d'], 'a b c d ', 'rsplit', None, 0) self.checkequal(['a b', 'c', 'd'], 'a b c d', 'rsplit', None, 2) diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index d543751..be6f391 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -60,7 +60,7 @@ L = [ (' 314', 314), ('314 ', 314), (' \t\t 314 \t\t ', 314), - (repr(sys.maxint), sys.maxint), + (repr(sys.maxsize), sys.maxsize), (' 1x', ValueError), (' 1 ', 1), (' 1\02 ', ValueError), @@ -97,7 +97,7 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(abs(0), 0) self.assertEqual(abs(1234), 1234) self.assertEqual(abs(-1234), 1234) - self.assertTrue(abs(-sys.maxint-1) > 0) + self.assertTrue(abs(-sys.maxsize-1) > 0) # float self.assertEqual(abs(0.0), 0.0) self.assertEqual(abs(3.14), 3.14) @@ -138,9 +138,9 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(any(x > 42 for x in S), False) def test_neg(self): - x = -sys.maxint-1 + x = -sys.maxsize-1 self.assert_(isinstance(x, int)) - self.assertEqual(-x, sys.maxint+1) + self.assertEqual(-x, sys.maxsize+1) # XXX(nnorwitz): This test case for callable should probably be removed. def test_callable(self): @@ -306,8 +306,8 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(divmod(12, -7), (-2, -2)) self.assertEqual(divmod(-12, -7), (1, -5)) - self.assertEqual(divmod(-sys.maxint-1, -1), - (sys.maxint+1, 0)) + self.assertEqual(divmod(-sys.maxsize-1, -1), + (sys.maxsize+1, 0)) self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) @@ -644,12 +644,12 @@ class BuiltinTest(unittest.TestCase): except v: pass - s = repr(-1-sys.maxint) + s = repr(-1-sys.maxsize) x = int(s) - self.assertEqual(x+1, -sys.maxint) + self.assertEqual(x+1, -sys.maxsize) self.assert_(isinstance(x, int)) # should return long - self.assertEqual(int(s[1:]), sys.maxint+1) + self.assertEqual(int(s[1:]), sys.maxsize+1) # should return long x = int(1e100) @@ -661,7 +661,7 @@ class BuiltinTest(unittest.TestCase): # SF bug 434186: 0x80000000/2 != 0x80000000>>1. # Worked by accident in Windows release build, but failed in debug build. # Failed in all Linux builds. - x = -1-sys.maxint + x = -1-sys.maxsize self.assertEqual(x >> 1, x//2) self.assertRaises(ValueError, int, '123\0') @@ -881,12 +881,12 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(list(''), []) self.assertEqual(list('spam'), ['s', 'p', 'a', 'm']) - if sys.maxint == 0x7fffffff: + if sys.maxsize == 0x7fffffff: # This test can currently only work on 32-bit machines. # XXX If/when PySequence_Length() returns a ssize_t, it should be # XXX re-enabled. # Verify clearing of bug #556025. - # This assumes that the max data size (sys.maxint) == max + # This assumes that the max data size (sys.maxsize) == max # address size this also assumes that the address size is at # least 4 bytes with 8 byte addresses, the bug is not well # tested @@ -896,7 +896,7 @@ class BuiltinTest(unittest.TestCase): # thread for the details: # http://sources.redhat.com/ml/newlib/2002/msg00369.html - self.assertRaises(MemoryError, list, range(sys.maxint // 2)) + self.assertRaises(MemoryError, list, range(sys.maxsize // 2)) # This code used to segfault in Py2.4a3 x = [] @@ -1384,9 +1384,9 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(list(range(0, 2**100, -1)), []) self.assertEqual(list(range(0, 2**100, -1)), []) - a = int(10 * sys.maxint) - b = int(100 * sys.maxint) - c = int(50 * sys.maxint) + a = int(10 * sys.maxsize) + b = int(100 * sys.maxsize) + c = int(50 * sys.maxsize) self.assertEqual(list(range(a, a+2)), [a, a+1]) self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1]) @@ -1428,10 +1428,10 @@ class BuiltinTest(unittest.TestCase): self.assertRaises(TypeError, range, 0, "spam") self.assertRaises(TypeError, range, 0, 42, "spam") - #NEAL self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint) - #NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxint) + #NEAL self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize) + #NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxsize) - self.assertRaises(OverflowError, len, range(0, sys.maxint**10)) + self.assertRaises(OverflowError, len, range(0, sys.maxsize**10)) def test_input(self): self.write_testfile() diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py index f037d4c..0fd2f76 100644 --- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -36,14 +36,14 @@ class BytesTest(unittest.TestCase): self.assertEqual(len(b), 0) self.assertRaises(IndexError, lambda: b[0]) self.assertRaises(IndexError, lambda: b[1]) - self.assertRaises(IndexError, lambda: b[sys.maxint]) - self.assertRaises(IndexError, lambda: b[sys.maxint+1]) + self.assertRaises(IndexError, lambda: b[sys.maxsize]) + self.assertRaises(IndexError, lambda: b[sys.maxsize+1]) self.assertRaises(IndexError, lambda: b[10**100]) self.assertRaises(IndexError, lambda: b[-1]) self.assertRaises(IndexError, lambda: b[-2]) - self.assertRaises(IndexError, lambda: b[-sys.maxint]) - self.assertRaises(IndexError, lambda: b[-sys.maxint-1]) - self.assertRaises(IndexError, lambda: b[-sys.maxint-2]) + self.assertRaises(IndexError, lambda: b[-sys.maxsize]) + self.assertRaises(IndexError, lambda: b[-sys.maxsize-1]) + self.assertRaises(IndexError, lambda: b[-sys.maxsize-2]) self.assertRaises(IndexError, lambda: b[-10**100]) def test_from_list(self): @@ -83,14 +83,14 @@ class BytesTest(unittest.TestCase): def test_constructor_value_errors(self): self.assertRaises(ValueError, bytearray, [-1]) - self.assertRaises(ValueError, bytearray, [-sys.maxint]) - self.assertRaises(ValueError, bytearray, [-sys.maxint-1]) - self.assertRaises(ValueError, bytearray, [-sys.maxint-2]) + self.assertRaises(ValueError, bytearray, [-sys.maxsize]) + self.assertRaises(ValueError, bytearray, [-sys.maxsize-1]) + self.assertRaises(ValueError, bytearray, [-sys.maxsize-2]) self.assertRaises(ValueError, bytearray, [-10**100]) self.assertRaises(ValueError, bytearray, [256]) self.assertRaises(ValueError, bytearray, [257]) - self.assertRaises(ValueError, bytearray, [sys.maxint]) - self.assertRaises(ValueError, bytearray, [sys.maxint+1]) + self.assertRaises(ValueError, bytearray, [sys.maxsize]) + self.assertRaises(ValueError, bytearray, [sys.maxsize+1]) self.assertRaises(ValueError, bytearray, [10**100]) def test_repr_str(self): @@ -412,7 +412,7 @@ class BytesTest(unittest.TestCase): self.assertRaises(TypeError, lambda: 3.14 * b) # XXX Shouldn't bytes and bytearray agree on what to raise? self.assertRaises((OverflowError, MemoryError), - lambda: b * sys.maxint) + lambda: b * sys.maxsize) def test_repeat_1char(self): self.assertEqual(b'x'*100, bytearray([ord('x')]*100)) diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py index cc490d7..4979f92 100644 --- a/Lib/test/test_compile.py +++ b/Lib/test/test_compile.py @@ -194,24 +194,24 @@ if 1: def test_unary_minus(self): # Verify treatment of unary minus on negative numbers SF bug #660455 - if sys.maxint == 2147483647: + if sys.maxsize == 2147483647: # 32-bit machine all_one_bits = '0xffffffff' self.assertEqual(eval(all_one_bits), 4294967295) self.assertEqual(eval("-" + all_one_bits), -4294967295) - elif sys.maxint == 9223372036854775807: + elif sys.maxsize == 9223372036854775807: # 64-bit machine all_one_bits = '0xffffffffffffffff' self.assertEqual(eval(all_one_bits), 18446744073709551615) self.assertEqual(eval("-" + all_one_bits), -18446744073709551615) else: self.fail("How many bits *does* this machine have???") - # Verify treatment of contant folding on -(sys.maxint+1) + # Verify treatment of contant folding on -(sys.maxsize+1) # i.e. -2147483648 on 32 bit platforms. Should return int, not long. - self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 1)), int)) - self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 2)), int)) + self.assertTrue(isinstance(eval("%s" % (-sys.maxsize - 1)), int)) + self.assertTrue(isinstance(eval("%s" % (-sys.maxsize - 2)), int)) - if sys.maxint == 9223372036854775807: + if sys.maxsize == 9223372036854775807: def test_32_63_bit_values(self): a = +4294967296 # 1 << 32 b = -4294967296 # 1 << 32 diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index aa01805..199a49c 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -4118,8 +4118,8 @@ def notimplemented(): else: raise TestFailed("no TypeError from %r" % (expr,)) - N1 = sys.maxint + 1 # might trigger OverflowErrors instead of TypeErrors - N2 = sys.maxint # if sizeof(int) < sizeof(long), might trigger + N1 = sys.maxsize + 1 # might trigger OverflowErrors instead of TypeErrors + N2 = sys.maxsize # if sizeof(int) < sizeof(long), might trigger # ValueErrors instead of TypeErrors if 1: metaclass = type diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py index 0b02adf..9f4528c 100644 --- a/Lib/test/test_format.py +++ b/Lib/test/test_format.py @@ -40,7 +40,7 @@ def testformat(formatstr, args, output=None): print('yes') testformat("%.1d", (1,), "1") -testformat("%.*d", (sys.maxint,1)) # expect overflow +testformat("%.*d", (sys.maxsize,1)) # expect overflow testformat("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001') testformat("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001') testformat("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001') diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py index ee3ffc7..7ab7557 100644 --- a/Lib/test/test_grammar.py +++ b/Lib/test/test_grammar.py @@ -32,8 +32,8 @@ class TokenTests(unittest.TestCase): self.assertEquals(0o377, 255) self.assertEquals(2147483647, 0o17777777777) self.assertEquals(0b1001, 9) - from sys import maxint - if maxint == 2147483647: + from sys import maxsize + if maxsize == 2147483647: self.assertEquals(-2147483647-1, -0o20000000000) # XXX -2147483648 self.assert_(0o37777777777 > 0) @@ -45,7 +45,7 @@ class TokenTests(unittest.TestCase): x = eval(s) except OverflowError: self.fail("OverflowError on huge integer literal %r" % s) - elif maxint == 9223372036854775807: + elif maxsize == 9223372036854775807: self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000) self.assert_(0o1777777777777777777777 > 0) self.assert_(0xffffffffffffffff > 0) @@ -58,7 +58,7 @@ class TokenTests(unittest.TestCase): except OverflowError: self.fail("OverflowError on huge integer literal %r" % s) else: - self.fail('Weird maxint value %r' % maxint) + self.fail('Weird maxsize value %r' % maxsize) def testLongIntegers(self): x = 0 diff --git a/Lib/test/test_hexoct.py b/Lib/test/test_hexoct.py index afd696a..df9b310 100644 --- a/Lib/test/test_hexoct.py +++ b/Lib/test/test_hexoct.py @@ -4,7 +4,7 @@ This is complex because of changes due to PEP 237. """ import sys -platform_long_is_32_bits = sys.maxint == 2147483647 +platform_long_is_32_bits = sys.maxsize == 2147483647 import unittest from test import test_support diff --git a/Lib/test/test_index.py b/Lib/test/test_index.py index 6275e12..9a22020 100644 --- a/Lib/test/test_index.py +++ b/Lib/test/test_index.py @@ -2,7 +2,6 @@ import unittest from test import test_support import operator import sys -from sys import maxint maxsize = test_support.MAX_Py_ssize_t minsize = -maxsize-1 @@ -180,7 +179,7 @@ class OverflowTestCase(unittest.TestCase): def test_getitem(self): class GetItem(object): def __len__(self): - return maxint #cannot return long here + return sys.maxsize def __getitem__(self, key): return key x = GetItem() diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index 81e2e8e..17e0058 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -71,7 +71,7 @@ class TestBasicOps(unittest.TestCase): self.assertEqual(repr(c), 'count(-9)') next(c) self.assertEqual(next(c), -8) - for i in (-sys.maxint-5, -sys.maxint+5 ,-10, -1, 0, 10, sys.maxint-5, sys.maxint+5): + for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5): # Test repr (ignoring the L in longs) r1 = repr(count(i)).replace('L', '') r2 = 'count(%r)'.__mod__(i).replace('L', '') diff --git a/Lib/test/test_list.py b/Lib/test/test_list.py index 2afb3e9..5b84a42 100644 --- a/Lib/test/test_list.py +++ b/Lib/test/test_list.py @@ -21,7 +21,7 @@ class ListTest(list_tests.CommonTest): def test_overflow(self): lst = [4, 5, 6, 7] - n = int((sys.maxint*2+2) // len(lst)) + n = int((sys.maxsize*2+2) // len(lst)) def mul(a, b): return a * b def imul(a, b): a *= b self.assertRaises((MemoryError, OverflowError), mul, lst, n) diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py index bdda5d8..8be8bff 100644 --- a/Lib/test/test_long.py +++ b/Lib/test/test_long.py @@ -233,48 +233,48 @@ class LongTest(unittest.TestCase): import sys # check the extremes in int<->long conversion - hugepos = sys.maxint + hugepos = sys.maxsize hugeneg = -hugepos - 1 hugepos_aslong = int(hugepos) hugeneg_aslong = int(hugeneg) - self.assertEqual(hugepos, hugepos_aslong, "long(sys.maxint) != sys.maxint") + self.assertEqual(hugepos, hugepos_aslong, "long(sys.maxsize) != sys.maxsize") self.assertEqual(hugeneg, hugeneg_aslong, - "long(-sys.maxint-1) != -sys.maxint-1") + "long(-sys.maxsize-1) != -sys.maxsize-1") # long -> int should not fail for hugepos_aslong or hugeneg_aslong x = int(hugepos_aslong) try: self.assertEqual(x, hugepos, - "converting sys.maxint to long and back to int fails") + "converting sys.maxsize to long and back to int fails") except OverflowError: - self.fail("int(long(sys.maxint)) overflowed!") + self.fail("int(long(sys.maxsize)) overflowed!") if not isinstance(x, int): - raise TestFailed("int(long(sys.maxint)) should have returned int") + raise TestFailed("int(long(sys.maxsize)) should have returned int") x = int(hugeneg_aslong) try: self.assertEqual(x, hugeneg, - "converting -sys.maxint-1 to long and back to int fails") + "converting -sys.maxsize-1 to long and back to int fails") except OverflowError: - self.fail("int(long(-sys.maxint-1)) overflowed!") + self.fail("int(long(-sys.maxsize-1)) overflowed!") if not isinstance(x, int): - raise TestFailed("int(long(-sys.maxint-1)) should have " + raise TestFailed("int(long(-sys.maxsize-1)) should have " "returned int") # but long -> int should overflow for hugepos+1 and hugeneg-1 x = hugepos_aslong + 1 try: y = int(x) except OverflowError: - self.fail("int(long(sys.maxint) + 1) mustn't overflow") + self.fail("int(long(sys.maxsize) + 1) mustn't overflow") self.assert_(isinstance(y, int), - "int(long(sys.maxint) + 1) should have returned long") + "int(long(sys.maxsize) + 1) should have returned long") x = hugeneg_aslong - 1 try: y = int(x) except OverflowError: - self.fail("int(long(-sys.maxint-1) - 1) mustn't overflow") + self.fail("int(long(-sys.maxsize-1) - 1) mustn't overflow") self.assert_(isinstance(y, int), - "int(long(-sys.maxint-1) - 1) should have returned long") + "int(long(-sys.maxsize-1) - 1) should have returned long") class long2(int): pass @@ -288,8 +288,8 @@ class LongTest(unittest.TestCase): def test_auto_overflow(self): import math, sys - special = [0, 1, 2, 3, sys.maxint-1, sys.maxint, sys.maxint+1] - sqrt = int(math.sqrt(sys.maxint)) + special = [0, 1, 2, 3, sys.maxsize-1, sys.maxsize, sys.maxsize+1] + sqrt = int(math.sqrt(sys.maxsize)) special.extend([sqrt-1, sqrt, sqrt+1]) special.extend([-i for i in special]) @@ -462,7 +462,7 @@ class LongTest(unittest.TestCase): for t in 2.0**48, 2.0**50, 2.0**53: cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0, int(t-1), int(t), int(t+1)]) - cases.extend([0, 1, 2, sys.maxint, float(sys.maxint)]) + cases.extend([0, 1, 2, sys.maxsize, float(sys.maxsize)]) # 1L<<20000 should exceed all double formats. long(1e200) is to # check that we get equality with 1e200 above. t = int(1e200) diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py index d14d50d..66545e0 100644 --- a/Lib/test/test_marshal.py +++ b/Lib/test/test_marshal.py @@ -28,7 +28,7 @@ class HelperMixin: class IntTestCase(unittest.TestCase, HelperMixin): def test_ints(self): # Test the full range of Python ints. - n = sys.maxint + n = sys.maxsize while n: for expected in (-n, n): self.helper(expected) @@ -66,7 +66,7 @@ class FloatTestCase(unittest.TestCase, HelperMixin): def test_floats(self): # Test a few floats small = 1e-25 - n = sys.maxint * 3.7e250 + n = sys.maxsize * 3.7e250 while n > small: for expected in (-n, n): self.helper(float(expected)) @@ -81,7 +81,7 @@ class FloatTestCase(unittest.TestCase, HelperMixin): got = marshal.loads(s) self.assertEqual(f, got) - n = sys.maxint * 3.7e-250 + n = sys.maxsize * 3.7e-250 while n < small: for expected in (-n, n): f = float(expected) diff --git a/Lib/test/test_multibytecodec.py b/Lib/test/test_multibytecodec.py index e9d3ef0..615ad8b 100644 --- a/Lib/test/test_multibytecodec.py +++ b/Lib/test/test_multibytecodec.py @@ -40,7 +40,7 @@ class Test_MultibyteCodec(unittest.TestCase): def test_errorcallback_longindex(self): dec = codecs.getdecoder('euc-kr') - myreplace = lambda exc: ('', sys.maxint+1) + myreplace = lambda exc: ('', sys.maxsize+1) codecs.register_error('test.cjktest', myreplace) self.assertRaises(IndexError, dec, 'apple\x92ham\x93spam', 'test.cjktest') diff --git a/Lib/test/test_multibytecodec_support.py b/Lib/test/test_multibytecodec_support.py index 957b9fc..6b67057 100644 --- a/Lib/test/test_multibytecodec_support.py +++ b/Lib/test/test_multibytecodec_support.py @@ -114,7 +114,7 @@ class TestBase: 'test.cjktest'), (b'abcdxefgh', 9)) def myreplace(exc): - return ('x', sys.maxint + 1) + return ('x', sys.maxsize + 1) codecs.register_error("test.cjktest", myreplace) self.assertRaises(IndexError, self.encode, self.unmappedunicode, 'test.cjktest') diff --git a/Lib/test/test_range.py b/Lib/test/test_range.py index 0a4c9a0..dedf007 100644 --- a/Lib/test/test_range.py +++ b/Lib/test/test_range.py @@ -51,10 +51,10 @@ class RangeTest(unittest.TestCase): self.assertRaises(TypeError, range, 0, "spam") self.assertRaises(TypeError, range, 0, 42, "spam") - self.assertEqual(len(range(0, sys.maxint, sys.maxint-1)), 2) + self.assertEqual(len(range(0, sys.maxsize, sys.maxsize-1)), 2) - r = range(-sys.maxint, sys.maxint, 2) - self.assertEqual(len(r), sys.maxint) + r = range(-sys.maxsize, sys.maxsize, 2) + self.assertEqual(len(r), sys.maxsize) def test_repr(self): self.assertEqual(repr(range(1)), 'range(0, 1)') diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py index cb9d8b2..20d2027 100644 --- a/Lib/test/test_slice.py +++ b/Lib/test/test_slice.py @@ -92,7 +92,7 @@ class SliceTest(unittest.TestCase): ) self.assertEqual(slice(-100, 100, 2).indices(10), (0, 10, 2)) - self.assertEqual(list(range(10))[::sys.maxint - 1], [0]) + self.assertEqual(list(range(10))[::sys.maxsize - 1], [0]) self.assertRaises(OverflowError, slice(None).indices, 1<<100) diff --git a/Lib/test/test_struct.py b/Lib/test/test_struct.py index 34596e0..23358be 100644 --- a/Lib/test/test_struct.py +++ b/Lib/test/test_struct.py @@ -506,8 +506,8 @@ def test_1229380(): deprecated_err(struct.pack, endian + 'B', 300) deprecated_err(struct.pack, endian + 'H', 70000) - deprecated_err(struct.pack, endian + 'I', sys.maxint * 4) - deprecated_err(struct.pack, endian + 'L', sys.maxint * 4) + deprecated_err(struct.pack, endian + 'I', sys.maxsize * 4) + deprecated_err(struct.pack, endian + 'L', sys.maxsize * 4) if PY_STRUCT_RANGE_CHECKING: test_1229380() diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index 435a696..0a62c01 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -282,7 +282,7 @@ class SysModuleTest(unittest.TestCase): self.assert_(isinstance(sys.float_info, dict)) self.assertEqual(len(sys.float_info), 11) self.assert_(isinstance(sys.hexversion, int)) - self.assert_(isinstance(sys.maxint, int)) + self.assert_(isinstance(sys.maxsize, int)) self.assert_(isinstance(sys.maxunicode, int)) self.assert_(isinstance(sys.platform, str)) self.assert_(isinstance(sys.prefix, str)) diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py index e5ed201..5dd3aea 100644 --- a/Lib/test/test_threading.py +++ b/Lib/test/test_threading.py @@ -258,7 +258,7 @@ class ThreadingExceptionTests(unittest.TestCase): def test_semaphore_with_negative_value(self): self.assertRaises(ValueError, threading.Semaphore, value = -1) - self.assertRaises(ValueError, threading.Semaphore, value = -sys.maxint) + self.assertRaises(ValueError, threading.Semaphore, value = -sys.maxsize) def test_joining_current_thread(self): currentThread = threading.currentThread() diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py index 70c281f..0014323 100644 --- a/Lib/test/test_types.py +++ b/Lib/test/test_types.py @@ -105,7 +105,7 @@ class TypesTests(unittest.TestCase): if not (xsize*ysize*zsize == zsize*xsize*ysize == 338912): self.fail('int mul commutativity') # And another. - m = -sys.maxint - 1 + m = -sys.maxsize - 1 for divisor in 1, 2, 4, 8, 16, 32: j = m // divisor prod = divisor * j @@ -122,7 +122,7 @@ class TypesTests(unittest.TestCase): self.fail("expected type(%r) to be long, not %r" % (prod, type(prod))) # Check for expected * overflow to long. - m = sys.maxint + m = sys.maxsize for divisor in 1, 2, 4, 8, 16, 32: j = m // divisor + 1 prod = divisor * j @@ -137,7 +137,7 @@ class TypesTests(unittest.TestCase): if (-12) + (-24) != -36: self.fail('long op') if not 12 < 24: self.fail('long op') if not -24 < -12: self.fail('long op') - x = sys.maxint + x = sys.maxsize if int(int(x)) != x: self.fail('long op') try: y = int(int(x)+1) except OverflowError: self.fail('long op') diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py index fe4eb85..eed8492 100644 --- a/Lib/test/test_unicode.py +++ b/Lib/test/test_unicode.py @@ -1055,9 +1055,9 @@ class UnicodeTest( # This test only affects 32-bit platforms because expandtabs can only take # an int as the max value, not a 64-bit C long. If expandtabs is changed # to take a 64-bit long, this test should apply to all platforms. - if sys.maxint > (1 << 32) or struct.calcsize('P') != 4: + if sys.maxsize > (1 << 32) or struct.calcsize('P') != 4: return - self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxint) + self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxsize) def test_main(): diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py index e54ca19..2674716 100644 --- a/Lib/test/test_xmlrpc.py +++ b/Lib/test/test_xmlrpc.py @@ -117,7 +117,7 @@ class XMLRPCTestCase(unittest.TestCase): self.assertRaises(TypeError, xmlrpclib.dumps, (d,)) def test_dump_big_int(self): - if sys.maxint > 2**31-1: + if sys.maxsize > 2**31-1: self.assertRaises(OverflowError, xmlrpclib.dumps, (int(2**34),)) diff --git a/Lib/zipfile.py b/Lib/zipfile.py index 97f639d..b274682 100644 --- a/Lib/zipfile.py +++ b/Lib/zipfile.py @@ -428,7 +428,7 @@ class ZipExtFile: read a whole line. """ if size < 0: - size = sys.maxint + size = sys.maxsize elif size == 0: return b'' @@ -54,6 +54,8 @@ Core and Builtins to longobject.h. It still exists to define several aliases from PyInt_ to PyLong_ functions. +- Removed sys.maxint, use sys.maxsize instead. + Extension Modules ----------------- diff --git a/Objects/longobject.c b/Objects/longobject.c index cf7cb47..1df7c5d 100644 --- a/Objects/longobject.c +++ b/Objects/longobject.c @@ -9,12 +9,6 @@ #include <ctype.h> -long -PyInt_GetMax(void) -{ - return LONG_MAX; /* To initialize sys.maxint */ -} - #ifndef NSMALLPOSINTS #define NSMALLPOSINTS 257 #endif diff --git a/Python/sysmodule.c b/Python/sysmodule.c index e77b1f6..69732cc 100644 --- a/Python/sysmodule.c +++ b/Python/sysmodule.c @@ -1078,8 +1078,6 @@ _PySys_Init(void) PyUnicode_DecodeFSDefault(Py_GetPrefix())); SET_SYS_FROM_STRING("exec_prefix", PyUnicode_DecodeFSDefault(Py_GetExecPrefix())); - SET_SYS_FROM_STRING("maxint", - PyLong_FromLong(PyInt_GetMax())); SET_SYS_FROM_STRING("maxsize", PyLong_FromSsize_t(PY_SSIZE_T_MAX)); SET_SYS_FROM_STRING("float_info", diff --git a/Tools/scripts/h2py.py b/Tools/scripts/h2py.py index 510714d..58acb82 100755 --- a/Tools/scripts/h2py.py +++ b/Tools/scripts/h2py.py @@ -96,13 +96,13 @@ def pytify(body): body = p_char.sub('ord(\\0)', body) # Compute negative hexadecimal constants start = 0 - UMAX = 2*(sys.maxint+1) + UMAX = 2*(sys.maxsize+1) while 1: m = p_hex.search(body, start) if not m: break s,e = m.span() val = long(body[slice(*m.span(1))], 16) - if val > sys.maxint: + if val > sys.maxsize: val -= UMAX body = body[:s] + "(" + str(val) + ")" + body[e:] start = s + 1 diff --git a/Tools/unicode/makeunicodedata.py b/Tools/unicode/makeunicodedata.py index 3778efa..5b5b5dc 100644 --- a/Tools/unicode/makeunicodedata.py +++ b/Tools/unicode/makeunicodedata.py @@ -948,7 +948,7 @@ def splitbins(t, trace=0): n >>= 1 maxshift += 1 del n - bytes = sys.maxint # smallest total size so far + bytes = sys.maxsize # smallest total size so far t = tuple(t) # so slices can be dict keys for shift in range(maxshift + 1): t1 = [] @@ -1074,7 +1074,7 @@ class PyBuildExt(build_ext): ['cjkcodecs/_codecs_%s.c' % loc])) # Dynamic loading module - if sys.maxint == 0x7fffffff: + if sys.maxsize == 0x7fffffff: # This requires sizeof(int) == sizeof(long) == sizeof(char*) dl_inc = find_file('dlfcn.h', [], inc_dirs) if (dl_inc is not None) and (platform not in ['atheos']): |