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 LocalVariableCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
string name = "testBoolVar";
var variable = builder.AddLocalVariable(Sort.Bool, name);
ExpressionTestHelper.CheckExpression(variable, ExpressionKind.Variable, Sort.Bool, name, 0);
Assert.AreEqual(builder.Graph, variable.Graph);
}
public void NegateOperatorConstructedProperly()
{
var negateA = -a;
ExpressionTestHelper.CheckExpressionWithChildren(
negateA.Expression,
ExpressionKind.Negate,
Sort.Int,
"(- a)",
a.Expression);
}
public void NotOperatorConstructedProperly()
{
var notA = !a;
ExpressionTestHelper.CheckExpressionWithChildren(
notA.Expression,
ExpressionKind.Not,
Sort.Bool,
"(not a)",
a.Expression);
}
public void GlobalVariableCreatedProperly()
{
var graphId = new FlowGraphId(1);
var builder = new FlowGraphBuilder(graphId);
string name = "testBoolVar";
var variableId = new GlobalFlowVariableId(1);
var variable = new GlobalFlowVariable(variableId, Sort.Bool, name);
ExpressionTestHelper.CheckExpression(variable, ExpressionKind.Variable, Sort.Bool, name, 0);
}
public void DivideRealOperatorConstructedProperly()
{
var aDivideRealB = a.DivideReal(b);
ExpressionTestHelper.CheckExpressionWithChildren(
aDivideRealB.Expression,
ExpressionKind.DivideReal,
Sort.Real,
"(/ a b)",
a.Expression,
b.Expression);
}
public void MultiplyOperatorConstructedProperly()
{
var aMultiplyB = a * b;
ExpressionTestHelper.CheckExpressionWithChildren(
aMultiplyB.Expression,
ExpressionKind.Multiply,
Sort.Int,
"(* a b)",
a.Expression,
b.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 AddOperatorConstructedProperly()
{
var aAddB = a + b;
ExpressionTestHelper.CheckExpressionWithChildren(
aAddB.Expression,
ExpressionKind.Add,
Sort.Int,
"(+ 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 DivideIntegerOperatorConstructedProperly()
{
var aDivideIntegerB = a / b;
ExpressionTestHelper.CheckExpressionWithChildren(
aDivideIntegerB.Expression,
ExpressionKind.DivideInteger,
Sort.Int,
"(div 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 EqualOperatorConstructedProperly()
{
var aEqB = (a == b);
ExpressionTestHelper.CheckExpressionWithChildren(
aEqB.Expression,
ExpressionKind.Equal,
Sort.Bool,
"(= 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 AndOperatorConstructedProperly()
{
var aAndB = a && b;
ExpressionTestHelper.CheckExpressionWithChildren(
aAndB.Expression,
ExpressionKind.And,
Sort.Bool,
"(and 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 ImpliesOperatorConstructedProperly()
{
var aImpliesB = a.Implies(b);
ExpressionTestHelper.CheckExpressionWithChildren(
aImpliesB.Expression,
ExpressionKind.Implies,
Sort.Bool,
"(=> 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 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 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 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 InterpretationConstructedProperly()
{
var trueVal = new BoolHandle(true);
ExpressionTestHelper.CheckExpression(
trueVal.Expression,
ExpressionKind.Interpretation,
Sort.Bool,
true.ToString(),
0);
Assert.AreEqual(ExpressionFactory.True, trueVal.Expression);
BoolHandle falseVal = false;
ExpressionTestHelper.CheckExpression(
falseVal.Expression,
ExpressionKind.Interpretation,
Sort.Bool,
false.ToString(),
0);
Assert.AreEqual(ExpressionFactory.False, falseVal.Expression);
}
