Index: Lib/test/test_long.py =================================================================== --- Lib/test/test_long.py (revision 81507) +++ Lib/test/test_long.py (working copy) @@ -320,6 +320,9 @@ self.assertEqual(long(3.5), 3L) self.assertEqual(long(-3.5), -3L) self.assertEqual(long("-3"), -3L) + self.assertEqual(long("0b10", 2), 2L) + self.assertEqual(long("0o10", 8), 8L) + self.assertEqual(long("0x10", 16), 16L) if test_support.have_unicode: self.assertEqual(long(unicode("-3")), -3L) # Different base: Index: Lib/test/test_enumerate.py =================================================================== --- Lib/test/test_enumerate.py (revision 81507) +++ Lib/test/test_enumerate.py (working copy) @@ -203,6 +203,18 @@ else: self.fail("non-callable __reversed__ didn't raise!") self.assertEqual(rc, sys.getrefcount(r)) + + def test_objmethods(self): + # Objects must have __len__() and __getitem__() implemented. + class NoLen(object): + def __getitem__(self): return 1 + nl = NoLen() + self.assertRaises(TypeError, reversed, nl) + + class NoGetItem(object): + def __len__(self): return 2 + ngi = NoGetItem() + self.assertRaises(TypeError, reversed, ngi) class EnumerateStartTestCase(EnumerateTestCase): Index: Lib/test/test_builtin.py =================================================================== --- Lib/test/test_builtin.py (revision 81507) +++ Lib/test/test_builtin.py (working copy) @@ -90,6 +90,16 @@ self.assertEqual(abs(-1234L), 1234L) # 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) @@ -152,20 +162,45 @@ def test_callable(self): 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(callable(f)) - class C: + + class Classic: def meth(self): pass - self.assertTrue(callable(C)) - x = C() - self.assertTrue(callable(x.meth)) - self.assertTrue(not callable(x)) - class D(C): + self.assertTrue(callable(Classic)) + c = Classic() + self.assertTrue(callable(c.meth)) + self.assertFalse(callable(c)) + + class NewStyle(object): + def meth(self): pass + self.assertTrue(callable(NewStyle)) + n = NewStyle() + self.assertTrue(callable(n.meth)) + self.assertFalse(callable(n)) + + # Classic and new-style classes evaluate __call__() differently + c.__call__ = None + self.assertTrue(callable(c)) + del c.__call__ + self.assertFalse(callable(c)) + n.__call__ = None + self.assertFalse(callable(n)) + del n.__call__ + self.assertFalse(callable(n)) + + class N2(object): def __call__(self): pass - y = D() - self.assertTrue(callable(y)) - y() - + n2 = N2() + self.assertTrue(callable(n2)) + class N3(N2): pass + n3 = N3() + self.assertTrue(callable(n3)) + def test_chr(self): self.assertEqual(chr(32), ' ') self.assertEqual(chr(65), 'A') @@ -729,7 +764,12 @@ def __len__(self): raise ValueError self.assertRaises(ValueError, len, BadSeq()) - + self.assertRaises(TypeError, len, 2) + class ClassicStyle: pass + class NewStyle(object): pass + self.assertRaises(AttributeError, len, ClassicStyle()) + self.assertRaises(TypeError, len, NewStyle()) + def test_map(self): self.assertEqual( map(None, 'hello world'), @@ -1071,6 +1111,16 @@ self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) # Reject floats. + self.assertRaises(TypeError, range, 0.0) + self.assertRaises(TypeError, range, 0, 0.0) + self.assertRaises(TypeError, range, 0.0, 0) + self.assertRaises(TypeError, range, 0.0, 0.0) + self.assertRaises(TypeError, range, 0, 0, 1.0) + self.assertRaises(TypeError, range, 0, 0.0, 1) + self.assertRaises(TypeError, range, 0, 0.0, 1.0) + self.assertRaises(TypeError, range, 0.0, 0, 1) + self.assertRaises(TypeError, range, 0.0, 0, 1.0) + self.assertRaises(TypeError, range, 0.0, 0.0, 1) self.assertRaises(TypeError, range, 1., 1., 1.) self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) @@ -1188,9 +1238,10 @@ unlink(TESTFN) def test_reduce(self): - self.assertEqual(reduce(lambda x, y: x+y, ['a', 'b', 'c'], ''), 'abc') + add = lambda x, y: x+y + self.assertEqual(reduce(add, ['a', 'b', 'c'], ''), 'abc') self.assertEqual( - reduce(lambda x, y: x+y, [['a', 'c'], [], ['d', 'w']], []), + reduce(add, [['a', 'c'], [], ['d', 'w']], []), ['a','c','d','w'] ) self.assertEqual(reduce(lambda x, y: x*y, range(2,8), 1), 5040) @@ -1198,16 +1249,24 @@ reduce(lambda x, y: x*y, range(2,21), 1L), 2432902008176640000L ) - self.assertEqual(reduce(lambda x, y: x+y, Squares(10)), 285) - self.assertEqual(reduce(lambda x, y: x+y, Squares(10), 0), 285) - self.assertEqual(reduce(lambda x, y: x+y, Squares(0), 0), 0) + self.assertEqual(reduce(add, Squares(10)), 285) + self.assertEqual(reduce(add, Squares(10), 0), 285) + self.assertEqual(reduce(add, Squares(0), 0), 0) self.assertRaises(TypeError, reduce) + self.assertRaises(TypeError, reduce, 42) self.assertRaises(TypeError, reduce, 42, 42) self.assertRaises(TypeError, reduce, 42, 42, 42) + self.assertRaises(TypeError, reduce, None, range(5)) + self.assertRaises(TypeError, reduce, add, 42) self.assertEqual(reduce(42, "1"), "1") # func is never called with one item self.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item self.assertRaises(TypeError, reduce, 42, (42, 42)) - + self.assertRaises(TypeError, reduce, add, []) # arg 2 must not be empty sequence with no initial value + self.assertRaises(TypeError, reduce, add, "") + self.assertRaises(TypeError, reduce, add, ()) + self.assertEqual(reduce(add, [], None), None) + self.assertEqual(reduce(add, [], 42), 42) + class BadSeq: def __getitem__(self, index): raise ValueError @@ -1390,6 +1449,11 @@ a = 1 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())) @@ -1399,6 +1463,7 @@ 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)