mirror of
https://github.com/python/cpython
synced 2024-09-04 15:56:13 +00:00
Removed PyInt_GetMax and sys.maxint
I replaced sys.maxint with sys.maxsize in Lib/*.py. Does anybody see a problem with the change on Win 64bit platforms? Win 64's long is just 32bit but the sys.maxsize is now 2**63-1 on every 64bit platform. Also added docs for sys.maxsize.
This commit is contained in:
parent
327858ef2c
commit
a37d4c693a
|
@ -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:
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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))
|
||||
|
|
|
@ -85,7 +85,7 @@ def __mod__(self, args):
|
|||
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 @@ def encode(self, encoding=None, errors=None): # XXX improve this?
|
|||
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 @@ def replace(self, old, new, maxsplit=-1):
|
|||
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 @@ def split(self, sep=None, maxsplit=-1):
|
|||
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())
|
||||
|
|
|
@ -246,7 +246,7 @@ def _hash(self):
|
|||
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)
|
||||
|
|
|
@ -348,8 +348,8 @@ def __init__(self, name, mode=DEFAULT_MODE, handle=None):
|
|||
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('__'):
|
||||
|
|
|
@ -98,7 +98,7 @@ def _num_version(libname):
|
|||
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)
|
||||
|
|
|
@ -307,13 +307,13 @@ def _dispatch(self, msg):
|
|||
|
||||
|
||||
# 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
|
||||
|
|
|
@ -409,7 +409,7 @@ def seek(self, offset, whence=0):
|
|||
|
||||
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 @@ def readline(self, size=-1):
|
|||
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()
|
||||
|
|
|
@ -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]:
|
||||
|
|
|
@ -365,7 +365,7 @@ def parsesequence(self, seq):
|
|||
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 @@ def _parseindex(self, seq, all):
|
|||
try:
|
||||
return int(seq)
|
||||
except (OverflowError, ValueError):
|
||||
return sys.maxint
|
||||
return sys.maxsize
|
||||
if seq in ('cur', '.'):
|
||||
return self.getcurrent()
|
||||
if seq == 'first':
|
||||
|
|
|
@ -152,7 +152,7 @@ def getwidth(self):
|
|||
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 @@ def getwidth(self):
|
|||
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:
|
||||
|
|
|
@ -344,7 +344,7 @@ class pywintypes:
|
|||
|
||||
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 @@ def __del__(self, sys=sys):
|
|||
# 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)
|
||||
|
|
|
@ -172,9 +172,9 @@ def test_expandtabs(self):
|
|||
|
||||
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())
|
||||
|
|
|
@ -388,8 +388,8 @@ def __eq__(self, other):
|
|||
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)
|
||||
|
|
|
@ -493,7 +493,7 @@ def test_unicode(self):
|
|||
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)
|
||||
|
|
|
@ -140,7 +140,7 @@
|
|||
# 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,
|
||||
|
|
|
@ -265,9 +265,9 @@ def test_expandtabs(self):
|
|||
|
||||
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 @@ def test_split(self):
|
|||
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 @@ def test_split(self):
|
|||
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 @@ def test_rsplit(self):
|
|||
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 @@ def test_rsplit(self):
|
|||
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 @@ def test_replace(self):
|
|||
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 @@ def test_replace(self):
|
|||
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 @@ def test_replace(self):
|
|||
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 @@ def test_replace(self):
|
|||
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 @@ def test_replace(self):
|
|||
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 @@ def test_replace(self):
|
|||
# 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 @@ def test_replace(self):
|
|||
|
||||
# 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 @@ def test_replace(self):
|
|||
# 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 @@ def test_replace(self):
|
|||
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 @@ def test_replace(self):
|
|||
|
||||
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 @@ def test_additional_split(self):
|
|||
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 @@ def test_additional_rsplit(self):
|
|||
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)
|
||||
|
|
|
@ -60,7 +60,7 @@ def write(self, line):
|
|||
(' 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 @@ def test_abs(self):
|
|||
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 @@ def test_any(self):
|
|||
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 @@ def test_divmod(self):
|
|||
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 @@ def test_int(self):
|
|||
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 @@ def test_int(self):
|
|||
# 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 @@ def test_list(self):
|
|||
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 @@ def test_list(self):
|
|||
# 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 @@ def test_range(self):
|
|||
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 @@ def __eq__(self, other):
|
|||
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()
|
||||
|
|
|
@ -36,14 +36,14 @@ def test_empty_sequence(self):
|
|||
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 C:
|
|||
|
||||
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 @@ def test_repeat(self):
|
|||
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))
|
||||
|
|
|
@ -194,24 +194,24 @@ def test_literals_with_leading_zeroes(self):
|
|||
|
||||
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
|
||||
|
|
|
@ -4118,8 +4118,8 @@ def check(expr, x, y):
|
|||
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
|
||||
|
|
|
@ -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')
|
||||
|
|
|
@ -32,8 +32,8 @@ def testPlainIntegers(self):
|
|||
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 @@ def testPlainIntegers(self):
|
|||
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 @@ def testPlainIntegers(self):
|
|||
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
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
|
||||
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
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
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 @@ def test_large_longs(self):
|
|||
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()
|
||||
|
|
|
@ -71,7 +71,7 @@ def test_count(self):
|
|||
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', '')
|
||||
|
|
|
@ -21,7 +21,7 @@ def test_len(self):
|
|||
|
||||
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)
|
||||
|
|
|
@ -233,48 +233,48 @@ def test_misc(self):
|
|||
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 long2(int):
|
|||
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 @@ def __cmp__(self, other):
|
|||
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)
|
||||
|
|
|
@ -28,7 +28,7 @@ def helper(self, sample, *extra):
|
|||
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 @@ def test_floats(self):
|
|||
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)
|
||||
|
|
|
@ -40,7 +40,7 @@ def test_str_decode(self):
|
|||
|
||||
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')
|
||||
|
|
|
@ -114,7 +114,7 @@ def myreplace(exc):
|
|||
'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')
|
||||
|
|
|
@ -51,10 +51,10 @@ def test_range(self):
|
|||
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)')
|
||||
|
|
|
@ -92,7 +92,7 @@ def test_indices(self):
|
|||
)
|
||||
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)
|
||||
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -282,7 +282,7 @@ def test_attributes(self):
|
|||
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))
|
||||
|
|
|
@ -258,7 +258,7 @@ def test_notify_on_unacquired_condition(self):
|
|||
|
||||
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()
|
||||
|
|
|
@ -105,7 +105,7 @@ def test_normal_integers(self):
|
|||
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 @@ def test_normal_integers(self):
|
|||
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 @@ def test_long_integers(self):
|
|||
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')
|
||||
|
|
|
@ -1055,9 +1055,9 @@ def test_expandtabs_overflows_gracefully(self):
|
|||
# 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():
|
||||
|
|
|
@ -117,7 +117,7 @@ def test_dump_recursive_dict(self):
|
|||
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),))
|
||||
|
||||
|
|
|
@ -428,7 +428,7 @@ def readline(self, size = -1):
|
|||
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
|
||||
-----------------
|
||||
|
|
|
@ -9,12 +9,6 @@
|
|||
|
||||
#include <ctype.h>
|
||||
|
||||
long
|
||||
PyInt_GetMax(void)
|
||||
{
|
||||
return LONG_MAX; /* To initialize sys.maxint */
|
||||
}
|
||||
|
||||
#ifndef NSMALLPOSINTS
|
||||
#define NSMALLPOSINTS 257
|
||||
#endif
|
||||
|
|
|
@ -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",
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -948,7 +948,7 @@ def dump(t1, t2, shift, bytes):
|
|||
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 = []
|
||||
|
|
2
setup.py
2
setup.py
|
@ -1074,7 +1074,7 @@ class db_found(Exception): pass
|
|||
['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']):
|
||||
|
|
Loading…
Reference in a new issue