def test_operation(self): prog = parser.wrapped_parse(PROG3) tables = typechecker.type_theory(prog, {}, MockSource({})) self.assertIn("p", tables) self.assertEqual(["int4"], tables['p']) self.assertIn("q", tables) self.assertEqual(["int"], tables['q'])
def test_unfolding(self): prog = "t(X) :- p(X,Y), X = Y & 1.\ns(X) :- t(X), 2 = X & 2." rules = parser.wrapped_parse(prog) extensible = {"p": ["int", "int"]} unfold = origin.Origin(rules, extensible) self.assertEqual((2, True), unfold.tables["p"]) self.assertEqual((1, False), unfold.tables["t"])
def test_type(self): rules = parser.wrapped_parse(prog0) external = {'q': ['int', 'int'], 'p': ['int']} unfold = origin.Origin(rules, external) unfold.type() result = unfold.table_types typ_s0 = result['s'][0] self.assertIsInstance(typ_s0, origin.UFDisj)
def test_get_to_solve(self): prog = parser.wrapped_parse("t(X) :- p(X,Y), X = Y & 1, q(X), X < 10.") rule = prog[0] vars = rule.body_variables() # Only the first is to solve. There is only one variable in the # equality. expected = [(vars, 1)] self.assertEqual(expected, unfolding.get_to_solve(prog[0]))
def test_simple(self): prog = parser.wrapped_parse(PROG1) tables = typechecker.type_theory(prog, PRIM1, MockSource(SRC1)) self.assertIn("p", tables) self.assertEqual(["t1", "t2"], tables['p']) self.assertIn("q", tables) self.assertEqual(["t1"], tables['q']) self.assertIn("r", tables) self.assertEqual(["t2"], tables['r'])
def test_strategy_1(self): rules = parser.wrapped_parse(prog1) external = {'q': ['int', 'int'], 'p': ['int'], 'r': ['int']} unfold = unfolding.Unfolding(rules, external, (lambda t: t)) ogn = origin.Origin(rules, external) var_types = ogn.type() result = unfold.rule_strategy(var_types, rules[0]) filtered = [(t, sorted(pos)) for (((t, pos),), _) in result] self.assertEqual([('q', [0, 1]), ('p', [0])], filtered)
def test_strategy_2(self): rules = parser.wrapped_parse(prog2) rule = rules[0] external = {'q': ['int'], 'p': ['int']} unfold = unfolding.Unfolding(rules, external, (lambda t: t)) ogn = origin.Origin(rules, external) var_types = ogn.type() result = unfold.rule_strategy(var_types, rule) filtered = [ sorted([(t, sorted(pos)) for (t, pos) in plan], key=lambda p: p[0]) for (plan, _) in result] self.assertEqual([[('p', [0])], [('p', [0]), ('q', [0])]], filtered)
def test_type_variables(self): rules = parser.wrapped_parse(prog0) vars = [rules[rid].head.args[pos].full_id() for (rid, pos) in [(1, 0), (3, 0), (3, 1)]] external = {'q': ['int', 'int'], 'p': ['int']} unfold = origin.Origin(rules, external) unfold.initialize_types() unfold.type_variables() typs = [unfold.var_types[v] for v in vars] self.assertEqual(['p', 'q', 'q'], [t.table for t in typs]) self.assertEqual([0, 0, 1], [t.pos for t in typs]) occs = [t.occurrence for t in typs] self.assertEqual(occs[1], occs[2]) self.assertEqual(False, occs[0] == occs[1])
def test_initialize_types_and_get_atom_types(self): rules = parser.wrapped_parse(prog0) atom_t = rules[0].head atom_z = ast.Atom('z', []) external = {'q': ['int', 'int'], 'p': ['int']} unfold = origin.Origin(rules, external) unfold.initialize_types() self.assertEqual( [origin.UFBot(), origin.UFGround(1, "t", None)], unfold.table_types['t']) self.assertEqual( origin.UFBot(), unfold.get_atom_type(atom_t, 0)) self.assertEqual(None, unfold.get_atom_type(atom_t, 3)) self.assertEqual(None, unfold.get_atom_type(atom_z, 0))
def test_plan_to_program_idb(self): rules = parser.wrapped_parse(prog0) # arbitrary not really used rules[0].id = 0 fp = z3.Fixedpoint() datasource = source.Datasource(primitives.TYPES) octant_type = datasource.types["int4"] z3_type = octant_type.type() def mkv(v): return z3.BitVecVal(v, z3_type) p = z3.Function('p', z3_type, z3_type, z3.BoolSort()) q = z3.Function('q', z3_type, z3_type, z3.BoolSort()) content = { 'p': [(mkv(3), mkv(0)), (mkv(4), mkv(1))] } for (x, y) in [(5, 0), (6, 1)]: fp.add_rule(q(mkv(x), mkv(y))) relations = {'p': p, 'q': q} x = ast.Variable("X", "int4") y = ast.Variable("Y", "int4") z = ast.Variable("Z", "int4") for f in [p, q]: fp.register_relation(f) unfold_plan = unfolding.UnfoldPlan( {0: [((('p', [1, 0]),), [x, y]), ((('q', [0, 1]),), [z, x])]}, content) records = unfolding.plan_to_program( unfold_plan, fp, datasource, relations, rules) self.assertIn(0, records) trimmed = sorted([ sorted((var, val.as_long()) for ((var, _), val) in rec.items()) for rec in records[0] ], key=lambda t: t[0]) expected = [ [('X', 0), ('Y', 3), ('Z', 5)], [('X', 1), ('Y', 4), ('Z', 6)] ] self.assertEqual(expected, trimmed)
def pp(text): return parser.wrapped_parse(text)
def pp(str): return parser.wrapped_parse(str)
def test_bad_compare(self): prog = parser.wrapped_parse(PROG4) self.assertRaises( obase.Z3TypeError, lambda: typechecker.type_theory(prog, {}, MockSource({})))
def test_clash_on_expr(self): prog = parser.wrapped_parse(PROG7) self.assertRaises( obase.Z3TypeError, lambda: typechecker.type_theory(prog, {}, MockSource({})))
def test_partially_ground(self): rules = parser.wrapped_parse(prog0) unfold = origin.Origin(rules, {}) result = unfold.get_partially_ground_preds() self.assertEqual({'s': set(), 't': set([1])}, result)