def test_translate(self):
fp = z3.Fixedpoint()
atom1 = ast.Atom('p', [
ast.NumConstant(2, 'int4'),
ast.NumConstant(3, 'int4'),
ast.Variable('X', 'int4')
])
atom2 = ast.Atom('p', [
ast.NumConstant(2, 'int4'),
ast.NumConstant(3, 'int4'),
ast.Variable('Y', 'int4')
])
int4 = z3.BitVecSort(4)
p = z3.Function('p', int4, int4, int4, z3.BoolSort())
a0 = z3.BitVecVal(2, int4)
a1 = z3.BitVecVal(3, int4)
a2 = z3.Const('X', int4)
a3 = z3.Const('Y', int4)
args1 = [a0, a1, a2]
args2 = [a0, a1, a3]
project = projection.Projection([], None)
project.grounded = {'p': (0, 1)}
project.items = {'p': {}}
project.relations = {'p': p}
result = project.translate(fp, atom1, args1)
self.assertIn((0, 1), project.items['p'])
self.assertIn((a0, a1), project.items['p'][(0, 1)])
p0 = project.items['p'][(0, 1)][(a0, a1)]
self.assertIs(True, z3.is_true(z3.simplify(p0(a2) == result)))
result2 = project.translate(fp, atom2, args2)
self.assertIs(True, z3.is_true(z3.simplify(p0(a3) == result2)))
def test_var(self):
'''constructor'''
v = ast.Variable('id')
self.assertEqual('id', v.id)
self.assertIsNone(v.type)
v = ast.Variable('id', dtype='string')
self.assertEqual('string', v.type)
def mk_o():
v1 = ast.Variable('V1')
v2 = ast.Variable('V2')
v3 = ast.Variable('V3')
n = ast.NumConstant(1)
o1 = ast.Operation('+', [v1, n])
o2 = ast.Operation('+', [v1, v2])
o = ast.Operation('+', [o1, o2, v3])
return o, v1, v2, v3
def mk_r():
v1 = ast.Variable('V1')
v2 = ast.Variable('V2')
v3 = ast.Variable('V3')
a1 = ast.Atom('p', [v1, v2])
a2 = ast.Atom('q', [v1, v3])
a3 = ast.Atom('r', [v3, v2])
r = ast.Rule(a1, [a2, a3])
return r, v1, v2, v3
def test_renaming(self):
v1 = ast.Variable('id')
v2 = ast.Variable('id')
v3 = ast.Variable('id')
self.assertEqual(v1, v2)
v1.pin_variables(1)
v2.pin_variables(1)
v3.pin_variables(2)
self.assertEqual(v1, v2)
self.assertIs(False, v1 == v3)
def test_eq(self):
v = ast.Variable('V')
n = ast.NumConstant(3)
self.assertIs(
True, ast.Operation('+', [v, n]) == ast.Operation('+', [v, n]))
self.assertIs(
False, ast.Operation('+', [v, n]) == ast.Operation('+', [n, n]))
def test_eq(self):
v = ast.Variable('V')
n = ast.NumConstant(3)
self.assertIs(True, ast.Atom('p', [v]) == ast.Atom('p', [v]))
self.assertIs(
False, ast.Atom('p', [v], negated=True) == ast.Atom('p', [v]))
self.assertIs(
False, ast.Atom('p', [v]) == ast.Atom('p', [n]))
def test_atom(self):
v = ast.Variable('V')
n = ast.NumConstant(3)
a = ast.Atom('p', [v, n])
self.assertEqual('p', a.table)
self.assertEqual([v, n], a.args)
self.assertIs(False, a.negated)
self.assertEqual('p', str(a)[0])
a = ast.Atom('p', [v, n], negated=True)
self.assertEqual('p', a.table)
self.assertIs(True, a.negated)
self.assertEqual('~p', str(a)[0:2])
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 find_base_relations(self):
"""Extracts base relations of the theory"""
aux_counter = 0
new_rules = []
for rule in self.rules:
if self.datasource.is_extensible(rule.head):
raise base.Z3NotWellFormed(
"No base predicate allowed in head: " + rule.head.table)
for i, atom in enumerate(rule.body):
if not self.datasource.is_extensible(atom):
continue
fields = self.extensible_tables.setdefault(atom.table, [])
if atom.labels is None:
raise base.Z3NotWellFormed(
"No labels for extensible atom {}".format(atom))
for label in atom.labels:
if label not in fields:
fields.append(label)
if atom.negated:
new_table = "_negated_%d" % aux_counter
aux_counter += 1
new_atom = ast.Atom(new_table, atom.args, negated=True)
var_row = [
ast.Variable("V%d" % i) for i in range(len(atom.args))
]
atom_head = ast.Atom(new_table, var_row)
atom_body = ast.Atom(atom.table,
var_row,
labels=atom.labels)
new_rule = ast.Rule(atom_head, [atom_body])
new_rules.append(new_rule)
rule.body[i] = new_atom
self.rules.extend(new_rules)
for fields in self.extensible_tables.values():
fields.sort()
for rule in self.rules:
for atom in rule.body:
if self.datasource.is_extensible(atom):
self.flatten(atom, self.extensible_tables[atom.table])
def p_sexpr_var(t):
'sexpr : VAR'
t[0] = ast.Variable(t[1])
def test_eq(self):
self.assertIs(True, ast.Variable('V') == ast.Variable('V'))
self.assertIs(False, ast.Variable('V') == ast.Variable('W'))
def test_str(self):
v = ast.Variable('V', dtype='string')
self.assertEqual('V:string', str(v))
def test_variables(self):
v = ast.Variable('id')
lvars = v.variables()
self.assertEqual(1, len(lvars))
lvars = [x.full_id()[0] for x in lvars]
self.assertIs(True, 'id' in lvars)
def test_operation(self):
v = ast.Variable('V')
n = ast.NumConstant(3)
o = ast.Operation('+', [v, n])
self.assertEqual('+', o.operation)
self.assertEqual([v, n], o.args)
def new_var():
"""Create a new var with unique name"""
self.var_count += 1
return ast.Variable("::{}".format(self.var_count))
