mirror of
https://github.com/RustPython/RustPython.git
synced 2026-10-28 18:59:04 +08:00
Synchronize core language tests with Python 3.15 (#9300)
Regenerate eight canonical language and container test modules using scripts/update_lib at CPython d220409a13b77de7a6c30abe16ea90db01528edc. Retain RustPython adaptations except the formatting expected-failure marker confirmed stale by an XPASS and a subsequent unmarked pass. AI-assisted source selection, synchronization, dependency review and bounded validation using OpenAI Codex. Assisted-by: Codex:unknown
This commit is contained in:
youknowdot authored and GitHub committed
1 parent
eb03691084
commit
4cb36ea8f2
8 files changed
+565
-112
No files matched your search
Vendored
+95
-26
@@ -2,7 +2,7 @@
|
||||
|
||||
import unittest
|
||||
from test import support
|
||||
from test.support import cpython_only, import_helper, script_helper
|
||||
from test.support import cpython_only, import_helper, isolation
|
||||
|
||||
testmeths = [
|
||||
|
||||
@@ -449,7 +449,6 @@ class ClassTests(unittest.TestCase):
|
||||
|
||||
def testHasAttrString(self):
|
||||
import sys
|
||||
from test.support import import_helper
|
||||
_testlimitedcapi = import_helper.import_module('_testlimitedcapi')
|
||||
|
||||
class A:
|
||||
@@ -557,6 +556,7 @@ class ClassTests(unittest.TestCase):
|
||||
self.assertFalse(hasattr(c, "__call__"))
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON; segmentation fault")
|
||||
@support.skip_if_huge_c_stack()
|
||||
@support.skip_emscripten_stack_overflow()
|
||||
@support.skip_wasi_stack_overflow()
|
||||
def testSFBug532646(self):
|
||||
@@ -653,6 +653,7 @@ class ClassTests(unittest.TestCase):
|
||||
a = A(hash(A.f)^(-1))
|
||||
hash(a.f)
|
||||
|
||||
@cpython_only
|
||||
def testSetattrWrapperNameIntern(self):
|
||||
# Issue #25794: __setattr__ should intern the attribute name
|
||||
class A:
|
||||
@@ -1014,36 +1015,104 @@ class TestInlineValues(unittest.TestCase):
|
||||
C.a = X()
|
||||
C.a = X()
|
||||
|
||||
@cpython_only
|
||||
@support.nomemtest
|
||||
@isolation.runInSubprocess()
|
||||
def test_detach_materialized_dict_no_memory(self):
|
||||
# Skip test if _testcapi is not available:
|
||||
import_helper.import_module('_testcapi')
|
||||
import _testcapi
|
||||
|
||||
code = """if 1:
|
||||
import test.support
|
||||
import _testcapi
|
||||
class A:
|
||||
def __init__(self):
|
||||
self.a = 1
|
||||
self.b = 2
|
||||
|
||||
class A:
|
||||
def __init__(self):
|
||||
self.a = 1
|
||||
self.b = 2
|
||||
# The failing allocation should be the one which detaches the
|
||||
# dictionary from the object, but other allocations can happen
|
||||
# first, so try to fail every one of the first allocations.
|
||||
raised = False
|
||||
for n in range(20):
|
||||
a = A()
|
||||
d = a.__dict__
|
||||
with test.support.catch_unraisable_exception() as ex:
|
||||
_testcapi.set_nomemory(0, 1)
|
||||
del a
|
||||
assert ex.unraisable.exc_type is MemoryError
|
||||
try:
|
||||
d["a"]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
assert False, "KeyError not raised"
|
||||
"""
|
||||
rc, out, err = script_helper.assert_python_ok("-c", code)
|
||||
self.assertEqual(rc, 0)
|
||||
self.assertFalse(out, msg=out.decode('utf-8'))
|
||||
self.assertFalse(err, msg=err.decode('utf-8'))
|
||||
with support.catch_unraisable_exception() as ex:
|
||||
_testcapi.set_nomemory(n, n + 1)
|
||||
try:
|
||||
del a
|
||||
finally:
|
||||
_testcapi.remove_mem_hooks()
|
||||
exc_type = ex.unraisable and ex.unraisable.exc_type
|
||||
except MemoryError:
|
||||
# The failing allocation was not in the deallocation code.
|
||||
continue
|
||||
if exc_type is not MemoryError:
|
||||
continue
|
||||
raised = True
|
||||
if "a" not in d:
|
||||
# The dictionary was cleared, as expected.
|
||||
break
|
||||
else:
|
||||
if not raised:
|
||||
self.fail("MemoryError was not raised during deallocation")
|
||||
self.fail("the dictionary was not cleared")
|
||||
|
||||
class DefinitionOrderTests(unittest.TestCase):
|
||||
# PEP 520: Preserving Class Attribute Definition Order
|
||||
|
||||
@staticmethod
|
||||
def defined_names(namespace):
|
||||
# Skip the names added by the compiler, like __firstlineno__.
|
||||
return [name for name in namespace if not name.startswith('__')]
|
||||
|
||||
def test_definition_order(self):
|
||||
class C:
|
||||
b = 1
|
||||
a = 2
|
||||
def m(self): pass
|
||||
@staticmethod
|
||||
def s(): pass
|
||||
z = 3
|
||||
|
||||
self.assertEqual(self.defined_names(C.__dict__),
|
||||
['b', 'a', 'm', 's', 'z'])
|
||||
|
||||
def test_definition_order_redefinition(self):
|
||||
class C:
|
||||
b = 1
|
||||
a = 2
|
||||
b = 3
|
||||
|
||||
self.assertEqual(self.defined_names(C.__dict__), ['b', 'a'])
|
||||
self.assertEqual(C.b, 3)
|
||||
|
||||
def test_definition_order_after_deletion(self):
|
||||
class C:
|
||||
a = 1
|
||||
b = 2
|
||||
del a
|
||||
a = 3
|
||||
|
||||
self.assertEqual(self.defined_names(C.__dict__), ['b', 'a'])
|
||||
|
||||
def test_definition_order_in_namespace(self):
|
||||
namespaces = []
|
||||
class Meta(type):
|
||||
def __new__(mcls, name, bases, namespace, **kwds):
|
||||
namespaces.append(list(namespace))
|
||||
return super().__new__(mcls, name, bases, namespace, **kwds)
|
||||
|
||||
class C(metaclass=Meta):
|
||||
b = 1
|
||||
a = 2
|
||||
def m(self): pass
|
||||
|
||||
self.assertEqual(self.defined_names(namespaces[0]), ['b', 'a', 'm'])
|
||||
|
||||
def test_prepare_preserves_order(self):
|
||||
namespace = type.__prepare__('C', ())
|
||||
namespace['b'] = 1
|
||||
namespace['a'] = 2
|
||||
namespace['b'] = 3
|
||||
self.assertEqual(list(namespace), ['b', 'a'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Vendored
+41
-8
@@ -1,6 +1,8 @@
|
||||
import errno
|
||||
import unittest
|
||||
import sys
|
||||
from test import support
|
||||
from test.support import import_helper
|
||||
from test.support.testcase import ComplexesAreIdenticalMixin
|
||||
from test.support.numbers import (
|
||||
VALID_UNDERSCORE_LITERALS,
|
||||
@@ -9,6 +11,7 @@ from test.support.numbers import (
|
||||
|
||||
from random import random
|
||||
from math import isnan, copysign
|
||||
import cmath
|
||||
import operator
|
||||
|
||||
INF = float("inf")
|
||||
@@ -505,17 +508,25 @@ class ComplexTest(ComplexesAreIdenticalMixin, unittest.TestCase):
|
||||
with self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'imag' must be a real number, not complex"):
|
||||
check(complex(0.0, 4.25j), -4.25, 0.0)
|
||||
with self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'real' must be a real number, not complex"):
|
||||
with (self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'real' must be a real number, not complex"),
|
||||
self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'imag' must be a real number, not complex")):
|
||||
check(complex(4.25+0j, 0j), 4.25, 0.0)
|
||||
with self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'real' must be a real number, not complex"):
|
||||
with (self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'real' must be a real number, not complex"),
|
||||
self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'imag' must be a real number, not complex")):
|
||||
check(complex(4.25j, 0j), 0.0, 4.25)
|
||||
with self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'real' must be a real number, not complex"):
|
||||
with (self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'real' must be a real number, not complex"),
|
||||
self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'imag' must be a real number, not complex")):
|
||||
check(complex(0j, 4.25+0j), 0.0, 4.25)
|
||||
with self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'real' must be a real number, not complex"):
|
||||
with (self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'real' must be a real number, not complex"),
|
||||
self.assertWarnsRegex(DeprecationWarning,
|
||||
"argument 'imag' must be a real number, not complex")):
|
||||
check(complex(0j, 4.25j), -4.25, 0.0)
|
||||
|
||||
check(complex(real=4.25), 4.25, 0.0)
|
||||
@@ -782,8 +793,30 @@ class ComplexTest(ComplexesAreIdenticalMixin, unittest.TestCase):
|
||||
for num in nums:
|
||||
self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num))
|
||||
|
||||
for x in 0.0, -0.0, INF, -INF, NAN:
|
||||
for y in 0.0, -0.0, INF, -INF, NAN:
|
||||
with self.subTest(x=x, y=y):
|
||||
z = complex(x, y)
|
||||
r = abs(z)
|
||||
if cmath.isfinite(z):
|
||||
self.assertFloatsAreIdentical(r, 0.0)
|
||||
elif cmath.isinf(z):
|
||||
self.assertEqual(r, INF)
|
||||
else:
|
||||
self.assertTrue(cmath.isnan(z))
|
||||
self.assertTrue(isnan(r))
|
||||
|
||||
self.assertRaises(OverflowError, abs, complex(DBL_MAX, DBL_MAX))
|
||||
|
||||
def test_abs_errno_handling(self):
|
||||
_testcapi = import_helper.import_module('_testcapi')
|
||||
z = complex('nan')
|
||||
_testcapi.set_errno(errno.ERANGE)
|
||||
try:
|
||||
self.assertTrue(isnan(abs(z)))
|
||||
finally:
|
||||
_testcapi.set_errno(0)
|
||||
|
||||
def test_repr_str(self):
|
||||
def test(v, expected, test_fn=self.assertEqual):
|
||||
test_fn(repr(v), expected)
|
||||
|
||||
Vendored
+2
-2
@@ -3,7 +3,7 @@ import copy
|
||||
import pickle
|
||||
import unittest
|
||||
from test.support import (skip_emscripten_stack_overflow,
|
||||
skip_wasi_stack_overflow, run_with_limited_c_stack,
|
||||
skip_wasi_stack_overflow, skip_if_huge_c_stack,
|
||||
exceeds_recursion_limit)
|
||||
|
||||
class DictSetTest(unittest.TestCase):
|
||||
@@ -280,7 +280,7 @@ class DictSetTest(unittest.TestCase):
|
||||
self.assertIsInstance(r, str)
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON; segfault")
|
||||
@run_with_limited_c_stack()
|
||||
@skip_if_huge_c_stack()
|
||||
@skip_wasi_stack_overflow()
|
||||
@skip_emscripten_stack_overflow()
|
||||
def test_deeply_nested_repr(self):
|
||||
|
||||
Vendored
+229
-62
@@ -57,10 +57,6 @@ def testcommon(formatstr, args, output=None, limit=None, overflowok=False):
|
||||
else:
|
||||
b_format = formatstr
|
||||
ba_format = bytearray(b_format)
|
||||
b_args = []
|
||||
if not isinstance(args, tuple):
|
||||
args = (args, )
|
||||
b_args = tuple(args)
|
||||
if output is None:
|
||||
b_output = ba_output = None
|
||||
else:
|
||||
@@ -69,33 +65,23 @@ def testcommon(formatstr, args, output=None, limit=None, overflowok=False):
|
||||
else:
|
||||
b_output = output
|
||||
ba_output = bytearray(b_output)
|
||||
testformat(b_format, b_args, b_output, limit, overflowok)
|
||||
testformat(ba_format, b_args, ba_output, limit, overflowok)
|
||||
testformat(b_format, args, b_output, limit, overflowok)
|
||||
testformat(ba_format, args, ba_output, limit, overflowok)
|
||||
|
||||
def test_exc(formatstr, args, exception, excmsg):
|
||||
try:
|
||||
testformat(formatstr, args)
|
||||
except exception as exc:
|
||||
if str(exc) == excmsg:
|
||||
if verbose:
|
||||
print("yes")
|
||||
else:
|
||||
if verbose: print('no')
|
||||
print('Unexpected ', exception, ':', repr(str(exc)))
|
||||
except:
|
||||
if verbose: print('no')
|
||||
print('Unexpected exception')
|
||||
raise
|
||||
else:
|
||||
raise TestFailed('did not get expected exception: %s' % excmsg)
|
||||
|
||||
def test_exc_common(formatstr, args, exception, excmsg):
|
||||
# test str and bytes
|
||||
test_exc(formatstr, args, exception, excmsg)
|
||||
test_exc(formatstr.encode('ascii'), args, exception, excmsg)
|
||||
|
||||
class FormatTest(unittest.TestCase):
|
||||
|
||||
def check_exc(self, formatstr, args, exception, excmsg):
|
||||
with self.assertRaisesRegex(exception, re.escape(excmsg)):
|
||||
testformat(formatstr, args)
|
||||
|
||||
def check_exc_common(self, formatstr, args, exception, excmsg):
|
||||
# test str and bytes
|
||||
self.check_exc(formatstr, args, exception, excmsg)
|
||||
if isinstance(args, dict):
|
||||
args = {k.encode('ascii'): v for k, v in args.items()}
|
||||
self.check_exc(formatstr.encode('ascii'), args, exception, excmsg)
|
||||
|
||||
def test_common_format(self):
|
||||
# test the format identifiers that work the same across
|
||||
# str, bytes, and bytearrays (integer, float, oct, hex)
|
||||
@@ -272,45 +258,156 @@ class FormatTest(unittest.TestCase):
|
||||
|
||||
if verbose:
|
||||
print('Testing exceptions')
|
||||
test_exc_common('%', (), ValueError, "incomplete format")
|
||||
test_exc_common('% %s', 1, ValueError,
|
||||
"unsupported format character '%' (0x25) at index 2")
|
||||
test_exc_common = self.check_exc_common
|
||||
test_exc_common('abc %', (), ValueError, "stray % at position 4")
|
||||
test_exc_common('abc % %s', 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character '%' at position 6")
|
||||
test_exc_common('abc %z', 1, ValueError,
|
||||
"unsupported format %z at position 4")
|
||||
test_exc_common("abc %Id", 1, ValueError,
|
||||
"unsupported format %I at position 4")
|
||||
test_exc_common("abc %'d", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character \"'\" at position 5")
|
||||
test_exc_common("abc %1 d", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character ' ' at position 6")
|
||||
test_exc_common('abc % (x)r', {}, ValueError,
|
||||
"stray % at position 4 or unexpected format character '(' at position 6")
|
||||
test_exc_common('abc %((x)r', {}, ValueError,
|
||||
"stray % or incomplete format key at position 4")
|
||||
test_exc_common('%r %r', 1, TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%r %r', (1,), TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%r', (), TypeError,
|
||||
"not enough arguments for format string (got 0)")
|
||||
test_exc_common('abc %' + '9'*50 + 'r', 1, ValueError,
|
||||
"width too big at position 4")
|
||||
test_exc_common('abc %.' + '9'*50 + 'r', 1, ValueError,
|
||||
"precision too big at position 4")
|
||||
test_exc_common('%r %*r', 1, TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%r %*r', (1,), TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%*r', (1,), TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%*r', (), TypeError,
|
||||
"not enough arguments for format string (got 0)")
|
||||
test_exc_common('%r %.*r', 1, TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%r %.*r', (1,), TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%.*r', (1,), TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%.*r', (), TypeError,
|
||||
"not enough arguments for format string (got 0)")
|
||||
test_exc_common('%(x)r', 1, TypeError,
|
||||
"format requires a mapping, not int")
|
||||
test_exc_common('%*r', 1, TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%*r', 3.14, TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%*r', (3.14, 1), TypeError,
|
||||
"format argument 1: * requires int, not float")
|
||||
test_exc_common('%.*r', 1, TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%.*r', 3.14, TypeError,
|
||||
"not enough arguments for format string (got 1)")
|
||||
test_exc_common('%.*r', (3.14, 1), TypeError,
|
||||
"format argument 1: * requires int, not float")
|
||||
test_exc_common('%*r', (2**1000, 1), OverflowError,
|
||||
"format argument 1: too big for width")
|
||||
test_exc_common('%*r', (-2**1000, 1), OverflowError,
|
||||
"format argument 1: too big for width")
|
||||
test_exc_common('%.*r', (2**1000, 1), OverflowError,
|
||||
"format argument 1: too big for precision")
|
||||
test_exc_common('%.*r', (-2**1000, 1), OverflowError,
|
||||
"format argument 1: too big for precision")
|
||||
test_exc_common('%d', '1', TypeError,
|
||||
"%d format: a real number is required, not str")
|
||||
"format argument: %d requires a real number, not str")
|
||||
test_exc_common('%d', b'1', TypeError,
|
||||
"%d format: a real number is required, not bytes")
|
||||
"format argument: %d requires a real number, not bytes")
|
||||
test_exc_common('%d', ('1',), TypeError,
|
||||
"format argument 1: %d requires a real number, not str")
|
||||
test_exc_common('%x', '1', TypeError,
|
||||
"%x format: an integer is required, not str")
|
||||
"format argument: %x requires an integer, not str")
|
||||
test_exc_common('%x', 3.14, TypeError,
|
||||
"%x format: an integer is required, not float")
|
||||
"format argument: %x requires an integer, not float")
|
||||
test_exc_common('%x', ('1',), TypeError,
|
||||
"format argument 1: %x requires an integer, not str")
|
||||
test_exc_common('%i', '1', TypeError,
|
||||
"%i format: a real number is required, not str")
|
||||
"format argument: %i requires a real number, not str")
|
||||
test_exc_common('%i', b'1', TypeError,
|
||||
"%i format: a real number is required, not bytes")
|
||||
"format argument: %i requires a real number, not bytes")
|
||||
test_exc_common('%g', '1', TypeError,
|
||||
"format argument: %g requires a real number, not str")
|
||||
test_exc_common('%g', ('1',), TypeError,
|
||||
"format argument 1: %g requires a real number, not str")
|
||||
|
||||
def test_str_format(self):
|
||||
testformat("%r", "\u0378", "'\\u0378'") # non printable
|
||||
testformat("%a", "\u0378", "'\\u0378'") # non printable
|
||||
testformat("%r", "\u0374", "'\u0374'") # printable
|
||||
testformat("%a", "\u0374", "'\\u0374'") # printable
|
||||
testformat('%(x)r', {'x': 1}, '1')
|
||||
|
||||
# Test exception for unknown format characters, etc.
|
||||
if verbose:
|
||||
print('Testing exceptions')
|
||||
test_exc = self.check_exc
|
||||
test_exc('abc %b', 1, ValueError,
|
||||
"unsupported format character 'b' (0x62) at index 5")
|
||||
#test_exc(unicode('abc %\u3000','raw-unicode-escape'), 1, ValueError,
|
||||
# "unsupported format character '?' (0x3000) at index 5")
|
||||
test_exc('%g', '1', TypeError, "must be real number, not str")
|
||||
"unsupported format %b at position 4")
|
||||
test_exc("abc %\nd", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character U+000A at position 5")
|
||||
test_exc("abc %\x1fd", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character U+001F at position 5")
|
||||
test_exc("abc %\x7fd", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character U+007F at position 5")
|
||||
test_exc("abc %\x80d", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character U+0080 at position 5")
|
||||
test_exc('abc %äd', 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character 'ä' (U+00E4) at position 5")
|
||||
test_exc('abc %€d', 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character '€' (U+20AC) at position 5")
|
||||
test_exc('no format', '1', TypeError,
|
||||
"not all arguments converted during string formatting")
|
||||
test_exc('%c', -1, OverflowError, "%c arg not in range(0x110000)")
|
||||
"not all arguments converted during string formatting (required 0, got 1)")
|
||||
test_exc('%r', (1, 2), TypeError,
|
||||
"not all arguments converted during string formatting (required 1, got 2)")
|
||||
test_exc('%(x)r %r', {'x': 1}, ValueError,
|
||||
"format requires a parenthesised mapping key at position 6")
|
||||
test_exc('%(x)*r', {'x': 1}, ValueError,
|
||||
"* cannot be used with a parenthesised mapping key at position 0")
|
||||
test_exc('%(x).*r', {'x': 1}, ValueError,
|
||||
"* cannot be used with a parenthesised mapping key at position 0")
|
||||
test_exc('%(x)d', {'x': '1'}, TypeError,
|
||||
"format argument 'x': %d requires a real number, not str")
|
||||
test_exc('%(x)x', {'x': '1'}, TypeError,
|
||||
"format argument 'x': %x requires an integer, not str")
|
||||
test_exc('%(x)g', {'x': '1'}, TypeError,
|
||||
"format argument 'x': %g requires a real number, not str")
|
||||
test_exc('%c', -1, OverflowError,
|
||||
"format argument: %c argument not in range(0x110000)")
|
||||
test_exc('%c', (-1,), OverflowError,
|
||||
"format argument 1: %c argument not in range(0x110000)")
|
||||
test_exc('%(x)c', {'x': -1}, OverflowError,
|
||||
"format argument 'x': %c argument not in range(0x110000)")
|
||||
test_exc('%c', sys.maxunicode+1, OverflowError,
|
||||
"%c arg not in range(0x110000)")
|
||||
#test_exc('%c', 2**128, OverflowError, "%c arg not in range(0x110000)")
|
||||
test_exc('%c', 3.14, TypeError, "%c requires an int or a unicode character, not float")
|
||||
test_exc('%c', 'ab', TypeError, "%c requires an int or a unicode character, not a string of length 2")
|
||||
test_exc('%c', b'x', TypeError, "%c requires an int or a unicode character, not bytes")
|
||||
"format argument: %c argument not in range(0x110000)")
|
||||
test_exc('%c', 2**128, OverflowError,
|
||||
"format argument: %c argument not in range(0x110000)")
|
||||
test_exc('%c', 3.14, TypeError,
|
||||
"format argument: %c requires an integer or a unicode character, not float")
|
||||
test_exc('%c', (3.14,), TypeError,
|
||||
"format argument 1: %c requires an integer or a unicode character, not float")
|
||||
test_exc('%(x)c', {'x': 3.14}, TypeError,
|
||||
"format argument 'x': %c requires an integer or a unicode character, not float")
|
||||
test_exc('%c', 'ab', TypeError,
|
||||
"format argument: %c requires an integer or a unicode character, not a string of length 2")
|
||||
test_exc('%c', ('ab',), TypeError,
|
||||
"format argument 1: %c requires an integer or a unicode character, not a string of length 2")
|
||||
test_exc('%(x)c', {'x': 'ab'}, TypeError,
|
||||
"format argument 'x': %c requires an integer or a unicode character, not a string of length 2")
|
||||
test_exc('%c', b'x', TypeError,
|
||||
"format argument: %c requires an integer or a unicode character, not bytes")
|
||||
|
||||
if maxsize == 2**31-1:
|
||||
# crashes 2.2.1 and earlier:
|
||||
@@ -355,36 +452,84 @@ class FormatTest(unittest.TestCase):
|
||||
testcommon(b"%r", b"ghi", b"b'ghi'")
|
||||
testcommon(b"%r", "jkl", b"'jkl'")
|
||||
testcommon(b"%r", "\u0544", b"'\\u0544'")
|
||||
testcommon(b'%(x)r', {b'x': 1}, b'1')
|
||||
|
||||
# Test exception for unknown format characters, etc.
|
||||
if verbose:
|
||||
print('Testing exceptions')
|
||||
test_exc(b'%g', '1', TypeError, "float argument required, not str")
|
||||
test_exc(b'%g', b'1', TypeError, "float argument required, not bytes")
|
||||
test_exc = self.check_exc
|
||||
test_exc(b"abc %\nd", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character with code 0x0a at position 5")
|
||||
test_exc(b"abc %'d", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character \"'\" at position 5")
|
||||
test_exc(b"abc %\x1fd", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character with code 0x1f at position 5")
|
||||
test_exc(b"abc %\x7fd", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character with code 0x7f at position 5")
|
||||
test_exc(b"abc %\x80d", 1, ValueError,
|
||||
"stray % at position 4 or unexpected format character with code 0x80 at position 5")
|
||||
test_exc(b'no format', 7, TypeError,
|
||||
"not all arguments converted during bytes formatting")
|
||||
"not all arguments converted during bytes formatting (required 0, got 1)")
|
||||
test_exc(b'no format', b'1', TypeError,
|
||||
"not all arguments converted during bytes formatting")
|
||||
"not all arguments converted during bytes formatting (required 0, got 1)")
|
||||
test_exc(b'no format', bytearray(b'1'), TypeError,
|
||||
"not all arguments converted during bytes formatting")
|
||||
"not all arguments converted during bytes formatting (required 0, got 1)")
|
||||
test_exc(b'%r', (1, 2), TypeError,
|
||||
"not all arguments converted during bytes formatting (required 1, got 2)")
|
||||
test_exc(b'%(x)r %r', {b'x': 1}, ValueError,
|
||||
"format requires a parenthesised mapping key at position 6")
|
||||
test_exc(b'%(x)*r', {b'x': 1}, ValueError,
|
||||
"* cannot be used with a parenthesised mapping key at position 0")
|
||||
test_exc(b'%(x).*r', {b'x': 1}, ValueError,
|
||||
"* cannot be used with a parenthesised mapping key at position 0")
|
||||
test_exc(b'%(x)d', {b'x': '1'}, TypeError,
|
||||
"format argument b'x': %d requires a real number, not str")
|
||||
test_exc(b'%(x)x', {b'x': '1'}, TypeError,
|
||||
"format argument b'x': %x requires an integer, not str")
|
||||
test_exc(b'%(x)g', {b'x': '1'}, TypeError,
|
||||
"format argument b'x': %g requires a real number, not str")
|
||||
test_exc(b"%c", -1, OverflowError,
|
||||
"%c arg not in range(256)")
|
||||
"format argument: %c argument not in range(256)")
|
||||
test_exc(b"%c", (-1,), OverflowError,
|
||||
"format argument 1: %c argument not in range(256)")
|
||||
test_exc(b"%(x)c", {b'x': -1}, OverflowError,
|
||||
"format argument b'x': %c argument not in range(256)")
|
||||
test_exc(b"%c", 256, OverflowError,
|
||||
"%c arg not in range(256)")
|
||||
"format argument: %c argument not in range(256)")
|
||||
test_exc(b"%c", 2**128, OverflowError,
|
||||
"%c arg not in range(256)")
|
||||
"format argument: %c argument not in range(256)")
|
||||
test_exc(b"%c", b"Za", TypeError,
|
||||
"%c requires an integer in range(256) or a single byte, not a bytes object of length 2")
|
||||
"format argument: %c requires an integer in range(256) or a single byte, not a bytes object of length 2")
|
||||
test_exc(b"%c", (b"Za",), TypeError,
|
||||
"format argument 1: %c requires an integer in range(256) or a single byte, not a bytes object of length 2")
|
||||
test_exc(b"%(x)c", {b'x': b"Za"}, TypeError,
|
||||
"format argument b'x': %c requires an integer in range(256) or a single byte, not a bytes object of length 2")
|
||||
test_exc(b"%c", bytearray(b"Za"), TypeError,
|
||||
"format argument: %c requires an integer in range(256) or a single byte, not a bytearray object of length 2")
|
||||
test_exc(b"%c", (bytearray(b"Za"),), TypeError,
|
||||
"format argument 1: %c requires an integer in range(256) or a single byte, not a bytearray object of length 2")
|
||||
test_exc(b"%(x)c", {b'x': bytearray(b"Za")}, TypeError,
|
||||
"format argument b'x': %c requires an integer in range(256) or a single byte, not a bytearray object of length 2")
|
||||
test_exc(b"%c", "Y", TypeError,
|
||||
"%c requires an integer in range(256) or a single byte, not str")
|
||||
"format argument: %c requires an integer in range(256) or a single byte, not str")
|
||||
test_exc(b"%c", 3.14, TypeError,
|
||||
"%c requires an integer in range(256) or a single byte, not float")
|
||||
"format argument: %c requires an integer in range(256) or a single byte, not float")
|
||||
test_exc(b"%c", (3.14,), TypeError,
|
||||
"format argument 1: %c requires an integer in range(256) or a single byte, not float")
|
||||
test_exc(b"%(x)c", {b'x': 3.14}, TypeError,
|
||||
"format argument b'x': %c requires an integer in range(256) or a single byte, not float")
|
||||
test_exc(b"%b", "Xc", TypeError,
|
||||
"%b requires a bytes-like object, "
|
||||
"or an object that implements __bytes__, not 'str'")
|
||||
"format argument: %b requires a bytes-like object, "
|
||||
"or an object that implements __bytes__, not str")
|
||||
test_exc(b"%b", ("Xc",), TypeError,
|
||||
"format argument 1: %b requires a bytes-like object, "
|
||||
"or an object that implements __bytes__, not str")
|
||||
test_exc(b"%(x)b", {b'x': "Xc"}, TypeError,
|
||||
"format argument b'x': %b requires a bytes-like object, "
|
||||
"or an object that implements __bytes__, not str")
|
||||
test_exc(b"%s", "Wd", TypeError,
|
||||
"%b requires a bytes-like object, "
|
||||
"or an object that implements __bytes__, not 'str'")
|
||||
"format argument: %b requires a bytes-like object, "
|
||||
"or an object that implements __bytes__, not str")
|
||||
|
||||
if maxsize == 2**31-1:
|
||||
# crashes 2.2.1 and earlier:
|
||||
@@ -494,6 +639,28 @@ class FormatTest(unittest.TestCase):
|
||||
with self.assertRaises(ValueError) as cm:
|
||||
format(c, ".%sf" % (INT_MAX + 1))
|
||||
|
||||
@support.cpython_only
|
||||
def test_precision_near_int_max(self):
|
||||
# gh-158446: Precisions just below INT_MAX are rejected before any
|
||||
# output buffer size is computed from them.
|
||||
_testcapi = import_module("_testcapi")
|
||||
INT_MAX = _testcapi.INT_MAX
|
||||
|
||||
f = 1e300
|
||||
c = complex(f)
|
||||
for prec in (INT_MAX, INT_MAX - 1023):
|
||||
for code in "feg":
|
||||
spec = ".%d%s" % (prec, code)
|
||||
with self.subTest(spec=spec):
|
||||
with self.assertRaises(ValueError):
|
||||
format(f, spec)
|
||||
with self.assertRaises(ValueError):
|
||||
format(c, spec)
|
||||
with self.assertRaises(ValueError):
|
||||
("%" + spec) % f
|
||||
with self.assertRaises(ValueError):
|
||||
("%" + spec).encode() % f
|
||||
|
||||
def test_g_format_has_no_trailing_zeros(self):
|
||||
# regression test for bugs.python.org/issue40780
|
||||
self.assertEqual("%.3g" % 1505.0, "1.5e+03")
|
||||
|
||||
Vendored
+7
-2
@@ -1,8 +1,6 @@
|
||||
# Python test set -- part 1, grammar.
|
||||
# This just tests whether the parser accepts them all.
|
||||
|
||||
from test.support import check_syntax_error, skip_wasi_stack_overflow
|
||||
from test.support import import_helper
|
||||
import annotationlib
|
||||
import inspect
|
||||
import unittest
|
||||
@@ -18,6 +16,12 @@ import test.typinganndata.ann_module as ann_module
|
||||
import typing
|
||||
from test.typinganndata import ann_module2
|
||||
import test
|
||||
from test.support import (
|
||||
check_syntax_error,
|
||||
import_helper,
|
||||
skip_emscripten_stack_overflow,
|
||||
skip_wasi_stack_overflow,
|
||||
)
|
||||
from test.support.numbers import (
|
||||
VALID_UNDERSCORE_LITERALS,
|
||||
INVALID_UNDERSCORE_LITERALS,
|
||||
@@ -250,6 +254,7 @@ the \'lazy\' dog.\n\
|
||||
self.assertIn("was never closed", str(cm.exception))
|
||||
|
||||
@skip_wasi_stack_overflow()
|
||||
@skip_emscripten_stack_overflow()
|
||||
def test_max_level(self):
|
||||
# Macro defined in Parser/lexer/state.h
|
||||
MAXLEVEL = 200
|
||||
|
||||
Vendored
+16
@@ -2,6 +2,7 @@ import unittest
|
||||
import inspect
|
||||
import pickle
|
||||
import sys
|
||||
import weakref
|
||||
from decimal import Decimal
|
||||
from fractions import Fraction
|
||||
|
||||
@@ -511,6 +512,21 @@ class OperatorTestCase:
|
||||
f = operator.methodcaller('return_arguments', *many_positional_arguments, **many_kw_arguments)
|
||||
self.assertEqual(f(a), (many_positional_arguments, many_kw_arguments))
|
||||
|
||||
def test_methodcaller_cyclic_gc(self):
|
||||
# gh-156762: Check for undefined behavior on calling methodcaller_clear()
|
||||
operator = self.module
|
||||
|
||||
class C:
|
||||
pass
|
||||
|
||||
c = C()
|
||||
ref = weakref.ref(c)
|
||||
c.m = operator.methodcaller('foo', c)
|
||||
del c
|
||||
|
||||
support.gc_collect()
|
||||
self.assertIsNone(ref())
|
||||
|
||||
def test_inplace(self):
|
||||
operator = self.module
|
||||
class C(object):
|
||||
|
||||
Vendored
+119
@@ -2762,6 +2762,97 @@ class TestPatma(unittest.TestCase):
|
||||
self.assertEqual(y, 1)
|
||||
self.assertIs(z, x)
|
||||
|
||||
def test_patma_256(self):
|
||||
x = 0
|
||||
match x:
|
||||
case +0:
|
||||
y = 0
|
||||
self.assertEqual(x, 0)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_257(self):
|
||||
x = 0
|
||||
match x:
|
||||
case +0.0:
|
||||
y = 0
|
||||
self.assertEqual(x, 0)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_258(self):
|
||||
x = 0
|
||||
match x:
|
||||
case +0j:
|
||||
y = 0
|
||||
self.assertEqual(x, 0)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_259(self):
|
||||
x = 0
|
||||
match x:
|
||||
case +0.0j:
|
||||
y = 0
|
||||
self.assertEqual(x, 0)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_260(self):
|
||||
x = 1
|
||||
match x:
|
||||
case +1:
|
||||
y = 0
|
||||
self.assertEqual(x, 1)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_261(self):
|
||||
x = 1.5
|
||||
match x:
|
||||
case +1.5:
|
||||
y = 0
|
||||
self.assertEqual(x, 1.5)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_262(self):
|
||||
x = 1j
|
||||
match x:
|
||||
case +1j:
|
||||
y = 0
|
||||
self.assertEqual(x, 1j)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_263(self):
|
||||
x = 1.5j
|
||||
match x:
|
||||
case +1.5j:
|
||||
y = 0
|
||||
self.assertEqual(x, 1.5j)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_264(self):
|
||||
x = 0.25 + 1.75j
|
||||
match x:
|
||||
case +0.25 + 1.75j:
|
||||
y = 0
|
||||
self.assertEqual(x, 0.25 + 1.75j)
|
||||
self.assertEqual(y, 0)
|
||||
|
||||
def test_patma_265(self):
|
||||
x = 0
|
||||
match x:
|
||||
case +1e1000:
|
||||
y = 0
|
||||
case 0:
|
||||
y = 1
|
||||
self.assertEqual(x, 0)
|
||||
self.assertEqual(y, 1)
|
||||
|
||||
def test_patma_frozendict_class_self(self):
|
||||
x = frozendict()
|
||||
match x:
|
||||
case frozendict(z):
|
||||
y = 0
|
||||
self.assertEqual(x, frozendict())
|
||||
self.assertEqual(y, 0)
|
||||
self.assertIs(z, x)
|
||||
|
||||
def test_patma_runtime_checkable_protocol(self):
|
||||
# Runtime-checkable protocol
|
||||
from typing import Protocol, runtime_checkable
|
||||
@@ -3230,6 +3321,34 @@ class TestSyntaxErrors(unittest.TestCase):
|
||||
pass
|
||||
""")
|
||||
|
||||
def test_duplicate_sign_in_complex_1(self):
|
||||
self.assert_syntax_error("""
|
||||
match ...:
|
||||
case 0 ++ 0j:
|
||||
pass
|
||||
""")
|
||||
|
||||
def test_duplicate_sign_in_complex_2(self):
|
||||
self.assert_syntax_error("""
|
||||
match ...:
|
||||
case 0 -+ 0j:
|
||||
pass
|
||||
""")
|
||||
|
||||
def test_duplicate_sign_in_complex_3(self):
|
||||
self.assert_syntax_error("""
|
||||
match ...:
|
||||
case 0 +- 0j:
|
||||
pass
|
||||
""")
|
||||
|
||||
def test_duplicate_sign_in_complex_4(self):
|
||||
self.assert_syntax_error("""
|
||||
match ...:
|
||||
case 0 -- 0j:
|
||||
pass
|
||||
""")
|
||||
|
||||
class TestTypeErrors(unittest.TestCase):
|
||||
|
||||
def test_accepts_positional_subpatterns_0(self):
|
||||
|
||||
Vendored
+56
-12
@@ -454,6 +454,13 @@ class StrTest(string_tests.StringLikeTest,
|
||||
self.assertEqual("[a\xe9]".translate(str.maketrans({'a': '<\u20ac>'})),
|
||||
"[<\u20ac>\xe9]")
|
||||
|
||||
# with frozendict
|
||||
tbl = self.type2test.maketrans(frozendict({'s': 'S', 'T': 't'}))
|
||||
self.assertEqual(tbl, {ord('s'): 'S', ord('T'): 't'})
|
||||
self.assertEqual('sTan'.translate(tbl), 'Stan')
|
||||
tbl = self.type2test.maketrans(frozendict({'a': None, 'b': '<i>'}))
|
||||
self.checkequalnofix('<i><i><i>c', 'abababc', 'translate', tbl)
|
||||
|
||||
# invalid Unicode characters
|
||||
invalid_char = 0x10ffff+1
|
||||
for before in "a\xe9\u20ac\U0010ffff":
|
||||
@@ -600,6 +607,21 @@ class StrTest(string_tests.StringLikeTest,
|
||||
text = 'abc def'
|
||||
self.assertIs(text.replace(pattern, pattern), text)
|
||||
|
||||
@support.nomemtest
|
||||
def test_replace_oom(self):
|
||||
# https://github.com/python/cpython/issues/152228
|
||||
s1 = "轘" * 4
|
||||
s2 = "&"
|
||||
s3 = "&"
|
||||
assertion = self.assertRaises(MemoryError)
|
||||
_testcapi.set_nomemory(0, 0)
|
||||
try:
|
||||
# No allocations made in the test itself:
|
||||
with assertion:
|
||||
s1.replace(s2, s3) # this line used to crash before
|
||||
finally:
|
||||
_testcapi.remove_mem_hooks()
|
||||
|
||||
def test_repeat_id_preserving(self):
|
||||
a = '123abc1@'
|
||||
b = '456zyx-+'
|
||||
@@ -1499,7 +1521,6 @@ class StrTest(string_tests.StringLikeTest,
|
||||
self.assertEqual('{:{f}}{g}{}'.format(1, 3, g='g', f=2), ' 1g3')
|
||||
self.assertEqual('{f:{}}{}{g}'.format(2, 4, f=1, g='g'), ' 14g')
|
||||
|
||||
@unittest.expectedFailure # TODO: RUSTPYTHON; %c error wording uses bare class name; CPython uses fully qualified module.qualname (e.g. test.test_str.PseudoFloat)
|
||||
def test_formatting(self):
|
||||
string_tests.StringLikeTest.test_formatting(self)
|
||||
# Testing Unicode formatting strings...
|
||||
@@ -1580,17 +1601,40 @@ class StrTest(string_tests.StringLikeTest,
|
||||
self.assertEqual('%X' % letter_m, '6D')
|
||||
self.assertEqual('%o' % letter_m, '155')
|
||||
self.assertEqual('%c' % letter_m, 'm')
|
||||
self.assertRaisesRegex(TypeError, '%x format: an integer is required, not float', operator.mod, '%x', 3.14)
|
||||
self.assertRaisesRegex(TypeError, '%X format: an integer is required, not float', operator.mod, '%X', 2.11)
|
||||
self.assertRaisesRegex(TypeError, '%o format: an integer is required, not float', operator.mod, '%o', 1.79)
|
||||
self.assertRaisesRegex(TypeError, '%x format: an integer is required, not PseudoFloat', operator.mod, '%x', pi)
|
||||
self.assertRaisesRegex(TypeError, '%x format: an integer is required, not complex', operator.mod, '%x', 3j)
|
||||
self.assertRaisesRegex(TypeError, '%X format: an integer is required, not complex', operator.mod, '%X', 2j)
|
||||
self.assertRaisesRegex(TypeError, '%o format: an integer is required, not complex', operator.mod, '%o', 1j)
|
||||
self.assertRaisesRegex(TypeError, '%u format: a real number is required, not complex', operator.mod, '%u', 3j)
|
||||
self.assertRaisesRegex(TypeError, '%i format: a real number is required, not complex', operator.mod, '%i', 2j)
|
||||
self.assertRaisesRegex(TypeError, '%d format: a real number is required, not complex', operator.mod, '%d', 1j)
|
||||
self.assertRaisesRegex(TypeError, r'%c requires an int or a unicode character, not .*\.PseudoFloat', operator.mod, '%c', pi)
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %x requires an integer, not float'):
|
||||
'%x' % 3.14
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %X requires an integer, not float'):
|
||||
'%X' % 2.11
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %o requires an integer, not float'):
|
||||
'%o' % 1.79
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
r'format argument: %x requires an integer, not .*\.PseudoFloat'):
|
||||
'%x' % pi
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %x requires an integer, not complex'):
|
||||
'%x' % 3j
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %X requires an integer, not complex'):
|
||||
'%X' % 2j
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %o requires an integer, not complex'):
|
||||
'%o' % 1j
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %u requires a real number, not complex'):
|
||||
'%u' % 3j
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %i requires a real number, not complex'):
|
||||
'%i' % 2j
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
'format argument: %d requires a real number, not complex'):
|
||||
'%d' % 1j
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
r'format argument: %c requires an integer or a unicode character, '
|
||||
r'not .*\.PseudoFloat'):
|
||||
'%c' % pi
|
||||
|
||||
class RaisingNumber:
|
||||
def __int__(self):
|
||||
|
||||
Reference in new issue
Block a user