public void RequiresXMinusOne()
{
Init();
bool hitExpectedBreakPoint = false;
e.BreakPointReached += delegate(object executor, Executor.BreakPointEventArgs data)
{
if (data.Name != "cmodset")
{
return;
}
hitExpectedBreakPoint = true;
// Check for "requires x > -1" constraint
var xTuple = e.CurrentState.GetInScopeVariableAndExprByName("x");
var xVar = xTuple.Key;
// Find the symbolic associated with this variable
// FIXME: Broken
//var symbolicForX = e.CurrentState.Symbolics.Where( s => s.Origin.IsVariable && s.Origin.AsVariable == xVar).First();
SymbolicVariable symbolicForX = null; // Just so it compiles
// FIXME: Move constant construction functions to utility so can be shared across tests.
var expectedConstraint = Expr.Gt(symbolicForX.Expr, Expr.Neg(Builder.ConstantInt(1)));
int hasConstraint = e.CurrentState.Constraints.Constraints.Where(c => c.Condition.Equals(expectedConstraint)).Count();
Assert.AreEqual(1, hasConstraint);
};
e.Run(GetMain(p));
Assert.IsTrue(hitExpectedBreakPoint);
}
public void Global()
{
p = LoadProgramFrom("programs/CallAssignsToGlobal.bpl");
e = GetExecutor(p, new DFSStateScheduler(), GetSolver());
bool checkg = false;
bool checkg2 = false;
e.BreakPointReached += delegate(object executor, Executor.BreakPointEventArgs data)
{
if (data.Name != "checkg")
{
return;
}
checkg = true;
var gTuple = e.CurrentState.GetInScopeVariableAndExprByName("g");
Assert.IsInstanceOf <LiteralExpr>(gTuple.Value);
Assert.IsTrue((gTuple.Value as LiteralExpr).isBigNum);
Assert.AreEqual(BigNum.FromInt(2), (gTuple.Value as LiteralExpr).asBigNum);
};
e.BreakPointReached += delegate(object executor, Executor.BreakPointEventArgs data)
{
if (data.Name != "checkg2")
{
return;
}
checkg2 = true;
// The symbolic assigned to g2 should have a constraint that says it is equal to 3
var g2Tuple = e.CurrentState.GetInScopeVariableAndExprByName("g2");
var g2Expr = g2Tuple.Value;
Assert.IsTrue(e.IsSymbolic(g2Tuple.Key));
Assert.IsInstanceOf <IdentifierExpr>(g2Expr);
Assert.IsInstanceOf <SymbolicVariable>((g2Expr as IdentifierExpr).Decl);
var expectedConstraint = Expr.Eq(g2Expr, Builder.ConstantInt(3));
int found = e.CurrentState.Constraints.Constraints.Where(c => c.Condition.Equals(expectedConstraint)).Count();
Assert.AreEqual(1, found);
};
e.Run(GetMain(p));
Assert.IsTrue(checkg);
Assert.IsTrue(checkg2);
}
public override Expr VisitLiteralExpr(LiteralExpr node)
{
if (node.isBool)
{
return((Expr)Builder.ConstantBool(node.asBool));
}
else if (node.isBigNum)
{
return(Builder.ConstantInt(node.asBigNum.ToBigInteger));
}
else if (node.isBigDec)
{
return(Builder.ConstantReal(node.asBigDec));
}
else if (node.isBvConst)
{
var bv = node.asBvConst;
return(Builder.ConstantBV(bv.Value.ToBigInteger, bv.Bits));
}
else
{
throw new NotSupportedException("Unknown LiteralExpr type");
}
}
public void Integers()
{
var literal = Builder.ConstantInt(-15);
checkLiteral(literal, "-15");
}
public virtual LiteralExpr ConstantInt(int value)
{
return(UB.ConstantInt(value));
}
public void Integer()
{
CheckType(BasicType.Int, builder.ConstantInt(15), "Int", "(= symbolic_0 15 )");
}
