diff options
Diffstat (limited to 'Lib/test/test_builtin.py')
| -rw-r--r-- | Lib/test/test_builtin.py | 396 |
1 files changed, 221 insertions, 175 deletions
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index 420a17f..1469e36 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -1,17 +1,18 @@ # Python test set -- built-in functions import platform -import test.support, unittest -from test.support import fcmp, TESTFN, unlink, run_unittest, \ - run_with_locale +import unittest +import sys +import warnings +import collections +import io +import ast +import types +import builtins +import random +from test.support import fcmp, TESTFN, unlink, run_unittest, check_warnings from operator import neg -import sys, warnings, random, collections, io, fractions -warnings.filterwarnings("ignore", "hex../oct.. of negative int", - FutureWarning, __name__) -warnings.filterwarnings("ignore", "integer argument expected", - DeprecationWarning, "unittest") -import builtins class Squares: @@ -126,12 +127,18 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(abs(0.0), 0.0) self.assertEqual(abs(3.14), 3.14) self.assertEqual(abs(-3.14), 3.14) - # long - self.assertEqual(abs(0), 0) - self.assertEqual(abs(1234), 1234) - self.assertEqual(abs(-1234), 1234) # str self.assertRaises(TypeError, abs, 'a') + # bool + self.assertEqual(abs(True), 1) + self.assertEqual(abs(False), 0) + # other + self.assertRaises(TypeError, abs) + self.assertRaises(TypeError, abs, None) + class AbsClass(object): + def __abs__(self): + return -5 + self.assertEqual(abs(AbsClass()), -5) def test_all(self): self.assertEqual(all([2, 4, 6]), True) @@ -164,7 +171,6 @@ class BuiltinTest(unittest.TestCase): def test_ascii(self): self.assertEqual(ascii(''), '\'\'') self.assertEqual(ascii(0), '0') - self.assertEqual(ascii(0), '0') self.assertEqual(ascii(()), '()') self.assertEqual(ascii([]), '[]') self.assertEqual(ascii({}), '{}') @@ -202,22 +208,39 @@ class BuiltinTest(unittest.TestCase): self.assertTrue(isinstance(x, int)) self.assertEqual(-x, sys.maxsize+1) - # XXX(nnorwitz): This test case for callable should probably be removed. def test_callable(self): - self.assertTrue(hasattr(len, '__call__')) + self.assertTrue(callable(len)) + self.assertFalse(callable("a")) + self.assertTrue(callable(callable)) + self.assertTrue(callable(lambda x, y: x + y)) + self.assertFalse(callable(__builtins__)) def f(): pass - self.assertTrue(hasattr(f, '__call__')) - class C: + self.assertTrue(callable(f)) + + class C1: def meth(self): pass - self.assertTrue(hasattr(C, '__call__')) - x = C() - self.assertTrue(hasattr(x.meth, '__call__')) - self.assertTrue(not hasattr(x, '__call__')) - class D(C): + self.assertTrue(callable(C1)) + c = C1() + self.assertTrue(callable(c.meth)) + self.assertFalse(callable(c)) + + # __call__ is looked up on the class, not the instance + c.__call__ = None + self.assertFalse(callable(c)) + c.__call__ = lambda self: 0 + self.assertFalse(callable(c)) + del c.__call__ + self.assertFalse(callable(c)) + + class C2(object): def __call__(self): pass - y = D() - self.assertTrue(hasattr(y, '__call__')) - y() + c2 = C2() + self.assertTrue(callable(c2)) + c2.__call__ = None + self.assertTrue(callable(c2)) + class C3(C2): pass + c3 = C3() + self.assertTrue(callable(c3)) def test_chr(self): self.assertEqual(chr(32), ' ') @@ -263,8 +286,35 @@ class BuiltinTest(unittest.TestCase): self.assertRaises(TypeError, compile, chr(0), 'f', 'exec') self.assertRaises(ValueError, compile, str('a = 1'), 'f', 'bad') + # test the optimize argument + + codestr = '''def f(): + """doc""" + try: + assert False + except AssertionError: + return (True, f.__doc__) + else: + return (False, f.__doc__) + ''' + def f(): """doc""" + values = [(-1, __debug__, f.__doc__), + (0, True, 'doc'), + (1, False, 'doc'), + (2, False, None)] + for optval, debugval, docstring in values: + # test both direct compilation and compilation via AST + codeobjs = [] + codeobjs.append(compile(codestr, "<test>", "exec", optimize=optval)) + tree = ast.parse(codestr) + codeobjs.append(compile(tree, "<test>", "exec", optimize=optval)) + for code in codeobjs: + ns = {} + exec(code, ns) + rv = ns['f']() + self.assertEqual(rv, (debugval, docstring)) + def test_delattr(self): - import sys sys.spam = 1 delattr(sys, 'spam') self.assertRaises(TypeError, delattr) @@ -275,22 +325,20 @@ class BuiltinTest(unittest.TestCase): # dir() - local scope local_var = 1 - self.assertTrue('local_var' in dir()) + self.assertIn('local_var', dir()) # dir(module) - import sys - self.assertTrue('exit' in dir(sys)) + self.assertIn('exit', dir(sys)) # dir(module_with_invalid__dict__) - import types class Foo(types.ModuleType): __dict__ = 8 f = Foo("foo") self.assertRaises(TypeError, dir, f) # dir(type) - self.assertTrue("strip" in dir(str)) - self.assertTrue("__mro__" not in dir(str)) + self.assertIn("strip", dir(str)) + self.assertNotIn("__mro__", dir(str)) # dir(obj) class Foo(object): @@ -299,13 +347,13 @@ class BuiltinTest(unittest.TestCase): self.y = 8 self.z = 9 f = Foo() - self.assertTrue("y" in dir(f)) + self.assertIn("y", dir(f)) # dir(obj_no__dict__) class Foo(object): __slots__ = [] f = Foo() - self.assertTrue("__repr__" in dir(f)) + self.assertIn("__repr__", dir(f)) # dir(obj_no__class__with__dict__) # (an ugly trick to cause getattr(f, "__class__") to fail) @@ -314,8 +362,8 @@ class BuiltinTest(unittest.TestCase): def __init__(self): self.bar = "wow" f = Foo() - self.assertTrue("__repr__" not in dir(f)) - self.assertTrue("bar" in dir(f)) + self.assertNotIn("__repr__", dir(f)) + self.assertIn("bar", dir(f)) # dir(obj_using __dir__) class Foo(object): @@ -344,18 +392,7 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(divmod(12, -7), (-2, -2)) self.assertEqual(divmod(-12, -7), (1, -5)) - self.assertEqual(divmod(12, 7), (1, 5)) - self.assertEqual(divmod(-12, 7), (-2, 2)) - self.assertEqual(divmod(12, -7), (-2, -2)) - self.assertEqual(divmod(-12, -7), (1, -5)) - - self.assertEqual(divmod(12, 7), (1, 5)) - self.assertEqual(divmod(-12, 7), (-2, 2)) - self.assertEqual(divmod(12, -7), (-2, -2)) - self.assertEqual(divmod(-12, -7), (1, -5)) - - self.assertEqual(divmod(-sys.maxsize-1, -1), - (sys.maxsize+1, 0)) + self.assertEqual(divmod(-sys.maxsize-1, -1), (sys.maxsize+1, 0)) self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) @@ -465,9 +502,10 @@ class BuiltinTest(unittest.TestCase): g = {} l = {} - import warnings - warnings.filterwarnings("ignore", "global statement", module="<string>") - exec('global a; a = 1; b = 2', g, l) + with check_warnings(): + warnings.filterwarnings("ignore", "global statement", + module="<string>") + exec('global a; a = 1; b = 2', g, l) if '__builtins__' in g: del g['__builtins__'] if '__builtins__' in l: @@ -511,7 +549,6 @@ class BuiltinTest(unittest.TestCase): self.assertRaises(TypeError, list, filter(42, (1, 2))) def test_getattr(self): - import sys self.assertTrue(getattr(sys, 'stdout') is sys.stdout) self.assertRaises(TypeError, getattr, sys, 1) self.assertRaises(TypeError, getattr, sys, 1, "foo") @@ -521,21 +558,21 @@ class BuiltinTest(unittest.TestCase): self.assertRaises(AttributeError, getattr, 1, "\uDAD1\uD51E") def test_hasattr(self): - import sys self.assertTrue(hasattr(sys, 'stdout')) self.assertRaises(TypeError, hasattr, sys, 1) self.assertRaises(TypeError, hasattr) self.assertEqual(False, hasattr(sys, chr(sys.maxunicode))) - # Check that hasattr allows SystemExit and KeyboardInterrupts by + # Check that hasattr propagates all exceptions outside of + # AttributeError. class A: def __getattr__(self, what): - raise KeyboardInterrupt - self.assertRaises(KeyboardInterrupt, hasattr, A(), "b") + raise SystemExit + self.assertRaises(SystemExit, hasattr, A(), "b") class B: def __getattr__(self, what): - raise SystemExit - self.assertRaises(SystemExit, hasattr, B(), "b") + raise ValueError + self.assertRaises(ValueError, hasattr, B(), "b") def test_hash(self): hash(None) @@ -552,10 +589,6 @@ class BuiltinTest(unittest.TestCase): def __hash__(self): return 2**100 self.assertEqual(type(hash(X())), int) - class Y(object): - def __hash__(self): - return 2**100 - self.assertEqual(type(hash(Y())), int) class Z(int): def __hash__(self): return self @@ -563,15 +596,12 @@ class BuiltinTest(unittest.TestCase): def test_hex(self): self.assertEqual(hex(16), '0x10') - self.assertEqual(hex(16), '0x10') - self.assertEqual(hex(-16), '-0x10') self.assertEqual(hex(-16), '-0x10') self.assertRaises(TypeError, hex, {}) def test_id(self): id(None) id(1) - id(1) id(1.0) id('spam') id((0,1,2,3)) @@ -648,6 +678,8 @@ class BuiltinTest(unittest.TestCase): def __len__(self): return sys.maxsize + 1 self.assertRaises(OverflowError, len, HugeLen()) + class NoLenMethod(object): pass + self.assertRaises(TypeError, len, NoLenMethod()) def test_map(self): self.assertEqual( @@ -814,8 +846,6 @@ class BuiltinTest(unittest.TestCase): def test_oct(self): self.assertEqual(oct(100), '0o144') - self.assertEqual(oct(100), '0o144') - self.assertEqual(oct(-100), '-0o144') self.assertEqual(oct(-100), '-0o144') self.assertRaises(TypeError, oct, ()) @@ -824,7 +854,6 @@ class BuiltinTest(unittest.TestCase): fp = open(TESTFN, 'w') try: fp.write('1+1\n') - fp.write('1+1\n') fp.write('The quick brown fox jumps over the lazy dog') fp.write('.\n') fp.write('Dear John\n') @@ -838,7 +867,6 @@ class BuiltinTest(unittest.TestCase): fp = open(TESTFN, 'r') try: self.assertEqual(fp.readline(4), '1+1\n') - self.assertEqual(fp.readline(4), '1+1\n') self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n') self.assertEqual(fp.readline(4), 'Dear') self.assertEqual(fp.readline(100), ' John\n') @@ -891,21 +919,6 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(pow(-2,2), 4) self.assertEqual(pow(-2,3), -8) - self.assertEqual(pow(0,0), 1) - self.assertEqual(pow(0,1), 0) - self.assertEqual(pow(1,0), 1) - self.assertEqual(pow(1,1), 1) - - self.assertEqual(pow(2,0), 1) - self.assertEqual(pow(2,10), 1024) - self.assertEqual(pow(2,20), 1024*1024) - self.assertEqual(pow(2,30), 1024*1024*1024) - - self.assertEqual(pow(-2,0), 1) - self.assertEqual(pow(-2,1), -2) - self.assertEqual(pow(-2,2), 4) - self.assertEqual(pow(-2,3), -8) - self.assertAlmostEqual(pow(0.,0), 1.) self.assertAlmostEqual(pow(0.,1), 0.) self.assertAlmostEqual(pow(1.,0), 1.) @@ -921,9 +934,9 @@ class BuiltinTest(unittest.TestCase): self.assertAlmostEqual(pow(-2.,2), 4.) self.assertAlmostEqual(pow(-2.,3), -8.) - for x in 2, 2, 2.0: - for y in 10, 10, 10.0: - for z in 1000, 1000, 1000.0: + for x in 2, 2.0: + for y in 10, 10.0: + for z in 1000, 1000.0: if isinstance(x, float) or \ isinstance(y, float) or \ isinstance(z, float): @@ -936,93 +949,9 @@ class BuiltinTest(unittest.TestCase): self.assertRaises(TypeError, pow, -1, -2, 3) self.assertRaises(ValueError, pow, 1, 2, 0) - self.assertRaises(TypeError, pow, -1, -2, 3) - self.assertRaises(ValueError, pow, 1, 2, 0) self.assertRaises(TypeError, pow) - def test_range(self): - self.assertEqual(list(range(3)), [0, 1, 2]) - self.assertEqual(list(range(1, 5)), [1, 2, 3, 4]) - self.assertEqual(list(range(0)), []) - self.assertEqual(list(range(-3)), []) - self.assertEqual(list(range(1, 10, 3)), [1, 4, 7]) - #self.assertEqual(list(range(5, -5, -3)), [5, 2, -1, -4]) - - #issue 6334: the internal stored range length was being - #computed incorrectly in some cases involving large arguments. - x = range(10**20, 10**20+10, 3) - self.assertEqual(len(x), 4) - self.assertEqual(len(list(x)), 4) - - x = range(10**20+10, 10**20, 3) - self.assertEqual(len(x), 0) - self.assertEqual(len(list(x)), 0) - - x = range(10**20, 10**20+10, -3) - self.assertEqual(len(x), 0) - self.assertEqual(len(list(x)), 0) - - x = range(10**20+10, 10**20, -3) - self.assertEqual(len(x), 4) - self.assertEqual(len(list(x)), 4) - - """ XXX(nnorwitz): - # Now test range() with longs - self.assertEqual(list(range(-2**100)), []) - self.assertEqual(list(range(0, -2**100)), []) - self.assertEqual(list(range(0, 2**100, -1)), []) - self.assertEqual(list(range(0, 2**100, -1)), []) - - a = int(10 * sys.maxsize) - b = int(100 * sys.maxsize) - c = int(50 * sys.maxsize) - - self.assertEqual(list(range(a, a+2)), [a, a+1]) - self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1]) - self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2]) - - seq = list(range(a, b, c)) - self.assertTrue(a in seq) - self.assertTrue(b not in seq) - self.assertEqual(len(seq), 2) - - seq = list(range(b, a, -c)) - self.assertTrue(b in seq) - self.assertTrue(a not in seq) - self.assertEqual(len(seq), 2) - - seq = list(range(-a, -b, -c)) - self.assertTrue(-a in seq) - self.assertTrue(-b not in seq) - self.assertEqual(len(seq), 2) - - self.assertRaises(TypeError, range) - self.assertRaises(TypeError, range, 1, 2, 3, 4) - self.assertRaises(ValueError, range, 1, 2, 0) - self.assertRaises(ValueError, range, a, a + 1, int(0)) - - class badzero(int): - def __eq__(self, other): - raise RuntimeError - __ne__ = __lt__ = __gt__ = __le__ = __ge__ = __eq__ - - # XXX This won't (but should!) raise RuntimeError if a is an int... - self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) - """ - - # Reject floats when it would require PyLongs to represent. - # (smaller floats still accepted, but deprecated) - self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) - - self.assertRaises(TypeError, range, 0, "spam") - self.assertRaises(TypeError, range, 0, 42, "spam") - - #NEAL self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize) - #NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxsize) - - self.assertRaises(OverflowError, len, range(0, sys.maxsize**10)) - def test_input(self): self.write_testfile() fp = open(TESTFN, 'r') @@ -1032,7 +961,6 @@ class BuiltinTest(unittest.TestCase): sys.stdin = fp sys.stdout = BitBucket() self.assertEqual(input(), "1+1") - self.assertEqual(input('testing\n'), "1+1") self.assertEqual(input(), 'The quick brown fox jumps over the lazy dog.') self.assertEqual(input('testing\n'), 'Dear John') @@ -1063,7 +991,6 @@ class BuiltinTest(unittest.TestCase): def test_repr(self): self.assertEqual(repr(''), '\'\'') self.assertEqual(repr(0), '0') - self.assertEqual(repr(0), '0') self.assertEqual(repr(()), '()') self.assertEqual(repr([]), '[]') self.assertEqual(repr({}), '{}') @@ -1197,6 +1124,10 @@ class BuiltinTest(unittest.TestCase): raise ValueError self.assertRaises(ValueError, sum, BadSeq()) + empty = [] + sum(([x] for x in range(10)), empty) + self.assertEqual(empty, []) + def test_type(self): self.assertEqual(type(''), type('123')) self.assertNotEqual(type(''), type(())) @@ -1214,14 +1145,19 @@ class BuiltinTest(unittest.TestCase): b = 2 return vars() + class C_get_vars(object): + def getDict(self): + return {'a':2} + __dict__ = property(fget=getDict) + def test_vars(self): self.assertEqual(set(vars()), set(dir())) - import sys self.assertEqual(set(vars(sys)), set(dir(sys))) self.assertEqual(self.get_vars_f0(), {}) self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2}) self.assertRaises(TypeError, vars, 42, 42) self.assertRaises(TypeError, vars, 42) + self.assertEqual(vars(self.C_get_vars()), {'a':2}) def test_zip(self): a = (1, 2, 3) @@ -1267,6 +1203,116 @@ class BuiltinTest(unittest.TestCase): return i self.assertRaises(ValueError, list, zip(BadSeq(), BadSeq())) + def test_format(self): + # Test the basic machinery of the format() builtin. Don't test + # the specifics of the various formatters + self.assertEqual(format(3, ''), '3') + + # Returns some classes to use for various tests. There's + # an old-style version, and a new-style version + def classes_new(): + class A(object): + def __init__(self, x): + self.x = x + def __format__(self, format_spec): + return str(self.x) + format_spec + class DerivedFromA(A): + pass + + class Simple(object): pass + class DerivedFromSimple(Simple): + def __init__(self, x): + self.x = x + def __format__(self, format_spec): + return str(self.x) + format_spec + class DerivedFromSimple2(DerivedFromSimple): pass + return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 + + def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2): + self.assertEqual(format(A(3), 'spec'), '3spec') + self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec') + self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc') + self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'), + '10abcdef') + + class_test(*classes_new()) + + def empty_format_spec(value): + # test that: + # format(x, '') == str(x) + # format(x) == str(x) + self.assertEqual(format(value, ""), str(value)) + self.assertEqual(format(value), str(value)) + + # for builtin types, format(x, "") == str(x) + empty_format_spec(17**13) + empty_format_spec(1.0) + empty_format_spec(3.1415e104) + empty_format_spec(-3.1415e104) + empty_format_spec(3.1415e-104) + empty_format_spec(-3.1415e-104) + empty_format_spec(object) + empty_format_spec(None) + + # TypeError because self.__format__ returns the wrong type + class BadFormatResult: + def __format__(self, format_spec): + return 1.0 + self.assertRaises(TypeError, format, BadFormatResult(), "") + + # TypeError because format_spec is not unicode or str + self.assertRaises(TypeError, format, object(), 4) + self.assertRaises(TypeError, format, object(), object()) + + # tests for object.__format__ really belong elsewhere, but + # there's no good place to put them + x = object().__format__('') + self.assertTrue(x.startswith('<object object at')) + + # first argument to object.__format__ must be string + self.assertRaises(TypeError, object().__format__, 3) + self.assertRaises(TypeError, object().__format__, object()) + self.assertRaises(TypeError, object().__format__, None) + + # -------------------------------------------------------------------- + # Issue #7994: object.__format__ with a non-empty format string is + # pending deprecated + def test_deprecated_format_string(obj, fmt_str, should_raise_warning): + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always", PendingDeprecationWarning) + format(obj, fmt_str) + if should_raise_warning: + self.assertEqual(len(w), 1) + self.assertIsInstance(w[0].message, PendingDeprecationWarning) + self.assertIn('object.__format__ with a non-empty format ' + 'string', str(w[0].message)) + else: + self.assertEqual(len(w), 0) + + fmt_strs = ['', 's'] + + class A: + def __format__(self, fmt_str): + return format('', fmt_str) + + for fmt_str in fmt_strs: + test_deprecated_format_string(A(), fmt_str, False) + + class B: + pass + + class C(object): + pass + + for cls in [object, B, C]: + for fmt_str in fmt_strs: + test_deprecated_format_string(cls(), fmt_str, len(fmt_str) != 0) + # -------------------------------------------------------------------- + + # make sure we can take a subclass of str as a format spec + class DerivedFromStr(str): pass + self.assertEqual(format(0, DerivedFromStr('10')), ' 0') + def test_bin(self): self.assertEqual(bin(0), '0b0') self.assertEqual(bin(1), '0b1') |