public void NestedSelectStoreConstructedProperly()
{
var nested = a.Store(k, v).Select(k);
ExpressionTestHelper.CheckExpression(
nested.Expression,
ExpressionKind.Select,
Sort.Bool,
"(select (store a k v) k)",
2);
var storeAKV = nested.Expression.Children.ElementAt(0);
ExpressionTestHelper.CheckExpressionWithChildren(
storeAKV,
ExpressionKind.Store,
arraySort,
"(store a k v)",
a.Expression,
k.Expression,
v.Expression);
var kExpr = nested.Expression.Children.ElementAt(1);
Assert.AreEqual(k, kExpr);
}
public void NotOperatorConstructedProperly()
{
var notA = !a;
ExpressionTestHelper.CheckExpressionWithChildren(
notA.Expression,
ExpressionKind.Not,
Sort.Bool,
"(not a)",
a.Expression);
}
public void NegateOperatorConstructedProperly()
{
var negateA = -a;
ExpressionTestHelper.CheckExpressionWithChildren(
negateA.Expression,
ExpressionKind.Negate,
Sort.Int,
"(- a)",
a.Expression);
}
public void DistinctOperatorConstructedProperly()
{
var aNeqB = (a != b);
ExpressionTestHelper.CheckExpressionWithChildren(
aNeqB.Expression,
ExpressionKind.Distinct,
Sort.Bool,
"(distinct a b)",
a.Expression,
b.Expression);
}
public void GreaterThanOrEqualOperatorConstructedProperly()
{
var aGteB = a >= b;
ExpressionTestHelper.CheckExpressionWithChildren(
aGteB.Expression,
ExpressionKind.GreaterThanOrEqual,
Sort.Bool,
"(>= a b)",
a.Expression,
b.Expression);
}
public void LessThanOrEqualOperatorConstructedProperly()
{
var aLtB = a <= b;
ExpressionTestHelper.CheckExpressionWithChildren(
aLtB.Expression,
ExpressionKind.LessThanOrEqual,
Sort.Bool,
"(<= a b)",
a.Expression,
b.Expression);
}
public void SubtractOperatorConstructedProperly()
{
var aSubtractB = a - b;
ExpressionTestHelper.CheckExpressionWithChildren(
aSubtractB.Expression,
ExpressionKind.Subtract,
Sort.Int,
"(- a b)",
a.Expression,
b.Expression);
}
public void ModulusOperatorConstructedProperly()
{
var aModuloB = a % b;
ExpressionTestHelper.CheckExpressionWithChildren(
aModuloB.Expression,
ExpressionKind.Modulus,
Sort.Int,
"(mod a b)",
a.Expression,
b.Expression);
}
public void OrOperatorConstructedProperly()
{
var aOrB = a || b;
ExpressionTestHelper.CheckExpressionWithChildren(
aOrB.Expression,
ExpressionKind.Or,
Sort.Bool,
"(or a b)",
a.Expression,
b.Expression);
}
public void XorOperatorConstructedProperly()
{
var aXorB = a ^ b;
ExpressionTestHelper.CheckExpressionWithChildren(
aXorB.Expression,
ExpressionKind.Xor,
Sort.Bool,
"(xor a b)",
a.Expression,
b.Expression);
}
public void RemainderOperatorConstructedProperly()
{
var aRemainderB = a.Remainder(b);
ExpressionTestHelper.CheckExpressionWithChildren(
aRemainderB.Expression,
ExpressionKind.Remainder,
Sort.Int,
"(rem a b)",
a.Expression,
b.Expression);
}
public void DivideRealOperatorConstructedProperly()
{
var aDivideRealB = a.DivideReal(b);
ExpressionTestHelper.CheckExpressionWithChildren(
aDivideRealB.Expression,
ExpressionKind.DivideReal,
Sort.Real,
"(/ a b)",
a.Expression,
b.Expression);
}
public void SelectConstructedProperly()
{
var selectAK = a.Select(k);
ExpressionTestHelper.CheckExpressionWithChildren(
selectAK.Expression,
ExpressionKind.Select,
Sort.Bool,
"(select a k)",
a.Expression,
k.Expression);
}
public void MultiplyOperatorConstructedProperly()
{
var aMultiplyB = a * b;
ExpressionTestHelper.CheckExpressionWithChildren(
aMultiplyB.Expression,
ExpressionKind.Multiply,
Sort.Int,
"(* a b)",
a.Expression,
b.Expression);
}
public void AndOperatorConstructedProperly()
{
var aAndB = a && b;
ExpressionTestHelper.CheckExpressionWithChildren(
aAndB.Expression,
ExpressionKind.And,
Sort.Bool,
"(and a b)",
a.Expression,
b.Expression);
}
public void AddOperatorConstructedProperly()
{
var aAddB = a + b;
ExpressionTestHelper.CheckExpressionWithChildren(
aAddB.Expression,
ExpressionKind.Add,
Sort.Int,
"(+ a b)",
a.Expression,
b.Expression);
}
public void DivideIntegerOperatorConstructedProperly()
{
var aDivideIntegerB = a / b;
ExpressionTestHelper.CheckExpressionWithChildren(
aDivideIntegerB.Expression,
ExpressionKind.DivideInteger,
Sort.Int,
"(div a b)",
a.Expression,
b.Expression);
}
public void EqualOperatorConstructedProperly()
{
var aEqB = (a == b);
ExpressionTestHelper.CheckExpressionWithChildren(
aEqB.Expression,
ExpressionKind.Equal,
Sort.Bool,
"(= a b)",
a.Expression,
b.Expression);
}
public void ImpliesOperatorConstructedProperly()
{
var aImpliesB = a.Implies(b);
ExpressionTestHelper.CheckExpressionWithChildren(
aImpliesB.Expression,
ExpressionKind.Implies,
Sort.Bool,
"(=> a b)",
a.Expression,
b.Expression);
}
public void OrOperatorMergedProperly()
{
var orABC = a || b || c;
ExpressionTestHelper.CheckExpressionWithChildren(
orABC.Expression,
ExpressionKind.Or,
Sort.Bool,
"(or a b c)",
a.Expression,
b.Expression,
c.Expression);
}
public void StoreConstructedProperly()
{
var storeAKV = a.Store(k, v);
ExpressionTestHelper.CheckExpressionWithChildren(
storeAKV.Expression,
ExpressionKind.Store,
arraySort,
"(store a k v)",
a.Expression,
k.Expression,
v.Expression);
}
public void MultiplyOperatorMergedProperly()
{
var nultiplyABC = a * b * c;
ExpressionTestHelper.CheckExpressionWithChildren(
nultiplyABC.Expression,
ExpressionKind.Multiply,
Sort.Int,
"(* a b c)",
a.Expression,
b.Expression,
c.Expression);
}
public void AndOperatorMergedProperly()
{
var andABC = a && b && c;
ExpressionTestHelper.CheckExpressionWithChildren(
andABC.Expression,
ExpressionKind.And,
Sort.Bool,
"(and a b c)",
a.Expression,
b.Expression,
c.Expression);
}
public void AddOperatorMergedProperly()
{
var addABC = a + b + c;
ExpressionTestHelper.CheckExpressionWithChildren(
addABC.Expression,
ExpressionKind.Add,
Sort.Int,
"(+ a b c)",
a.Expression,
b.Expression,
c.Expression);
}
public void IfThenElseOperatorConstructedProperly()
{
var ifAThenBElseC = a.IfThenElse(b, c);
ExpressionTestHelper.CheckExpressionWithChildren(
ifAThenBElseC.Expression,
ExpressionKind.IfThenElse,
Sort.Bool,
"(ite a b c)",
a.Expression,
b.Expression,
c.Expression);
}
public void IfThenElseOperatorConstructedProperly()
{
var cond = (BoolHandle)ExpressionFactory.NamedVariable(Sort.Bool, "cond");
var ifCondThenAElseB = cond.IfThenElse(a, b);
ExpressionTestHelper.CheckExpressionWithChildren(
ifCondThenAElseB.Expression,
ExpressionKind.IfThenElse,
Sort.Int,
"(ite cond a b)",
cond.Expression,
a.Expression,
b.Expression);
}
public void NestedOperatorsWorkProperly()
{
var nested = (a && b && c) || (b == c) || b.Implies(c);
var or = nested.Expression;
ExpressionTestHelper.CheckExpression(
or,
ExpressionKind.Or,
Sort.Bool,
"(or (and a b c) (= b c) (=> b c))",
3);
var and = or.Children.ElementAt(0);
ExpressionTestHelper.CheckExpressionWithChildren(
and,
ExpressionKind.And,
Sort.Bool,
"(and a b c)",
a.Expression,
b.Expression,
c.Expression);
var eq = or.Children.ElementAt(1);
ExpressionTestHelper.CheckExpressionWithChildren(
eq,
ExpressionKind.Equal,
Sort.Bool,
"(= b c)",
b.Expression,
c.Expression);
var implies = or.Children.ElementAt(2);
ExpressionTestHelper.CheckExpressionWithChildren(
implies,
ExpressionKind.Implies,
Sort.Bool,
"(=> b c)",
b.Expression,
c.Expression);
}
public void DistinctOperatorNestedProperly()
{
var aNeqBNeqC = (a != b != c);
ExpressionTestHelper.CheckExpression(
aNeqBNeqC.Expression,
ExpressionKind.Distinct,
Sort.Bool,
"(distinct (distinct a b) c)",
2);
var aNeqB = aNeqBNeqC.Expression.Children.ElementAt(0);
ExpressionTestHelper.CheckExpressionWithChildren(
aNeqB,
ExpressionKind.Distinct,
Sort.Bool,
"(distinct a b)",
a.Expression,
b.Expression);
Assert.AreEqual(c.Expression, aNeqBNeqC.Expression.Children.ElementAt(1));
}
public void NestedOperatorsWorkProperly()
{
var nested = (a == b) || (b >= a + a * c + a / b);
var or = nested.Expression;
ExpressionTestHelper.CheckExpression(
or,
ExpressionKind.Or,
Sort.Bool,
"(or (= a b) (>= b (+ a (* a c) (div a b))))",
2);
var eq = or.Children.ElementAt(0);
ExpressionTestHelper.CheckExpressionWithChildren(
eq,
ExpressionKind.Equal,
Sort.Bool,
"(= a b)",
a.Expression,
b.Expression);
var geq = or.Children.ElementAt(1);
ExpressionTestHelper.CheckExpression(
geq,
ExpressionKind.GreaterThanOrEqual,
Sort.Bool,
"(>= b (+ a (* a c) (div a b)))",
2);
Assert.AreEqual(b.Expression, geq.Children.ElementAt(0));
var add = geq.Children.ElementAt(1);
ExpressionTestHelper.CheckExpression(
add,
ExpressionKind.Add,
Sort.Int,
"(+ a (* a c) (div a b))",
3);
Assert.AreEqual(a.Expression, add.Children.ElementAt(0));
var mul = add.Children.ElementAt(1);
ExpressionTestHelper.CheckExpressionWithChildren(
mul,
ExpressionKind.Multiply,
Sort.Int,
"(* a c)",
a.Expression,
c.Expression);
var div = add.Children.ElementAt(2);
ExpressionTestHelper.CheckExpressionWithChildren(
div,
ExpressionKind.DivideInteger,
Sort.Int,
"(div a b)",
a.Expression,
b.Expression);
}
