def setUp(self):

self.tempdir = tempfile.mkdtemp() + os.path.sep

def test_super(self):

class verbose_list(list):

'''

def append(self, item):

print('Adding an item')

super().append(item)

l = verbose_list()

l.append('blah')

self.assertEqual(l[0], 'blah')

self.assertEqual(len(l), 1)

self.assertTrue(isinstance(l, list))

def test_super_2(self):

"""

class Terminal(str):

def __new__(cls, value, token_type):

self = super().__new__(cls, value)

self.token_type = token_type

self.defects = []

return self

DOT = Terminal('.', 'dot')

self.assertTrue(True)

def test_isinstance_int(self):

"""

self.assertTrue(isinstance(0, int))

self.assertTrue(isinstance(int(1), int))

self.assertFalse(isinstance(1.0, int))

def test_isinstance_Integral(self):

"""

self.assertTrue(isinstance(0, Integral))

def test_isinstance_long(self):

"""

self.assertTrue(isinstance(10**100, int))

self.assertTrue(isinstance(int(2**64), int))

if not PY3:

self.assertTrue(isinstance(long(1), int))

# Note: the following is a SyntaxError on Py3:

# self.assertTrue(isinstance(1L, int))

def test_isinstance_bytes(self):

self.assertTrue(isinstance(b'byte-string', bytes))

self.assertFalse(isinstance(b'byte-string', str))

def test_isinstance_str(self):

self.assertTrue(isinstance('string', str))

self.assertTrue(isinstance(u'string', str))

self.assertFalse(isinstance(u'string', bytes))

@expectedFailurePY2

def test_type(self):

"""

mytype = type('blah', (dict,), {"old": 1, "new": 2})

d = mytype()

self.assertTrue(isinstance(d, mytype))

self.assertTrue(isinstance(d, dict))

def test_isinstance_tuple_of_types(self):

# These two should be equivalent, even if ``int`` is a special

# backported type.

label = 1

self.assertTrue(isinstance(label, (float, Decimal)) or

isinstance(label, int))

self.assertTrue(isinstance(label, (float, Decimal, int)))

self.assertTrue(isinstance(10**100, (float, Decimal, int)))

self.assertTrue(isinstance(b'blah', (str, bytes)))

self.assertTrue(isinstance(b'blah', (bytes, float, int)))

self.assertFalse(isinstance(b'blah', (str, Decimal, float, int)))

self.assertTrue(isinstance('blah', (str, Decimal, float, int)))

self.assertTrue(isinstance(u'blah', (Decimal, float, int, str)))

self.assertFalse(isinstance('blah', (bytes, Decimal, float, int)))

def test_round(self):

"""

self.assertEqual(round(0.1250, 2), 0.12)

self.assertEqual(round(0.1350, 2), 0.14)

self.assertEqual(round(0.1251, 2), 0.13)

self.assertEqual(round(0.125000001, 2), 0.13)

self.assertEqual(round(123.5, 0), 124.0)

self.assertEqual(round(123.5), 124)

self.assertEqual(round(12.35, 2), 12.35)

self.assertEqual(round(12.35, 1), 12.3)

self.assertEqual(round(12.35, 0), 12.0)

self.assertEqual(round(123.5, 1), 123.5)

self.assertTrue(isinstance(round(123.5, 0), float))

self.assertTrue(isinstance(round(123.5), Integral))

@unittest.skip('negative ndigits not implemented yet')

def test_round_negative_ndigits(self):

self.assertEqual(round(10.1350, 0), 10.0)

self.assertEqual(round(10.1350, -1), 10.0)

self.assertEqual(round(10.1350, -2), 0.0)

self.assertEqual(round(10.1350, -3), 0.0)

self.assertEqual(round(12.35, -1), 10.0)

self.assertEqual(round(12.35, -2), 0.0)

self.assertEqual(round(123.5, -1), 120.0)

self.assertEqual(round(123.5, -2), 100.0)

self.assertEqual(round(123.551, -2), 100.0)

self.assertEqual(round(123.551, -3), 0.0)

def test_newnext_doc_example(self):

# Python 3-style iterator:

class Upper(object):

def __init__(self, iterable):

self._iter = iter(iterable)

def __next__(self): # note the Py3 interface

return next(self._iter).upper()

def __iter__(self):

return self

# from future.builtins import next

itr = Upper('hello')

self.assertEqual(next(itr), 'H')

self.assertEqual(next(itr), 'E')

# This doesn't work on Py2 because next() isn't defined:

# self.assertEqual(list(itr), 'LLO')

# Check that regular Py2 iterators with just a .next method also work:

itr2 = iter(['one', 'three', 'five'])

def __init__(self, max):

self.max = max

self.sofar = []

def __len__(self): return len(self.sofar)

def __getitem__(self, i):

if not 0 <= i < self.max: raise IndexError

n = len(self.sofar)

while n <= i:

self.sofar.append(n*n)

n += 1

def __init__(self, max):

self.max = max

self.sofar = []

def __len__(self):

return len(self.sofar)

def __getitem__(self, i):

if not 0 <= i < self.max:

raise IndexError

n = len(self.sofar)

while n <= i:

self.sofar.append(str(n*n))

n += 1

('0', 0),

('1', 1),

('9', 9),

('10', 10),

('99', 99),

('100', 100),

('314', 314),

(' 314', 314),

('314 ', 314),

(' \t\t 314 \t\t ', 314),

(repr(sys.maxsize), sys.maxsize),

(' 1x', ValueError),

(' 1 ', 1),

(' 1\02 ', ValueError),

('', ValueError),

(' ', ValueError),

(' \t\t ', ValueError),

(str(b'\u0663\u0661\u0664 ','raw-unicode-escape'), 314),

(chr(0x200), ValueError),

('0', 0),

('1', 1),

('9', 9),

('10', 10),

('99', 99),

('100', 100),

('314', 314),

(' 314', ValueError),

('314 ', 314),

(' \t\t 314 \t\t ', ValueError),

(repr(sys.maxsize), sys.maxsize),

(' 1x', ValueError),

(' 1 ', ValueError),

(' 1\02 ', ValueError),

('', ValueError),

(' ', ValueError),

(' \t\t ', ValueError),

(str(b'\u0663\u0661\u0664 ','raw-unicode-escape'), 314),

(chr(0x200), ValueError),

def __bool__(self):

raise RuntimeError

# On Py2:

def __nonzero__(self):

# Helper to check picklability

def check_iter_pickle(self, it, seq):

itorg = it

d = pickle.dumps(it)

it = pickle.loads(d)

self.assertEqual(type(itorg), type(it))

self.assertEqual(list(it), seq)

#test the iterator after dropping one from it

it = pickle.loads(d)

try:

next(it)

except StopIteration:

return

d = pickle.dumps(it)

it = pickle.loads(d)

self.assertEqual(list(it), seq[1:])

def test_import(self):

__import__('sys')

__import__('time')

__import__('string')

__import__(name='sys')

__import__(name='time', level=0)

self.assertRaises(ImportError, __import__, 'spamspam')

self.assertRaises(TypeError, __import__, 1, 2, 3, 4)

self.assertRaises(ValueError, __import__, '')

self.assertRaises(TypeError, __import__, 'sys', name='sys')

def test_abs(self):

# int

self.assertEqual(abs(0), 0)

self.assertEqual(abs(1234), 1234)

self.assertEqual(abs(-1234), 1234)

self.assertTrue(abs(-sys.maxsize-1) > 0)

# float

self.assertEqual(abs(0.0), 0.0)

self.assertEqual(abs(3.14), 3.14)

self.assertEqual(abs(-3.14), 3.14)

# 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)

self.assertEqual(all([2, None, 6]), False)

self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6])

self.assertRaises(RuntimeError, all, TestFailingIter())

self.assertRaises(TypeError, all, 10) # Non-iterable

self.assertRaises(TypeError, all) # No args

self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args

self.assertEqual(all([]), True) # Empty iterator

self.assertEqual(all([0, TestFailingBool()]), False)# Short-circuit

S = [50, 60]

self.assertEqual(all(x > 42 for x in S), True)

S = [50, 40, 60]

self.assertEqual(all(x > 42 for x in S), False)

def test_any(self):

self.assertEqual(any([None, None, None]), False)

self.assertEqual(any([None, 4, None]), True)

self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6])

self.assertRaises(RuntimeError, any, TestFailingIter())

self.assertRaises(TypeError, any, 10) # Non-iterable

self.assertRaises(TypeError, any) # No args

self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args

self.assertEqual(any([]), False) # Empty iterator

self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit

S = [40, 60, 30]

self.assertEqual(any(x > 42 for x in S), True)

S = [10, 20, 30]

self.assertEqual(any(x > 42 for x in S), False)

def test_ascii(self):

# Was: self.assertEqual(ascii(''), "''") # '\'\'')

# Heisenbug on Py2.7?!

self.assertEqual(ascii(0), '0')

self.assertEqual(ascii(()), '()')

self.assertEqual(ascii([]), '[]')

self.assertEqual(ascii({}), '{}')

a = []

a.append(a)

self.assertEqual(ascii(a), '[[...]]')

a = {}

a[0] = a

self.assertEqual(ascii(a), '{0: {...}}')

# Advanced checks for unicode strings

def _check_uni(s):

self.assertEqual(ascii(s), repr(s))

_check_uni("'")

_check_uni('"')

_check_uni('"\'')

_check_uni('\0')

_check_uni('\r\n\t .')

# Unprintable non-ASCII characters

_check_uni('\x85')

_check_uni('\u1fff')

_check_uni('\U00012fff')

# Lone surrogates

_check_uni('\ud800')

_check_uni('\udfff')

# Issue #9804: surrogates should be joined even for printable

# wide characters (UCS-2 builds).

# Fails on Py2.7. Was:

# self.assertEqual(ascii('\U0001d121'), "'\\U0001d121'")

# # All together

# s = "'\0\"\n\r\t abcd\x85é\U00012fff\uD800\U0001D121xxx."

# self.assertEqual(ascii(s),

# r"""'\'\x00"\n\r\t abcd\x85\xe9\U00012fff\ud800\U0001d121xxx.'""")

def test_neg(self):

x = -sys.maxsize-1

self.assertTrue(isinstance(x, int))

self.assertEqual(-x, sys.maxsize+1)

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 C1(object): # Was: class C1: (old-style class on Py2)

def meth(self): pass

self.assertTrue(callable(C1))

c = C1()

self.assertTrue(callable(c.meth))

self.assertFalse(callable(c))

# __call__ is looked up on the class, not the instance

c.__call__ = None

self.assertFalse(callable(c))

c.__call__ = lambda self: 0

self.assertFalse(callable(c))

del c.__call__

self.assertFalse(callable(c))

class C2(object):

def __call__(self): pass

c2 = C2()

self.assertTrue(callable(c2))

c2.__call__ = None

self.assertTrue(callable(c2))

class C3(C2): pass

c3 = C3()

self.assertTrue(callable(c3))

def test_chr(self):

self.assertEqual(chr(32), ' ')

self.assertEqual(chr(65), 'A')

self.assertEqual(chr(97), 'a')

self.assertEqual(chr(0xff), '\xff')

self.assertRaises(ValueError, chr, 1<<24)

self.assertRaises(TypeError, chr)

self.assertEqual(chr(0x0000FFFF), "\U0000FFFF")

self.assertRaises(ValueError, chr, -1)

self.assertRaises(ValueError, chr, 0x00110000)

self.assertRaises((OverflowError, ValueError), chr, 2**32)

@unittest.skip('FIXME: skip on narrow builds?')

def test_ord_big(self):

"""

self.assertEqual(chr(sys.maxunicode),

str('\\U0010ffff'.encode("ascii"), 'unicode-escape'))

self.assertEqual(ord("\U0000FFFF"), 0x0000FFFF)

self.assertEqual(ord("\U00010000"), 0x00010000)

self.assertEqual(ord("\U00010001"), 0x00010001)

self.assertEqual(ord("\U000FFFFE"), 0x000FFFFE)

self.assertEqual(ord("\U000FFFFF"), 0x000FFFFF)

self.assertEqual(ord("\U00100000"), 0x00100000)

self.assertEqual(ord("\U00100001"), 0x00100001)

self.assertEqual(ord("\U0010FFFE"), 0x0010FFFE)

self.assertEqual(ord("\U0010FFFF"), 0x0010FFFF)

@unittest.skip('FIXME: skip on narrow builds?')

def test_chr_big(self):

"""

self.assertEqual(ord(chr(0x10FFFF)), 0x10FFFF)

self.assertEqual(chr(0x00010000), "\U00010000")

self.assertEqual(chr(0x00010001), "\U00010001")

self.assertEqual(chr(0x000FFFFE), "\U000FFFFE")

self.assertEqual(chr(0x000FFFFF), "\U000FFFFF")

self.assertEqual(chr(0x00100000), "\U00100000")

self.assertEqual(chr(0x00100001), "\U00100001")

self.assertEqual(chr(0x0010FFFE), "\U0010FFFE")

self.assertEqual(chr(0x0010FFFF), "\U0010FFFF")

def test_compile(self):

compile('print(1)\n', '', 'exec')

bom = b'\xef\xbb\xbf'

compile(bom + b'print(1)\n', '', 'exec')

compile(source='pass', filename='?', mode='exec')

compile(dont_inherit=0, filename='tmp', source='0', mode='eval')

compile('pass', '?', dont_inherit=1, mode='exec')

# Fails on Py2.7:

# Was: compile(memoryview(b"text"), "name", "exec")

self.assertRaises(TypeError, compile)

self.assertRaises(ValueError, compile, 'print(42)\n', '<string>', 'badmode')

self.assertRaises(ValueError, compile, 'print(42)\n', '<string>', 'single', 0xff)

# Raises TypeError in Python < v3.5, ValueError in v3.5:

self.assertRaises((TypeError, ValueError), compile, chr(0), 'f', 'exec')

self.assertRaises(TypeError, compile, 'pass', '?', 'exec',

mode='eval', source='0', filename='tmp')

compile('print("\xe5")\n', '', 'exec')

self.assertRaises(ValueError, compile, str('a = 1'), 'f', 'bad')

# test the optimize argument

# These tests fail on Py2.7 ...

# codestr = '''def f():

# """doc"""

# try:

# assert False

# except AssertionError:

# return (True, f.__doc__)

# else:

# return (False, f.__doc__)

# '''

# def f(): """doc"""

# values = [(-1, __debug__, f.__doc__),

# (0, True, 'doc'),

# (1, False, 'doc'),

# (2, False, None)]

# for optval, debugval, docstring in values:

# # test both direct compilation and compilation via AST

# codeobjs = []

# codeobjs.append(compile(codestr, "<test>", "exec", optimize=optval))

# tree = ast.parse(codestr)

# codeobjs.append(compile(tree, "<test>", "exec", optimize=optval))

# for code in codeobjs:

# ns = {}

# exec_(code, ns)

# rv = ns['f']()

# self.assertEqual(rv, (debugval, docstring))

def test_delattr(self):

sys.spam = 1

delattr(sys, 'spam')

self.assertRaises(TypeError, delattr)

def test_dir(self):

# dir(wrong number of arguments)

self.assertRaises(TypeError, dir, 42, 42)

# dir() - local scope

local_var = 1

self.assertIn('local_var', dir())

# dir(module)

self.assertIn('exit', dir(sys))

# dir(module_with_invalid__dict__)

class Foo(types.ModuleType):

__dict__ = 8

f = Foo(native_str("foo"))

self.assertRaises(TypeError, dir, f)

# dir(type)

self.assertIn("strip", dir(str))

self.assertNotIn("__mro__", dir(str))

# dir(obj)

class Foo(object):

def __init__(self):

self.x = 7

self.y = 8

self.z = 9

f = Foo()

self.assertIn("y", dir(f))

# dir(obj_no__dict__)

class Foo(object):

__slots__ = []

f = Foo()

self.assertIn("__repr__", dir(f))

# dir(obj_no__class__with__dict__)

# (an ugly trick to cause getattr(f, "__class__") to fail)

class Foo(object):

__slots__ = ["__class__", "__dict__"]

def __init__(self):

self.bar = "wow"

f = Foo()

self.assertNotIn("__repr__", dir(f))

self.assertIn("bar", dir(f))

# dir(obj_using __dir__)

class Foo(object):

def __dir__(self):

return ["kan", "ga", "roo"]

f = Foo()

self.assertTrue(dir(f) == ["ga", "kan", "roo"])

# dir(obj__dir__tuple)

# Was:

# class Foo(object):

# def __dir__(self):

# return ("b", "c", "a")

# res = dir(Foo())

# self.assertIsInstance(res, list)

# self.assertTrue(res == ["a", "b", "c"])

# dir(obj__dir__not_sequence)

class Foo(object):

def __dir__(self):

return 7

f = Foo()

self.assertRaises(TypeError, dir, f)

# These tests fail on Py2:

# # dir(traceback)

# try:

# raise IndexError

# except:

# self.assertEqual(len(dir(sys.exc_info()[2])), 4)

#

# # test that object has a __dir__()

# self.assertEqual(sorted([].__dir__()), dir([]))

def test_divmod(self):

self.assertEqual(divmod(12, 7), (1, 5))

self.assertEqual(divmod(-12, 7), (-2, 2))

self.assertEqual(divmod(12, -7), (-2, -2))

self.assertEqual(divmod(-12, -7), (1, -5))

self.assertEqual(divmod(-sys.maxsize-1, -1), (sys.maxsize+1, 0))

for num, denom, exp_result in [ (3.25, 1.0, (3.0, 0.25)),

(-3.25, 1.0, (-4.0, 0.75)),

(3.25, -1.0, (-4.0, -0.75)),

(-3.25, -1.0, (3.0, -0.25))]:

result = divmod(num, denom)

self.assertAlmostEqual(result[0], exp_result[0])

self.assertAlmostEqual(result[1], exp_result[1])

self.assertRaises(TypeError, divmod)

def test_eval(self):

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)

globals = {'a': 1, 'b': 2}

locals = {'b': 200, 'c': 300}

bom = b'\xef\xbb\xbf'

self.assertEqual(eval(bom + b'a', globals, locals), 1)

self.assertEqual(eval('"\xe5"', globals), "\xe5")

self.assertRaises(TypeError, eval)

self.assertRaises(TypeError, eval, ())

self.assertRaises(SyntaxError, eval, bom[:2] + b'a')

def test_general_eval(self):

# Tests that general mappings can be used for the locals argument

class M:

"Test mapping interface versus possible calls from eval()."

def __getitem__(self, key):

if key == 'a':

return 12

raise KeyError

def keys(self):

return list('xyz')

m = M()

g = globals()

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)

class A:

"Non-mapping"

pass

m = A()

self.assertRaises(TypeError, eval, 'a', g, m)

# Verify that dict subclasses work as well

class D(dict):

def __getitem__(self, key):

if key == 'a':

return 12

return dict.__getitem__(self, key)

def keys(self):

return list('xyz')

d = D()

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)

if PY3:

from collections import UserDict

else:

from UserDict import UserDict

eval('[locals() for i in (2,3)]', g, UserDict())

class SpreadSheet:

"Sample application showing nested, calculated lookups."

_cells = {}

def __setitem__(self, key, formula):

self._cells[key] = formula

def __getitem__(self, key):

return eval(self._cells[key], globals(), self)

ss = SpreadSheet()

ss['a1'] = '5'

ss['a2'] = 'a1*6'

ss['a3'] = 'a2*7'

self.assertEqual(ss['a3'], 210)

# Verify that dir() catches a non-list returned by eval

# SF bug #1004669

class C:

def __getitem__(self, item):

raise KeyError(item)

def keys(self):

return 1 # used to be 'a' but that's no longer an error

self.assertRaises(TypeError, eval, 'dir()', globals(), C())

def test_exec_(self):

g = {}

exec_('z = 1', g)

if '__builtins__' in g:

del g['__builtins__']

self.assertEqual(g, {'z': 1})

exec_('z = 1+1', g)

if '__builtins__' in g:

del g['__builtins__']

self.assertEqual(g, {'z': 2})

g = {}

l = {}

with check_warnings():

warnings.filterwarnings("ignore", "global statement",

module="<string>")

exec_('global a; a = 1; b = 2', g, l)

if '__builtins__' in g:

del g['__builtins__']

if '__builtins__' in l:

del l['__builtins__']

self.assertEqual((g, l), ({'a': 1}, {'b': 2}))

def test_exec_globals(self):

code = compile("print('Hello World!')", "", "exec")

# no builtin function

# Was:

# self.assertRaisesRegex(NameError, "name 'print' is not defined",

# exec_, code, {'__builtins__': {}})

# Now:

self.assertRaises(NameError,

exec_, code, {'__builtins__': {}})

# __builtins__ must be a mapping type

# Was:

# self.assertRaises(TypeError,

# exec_, code, {'__builtins__': 123})

# Raises a NameError again on Py2

# no __build_class__ function

code = compile("class A: pass", "", "exec")

# Was:

# self.assertRaisesRegex(NameError, "__build_class__ not found",

# exec_, code, {'__builtins__': {}})

self.assertRaises(NameError,

exec_, code, {'__builtins__': {}})

class frozendict_error(Exception):

pass

class frozendict(dict):

def __setitem__(self, key, value):

raise frozendict_error("frozendict is readonly")

# This test seems to fail with "TypeError: 'module' object is not iterable":

# # read-only builtins

# frozen_builtins = frozendict(__builtins__)

# code = compile("__builtins__['superglobal']=2; print(superglobal)", "test", "exec")

# self.assertRaises(frozendict_error,

# exec_, code, {'__builtins__': frozen_builtins})

# read-only globals

namespace = frozendict({})

code = compile("x=1", "test", "exec")

self.assertRaises(frozendict_error,

exec_, code, namespace)

def test_exec_redirected(self):

savestdout = sys.stdout

sys.stdout = None # Whatever that cannot flush()

try:

# Used to raise SystemError('error return without exception set')

exec_('a')

except NameError:

pass

finally:

sys.stdout = savestdout

def test_filter(self):

self.assertEqual(list(filter(lambda c: 'a' <= c <= 'z', 'Hello World')), list('elloorld'))

self.assertEqual(list(filter(None, [1, 'hello', [], [3], '', None, 9, 0])), [1, 'hello', [3], 9])

self.assertEqual(list(filter(lambda x: x > 0, [1, -3, 9, 0, 2])), [1, 9, 2])

self.assertEqual(list(filter(None, Squares(10))), [1, 4, 9, 16, 25, 36, 49, 64, 81])

self.assertEqual(list(filter(lambda x: x%2, Squares(10))), [1, 9, 25, 49, 81])

def identity(item):

return 1

filter(identity, Squares(5))

self.assertRaises(TypeError, filter)

class BadSeq(object):

def __getitem__(self, index):

if index<4:

return 42

raise ValueError

self.assertRaises(ValueError, list, filter(lambda x: x, BadSeq()))

def badfunc():

pass

self.assertRaises(TypeError, list, filter(badfunc, range(5)))

# test bltinmodule.c::filtertuple()

self.assertEqual(list(filter(None, (1, 2))), [1, 2])

self.assertEqual(list(filter(lambda x: x>=3, (1, 2, 3, 4))), [3, 4])

self.assertRaises(TypeError, list, filter(42, (1, 2)))

@expectedFailurePY2

def test_filter_pickle(self):

f1 = filter(filter_char, "abcdeabcde")

f2 = filter(filter_char, "abcdeabcde")

self.check_iter_pickle(f1, list(f2))

def test_getattr(self):

self.assertTrue(getattr(sys, 'stdout') is sys.stdout)

self.assertRaises(TypeError, getattr, sys, 1)

self.assertRaises(TypeError, getattr, sys, 1, "foo")

self.assertRaises(TypeError, getattr)

# These tests fail on Py2:

# self.assertRaises(AttributeError, getattr, sys, chr(sys.maxunicode))

# unicode surrogates are not encodable to the default encoding (utf8)

# self.assertRaises(AttributeError, getattr, 1, "\uDAD1\uD51E")

# This test fails on Py2

def test_hasattr(self):

self.assertTrue(hasattr(sys, 'stdout'))

self.assertRaises(TypeError, hasattr, sys, 1)

self.assertRaises(TypeError, hasattr)

# Fails on Py2:

# self.assertEqual(False, hasattr(sys, chr(sys.maxunicode)))

# Check that hasattr propagates all exceptions outside of

# AttributeError.

class A(object):

def __getattr__(self, what):

raise SystemExit

self.assertRaises(SystemExit, hasattr, A(), "b")

class B(object):

def __getattr__(self, what):

raise ValueError

# Was: self.assertRaises(ValueError, hasattr, B(), "b")

# Fails on Py2

def test_hash(self):

hash(None)

self.assertEqual(hash(1), hash(1))

self.assertEqual(hash(1), hash(1.0))

hash('spam')

self.assertEqual(hash('spam'), hash(b'spam'))

hash((0,1,2,3))

def f(): pass

self.assertRaises(TypeError, hash, [])

self.assertRaises(TypeError, hash, {})

# Bug 1536021: Allow hash to return long objects

class X:

def __hash__(self):

return 2**100

self.assertTrue(isinstance(hash(X()), int))

class Z(int):

def __hash__(self):

return self

self.assertEqual(hash(Z(42)), hash(42))

def test_hex(self):

self.assertEqual(hex(16), '0x10')

self.assertEqual(hex(-16), '-0x10')

self.assertRaises(TypeError, hex, {})

def test_id(self):

id(None)

id(1)

id(1.0)

id('spam')

id((0,1,2,3))

id([0,1,2,3])

id({'spam': 1, 'eggs': 2, 'ham': 3})

# Test input() later, alphabetized as if it were raw_input

def test_iter(self):

self.assertRaises(TypeError, iter)

self.assertRaises(TypeError, iter, 42, 42)

lists = [("1", "2"), ["1", "2"], "12"]

for l in lists:

i = iter(l)

self.assertEqual(next(i), '1')

self.assertEqual(next(i), '2')

self.assertRaises(StopIteration, next, i)

def test_isinstance(self):

class C:

pass

class D(C):

pass

class E:

pass

c = C()

d = D()

e = E()

self.assertTrue(isinstance(c, C))

self.assertTrue(isinstance(d, C))

self.assertTrue(not isinstance(e, C))

self.assertTrue(not isinstance(c, D))

self.assertTrue(not isinstance('foo', E))

self.assertRaises(TypeError, isinstance, E, 'foo')

self.assertRaises(TypeError, isinstance)

def test_issubclass(self):

class C:

pass

class D(C):

pass

class E:

pass

c = C()

d = D()

e = E()

self.assertTrue(issubclass(D, C))

self.assertTrue(issubclass(C, C))

self.assertTrue(not issubclass(C, D))

self.assertRaises(TypeError, issubclass, 'foo', E)

self.assertRaises(TypeError, issubclass, E, 'foo')

self.assertRaises(TypeError, issubclass)

def test_len(self):

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)

class BadSeq:

def __len__(self):

raise ValueError

self.assertRaises(ValueError, len, BadSeq())

class InvalidLen:

def __len__(self):

return None

self.assertRaises(TypeError, len, InvalidLen())

class FloatLen:

def __len__(self):

return 4.5

self.assertRaises(TypeError, len, FloatLen())

class HugeLen:

def __len__(self):

return sys.maxsize + 1

# Was: self.assertRaises(OverflowError, len, HugeLen())

class NoLenMethod(object): pass

self.assertRaises(TypeError, len, NoLenMethod())