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_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_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_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_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_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
