def test_choice(): p = choice(partial(int, 15.5), (15, 4), (3, 2)) assert evaluate(p) == 4 p = choice(variable('x', value_type=['a', 'b', 'c']), ('a', 'b'), ('b', 'c')) assert evaluate(p, x='a') == 'b' assert evaluate(p, x='b') == 'c'
def test_pyll_deeply_nested_func(): # N.B. uses stuff that isn't in the SymbolTable yet, must remove. try: def my_add(x, y): return x + y x = as_partialplus( (partial(float, partial(my_add, 0, partial(int, 3.3))) / 2, partial(float, 3)) ) y = as_pyll(x) evaluate(x) == rec_eval(y) finally: scope.undefine(my_add)
def test_lazy_index_range(): """ Test that lazy evaluation of indexing works with range lookups. """ def dont_eval(): # -- This function body should never be evaluated # because we only need the 0'th element of `plist` assert 0, 'Evaluate does not need this, should not eval' plist = as_pp([-1, 0, 1, partial(dont_eval)]) assert [-1, 0, 1] == evaluate(plist[:3]) plist = as_pp((-1, 0, 1, partial(dont_eval))) assert (-1, 0, 1) == evaluate(plist[:3])
def test_pyll_list_tuple_nested(): x = as_partialplus([[5, 3, (5, 3)], (4, 5)]) y = as_pyll(x) # rec_eval always uses tuple val_y = rec_eval(y) # Correct for tuple-only in rec_eval. assert evaluate(x) == [list(val_y[0]), val_y[1]]
def test_dict(): """Test that dicts are correctly traversed/converted.""" def mod(x, y): return x % y x = as_pp({5: partial(mod, 5, 3), 3: (7, 9), 4: [partial(mod, 9, 4)]}) y = evaluate(x) assert y == {5: 2, 3: (7, 9), 4: [1]}
def test_dict(): x = as_partialplus({'x': partial(float, partial(float, partial(int, 3.3))) / 2, 'y': partial(float, 3) }) y = as_pyll(x) assert evaluate(x) == rec_eval(y)
def test_switch_ordered_dict(): """Test that lazy evaluation works with OrderedDicts.""" def dont_eval(): # -- This function body should never be evaluated # because we only need the 0'th element of `plist` assert 0, 'Evaluate does not need this, should not eval' r = evaluate(as_pp(OrderedDict({'a': partial(dont_eval), 'b': 3}))['b']) assert r == 3
def test_list(): """Test that lists are correctly traversed/converted.""" def sub(x, y): return x - y x = as_pp([[3, partial(sub, 2, 3)], partial(sub, 5, 7), partial(float, 9)]) y = evaluate(x) assert y == [[3, -1], -2, 9.0] assert isinstance(y[2], float)
def test_tuple(): """Test that tuples are correctly traversed/converted.""" def add(x, y): return x + y x = as_pp(((3, partial(add, 2, 3)), partial(add, 5, 7), partial(float, 9))) y = evaluate(x) assert y == ((3, 5), 12, 9.0) assert isinstance(y[2], float)
def test_variable_substitution(): """Test that variable substitution works correctly.""" x = variable(name='x', value_type=int) y = variable(name='y', value_type=float) p = as_pp({3: x, x: [y, [y]], y: 4}) # Currently no type-checking. This will fail when we add it and need to be # updated. e = evaluate(p, x='hey', y=5) assert e[3] == 'hey' assert e['hey'] == [5, [5]] assert e[5] == 4
def test_lazy_index_dict(): """ Test that lazy evaluation of indexing works with dict lookups. """ def dont_eval(): # -- This function body should never be evaluated # because we only need the 0'th element of `plist` assert 0, 'Evaluate does not need this, should not eval' r = evaluate(as_pp({'a': partial(dont_eval), 'b': 3})['b']) assert r == 3
def test_two_objects(): """ Test that identical expression in different parts of graph evaluates to an identical object. """ class Foo(object): pass p = partial(Foo) q = as_pp([p, [0, 1, p], [(p, )]]) r = evaluate(q) assert r[0] is r[1][-1] assert r[0] is r[2][0][0]
def test_lazy_index_tuple(): """ Test that lazy evaluation of indexing works with element lookups on lists. """ def dont_eval(): # -- This function body should never be evaluated # because we only need the 0'th element of `plist` assert 0, 'Evaluate does not need this, should not eval' # TODO: James: I opted for this behaviour rather than list(f, el1, el2...) # is there a compelling reason to do that? It kind of breaks with the # model. plist = as_pp((-1, partial(dont_eval))) assert -1 == evaluate(plist[0])
def check(a, b): assert evaluate(as_pp(partial(int, a)) + as_pp(partial(int, b))) == a + b assert evaluate(as_pp(partial(int, a)) - as_pp(partial(int, b))) == a - b assert evaluate(as_pp(partial(int, a)) * as_pp(partial(int, b))) == a * b assert evaluate(as_pp(partial(int, a)) / as_pp(partial(int, b))) == a / b assert evaluate(as_pp(partial(int, a)) % as_pp(partial(int, b))) == a % b assert evaluate(as_pp(partial(int, a)) | as_pp(partial(int, b))) == a | b assert evaluate(as_pp(partial(int, a)) ^ as_pp(partial(int, b))) == a ^ b assert evaluate(as_pp(partial(int, a)) & as_pp(partial(int, b))) == a & b
def test_pyll_tuple(): x = as_partialplus((6, 9, 4)) y = as_pyll(x) assert evaluate(x) == rec_eval(y)
def test_pyll_func(): # N.B. Only uses stuff that's already in the SymbolTable. x = partial(float, 5) y = as_pyll(x) assert evaluate(x) == rec_eval(y)
def test_pyll_nested_func(): x = partial(float, partial(int, 5.5)) y = as_pyll(x) assert evaluate(x) == rec_eval(y)
def test_pyll_list(): x = as_partialplus([5, 3, 9]) y = as_pyll(x) # rec_eval always uses tuple assert evaluate(x) == list(rec_eval(y))
def test_getitem_dict(): """Test that indexing works on a PartialPlus'd dict.""" v = evaluate(as_pp({'a': partial(float, '3'), 'b': 3})['a']) assert v == 3.0