Changeset 391 for python/trunk/Lib/test/test_builtin.py
- Timestamp:
- Mar 19, 2014, 11:31:01 PM (11 years ago)
- Location:
- python/trunk
- Files:
-
- 2 edited
-
. (modified) (1 prop)
-
Lib/test/test_builtin.py (modified) (40 diffs)
Legend:
- Unmodified
- Added
- Removed
-
python/trunk
-
Property svn:mergeinfo
set to
/python/vendor/Python-2.7.6 merged eligible /python/vendor/current merged eligible
-
Property svn:mergeinfo
set to
-
python/trunk/Lib/test/test_builtin.py
r2 r391 2 2 3 3 import platform 4 import test.test_support,unittest4 import unittest 5 5 from test.test_support import fcmp, have_unicode, TESTFN, unlink, \ 6 run_unittest, run_with_locale 6 run_unittest, check_py3k_warnings 7 import warnings 7 8 from operator import neg 8 9 9 import sys, warnings, cStringIO, random, fractions, UserDict 10 warnings.filterwarnings("ignore", "hex../oct.. of negative int", 11 FutureWarning, __name__) 12 warnings.filterwarnings("ignore", "integer argument expected", 13 DeprecationWarning, "unittest") 10 import sys, cStringIO, random, UserDict 14 11 15 12 # count the number of test runs. … … 94 91 # str 95 92 self.assertRaises(TypeError, abs, 'a') 93 # bool 94 self.assertEqual(abs(True), 1) 95 self.assertEqual(abs(False), 0) 96 # other 97 self.assertRaises(TypeError, abs) 98 self.assertRaises(TypeError, abs, None) 99 class AbsClass(object): 100 def __abs__(self): 101 return -5 102 self.assertEqual(abs(AbsClass()), -5) 96 103 97 104 def test_all(self): … … 104 111 self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args 105 112 self.assertEqual(all([]), True) # Empty iterator 113 self.assertEqual(all([0, TestFailingBool()]), False)# Short-circuit 106 114 S = [50, 60] 107 115 self.assertEqual(all(x > 42 for x in S), True) … … 113 121 self.assertEqual(any([None, 4, None]), True) 114 122 self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6]) 115 self.assertRaises(RuntimeError, a ll, TestFailingIter())123 self.assertRaises(RuntimeError, any, TestFailingIter()) 116 124 self.assertRaises(TypeError, any, 10) # Non-iterable 117 125 self.assertRaises(TypeError, any) # No args 118 126 self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args 119 127 self.assertEqual(any([]), False) # Empty iterator 128 self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit 120 129 S = [40, 60, 30] 121 130 self.assertEqual(any(x > 42 for x in S), True) … … 125 134 def test_neg(self): 126 135 x = -sys.maxint-1 127 self.assert _(isinstance(x, int))136 self.assertTrue(isinstance(x, int)) 128 137 self.assertEqual(-x, sys.maxint+1) 129 138 … … 155 164 156 165 def test_callable(self): 157 self.assert_(callable(len)) 166 self.assertTrue(callable(len)) 167 self.assertFalse(callable("a")) 168 self.assertTrue(callable(callable)) 169 self.assertTrue(callable(lambda x, y: x + y)) 170 self.assertFalse(callable(__builtins__)) 158 171 def f(): pass 159 self.assert_(callable(f)) 160 class C: 172 self.assertTrue(callable(f)) 173 174 class Classic: 161 175 def meth(self): pass 162 self.assert_(callable(C)) 163 x = C() 164 self.assert_(callable(x.meth)) 165 self.assert_(not callable(x)) 166 class D(C): 176 self.assertTrue(callable(Classic)) 177 c = Classic() 178 self.assertTrue(callable(c.meth)) 179 self.assertFalse(callable(c)) 180 181 class NewStyle(object): 182 def meth(self): pass 183 self.assertTrue(callable(NewStyle)) 184 n = NewStyle() 185 self.assertTrue(callable(n.meth)) 186 self.assertFalse(callable(n)) 187 188 # Classic and new-style classes evaluate __call__() differently 189 c.__call__ = None 190 self.assertTrue(callable(c)) 191 del c.__call__ 192 self.assertFalse(callable(c)) 193 n.__call__ = None 194 self.assertFalse(callable(n)) 195 del n.__call__ 196 self.assertFalse(callable(n)) 197 198 class N2(object): 167 199 def __call__(self): pass 168 y = D() 169 self.assert_(callable(y)) 170 y() 200 n2 = N2() 201 self.assertTrue(callable(n2)) 202 class N3(N2): pass 203 n3 = N3() 204 self.assertTrue(callable(n3)) 171 205 172 206 def test_chr(self): … … 196 230 197 231 def test_coerce(self): 198 self.assert _(not fcmp(coerce(1, 1.1), (1.0, 1.1)))232 self.assertTrue(not fcmp(coerce(1, 1.1), (1.0, 1.1))) 199 233 self.assertEqual(coerce(1, 1L), (1L, 1L)) 200 self.assert _(not fcmp(coerce(1L, 1.1), (1.0, 1.1)))234 self.assertTrue(not fcmp(coerce(1L, 1.1), (1.0, 1.1))) 201 235 self.assertRaises(TypeError, coerce) 202 236 class BadNumber: … … 237 271 # dir() - local scope 238 272 local_var = 1 239 self.assert _('local_var' indir())273 self.assertIn('local_var', dir()) 240 274 241 275 # dir(module) 242 276 import sys 243 self.assert _('exit' indir(sys))277 self.assertIn('exit', dir(sys)) 244 278 245 279 # dir(module_with_invalid__dict__) … … 251 285 252 286 # dir(type) 253 self.assert _("strip" indir(str))254 self.assert _("__mro__" not indir(str))287 self.assertIn("strip", dir(str)) 288 self.assertNotIn("__mro__", dir(str)) 255 289 256 290 # dir(obj) … … 261 295 self.z = 9 262 296 f = Foo() 263 self.assert _("y" indir(f))297 self.assertIn("y", dir(f)) 264 298 265 299 # dir(obj_no__dict__) … … 267 301 __slots__ = [] 268 302 f = Foo() 269 self.assert _("__repr__" indir(f))303 self.assertIn("__repr__", dir(f)) 270 304 271 305 # dir(obj_no__class__with__dict__) … … 276 310 self.bar = "wow" 277 311 f = Foo() 278 self.assert _("__repr__" not indir(f))279 self.assert _("bar" indir(f))312 self.assertNotIn("__repr__", dir(f)) 313 self.assertIn("bar", dir(f)) 280 314 281 315 # dir(obj_using __dir__) … … 284 318 return ["kan", "ga", "roo"] 285 319 f = Foo() 286 self.assert _(dir(f) == ["ga", "kan", "roo"])320 self.assertTrue(dir(f) == ["ga", "kan", "roo"]) 287 321 288 322 # dir(obj__dir__not_list) … … 312 346 (sys.maxint+1, 0)) 313 347 314 self.assert _(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))315 self.assert _(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))316 self.assert _(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))317 self.assert _(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))348 self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) 349 self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) 350 self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) 351 self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) 318 352 319 353 self.assertRaises(TypeError, divmod) … … 420 454 f.write('z = z*2\n') 421 455 f.close() 422 execfile(TESTFN) 456 with check_py3k_warnings(("execfile.. not supported in 3.x", 457 DeprecationWarning)): 458 execfile(TESTFN) 423 459 424 460 def test_execfile(self): … … 574 610 outp = filter(func, cls(inp)) 575 611 self.assertEqual(outp, exp) 576 self.assert _(not isinstance(outp, cls))612 self.assertTrue(not isinstance(outp, cls)) 577 613 578 614 def test_getattr(self): 579 615 import sys 580 self.assert _(getattr(sys, 'stdout') is sys.stdout)616 self.assertTrue(getattr(sys, 'stdout') is sys.stdout) 581 617 self.assertRaises(TypeError, getattr, sys, 1) 582 618 self.assertRaises(TypeError, getattr, sys, 1, "foo") … … 587 623 def test_hasattr(self): 588 624 import sys 589 self.assert _(hasattr(sys, 'stdout'))625 self.assertTrue(hasattr(sys, 'stdout')) 590 626 self.assertRaises(TypeError, hasattr, sys, 1) 591 627 self.assertRaises(TypeError, hasattr) … … 618 654 def __hash__(self): 619 655 return 2**100 620 self.assertEqual s(type(hash(X())), int)656 self.assertEqual(type(hash(X())), int) 621 657 class Y(object): 622 658 def __hash__(self): 623 659 return 2**100 624 self.assertEqual s(type(hash(Y())), int)660 self.assertEqual(type(hash(Y())), int) 625 661 class Z(long): 626 662 def __hash__(self): 627 663 return self 628 self.assertEqual s(hash(Z(42)), hash(42L))664 self.assertEqual(hash(Z(42)), hash(42L)) 629 665 630 666 def test_hex(self): … … 647 683 # Test input() later, together with raw_input 648 684 685 # test_int(): see test_int.py for int() tests. 686 649 687 def test_intern(self): 650 688 self.assertRaises(TypeError, intern) … … 652 690 # therefore append the run counter 653 691 s = "never interned before " + str(numruns) 654 self.assert _(intern(s) is s)692 self.assertTrue(intern(s) is s) 655 693 s2 = s.swapcase().swapcase() 656 self.assert _(intern(s2) is s)694 self.assertTrue(intern(s2) is s) 657 695 658 696 # Subclasses of string can't be interned, because they … … 660 698 # We don't want them in the interned dict and if they aren't 661 699 # actually interned, we don't want to create the appearance 662 # that they are by allowing intern() to succee ed.700 # that they are by allowing intern() to succeed. 663 701 class S(str): 664 702 def __hash__(self): … … 695 733 d = D() 696 734 e = E() 697 self.assert _(isinstance(c, C))698 self.assert _(isinstance(d, C))699 self.assert _(not isinstance(e, C))700 self.assert _(not isinstance(c, D))701 self.assert _(not isinstance('foo', E))735 self.assertTrue(isinstance(c, C)) 736 self.assertTrue(isinstance(d, C)) 737 self.assertTrue(not isinstance(e, C)) 738 self.assertTrue(not isinstance(c, D)) 739 self.assertTrue(not isinstance('foo', E)) 702 740 self.assertRaises(TypeError, isinstance, E, 'foo') 703 741 self.assertRaises(TypeError, isinstance) … … 713 751 d = D() 714 752 e = E() 715 self.assert _(issubclass(D, C))716 self.assert _(issubclass(C, C))717 self.assert _(not issubclass(C, D))753 self.assertTrue(issubclass(D, C)) 754 self.assertTrue(issubclass(C, C)) 755 self.assertTrue(not issubclass(C, D)) 718 756 self.assertRaises(TypeError, issubclass, 'foo', E) 719 757 self.assertRaises(TypeError, issubclass, E, 'foo') … … 731 769 raise ValueError 732 770 self.assertRaises(ValueError, len, BadSeq()) 771 self.assertRaises(TypeError, len, 2) 772 class ClassicStyle: pass 773 class NewStyle(object): pass 774 self.assertRaises(AttributeError, len, ClassicStyle()) 775 self.assertRaises(TypeError, len, NewStyle()) 733 776 734 777 def test_map(self): … … 892 935 self.assertRaises(StopIteration, next, it) 893 936 self.assertRaises(StopIteration, next, it) 894 self.assertEqual s(next(it, 42), 42)937 self.assertEqual(next(it, 42), 42) 895 938 896 939 class Iter(object): … … 901 944 902 945 it = iter(Iter()) 903 self.assertEqual s(next(it, 42), 42)946 self.assertEqual(next(it, 42), 42) 904 947 self.assertRaises(StopIteration, next, it) 905 948 … … 909 952 910 953 it = gen() 911 self.assertEqual s(next(it), 1)954 self.assertEqual(next(it), 1) 912 955 self.assertRaises(StopIteration, next, it) 913 self.assertEqual s(next(it, 42), 42)956 self.assertEqual(next(it, 42), 42) 914 957 915 958 def test_oct(self): … … 1047 1090 1048 1091 seq = range(a, b, c) 1049 self.assert _(a inseq)1050 self.assert _(b not inseq)1092 self.assertIn(a, seq) 1093 self.assertNotIn(b, seq) 1051 1094 self.assertEqual(len(seq), 2) 1052 1095 1053 1096 seq = range(b, a, -c) 1054 self.assert _(b inseq)1055 self.assert _(a not inseq)1097 self.assertIn(b, seq) 1098 self.assertNotIn(a, seq) 1056 1099 self.assertEqual(len(seq), 2) 1057 1100 1058 1101 seq = range(-a, -b, -c) 1059 self.assert _(-a inseq)1060 self.assert _(-b not inseq)1102 self.assertIn(-a, seq) 1103 self.assertNotIn(-b, seq) 1061 1104 self.assertEqual(len(seq), 2) 1062 1105 … … 1072 1115 self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) 1073 1116 1074 # Reject floats when it would require PyLongs to represent.1075 # (smaller floats still accepted, but deprecated)1117 # Reject floats. 1118 self.assertRaises(TypeError, range, 1., 1., 1.) 1076 1119 self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) 1077 1120 … … 1081 1124 self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint) 1082 1125 self.assertRaises(OverflowError, range, 0, 2*sys.maxint) 1126 1127 bignum = 2*sys.maxint 1128 smallnum = 42 1129 # Old-style user-defined class with __int__ method 1130 class I0: 1131 def __init__(self, n): 1132 self.n = int(n) 1133 def __int__(self): 1134 return self.n 1135 self.assertEqual(range(I0(bignum), I0(bignum + 1)), [bignum]) 1136 self.assertEqual(range(I0(smallnum), I0(smallnum + 1)), [smallnum]) 1137 1138 # New-style user-defined class with __int__ method 1139 class I1(object): 1140 def __init__(self, n): 1141 self.n = int(n) 1142 def __int__(self): 1143 return self.n 1144 self.assertEqual(range(I1(bignum), I1(bignum + 1)), [bignum]) 1145 self.assertEqual(range(I1(smallnum), I1(smallnum + 1)), [smallnum]) 1146 1147 # New-style user-defined class with failing __int__ method 1148 class IX(object): 1149 def __int__(self): 1150 raise RuntimeError 1151 self.assertRaises(RuntimeError, range, IX()) 1152 1153 # New-style user-defined class with invalid __int__ method 1154 class IN(object): 1155 def __int__(self): 1156 return "not a number" 1157 self.assertRaises(TypeError, range, IN()) 1158 1159 # Exercise various combinations of bad arguments, to check 1160 # refcounting logic 1161 self.assertRaises(TypeError, range, 0.0) 1162 1163 self.assertRaises(TypeError, range, 0, 0.0) 1164 self.assertRaises(TypeError, range, 0.0, 0) 1165 self.assertRaises(TypeError, range, 0.0, 0.0) 1166 1167 self.assertRaises(TypeError, range, 0, 0, 1.0) 1168 self.assertRaises(TypeError, range, 0, 0.0, 1) 1169 self.assertRaises(TypeError, range, 0, 0.0, 1.0) 1170 self.assertRaises(TypeError, range, 0.0, 0, 1) 1171 self.assertRaises(TypeError, range, 0.0, 0, 1.0) 1172 self.assertRaises(TypeError, range, 0.0, 0.0, 1) 1173 self.assertRaises(TypeError, range, 0.0, 0.0, 1.0) 1174 1175 1083 1176 1084 1177 def test_input_and_raw_input(self): … … 1140 1233 1141 1234 def test_reduce(self): 1142 self.assertEqual(reduce(lambda x, y: x+y, ['a', 'b', 'c'], ''), 'abc') 1235 add = lambda x, y: x+y 1236 self.assertEqual(reduce(add, ['a', 'b', 'c'], ''), 'abc') 1143 1237 self.assertEqual( 1144 reduce( lambda x, y: x+y, [['a', 'c'], [], ['d', 'w']], []),1238 reduce(add, [['a', 'c'], [], ['d', 'w']], []), 1145 1239 ['a','c','d','w'] 1146 1240 ) … … 1150 1244 2432902008176640000L 1151 1245 ) 1152 self.assertEqual(reduce( lambda x, y: x+y, Squares(10)), 285)1153 self.assertEqual(reduce( lambda x, y: x+y, Squares(10), 0), 285)1154 self.assertEqual(reduce( lambda x, y: x+y, Squares(0), 0), 0)1246 self.assertEqual(reduce(add, Squares(10)), 285) 1247 self.assertEqual(reduce(add, Squares(10), 0), 285) 1248 self.assertEqual(reduce(add, Squares(0), 0), 0) 1155 1249 self.assertRaises(TypeError, reduce) 1250 self.assertRaises(TypeError, reduce, 42) 1156 1251 self.assertRaises(TypeError, reduce, 42, 42) 1157 1252 self.assertRaises(TypeError, reduce, 42, 42, 42) 1253 self.assertRaises(TypeError, reduce, None, range(5)) 1254 self.assertRaises(TypeError, reduce, add, 42) 1158 1255 self.assertEqual(reduce(42, "1"), "1") # func is never called with one item 1159 1256 self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item 1160 1257 self.assertRaises(TypeError, reduce, 42, (42, 42)) 1258 self.assertRaises(TypeError, reduce, add, []) # arg 2 must not be empty sequence with no initial value 1259 self.assertRaises(TypeError, reduce, add, "") 1260 self.assertRaises(TypeError, reduce, add, ()) 1261 self.assertEqual(reduce(add, [], None), None) 1262 self.assertEqual(reduce(add, [], 42), 42) 1161 1263 1162 1264 class BadSeq: … … 1261 1363 self.assertRaises(TypeError, round, t, 0) 1262 1364 1365 # Some versions of glibc for alpha have a bug that affects 1366 # float -> integer rounding (floor, ceil, rint, round) for 1367 # values in the range [2**52, 2**53). See: 1368 # 1369 # http://sources.redhat.com/bugzilla/show_bug.cgi?id=5350 1370 # 1371 # We skip this test on Linux/alpha if it would fail. 1372 linux_alpha = (platform.system().startswith('Linux') and 1373 platform.machine().startswith('alpha')) 1374 system_round_bug = round(5e15+1) != 5e15+1 1375 @unittest.skipIf(linux_alpha and system_round_bug, 1376 "test will fail; failure is probably due to a " 1377 "buggy system round function") 1263 1378 def test_round_large(self): 1264 1379 # Issue #1869: integral floats should remain unchanged … … 1295 1410 raise ValueError 1296 1411 self.assertRaises(ValueError, sum, BadSeq()) 1412 1413 empty = [] 1414 sum(([x] for x in range(10)), empty) 1415 self.assertEqual(empty, []) 1297 1416 1298 1417 def test_type(self): … … 1326 1445 return vars() 1327 1446 1447 class C_get_vars(object): 1448 def getDict(self): 1449 return {'a':2} 1450 __dict__ = property(fget=getDict) 1451 1328 1452 def test_vars(self): 1329 1453 self.assertEqual(set(vars()), set(dir())) … … 1334 1458 self.assertRaises(TypeError, vars, 42, 42) 1335 1459 self.assertRaises(TypeError, vars, 42) 1460 self.assertEqual(vars(self.C_get_vars()), {'a':2}) 1336 1461 1337 1462 def test_zip(self): … … 1462 1587 # there's no good place to put them 1463 1588 x = object().__format__('') 1464 self.assert _(x.startswith('<object object at'))1589 self.assertTrue(x.startswith('<object object at')) 1465 1590 1466 1591 # first argument to object.__format__ must be string … … 1468 1593 self.assertRaises(TypeError, object().__format__, object()) 1469 1594 self.assertRaises(TypeError, object().__format__, None) 1595 1596 # -------------------------------------------------------------------- 1597 # Issue #7994: object.__format__ with a non-empty format string is 1598 # pending deprecated 1599 def test_deprecated_format_string(obj, fmt_str, should_raise_warning): 1600 with warnings.catch_warnings(record=True) as w: 1601 warnings.simplefilter("always", PendingDeprecationWarning) 1602 format(obj, fmt_str) 1603 if should_raise_warning: 1604 self.assertEqual(len(w), 1) 1605 self.assertIsInstance(w[0].message, PendingDeprecationWarning) 1606 self.assertIn('object.__format__ with a non-empty format ' 1607 'string', str(w[0].message)) 1608 else: 1609 self.assertEqual(len(w), 0) 1610 1611 fmt_strs = ['', 's', u'', u's'] 1612 1613 class A: 1614 def __format__(self, fmt_str): 1615 return format('', fmt_str) 1616 1617 for fmt_str in fmt_strs: 1618 test_deprecated_format_string(A(), fmt_str, False) 1619 1620 class B: 1621 pass 1622 1623 class C(object): 1624 pass 1625 1626 for cls in [object, B, C]: 1627 for fmt_str in fmt_strs: 1628 test_deprecated_format_string(cls(), fmt_str, len(fmt_str) != 0) 1629 # -------------------------------------------------------------------- 1470 1630 1471 1631 # make sure we can take a subclass of str as a format spec … … 1526 1686 self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) 1527 1687 1688 def _run_unittest(*args): 1689 with check_py3k_warnings( 1690 (".+ not supported in 3.x", DeprecationWarning), 1691 (".+ is renamed to imp.reload", DeprecationWarning), 1692 ("classic int division", DeprecationWarning)): 1693 run_unittest(*args) 1694 1528 1695 def test_main(verbose=None): 1529 1696 test_classes = (BuiltinTest, TestSorted) 1530 1697 1531 run_unittest(*test_classes)1698 _run_unittest(*test_classes) 1532 1699 1533 1700 # verify reference counting … … 1536 1703 counts = [None] * 5 1537 1704 for i in xrange(len(counts)): 1538 run_unittest(*test_classes)1705 _run_unittest(*test_classes) 1539 1706 gc.collect() 1540 1707 counts[i] = sys.gettotalrefcount()
Note:
See TracChangeset
for help on using the changeset viewer.
