1 # Python test set -- built-in functions
3 import test
.test_support
, unittest
4 from test
.test_support
import fcmp
, have_unicode
, TESTFN
, unlink
, \
5 run_unittest
, run_with_locale
6 from operator
import neg
8 import sys
, warnings
, cStringIO
, random
, fractions
, UserDict
9 warnings
.filterwarnings("ignore", "hex../oct.. of negative int",
10 FutureWarning
, __name__
)
11 warnings
.filterwarnings("ignore", "integer argument expected",
12 DeprecationWarning, "unittest")
14 # count the number of test runs.
15 # used to skip running test_execfile() multiple times
20 def __init__(self
, max):
24 def __len__(self
): return len(self
.sofar
)
26 def __getitem__(self
, i
):
27 if not 0 <= i
< self
.max: raise IndexError
30 self
.sofar
.append(n
*n
)
36 def __init__(self
, max):
41 return len(self
.sofar
)
43 def __getitem__(self
, i
):
44 if not 0 <= i
< self
.max:
48 self
.sofar
.append(str(n
*n
))
53 def write(self
, line
):
57 class TestFailingBool
:
58 def __nonzero__(self
):
61 class TestFailingIter
:
65 class BuiltinTest(unittest
.TestCase
):
67 def test_import(self
):
71 __import__(name
='sys')
72 __import__(name
='time', level
=0)
73 self
.assertRaises(ImportError, __import__, 'spamspam')
74 self
.assertRaises(TypeError, __import__, 1, 2, 3, 4)
75 self
.assertRaises(ValueError, __import__, '')
76 self
.assertRaises(TypeError, __import__, 'sys', name
='sys')
80 self
.assertEqual(abs(0), 0)
81 self
.assertEqual(abs(1234), 1234)
82 self
.assertEqual(abs(-1234), 1234)
83 self
.assertTrue(abs(-sys
.maxint
-1) > 0)
85 self
.assertEqual(abs(0.0), 0.0)
86 self
.assertEqual(abs(3.14), 3.14)
87 self
.assertEqual(abs(-3.14), 3.14)
89 self
.assertEqual(abs(0L), 0L)
90 self
.assertEqual(abs(1234L), 1234L)
91 self
.assertEqual(abs(-1234L), 1234L)
93 self
.assertRaises(TypeError, abs, 'a')
96 self
.assertEqual(all([2, 4, 6]), True)
97 self
.assertEqual(all([2, None, 6]), False)
98 self
.assertRaises(RuntimeError, all
, [2, TestFailingBool(), 6])
99 self
.assertRaises(RuntimeError, all
, TestFailingIter())
100 self
.assertRaises(TypeError, all
, 10) # Non-iterable
101 self
.assertRaises(TypeError, all
) # No args
102 self
.assertRaises(TypeError, all
, [2, 4, 6], []) # Too many args
103 self
.assertEqual(all([]), True) # Empty iterator
105 self
.assertEqual(all(x
> 42 for x
in S
), True)
107 self
.assertEqual(all(x
> 42 for x
in S
), False)
110 self
.assertEqual(any([None, None, None]), False)
111 self
.assertEqual(any([None, 4, None]), True)
112 self
.assertRaises(RuntimeError, any
, [None, TestFailingBool(), 6])
113 self
.assertRaises(RuntimeError, all
, TestFailingIter())
114 self
.assertRaises(TypeError, any
, 10) # Non-iterable
115 self
.assertRaises(TypeError, any
) # No args
116 self
.assertRaises(TypeError, any
, [2, 4, 6], []) # Too many args
117 self
.assertEqual(any([]), False) # Empty iterator
119 self
.assertEqual(any(x
> 42 for x
in S
), True)
121 self
.assertEqual(any(x
> 42 for x
in S
), False)
125 self
.assert_(isinstance(x
, int))
126 self
.assertEqual(-x
, sys
.maxint
+1)
128 def test_apply(self
):
130 self
.assertEqual(args
, ())
132 self
.assertEqual(a1
, 1)
134 self
.assertEqual(a1
, 1)
135 self
.assertEqual(a2
, 2)
137 self
.assertEqual(a1
, 1)
138 self
.assertEqual(a2
, 2)
139 self
.assertEqual(a3
, 3)
145 # A PyCFunction that takes only positional parameters should allow an
146 # empty keyword dictionary to pass without a complaint, but raise a
147 # TypeError if the dictionary is non-empty.
149 self
.assertRaises(TypeError, apply, id, (1,), {"foo": 1})
150 self
.assertRaises(TypeError, apply)
151 self
.assertRaises(TypeError, apply, id, 42)
152 self
.assertRaises(TypeError, apply, id, (42,), 42)
154 def test_callable(self
):
155 self
.assert_(callable(len))
157 self
.assert_(callable(f
))
160 self
.assert_(callable(C
))
162 self
.assert_(callable(x
.meth
))
163 self
.assert_(not callable(x
))
165 def __call__(self
): pass
167 self
.assert_(callable(y
))
171 self
.assertEqual(chr(32), ' ')
172 self
.assertEqual(chr(65), 'A')
173 self
.assertEqual(chr(97), 'a')
174 self
.assertEqual(chr(0xff), '\xff')
175 self
.assertRaises(ValueError, chr, 256)
176 self
.assertRaises(TypeError, chr)
179 self
.assertEqual(cmp(-1, 1), -1)
180 self
.assertEqual(cmp(1, -1), 1)
181 self
.assertEqual(cmp(1, 1), 0)
182 # verify that circular objects are not handled
185 from UserList
import UserList
186 c
= UserList(); c
.append(c
)
187 self
.assertRaises(RuntimeError, cmp, a
, b
)
188 self
.assertRaises(RuntimeError, cmp, b
, c
)
189 self
.assertRaises(RuntimeError, cmp, c
, a
)
190 self
.assertRaises(RuntimeError, cmp, a
, c
)
191 # okay, now break the cycles
192 a
.pop(); b
.pop(); c
.pop()
193 self
.assertRaises(TypeError, cmp)
195 def test_coerce(self
):
196 self
.assert_(not fcmp(coerce(1, 1.1), (1.0, 1.1)))
197 self
.assertEqual(coerce(1, 1L), (1L, 1L))
198 self
.assert_(not fcmp(coerce(1L, 1.1), (1.0, 1.1)))
199 self
.assertRaises(TypeError, coerce)
201 def __coerce__(self
, other
):
203 self
.assertRaises(ValueError, coerce, 42, BadNumber())
204 self
.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000))
206 def test_compile(self
):
207 compile('print 1\n', '', 'exec')
209 compile(bom
+ 'print 1\n', '', 'exec')
210 compile(source
='pass', filename
='?', mode
='exec')
211 compile(dont_inherit
=0, filename
='tmp', source
='0', mode
='eval')
212 compile('pass', '?', dont_inherit
=1, mode
='exec')
213 self
.assertRaises(TypeError, compile)
214 self
.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode')
215 self
.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff)
216 self
.assertRaises(TypeError, compile, chr(0), 'f', 'exec')
217 self
.assertRaises(TypeError, compile, 'pass', '?', 'exec',
218 mode
='eval', source
='0', filename
='tmp')
220 compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')
221 self
.assertRaises(TypeError, compile, unichr(0), 'f', 'exec')
222 self
.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad')
225 def test_delattr(self
):
229 self
.assertRaises(TypeError, delattr)
232 # dir(wrong number of arguments)
233 self
.assertRaises(TypeError, dir, 42, 42)
235 # dir() - local scope
237 self
.assert_('local_var' in dir())
241 self
.assert_('exit' in dir(sys
))
243 # dir(module_with_invalid__dict__)
245 class Foo(types
.ModuleType
):
248 self
.assertRaises(TypeError, dir, f
)
251 self
.assert_("strip" in dir(str))
252 self
.assert_("__mro__" not in dir(str))
261 self
.assert_("y" in dir(f
))
263 # dir(obj_no__dict__)
267 self
.assert_("__repr__" in dir(f
))
269 # dir(obj_no__class__with__dict__)
270 # (an ugly trick to cause getattr(f, "__class__") to fail)
272 __slots__
= ["__class__", "__dict__"]
276 self
.assert_("__repr__" not in dir(f
))
277 self
.assert_("bar" in dir(f
))
279 # dir(obj_using __dir__)
282 return ["kan", "ga", "roo"]
284 self
.assert_(dir(f
) == ["ga", "kan", "roo"])
286 # dir(obj__dir__not_list)
291 self
.assertRaises(TypeError, dir, f
)
293 def test_divmod(self
):
294 self
.assertEqual(divmod(12, 7), (1, 5))
295 self
.assertEqual(divmod(-12, 7), (-2, 2))
296 self
.assertEqual(divmod(12, -7), (-2, -2))
297 self
.assertEqual(divmod(-12, -7), (1, -5))
299 self
.assertEqual(divmod(12L, 7L), (1L, 5L))
300 self
.assertEqual(divmod(-12L, 7L), (-2L, 2L))
301 self
.assertEqual(divmod(12L, -7L), (-2L, -2L))
302 self
.assertEqual(divmod(-12L, -7L), (1L, -5L))
304 self
.assertEqual(divmod(12, 7L), (1, 5L))
305 self
.assertEqual(divmod(-12, 7L), (-2, 2L))
306 self
.assertEqual(divmod(12L, -7), (-2L, -2))
307 self
.assertEqual(divmod(-12L, -7), (1L, -5))
309 self
.assertEqual(divmod(-sys
.maxint
-1, -1),
312 self
.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
313 self
.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
314 self
.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))
315 self
.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))
317 self
.assertRaises(TypeError, divmod)
320 self
.assertEqual(eval('1+1'), 2)
321 self
.assertEqual(eval(' 1+1\n'), 2)
322 globals = {'a': 1, 'b': 2}
323 locals = {'b': 200, 'c': 300}
324 self
.assertEqual(eval('a', globals) , 1)
325 self
.assertEqual(eval('a', globals, locals), 1)
326 self
.assertEqual(eval('b', globals, locals), 200)
327 self
.assertEqual(eval('c', globals, locals), 300)
329 self
.assertEqual(eval(unicode('1+1')), 2)
330 self
.assertEqual(eval(unicode(' 1+1\n')), 2)
331 globals = {'a': 1, 'b': 2}
332 locals = {'b': 200, 'c': 300}
334 self
.assertEqual(eval(unicode('a'), globals), 1)
335 self
.assertEqual(eval(unicode('a'), globals, locals), 1)
336 self
.assertEqual(eval(unicode('b'), globals, locals), 200)
337 self
.assertEqual(eval(unicode('c'), globals, locals), 300)
339 self
.assertEqual(eval(bom
+ 'a', globals, locals), 1)
340 self
.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals),
341 unicode('\xc3\xa5', 'utf8'))
342 self
.assertRaises(TypeError, eval)
343 self
.assertRaises(TypeError, eval, ())
345 def test_general_eval(self
):
346 # Tests that general mappings can be used for the locals argument
349 "Test mapping interface versus possible calls from eval()."
350 def __getitem__(self
, key
):
359 self
.assertEqual(eval('a', g
, m
), 12)
360 self
.assertRaises(NameError, eval, 'b', g
, m
)
361 self
.assertEqual(eval('dir()', g
, m
), list('xyz'))
362 self
.assertEqual(eval('globals()', g
, m
), g
)
363 self
.assertEqual(eval('locals()', g
, m
), m
)
364 self
.assertRaises(TypeError, eval, 'a', m
)
369 self
.assertRaises(TypeError, eval, 'a', g
, m
)
371 # Verify that dict subclasses work as well
373 def __getitem__(self
, key
):
376 return dict.__getitem
__(self
, key
)
381 self
.assertEqual(eval('a', g
, d
), 12)
382 self
.assertRaises(NameError, eval, 'b', g
, d
)
383 self
.assertEqual(eval('dir()', g
, d
), list('xyz'))
384 self
.assertEqual(eval('globals()', g
, d
), g
)
385 self
.assertEqual(eval('locals()', g
, d
), d
)
387 # Verify locals stores (used by list comps)
388 eval('[locals() for i in (2,3)]', g
, d
)
389 eval('[locals() for i in (2,3)]', g
, UserDict
.UserDict())
392 "Sample application showing nested, calculated lookups."
394 def __setitem__(self
, key
, formula
):
395 self
._cells
[key
] = formula
396 def __getitem__(self
, key
):
397 return eval(self
._cells
[key
], globals(), self
)
403 self
.assertEqual(ss
['a3'], 210)
405 # Verify that dir() catches a non-list returned by eval
408 def __getitem__(self
, item
):
412 self
.assertRaises(TypeError, eval, 'dir()', globals(), C())
414 # Done outside of the method test_z to get the correct scope
416 f
= open(TESTFN
, 'w')
422 def test_execfile(self
):
428 globals = {'a': 1, 'b': 2}
429 locals = {'b': 200, 'c': 300}
431 self
.assertEqual(self
.__class
__.z
, 2)
433 execfile(TESTFN
, globals)
434 self
.assertEqual(globals['z'], 2)
436 execfile(TESTFN
, globals, locals)
437 self
.assertEqual(locals['z'], 2)
440 "Test mapping interface versus possible calls from execfile()."
443 def __getitem__(self
, key
):
447 def __setitem__(self
, key
, value
):
455 execfile(TESTFN
, globals, locals)
456 self
.assertEqual(locals['z'], 2)
459 self
.assertRaises(TypeError, execfile)
460 self
.assertRaises(TypeError, execfile, TESTFN
, {}, ())
462 self
.assertRaises(IOError, execfile, os
.curdir
)
463 self
.assertRaises(IOError, execfile, "I_dont_exist")
465 def test_filter(self
):
466 self
.assertEqual(filter(lambda c
: 'a' <= c
<= 'z', 'Hello World'), 'elloorld')
467 self
.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9])
468 self
.assertEqual(filter(lambda x
: x
> 0, [1, -3, 9, 0, 2]), [1, 9, 2])
469 self
.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81])
470 self
.assertEqual(filter(lambda x
: x
%2, Squares(10)), [1, 9, 25, 49, 81])
473 filter(identity
, Squares(5))
474 self
.assertRaises(TypeError, filter)
475 class BadSeq(object):
476 def __getitem__(self
, index
):
480 self
.assertRaises(ValueError, filter, lambda x
: x
, BadSeq())
483 self
.assertRaises(TypeError, filter, badfunc
, range(5))
485 # test bltinmodule.c::filtertuple()
486 self
.assertEqual(filter(None, (1, 2)), (1, 2))
487 self
.assertEqual(filter(lambda x
: x
>=3, (1, 2, 3, 4)), (3, 4))
488 self
.assertRaises(TypeError, filter, 42, (1, 2))
490 # test bltinmodule.c::filterstring()
491 self
.assertEqual(filter(None, "12"), "12")
492 self
.assertEqual(filter(lambda x
: x
>="3", "1234"), "34")
493 self
.assertRaises(TypeError, filter, 42, "12")
495 def __getitem__(self
, index
):
497 self
.assertRaises(ValueError, filter, lambda x
: x
>="3", badstr("1234"))
500 def __getitem__(self
, index
):
502 self
.assertRaises(TypeError, filter, lambda x
: x
>=42, badstr2("1234"))
505 def __getitem__(self
, index
):
506 return weirdstr(2*str.__getitem
__(self
, index
))
507 self
.assertEqual(filter(lambda x
: x
>="33", weirdstr("1234")), "3344")
510 def __getitem__(self
, index
):
511 return chr(ord(str.__getitem
__(self
, index
))+1)
512 self
.assertEqual(filter(lambda x
: x
>="3", shiftstr("1234")), "345")
515 # test bltinmodule.c::filterunicode()
516 self
.assertEqual(filter(None, unicode("12")), unicode("12"))
517 self
.assertEqual(filter(lambda x
: x
>="3", unicode("1234")), unicode("34"))
518 self
.assertRaises(TypeError, filter, 42, unicode("12"))
519 self
.assertRaises(ValueError, filter, lambda x
: x
>="3", badstr(unicode("1234")))
521 class badunicode(unicode):
522 def __getitem__(self
, index
):
524 self
.assertRaises(TypeError, filter, lambda x
: x
>=42, badunicode("1234"))
526 class weirdunicode(unicode):
527 def __getitem__(self
, index
):
528 return weirdunicode(2*unicode.__getitem
__(self
, index
))
530 filter(lambda x
: x
>=unicode("33"), weirdunicode("1234")), unicode("3344"))
532 class shiftunicode(unicode):
533 def __getitem__(self
, index
):
534 return unichr(ord(unicode.__getitem
__(self
, index
))+1)
536 filter(lambda x
: x
>=unicode("3"), shiftunicode("1234")),
540 def test_filter_subclasses(self
):
541 # test that filter() never returns tuple, str or unicode subclasses
542 # and that the result always goes through __getitem__
543 funcs
= (None, bool, lambda x
: True)
545 def __getitem__(self
, index
):
546 return 2*tuple.__getitem
__(self
, index
)
548 def __getitem__(self
, index
):
549 return 2*str.__getitem
__(self
, index
)
551 tuple2
: {(): (), (1, 2, 3): (2, 4, 6)},
552 str2
: {"": "", "123": "112233"}
555 class unicode2(unicode):
556 def __getitem__(self
, index
):
557 return 2*unicode.__getitem
__(self
, index
)
559 unicode(): unicode(),
560 unicode("123"): unicode("112233")
563 for (cls
, inps
) in inputs
.iteritems():
564 for (inp
, exp
) in inps
.iteritems():
565 # make sure the output goes through __getitem__
566 # even if func is None
568 filter(funcs
[0], cls(inp
)),
569 filter(funcs
[1], cls(inp
))
572 outp
= filter(func
, cls(inp
))
573 self
.assertEqual(outp
, exp
)
574 self
.assert_(not isinstance(outp
, cls
))
576 def test_getattr(self
):
578 self
.assert_(getattr(sys
, 'stdout') is sys
.stdout
)
579 self
.assertRaises(TypeError, getattr, sys
, 1)
580 self
.assertRaises(TypeError, getattr, sys
, 1, "foo")
581 self
.assertRaises(TypeError, getattr)
583 self
.assertRaises(UnicodeError, getattr, sys
, unichr(sys
.maxunicode
))
585 def test_hasattr(self
):
587 self
.assert_(hasattr(sys
, 'stdout'))
588 self
.assertRaises(TypeError, hasattr, sys
, 1)
589 self
.assertRaises(TypeError, hasattr)
591 self
.assertRaises(UnicodeError, hasattr, sys
, unichr(sys
.maxunicode
))
595 self
.assertEqual(hash(1), hash(1L))
596 self
.assertEqual(hash(1), hash(1.0))
599 self
.assertEqual(hash('spam'), hash(unicode('spam')))
602 self
.assertRaises(TypeError, hash, [])
603 self
.assertRaises(TypeError, hash, {})
604 # Bug 1536021: Allow hash to return long objects
608 self
.assertEquals(type(hash(X())), int)
612 self
.assertEquals(type(hash(Y())), int)
616 self
.assertEquals(hash(Z(42)), hash(42L))
619 self
.assertEqual(hex(16), '0x10')
620 self
.assertEqual(hex(16L), '0x10L')
621 self
.assertEqual(hex(-16), '-0x10')
622 self
.assertEqual(hex(-16L), '-0x10L')
623 self
.assertRaises(TypeError, hex, {})
633 id({'spam': 1, 'eggs': 2, 'ham': 3})
635 # Test input() later, together with raw_input
637 def test_intern(self
):
638 self
.assertRaises(TypeError, intern)
639 s
= "never interned before"
640 self
.assert_(intern(s
) is s
)
641 s2
= s
.swapcase().swapcase()
642 self
.assert_(intern(s2
) is s
)
644 # Subclasses of string can't be interned, because they
645 # provide too much opportunity for insane things to happen.
646 # We don't want them in the interned dict and if they aren't
647 # actually interned, we don't want to create the appearance
648 # that they are by allowing intern() to succeeed.
653 self
.assertRaises(TypeError, intern, S("abc"))
655 # It's still safe to pass these strings to routines that
656 # call intern internally, e.g. PyObject_SetAttr().
659 self
.assertEqual(getattr(s
, s
), s
)
662 self
.assertRaises(TypeError, iter)
663 self
.assertRaises(TypeError, iter, 42, 42)
664 lists
= [("1", "2"), ["1", "2"], "12"]
666 lists
.append(unicode("12"))
669 self
.assertEqual(i
.next(), '1')
670 self
.assertEqual(i
.next(), '2')
671 self
.assertRaises(StopIteration, i
.next
)
673 def test_isinstance(self
):
683 self
.assert_(isinstance(c
, C
))
684 self
.assert_(isinstance(d
, C
))
685 self
.assert_(not isinstance(e
, C
))
686 self
.assert_(not isinstance(c
, D
))
687 self
.assert_(not isinstance('foo', E
))
688 self
.assertRaises(TypeError, isinstance, E
, 'foo')
689 self
.assertRaises(TypeError, isinstance)
691 def test_issubclass(self
):
701 self
.assert_(issubclass(D
, C
))
702 self
.assert_(issubclass(C
, C
))
703 self
.assert_(not issubclass(C
, D
))
704 self
.assertRaises(TypeError, issubclass, 'foo', E
)
705 self
.assertRaises(TypeError, issubclass, E
, 'foo')
706 self
.assertRaises(TypeError, issubclass)
709 self
.assertEqual(len('123'), 3)
710 self
.assertEqual(len(()), 0)
711 self
.assertEqual(len((1, 2, 3, 4)), 4)
712 self
.assertEqual(len([1, 2, 3, 4]), 4)
713 self
.assertEqual(len({}), 0)
714 self
.assertEqual(len({'a':1, 'b': 2}), 2)
718 self
.assertRaises(ValueError, len, BadSeq())
722 map(None, 'hello world'),
723 ['h','e','l','l','o',' ','w','o','r','l','d']
726 map(None, 'abcd', 'efg'),
727 [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)]
730 map(None, range(10)),
731 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
734 map(lambda x
: x
*x
, range(1,4)),
738 from math
import sqrt
743 map(lambda x
: map(sqrt
,x
), [[16, 4], [81, 9]]),
744 [[4.0, 2.0], [9.0, 3.0]]
747 map(lambda x
, y
: x
+y
, [1,3,2], [9,1,4]),
753 for i
in v
: accu
= accu
+ i
756 map(plus
, [1, 3, 7]),
760 map(plus
, [1, 3, 7], [4, 9, 2]),
764 map(plus
, [1, 3, 7], [4, 9, 2], [1, 1, 0]),
765 [1+4+1, 3+9+1, 7+2+0]
768 map(None, Squares(10)),
769 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
772 map(int, Squares(10)),
773 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
776 map(None, Squares(3), Squares(2)),
777 [(0,0), (1,1), (4,None)]
780 map(max, Squares(3), Squares(2)),
783 self
.assertRaises(TypeError, map)
784 self
.assertRaises(TypeError, map, lambda x
: x
, 42)
785 self
.assertEqual(map(None, [42]), [42])
787 def __getitem__(self
, index
):
789 self
.assertRaises(ValueError, map, lambda x
: x
, BadSeq())
792 self
.assertRaises(RuntimeError, map, badfunc
, range(5))
795 self
.assertEqual(max('123123'), '3')
796 self
.assertEqual(max(1, 2, 3), 3)
797 self
.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
798 self
.assertEqual(max([1, 2, 3, 1, 2, 3]), 3)
800 self
.assertEqual(max(1, 2L, 3.0), 3.0)
801 self
.assertEqual(max(1L, 2.0, 3), 3)
802 self
.assertEqual(max(1.0, 2, 3L), 3L)
805 "max(key=int)", # no args
806 "max(1, key=int)", # single arg not iterable
807 "max(1, 2, keystone=int)", # wrong keyword
808 "max(1, 2, key=int, abc=int)", # two many keywords
809 "max(1, 2, key=1)", # keyfunc is not callable
812 exec(stmt
) in globals()
818 self
.assertEqual(max((1,), key
=neg
), 1) # one elem iterable
819 self
.assertEqual(max((1,2), key
=neg
), 1) # two elem iterable
820 self
.assertEqual(max(1, 2, key
=neg
), 1) # two elems
822 data
= [random
.randrange(200) for i
in range(100)]
823 keys
= dict((elem
, random
.randrange(50)) for elem
in data
)
825 self
.assertEqual(max(data
, key
=f
),
826 sorted(reversed(data
), key
=f
)[-1])
829 self
.assertEqual(min('123123'), '1')
830 self
.assertEqual(min(1, 2, 3), 1)
831 self
.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
832 self
.assertEqual(min([1, 2, 3, 1, 2, 3]), 1)
834 self
.assertEqual(min(1, 2L, 3.0), 1)
835 self
.assertEqual(min(1L, 2.0, 3), 1L)
836 self
.assertEqual(min(1.0, 2, 3L), 1.0)
838 self
.assertRaises(TypeError, min)
839 self
.assertRaises(TypeError, min, 42)
840 self
.assertRaises(ValueError, min, ())
842 def __getitem__(self
, index
):
844 self
.assertRaises(ValueError, min, BadSeq())
846 def __cmp__(self
, other
):
848 self
.assertRaises(ValueError, min, (42, BadNumber()))
851 "min(key=int)", # no args
852 "min(1, key=int)", # single arg not iterable
853 "min(1, 2, keystone=int)", # wrong keyword
854 "min(1, 2, key=int, abc=int)", # two many keywords
855 "min(1, 2, key=1)", # keyfunc is not callable
858 exec(stmt
) in globals()
864 self
.assertEqual(min((1,), key
=neg
), 1) # one elem iterable
865 self
.assertEqual(min((1,2), key
=neg
), 2) # two elem iterable
866 self
.assertEqual(min(1, 2, key
=neg
), 2) # two elems
868 data
= [random
.randrange(200) for i
in range(100)]
869 keys
= dict((elem
, random
.randrange(50)) for elem
in data
)
871 self
.assertEqual(min(data
, key
=f
),
872 sorted(data
, key
=f
)[0])
876 self
.assertEqual(next(it
), 0)
877 self
.assertEqual(next(it
), 1)
878 self
.assertRaises(StopIteration, next
, it
)
879 self
.assertRaises(StopIteration, next
, it
)
880 self
.assertEquals(next(it
, 42), 42)
889 self
.assertEquals(next(it
, 42), 42)
890 self
.assertRaises(StopIteration, next
, it
)
897 self
.assertEquals(next(it
), 1)
898 self
.assertRaises(StopIteration, next
, it
)
899 self
.assertEquals(next(it
, 42), 42)
902 self
.assertEqual(oct(100), '0144')
903 self
.assertEqual(oct(100L), '0144L')
904 self
.assertEqual(oct(-100), '-0144')
905 self
.assertEqual(oct(-100L), '-0144L')
906 self
.assertRaises(TypeError, oct, ())
908 def write_testfile(self
):
909 # NB the first 4 lines are also used to test input and raw_input, below
910 fp
= open(TESTFN
, 'w')
914 fp
.write('The quick brown fox jumps over the lazy dog')
916 fp
.write('Dear John\n')
923 self
.write_testfile()
924 fp
= open(TESTFN
, 'r')
926 self
.assertEqual(fp
.readline(4), '1+1\n')
927 self
.assertEqual(fp
.readline(4), '1+1\n')
928 self
.assertEqual(fp
.readline(), 'The quick brown fox jumps over the lazy dog.\n')
929 self
.assertEqual(fp
.readline(4), 'Dear')
930 self
.assertEqual(fp
.readline(100), ' John\n')
931 self
.assertEqual(fp
.read(300), 'XXX'*100)
932 self
.assertEqual(fp
.read(1000), 'YYY'*100)
938 self
.assertEqual(ord(' '), 32)
939 self
.assertEqual(ord('A'), 65)
940 self
.assertEqual(ord('a'), 97)
942 self
.assertEqual(ord(unichr(sys
.maxunicode
)), sys
.maxunicode
)
943 self
.assertRaises(TypeError, ord, 42)
945 self
.assertRaises(TypeError, ord, unicode("12"))
948 self
.assertEqual(pow(0,0), 1)
949 self
.assertEqual(pow(0,1), 0)
950 self
.assertEqual(pow(1,0), 1)
951 self
.assertEqual(pow(1,1), 1)
953 self
.assertEqual(pow(2,0), 1)
954 self
.assertEqual(pow(2,10), 1024)
955 self
.assertEqual(pow(2,20), 1024*1024)
956 self
.assertEqual(pow(2,30), 1024*1024*1024)
958 self
.assertEqual(pow(-2,0), 1)
959 self
.assertEqual(pow(-2,1), -2)
960 self
.assertEqual(pow(-2,2), 4)
961 self
.assertEqual(pow(-2,3), -8)
963 self
.assertEqual(pow(0L,0), 1)
964 self
.assertEqual(pow(0L,1), 0)
965 self
.assertEqual(pow(1L,0), 1)
966 self
.assertEqual(pow(1L,1), 1)
968 self
.assertEqual(pow(2L,0), 1)
969 self
.assertEqual(pow(2L,10), 1024)
970 self
.assertEqual(pow(2L,20), 1024*1024)
971 self
.assertEqual(pow(2L,30), 1024*1024*1024)
973 self
.assertEqual(pow(-2L,0), 1)
974 self
.assertEqual(pow(-2L,1), -2)
975 self
.assertEqual(pow(-2L,2), 4)
976 self
.assertEqual(pow(-2L,3), -8)
978 self
.assertAlmostEqual(pow(0.,0), 1.)
979 self
.assertAlmostEqual(pow(0.,1), 0.)
980 self
.assertAlmostEqual(pow(1.,0), 1.)
981 self
.assertAlmostEqual(pow(1.,1), 1.)
983 self
.assertAlmostEqual(pow(2.,0), 1.)
984 self
.assertAlmostEqual(pow(2.,10), 1024.)
985 self
.assertAlmostEqual(pow(2.,20), 1024.*1024.)
986 self
.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.)
988 self
.assertAlmostEqual(pow(-2.,0), 1.)
989 self
.assertAlmostEqual(pow(-2.,1), -2.)
990 self
.assertAlmostEqual(pow(-2.,2), 4.)
991 self
.assertAlmostEqual(pow(-2.,3), -8.)
994 for y
in 10, 10L, 10.0:
995 for z
in 1000, 1000L, 1000.0:
996 if isinstance(x
, float) or \
997 isinstance(y
, float) or \
998 isinstance(z
, float):
999 self
.assertRaises(TypeError, pow, x
, y
, z
)
1001 self
.assertAlmostEqual(pow(x
, y
, z
), 24.0)
1003 self
.assertRaises(TypeError, pow, -1, -2, 3)
1004 self
.assertRaises(ValueError, pow, 1, 2, 0)
1005 self
.assertRaises(TypeError, pow, -1L, -2L, 3L)
1006 self
.assertRaises(ValueError, pow, 1L, 2L, 0L)
1007 # Will return complex in 3.0:
1008 self
.assertRaises(ValueError, pow, -342.43, 0.234)
1010 self
.assertRaises(TypeError, pow)
1012 def test_range(self
):
1013 self
.assertEqual(range(3), [0, 1, 2])
1014 self
.assertEqual(range(1, 5), [1, 2, 3, 4])
1015 self
.assertEqual(range(0), [])
1016 self
.assertEqual(range(-3), [])
1017 self
.assertEqual(range(1, 10, 3), [1, 4, 7])
1018 self
.assertEqual(range(5, -5, -3), [5, 2, -1, -4])
1020 # Now test range() with longs
1021 self
.assertEqual(range(-2**100), [])
1022 self
.assertEqual(range(0, -2**100), [])
1023 self
.assertEqual(range(0, 2**100, -1), [])
1024 self
.assertEqual(range(0, 2**100, -1), [])
1026 a
= long(10 * sys
.maxint
)
1027 b
= long(100 * sys
.maxint
)
1028 c
= long(50 * sys
.maxint
)
1030 self
.assertEqual(range(a
, a
+2), [a
, a
+1])
1031 self
.assertEqual(range(a
+2, a
, -1L), [a
+2, a
+1])
1032 self
.assertEqual(range(a
+4, a
, -2), [a
+4, a
+2])
1034 seq
= range(a
, b
, c
)
1035 self
.assert_(a
in seq
)
1036 self
.assert_(b
not in seq
)
1037 self
.assertEqual(len(seq
), 2)
1039 seq
= range(b
, a
, -c
)
1040 self
.assert_(b
in seq
)
1041 self
.assert_(a
not in seq
)
1042 self
.assertEqual(len(seq
), 2)
1044 seq
= range(-a
, -b
, -c
)
1045 self
.assert_(-a
in seq
)
1046 self
.assert_(-b
not in seq
)
1047 self
.assertEqual(len(seq
), 2)
1049 self
.assertRaises(TypeError, range)
1050 self
.assertRaises(TypeError, range, 1, 2, 3, 4)
1051 self
.assertRaises(ValueError, range, 1, 2, 0)
1052 self
.assertRaises(ValueError, range, a
, a
+ 1, long(0))
1055 def __cmp__(self
, other
):
1057 self
.assertRaises(RuntimeError, range, a
, a
+ 1, badzero(1))
1059 # Reject floats when it would require PyLongs to represent.
1060 # (smaller floats still accepted, but deprecated)
1061 self
.assertRaises(TypeError, range, 1e100
, 1e101
, 1e101
)
1063 self
.assertRaises(TypeError, range, 0, "spam")
1064 self
.assertRaises(TypeError, range, 0, 42, "spam")
1066 self
.assertRaises(OverflowError, range, -sys
.maxint
, sys
.maxint
)
1067 self
.assertRaises(OverflowError, range, 0, 2*sys
.maxint
)
1069 def test_input_and_raw_input(self
):
1070 self
.write_testfile()
1071 fp
= open(TESTFN
, 'r')
1072 savestdin
= sys
.stdin
1073 savestdout
= sys
.stdout
# Eats the echo
1076 sys
.stdout
= BitBucket()
1077 self
.assertEqual(input(), 2)
1078 self
.assertEqual(input('testing\n'), 2)
1079 self
.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.')
1080 self
.assertEqual(raw_input('testing\n'), 'Dear John')
1082 # SF 1535165: don't segfault on closed stdin
1083 # sys.stdout must be a regular file for triggering
1084 sys
.stdout
= savestdout
1086 self
.assertRaises(ValueError, input)
1088 sys
.stdout
= BitBucket()
1089 sys
.stdin
= cStringIO
.StringIO("NULL\0")
1090 self
.assertRaises(TypeError, input, 42, 42)
1091 sys
.stdin
= cStringIO
.StringIO(" 'whitespace'")
1092 self
.assertEqual(input(), 'whitespace')
1093 sys
.stdin
= cStringIO
.StringIO()
1094 self
.assertRaises(EOFError, input)
1096 # SF 876178: make sure input() respect future options.
1097 sys
.stdin
= cStringIO
.StringIO('1/2')
1098 sys
.stdout
= cStringIO
.StringIO()
1099 exec compile('print input()', 'test_builtin_tmp', 'exec')
1100 sys
.stdin
.seek(0, 0)
1101 exec compile('from __future__ import division;print input()',
1102 'test_builtin_tmp', 'exec')
1103 sys
.stdin
.seek(0, 0)
1104 exec compile('print input()', 'test_builtin_tmp', 'exec')
1105 # The result we expect depends on whether new division semantics
1106 # are already in effect.
1108 # This test was compiled with old semantics.
1109 expected
= ['0', '0.5', '0']
1111 # This test was compiled with new semantics (e.g., -Qnew
1112 # was given on the command line.
1113 expected
= ['0.5', '0.5', '0.5']
1114 self
.assertEqual(sys
.stdout
.getvalue().splitlines(), expected
)
1117 self
.assertRaises(RuntimeError, input, 'prompt')
1119 self
.assertRaises(RuntimeError, input, 'prompt')
1121 sys
.stdin
= savestdin
1122 sys
.stdout
= savestdout
1126 def test_reduce(self
):
1127 self
.assertEqual(reduce(lambda x
, y
: x
+y
, ['a', 'b', 'c'], ''), 'abc')
1129 reduce(lambda x
, y
: x
+y
, [['a', 'c'], [], ['d', 'w']], []),
1132 self
.assertEqual(reduce(lambda x
, y
: x
*y
, range(2,8), 1), 5040)
1134 reduce(lambda x
, y
: x
*y
, range(2,21), 1L),
1135 2432902008176640000L
1137 self
.assertEqual(reduce(lambda x
, y
: x
+y
, Squares(10)), 285)
1138 self
.assertEqual(reduce(lambda x
, y
: x
+y
, Squares(10), 0), 285)
1139 self
.assertEqual(reduce(lambda x
, y
: x
+y
, Squares(0), 0), 0)
1140 self
.assertRaises(TypeError, reduce)
1141 self
.assertRaises(TypeError, reduce, 42, 42)
1142 self
.assertRaises(TypeError, reduce, 42, 42, 42)
1143 self
.assertEqual(reduce(42, "1"), "1") # func is never called with one item
1144 self
.assertEqual(reduce(42, "", "1"), "1") # func is never called with one item
1145 self
.assertRaises(TypeError, reduce, 42, (42, 42))
1148 def __getitem__(self
, index
):
1150 self
.assertRaises(ValueError, reduce, 42, BadSeq())
1152 def test_reload(self
):
1158 ## self.assertRaises(ImportError, reload, sys)
1160 def test_repr(self
):
1161 self
.assertEqual(repr(''), '\'\'')
1162 self
.assertEqual(repr(0), '0')
1163 self
.assertEqual(repr(0L), '0L')
1164 self
.assertEqual(repr(()), '()')
1165 self
.assertEqual(repr([]), '[]')
1166 self
.assertEqual(repr({}), '{}')
1169 self
.assertEqual(repr(a
), '[[...]]')
1172 self
.assertEqual(repr(a
), '{0: {...}}')
1174 def test_round(self
):
1175 self
.assertEqual(round(0.0), 0.0)
1176 self
.assertEqual(type(round(0.0)), float) # Will be int in 3.0.
1177 self
.assertEqual(round(1.0), 1.0)
1178 self
.assertEqual(round(10.0), 10.0)
1179 self
.assertEqual(round(1000000000.0), 1000000000.0)
1180 self
.assertEqual(round(1e20
), 1e20
)
1182 self
.assertEqual(round(-1.0), -1.0)
1183 self
.assertEqual(round(-10.0), -10.0)
1184 self
.assertEqual(round(-1000000000.0), -1000000000.0)
1185 self
.assertEqual(round(-1e20
), -1e20
)
1187 self
.assertEqual(round(0.1), 0.0)
1188 self
.assertEqual(round(1.1), 1.0)
1189 self
.assertEqual(round(10.1), 10.0)
1190 self
.assertEqual(round(1000000000.1), 1000000000.0)
1192 self
.assertEqual(round(-1.1), -1.0)
1193 self
.assertEqual(round(-10.1), -10.0)
1194 self
.assertEqual(round(-1000000000.1), -1000000000.0)
1196 self
.assertEqual(round(0.9), 1.0)
1197 self
.assertEqual(round(9.9), 10.0)
1198 self
.assertEqual(round(999999999.9), 1000000000.0)
1200 self
.assertEqual(round(-0.9), -1.0)
1201 self
.assertEqual(round(-9.9), -10.0)
1202 self
.assertEqual(round(-999999999.9), -1000000000.0)
1204 self
.assertEqual(round(-8.0, -1), -10.0)
1205 self
.assertEqual(type(round(-8.0, -1)), float)
1207 self
.assertEqual(type(round(-8.0, 0)), float)
1208 self
.assertEqual(type(round(-8.0, 1)), float)
1210 # Check half rounding behaviour.
1211 self
.assertEqual(round(5.5), 6)
1212 self
.assertEqual(round(6.5), 7)
1213 self
.assertEqual(round(-5.5), -6)
1214 self
.assertEqual(round(-6.5), -7)
1216 # Check behavior on ints
1217 self
.assertEqual(round(0), 0)
1218 self
.assertEqual(round(8), 8)
1219 self
.assertEqual(round(-8), -8)
1220 self
.assertEqual(type(round(0)), float) # Will be int in 3.0.
1221 self
.assertEqual(type(round(-8, -1)), float)
1222 self
.assertEqual(type(round(-8, 0)), float)
1223 self
.assertEqual(type(round(-8, 1)), float)
1226 self
.assertEqual(round(number
=-8.0, ndigits
=-1), -10.0)
1228 self
.assertRaises(TypeError, round)
1230 # test generic rounding delegation for reals
1231 class TestRound(object):
1232 def __float__(self
):
1235 class TestNoRound(object):
1238 self
.assertEqual(round(TestRound()), 23)
1240 self
.assertRaises(TypeError, round, 1, 2, 3)
1241 self
.assertRaises(TypeError, round, TestNoRound())
1244 t
.__float
__ = lambda *args
: args
1245 self
.assertRaises(TypeError, round, t
)
1246 self
.assertRaises(TypeError, round, t
, 0)
1248 def test_setattr(self
):
1249 setattr(sys
, 'spam', 1)
1250 self
.assertEqual(sys
.spam
, 1)
1251 self
.assertRaises(TypeError, setattr, sys
, 1, 'spam')
1252 self
.assertRaises(TypeError, setattr)
1255 self
.assertEqual(sum([]), 0)
1256 self
.assertEqual(sum(range(2,8)), 27)
1257 self
.assertEqual(sum(iter(range(2,8))), 27)
1258 self
.assertEqual(sum(Squares(10)), 285)
1259 self
.assertEqual(sum(iter(Squares(10))), 285)
1260 self
.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3])
1262 self
.assertRaises(TypeError, sum)
1263 self
.assertRaises(TypeError, sum, 42)
1264 self
.assertRaises(TypeError, sum, ['a', 'b', 'c'])
1265 self
.assertRaises(TypeError, sum, ['a', 'b', 'c'], '')
1266 self
.assertRaises(TypeError, sum, [[1], [2], [3]])
1267 self
.assertRaises(TypeError, sum, [{2:3}])
1268 self
.assertRaises(TypeError, sum, [{2:3}]*2, {2:3})
1271 def __getitem__(self
, index
):
1273 self
.assertRaises(ValueError, sum, BadSeq())
1275 def test_type(self
):
1276 self
.assertEqual(type(''), type('123'))
1277 self
.assertNotEqual(type(''), type(()))
1279 def test_unichr(self
):
1281 self
.assertEqual(unichr(32), unicode(' '))
1282 self
.assertEqual(unichr(65), unicode('A'))
1283 self
.assertEqual(unichr(97), unicode('a'))
1285 unichr(sys
.maxunicode
),
1286 unicode('\\U%08x' % (sys
.maxunicode
), 'unicode-escape')
1288 self
.assertRaises(ValueError, unichr, sys
.maxunicode
+1)
1289 self
.assertRaises(TypeError, unichr)
1291 # We don't want self in vars(), so these are static methods
1299 BuiltinTest
.get_vars_f0()
1304 def test_vars(self
):
1305 self
.assertEqual(set(vars()), set(dir()))
1307 self
.assertEqual(set(vars(sys
)), set(dir(sys
)))
1308 self
.assertEqual(self
.get_vars_f0(), {})
1309 self
.assertEqual(self
.get_vars_f2(), {'a': 1, 'b': 2})
1310 self
.assertRaises(TypeError, vars, 42, 42)
1311 self
.assertRaises(TypeError, vars, 42)
1316 t
= [(1, 4), (2, 5), (3, 6)]
1317 self
.assertEqual(zip(a
, b
), t
)
1319 self
.assertEqual(zip(a
, b
), t
)
1321 self
.assertEqual(zip(a
, b
), t
)
1323 def __getitem__(self
, i
):
1324 if i
< 0 or i
> 2: raise IndexError
1326 self
.assertEqual(zip(a
, I()), t
)
1327 self
.assertEqual(zip(), [])
1328 self
.assertEqual(zip(*[]), [])
1329 self
.assertRaises(TypeError, zip, None)
1332 self
.assertRaises(TypeError, zip, a
, G())
1334 # Make sure zip doesn't try to allocate a billion elements for the
1335 # result list when one of its arguments doesn't say how long it is.
1336 # A MemoryError is the most likely failure mode.
1337 class SequenceWithoutALength
:
1338 def __getitem__(self
, i
):
1344 zip(SequenceWithoutALength(), xrange(2**30)),
1345 list(enumerate(range(5)))
1349 def __getitem__(self
, i
):
1354 self
.assertRaises(ValueError, zip, BadSeq(), BadSeq())
1356 def test_format(self
):
1357 # Test the basic machinery of the format() builtin. Don't test
1358 # the specifics of the various formatters
1359 self
.assertEqual(format(3, ''), '3')
1361 # Returns some classes to use for various tests. There's
1362 # an old-style version, and a new-style version
1365 def __init__(self
, x
):
1367 def __format__(self
, format_spec
):
1368 return str(self
.x
) + format_spec
1369 class DerivedFromA(A
):
1372 class Simple(object): pass
1373 class DerivedFromSimple(Simple
):
1374 def __init__(self
, x
):
1376 def __format__(self
, format_spec
):
1377 return str(self
.x
) + format_spec
1378 class DerivedFromSimple2(DerivedFromSimple
): pass
1379 return A
, DerivedFromA
, DerivedFromSimple
, DerivedFromSimple2
1381 # In 3.0, classes_classic has the same meaning as classes_new
1382 def classes_classic():
1384 def __init__(self
, x
):
1386 def __format__(self
, format_spec
):
1387 return str(self
.x
) + format_spec
1388 class DerivedFromA(A
):
1392 class DerivedFromSimple(Simple
):
1393 def __init__(self
, x
):
1395 def __format__(self
, format_spec
):
1396 return str(self
.x
) + format_spec
1397 class DerivedFromSimple2(DerivedFromSimple
): pass
1398 return A
, DerivedFromA
, DerivedFromSimple
, DerivedFromSimple2
1400 def class_test(A
, DerivedFromA
, DerivedFromSimple
, DerivedFromSimple2
):
1401 self
.assertEqual(format(A(3), 'spec'), '3spec')
1402 self
.assertEqual(format(DerivedFromA(4), 'spec'), '4spec')
1403 self
.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc')
1404 self
.assertEqual(format(DerivedFromSimple2(10), 'abcdef'),
1407 class_test(*classes_new())
1408 class_test(*classes_classic())
1410 def empty_format_spec(value
):
1412 # format(x, '') == str(x)
1413 # format(x) == str(x)
1414 self
.assertEqual(format(value
, ""), str(value
))
1415 self
.assertEqual(format(value
), str(value
))
1417 # for builtin types, format(x, "") == str(x)
1418 empty_format_spec(17**13)
1419 empty_format_spec(1.0)
1420 empty_format_spec(3.1415e104
)
1421 empty_format_spec(-3.1415e104
)
1422 empty_format_spec(3.1415e-104)
1423 empty_format_spec(-3.1415e-104)
1424 empty_format_spec(object)
1425 empty_format_spec(None)
1427 # TypeError because self.__format__ returns the wrong type
1428 class BadFormatResult
:
1429 def __format__(self
, format_spec
):
1431 self
.assertRaises(TypeError, format
, BadFormatResult(), "")
1433 # TypeError because format_spec is not unicode or str
1434 self
.assertRaises(TypeError, format
, object(), 4)
1435 self
.assertRaises(TypeError, format
, object(), object())
1437 # tests for object.__format__ really belong elsewhere, but
1438 # there's no good place to put them
1439 x
= object().__format
__('')
1440 self
.assert_(x
.startswith('<object object at'))
1442 # first argument to object.__format__ must be string
1443 self
.assertRaises(TypeError, object().__format
__, 3)
1444 self
.assertRaises(TypeError, object().__format
__, object())
1445 self
.assertRaises(TypeError, object().__format
__, None)
1447 # make sure we can take a subclass of str as a format spec
1448 class DerivedFromStr(str): pass
1449 self
.assertEqual(format(0, DerivedFromStr('10')), ' 0')
1452 self
.assertEqual(bin(0), '0b0')
1453 self
.assertEqual(bin(1), '0b1')
1454 self
.assertEqual(bin(-1), '-0b1')
1455 self
.assertEqual(bin(2**65), '0b1' + '0' * 65)
1456 self
.assertEqual(bin(2**65-1), '0b' + '1' * 65)
1457 self
.assertEqual(bin(-(2**65)), '-0b1' + '0' * 65)
1458 self
.assertEqual(bin(-(2**65-1)), '-0b' + '1' * 65)
1460 class TestSorted(unittest
.TestCase
):
1462 def test_basic(self
):
1465 random
.shuffle(copy
)
1466 self
.assertEqual(data
, sorted(copy
))
1467 self
.assertNotEqual(data
, copy
)
1470 random
.shuffle(copy
)
1471 self
.assertEqual(data
, sorted(copy
, cmp=lambda x
, y
: cmp(y
,x
)))
1472 self
.assertNotEqual(data
, copy
)
1473 random
.shuffle(copy
)
1474 self
.assertEqual(data
, sorted(copy
, key
=lambda x
: -x
))
1475 self
.assertNotEqual(data
, copy
)
1476 random
.shuffle(copy
)
1477 self
.assertEqual(data
, sorted(copy
, reverse
=1))
1478 self
.assertNotEqual(data
, copy
)
1480 def test_inputtypes(self
):
1482 types
= [list, tuple]
1484 types
.insert(0, unicode)
1486 self
.assertEqual(sorted(s
), sorted(T(s
)))
1488 s
= ''.join(dict.fromkeys(s
).keys()) # unique letters only
1489 types
= [set, frozenset, list, tuple, dict.fromkeys
]
1491 types
.insert(0, unicode)
1493 self
.assertEqual(sorted(s
), sorted(T(s
)))
1495 def test_baddecorator(self
):
1496 data
= 'The quick Brown fox Jumped over The lazy Dog'.split()
1497 self
.assertRaises(TypeError, sorted, data
, None, lambda x
,y
: 0)
1499 def test_main(verbose
=None):
1500 test_classes
= (BuiltinTest
, TestSorted
)
1502 run_unittest(*test_classes
)
1504 # verify reference counting
1505 if verbose
and hasattr(sys
, "gettotalrefcount"):
1508 for i
in xrange(len(counts
)):
1509 run_unittest(*test_classes
)
1511 counts
[i
] = sys
.gettotalrefcount()
1515 if __name__
== "__main__":
1516 test_main(verbose
=True)