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_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_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_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 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_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_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_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_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_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_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_augmented_attribute_assignment(self): suite = Suite("d['k'] += 42") d = {"k": 1} suite.execute({"d": d}) self.assertEqual(43, d["k"])