def test_single_prop_bool(self): tree = self.parse("true") t = boogie_parsing.infer_variable_types(tree, {}) t, type_env = t.derive_type() self.assertEqual(BoogieType.bool, t, msg="Error deriving bool from TRUE")
def generic_test_type_inference(self, expression, given_env, expected_env, expected_expression_type): """ Args: expression: given_env: expected_env: """ parser = boogie_parsing.get_parser_instance() tree = parser.parse(expression) t = boogie_parsing.infer_variable_types(tree, given_env) t, type_env = t.derive_type() for var, derived_type in type_env.items(): self.assertEqual( expected_env[var], derived_type, msg= "Error deriving `{}` type for variable `{}`. Derived `{}` instead." .format(expected_env[var], var, derived_type)) self.assertEqual( expected_expression_type, t, msg="Error deriving expression type `{}`. Got `{}` instead.". format(expected_expression_type, t))
def test_singleton(self): for type in [BoogieType.bool]: tree = self.parse("x") t = boogie_parsing.infer_variable_types(tree, {"x": type}) t, type_env = t.derive_type() self.assertEqual(type, t, msg="Error deriving bool from TRUE") self.assertEqual(type, type_env["x"], msg="Error deriving bool from TRUE")
def test_single_prop_must_be_bool(self): tree = self.parse("x") t = boogie_parsing.infer_variable_types(tree, {}) t, type_env = t.derive_type() self.assertEqual(BoogieType.bool, type_env["x"], msg="Error deriving variable type") self.assertEqual(BoogieType.bool, t, msg="Error deriving expression type")
def test_type_tree_gen(self): tree = self.parse("23 + a < 2") t = boogie_parsing.infer_variable_types(tree, {}) t, type_env = t.derive_type() self.assertEqual(BoogieType.int, type_env["a"], msg="Error deriving expression type") self.assertEqual(BoogieType.bool, t, msg="Error deriving expression type")
def test_propagate_error(self): tree = self.parse("(b + a) + 23") t = boogie_parsing.infer_variable_types(tree, {"a": BoogieType.real}) t, type_env = t.derive_type() self.assertEqual(BoogieType.real, type_env["b"], msg="Error deriving real type") self.assertEqual(BoogieType.error, t, msg="Error propagating the error type")
def test_illegal_compare(self): expr = 'MAX > 2.2' initial_type_env = {"MAX": BoogieType.bool} tree = self.parse(expr) type_node = boogie_parsing.infer_variable_types(tree, initial_type_env) type, type_env = type_node.derive_type() self.assertEqual( type, boogie_parsing.BoogieType.error, "Derived `{}` for expression `{}` with type_env: `{}`".format( type.name, expr, initial_type_env))
def test_unknown_expr(self): tree = self.parse("x == y") t = boogie_parsing.infer_variable_types(tree, {}) t, type_env = t.derive_type() self.assertEqual(BoogieType.bool, t, msg="Error deriving bool from TRUE") self.assertEqual(BoogieType.unknown, type_env["x"], msg="Error deriving bool from TRUE") self.assertEqual(BoogieType.unknown, type_env["y"], msg="Error deriving bool from TRUE")
def test_singleton_bad(self): # what do we want to do here, # error -> error # unknown -> ? # bloarg -> error for type in [BoogieType.error, "bloarg"]: tree = self.parse("x") # the type universe may not contain illegal types. Check after retrieval. t = boogie_parsing.infer_variable_types(tree, {"x": type}) t, type_env = t.derive_type() self.assertEqual(BoogieType.error, t, msg="Error deriving bool from TRUE")
def test_unknown_type(self): type = "bllluarg" tree = self.parse("x == y") t = boogie_parsing.infer_variable_types(tree, {"x": type}) t, type_env = t.derive_type() self.assertEqual( BoogieType.error, t, msg="Error deriving expression type error from unknown type") #self.assertEqual(type, type_env["x"], msg="Error deriving bool from TRUE") self.assertEqual(BoogieType.unknown, type_env["y"], msg="Error deriving bool from TRUE")
def test_type_nested_inf(self): tree = self.parse("(b + a) + 23 < 47") t = boogie_parsing.infer_variable_types(tree, {"a": BoogieType.unknown}) t, type_env = t.derive_type() self.assertEqual(BoogieType.int, type_env["a"], msg="Error deriving expression type") self.assertEqual(BoogieType.int, type_env["b"], msg="Error deriving expression type") self.assertEqual(BoogieType.bool, t, msg="Error deriving expression type")
def test_eq_expr_runknown(self): for type in [BoogieType.bool, BoogieType.real, BoogieType.int]: tree = self.parse("x == y") t = boogie_parsing.infer_variable_types(tree, {"x": type}) t, type_env = t.derive_type() self.assertEqual(BoogieType.bool, t, msg="Error deriving bool from TRUE") self.assertEqual(type, type_env["x"], msg="Error deriving bool from TRUE") self.assertEqual(type, type_env["y"], msg="Error deriving bool from TRUE")
def test_type_tree_gen2(self): tree = self.parse("(23.1 + 47.2 + x) < 44 && (b && a)") t = boogie_parsing.infer_variable_types(tree, { "a": BoogieType.bool, "x": BoogieType.real }) t, type_env = t.derive_type() self.assertEqual(BoogieType.bool, type_env["b"], msg="Infering bool from mixed expression failed.") self.assertEqual( BoogieType.real, type_env["x"], msg="Detecting variable in real/int mixed expression failed.") self.assertEqual(BoogieType.error, t, msg="Error deriving expression type")
def test_numbers(self): expressions = [ 'MAX_TIME', 'MAX_TIME + OFFSET', 'MAX_TIME - OFFSET', 'MAX_TIME * OFFSET', 'MAX_TIME / OFFSET' ] initial_type_env = {"MAX_TIME": BoogieType.real} for expr in expressions: tree = self.parse(expr) type_node = boogie_parsing.infer_variable_types( tree, initial_type_env) type, type_env = type_node.derive_type() self.assertEqual( type.name, boogie_parsing.BoogieType.real.name, "Derived `{}` for `{}` with type_env: `{}`. Expected type `{}`." .format(type.name, expr, initial_type_env, boogie_parsing.BoogieType.real.name))
def test_type_nested_large(self): tree = self.parse("(((((b + a) + d) * 23) < 4) && x ==> y )") t = boogie_parsing.infer_variable_types(tree, {"a": BoogieType.unknown}) t, type_env = t.derive_type() self.assertEqual(BoogieType.int, type_env["a"], msg="Error deriving variable type int") self.assertEqual(BoogieType.int, type_env["b"], msg="Error deriving variable type int") self.assertEqual(BoogieType.int, type_env["d"], msg="Error deriving variable type int") self.assertEqual(BoogieType.bool, type_env["x"], msg="Error deriving variable type bool") self.assertEqual(BoogieType.bool, type_env["y"], msg="Error deriving variable type bool") self.assertEqual(BoogieType.bool, t, msg="Error deriving expression type")