def test_checking_logical_support(self):
class NoBoolFunction(Function):
operations = set(["equality"])
def equals(self, node): pass
def to_python(self): pass
def check_arguments(self): pass
func1 = PermissiveFunction(String("foo"))
func2 = NoBoolFunction()
# Checking logical support:
func1.check_logical_support()
assert_raises(InvalidOperationError, func2.check_logical_support)
def test_equivalence(self):
"""
Two functions are equivalent not only if they share the same class,
but also if their arguments are equivalent.
"""
class FooFunction(Function):
bypass_operation_check = True
required_arguments = ("abc", )
optional_arguments = {"xyz": String("123")}
def check_arguments(self): pass
func1 = FooFunction(String("whatever"))
func2 = FooFunction(String("whatever"))
func3 = TrafficViolationFunc(String("pedestrians"))
func4 = PermissiveFunction(String("foo"))
func5 = FooFunction(String("something"))
func1.check_equivalence(func2)
func2.check_equivalence(func1)
assert_raises(AssertionError, func1.check_equivalence, func3)
assert_raises(AssertionError, func1.check_equivalence, func4)
assert_raises(AssertionError, func1.check_equivalence, func5)
assert_raises(AssertionError, func2.check_equivalence, func3)
assert_raises(AssertionError, func2.check_equivalence, func4)
assert_raises(AssertionError, func2.check_equivalence, func5)
assert_raises(AssertionError, func3.check_equivalence, func1)
assert_raises(AssertionError, func3.check_equivalence, func2)
assert_raises(AssertionError, func3.check_equivalence, func4)
assert_raises(AssertionError, func3.check_equivalence, func5)
assert_raises(AssertionError, func4.check_equivalence, func1)
assert_raises(AssertionError, func4.check_equivalence, func2)
assert_raises(AssertionError, func4.check_equivalence, func3)
assert_raises(AssertionError, func4.check_equivalence, func5)
assert_raises(AssertionError, func5.check_equivalence, func1)
assert_raises(AssertionError, func5.check_equivalence, func2)
assert_raises(AssertionError, func5.check_equivalence, func3)
assert_raises(AssertionError, func5.check_equivalence, func4)
ok_(func1 == func2)
ok_(func2 == func1)
ok_(func1 != func3)
ok_(func1 != func4)
ok_(func1 != func5)
ok_(func2 != func3)
ok_(func2 != func4)
ok_(func2 != func5)
ok_(func3 != func1)
ok_(func3 != func2)
ok_(func3 != func4)
ok_(func3 != func5)
ok_(func4 != func1)
ok_(func4 != func2)
ok_(func4 != func3)
ok_(func4 != func5)
ok_(func5 != func1)
ok_(func5 != func2)
ok_(func5 != func3)
ok_(func5 != func4)
def test_constructor_with_minimum_arguments(self):
func = PermissiveFunction(String("this-is-arg0"))
args = {
'arg0': String("this-is-arg0"),
'oarg0': Set(),
'oarg1': Number(1),
}
eq_(func.arguments, args)
def test_constructor_with_one_optional_argument(self):
func = PermissiveFunction(String("this-is-arg0"),
String("this-is-oarg0"))
args = {
'arg0': String("this-is-arg0"),
'oarg0': String("this-is-oarg0"),
'oarg1': Number(1),
}
eq_(func.arguments, args)
def test_constructor_with_all_arguments(self):
func = PermissiveFunction(
String("this-is-arg0"),
String("this-is-oarg0"),
String("this-is-oarg1"),
)
args = {
'arg0': String("this-is-arg0"),
'oarg0': String("this-is-oarg0"),
'oarg1': String("this-is-oarg1"),
}
eq_(func.arguments, args)
def test_constructor_with_many_arguments(self):
PermissiveFunction(
Number(0),
Number(1),
Number(2),
Number(3),
Number(4),
Number(5),
Number(6),
Number(7),
Number(8),
Number(9),
)
def test_representation(self):
func = PermissiveFunction(String("foo"), String(u"báz"))
expected = '<Anonymous function call [PermissiveFunction] ' \
'arg0=<String "foo">, oarg0=<String "báz">, ' \
'oarg1=<Number 1.0>>'
eq_(repr(func), expected)
def test_constructor_accepts_operands(self):
"""Only operands are valid function arguments."""
PermissiveFunction(Number(0), Number(1))
assert_raises(BadCallError, PermissiveFunction, 0, 1)
def test_constructor_with_few_arguments(self):
PermissiveFunction()
def test_node_type(self):
"""Functions are branch nodes."""
func = PermissiveFunction(String("arg0"))
ok_(func.is_branch())
assert_false(func.is_leaf())
def test_existing_function_without_namespace(self):
parse_tree = self.parser('~ foo("baz")')
eq_(parse_tree.root_node, Not(PermissiveFunction(String("baz"))))