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_constants_unknown(self):
rules = pp(PROG1.format('a', 'b', 'd'))
constants = {
'a': ast.StringConstant('n'),
'b': ast.NumConstant(2),
'c': ast.NumConstant(0)}
comp = compiler.Z3Compiler(rules, constants, None)
self.assertRaises(obase.Z3NotWellFormed, comp.substitute_constants)
def test_num(self):
c = ast.NumConstant(5)
self.assertEqual(5, c.val)
self.assertEqual('int', c.type)
self.assertEqual(0, len(c.variables()))
c = ast.NumConstant(3, dtype='int4')
self.assertEqual(3, c.val)
self.assertEqual('int4', c.type)
def test_constants(self):
ast.Rule.rule_counter = 0
rules = pp(PROG1.format('a', 'b', 'c'))
constants = {
'a': ast.StringConstant('n'),
'b': ast.NumConstant(2),
'c': ast.NumConstant(0)}
comp = compiler.Z3Compiler(rules, constants, None)
comp.substitute_constants()
ast.Rule.rule_counter = 0
expected = pp(PROG1.format('"n"', '2', '0'))
self.assertEqual(expected, rules)
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_string(self):
c = ast.StringConstant('foo')
self.assertEqual('foo', c.val)
self.assertEqual('string', c.type)
self.assertEqual(0, len(c.variables()))
c = ast.NumConstant('aaa-bbb', dtype='id')
self.assertEqual('aaa-bbb', c.val)
self.assertEqual('id', c.type)
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 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 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 p_sexpr_number(t):
'sexpr : NUMBER'
t[0] = ast.NumConstant(t[1])
def test_num_eq(self):
self.assertIs(True, ast.NumConstant(2) == ast.NumConstant(2))
self.assertIs(False, ast.NumConstant(3) == ast.NumConstant(2))
self.assertIs(False,
ast.NumConstant(2) == ast.NumConstant(2, dtype='int4'))
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)
