def test_if(self):
suite = Suite("""if foo == 42:
x = True
""")
data = {'foo': 42}
suite.execute(data)
self.assertEqual(True, data['x'])
def test_return(self):
suite = Suite("""
def f():
return v
assert f() == 42
""")
suite.execute({"v": 42})
def test_assign_to_attribute(self):
class Something(object): pass
something = Something()
suite = Suite("obj.attr = 'foo'")
data = {"obj": something}
suite.execute(data)
self.assertEqual('foo', something.attr)
def test_delete(self):
suite = Suite("""foo = 42
del foo
""")
data = {}
suite.execute(data)
assert 'foo' not in data
def test_class_with_methods(self):
suite = Suite("""class plain(object):
def donothing():
pass
""")
data = {}
suite.execute(data)
assert 'plain' in data
def test_if(self):
suite = Suite("""if foo == 42:
x = True
""")
data = {'foo': 42}
suite.execute(data)
self.assertEqual(True, data['x'])
def test_assign_to_attribute(self):
class Something(object): pass
something = Something()
suite = Suite("obj.attr = 'foo'")
data = {"obj": something}
suite.execute(data)
self.assertEqual('foo', something.attr)
def test_slice_call(self):
def f():
return 2
suite = Suite("x = numbers[f()]")
data = {"numbers": [0, 1, 2, 3, 4], "f": f}
suite.execute(data)
self.assertEqual(2, data["x"])
def test_delete(self):
suite = Suite("""foo = 42
del foo
""")
data = {}
suite.execute(data)
assert 'foo' not in data
def test_class_with_methods(self):
suite = Suite("""class plain(object):
def donothing():
pass
""")
data = {}
suite.execute(data)
assert 'plain' in data
def test_return(self):
suite = Suite("""
def f():
return v
assert f() == 42
""")
suite.execute({"v": 42})
def test_slice_attribute(self):
class ValueHolder:
def __init__(self):
self.value = 3
suite = Suite("x = numbers[obj.value]")
data = {"numbers": [0, 1, 2, 3, 4], "obj": ValueHolder()}
suite.execute(data)
self.assertEqual(3, data["x"])
def test_for(self):
suite = Suite("""x = []
for i in range(3):
x.append(i**2)
""")
data = {}
suite.execute(data)
self.assertEqual([0, 1, 4], data['x'])
def test_for(self):
suite = Suite("""x = []
for i in range(3):
x.append(i**2)
""")
data = {}
suite.execute(data)
self.assertEqual([0, 1, 4], data['x'])
def test_def_kwonlyarg(self):
suite = Suite("""
def kwonly(*args, k):
return k
x = kwonly(k="foo")
""")
data = {}
suite.execute(data)
self.assertEqual("foo", data['x'])
def test_def_kwargs(self):
suite = Suite("""
def smash(**kw):
return [''.join(i) for i in kw.items()]
x = smash(foo='abc', bar='def')
""")
data = {}
suite.execute(data)
self.assertEqual(['bardef', 'fooabc'], sorted(data['x']))
def test_import_in_def(self):
suite = Suite("""def fun():
from itertools import repeat
return repeat(1, 3)
""")
data = Context()
suite.execute(data)
assert 'repeat' not in data
self.assertEqual([1, 1, 1], list(data['fun']()))
def test_import_in_def(self):
suite = Suite("""def fun():
from itertools import repeat
return repeat(1, 3)
""")
data = Context()
suite.execute(data)
assert 'repeat' not in data
self.assertEqual([1, 1, 1], list(data['fun']()))
def test_import_in_def(self):
suite = Suite("""def fun():
from itertools import ifilter
return ifilter(None, range(3))
""")
data = Context()
suite.execute(data)
assert 'ifilter' not in data
self.assertEqual([1, 2], list(data['fun']()))
def test_def_kwargs(self):
suite = Suite("""
def smash(**kw):
return [''.join(i) for i in kw.items()]
x = smash(foo='abc', bar='def')
""")
data = {}
suite.execute(data)
self.assertEqual(['fooabc', 'bardef'], data['x'])
def test_import_in_def(self):
suite = Suite("""def fun():
from itertools import ifilter
return ifilter(None, range(3))
""")
data = Context()
suite.execute(data)
assert 'ifilter' not in data
self.assertEqual([1, 2], list(data['fun']()))
def test_finally(self):
suite = Suite("""try:
x = 2
finally:
x = None
""")
data = {}
suite.execute(data)
self.assertEqual(None, data['x'])
def test_finally(self):
suite = Suite("""try:
x = 2
finally:
x = None
""")
data = {}
suite.execute(data)
self.assertEqual(None, data['x'])
def test_def_with_multiple_statements(self):
suite = Suite("""
def donothing():
if True:
return foo
""")
data = {'foo': 'bar'}
suite.execute(data)
assert 'donothing' in data
self.assertEqual('bar', data['donothing']())
def test_try_except(self):
suite = Suite("""try:
import somemod
except ImportError:
somemod = None
else:
somemod.dosth()""")
data = {}
suite.execute(data)
self.assertEqual(None, data['somemod'])
def test_while_break(self):
suite = Suite("""x = 0
while x < 5:
x += step
if x == 4:
break
""")
data = {'step': 2}
suite.execute(data)
self.assertEqual(4, data['x'])
def test_while_break(self):
suite = Suite("""x = 0
while x < 5:
x += step
if x == 4:
break
""")
data = {'step': 2}
suite.execute(data)
self.assertEqual(4, data['x'])
def test_try_except(self):
suite = Suite("""try:
import somemod
except ImportError:
somemod = None
else:
somemod.dosth()""")
data = {}
suite.execute(data)
self.assertEqual(None, data['somemod'])
def test_def_with_multiple_statements(self):
suite = Suite("""
def donothing():
if True:
return foo
""")
data = {'foo': 'bar'}
suite.execute(data)
assert 'donothing' in data
self.assertEqual('bar', data['donothing']())
def test_for_in_def(self):
suite = Suite("""def loop():
for i in range(10):
if i == 5:
break
return i
""")
data = {}
suite.execute(data)
assert 'loop' in data
self.assertEqual(5, data['loop']())
def test_for_in_def(self):
suite = Suite("""def loop():
for i in range(10):
if i == 5:
break
return i
""")
data = {}
suite.execute(data)
assert 'loop' in data
self.assertEqual(5, data['loop']())
def test_def_some_defaults(self):
suite = Suite("""
def difference(v1, v2=10):
return v1 - v2
x = difference(20, 19)
y = difference(20)
""")
data = {}
suite.execute(data)
self.assertEqual(1, data['x'])
self.assertEqual(10, data['y'])
def test_def_kwonlyarg_with_default(self):
suite = Suite("""
def kwonly(*args, k="bar"):
return k
x = kwonly(k="foo")
y = kwonly()
""")
data = {}
suite.execute(data)
self.assertEqual("foo", data['x'])
self.assertEqual("bar", data['y'])
def test_def_some_defaults(self):
suite = Suite("""
def difference(v1, v2=10):
return v1 - v2
x = difference(20, 19)
y = difference(20)
""")
data = {}
suite.execute(data)
self.assertEqual(1, data['x'])
self.assertEqual(10, data['y'])
def test_class_in_def(self):
suite = Suite("""
def create():
class Foobar(object):
def __str__(self):
return 'foobar'
return Foobar()
x = create()
""")
data = {}
suite.execute(data)
self.assertEqual('foobar', str(data['x']))
def test_internal_shadowing(self):
# The context itself is stored in the global execution scope of a suite
# It used to get stored under the name 'data', which meant the
# following test would fail, as the user defined 'data' variable
# shadowed the Genshi one. We now use the name '__data__' to avoid
# conflicts
suite = Suite("""data = []
bar = foo
""")
data = {'foo': 42}
suite.execute(data)
self.assertEqual(42, data['bar'])
def test_def_using_nonlocal(self):
suite = Suite("""
values = []
def add(value):
if value not in values:
values.append(value)
add('foo')
add('bar')
""")
data = {}
suite.execute(data)
self.assertEqual(['foo', 'bar'], data['values'])
def test_def_vararg(self):
suite = Suite("""
def mysum(*others):
rv = 0
for n in others:
rv = rv + n
return rv
x = mysum(1, 2, 3)
""")
data = {}
suite.execute(data)
self.assertEqual(6, data['x'])
def test_def_vararg(self):
suite = Suite("""
def mysum(*others):
rv = 0
for n in others:
rv = rv + n
return rv
x = mysum(1, 2, 3)
""")
data = {}
suite.execute(data)
self.assertEqual(6, data['x'])
def test_def_using_nonlocal(self):
suite = Suite("""
values = []
def add(value):
if value not in values:
values.append(value)
add('foo')
add('bar')
""")
data = {}
suite.execute(data)
self.assertEqual(['foo', 'bar'], data['values'])
def test_internal_shadowing(self):
# The context itself is stored in the global execution scope of a suite
# It used to get stored under the name 'data', which meant the
# following test would fail, as the user defined 'data' variable
# shadowed the Genshi one. We now use the name '__data__' to avoid
# conflicts
suite = Suite("""data = []
bar = foo
""")
data = {'foo': 42}
suite.execute(data)
self.assertEqual(42, data['bar'])
def test_class_in_def(self):
suite = Suite("""
def create():
class Foobar(object):
def __str__(self):
return 'foobar'
return Foobar()
x = create()
""")
data = {}
suite.execute(data)
self.assertEqual('foobar', str(data['x']))
def test_def_with_decorator(self):
suite = Suite("""
def lower(fun):
return lambda: fun().lower()
@lower
def say_hi():
return 'Hi!'
result = say_hi()
""")
data = {}
suite.execute(data)
self.assertEqual('hi!', data['result'])
def test_def_with_decorator(self):
suite = Suite("""
def lower(fun):
return lambda: fun().lower()
@lower
def say_hi():
return 'Hi!'
result = say_hi()
""")
data = {}
suite.execute(data)
self.assertEqual('hi!', data['result'])
def test_def_nested(self):
suite = Suite("""
def doit():
values = []
def add(value):
if value not in values:
values.append(value)
add('foo')
add('bar')
return values
x = doit()
""")
data = {}
suite.execute(data)
self.assertEqual(['foo', 'bar'], data['x'])
def test_def_nested(self):
suite = Suite("""
def doit():
values = []
def add(value):
if value not in values:
values.append(value)
add('foo')
add('bar')
return values
x = doit()
""")
data = {}
suite.execute(data)
self.assertEqual(['foo', 'bar'], data['x'])
def test_yield_expression(self):
d = {}
suite = Suite("""results = []
def counter(maximum):
i = 0
while i < maximum:
val = (yield i)
if val is not None:
i = val
else:
i += 1
it = counter(5)
results.append(it.next())
results.append(it.send(3))
results.append(it.next())
""")
suite.execute(d)
self.assertEqual([0, 3, 4], d['results'])
def test_yield_expression(self):
d = {}
suite = Suite("""results = []
def counter(maximum):
i = 0
while i < maximum:
val = (yield i)
if val is not None:
i = val
else:
i += 1
it = counter(5)
results.append(it.next())
results.append(it.send(3))
results.append(it.next())
""")
suite.execute(d)
self.assertEqual([0, 3, 4], d['results'])
def test_with_statement(self):
fd, path = mkstemp()
f = os.fdopen(fd, "w")
try:
f.write('foo\nbar\n')
f.seek(0)
f.close()
d = {'path': path}
suite = Suite("""from __future__ import with_statement
lines = []
with open(path) as file:
for line in file:
lines.append(line)
""")
suite.execute(d)
self.assertEqual(['foo\n', 'bar\n'], d['lines'])
finally:
os.remove(path)
def test_with_statement(self):
fd, path = mkstemp()
f = os.fdopen(fd, "w")
try:
f.write('foo\nbar\n')
f.seek(0)
f.close()
d = {'path': path}
suite = Suite("""from __future__ import with_statement
lines = []
with open(path) as file:
for line in file:
lines.append(line)
""")
suite.execute(d)
self.assertEqual(['foo\n', 'bar\n'], d['lines'])
finally:
os.remove(path)
def test_exec(self):
suite = Suite("x = 1; exec d['k']; assert x == 42, x")
suite.execute({"d": {"k": "x = 42"}})
def test_assign_in_list(self):
suite = Suite("[d['k']] = 'foo',; assert d['k'] == 'foo'")
d = {"k": "bar"}
suite.execute({"d": d})
self.assertEqual("foo", d["k"])
def test_assign_to_dict_item(self):
suite = Suite("d['k'] = 'foo'")
data = {'d': {}}
suite.execute(data)
self.assertEqual('foo', data['d']['k'])
def test_class(self):
suite = Suite("class plain(object): pass")
data = {}
suite.execute(data)
assert 'plain' in data
def test_import(self):
suite = Suite("from itertools import ifilter")
data = {}
suite.execute(data)
assert 'ifilter' in data
def test_import_star(self):
suite = Suite("from itertools import *")
data = Context()
suite.execute(data)
assert 'ifilter' in data
def test_assign_in_list(self):
suite = Suite("[d['k']] = 'foo',; assert d['k'] == 'foo'")
d = {"k": "bar"}
suite.execute({"d": d})
self.assertEqual("foo", d["k"])
def test_augmented_attribute_assignment(self):
suite = Suite("d['k'] += 42")
d = {"k": 1}
suite.execute({"d": d})
self.assertEqual(43, d["k"])
def test_assign_to_dict_item(self):
suite = Suite("d['k'] = 'foo'")
data = {'d': {}}
suite.execute(data)
self.assertEqual('foo', data['d']['k'])
def test_exec(self):
suite = Suite("x = 1; exec d['k']; assert x == 42, x")
suite.execute({"d": {"k": "x = 42"}})
