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)