def test_ite_term(solver):
bvSort = solver.mkBitVectorSort(8)
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(bvSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
b = solver.mkTrue()
with pytest.raises(RuntimeError):
Term(solver).iteTerm(b, b)
with pytest.raises(RuntimeError):
b.iteTerm(Term(solver), b)
with pytest.raises(RuntimeError):
b.iteTerm(b, Term(solver))
b.iteTerm(b, b)
x = solver.mkVar(solver.mkBitVectorSort(8), "x")
b.iteTerm(x, x)
b.iteTerm(b, b)
with pytest.raises(RuntimeError):
b.iteTerm(x, b)
with pytest.raises(RuntimeError):
x.iteTerm(x, x)
with pytest.raises(RuntimeError):
x.iteTerm(x, b)
f = solver.mkVar(funSort1, "f")
with pytest.raises(RuntimeError):
f.iteTerm(b, b)
with pytest.raises(RuntimeError):
x.iteTerm(b, x)
p = solver.mkVar(funSort2, "p")
with pytest.raises(RuntimeError):
p.iteTerm(b, b)
with pytest.raises(RuntimeError):
p.iteTerm(x, b)
zero = solver.mkInteger(0)
with pytest.raises(RuntimeError):
zero.iteTerm(x, x)
with pytest.raises(RuntimeError):
zero.iteTerm(x, b)
f_x = solver.mkTerm(kinds.ApplyUf, f, x)
with pytest.raises(RuntimeError):
f_x.iteTerm(b, b)
with pytest.raises(RuntimeError):
f_x.iteTerm(b, x)
sum = solver.mkTerm(kinds.Plus, f_x, f_x)
with pytest.raises(RuntimeError):
sum.iteTerm(x, x)
with pytest.raises(RuntimeError):
sum.iteTerm(b, x)
p_0 = solver.mkTerm(kinds.ApplyUf, p, zero)
p_0.iteTerm(b, b)
p_0.iteTerm(x, x)
with pytest.raises(RuntimeError):
p_0.iteTerm(x, b)
p_f_x = solver.mkTerm(kinds.ApplyUf, p, f_x)
p_f_x.iteTerm(b, b)
p_f_x.iteTerm(x, x)
with pytest.raises(RuntimeError):
p_f_x.iteTerm(x, b)
def test_get_id(solver):
n = Term(solver)
with pytest.raises(RuntimeError):
n.getId()
x = solver.mkVar(solver.getIntegerSort(), "x")
x.getId()
y = x
assert x.getId() == y.getId()
z = solver.mkVar(solver.getIntegerSort(), "z")
assert x.getId() != z.getId()
def test_not_term(solver):
bvSort = solver.mkBitVectorSort(8)
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(bvSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
with pytest.raises(RuntimeError):
Term(solver).notTerm()
b = solver.mkTrue()
b.notTerm()
x = solver.mkVar(solver.mkBitVectorSort(8), "x")
with pytest.raises(RuntimeError):
x.notTerm()
f = solver.mkVar(funSort1, "f")
with pytest.raises(RuntimeError):
f.notTerm()
p = solver.mkVar(funSort2, "p")
with pytest.raises(RuntimeError):
p.notTerm()
zero = solver.mkInteger(0)
with pytest.raises(RuntimeError):
zero.notTerm()
f_x = solver.mkTerm(kinds.ApplyUf, f, x)
with pytest.raises(RuntimeError):
f_x.notTerm()
sum = solver.mkTerm(kinds.Plus, f_x, f_x)
with pytest.raises(RuntimeError):
sum.notTerm()
p_0 = solver.mkTerm(kinds.ApplyUf, p, zero)
p_0.notTerm()
p_f_x = solver.mkTerm(kinds.ApplyUf, p, f_x)
p_f_x.notTerm()
def test_get_sort(solver):
bvSort = solver.mkBitVectorSort(8)
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(bvSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
n = Term(solver)
with pytest.raises(RuntimeError):
n.getSort()
x = solver.mkVar(bvSort, "x")
x.getSort()
assert x.getSort() == bvSort
y = solver.mkVar(bvSort, "y")
y.getSort()
assert y.getSort() == bvSort
f = solver.mkVar(funSort1, "f")
f.getSort()
assert f.getSort() == funSort1
p = solver.mkVar(funSort2, "p")
p.getSort()
assert p.getSort() == funSort2
zero = solver.mkInteger(0)
zero.getSort()
assert zero.getSort() == intSort
f_x = solver.mkTerm(kinds.ApplyUf, f, x)
f_x.getSort()
assert f_x.getSort() == intSort
f_y = solver.mkTerm(kinds.ApplyUf, f, y)
f_y.getSort()
assert f_y.getSort() == intSort
sum = solver.mkTerm(kinds.Plus, f_x, f_y)
sum.getSort()
assert sum.getSort() == intSort
p_0 = solver.mkTerm(kinds.ApplyUf, p, zero)
p_0.getSort()
assert p_0.getSort() == boolSort
p_f_y = solver.mkTerm(kinds.ApplyUf, p, f_y)
p_f_y.getSort()
assert p_f_y.getSort() == boolSort
def test_term_children(solver):
# simple term 2+3
two = solver.mkInteger(2)
t1 = solver.mkTerm(kinds.Plus, two, solver.mkInteger(3))
assert t1[0] == two
assert t1.getNumChildren() == 2
tnull = Term(solver)
with pytest.raises(RuntimeError):
tnull.getNumChildren()
# apply term f(2)
intSort = solver.getIntegerSort()
fsort = solver.mkFunctionSort(intSort, intSort)
f = solver.mkConst(fsort, "f")
t2 = solver.mkTerm(kinds.ApplyUf, f, two)
# due to our higher-order view of terms, we treat f as a child of kinds.ApplyUf
assert t2.getNumChildren() == 2
assert t2[0] == f
assert t2[1] == two
with pytest.raises(RuntimeError):
tnull[0]
def test_eq(solver):
uSort = solver.mkUninterpretedSort("u")
x = solver.mkVar(uSort, "x")
y = solver.mkVar(uSort, "y")
z = Term(solver)
assert x == x
assert not x != x
assert not x == y
assert x != y
assert not (x == z)
assert x != z
def test_get_kind(solver):
uSort = solver.mkUninterpretedSort("u")
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(uSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
n = Term(solver)
with pytest.raises(RuntimeError):
n.getKind()
x = solver.mkVar(uSort, "x")
x.getKind()
y = solver.mkVar(uSort, "y")
y.getKind()
f = solver.mkVar(funSort1, "f")
f.getKind()
p = solver.mkVar(funSort2, "p")
p.getKind()
zero = solver.mkInteger(0)
zero.getKind()
f_x = solver.mkTerm(kinds.ApplyUf, f, x)
f_x.getKind()
f_y = solver.mkTerm(kinds.ApplyUf, f, y)
f_y.getKind()
sum = solver.mkTerm(kinds.Plus, f_x, f_y)
sum.getKind()
p_0 = solver.mkTerm(kinds.ApplyUf, p, zero)
p_0.getKind()
p_f_y = solver.mkTerm(kinds.ApplyUf, p, f_y)
p_f_y.getKind()
# Sequence kinds do not exist internally, test that the API properly
# converts them back.
seqSort = solver.mkSequenceSort(intSort)
s = solver.mkConst(seqSort, "s")
ss = solver.mkTerm(kinds.SeqConcat, s, s)
assert ss.getKind() == kinds.SeqConcat
def test_substitute(solver):
x = solver.mkConst(solver.getIntegerSort(), "x")
one = solver.mkInteger(1)
ttrue = solver.mkTrue()
xpx = solver.mkTerm(kinds.Plus, x, x)
onepone = solver.mkTerm(kinds.Plus, one, one)
assert xpx.substitute(x, one) == onepone
assert onepone.substitute(one, x) == xpx
# incorrect due to type
with pytest.raises(RuntimeError):
xpx.substitute(one, ttrue)
# simultaneous substitution
y = solver.mkConst(solver.getIntegerSort(), "y")
xpy = solver.mkTerm(kinds.Plus, x, y)
xpone = solver.mkTerm(kinds.Plus, y, one)
es = []
rs = []
es.append(x)
rs.append(y)
es.append(y)
rs.append(one)
assert xpy.substitute(es, rs) == xpone
# incorrect substitution due to arity
rs.pop()
with pytest.raises(RuntimeError):
xpy.substitute(es, rs)
# incorrect substitution due to types
rs.append(ttrue)
with pytest.raises(RuntimeError):
xpy.substitute(es, rs)
# null cannot substitute
tnull = Term(solver)
with pytest.raises(RuntimeError):
tnull.substitute(one, x)
with pytest.raises(RuntimeError):
xpx.substitute(tnull, x)
with pytest.raises(RuntimeError):
xpx.substitute(x, tnull)
rs.pop()
rs.append(tnull)
with pytest.raises(RuntimeError):
xpy.substitute(es, rs)
es.clear()
rs.clear()
es.append(x)
rs.append(y)
with pytest.raises(RuntimeError):
tnull.substitute(es, rs)
es.append(tnull)
rs.append(one)
with pytest.raises(RuntimeError):
xpx.substitute(es, rs)
def test_eq_term(solver):
bvSort = solver.mkBitVectorSort(8)
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(bvSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
b = solver.mkTrue()
with pytest.raises(RuntimeError):
Term(solver).eqTerm(b)
with pytest.raises(RuntimeError):
b.eqTerm(Term(solver))
b.eqTerm(b)
x = solver.mkVar(solver.mkBitVectorSort(8), "x")
with pytest.raises(RuntimeError):
x.eqTerm(b)
x.eqTerm(x)
f = solver.mkVar(funSort1, "f")
with pytest.raises(RuntimeError):
f.eqTerm(b)
with pytest.raises(RuntimeError):
f.eqTerm(x)
f.eqTerm(f)
p = solver.mkVar(funSort2, "p")
with pytest.raises(RuntimeError):
p.eqTerm(b)
with pytest.raises(RuntimeError):
p.eqTerm(x)
with pytest.raises(RuntimeError):
p.eqTerm(f)
p.eqTerm(p)
zero = solver.mkInteger(0)
with pytest.raises(RuntimeError):
zero.eqTerm(b)
with pytest.raises(RuntimeError):
zero.eqTerm(x)
with pytest.raises(RuntimeError):
zero.eqTerm(f)
with pytest.raises(RuntimeError):
zero.eqTerm(p)
zero.eqTerm(zero)
f_x = solver.mkTerm(kinds.ApplyUf, f, x)
with pytest.raises(RuntimeError):
f_x.eqTerm(b)
with pytest.raises(RuntimeError):
f_x.eqTerm(x)
with pytest.raises(RuntimeError):
f_x.eqTerm(f)
with pytest.raises(RuntimeError):
f_x.eqTerm(p)
f_x.eqTerm(zero)
f_x.eqTerm(f_x)
sum = solver.mkTerm(kinds.Plus, f_x, f_x)
with pytest.raises(RuntimeError):
sum.eqTerm(b)
with pytest.raises(RuntimeError):
sum.eqTerm(x)
with pytest.raises(RuntimeError):
sum.eqTerm(f)
with pytest.raises(RuntimeError):
sum.eqTerm(p)
sum.eqTerm(zero)
sum.eqTerm(f_x)
sum.eqTerm(sum)
p_0 = solver.mkTerm(kinds.ApplyUf, p, zero)
p_0.eqTerm(b)
with pytest.raises(RuntimeError):
p_0.eqTerm(x)
with pytest.raises(RuntimeError):
p_0.eqTerm(f)
with pytest.raises(RuntimeError):
p_0.eqTerm(p)
with pytest.raises(RuntimeError):
p_0.eqTerm(zero)
with pytest.raises(RuntimeError):
p_0.eqTerm(f_x)
with pytest.raises(RuntimeError):
p_0.eqTerm(sum)
p_0.eqTerm(p_0)
p_f_x = solver.mkTerm(kinds.ApplyUf, p, f_x)
p_f_x.eqTerm(b)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(x)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(f)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(p)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(zero)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(f_x)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(sum)
p_f_x.eqTerm(p_0)
p_f_x.eqTerm(p_f_x)
def test_is_null(solver):
x = Term(solver)
assert x.isNull()
x = solver.mkVar(solver.mkBitVectorSort(4), "x")
assert not x.isNull()