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(br'\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(br'\u0663\u0661\u0664 ','raw-unicode-escape'), 314),

(chr(0x200), ValueError),

# Helper to check picklability

def check_iter_pickle(self, it, seq, proto):

itorg = it

d = pickle.dumps(it, proto)

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, proto)

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(ModuleNotFoundError, __import__, 'spamspam')

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

self.assertRaises(ValueError, __import__, '')

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

# Relative import outside of a package with no __package__ or __spec__ (bpo-37409).

with self.assertWarns(ImportWarning):

self.assertRaises(ImportError, __import__, '',

{'__package__': None, '__spec__': None, '__name__': '__main__'},

locals={}, fromlist=('foo',), level=1)

# embedded null character

self.assertRaises(ModuleNotFoundError, __import__, 'string\x00')

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)

S = [50, 40, 60, TestFailingBool()]

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 = [40, 60, 30, TestFailingBool()]

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_all_any_tuple_list_set_optimization(self):

def f_all():

return all(x-2 for x in [1,2,3])

def f_any():

return any(x-1 for x in [1,2,3])

def f_tuple():

return tuple(2*x for x in [1,2,3])

def f_list():

return list(2*x for x in [1,2,3])

def f_set():

return set(2*x for x in [1,2,3])

def f_frozenset():

return frozenset(2*x for x in [1,2,3])

funcs = [f_all, f_any, f_tuple, f_list, f_set, f_frozenset]

for f in funcs:

# check that generator code object is not duplicated

code_objs = [c for c in f.__code__.co_consts if isinstance(c, type(f.__code__))]

self.assertEqual(len(code_objs), 1)

# check the overriding the builtins works

global all, any, tuple, list, set, frozenset

saved = all, any, tuple, list, set, frozenset

try:

all = lambda x : "all"

any = lambda x : "any"

tuple = lambda x : "tuple"

list = lambda x : "list"

set = lambda x : "set"

frozenset = lambda x : "frozenset"

overridden_outputs = [f() for f in funcs]

finally:

all, any, tuple, list, set, frozenset = saved

self.assertEqual(overridden_outputs, ['all', 'any', 'tuple', 'list', 'set', 'frozenset'])

# Now repeat, overriding the builtins module as well

saved = all, any, tuple, list, set, frozenset

try:

builtins.all = all = lambda x : "all"

builtins.any = any = lambda x : "any"

builtins.tuple = tuple = lambda x : "tuple"

builtins.list = list = lambda x : "list"

builtins.set = set = lambda x : "set"

builtins.frozenset = frozenset = lambda x : "frozenset"

overridden_outputs = [f() for f in funcs]

finally:

all, any, tuple, list, set, frozenset = saved

builtins.all, builtins.any, builtins.tuple, builtins.list, builtins.set, builtins.frozenset = saved

self.assertEqual(overridden_outputs, ['all', 'any', 'tuple', 'list', 'set', 'frozenset'])

def test_builtin_call_async_genexpr_no_crash(self):

async def f_all():

return all(await 2 for _ in [])

async def f_any():

return any(await 2 for _ in [])

async def f_tuple():

return tuple(await 2 for _ in [])

async def f_list():

return list(await 2 for _ in [])

async def f_set():

return set(await 2 for _ in [])

for f in (f_all, f_any, f_tuple, f_list, f_set):

with self.subTest(func=f.__name__):

with self.assertRaises(TypeError):

run_yielding_async_fn(f)

def test_ascii(self):

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

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

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:

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(0), '\0')

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

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

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

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

self.assertRaises(TypeError, chr)

self.assertRaises(TypeError, chr, 65.0)

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

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

self.assertRaises(ValueError, chr, -1)

self.assertRaises(ValueError, chr, 0x00110000)

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

self.assertRaises(ValueError, chr, 2**32-1)

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

self.assertRaises(ValueError, chr, 2**1000)

self.assertRaises(ValueError, chr, -2**1000)

def test_cmp(self):

self.assertNotHasAttr(builtins, "cmp")

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=False, filename='tmp', source='0', mode='eval')

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

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)

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

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

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

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

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

# test the optimize argument

codestr = '''def f():

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

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

(0, True, 'doc', True, True),

(1, False, 'doc', False, False),

(2, False, None, False, False)]

for optval, *expected in values:

with self.subTest(optval=optval):

# test both direct compilation and compilation via AST

codeobjs = []

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

tree = ast.parse(codestr, optimize=optval)

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

for code in codeobjs:

ns = {}

exec(code, ns)

rv = ns['f']()

self.assertEqual(rv, tuple(expected))

def test_compile_top_level_await_no_coro(self):

"""Make sure top level non-await codes get the correct coroutine flags"""

modes = ('single', 'exec')

code_samples = [

'''def f():pass\n''',

'''[x for x in l]''',

'''{x for x in l}''',

'''(x for x in l)''',

'''{x:x for x in l}''',

]

for mode, code_sample in product(modes, code_samples):

source = dedent(code_sample)

co = compile(source,

'?',

mode,

flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)

self.assertNotEqual(co.co_flags & CO_COROUTINE, CO_COROUTINE,

msg=f"source={source} mode={mode}")

def test_compile_top_level_await(self):

"""Test whether code with top level await can be compiled.

# helper function just to check we can run top=level async-for

async def arange(n):

for i in range(n):

yield i

class Lock:

async def __aenter__(self):

return self

async def __aexit__(self, *exc_info):

pass

async def sleep(delay, result=None):

assert delay == 0

await async_yield(None)

return result

modes = ('single', 'exec')

optimizations = (-1, 0, 1, 2)

code_samples = [

'''a = await sleep(0, result=1)''',

'''async for i in arange(1):

a = 1''',

'''async with Lock() as l:

a = 1''',

'''a = [x async for x in arange(2)][1]''',

'''a = 1 in {x async for x in arange(2)}''',

'''a = {x:1 async for x in arange(1)}[0]''',

'''a = [x async for x in arange(2) async for x in arange(2)][1]''',

'''a = [x async for x in (x async for x in arange(5))][1]''',

'''a, = [1 for x in {x async for x in arange(1)}]''',

'''a = [await sleep(0, x) async for x in arange(2)][1]''',

'''a = [await sleep(0, 1) for _ in [0]][0]''',

'''a = {await sleep(0, 1) for _ in [0]}.pop()''',

'''a = {0: await sleep(0, 1) for _ in [0]}[0]''',

'''a = (lambda x=[await sleep(0, 1) for _ in [0]]: x)()[0]''',

# gh-121637: Make sure we correctly handle the case where the

# async code is optimized away

'''assert not await sleep(0); a = 1''',

'''assert [x async for x in arange(1)]; a = 1''',

'''assert {x async for x in arange(1)}; a = 1''',

'''assert {x: x async for x in arange(1)}; a = 1''',

'''

''',

'''

''',

]

for mode, code_sample, optimize in product(modes, code_samples, optimizations):

with self.subTest(mode=mode, code_sample=code_sample, optimize=optimize):

source = dedent(code_sample)

with self.assertRaises(

SyntaxError, msg=f"source={source} mode={mode}"):

compile(source, '?', mode, optimize=optimize)

co = compile(source,

'?',

mode,

flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT,

optimize=optimize)

self.assertEqual(co.co_flags & CO_COROUTINE, CO_COROUTINE,

msg=f"source={source} mode={mode}")

# test we can create and advance a function type

globals_ = {'Lock': Lock, 'a': 0, 'arange': arange, 'sleep': sleep}

run_yielding_async_fn(FunctionType(co, globals_))

self.assertEqual(globals_['a'], 1)

# test we can await-eval,

globals_ = {'Lock': Lock, 'a': 0, 'arange': arange, 'sleep': sleep}

run_yielding_async_fn(lambda: eval(co, globals_))

self.assertEqual(globals_['a'], 1)

def test_compile_top_level_await_invalid_cases(self):

# helper function just to check we can run top=level async-for

async def arange(n):

for i in range(n):

yield i

class Lock:

async def __aenter__(self):

return self

async def __aexit__(self, *exc_info):

pass

modes = ('single', 'exec')

code_samples = [

'''def f(): await arange(10)\n''',

'''def f(): [x async for x in arange(10)]\n''',

'''def f(): [await x async for x in arange(10)]\n''',

'''def f():

''',

'''def f():

''',

'''class C:

''',

'''class C:

''',

'''async def f():

''',

'''lambda: [await x for x in y]''',

'''class C:

''',

'''type T = [await x for x in y]''',

'''async def f[T=[await x for x in y]]():

''',

]

for mode, code_sample in product(modes, code_samples):

source = dedent(code_sample)

with self.assertRaises(

SyntaxError, msg=f"source={source} mode={mode}"):

compile(source, '?', mode)

with self.assertRaises(

SyntaxError, msg=f"source={source} mode={mode}"):

co = compile(source,

'?',

mode,

flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)

def test_compile_async_generator(self):

"""

code = dedent("""async def ticker():

await sleep(0)""")

co = compile(code, '?', 'exec', flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)

glob = {}

exec(co, glob)

self.assertEqual(type(glob['ticker']()), AsyncGeneratorType)

def test_compile_ast(self):

args = ("a*__debug__", "f.py", "exec")

raw = compile(*args, flags = ast.PyCF_ONLY_AST).body[0]

opt1 = compile(*args, flags = ast.PyCF_OPTIMIZED_AST).body[0]

opt2 = compile(ast.parse(args[0]), *args[1:], flags = ast.PyCF_OPTIMIZED_AST).body[0]

for tree in (raw, opt1, opt2):

self.assertIsInstance(tree.value, ast.BinOp)

self.assertIsInstance(tree.value.op, ast.Mult)

self.assertIsInstance(tree.value.left, ast.Name)

self.assertEqual(tree.value.left.id, 'a')

raw_right = raw.value.right

self.assertIsInstance(raw_right, ast.Name)

self.assertEqual(raw_right.id, "__debug__")

for opt in [opt1, opt2]:

opt_right = opt.value.right

self.assertIsInstance(opt_right, ast.Constant)

self.assertEqual(opt_right.value, __debug__)

def test_delattr(self):

sys.spam = 1

delattr(sys, 'spam')

self.assertRaises(TypeError, delattr)

self.assertRaises(TypeError, delattr, sys)

msg = r"^attribute name must be string, not 'int'$"

self.assertRaisesRegex(TypeError, msg, delattr, sys, 1)

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("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)

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

class Foo(object):

def __dir__(self):

return {"b", "c", "a"}

res = dir(Foo())

self.assertIsInstance(res, list)

self.assertEqual(sorted(res), ["a", "b", "c"])

# dir(obj__dir__not_sequence)

class Foo(object):

def __dir__(self):

return 7

f = Foo()

self.assertRaises(TypeError, dir, f)

# dir(traceback)

try:

raise IndexError

except IndexError as e:

self.assertEqual(len(dir(e.__traceback__)), 4)

# test that object has a __dir__()

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

def test___ne__(self):

self.assertFalse(None.__ne__(None))

self.assertIs(None.__ne__(0), NotImplemented)

self.assertIs(None.__ne__("abc"), NotImplemented)

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)

self.assertRaisesRegex(

ZeroDivisionError,

"division by zero",

divmod, 1, 0,

)

self.assertRaisesRegex(

ZeroDivisionError,

"division by zero",

divmod, 0.0, 0,

)

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

class X:

def __getitem__(self, key):

raise ValueError

self.assertRaises(ValueError, eval, "foo", {}, X())

def test_eval_frozendict(self):

ns = frozendict(x=1, data=[], __builtins__=__builtins__)

eval("data.append(x)", ns, ns)

self.assertEqual(ns['data'], [1])

ns = frozendict()

errmsg = "cannot assign __builtins__ to frozendict globals"

with self.assertRaisesRegex(TypeError, errmsg):

eval("", ns, ns)

def test_eval_kwargs(self):

data = {"A_GLOBAL_VALUE": 456}

self.assertEqual(eval("globals()['A_GLOBAL_VALUE']", globals=data), 456)

self.assertEqual(eval("globals()['A_GLOBAL_VALUE']", locals=data), 123)

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)

eval('[locals() for i in (2,3)]', g, collections.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_frozendict(self):

ns = frozendict(x=1, data=[], __builtins__=__builtins__)

exec("data.append(x)", ns, ns)

self.assertEqual(ns['data'], [1])

ns = frozendict(__builtins__=__builtins__)

errmsg = "'frozendict' object does not support item assignment"

with self.assertRaisesRegex(TypeError, errmsg):

exec("x = 1", ns, ns)

ns = frozendict()

errmsg = "cannot assign __builtins__ to frozendict globals"

with self.assertRaisesRegex(TypeError, errmsg):

exec("", ns, ns)

def test_exec_kwargs(self):

g = {}

exec('global z\nz = 1', globals=g)

if '__builtins__' in g:

del g['__builtins__']

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

# if we only set locals, the global assignment will not

# reach this locals dictionary

g = {}

exec('global z\nz = 1', locals=g)

self.assertEqual(g, {})

def test_exec_globals(self):

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

# no builtin function

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

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

# __builtins__ must be a mapping type

self.assertRaises(TypeError,

exec, code, {'__builtins__': 123})

def test_exec_globals_frozen(self):

class frozendict_error(Exception):

pass

class frozendict(dict):

def __setitem__(self, key, value):

raise frozendict_error("frozendict is readonly")

# read-only builtins

if isinstance(__builtins__, types.ModuleType):

frozen_builtins = frozendict(__builtins__.__dict__)

else:

frozen_builtins = frozendict(__builtins__)

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

self.assertRaises(frozendict_error,

exec, code, {'__builtins__': frozen_builtins})

# no __build_class__ function

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