public void SimpleForAllWithTrigger()
{
var builder = GetSimpleBuilder();
var freeVarX = GetVariable("x", BasicType.Int);
var xid = new IdentifierExpr(Token.NoToken, freeVarX);
var fb = new FunctionCallBuilder();
var funcCall = fb.CreateUninterpretedFunctionCall("f", BPLType.Int, new List <BPLType>()
{
BPLType.Int
});
var body = builder.Gt(builder.UFC(funcCall, xid), xid);
// Single trigger
var triggers = new Microsoft.Boogie.Trigger(Token.NoToken,
/*positive=*/ true,
new List <Expr>()
{
builder.UFC(funcCall, xid)
}, null);
var result = builder.ForAll(new List <Variable>()
{
freeVarX
}, body, triggers);
Assert.AreEqual("(forall x: int :: { f(x) } f(x) > x)", result.ToString());
CheckIsBoolType(result);
}
public void simpleUF()
{
var builder = GetSimpleBuilder();
var FCB = new FunctionCallBuilder();
var func = FCB.CreateUninterpretedFunctionCall("foo", BasicType.Bool, new List <Microsoft.Boogie.Type>()
{
BasicType.Real,
BasicType.Int,
BasicType.GetBvType(8)
});
var root = builder.UFC(func, builder.ConstantReal("0.0"), builder.ConstantInt(5), builder.ConstantBV(5, 8));
Assert.AreEqual("foo(0e0, 5, 5bv8)", root.ToString());
DuplicateAndCheck(root, builder);
}
public void TestCase()
{
var FCB = new FunctionCallBuilder();
var functionCall = FCB.CreateUninterpretedFunctionCall("uf", Microsoft.Boogie.Type.Bool, new List <Microsoft.Boogie.Type>()
{
Microsoft.Boogie.Type.Int,
Microsoft.Boogie.Type.Real
});
var e = SEB.UFC(functionCall, SEB.ConstantInt(5), SEB.ConstantReal("5.5"));
// FIXME: This needs to be factored out
using (var writer = new StringWriter())
{
var printer = GetPrinter(writer);
printer.AddDeclarations(e);
printer.PrintFunctionDeclarations();
printer.PrintExpr(e);
Assert.AreEqual("(declare-fun uf (Int Real ) Bool)" + Environment.NewLine + "(uf 5 5.5 )", writer.ToString());
}
}
public void RemoveOneConstraintBasedOnVarsAndFunctions()
{
IConstraintManager CM = new ConstraintManager();
var builder = GetBuilder();
// Dummy Boogie variable
var bv8Type = Microsoft.Boogie.Type.GetBvType(8);
var bv8TypeIdent = new TypedIdent(Token.NoToken, "bv8", bv8Type);
var dummyVarBv = new GlobalVariable(Token.NoToken, bv8TypeIdent);
// dummyVar needs a programLocation, otherwise SymbolicVariable constructor raises an exception
var progLoc = new ProgramLocation(dummyVarBv);
dummyVarBv.SetMetadata <ProgramLocation>((int)Symbooglix.Annotation.AnnotationIndex.PROGRAM_LOCATION, progLoc);
var s0 = new SymbolicVariable("s0", dummyVarBv).Expr;
var s1 = new SymbolicVariable("s1", dummyVarBv).Expr;
var s2 = new SymbolicVariable("s2", dummyVarBv).Expr;
// Construct some constraints
Expr c0 = builder.Eq(builder.BVAND(s0, s1), builder.ConstantBV(0, 8));
Expr c1 = builder.Eq(s2, builder.ConstantBV(1, 8));
var FCB = new FunctionCallBuilder();
var foobarFunc = FCB.CreateUninterpretedFunctionCall("foobar", bv8Type, new List <Microsoft.Boogie.Type>()
{
bv8Type
});
// foobar(0bv8) == 0bv8
Expr c2 = builder.Eq(builder.UFC(foobarFunc, builder.ConstantBV(0, 8)), builder.ConstantBV(0, 8));
CM.AddConstraint(c0, progLoc);
CM.AddConstraint(c1, progLoc);
CM.AddConstraint(c2, progLoc);
var mockSolver = new MockSolver();
var indepenceSolver = new Symbooglix.Solver.ConstraintIndependenceSolver(mockSolver);
// The query expression does not use the "foobar" function so we don't need to keep constraints on that function
Expr queryExpr = builder.Eq(builder.BVAND(s1, s2), builder.ConstantBV(0, 8));
indepenceSolver.ComputeSatisfiability(new Solver.Query(CM, new Constraint(queryExpr)));
// Check no constraints were removed
Assert.AreEqual(2, mockSolver.Constraints.Count);
Assert.AreSame(queryExpr, mockSolver.QueryExpr);
bool c0Found = false;
bool c1Found = false;
foreach (var constraint in mockSolver.Constraints)
{
if (c0 == constraint.Condition)
{
c0Found = true;
}
if (c1 == constraint.Condition)
{
c1Found = true;
}
}
Assert.IsTrue(c0Found);
Assert.IsTrue(c1Found);
}