# Python test set -- built-in functions
import test
.test_support
, unittest
from test
.test_support
import fcmp
, have_unicode
, TESTFN
, unlink
import sys
, warnings
, cStringIO
, random
, UserDict
warnings
.filterwarnings("ignore", "hex../oct.. of negative int",
warnings
.filterwarnings("ignore", "integer argument expected",
DeprecationWarning, "unittest")
def __len__(self
): return len(self
.sofar
)
def __getitem__(self
, i
):
if not 0 <= i
< self
.max: raise IndexError
def __getitem__(self
, i
):
if not 0 <= i
< self
.max:
self
.sofar
.append(str(n
*n
))
(' \t\t 314 \t\t ', 314),
(repr(sys
.maxint
), sys
.maxint
),
(unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314),
(unicode(' \t\t 314 \t\t '), 314),
(unicode(' 1x'), ValueError),
(unicode(' 1\02 '), ValueError),
(unicode(''), ValueError),
(unicode(' '), ValueError),
(unicode(' \t\t '), ValueError),
(unichr(0x200), ValueError),
class BuiltinTest(unittest
.TestCase
):
self
.assertRaises(ImportError, __import__, 'spamspam')
self
.assertRaises(TypeError, __import__, 1, 2, 3, 4)
self
.assertEqual(abs(0), 0)
self
.assertEqual(abs(1234), 1234)
self
.assertEqual(abs(-1234), 1234)
self
.assertEqual(abs(0.0), 0.0)
self
.assertEqual(abs(3.14), 3.14)
self
.assertEqual(abs(-3.14), 3.14)
self
.assertEqual(abs(0L), 0L)
self
.assertEqual(abs(1234L), 1234L)
self
.assertEqual(abs(-1234L), 1234L)
self
.assertRaises(TypeError, abs, 'a')
self
.assertEqual(args
, ())
# A PyCFunction that takes only positional parameters should allow an
# empty keyword dictionary to pass without a complaint, but raise a
# TypeError if the dictionary is non-empty.
self
.assertRaises(TypeError, apply, id, (1,), {"foo": 1})
self
.assertRaises(TypeError, apply)
self
.assertRaises(TypeError, apply, id, 42)
self
.assertRaises(TypeError, apply, id, (42,), 42)
self
.assert_(callable(len))
self
.assert_(callable(f
))
self
.assert_(callable(C
))
self
.assert_(callable(x
.meth
))
self
.assert_(not callable(x
))
self
.assert_(callable(y
))
self
.assertEqual(chr(32), ' ')
self
.assertEqual(chr(65), 'A')
self
.assertEqual(chr(97), 'a')
self
.assertEqual(chr(0xff), '\xff')
self
.assertRaises(ValueError, chr, 256)
self
.assertRaises(TypeError, chr)
self
.assertEqual(cmp(-1, 1), -1)
self
.assertEqual(cmp(1, -1), 1)
self
.assertEqual(cmp(1, 1), 0)
# verify that circular objects are not handled
from UserList
import UserList
c
= UserList(); c
.append(c
)
self
.assertRaises(RuntimeError, cmp, a
, b
)
self
.assertRaises(RuntimeError, cmp, b
, c
)
self
.assertRaises(RuntimeError, cmp, c
, a
)
self
.assertRaises(RuntimeError, cmp, a
, c
)
# okay, now break the cycles
a
.pop(); b
.pop(); c
.pop()
self
.assertRaises(TypeError, cmp)
self
.assert_(not fcmp(coerce(1, 1.1), (1.0, 1.1)))
self
.assertEqual(coerce(1, 1L), (1L, 1L))
self
.assert_(not fcmp(coerce(1L, 1.1), (1.0, 1.1)))
self
.assertRaises(TypeError, coerce)
def __coerce__(self
, other
):
self
.assertRaises(ValueError, coerce, 42, BadNumber())
self
.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000))
compile('print 1\n', '', 'exec')
compile(bom
+ 'print 1\n', '', 'exec')
self
.assertRaises(TypeError, compile)
self
.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode')
self
.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff)
compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')
self
.assertRaises(TypeError, delattr)
self
.assert_('x' in dir())
self
.assert_('modules' in dir(sys
))
self
.assertRaises(TypeError, dir, 42, 42)
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(12L, 7L), (1L, 5L))
self
.assertEqual(divmod(-12L, 7L), (-2L, 2L))
self
.assertEqual(divmod(12L, -7L), (-2L, -2L))
self
.assertEqual(divmod(-12L, -7L), (1L, -5L))
self
.assertEqual(divmod(12, 7L), (1, 5L))
self
.assertEqual(divmod(-12, 7L), (-2, 2L))
self
.assertEqual(divmod(12L, -7), (-2L, -2))
self
.assertEqual(divmod(-12L, -7), (1L, -5))
self
.assertEqual(divmod(-sys
.maxint
-1, -1),
self
.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
self
.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
self
.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))
self
.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))
self
.assertRaises(TypeError, divmod)
self
.assertEqual(eval('1+1'), 2)
self
.assertEqual(eval(' 1+1\n'), 2)
globals = {'a': 1, 'b': 2}
locals = {'b': 200, 'c': 300}
self
.assertEqual(eval('a', globals) , 1)
self
.assertEqual(eval('a', globals, locals), 1)
self
.assertEqual(eval('b', globals, locals), 200)
self
.assertEqual(eval('c', globals, locals), 300)
self
.assertEqual(eval(unicode('1+1')), 2)
self
.assertEqual(eval(unicode(' 1+1\n')), 2)
globals = {'a': 1, 'b': 2}
locals = {'b': 200, 'c': 300}
self
.assertEqual(eval(unicode('a'), globals), 1)
self
.assertEqual(eval(unicode('a'), globals, locals), 1)
self
.assertEqual(eval(unicode('b'), globals, locals), 200)
self
.assertEqual(eval(unicode('c'), globals, locals), 300)
self
.assertEqual(eval(bom
+ 'a', globals, locals), 1)
self
.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals),
unicode('\xc3\xa5', 'utf8'))
self
.assertRaises(TypeError, eval)
self
.assertRaises(TypeError, eval, ())
def test_general_eval(self
):
# Tests that general mappings can be used for the locals argument
"Test mapping interface versus possible calls from eval()."
def __getitem__(self
, key
):
self
.assertEqual(eval('a', g
, m
), 12)
self
.assertRaises(NameError, eval, 'b', g
, m
)
self
.assertEqual(eval('dir()', g
, m
), list('xyz'))
self
.assertEqual(eval('globals()', g
, m
), g
)
self
.assertEqual(eval('locals()', g
, m
), m
)
self
.assertRaises(TypeError, eval, 'a', m
)
self
.assertRaises(TypeError, eval, 'a', g
, m
)
# Verify that dict subclasses work as well
def __getitem__(self
, key
):
return dict.__getitem
__(self
, key
)
self
.assertEqual(eval('a', g
, d
), 12)
self
.assertRaises(NameError, eval, 'b', g
, d
)
self
.assertEqual(eval('dir()', g
, d
), list('xyz'))
self
.assertEqual(eval('globals()', g
, d
), g
)
self
.assertEqual(eval('locals()', g
, d
), d
)
# Verify locals stores (used by list comps)
eval('[locals() for i in (2,3)]', g
, d
)
eval('[locals() for i in (2,3)]', g
, UserDict
.UserDict())
"Sample application showing nested, calculated lookups."
def __setitem__(self
, key
, formula
):
self
._cells
[key
] = formula
def __getitem__(self
, key
):
return eval(self
._cells
[key
], globals(), self
)
self
.assertEqual(ss
['a3'], 210)
# Verify that dir() catches a non-list returned by eval
def __getitem__(self
, item
):
self
.assertRaises(TypeError, eval, 'dir()', globals(), C())
# Done outside of the method test_z to get the correct scope
globals = {'a': 1, 'b': 2}
locals = {'b': 200, 'c': 300}
self
.assertEqual(self
.__class
__.z
, 2)
execfile(TESTFN
, globals)
self
.assertEqual(globals['z'], 2)
execfile(TESTFN
, globals, locals)
self
.assertEqual(locals['z'], 2)
"Test mapping interface versus possible calls from execfile()."
def __getitem__(self
, key
):
def __setitem__(self
, key
, value
):
execfile(TESTFN
, globals, locals)
self
.assertEqual(locals['z'], 2)
self
.assertRaises(TypeError, execfile)
self
.assertRaises(IOError, execfile, os
.curdir
)
self
.assertRaises(IOError, execfile, "I_dont_exist")
self
.assertEqual(filter(lambda c
: 'a' <= c
<= 'z', 'Hello World'), 'elloorld')
self
.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9])
self
.assertEqual(filter(lambda x
: x
> 0, [1, -3, 9, 0, 2]), [1, 9, 2])
self
.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81])
self
.assertEqual(filter(lambda x
: x
%2, Squares(10)), [1, 9, 25, 49, 81])
filter(identity
, Squares(5))
self
.assertRaises(TypeError, filter)
def __getitem__(self
, index
):
self
.assertRaises(ValueError, filter, lambda x
: x
, BadSeq())
self
.assertRaises(TypeError, filter, badfunc
, range(5))
# test bltinmodule.c::filtertuple()
self
.assertEqual(filter(None, (1, 2)), (1, 2))
self
.assertEqual(filter(lambda x
: x
>=3, (1, 2, 3, 4)), (3, 4))
self
.assertRaises(TypeError, filter, 42, (1, 2))
# test bltinmodule.c::filterstring()
self
.assertEqual(filter(None, "12"), "12")
self
.assertEqual(filter(lambda x
: x
>="3", "1234"), "34")
self
.assertRaises(TypeError, filter, 42, "12")
def __getitem__(self
, index
):
self
.assertRaises(ValueError, filter, lambda x
: x
>="3", badstr("1234"))
def __getitem__(self
, index
):
self
.assertRaises(TypeError, filter, lambda x
: x
>=42, badstr2("1234"))
def __getitem__(self
, index
):
return weirdstr(2*str.__getitem
__(self
, index
))
self
.assertEqual(filter(lambda x
: x
>="33", weirdstr("1234")), "3344")
def __getitem__(self
, index
):
return chr(ord(str.__getitem
__(self
, index
))+1)
self
.assertEqual(filter(lambda x
: x
>="3", shiftstr("1234")), "345")
# test bltinmodule.c::filterunicode()
self
.assertEqual(filter(None, unicode("12")), unicode("12"))
self
.assertEqual(filter(lambda x
: x
>="3", unicode("1234")), unicode("34"))
self
.assertRaises(TypeError, filter, 42, unicode("12"))
self
.assertRaises(ValueError, filter, lambda x
: x
>="3", badstr(unicode("1234")))
class badunicode(unicode):
def __getitem__(self
, index
):
self
.assertRaises(TypeError, filter, lambda x
: x
>=42, badunicode("1234"))
class weirdunicode(unicode):
def __getitem__(self
, index
):
return weirdunicode(2*unicode.__getitem
__(self
, index
))
filter(lambda x
: x
>=unicode("33"), weirdunicode("1234")), unicode("3344"))
class shiftunicode(unicode):
def __getitem__(self
, index
):
return unichr(ord(unicode.__getitem
__(self
, index
))+1)
filter(lambda x
: x
>=unicode("3"), shiftunicode("1234")),
def test_filter_subclasses(self
):
# test that filter() never returns tuple, str or unicode subclasses
# and that the result always goes through __getitem__
funcs
= (None, bool, lambda x
: True)
def __getitem__(self
, index
):
return 2*tuple.__getitem
__(self
, index
)
def __getitem__(self
, index
):
return 2*str.__getitem
__(self
, index
)
tuple2
: {(): (), (1, 2, 3): (2, 4, 6)},
str2
: {"": "", "123": "112233"}
def __getitem__(self
, index
):
return 2*unicode.__getitem
__(self
, index
)
unicode("123"): unicode("112233")
for (cls
, inps
) in inputs
.iteritems():
for (inp
, exp
) in inps
.iteritems():
# make sure the output goes through __getitem__
filter(funcs
[0], cls(inp
)),
filter(funcs
[1], cls(inp
))
outp
= filter(func
, cls(inp
))
self
.assertEqual(outp
, exp
)
self
.assert_(not isinstance(outp
, cls
))
self
.assertEqual(float(3.14), 3.14)
self
.assertEqual(float(314), 314.0)
self
.assertEqual(float(314L), 314.0)
self
.assertEqual(float(" 3.14 "), 3.14)
self
.assertEqual(float(unicode(" 3.14 ")), 3.14)
self
.assertEqual(float(unicode(" \u0663.\u0661\u0664 ",'raw-unicode-escape')), 3.14)
self
.assert_(getattr(sys
, 'stdout') is sys
.stdout
)
self
.assertRaises(TypeError, getattr, sys
, 1)
self
.assertRaises(TypeError, getattr, sys
, 1, "foo")
self
.assertRaises(TypeError, getattr)
self
.assertRaises(UnicodeError, getattr, sys
, unichr(sys
.maxunicode
))
self
.assert_(hasattr(sys
, 'stdout'))
self
.assertRaises(TypeError, hasattr, sys
, 1)
self
.assertRaises(TypeError, hasattr)
self
.assertRaises(UnicodeError, hasattr, sys
, unichr(sys
.maxunicode
))
self
.assertEqual(hash(1), hash(1L))
self
.assertEqual(hash(1), hash(1.0))
self
.assertEqual(hash('spam'), hash(unicode('spam')))
self
.assertRaises(TypeError, hash, [])
self
.assertRaises(TypeError, hash, {})
self
.assertEqual(hex(16), '0x10')
self
.assertEqual(hex(16L), '0x10L')
self
.assertEqual(hex(-16), '-0x10')
self
.assertEqual(hex(-16L), '-0x10L')
self
.assertRaises(TypeError, hex, {})
id({'spam': 1, 'eggs': 2, 'ham': 3})
# Test input() later, together with raw_input
self
.assertEqual(int(314), 314)
self
.assertEqual(int(3.14), 3)
self
.assertEqual(int(314L), 314)
# 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("10",16), 16L)
self
.assertEqual(int(unicode("10"),16), 16L)
# Test conversion from strings and various anomalies
for sign
in "", "+", "-":
for prefix
in "", " ", "\t", " \t\t ":
if sign
== "-" and v
is not ValueError:
self
.assertEqual(int(ss
), vv
)
self
.assertEqual(int(s
)+1, -sys
.maxint
)
self
.assert_(isinstance(x
, long))
self
.assert_(isinstance(x
, long))
# SF bug 434186: 0x80000000/2 != 0x80000000>>1.
# Worked by accident in Windows release build, but failed in debug build.
# Failed in all Linux builds.
self
.assertEqual(x
>> 1, x
//2)
self
.assertRaises(ValueError, int, '123\0')
self
.assertRaises(ValueError, int, '53', 40)
self
.assert_(isinstance(x
, long))
x
= int(unichr(0x661) * 600)
self
.assert_(isinstance(x
, long))
self
.assertRaises(TypeError, int, 1, 12)
self
.assertEqual(int('0123', 0), 83)
self
.assertRaises(TypeError, intern)
s
= "never interned before"
self
.assert_(intern(s
) is s
)
s2
= s
.swapcase().swapcase()
self
.assert_(intern(s2
) is s
)
# Subclasses of string can't be interned, because they
# provide too much opportunity for insane things to happen.
# We don't want them in the interned dict and if they aren't
# actually interned, we don't want to create the appearance
# that they are by allowing intern() to succeeed.
self
.assertRaises(TypeError, intern, S("abc"))
# It's still safe to pass these strings to routines that
# call intern internally, e.g. PyObject_SetAttr().
self
.assertEqual(getattr(s
, s
), s
)
self
.assertRaises(TypeError, iter)
self
.assertRaises(TypeError, iter, 42, 42)
lists
= [("1", "2"), ["1", "2"], "12"]
lists
.append(unicode("12"))
self
.assertEqual(i
.next(), '1')
self
.assertEqual(i
.next(), '2')
self
.assertRaises(StopIteration, i
.next
)
def test_isinstance(self
):
self
.assert_(isinstance(c
, C
))
self
.assert_(isinstance(d
, C
))
self
.assert_(not isinstance(e
, C
))
self
.assert_(not isinstance(c
, D
))
self
.assert_(not isinstance('foo', E
))
self
.assertRaises(TypeError, isinstance, E
, 'foo')
self
.assertRaises(TypeError, isinstance)
def test_issubclass(self
):
self
.assert_(issubclass(D
, C
))
self
.assert_(issubclass(C
, C
))
self
.assert_(not issubclass(C
, D
))
self
.assertRaises(TypeError, issubclass, 'foo', E
)
self
.assertRaises(TypeError, issubclass, E
, 'foo')
self
.assertRaises(TypeError, issubclass)
self
.assertEqual(len('123'), 3)
self
.assertEqual(len(()), 0)
self
.assertEqual(len((1, 2, 3, 4)), 4)
self
.assertEqual(len([1, 2, 3, 4]), 4)
self
.assertEqual(len({}), 0)
self
.assertEqual(len({'a':1, 'b': 2}), 2)
self
.assertRaises(ValueError, len, BadSeq())
self
.assertEqual(list([]), [])
self
.assertEqual(l0_3
, l0_3_bis
)
self
.assert_(l0_3
is not l0_3_bis
)
self
.assertEqual(list(()), [])
self
.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3])
self
.assertEqual(list(''), [])
self
.assertEqual(list('spam'), ['s', 'p', 'a', 'm'])
if sys
.maxint
== 0x7fffffff:
# This test can currently only work on 32-bit machines.
# XXX If/when PySequence_Length() returns a ssize_t, it should be
# Verify clearing of bug #556025.
# This assumes that the max data size (sys.maxint) == max
# address size this also assumes that the address size is at
# least 4 bytes with 8 byte addresses, the bug is not well
# Note: This test is expected to SEGV under Cygwin 1.3.12 or
# earlier due to a newlib bug. See the following mailing list
# thread for the details:
# http://sources.redhat.com/ml/newlib/2002/msg00369.html
self
.assertRaises(MemoryError, list, xrange(sys
.maxint
// 2))
# This code used to segfault in Py2.4a3
self
.assertEqual(long(314), 314L)
self
.assertEqual(long(3.14), 3L)
self
.assertEqual(long(314L), 314L)
# Check that conversion from float truncates towards zero
self
.assertEqual(long(-3.14), -3L)
self
.assertEqual(long(3.9), 3L)
self
.assertEqual(long(-3.9), -3L)
self
.assertEqual(long(3.5), 3L)
self
.assertEqual(long(-3.5), -3L)
self
.assertEqual(long("-3"), -3L)
self
.assertEqual(long(unicode("-3")), -3L)
self
.assertEqual(long("10",16), 16L)
self
.assertEqual(long(unicode("10"),16), 16L)
# Check conversions from string (same test set as for int(), and then some)
('1' + '0'*100, 10L**100)
(unicode('1') + unicode('0')*20, 10L**20),
(unicode('1') + unicode('0')*100, 10L**100),
for sign
in "", "+", "-":
for prefix
in "", " ", "\t", " \t\t ":
if sign
== "-" and v
is not ValueError:
self
.assertEqual(long(ss
), long(vv
))
self
.assertRaises(ValueError, long, '123\0')
self
.assertRaises(ValueError, long, '53', 40)
self
.assertRaises(TypeError, long, 1, 12)
map(None, 'hello world'),
['h','e','l','l','o',' ','w','o','r','l','d']
map(None, 'abcd', 'efg'),
[('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
map(lambda x
: x
*x
, range(1,4)),
map(lambda x
: map(sqrt
,x
), [[16, 4], [81, 9]]),
map(lambda x
, y
: x
+y
, [1,3,2], [9,1,4]),
for i
in v
: accu
= accu
+ i
map(plus
, [1, 3, 7], [4, 9, 2]),
map(plus
, [1, 3, 7], [4, 9, 2], [1, 1, 0]),
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
map(None, Squares(3), Squares(2)),
map(max, Squares(3), Squares(2)),
self
.assertRaises(TypeError, map)
self
.assertRaises(TypeError, map, lambda x
: x
, 42)
self
.assertEqual(map(None, [42]), [42])
def __getitem__(self
, index
):
self
.assertRaises(ValueError, map, lambda x
: x
, BadSeq())
self
.assertEqual(max('123123'), '3')
self
.assertEqual(max(1, 2, 3), 3)
self
.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
self
.assertEqual(max([1, 2, 3, 1, 2, 3]), 3)
self
.assertEqual(max(1, 2L, 3.0), 3.0)
self
.assertEqual(max(1L, 2.0, 3), 3)
self
.assertEqual(max(1.0, 2, 3L), 3L)
self
.assertEqual(min('123123'), '1')
self
.assertEqual(min(1, 2, 3), 1)
self
.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
self
.assertEqual(min([1, 2, 3, 1, 2, 3]), 1)
self
.assertEqual(min(1, 2L, 3.0), 1)
self
.assertEqual(min(1L, 2.0, 3), 1L)
self
.assertEqual(min(1.0, 2, 3L), 1.0)
self
.assertRaises(TypeError, min)
self
.assertRaises(TypeError, min, 42)
self
.assertRaises(ValueError, min, ())
def __getitem__(self
, index
):
self
.assertRaises(ValueError, min, BadSeq())
def __cmp__(self
, other
):
self
.assertRaises(ValueError, min, (42, BadNumber()))
self
.assertEqual(oct(100), '0144')
self
.assertEqual(oct(100L), '0144L')
self
.assertEqual(oct(-100), '-0144')
self
.assertEqual(oct(-100L), '-0144L')
self
.assertRaises(TypeError, oct, ())
def write_testfile(self
):
# NB the first 4 lines are also used to test input and raw_input, below
fp
.write('The quick brown fox jumps over the lazy dog')
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')
self
.assertEqual(fp
.read(300), 'XXX'*100)
self
.assertEqual(fp
.read(1000), 'YYY'*100)
self
.assertEqual(ord(' '), 32)
self
.assertEqual(ord('A'), 65)
self
.assertEqual(ord('a'), 97)
self
.assertEqual(ord(unichr(sys
.maxunicode
)), sys
.maxunicode
)
self
.assertRaises(TypeError, ord, 42)
self
.assertRaises(TypeError, ord, unicode("12"))
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
.assertEqual(pow(0L,0), 1)
self
.assertEqual(pow(0L,1), 0)
self
.assertEqual(pow(1L,0), 1)
self
.assertEqual(pow(1L,1), 1)
self
.assertEqual(pow(2L,0), 1)
self
.assertEqual(pow(2L,10), 1024)
self
.assertEqual(pow(2L,20), 1024*1024)
self
.assertEqual(pow(2L,30), 1024*1024*1024)
self
.assertEqual(pow(-2L,0), 1)
self
.assertEqual(pow(-2L,1), -2)
self
.assertEqual(pow(-2L,2), 4)
self
.assertEqual(pow(-2L,3), -8)
self
.assertAlmostEqual(pow(0.,0), 1.)
self
.assertAlmostEqual(pow(0.,1), 0.)
self
.assertAlmostEqual(pow(1.,0), 1.)
self
.assertAlmostEqual(pow(1.,1), 1.)
self
.assertAlmostEqual(pow(2.,0), 1.)
self
.assertAlmostEqual(pow(2.,10), 1024.)
self
.assertAlmostEqual(pow(2.,20), 1024.*1024.)
self
.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.)
self
.assertAlmostEqual(pow(-2.,0), 1.)
self
.assertAlmostEqual(pow(-2.,1), -2.)
self
.assertAlmostEqual(pow(-2.,2), 4.)
self
.assertAlmostEqual(pow(-2.,3), -8.)
for z
in 1000, 1000L, 1000.0:
if isinstance(x
, float) or \
isinstance(y
, float) or \
self
.assertRaises(TypeError, pow, x
, y
, z
)
self
.assertAlmostEqual(pow(x
, y
, z
), 24.0)
self
.assertRaises(TypeError, pow, -1, -2, 3)
self
.assertRaises(ValueError, pow, 1, 2, 0)
self
.assertRaises(TypeError, pow, -1L, -2L, 3L)
self
.assertRaises(ValueError, pow, 1L, 2L, 0L)
self
.assertRaises(ValueError, pow, -342.43, 0.234)
self
.assertRaises(TypeError, pow)
self
.assertEqual(range(3), [0, 1, 2])
self
.assertEqual(range(1, 5), [1, 2, 3, 4])
self
.assertEqual(range(0), [])
self
.assertEqual(range(-3), [])
self
.assertEqual(range(1, 10, 3), [1, 4, 7])
self
.assertEqual(range(5, -5, -3), [5, 2, -1, -4])
# Now test range() with longs
self
.assertEqual(range(-2**100), [])
self
.assertEqual(range(0, -2**100), [])
self
.assertEqual(range(0, 2**100, -1), [])
self
.assertEqual(range(0, 2**100, -1), [])
a
= long(10 * sys
.maxint
)
b
= long(100 * sys
.maxint
)
c
= long(50 * sys
.maxint
)
self
.assertEqual(range(a
, a
+2), [a
, a
+1])
self
.assertEqual(range(a
+2, a
, -1L), [a
+2, a
+1])
self
.assertEqual(range(a
+4, a
, -2), [a
+4, a
+2])
self
.assert_(b
not in seq
)
self
.assertEqual(len(seq
), 2)
self
.assert_(a
not in seq
)
self
.assertEqual(len(seq
), 2)
self
.assert_(-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)
# 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")
self
.assertRaises(OverflowError, range, -sys
.maxint
, sys
.maxint
)
self
.assertRaises(OverflowError, range, 0, 2*sys
.maxint
)
def test_input_and_raw_input(self
):
savestdout
= sys
.stdout
# Eats the echo
self
.assertEqual(input(), 2)
self
.assertEqual(input('testing\n'), 2)
self
.assertEqual(raw_input(), 'The quick brown fox jumps over the lazy dog.')
self
.assertEqual(raw_input('testing\n'), 'Dear John')
sys
.stdin
= cStringIO
.StringIO("NULL\0")
self
.assertRaises(TypeError, input, 42, 42)
sys
.stdin
= cStringIO
.StringIO(" 'whitespace'")
self
.assertEqual(input(), 'whitespace')
sys
.stdin
= cStringIO
.StringIO()
self
.assertRaises(EOFError, input)
# SF 876178: make sure input() respect future options.
sys
.stdin
= cStringIO
.StringIO('1/2')
sys
.stdout
= cStringIO
.StringIO()
exec compile('print input()', 'test_builtin_tmp', 'exec')
exec compile('from __future__ import division;print input()',
'test_builtin_tmp', 'exec')
exec compile('print input()', 'test_builtin_tmp', 'exec')
self
.assertEqual(sys
.stdout
.getvalue().splitlines(),
self
.assertRaises(RuntimeError, input, 'prompt')
self
.assertRaises(RuntimeError, input, 'prompt')
self
.assertEqual(reduce(lambda x
, y
: x
+y
, ['a', 'b', 'c'], ''), 'abc')
reduce(lambda x
, y
: x
+y
, [['a', 'c'], [], ['d', 'w']], []),
self
.assertEqual(reduce(lambda x
, y
: x
*y
, range(2,8), 1), 5040)
reduce(lambda x
, y
: x
*y
, range(2,21), 1L),
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
.assertRaises(TypeError, reduce)
self
.assertRaises(TypeError, reduce, 42, 42)
self
.assertRaises(TypeError, reduce, 42, 42, 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))
def __getitem__(self
, index
):
self
.assertRaises(ValueError, reduce, 42, BadSeq())
## self.assertRaises(ImportError, reload, sys)
self
.assertEqual(repr(''), '\'\'')
self
.assertEqual(repr(0), '0')
self
.assertEqual(repr(0L), '0L')
self
.assertEqual(repr(()), '()')
self
.assertEqual(repr([]), '[]')
self
.assertEqual(repr({}), '{}')
self
.assertEqual(repr(a
), '[[...]]')
self
.assertEqual(repr(a
), '{0: {...}}')
self
.assertEqual(round(0.0), 0.0)
self
.assertEqual(round(1.0), 1.0)
self
.assertEqual(round(10.0), 10.0)
self
.assertEqual(round(1000000000.0), 1000000000.0)
self
.assertEqual(round(1e20
), 1e20
)
self
.assertEqual(round(-1.0), -1.0)
self
.assertEqual(round(-10.0), -10.0)
self
.assertEqual(round(-1000000000.0), -1000000000.0)
self
.assertEqual(round(-1e20
), -1e20
)
self
.assertEqual(round(0.1), 0.0)
self
.assertEqual(round(1.1), 1.0)
self
.assertEqual(round(10.1), 10.0)
self
.assertEqual(round(1000000000.1), 1000000000.0)
self
.assertEqual(round(-1.1), -1.0)
self
.assertEqual(round(-10.1), -10.0)
self
.assertEqual(round(-1000000000.1), -1000000000.0)
self
.assertEqual(round(0.9), 1.0)
self
.assertEqual(round(9.9), 10.0)
self
.assertEqual(round(999999999.9), 1000000000.0)
self
.assertEqual(round(-0.9), -1.0)
self
.assertEqual(round(-9.9), -10.0)
self
.assertEqual(round(-999999999.9), -1000000000.0)
self
.assertEqual(round(-8.0, -1), -10.0)
self
.assertRaises(TypeError, round)
self
.assertEqual(sys
.spam
, 1)
self
.assertRaises(TypeError, setattr, sys
, 1, 'spam')
self
.assertRaises(TypeError, setattr)
self
.assertEqual(str(''), '')
self
.assertEqual(str(0), '0')
self
.assertEqual(str(0L), '0')
self
.assertEqual(str(()), '()')
self
.assertEqual(str([]), '[]')
self
.assertEqual(str({}), '{}')
self
.assertEqual(str(a
), '[[...]]')
self
.assertEqual(str(a
), '{0: {...}}')
self
.assertEqual(sum([]), 0)
self
.assertEqual(sum(range(2,8)), 27)
self
.assertEqual(sum(iter(range(2,8))), 27)
self
.assertEqual(sum(Squares(10)), 285)
self
.assertEqual(sum(iter(Squares(10))), 285)
self
.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3])
self
.assertRaises(TypeError, sum)
self
.assertRaises(TypeError, sum, 42)
self
.assertRaises(TypeError, sum, ['a', 'b', 'c'])
self
.assertRaises(TypeError, sum, ['a', 'b', 'c'], '')
self
.assertRaises(TypeError, sum, [[1], [2], [3]])
self
.assertRaises(TypeError, sum, [{2:3}])
self
.assertRaises(TypeError, sum, [{2:3}]*2, {2:3})
def __getitem__(self
, index
):
self
.assertRaises(ValueError, sum, BadSeq())
self
.assertEqual(tuple(()), ())
self
.assert_(t0_3
is t0_3_bis
)
self
.assertEqual(tuple([]), ())
self
.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3))
self
.assertEqual(tuple(''), ())
self
.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm'))
self
.assertEqual(type(''), type('123'))
self
.assertNotEqual(type(''), type(()))
self
.assertEqual(unichr(32), unicode(' '))
self
.assertEqual(unichr(65), unicode('A'))
self
.assertEqual(unichr(97), unicode('a'))
unicode('\\U%08x' % (sys
.maxunicode
), 'unicode-escape')
self
.assertRaises(ValueError, unichr, sys
.maxunicode
+1)
self
.assertRaises(TypeError, unichr)
# we don't want self in vars(), so use staticmethod
get_vars_f0
= staticmethod(get_vars_f0
)
BuiltinTest
.get_vars_f0()
get_vars_f2
= staticmethod(get_vars_f2
)
self
.assertEqual(set(vars()), set(dir()))
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)
t
= [(1, 4), (2, 5), (3, 6)]
self
.assertEqual(zip(a
, b
), t
)
self
.assertEqual(zip(a
, b
), t
)
self
.assertEqual(zip(a
, b
), t
)
def __getitem__(self
, i
):
if i
< 0 or i
> 2: raise IndexError
self
.assertEqual(zip(a
, I()), t
)
self
.assertEqual(zip(), [])
self
.assertEqual(zip(*[]), [])
self
.assertRaises(TypeError, zip, None)
self
.assertRaises(TypeError, zip, a
, G())
# Make sure zip doesn't try to allocate a billion elements for the
# result list when one of its arguments doesn't say how long it is.
# A MemoryError is the most likely failure mode.
class SequenceWithoutALength
:
def __getitem__(self
, i
):
zip(SequenceWithoutALength(), xrange(2**30)),
list(enumerate(range(5)))
def __getitem__(self
, i
):
self
.assertRaises(ValueError, zip, BadSeq(), BadSeq())
class TestSorted(unittest
.TestCase
):
self
.assertEqual(data
, sorted(copy
))
self
.assertNotEqual(data
, copy
)
self
.assertEqual(data
, sorted(copy
, cmp=lambda x
, y
: cmp(y
,x
)))
self
.assertNotEqual(data
, copy
)
self
.assertEqual(data
, sorted(copy
, key
=lambda x
: -x
))
self
.assertNotEqual(data
, copy
)
self
.assertEqual(data
, sorted(copy
, reverse
=1))
self
.assertNotEqual(data
, copy
)
def test_inputtypes(self
):
for T
in [unicode, list, tuple]:
self
.assertEqual(sorted(s
), sorted(T(s
)))
s
= ''.join(dict.fromkeys(s
).keys()) # unique letters only
for T
in [unicode, set, frozenset, list, tuple, dict.fromkeys
]:
self
.assertEqual(sorted(s
), sorted(T(s
)))
def test_baddecorator(self
):
data
= 'The quick Brown fox Jumped over The lazy Dog'.split()
self
.assertRaises(TypeError, sorted, data
, None, lambda x
,y
: 0)
test
.test_support
.run_unittest(BuiltinTest
, TestSorted
)
if __name__
== "__main__":