mirror of
https://github.com/RustPython/RustPython.git
synced 2026-10-28 18:59:04 +08:00
Merge pull request #1757 from palaviv/test-baseexception
Add more CPython tests
This commit is contained in:
7 files changed
+1691
No files matched your search
@@ -0,0 +1,65 @@
|
||||
BaseException
|
||||
+-- SystemExit
|
||||
+-- KeyboardInterrupt
|
||||
+-- GeneratorExit
|
||||
+-- Exception
|
||||
+-- StopIteration
|
||||
+-- StopAsyncIteration
|
||||
+-- ArithmeticError
|
||||
| +-- FloatingPointError
|
||||
| +-- OverflowError
|
||||
| +-- ZeroDivisionError
|
||||
+-- AssertionError
|
||||
+-- AttributeError
|
||||
+-- BufferError
|
||||
+-- EOFError
|
||||
+-- ImportError
|
||||
| +-- ModuleNotFoundError
|
||||
+-- LookupError
|
||||
| +-- IndexError
|
||||
| +-- KeyError
|
||||
+-- MemoryError
|
||||
+-- NameError
|
||||
| +-- UnboundLocalError
|
||||
+-- OSError
|
||||
| +-- BlockingIOError
|
||||
| +-- ChildProcessError
|
||||
| +-- ConnectionError
|
||||
| | +-- BrokenPipeError
|
||||
| | +-- ConnectionAbortedError
|
||||
| | +-- ConnectionRefusedError
|
||||
| | +-- ConnectionResetError
|
||||
| +-- FileExistsError
|
||||
| +-- FileNotFoundError
|
||||
| +-- InterruptedError
|
||||
| +-- IsADirectoryError
|
||||
| +-- NotADirectoryError
|
||||
| +-- PermissionError
|
||||
| +-- ProcessLookupError
|
||||
| +-- TimeoutError
|
||||
+-- ReferenceError
|
||||
+-- RuntimeError
|
||||
| +-- NotImplementedError
|
||||
| +-- RecursionError
|
||||
+-- SyntaxError
|
||||
| +-- TargetScopeError
|
||||
| +-- IndentationError
|
||||
| +-- TabError
|
||||
+-- SystemError
|
||||
+-- TypeError
|
||||
+-- ValueError
|
||||
| +-- UnicodeError
|
||||
| +-- UnicodeDecodeError
|
||||
| +-- UnicodeEncodeError
|
||||
| +-- UnicodeTranslateError
|
||||
+-- Warning
|
||||
+-- DeprecationWarning
|
||||
+-- PendingDeprecationWarning
|
||||
+-- RuntimeWarning
|
||||
+-- SyntaxWarning
|
||||
+-- UserWarning
|
||||
+-- FutureWarning
|
||||
+-- ImportWarning
|
||||
+-- UnicodeWarning
|
||||
+-- BytesWarning
|
||||
+-- ResourceWarning
|
||||
@@ -0,0 +1,189 @@
|
||||
import unittest
|
||||
import builtins
|
||||
import os
|
||||
from platform import system as platform_system
|
||||
|
||||
|
||||
class ExceptionClassTests(unittest.TestCase):
|
||||
|
||||
"""Tests for anything relating to exception objects themselves (e.g.,
|
||||
inheritance hierarchy)"""
|
||||
|
||||
def test_builtins_new_style(self):
|
||||
self.assertTrue(issubclass(Exception, object))
|
||||
|
||||
def verify_instance_interface(self, ins):
|
||||
for attr in ("args", "__str__", "__repr__"):
|
||||
self.assertTrue(hasattr(ins, attr),
|
||||
"%s missing %s attribute" %
|
||||
(ins.__class__.__name__, attr))
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_inheritance(self):
|
||||
# Make sure the inheritance hierarchy matches the documentation
|
||||
exc_set = set()
|
||||
for object_ in builtins.__dict__.values():
|
||||
try:
|
||||
if issubclass(object_, BaseException):
|
||||
exc_set.add(object_.__name__)
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
inheritance_tree = open(os.path.join(os.path.split(__file__)[0],
|
||||
'exception_hierarchy.txt'))
|
||||
try:
|
||||
superclass_name = inheritance_tree.readline().rstrip()
|
||||
try:
|
||||
last_exc = getattr(builtins, superclass_name)
|
||||
except AttributeError:
|
||||
self.fail("base class %s not a built-in" % superclass_name)
|
||||
self.assertIn(superclass_name, exc_set,
|
||||
'%s not found' % superclass_name)
|
||||
exc_set.discard(superclass_name)
|
||||
superclasses = [] # Loop will insert base exception
|
||||
last_depth = 0
|
||||
for exc_line in inheritance_tree:
|
||||
exc_line = exc_line.rstrip()
|
||||
depth = exc_line.rindex('-')
|
||||
exc_name = exc_line[depth+2:] # Slice past space
|
||||
if '(' in exc_name:
|
||||
paren_index = exc_name.index('(')
|
||||
platform_name = exc_name[paren_index+1:-1]
|
||||
exc_name = exc_name[:paren_index-1] # Slice off space
|
||||
if platform_system() != platform_name:
|
||||
exc_set.discard(exc_name)
|
||||
continue
|
||||
if '[' in exc_name:
|
||||
left_bracket = exc_name.index('[')
|
||||
exc_name = exc_name[:left_bracket-1] # cover space
|
||||
try:
|
||||
exc = getattr(builtins, exc_name)
|
||||
except AttributeError:
|
||||
self.fail("%s not a built-in exception" % exc_name)
|
||||
if last_depth < depth:
|
||||
superclasses.append((last_depth, last_exc))
|
||||
elif last_depth > depth:
|
||||
while superclasses[-1][0] >= depth:
|
||||
superclasses.pop()
|
||||
self.assertTrue(issubclass(exc, superclasses[-1][1]),
|
||||
"%s is not a subclass of %s" % (exc.__name__,
|
||||
superclasses[-1][1].__name__))
|
||||
try: # Some exceptions require arguments; just skip them
|
||||
self.verify_instance_interface(exc())
|
||||
except TypeError:
|
||||
pass
|
||||
self.assertIn(exc_name, exc_set)
|
||||
exc_set.discard(exc_name)
|
||||
last_exc = exc
|
||||
last_depth = depth
|
||||
finally:
|
||||
inheritance_tree.close()
|
||||
self.assertEqual(len(exc_set), 0, "%s not accounted for" % exc_set)
|
||||
|
||||
interface_tests = ("length", "args", "str", "repr")
|
||||
|
||||
def interface_test_driver(self, results):
|
||||
for test_name, (given, expected) in zip(self.interface_tests, results):
|
||||
self.assertEqual(given, expected, "%s: %s != %s" % (test_name,
|
||||
given, expected))
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_interface_single_arg(self):
|
||||
# Make sure interface works properly when given a single argument
|
||||
arg = "spam"
|
||||
exc = Exception(arg)
|
||||
results = ([len(exc.args), 1], [exc.args[0], arg],
|
||||
[str(exc), str(arg)],
|
||||
[repr(exc), '%s(%r)' % (exc.__class__.__name__, arg)])
|
||||
self.interface_test_driver(results)
|
||||
|
||||
def test_interface_multi_arg(self):
|
||||
# Make sure interface correct when multiple arguments given
|
||||
arg_count = 3
|
||||
args = tuple(range(arg_count))
|
||||
exc = Exception(*args)
|
||||
results = ([len(exc.args), arg_count], [exc.args, args],
|
||||
[str(exc), str(args)],
|
||||
[repr(exc), exc.__class__.__name__ + repr(exc.args)])
|
||||
self.interface_test_driver(results)
|
||||
|
||||
def test_interface_no_arg(self):
|
||||
# Make sure that with no args that interface is correct
|
||||
exc = Exception()
|
||||
results = ([len(exc.args), 0], [exc.args, tuple()],
|
||||
[str(exc), ''],
|
||||
[repr(exc), exc.__class__.__name__ + '()'])
|
||||
self.interface_test_driver(results)
|
||||
|
||||
class UsageTests(unittest.TestCase):
|
||||
|
||||
"""Test usage of exceptions"""
|
||||
|
||||
def raise_fails(self, object_):
|
||||
"""Make sure that raising 'object_' triggers a TypeError."""
|
||||
try:
|
||||
raise object_
|
||||
except TypeError:
|
||||
return # What is expected.
|
||||
self.fail("TypeError expected for raising %s" % type(object_))
|
||||
|
||||
def catch_fails(self, object_):
|
||||
"""Catching 'object_' should raise a TypeError."""
|
||||
try:
|
||||
try:
|
||||
raise Exception
|
||||
except object_:
|
||||
pass
|
||||
except TypeError:
|
||||
pass
|
||||
except Exception:
|
||||
self.fail("TypeError expected when catching %s" % type(object_))
|
||||
|
||||
try:
|
||||
try:
|
||||
raise Exception
|
||||
except (object_,):
|
||||
pass
|
||||
except TypeError:
|
||||
return
|
||||
except Exception:
|
||||
self.fail("TypeError expected when catching %s as specified in a "
|
||||
"tuple" % type(object_))
|
||||
|
||||
def test_raise_new_style_non_exception(self):
|
||||
# You cannot raise a new-style class that does not inherit from
|
||||
# BaseException; the ability was not possible until BaseException's
|
||||
# introduction so no need to support new-style objects that do not
|
||||
# inherit from it.
|
||||
class NewStyleClass(object):
|
||||
pass
|
||||
self.raise_fails(NewStyleClass)
|
||||
self.raise_fails(NewStyleClass())
|
||||
|
||||
def test_raise_string(self):
|
||||
# Raising a string raises TypeError.
|
||||
self.raise_fails("spam")
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_catch_non_BaseException(self):
|
||||
# Trying to catch an object that does not inherit from BaseException
|
||||
# is not allowed.
|
||||
class NonBaseException(object):
|
||||
pass
|
||||
self.catch_fails(NonBaseException)
|
||||
self.catch_fails(NonBaseException())
|
||||
|
||||
def test_catch_BaseException_instance(self):
|
||||
# Catching an instance of a BaseException subclass won't work.
|
||||
self.catch_fails(BaseException())
|
||||
|
||||
def test_catch_string(self):
|
||||
# Catching a string is bad.
|
||||
self.catch_fails("spam")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,530 @@
|
||||
import sys
|
||||
|
||||
import unittest
|
||||
from test import support
|
||||
# from test.test_grammar import (VALID_UNDERSCORE_LITERALS,
|
||||
# INVALID_UNDERSCORE_LITERALS)
|
||||
|
||||
L = [
|
||||
('0', 0),
|
||||
('1', 1),
|
||||
('9', 9),
|
||||
('10', 10),
|
||||
('99', 99),
|
||||
('100', 100),
|
||||
('314', 314),
|
||||
(' 314', 314),
|
||||
('314 ', 314),
|
||||
(' \t\t 314 \t\t ', 314),
|
||||
(repr(sys.maxsize), sys.maxsize),
|
||||
(' 1x', ValueError),
|
||||
(' 1 ', 1),
|
||||
(' 1\02 ', ValueError),
|
||||
('', ValueError),
|
||||
(' ', ValueError),
|
||||
(' \t\t ', ValueError),
|
||||
("\u0200", ValueError)
|
||||
]
|
||||
|
||||
class IntSubclass(int):
|
||||
pass
|
||||
|
||||
class IntTestCases(unittest.TestCase):
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_basic(self):
|
||||
self.assertEqual(int(314), 314)
|
||||
self.assertEqual(int(3.14), 3)
|
||||
# Check that conversion from float truncates towards zero
|
||||
self.assertEqual(int(-3.14), -3)
|
||||
self.assertEqual(int(3.9), 3)
|
||||
self.assertEqual(int(-3.9), -3)
|
||||
self.assertEqual(int(3.5), 3)
|
||||
self.assertEqual(int(-3.5), -3)
|
||||
self.assertEqual(int("-3"), -3)
|
||||
self.assertEqual(int(" -3 "), -3)
|
||||
self.assertEqual(int("\N{EM SPACE}-3\N{EN SPACE}"), -3)
|
||||
# Different base:
|
||||
self.assertEqual(int("10",16), 16)
|
||||
# Test conversion from strings and various anomalies
|
||||
for s, v in L:
|
||||
for sign in "", "+", "-":
|
||||
for prefix in "", " ", "\t", " \t\t ":
|
||||
ss = prefix + sign + s
|
||||
vv = v
|
||||
if sign == "-" and v is not ValueError:
|
||||
vv = -v
|
||||
try:
|
||||
self.assertEqual(int(ss), vv)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
s = repr(-1-sys.maxsize)
|
||||
x = int(s)
|
||||
self.assertEqual(x+1, -sys.maxsize)
|
||||
self.assertIsInstance(x, int)
|
||||
# should return int
|
||||
self.assertEqual(int(s[1:]), sys.maxsize+1)
|
||||
|
||||
# should return int
|
||||
x = int(1e100)
|
||||
self.assertIsInstance(x, int)
|
||||
x = int(-1e100)
|
||||
self.assertIsInstance(x, int)
|
||||
|
||||
|
||||
# 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.maxsize
|
||||
self.assertEqual(x >> 1, x//2)
|
||||
|
||||
x = int('1' * 600)
|
||||
self.assertIsInstance(x, int)
|
||||
|
||||
|
||||
self.assertRaises(TypeError, int, 1, 12)
|
||||
|
||||
self.assertEqual(int('0o123', 0), 83)
|
||||
self.assertEqual(int('0x123', 16), 291)
|
||||
|
||||
# Bug 1679: "0x" is not a valid hex literal
|
||||
self.assertRaises(ValueError, int, "0x", 16)
|
||||
self.assertRaises(ValueError, int, "0x", 0)
|
||||
|
||||
self.assertRaises(ValueError, int, "0o", 8)
|
||||
self.assertRaises(ValueError, int, "0o", 0)
|
||||
|
||||
self.assertRaises(ValueError, int, "0b", 2)
|
||||
self.assertRaises(ValueError, int, "0b", 0)
|
||||
|
||||
# SF bug 1334662: int(string, base) wrong answers
|
||||
# Various representations of 2**32 evaluated to 0
|
||||
# rather than 2**32 in previous versions
|
||||
|
||||
self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296)
|
||||
self.assertEqual(int('102002022201221111211', 3), 4294967296)
|
||||
self.assertEqual(int('10000000000000000', 4), 4294967296)
|
||||
self.assertEqual(int('32244002423141', 5), 4294967296)
|
||||
self.assertEqual(int('1550104015504', 6), 4294967296)
|
||||
self.assertEqual(int('211301422354', 7), 4294967296)
|
||||
self.assertEqual(int('40000000000', 8), 4294967296)
|
||||
self.assertEqual(int('12068657454', 9), 4294967296)
|
||||
self.assertEqual(int('4294967296', 10), 4294967296)
|
||||
self.assertEqual(int('1904440554', 11), 4294967296)
|
||||
self.assertEqual(int('9ba461594', 12), 4294967296)
|
||||
self.assertEqual(int('535a79889', 13), 4294967296)
|
||||
self.assertEqual(int('2ca5b7464', 14), 4294967296)
|
||||
self.assertEqual(int('1a20dcd81', 15), 4294967296)
|
||||
self.assertEqual(int('100000000', 16), 4294967296)
|
||||
self.assertEqual(int('a7ffda91', 17), 4294967296)
|
||||
self.assertEqual(int('704he7g4', 18), 4294967296)
|
||||
self.assertEqual(int('4f5aff66', 19), 4294967296)
|
||||
self.assertEqual(int('3723ai4g', 20), 4294967296)
|
||||
self.assertEqual(int('281d55i4', 21), 4294967296)
|
||||
self.assertEqual(int('1fj8b184', 22), 4294967296)
|
||||
self.assertEqual(int('1606k7ic', 23), 4294967296)
|
||||
self.assertEqual(int('mb994ag', 24), 4294967296)
|
||||
self.assertEqual(int('hek2mgl', 25), 4294967296)
|
||||
self.assertEqual(int('dnchbnm', 26), 4294967296)
|
||||
self.assertEqual(int('b28jpdm', 27), 4294967296)
|
||||
self.assertEqual(int('8pfgih4', 28), 4294967296)
|
||||
self.assertEqual(int('76beigg', 29), 4294967296)
|
||||
self.assertEqual(int('5qmcpqg', 30), 4294967296)
|
||||
self.assertEqual(int('4q0jto4', 31), 4294967296)
|
||||
self.assertEqual(int('4000000', 32), 4294967296)
|
||||
self.assertEqual(int('3aokq94', 33), 4294967296)
|
||||
self.assertEqual(int('2qhxjli', 34), 4294967296)
|
||||
self.assertEqual(int('2br45qb', 35), 4294967296)
|
||||
self.assertEqual(int('1z141z4', 36), 4294967296)
|
||||
|
||||
# tests with base 0
|
||||
# this fails on 3.0, but in 2.x the old octal syntax is allowed
|
||||
self.assertEqual(int(' 0o123 ', 0), 83)
|
||||
self.assertEqual(int(' 0o123 ', 0), 83)
|
||||
self.assertEqual(int('000', 0), 0)
|
||||
self.assertEqual(int('0o123', 0), 83)
|
||||
self.assertEqual(int('0x123', 0), 291)
|
||||
self.assertEqual(int('0b100', 0), 4)
|
||||
self.assertEqual(int(' 0O123 ', 0), 83)
|
||||
self.assertEqual(int(' 0X123 ', 0), 291)
|
||||
self.assertEqual(int(' 0B100 ', 0), 4)
|
||||
|
||||
# without base still base 10
|
||||
self.assertEqual(int('0123'), 123)
|
||||
self.assertEqual(int('0123', 10), 123)
|
||||
|
||||
# tests with prefix and base != 0
|
||||
self.assertEqual(int('0x123', 16), 291)
|
||||
self.assertEqual(int('0o123', 8), 83)
|
||||
self.assertEqual(int('0b100', 2), 4)
|
||||
self.assertEqual(int('0X123', 16), 291)
|
||||
self.assertEqual(int('0O123', 8), 83)
|
||||
self.assertEqual(int('0B100', 2), 4)
|
||||
|
||||
# the code has special checks for the first character after the
|
||||
# type prefix
|
||||
self.assertRaises(ValueError, int, '0b2', 2)
|
||||
self.assertRaises(ValueError, int, '0b02', 2)
|
||||
self.assertRaises(ValueError, int, '0B2', 2)
|
||||
self.assertRaises(ValueError, int, '0B02', 2)
|
||||
self.assertRaises(ValueError, int, '0o8', 8)
|
||||
self.assertRaises(ValueError, int, '0o08', 8)
|
||||
self.assertRaises(ValueError, int, '0O8', 8)
|
||||
self.assertRaises(ValueError, int, '0O08', 8)
|
||||
self.assertRaises(ValueError, int, '0xg', 16)
|
||||
self.assertRaises(ValueError, int, '0x0g', 16)
|
||||
self.assertRaises(ValueError, int, '0Xg', 16)
|
||||
self.assertRaises(ValueError, int, '0X0g', 16)
|
||||
|
||||
# SF bug 1334662: int(string, base) wrong answers
|
||||
# Checks for proper evaluation of 2**32 + 1
|
||||
self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297)
|
||||
self.assertEqual(int('102002022201221111212', 3), 4294967297)
|
||||
self.assertEqual(int('10000000000000001', 4), 4294967297)
|
||||
self.assertEqual(int('32244002423142', 5), 4294967297)
|
||||
self.assertEqual(int('1550104015505', 6), 4294967297)
|
||||
self.assertEqual(int('211301422355', 7), 4294967297)
|
||||
self.assertEqual(int('40000000001', 8), 4294967297)
|
||||
self.assertEqual(int('12068657455', 9), 4294967297)
|
||||
self.assertEqual(int('4294967297', 10), 4294967297)
|
||||
self.assertEqual(int('1904440555', 11), 4294967297)
|
||||
self.assertEqual(int('9ba461595', 12), 4294967297)
|
||||
self.assertEqual(int('535a7988a', 13), 4294967297)
|
||||
self.assertEqual(int('2ca5b7465', 14), 4294967297)
|
||||
self.assertEqual(int('1a20dcd82', 15), 4294967297)
|
||||
self.assertEqual(int('100000001', 16), 4294967297)
|
||||
self.assertEqual(int('a7ffda92', 17), 4294967297)
|
||||
self.assertEqual(int('704he7g5', 18), 4294967297)
|
||||
self.assertEqual(int('4f5aff67', 19), 4294967297)
|
||||
self.assertEqual(int('3723ai4h', 20), 4294967297)
|
||||
self.assertEqual(int('281d55i5', 21), 4294967297)
|
||||
self.assertEqual(int('1fj8b185', 22), 4294967297)
|
||||
self.assertEqual(int('1606k7id', 23), 4294967297)
|
||||
self.assertEqual(int('mb994ah', 24), 4294967297)
|
||||
self.assertEqual(int('hek2mgm', 25), 4294967297)
|
||||
self.assertEqual(int('dnchbnn', 26), 4294967297)
|
||||
self.assertEqual(int('b28jpdn', 27), 4294967297)
|
||||
self.assertEqual(int('8pfgih5', 28), 4294967297)
|
||||
self.assertEqual(int('76beigh', 29), 4294967297)
|
||||
self.assertEqual(int('5qmcpqh', 30), 4294967297)
|
||||
self.assertEqual(int('4q0jto5', 31), 4294967297)
|
||||
self.assertEqual(int('4000001', 32), 4294967297)
|
||||
self.assertEqual(int('3aokq95', 33), 4294967297)
|
||||
self.assertEqual(int('2qhxjlj', 34), 4294967297)
|
||||
self.assertEqual(int('2br45qc', 35), 4294967297)
|
||||
self.assertEqual(int('1z141z5', 36), 4294967297)
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_underscores(self):
|
||||
for lit in VALID_UNDERSCORE_LITERALS:
|
||||
if any(ch in lit for ch in '.eEjJ'):
|
||||
continue
|
||||
self.assertEqual(int(lit, 0), eval(lit))
|
||||
self.assertEqual(int(lit, 0), int(lit.replace('_', ''), 0))
|
||||
for lit in INVALID_UNDERSCORE_LITERALS:
|
||||
if any(ch in lit for ch in '.eEjJ'):
|
||||
continue
|
||||
self.assertRaises(ValueError, int, lit, 0)
|
||||
# Additional test cases with bases != 0, only for the constructor:
|
||||
self.assertEqual(int("1_00", 3), 9)
|
||||
self.assertEqual(int("0_100"), 100) # not valid as a literal!
|
||||
self.assertEqual(int(b"1_00"), 100) # byte underscore
|
||||
self.assertRaises(ValueError, int, "_100")
|
||||
self.assertRaises(ValueError, int, "+_100")
|
||||
self.assertRaises(ValueError, int, "1__00")
|
||||
self.assertRaises(ValueError, int, "100_")
|
||||
|
||||
@support.cpython_only
|
||||
def test_small_ints(self):
|
||||
# Bug #3236: Return small longs from PyLong_FromString
|
||||
self.assertIs(int('10'), 10)
|
||||
self.assertIs(int('-1'), -1)
|
||||
self.assertIs(int(b'10'), 10)
|
||||
self.assertIs(int(b'-1'), -1)
|
||||
|
||||
def test_no_args(self):
|
||||
self.assertEqual(int(), 0)
|
||||
|
||||
def test_keyword_args(self):
|
||||
# Test invoking int() using keyword arguments.
|
||||
self.assertEqual(int('100', base=2), 4)
|
||||
with self.assertRaisesRegex(TypeError, 'keyword argument'):
|
||||
int(x=1.2)
|
||||
with self.assertRaisesRegex(TypeError, 'keyword argument'):
|
||||
int(x='100', base=2)
|
||||
self.assertRaises(TypeError, int, base=10)
|
||||
self.assertRaises(TypeError, int, base=0)
|
||||
|
||||
def test_int_base_limits(self):
|
||||
"""Testing the supported limits of the int() base parameter."""
|
||||
self.assertEqual(int('0', 5), 0)
|
||||
with self.assertRaises(ValueError):
|
||||
int('0', 1)
|
||||
with self.assertRaises(ValueError):
|
||||
int('0', 37)
|
||||
with self.assertRaises(ValueError):
|
||||
int('0', -909) # An old magic value base from Python 2.
|
||||
with self.assertRaises(ValueError):
|
||||
int('0', base=0-(2**234))
|
||||
with self.assertRaises(ValueError):
|
||||
int('0', base=2**234)
|
||||
# Bases 2 through 36 are supported.
|
||||
for base in range(2,37):
|
||||
self.assertEqual(int('0', base=base), 0)
|
||||
|
||||
def test_int_base_bad_types(self):
|
||||
"""Not integer types are not valid bases; issue16772."""
|
||||
with self.assertRaises(TypeError):
|
||||
int('0', 5.5)
|
||||
with self.assertRaises(TypeError):
|
||||
int('0', 5.0)
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_int_base_indexable(self):
|
||||
class MyIndexable(object):
|
||||
def __init__(self, value):
|
||||
self.value = value
|
||||
def __index__(self):
|
||||
return self.value
|
||||
|
||||
# Check out of range bases.
|
||||
for base in 2**100, -2**100, 1, 37:
|
||||
with self.assertRaises(ValueError):
|
||||
int('43', base)
|
||||
|
||||
# Check in-range bases.
|
||||
self.assertEqual(int('101', base=MyIndexable(2)), 5)
|
||||
self.assertEqual(int('101', base=MyIndexable(10)), 101)
|
||||
self.assertEqual(int('101', base=MyIndexable(36)), 1 + 36**2)
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_non_numeric_input_types(self):
|
||||
# Test possible non-numeric types for the argument x, including
|
||||
# subclasses of the explicitly documented accepted types.
|
||||
class CustomStr(str): pass
|
||||
class CustomBytes(bytes): pass
|
||||
class CustomByteArray(bytearray): pass
|
||||
|
||||
factories = [
|
||||
bytes,
|
||||
bytearray,
|
||||
lambda b: CustomStr(b.decode()),
|
||||
CustomBytes,
|
||||
CustomByteArray,
|
||||
memoryview,
|
||||
]
|
||||
try:
|
||||
from array import array
|
||||
except ImportError:
|
||||
pass
|
||||
else:
|
||||
factories.append(lambda b: array('B', b))
|
||||
|
||||
for f in factories:
|
||||
x = f(b'100')
|
||||
with self.subTest(type(x)):
|
||||
self.assertEqual(int(x), 100)
|
||||
if isinstance(x, (str, bytes, bytearray)):
|
||||
self.assertEqual(int(x, 2), 4)
|
||||
else:
|
||||
msg = "can't convert non-string"
|
||||
with self.assertRaisesRegex(TypeError, msg):
|
||||
int(x, 2)
|
||||
with self.assertRaisesRegex(ValueError, 'invalid literal'):
|
||||
int(f(b'A' * 0x10))
|
||||
|
||||
def test_int_memoryview(self):
|
||||
self.assertEqual(int(memoryview(b'123')[1:3]), 23)
|
||||
self.assertEqual(int(memoryview(b'123\x00')[1:3]), 23)
|
||||
self.assertEqual(int(memoryview(b'123 ')[1:3]), 23)
|
||||
self.assertEqual(int(memoryview(b'123A')[1:3]), 23)
|
||||
self.assertEqual(int(memoryview(b'1234')[1:3]), 23)
|
||||
|
||||
def test_string_float(self):
|
||||
self.assertRaises(ValueError, int, '1.2')
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_intconversion(self):
|
||||
# Test __int__()
|
||||
class ClassicMissingMethods:
|
||||
pass
|
||||
self.assertRaises(TypeError, int, ClassicMissingMethods())
|
||||
|
||||
class MissingMethods(object):
|
||||
pass
|
||||
self.assertRaises(TypeError, int, MissingMethods())
|
||||
|
||||
class Foo0:
|
||||
def __int__(self):
|
||||
return 42
|
||||
|
||||
self.assertEqual(int(Foo0()), 42)
|
||||
|
||||
class Classic:
|
||||
pass
|
||||
for base in (object, Classic):
|
||||
class IntOverridesTrunc(base):
|
||||
def __int__(self):
|
||||
return 42
|
||||
def __trunc__(self):
|
||||
return -12
|
||||
self.assertEqual(int(IntOverridesTrunc()), 42)
|
||||
|
||||
class JustTrunc(base):
|
||||
def __trunc__(self):
|
||||
return 42
|
||||
self.assertEqual(int(JustTrunc()), 42)
|
||||
|
||||
class ExceptionalTrunc(base):
|
||||
def __trunc__(self):
|
||||
1 / 0
|
||||
with self.assertRaises(ZeroDivisionError):
|
||||
int(ExceptionalTrunc())
|
||||
|
||||
for trunc_result_base in (object, Classic):
|
||||
class Integral(trunc_result_base):
|
||||
def __int__(self):
|
||||
return 42
|
||||
|
||||
class TruncReturnsNonInt(base):
|
||||
def __trunc__(self):
|
||||
return Integral()
|
||||
with self.assertWarns(DeprecationWarning):
|
||||
self.assertEqual(int(TruncReturnsNonInt()), 42)
|
||||
|
||||
class NonIntegral(trunc_result_base):
|
||||
def __trunc__(self):
|
||||
# Check that we avoid infinite recursion.
|
||||
return NonIntegral()
|
||||
|
||||
class TruncReturnsNonIntegral(base):
|
||||
def __trunc__(self):
|
||||
return NonIntegral()
|
||||
try:
|
||||
int(TruncReturnsNonIntegral())
|
||||
except TypeError as e:
|
||||
self.assertEqual(str(e),
|
||||
"__trunc__ returned non-Integral"
|
||||
" (type NonIntegral)")
|
||||
else:
|
||||
self.fail("Failed to raise TypeError with %s" %
|
||||
((base, trunc_result_base),))
|
||||
|
||||
# Regression test for bugs.python.org/issue16060.
|
||||
class BadInt(trunc_result_base):
|
||||
def __int__(self):
|
||||
return 42.0
|
||||
|
||||
class TruncReturnsBadInt(base):
|
||||
def __trunc__(self):
|
||||
return BadInt()
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
int(TruncReturnsBadInt())
|
||||
|
||||
def test_int_subclass_with_int(self):
|
||||
class MyInt(int):
|
||||
def __int__(self):
|
||||
return 42
|
||||
|
||||
class BadInt(int):
|
||||
def __int__(self):
|
||||
return 42.0
|
||||
|
||||
my_int = MyInt(7)
|
||||
self.assertEqual(my_int, 7)
|
||||
self.assertEqual(int(my_int), 42)
|
||||
|
||||
self.assertRaises(TypeError, int, BadInt())
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_int_returns_int_subclass(self):
|
||||
class BadInt:
|
||||
def __int__(self):
|
||||
return True
|
||||
|
||||
class BadInt2(int):
|
||||
def __int__(self):
|
||||
return True
|
||||
|
||||
class TruncReturnsBadInt:
|
||||
def __trunc__(self):
|
||||
return BadInt()
|
||||
|
||||
class TruncReturnsIntSubclass:
|
||||
def __trunc__(self):
|
||||
return True
|
||||
|
||||
bad_int = BadInt()
|
||||
with self.assertWarns(DeprecationWarning):
|
||||
n = int(bad_int)
|
||||
self.assertEqual(n, 1)
|
||||
self.assertIs(type(n), int)
|
||||
|
||||
bad_int = BadInt2()
|
||||
with self.assertWarns(DeprecationWarning):
|
||||
n = int(bad_int)
|
||||
self.assertEqual(n, 1)
|
||||
self.assertIs(type(n), int)
|
||||
|
||||
bad_int = TruncReturnsBadInt()
|
||||
with self.assertWarns(DeprecationWarning):
|
||||
n = int(bad_int)
|
||||
self.assertEqual(n, 1)
|
||||
self.assertIs(type(n), int)
|
||||
|
||||
good_int = TruncReturnsIntSubclass()
|
||||
n = int(good_int)
|
||||
self.assertEqual(n, 1)
|
||||
self.assertIs(type(n), int)
|
||||
n = IntSubclass(good_int)
|
||||
self.assertEqual(n, 1)
|
||||
self.assertIs(type(n), IntSubclass)
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_error_message(self):
|
||||
def check(s, base=None):
|
||||
with self.assertRaises(ValueError,
|
||||
msg="int(%r, %r)" % (s, base)) as cm:
|
||||
if base is None:
|
||||
int(s)
|
||||
else:
|
||||
int(s, base)
|
||||
self.assertEqual(cm.exception.args[0],
|
||||
"invalid literal for int() with base %d: %r" %
|
||||
(10 if base is None else base, s))
|
||||
|
||||
check('\xbd')
|
||||
check('123\xbd')
|
||||
check(' 123 456 ')
|
||||
|
||||
check('123\x00')
|
||||
# SF bug 1545497: embedded NULs were not detected with explicit base
|
||||
check('123\x00', 10)
|
||||
check('123\x00 245', 20)
|
||||
check('123\x00 245', 16)
|
||||
check('123\x00245', 20)
|
||||
check('123\x00245', 16)
|
||||
# byte string with embedded NUL
|
||||
check(b'123\x00')
|
||||
check(b'123\x00', 10)
|
||||
# non-UTF-8 byte string
|
||||
check(b'123\xbd')
|
||||
check(b'123\xbd', 10)
|
||||
# lone surrogate in Unicode string
|
||||
check('123\ud800')
|
||||
check('123\ud800', 10)
|
||||
|
||||
def test_issue31619(self):
|
||||
self.assertEqual(int('1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1_0_1', 2),
|
||||
0b1010101010101010101010101010101)
|
||||
self.assertEqual(int('1_2_3_4_5_6_7_0_1_2_3', 8), 0o12345670123)
|
||||
self.assertEqual(int('1_2_3_4_5_6_7_8_9', 16), 0x123456789)
|
||||
self.assertEqual(int('1_2_3_4_5_6_7', 32), 1144132807)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,143 @@
|
||||
"""Test correct treatment of hex/oct constants.
|
||||
|
||||
This is complex because of changes due to PEP 237.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
|
||||
class TestHexOctBin(unittest.TestCase):
|
||||
|
||||
def test_hex_baseline(self):
|
||||
# A few upper/lowercase tests
|
||||
self.assertEqual(0x0, 0X0)
|
||||
self.assertEqual(0x1, 0X1)
|
||||
self.assertEqual(0x123456789abcdef, 0X123456789abcdef)
|
||||
# Baseline tests
|
||||
self.assertEqual(0x0, 0)
|
||||
self.assertEqual(0x10, 16)
|
||||
self.assertEqual(0x7fffffff, 2147483647)
|
||||
self.assertEqual(0x7fffffffffffffff, 9223372036854775807)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0x0), 0)
|
||||
self.assertEqual(-(0x10), -16)
|
||||
self.assertEqual(-(0x7fffffff), -2147483647)
|
||||
self.assertEqual(-(0x7fffffffffffffff), -9223372036854775807)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
self.assertEqual(-0x0, 0)
|
||||
self.assertEqual(-0x10, -16)
|
||||
self.assertEqual(-0x7fffffff, -2147483647)
|
||||
self.assertEqual(-0x7fffffffffffffff, -9223372036854775807)
|
||||
|
||||
def test_hex_unsigned(self):
|
||||
# Positive constants
|
||||
self.assertEqual(0x80000000, 2147483648)
|
||||
self.assertEqual(0xffffffff, 4294967295)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0x80000000), -2147483648)
|
||||
self.assertEqual(-(0xffffffff), -4294967295)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
|
||||
self.assertEqual(-0x80000000, -2147483648)
|
||||
self.assertEqual(-0xffffffff, -4294967295)
|
||||
|
||||
# Positive constants
|
||||
self.assertEqual(0x8000000000000000, 9223372036854775808)
|
||||
self.assertEqual(0xffffffffffffffff, 18446744073709551615)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0x8000000000000000), -9223372036854775808)
|
||||
self.assertEqual(-(0xffffffffffffffff), -18446744073709551615)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
|
||||
self.assertEqual(-0x8000000000000000, -9223372036854775808)
|
||||
self.assertEqual(-0xffffffffffffffff, -18446744073709551615)
|
||||
|
||||
def test_oct_baseline(self):
|
||||
# A few upper/lowercase tests
|
||||
self.assertEqual(0o0, 0O0)
|
||||
self.assertEqual(0o1, 0O1)
|
||||
self.assertEqual(0o1234567, 0O1234567)
|
||||
# Baseline tests
|
||||
self.assertEqual(0o0, 0)
|
||||
self.assertEqual(0o20, 16)
|
||||
self.assertEqual(0o17777777777, 2147483647)
|
||||
self.assertEqual(0o777777777777777777777, 9223372036854775807)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0o0), 0)
|
||||
self.assertEqual(-(0o20), -16)
|
||||
self.assertEqual(-(0o17777777777), -2147483647)
|
||||
self.assertEqual(-(0o777777777777777777777), -9223372036854775807)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
self.assertEqual(-0o0, 0)
|
||||
self.assertEqual(-0o20, -16)
|
||||
self.assertEqual(-0o17777777777, -2147483647)
|
||||
self.assertEqual(-0o777777777777777777777, -9223372036854775807)
|
||||
|
||||
def test_oct_unsigned(self):
|
||||
# Positive constants
|
||||
self.assertEqual(0o20000000000, 2147483648)
|
||||
self.assertEqual(0o37777777777, 4294967295)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0o20000000000), -2147483648)
|
||||
self.assertEqual(-(0o37777777777), -4294967295)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
|
||||
self.assertEqual(-0o20000000000, -2147483648)
|
||||
self.assertEqual(-0o37777777777, -4294967295)
|
||||
|
||||
# Positive constants
|
||||
self.assertEqual(0o1000000000000000000000, 9223372036854775808)
|
||||
self.assertEqual(0o1777777777777777777777, 18446744073709551615)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0o1000000000000000000000), -9223372036854775808)
|
||||
self.assertEqual(-(0o1777777777777777777777), -18446744073709551615)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
|
||||
self.assertEqual(-0o1000000000000000000000, -9223372036854775808)
|
||||
self.assertEqual(-0o1777777777777777777777, -18446744073709551615)
|
||||
|
||||
def test_bin_baseline(self):
|
||||
# A few upper/lowercase tests
|
||||
self.assertEqual(0b0, 0B0)
|
||||
self.assertEqual(0b1, 0B1)
|
||||
self.assertEqual(0b10101010101, 0B10101010101)
|
||||
# Baseline tests
|
||||
self.assertEqual(0b0, 0)
|
||||
self.assertEqual(0b10000, 16)
|
||||
self.assertEqual(0b1111111111111111111111111111111, 2147483647)
|
||||
self.assertEqual(0b111111111111111111111111111111111111111111111111111111111111111, 9223372036854775807)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0b0), 0)
|
||||
self.assertEqual(-(0b10000), -16)
|
||||
self.assertEqual(-(0b1111111111111111111111111111111), -2147483647)
|
||||
self.assertEqual(-(0b111111111111111111111111111111111111111111111111111111111111111), -9223372036854775807)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
self.assertEqual(-0b0, 0)
|
||||
self.assertEqual(-0b10000, -16)
|
||||
self.assertEqual(-0b1111111111111111111111111111111, -2147483647)
|
||||
self.assertEqual(-0b111111111111111111111111111111111111111111111111111111111111111, -9223372036854775807)
|
||||
|
||||
def test_bin_unsigned(self):
|
||||
# Positive constants
|
||||
self.assertEqual(0b10000000000000000000000000000000, 2147483648)
|
||||
self.assertEqual(0b11111111111111111111111111111111, 4294967295)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0b10000000000000000000000000000000), -2147483648)
|
||||
self.assertEqual(-(0b11111111111111111111111111111111), -4294967295)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
|
||||
self.assertEqual(-0b10000000000000000000000000000000, -2147483648)
|
||||
self.assertEqual(-0b11111111111111111111111111111111, -4294967295)
|
||||
|
||||
# Positive constants
|
||||
self.assertEqual(0b1000000000000000000000000000000000000000000000000000000000000000, 9223372036854775808)
|
||||
self.assertEqual(0b1111111111111111111111111111111111111111111111111111111111111111, 18446744073709551615)
|
||||
# Ditto with a minus sign and parentheses
|
||||
self.assertEqual(-(0b1000000000000000000000000000000000000000000000000000000000000000), -9223372036854775808)
|
||||
self.assertEqual(-(0b1111111111111111111111111111111111111111111111111111111111111111), -18446744073709551615)
|
||||
# Ditto with a minus sign and NO parentheses
|
||||
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
|
||||
self.assertEqual(-0b1000000000000000000000000000000000000000000000000000000000000000, -9223372036854775808)
|
||||
self.assertEqual(-0b1111111111111111111111111111111111111111111111111111111111111111, -18446744073709551615)
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,141 @@
|
||||
# Python test set -- part 2, opcodes
|
||||
|
||||
import unittest
|
||||
from test import support #,ann_module
|
||||
|
||||
class OpcodeTest(unittest.TestCase):
|
||||
|
||||
def test_try_inside_for_loop(self):
|
||||
n = 0
|
||||
for i in range(10):
|
||||
n = n+i
|
||||
try: 1/0
|
||||
except NameError: pass
|
||||
except ZeroDivisionError: pass
|
||||
except TypeError: pass
|
||||
try: pass
|
||||
except: pass
|
||||
try: pass
|
||||
finally: pass
|
||||
n = n+i
|
||||
if n != 90:
|
||||
self.fail('try inside for')
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_setup_annotations_line(self):
|
||||
# check that SETUP_ANNOTATIONS does not create spurious line numbers
|
||||
try:
|
||||
with open(ann_module.__file__) as f:
|
||||
txt = f.read()
|
||||
co = compile(txt, ann_module.__file__, 'exec')
|
||||
self.assertEqual(co.co_firstlineno, 3)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
def test_no_annotations_if_not_needed(self):
|
||||
class C: pass
|
||||
with self.assertRaises(AttributeError):
|
||||
C.__annotations__
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_use_existing_annotations(self):
|
||||
ns = {'__annotations__': {1: 2}}
|
||||
exec('x: int', ns)
|
||||
self.assertEqual(ns['__annotations__'], {'x': int, 1: 2})
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_do_not_recreate_annotations(self):
|
||||
# Don't rely on the existence of the '__annotations__' global.
|
||||
with support.swap_item(globals(), '__annotations__', {}):
|
||||
del globals()['__annotations__']
|
||||
class C:
|
||||
del __annotations__
|
||||
with self.assertRaises(NameError):
|
||||
x: int
|
||||
|
||||
def test_raise_class_exceptions(self):
|
||||
|
||||
class AClass(Exception): pass
|
||||
class BClass(AClass): pass
|
||||
class CClass(Exception): pass
|
||||
class DClass(AClass):
|
||||
def __init__(self, ignore):
|
||||
pass
|
||||
|
||||
try: raise AClass()
|
||||
except: pass
|
||||
|
||||
try: raise AClass()
|
||||
except AClass: pass
|
||||
|
||||
try: raise BClass()
|
||||
except AClass: pass
|
||||
|
||||
try: raise BClass()
|
||||
except CClass: self.fail()
|
||||
except: pass
|
||||
|
||||
a = AClass()
|
||||
b = BClass()
|
||||
|
||||
try:
|
||||
raise b
|
||||
except AClass as v:
|
||||
self.assertEqual(v, b)
|
||||
else:
|
||||
self.fail("no exception")
|
||||
|
||||
# not enough arguments
|
||||
##try: raise BClass, a
|
||||
##except TypeError: pass
|
||||
##else: self.fail("no exception")
|
||||
|
||||
try: raise DClass(a)
|
||||
except DClass as v:
|
||||
self.assertIsInstance(v, DClass)
|
||||
else:
|
||||
self.fail("no exception")
|
||||
|
||||
def test_compare_function_objects(self):
|
||||
|
||||
f = eval('lambda: None')
|
||||
g = eval('lambda: None')
|
||||
self.assertNotEqual(f, g)
|
||||
|
||||
f = eval('lambda a: a')
|
||||
g = eval('lambda a: a')
|
||||
self.assertNotEqual(f, g)
|
||||
|
||||
f = eval('lambda a=1: a')
|
||||
g = eval('lambda a=1: a')
|
||||
self.assertNotEqual(f, g)
|
||||
|
||||
f = eval('lambda: 0')
|
||||
g = eval('lambda: 1')
|
||||
self.assertNotEqual(f, g)
|
||||
|
||||
f = eval('lambda: None')
|
||||
g = eval('lambda a: None')
|
||||
self.assertNotEqual(f, g)
|
||||
|
||||
f = eval('lambda a: None')
|
||||
g = eval('lambda b: None')
|
||||
self.assertNotEqual(f, g)
|
||||
|
||||
f = eval('lambda a: None')
|
||||
g = eval('lambda a=None: None')
|
||||
self.assertNotEqual(f, g)
|
||||
|
||||
f = eval('lambda a=0: None')
|
||||
g = eval('lambda a=1: None')
|
||||
self.assertNotEqual(f, g)
|
||||
|
||||
def test_modulo_of_string_subclasses(self):
|
||||
class MyString(str):
|
||||
def __mod__(self, value):
|
||||
return 42
|
||||
self.assertEqual(MyString() % 3, 42)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,123 @@
|
||||
import unittest
|
||||
|
||||
class PowTest(unittest.TestCase):
|
||||
|
||||
def powtest(self, type):
|
||||
if type != float:
|
||||
for i in range(-1000, 1000):
|
||||
self.assertEqual(pow(type(i), 0), 1)
|
||||
self.assertEqual(pow(type(i), 1), type(i))
|
||||
self.assertEqual(pow(type(0), 1), type(0))
|
||||
self.assertEqual(pow(type(1), 1), type(1))
|
||||
|
||||
for i in range(-100, 100):
|
||||
self.assertEqual(pow(type(i), 3), i*i*i)
|
||||
|
||||
pow2 = 1
|
||||
for i in range(0, 31):
|
||||
self.assertEqual(pow(2, i), pow2)
|
||||
if i != 30 : pow2 = pow2*2
|
||||
|
||||
for othertype in (int,):
|
||||
for i in list(range(-10, 0)) + list(range(1, 10)):
|
||||
ii = type(i)
|
||||
for j in range(1, 11):
|
||||
jj = -othertype(j)
|
||||
pow(ii, jj)
|
||||
|
||||
for othertype in int, float:
|
||||
for i in range(1, 100):
|
||||
zero = type(0)
|
||||
exp = -othertype(i/10.0)
|
||||
if exp == 0:
|
||||
continue
|
||||
self.assertRaises(ZeroDivisionError, pow, zero, exp)
|
||||
|
||||
il, ih = -20, 20
|
||||
jl, jh = -5, 5
|
||||
kl, kh = -10, 10
|
||||
asseq = self.assertEqual
|
||||
if type == float:
|
||||
il = 1
|
||||
asseq = self.assertAlmostEqual
|
||||
elif type == int:
|
||||
jl = 0
|
||||
elif type == int:
|
||||
jl, jh = 0, 15
|
||||
for i in range(il, ih+1):
|
||||
for j in range(jl, jh+1):
|
||||
for k in range(kl, kh+1):
|
||||
if k != 0:
|
||||
if type == float or j < 0:
|
||||
self.assertRaises(TypeError, pow, type(i), j, k)
|
||||
continue
|
||||
asseq(
|
||||
pow(type(i),j,k),
|
||||
pow(type(i),j)% type(k)
|
||||
)
|
||||
|
||||
def test_powint(self):
|
||||
self.powtest(int)
|
||||
|
||||
def test_powfloat(self):
|
||||
self.powtest(float)
|
||||
|
||||
def test_other(self):
|
||||
# Other tests-- not very systematic
|
||||
self.assertEqual(pow(3,3) % 8, pow(3,3,8))
|
||||
self.assertEqual(pow(3,3) % -8, pow(3,3,-8))
|
||||
self.assertEqual(pow(3,2) % -2, pow(3,2,-2))
|
||||
self.assertEqual(pow(-3,3) % 8, pow(-3,3,8))
|
||||
self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8))
|
||||
self.assertEqual(pow(5,2) % -8, pow(5,2,-8))
|
||||
|
||||
self.assertEqual(pow(3,3) % 8, pow(3,3,8))
|
||||
self.assertEqual(pow(3,3) % -8, pow(3,3,-8))
|
||||
self.assertEqual(pow(3,2) % -2, pow(3,2,-2))
|
||||
self.assertEqual(pow(-3,3) % 8, pow(-3,3,8))
|
||||
self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8))
|
||||
self.assertEqual(pow(5,2) % -8, pow(5,2,-8))
|
||||
|
||||
for i in range(-10, 11):
|
||||
for j in range(0, 6):
|
||||
for k in range(-7, 11):
|
||||
if j >= 0 and k != 0:
|
||||
self.assertEqual(
|
||||
pow(i,j) % k,
|
||||
pow(i,j,k)
|
||||
)
|
||||
if j >= 0 and k != 0:
|
||||
self.assertEqual(
|
||||
pow(int(i),j) % k,
|
||||
pow(int(i),j,k)
|
||||
)
|
||||
|
||||
def test_bug643260(self):
|
||||
class TestRpow:
|
||||
def __rpow__(self, other):
|
||||
return None
|
||||
None ** TestRpow() # Won't fail when __rpow__ invoked. SF bug #643260.
|
||||
|
||||
def test_bug705231(self):
|
||||
# -1.0 raised to an integer should never blow up. It did if the
|
||||
# platform pow() was buggy, and Python didn't worm around it.
|
||||
eq = self.assertEqual
|
||||
a = -1.0
|
||||
# The next two tests can still fail if the platform floor()
|
||||
# function doesn't treat all large inputs as integers
|
||||
# test_math should also fail if that is happening
|
||||
eq(pow(a, 1.23e167), 1.0)
|
||||
eq(pow(a, -1.23e167), 1.0)
|
||||
for b in range(-10, 11):
|
||||
eq(pow(a, float(b)), b & 1 and -1.0 or 1.0)
|
||||
for n in range(0, 100):
|
||||
fiveto = float(5 ** n)
|
||||
# For small n, fiveto will be odd. Eventually we run out of
|
||||
# mantissa bits, though, and thereafer fiveto will be even.
|
||||
expected = fiveto % 2.0 and -1.0 or 1.0
|
||||
eq(pow(a, fiveto), expected)
|
||||
eq(pow(a, -fiveto), expected)
|
||||
eq(expected, 1.0) # else we didn't push fiveto to evenness
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,500 @@
|
||||
# Copyright 2007 Google, Inc. All Rights Reserved.
|
||||
# Licensed to PSF under a Contributor Agreement.
|
||||
|
||||
"""Tests for the raise statement."""
|
||||
|
||||
from test import support
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
|
||||
|
||||
def get_tb():
|
||||
try:
|
||||
raise OSError()
|
||||
except:
|
||||
return sys.exc_info()[2]
|
||||
|
||||
|
||||
class Context:
|
||||
def __enter__(self):
|
||||
return self
|
||||
def __exit__(self, exc_type, exc_value, exc_tb):
|
||||
return True
|
||||
|
||||
|
||||
class TestRaise(unittest.TestCase):
|
||||
def test_invalid_reraise(self):
|
||||
try:
|
||||
raise
|
||||
except RuntimeError as e:
|
||||
self.assertIn("No active exception", str(e))
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_reraise(self):
|
||||
try:
|
||||
try:
|
||||
raise IndexError()
|
||||
except IndexError as e:
|
||||
exc1 = e
|
||||
raise
|
||||
except IndexError as exc2:
|
||||
self.assertIs(exc1, exc2)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_except_reraise(self):
|
||||
def reraise():
|
||||
try:
|
||||
raise TypeError("foo")
|
||||
except:
|
||||
try:
|
||||
raise KeyError("caught")
|
||||
except KeyError:
|
||||
pass
|
||||
raise
|
||||
self.assertRaises(TypeError, reraise)
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_finally_reraise(self):
|
||||
def reraise():
|
||||
try:
|
||||
raise TypeError("foo")
|
||||
except:
|
||||
try:
|
||||
raise KeyError("caught")
|
||||
finally:
|
||||
raise
|
||||
self.assertRaises(KeyError, reraise)
|
||||
|
||||
def test_nested_reraise(self):
|
||||
def nested_reraise():
|
||||
raise
|
||||
def reraise():
|
||||
try:
|
||||
raise TypeError("foo")
|
||||
except:
|
||||
nested_reraise()
|
||||
self.assertRaises(TypeError, reraise)
|
||||
|
||||
def test_raise_from_None(self):
|
||||
try:
|
||||
try:
|
||||
raise TypeError("foo")
|
||||
except:
|
||||
raise ValueError() from None
|
||||
except ValueError as e:
|
||||
self.assertIsInstance(e.__context__, TypeError)
|
||||
self.assertIsNone(e.__cause__)
|
||||
|
||||
def test_with_reraise1(self):
|
||||
def reraise():
|
||||
try:
|
||||
raise TypeError("foo")
|
||||
except:
|
||||
with Context():
|
||||
pass
|
||||
raise
|
||||
self.assertRaises(TypeError, reraise)
|
||||
|
||||
def test_with_reraise2(self):
|
||||
def reraise():
|
||||
try:
|
||||
raise TypeError("foo")
|
||||
except:
|
||||
with Context():
|
||||
raise KeyError("caught")
|
||||
raise
|
||||
self.assertRaises(TypeError, reraise)
|
||||
|
||||
def test_yield_reraise(self):
|
||||
def reraise():
|
||||
try:
|
||||
raise TypeError("foo")
|
||||
except:
|
||||
yield 1
|
||||
raise
|
||||
g = reraise()
|
||||
next(g)
|
||||
self.assertRaises(TypeError, lambda: next(g))
|
||||
self.assertRaises(StopIteration, lambda: next(g))
|
||||
|
||||
def test_erroneous_exception(self):
|
||||
class MyException(Exception):
|
||||
def __init__(self):
|
||||
raise RuntimeError()
|
||||
|
||||
try:
|
||||
raise MyException
|
||||
except RuntimeError:
|
||||
pass
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_new_returns_invalid_instance(self):
|
||||
# See issue #11627.
|
||||
class MyException(Exception):
|
||||
def __new__(cls, *args):
|
||||
return object()
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
raise MyException
|
||||
|
||||
def test_assert_with_tuple_arg(self):
|
||||
try:
|
||||
assert False, (3,)
|
||||
except AssertionError as e:
|
||||
self.assertEqual(str(e), "(3,)")
|
||||
|
||||
|
||||
|
||||
class TestCause(unittest.TestCase):
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def testCauseSyntax(self):
|
||||
try:
|
||||
try:
|
||||
try:
|
||||
raise TypeError
|
||||
except Exception:
|
||||
raise ValueError from None
|
||||
except ValueError as exc:
|
||||
self.assertIsNone(exc.__cause__)
|
||||
self.assertTrue(exc.__suppress_context__)
|
||||
exc.__suppress_context__ = False
|
||||
raise exc
|
||||
except ValueError as exc:
|
||||
e = exc
|
||||
|
||||
self.assertIsNone(e.__cause__)
|
||||
self.assertFalse(e.__suppress_context__)
|
||||
self.assertIsInstance(e.__context__, TypeError)
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_invalid_cause(self):
|
||||
try:
|
||||
raise IndexError from 5
|
||||
except TypeError as e:
|
||||
self.assertIn("exception cause", str(e))
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_class_cause(self):
|
||||
try:
|
||||
raise IndexError from KeyError
|
||||
except IndexError as e:
|
||||
self.assertIsInstance(e.__cause__, KeyError)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_instance_cause(self):
|
||||
cause = KeyError()
|
||||
try:
|
||||
raise IndexError from cause
|
||||
except IndexError as e:
|
||||
self.assertIs(e.__cause__, cause)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_erroneous_cause(self):
|
||||
class MyException(Exception):
|
||||
def __init__(self):
|
||||
raise RuntimeError()
|
||||
|
||||
try:
|
||||
raise IndexError from MyException
|
||||
except RuntimeError:
|
||||
pass
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
|
||||
class TestTraceback(unittest.TestCase):
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_sets_traceback(self):
|
||||
try:
|
||||
raise IndexError()
|
||||
except IndexError as e:
|
||||
self.assertIsInstance(e.__traceback__, types.TracebackType)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_accepts_traceback(self):
|
||||
tb = get_tb()
|
||||
try:
|
||||
raise IndexError().with_traceback(tb)
|
||||
except IndexError as e:
|
||||
self.assertNotEqual(e.__traceback__, tb)
|
||||
self.assertEqual(e.__traceback__.tb_next, tb)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
|
||||
class TestTracebackType(unittest.TestCase):
|
||||
|
||||
def raiser(self):
|
||||
raise ValueError
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_attrs(self):
|
||||
try:
|
||||
self.raiser()
|
||||
except Exception as exc:
|
||||
tb = exc.__traceback__
|
||||
|
||||
self.assertIsInstance(tb.tb_next, types.TracebackType)
|
||||
self.assertIs(tb.tb_frame, sys._getframe())
|
||||
self.assertIsInstance(tb.tb_lasti, int)
|
||||
self.assertIsInstance(tb.tb_lineno, int)
|
||||
|
||||
self.assertIs(tb.tb_next.tb_next, None)
|
||||
|
||||
# Invalid assignments
|
||||
with self.assertRaises(TypeError):
|
||||
del tb.tb_next
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
tb.tb_next = "asdf"
|
||||
|
||||
# Loops
|
||||
with self.assertRaises(ValueError):
|
||||
tb.tb_next = tb
|
||||
|
||||
with self.assertRaises(ValueError):
|
||||
tb.tb_next.tb_next = tb
|
||||
|
||||
# Valid assignments
|
||||
tb.tb_next = None
|
||||
self.assertIs(tb.tb_next, None)
|
||||
|
||||
new_tb = get_tb()
|
||||
tb.tb_next = new_tb
|
||||
self.assertIs(tb.tb_next, new_tb)
|
||||
|
||||
@unittest.skip("TODO: RUSTPYTHON")
|
||||
def test_constructor(self):
|
||||
other_tb = get_tb()
|
||||
frame = sys._getframe()
|
||||
|
||||
tb = types.TracebackType(other_tb, frame, 1, 2)
|
||||
self.assertEqual(tb.tb_next, other_tb)
|
||||
self.assertEqual(tb.tb_frame, frame)
|
||||
self.assertEqual(tb.tb_lasti, 1)
|
||||
self.assertEqual(tb.tb_lineno, 2)
|
||||
|
||||
tb = types.TracebackType(None, frame, 1, 2)
|
||||
self.assertEqual(tb.tb_next, None)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
types.TracebackType("no", frame, 1, 2)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
types.TracebackType(other_tb, "no", 1, 2)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
types.TracebackType(other_tb, frame, "no", 2)
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
types.TracebackType(other_tb, frame, 1, "nuh-uh")
|
||||
|
||||
|
||||
class TestContext(unittest.TestCase):
|
||||
def test_instance_context_instance_raise(self):
|
||||
context = IndexError()
|
||||
try:
|
||||
try:
|
||||
raise context
|
||||
except:
|
||||
raise OSError()
|
||||
except OSError as e:
|
||||
self.assertEqual(e.__context__, context)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_class_context_instance_raise(self):
|
||||
context = IndexError
|
||||
try:
|
||||
try:
|
||||
raise context
|
||||
except:
|
||||
raise OSError()
|
||||
except OSError as e:
|
||||
self.assertNotEqual(e.__context__, context)
|
||||
self.assertIsInstance(e.__context__, context)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_class_context_class_raise(self):
|
||||
context = IndexError
|
||||
try:
|
||||
try:
|
||||
raise context
|
||||
except:
|
||||
raise OSError
|
||||
except OSError as e:
|
||||
self.assertNotEqual(e.__context__, context)
|
||||
self.assertIsInstance(e.__context__, context)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_c_exception_context(self):
|
||||
try:
|
||||
try:
|
||||
1/0
|
||||
except:
|
||||
raise OSError
|
||||
except OSError as e:
|
||||
self.assertIsInstance(e.__context__, ZeroDivisionError)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_c_exception_raise(self):
|
||||
try:
|
||||
try:
|
||||
1/0
|
||||
except:
|
||||
xyzzy
|
||||
except NameError as e:
|
||||
self.assertIsInstance(e.__context__, ZeroDivisionError)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_noraise_finally(self):
|
||||
try:
|
||||
try:
|
||||
pass
|
||||
finally:
|
||||
raise OSError
|
||||
except OSError as e:
|
||||
self.assertIsNone(e.__context__)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_raise_finally(self):
|
||||
try:
|
||||
try:
|
||||
1/0
|
||||
finally:
|
||||
raise OSError
|
||||
except OSError as e:
|
||||
self.assertIsInstance(e.__context__, ZeroDivisionError)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_context_manager(self):
|
||||
class ContextManager:
|
||||
def __enter__(self):
|
||||
pass
|
||||
def __exit__(self, t, v, tb):
|
||||
xyzzy
|
||||
try:
|
||||
with ContextManager():
|
||||
1/0
|
||||
except NameError as e:
|
||||
self.assertIsInstance(e.__context__, ZeroDivisionError)
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_cycle_broken(self):
|
||||
# Self-cycles (when re-raising a caught exception) are broken
|
||||
try:
|
||||
try:
|
||||
1/0
|
||||
except ZeroDivisionError as e:
|
||||
raise e
|
||||
except ZeroDivisionError as e:
|
||||
self.assertIsNone(e.__context__)
|
||||
|
||||
def test_reraise_cycle_broken(self):
|
||||
# Non-trivial context cycles (through re-raising a previous exception)
|
||||
# are broken too.
|
||||
try:
|
||||
try:
|
||||
xyzzy
|
||||
except NameError as a:
|
||||
try:
|
||||
1/0
|
||||
except ZeroDivisionError:
|
||||
raise a
|
||||
except NameError as e:
|
||||
self.assertIsNone(e.__context__.__context__)
|
||||
|
||||
def test_3118(self):
|
||||
# deleting the generator caused the __context__ to be cleared
|
||||
def gen():
|
||||
try:
|
||||
yield 1
|
||||
finally:
|
||||
pass
|
||||
|
||||
def f():
|
||||
g = gen()
|
||||
next(g)
|
||||
try:
|
||||
try:
|
||||
raise ValueError
|
||||
except:
|
||||
del g
|
||||
raise KeyError
|
||||
except Exception as e:
|
||||
self.assertIsInstance(e.__context__, ValueError)
|
||||
|
||||
f()
|
||||
|
||||
def test_3611(self):
|
||||
# A re-raised exception in a __del__ caused the __context__
|
||||
# to be cleared
|
||||
class C:
|
||||
def __del__(self):
|
||||
try:
|
||||
1/0
|
||||
except:
|
||||
raise
|
||||
|
||||
def f():
|
||||
x = C()
|
||||
try:
|
||||
try:
|
||||
x.x
|
||||
except AttributeError:
|
||||
del x
|
||||
raise TypeError
|
||||
except Exception as e:
|
||||
self.assertNotEqual(e.__context__, None)
|
||||
self.assertIsInstance(e.__context__, AttributeError)
|
||||
|
||||
with support.captured_output("stderr"):
|
||||
f()
|
||||
|
||||
class TestRemovedFunctionality(unittest.TestCase):
|
||||
def test_tuples(self):
|
||||
try:
|
||||
raise (IndexError, KeyError) # This should be a tuple!
|
||||
except TypeError:
|
||||
pass
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
def test_strings(self):
|
||||
try:
|
||||
raise "foo"
|
||||
except TypeError:
|
||||
pass
|
||||
else:
|
||||
self.fail("No exception raised")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user