public override Counterexample extractLoopTrace(Counterexample cex, string mainProcName, Program program,
Dictionary<string, Dictionary<string, Block>> extractLoopMappingInfo)
{
// Construct the set of inlined procs in the original program
var inlinedProcs = new HashSet<string>();
foreach (var decl in program.TopLevelDeclarations)
{
// Implementations
if (decl is Implementation)
{
var impl = decl as Implementation;
if (!(impl.Proc is LoopProcedure))
{
inlinedProcs.Add(impl.Name);
}
}
// And recording procedures
if (decl is Procedure)
{
var proc = decl as Procedure;
if (proc.Name.StartsWith(recordProcName))
{
Debug.Assert(!(decl is LoopProcedure));
inlinedProcs.Add(proc.Name);
}
}
}
return extractLoopTraceRec(
new CalleeCounterexampleInfo(cex, new List<object>()),
mainProcName, inlinedProcs, extractLoopMappingInfo).counterexample;
}
public async Task NotifyCounterexampleAsync(Counterexample counterexample)
{
if (_predicate(counterexample))
{
await _innerNotifier.NotifyCounterexampleAsync(counterexample);
}
}
private void DisplayParameterValues(Counterexample error)
{
if (impl.InParams.Count() == 0)
{
return;
}
string funName = QKeyValue.FindStringAttribute(impl.Attributes, "source_name");
Debug.Assert(funName != null);
Console.Error.WriteLine("Bitwise values of parameters of '" + funName + "':");
PopulateModelWithStatesIfNecessary(error);
foreach (var p in impl.InParams)
{
int id;
string stripped = CleanOriginalProgramVariable(p.Name, out id);
Console.Error.Write(" " + stripped + " = ");
var VariableName = p.Name;
Console.Error.Write(ExtractVariableValueFromModel(VariableName, error.Model));
Console.Error.WriteLine((id == 1 || id == 2) ? " (" + ThreadDetails(error.Model, id, false) + ")" : "");
}
Console.Error.WriteLine();
}
private static IEnumerable <string> BuildLines(
Counterexample <object?> counterexample,
int iterations,
int shrinks,
Func <string, string>?formatReproduction)
{
const string LineBreak = "";
yield return(FalsifiedAfterLine(iterations, shrinks));
yield return(ReproductionLine(counterexample, formatReproduction));
yield return(CounterexampleValueLine(counterexample));
yield return(LineBreak);
if (counterexample.Exception == null)
{
yield return("Property function returned false");
}
else
{
yield return(ExceptionLine(counterexample.Exception));
}
}
public int ReportCounterexample(Counterexample error)
{
Contract.Requires(error != null);
int errors = 0;
if (error is AssertCounterexample)
{
AssertCounterexample cex = error as AssertCounterexample;
if (QKeyValue.FindBoolAttribute(cex.FailingAssert.Attributes, "race_checking"))
{
errors += this.ReportRace(cex);
}
else
{
if (ToolCommandLineOptions.Get().VerboseMode)
{
Output.PrintLine("..... Error: AssertCounterexample");
}
errors++;
}
}
if (errors > 0)
{
this.FoundErrors = true;
}
return(errors);
}
private static int RecBound(string recFunc, Counterexample trace, string traceName)
{
var ret = 0;
if (trace == null)
{
return(ret);
}
if (recFunc == traceName)
{
ret++;
}
for (int numBlock = 0; numBlock < trace.Trace.Count; numBlock++)
{
Block b = trace.Trace[numBlock];
for (int numInstr = 0; numInstr < b.Cmds.Count; numInstr++)
{
Cmd c = b.Cmds[numInstr];
var loc = new TraceLocation(numBlock, numInstr);
if (trace.calleeCounterexamples.ContainsKey(loc))
{
ret +=
RecBound(recFunc, trace.calleeCounterexamples[loc].counterexample,
(c as CallCmd).Proc.Name);
}
}
}
return(ret);
}
public override async Task NotifyCounterexampleAsync(Counterexample counterexample)
{
var formatted = Formatter.Format(counterexample);
var path = _pathGenerator(counterexample);
await File.WriteAllTextAsync(path, formatted, Encoding.UTF8);
}
private static void PopulateModelWithStatesIfNecessary(Counterexample Cex)
{
if (!Cex.ModelHasStatesAlready)
{
Cex.PopulateModelWithStates();
Cex.ModelHasStatesAlready = true;
}
}
private void PopulateModelWithStatesIfNecessary(Counterexample cex)
{
if (!cex.ModelHasStatesAlready)
{
cex.PopulateModelWithStates();
cex.ModelHasStatesAlready = true;
}
}
//private readonly Dictionary<IToken, List<ErrorCode>> reportedVerificationErrors = new Dictionary<IToken, List<ErrorCode>>();
//private readonly List<string> errors = new List<string>();
public void ReportCounterexample(Counterexample ce, string message)
{
if (message != null)
{
message = " (" + message + ")";
}
else
{
message = "";
}
try {
ReturnCounterexample /*?*/ rce = ce as ReturnCounterexample;
if (rce != null)
{
IToken tok = rce.FailingReturn.tok;
for (int i = rce.Trace.Length - 1; i >= 0; i--)
{
foreach (Cmd c in rce.Trace[i].Cmds)
{
AssertCmd assrt = c as AssertCmd;
if (assrt != null)
{
NAryExpr nary = assrt.Expr as NAryExpr;
if (nary != null)
{
FunctionCall fcall = nary.Fun as FunctionCall;
if (fcall != null && fcall.FunctionName == "$position_marker")
{
tok = assrt.tok;
}
}
}
}
}
ReportOutcomePostconditionFailed(rce.FailingEnsures.tok, tok, message);
}
AssertCounterexample /*?*/ ace = ce as AssertCounterexample;
if (ace != null)
{
ReportOutcomeAssertFailed(ace.FailingAssert.tok,
(ace.FailingAssert is LoopInvMaintainedAssertCmd ? "Loop body invariant" :
ace.FailingAssert is LoopInitAssertCmd ? "Loop entry invariant" : "Assertion"),
message
);
}
CallCounterexample /*?*/ cce = ce as CallCounterexample;
if (cce != null)
{
ReportOutcomePreconditionFailed(cce.FailingCall.tok, cce.FailingRequires, message);
}
} finally {
if (commandLineOptions != null && commandLineOptions.PrintCEVModel)
{
ce.PrintModel();
}
}
}
public override Task NotifyCounterexampleAsync(Counterexample counterexample)
{
var formatted = Formatter.Format(counterexample);
Console.WriteLine($"Counter-example for {counterexample.TestMethod.Name}:");
Console.WriteLine(formatted);
return(Task.CompletedTask);
}
private static string GetStateName(QKeyValue Attributes, Counterexample Cex)
{
Contract.Requires(QKeyValue.FindStringAttribute(Attributes, "check_id") != null);
string CheckId = QKeyValue.FindStringAttribute(Attributes, "check_id");
return(QKeyValue.FindStringAttribute(
(Cex.Trace.Last().Cmds.OfType <AssumeCmd>().Where(
Item => QKeyValue.FindStringAttribute(Item.Attributes, "check_id") == CheckId).ToList()[0]
).Attributes, "captureState"));
}
public PropertyFailedException(
Counterexample <object?> counterexample,
int iterations,
int shrinks,
Func <string, string>?formatReproduction,
Func <string, string>?formatMessage)
: base(FormatMessage(formatMessage, BuildMessage(counterexample, iterations, shrinks, formatReproduction)))
{
_counterexample = counterexample;
}
private static Counterexample <object?> BoxCounterexample <T>(Counterexample <T> counterexample)
{
var value = (object)counterexample.Value !;
return(new Counterexample <object?>(
counterexample.Id,
value,
counterexample.Distance,
counterexample.ReplayParameters,
counterexample.ReplayPath,
counterexample.Replay,
counterexample.Exception,
counterexample.PresentationalValue));
}
private void DisplayLoopAbstractions(Counterexample error)
{
PopulateModelWithStatesIfNecessary(error);
Program OriginalProgram = GetOriginalProgram();
var CFG = OriginalProgram.ProcessLoops(GetOriginalImplementation(OriginalProgram));
for (int i = 0; i < error.Trace.Count(); i++)
{
MaybeDisplayLoopHeadState(error.Trace[i], CFG, error.Model, OriginalProgram);
if (i < error.Trace.Count() - 1)
{
MaybeDisplayLoopEntryState(error.Trace[i], error.Trace[i + 1], CFG, error.Model, OriginalProgram);
}
MaybeDisplayLoopBackEdgeState(error.Trace[i], CFG, error.Model, OriginalProgram);
}
}
public void Basic()
{
var arguments = new[]
{
new Argument("number", 4),
new Argument("string", "hello"),
};
var counterexample = new Counterexample(Mock.Of <MethodInfo>(), arguments);
var formatted = new JsonFormatter().Format(counterexample);
var expected = @"{
""number"": 4,
""string"": ""hello""
}";
Assert.That.AreEqualIgnoreNewlineStyle(expected, formatted);
}
public int ReportCounterexample(Counterexample error)
{
Contract.Requires(error != null);
int errors = 0;
if (error is AssertCounterexample)
{
AssertCounterexample cex = error as AssertCounterexample;
if (QKeyValue.FindBoolAttribute(cex.FailingAssert.Attributes, "race_checking"))
{
errors += this.ReportRace(cex);
}
else
{
Console.WriteLine("Error: AssertCounterexample");
errors++;
}
}
else if (error is CallCounterexample)
{
CallCounterexample cex = error as CallCounterexample;
Console.WriteLine(cex.FailingRequires.Condition);
Console.WriteLine(cex.FailingRequires.Line);
Console.WriteLine("Error: CallCounterexample");
this.ReportRequiresFailure(cex);
errors++;
}
else if (error is ReturnCounterexample)
{
Console.WriteLine((error as ReturnCounterexample).FailingEnsures.Condition);
Console.WriteLine((error as ReturnCounterexample).FailingEnsures.Line);
Console.WriteLine("Error: ReturnCounterexample");
errors++;
}
if (errors > 0)
{
this.FoundErrors = true;
}
return(errors);
}
public static string MakeHTMLForExample(Counterexample aCounterexample)
{
if (aCounterexample == null)
{
return("<p>This proposition is self-contradictory; there are no examples.</p>");
}
else if (aCounterexample is KindOfWorld)
{
return("<div class=\"counterexample\"><h3>Example</h3><p>This is a kind of world in which the statement is true.</p>"
+ MakeHTML(aCounterexample as KindOfWorld, @"black") + "</div>");
}
else if (aCounterexample is ModalCounterexample)
{
return(MakeHTMLForExample(aCounterexample as ModalCounterexample));
}
else
{
throw new EngineException("Unhandled subclass of Counterexample encountered in MakeHTML: {0}", aCounterexample.GetType());
}
}
private static void printLabels(Counterexample cex, TokenTextWriter ttw, int indent)
{
for (int numBlock = 0; numBlock < cex.Trace.Count; numBlock++)
{
Block b = cex.Trace[numBlock];
printIndent(ttw, indent);
ttw.WriteLine(b.Label);
for (int numInstr = 0; numInstr < b.Cmds.Count; numInstr++)
{
Cmd c = b.Cmds[numInstr];
var loc = new TraceLocation(numBlock, numInstr);
if (cex.calleeCounterexamples.ContainsKey(loc))
{
printIndent(ttw, indent); ttw.WriteLine("call to {0}:", (c as CallCmd).Proc.Name);
printLabels(cex.calleeCounterexamples[loc].counterexample, ttw, indent + 1);
printIndent(ttw, indent); ttw.WriteLine("return from {0}.", (c as CallCmd).Proc.Name);
printIndent(ttw, indent); ttw.WriteLine(b.Label);
}
}
}
}
/// <summary>
/// Generates the errors from the counter example.
/// </summary>
/// <param name="example">The counter example.</param>
/// <param name="implementation">The implementation.</param>
/// <returns>The error.</returns>
private IEnumerable <Error> GenerateErrors(Counterexample example, Implementation implementation)
{
List <Error> errors = new List <Error>();
if (example is CallCounterexample)
{
CallCounterexample callCounterexample = example as CallCounterexample;
if (QKeyValue.FindBoolAttribute(callCounterexample.FailingRequires.Attributes, "barrier_divergence"))
{
DivergenceError divergence = new DivergenceError(example, implementation);
ErrorReporter reporter = new ErrorReporter(program, implementation.Name);
reporter.PopulateDivergenceInformation(callCounterexample, divergence);
IdentifyVariables(divergence);
errors.Add(divergence);
return(errors);
}
else if (QKeyValue.FindBoolAttribute(callCounterexample.FailingRequires.Attributes, "race"))
{
RaceError template = new RaceError(example, implementation);
ErrorReporter reporter = new ErrorReporter(program, implementation.Name);
IEnumerable <RaceError> races = reporter.GetRaceInformation(callCounterexample, template);
foreach (RaceError race in races)
{
IdentifyVariables(race);
}
errors.AddRange(races);
return(errors);
}
}
errors.Add(new Error(example, implementation));
return(errors);
}
//private readonly Dictionary<IToken, List<ErrorCode>> reportedVerificationErrors = new Dictionary<IToken, List<ErrorCode>>();
//private readonly List<string> errors = new List<string>();
public void ReportCounterexample(Counterexample ce, string message)
{
if (message != null) message = " (" + message + ")";
else message = "";
try {
ReturnCounterexample/*?*/ rce = ce as ReturnCounterexample;
if (rce != null) {
IToken tok = rce.FailingReturn.tok;
for (int i = rce.Trace.Length - 1; i >= 0; i--) {
foreach (Cmd c in rce.Trace[i].Cmds) {
AssertCmd assrt = c as AssertCmd;
if (assrt != null) {
NAryExpr nary = assrt.Expr as NAryExpr;
if (nary != null) {
FunctionCall fcall = nary.Fun as FunctionCall;
if (fcall != null && fcall.FunctionName == "$position_marker") {
tok = assrt.tok;
}
}
}
}
}
ReportOutcomePostconditionFailed(rce.FailingEnsures.tok, tok, message);
}
AssertCounterexample/*?*/ ace = ce as AssertCounterexample;
if (ace != null) {
ReportOutcomeAssertFailed(ace.FailingAssert.tok,
(ace.FailingAssert is LoopInvMaintainedAssertCmd ? "Loop body invariant" :
ace.FailingAssert is LoopInitAssertCmd ? "Loop entry invariant" : "Assertion"),
message
);
}
CallCounterexample/*?*/ cce = ce as CallCounterexample;
if (cce != null)
ReportOutcomePreconditionFailed(cce.FailingCall.tok, cce.FailingRequires, message);
} finally {
if (commandLineOptions != null && commandLineOptions.PrintCEVModel) {
ce.PrintModel();
}
}
}
public BoogieErrorTrace(Counterexample c, Implementation m, Program p)
{
cex = c;
impl = m;
prog = p;
}
// Note: this does not reconstruct the failing assert in trace
public static void ReconstructImperativeTrace(Counterexample trace, string currProc, Dictionary <string, Implementation> origProg)
{
if (trace == null)
{
return;
}
var originalBlocks = BoogieUtil.labelBlockMapping(origProg[currProc]);
var newBlocks = new List <Block>();
var newCalleeTraces = new Dictionary <TraceLocation, CalleeCounterexampleInfo>();
for (int numBlock = 0; numBlock < trace.Trace.Count; numBlock++)
{
Block b = trace.Trace[numBlock];
Block ib;
originalBlocks.TryGetValue(b.Label, out ib);
if (ib == null)
{
// Such blocks correspond to "itermediate" blocks inserted
// by Boogie. We can ignore them. (But note that we should
// still check that the counterexample is a valid path in impl
// to guard against vagaries of Boogie.)
//Log.Out(Log.Normal, "Could not find block " + b.Label);
//b.Emit(new TokenTextWriter(Console.Out), 0);
for (int numInstr = 0; numInstr < b.Cmds.Count; numInstr++)
{
if (trace.calleeCounterexamples.ContainsKey(new TraceLocation(numBlock, numInstr)))
{
throw new InternalError("BoogieVerify: An intermediate block has a procedure call");
}
}
}
else
{
// We have a corresponding block. The number of Commands in b and ib won't match. We
// simply use all of the Cmds of ib -- and match the calls manually
// TODO: Fix this! It doesn't work when the failing assert is not the last statement
// of the block
newBlocks.Add(ib);
var calleeTraces = new List <Duple <string, CalleeCounterexampleInfo> >();
for (int numInstr = 0; numInstr < b.Cmds.Count; numInstr++)
{
var loc = new TraceLocation(numBlock, numInstr);
if (trace.calleeCounterexamples.ContainsKey(loc))
{
Cmd c = b.Cmds[numInstr];
var calleeName = trace.getCalledProcName(c);
var calleeTrace = trace.calleeCounterexamples[loc].counterexample;
ReconstructImperativeTrace(calleeTrace, calleeName, origProg);
calleeTraces.Add(
new Duple <string, CalleeCounterexampleInfo>(
calleeName,
new CalleeCounterexampleInfo(calleeTrace,
trace.calleeCounterexamples[loc].args)
));
}
}
// Check consistency and map calleeTraces to the actual call instructions
var currCount = 0;
for (int numInstr = 0; numInstr < ib.Cmds.Count; numInstr++)
{
Cmd c = ib.Cmds[numInstr];
if (!(c is CallCmd))
{
continue;
}
var cc = c as CallCmd;
// No more calls left to process
if (calleeTraces.Count <= currCount)
{
break;
}
if (cc.Proc.Name != calleeTraces[currCount].fst)
{
continue;
}
// Check if this proc has an implementation
//if (!origProg.ContainsKey(cc.Proc.Name))
// continue;
// Check if the proc is inlined
//if (QKeyValue.FindExprAttribute(cc.Proc.Attributes, "inline") == null)
// continue;
// Some thing wrong about the interprocedural trace returned by Boogie if the
// following don't match
// TODO: Fix when the failing assert is not the last statement of the block
//Debug.Assert(cc.Proc.Name == calleeTraces[currCount].fst);
newCalleeTraces.Add(new TraceLocation(newBlocks.Count - 1, numInstr), calleeTraces[currCount].snd);
currCount++;
}
}
}
trace.Trace = newBlocks;
// reset other info. Safe thing to do unless we know what it is
trace.calleeCounterexamples = newCalleeTraces;
}
public static Counterexample ReconstructTrace(Counterexample trace, string currProc, TraceLocation currLocation, Dictionary <string, Tuple <Block, Implementation> > origProg)
{
// we cannot be starting in the last block
Debug.Assert(currLocation.numBlock != trace.Trace.Count - 1);
// we cannot be starting in the middle of a block
Debug.Assert(currLocation.numInstr == 0);
var newTrace = new List <Block>();
var newTraceCallees = new Dictionary <TraceLocation, CalleeCounterexampleInfo>();
Block currOrigBlock = null;
Implementation currOrigImpl = null;
int currOrigInstr = 0;
while (true)
{
if (currLocation.numInstr == 0 && origProg.ContainsKey(trace.Trace[currLocation.numBlock].Label))
{
var origPlace = origProg[trace.Trace[currLocation.numBlock].Label];
if (currOrigImpl != null && currOrigImpl.Name != origPlace.Item2.Name)
{
// change of proc
// First, recurse
var calleeTrace = ReconstructTrace(trace, origPlace.Item2.Name, currLocation, origProg);
// Find the call to this guy in currOrigBlock
while (currOrigInstr < currOrigBlock.Cmds.Count)
{
var cmd = currOrigBlock.Cmds[currOrigInstr] as CallCmd;
if (cmd != null && cmd.callee == origPlace.Item2.Name)
{
break;
}
currOrigInstr++;
}
Debug.Assert(currOrigInstr != currOrigBlock.Cmds.Count);
newTraceCallees.Add(new TraceLocation(newTrace.Count - 1, currOrigInstr), new CalleeCounterexampleInfo(calleeTrace, new List <object>()));
// we're done
break;
}
currOrigBlock = origPlace.Item1;
currOrigImpl = origProg[trace.Trace[currLocation.numBlock].Label].Item2;
currOrigInstr = 0;
newTrace.Add(currOrigBlock);
}
if (trace.calleeCounterexamples.ContainsKey(currLocation))
{
// find the corresponding call in origBlock
var calleeInfo = trace.calleeCounterexamples[currLocation];
var calleeName = trace.getCalledProcName(trace.Trace[currLocation.numBlock].Cmds[currLocation.numInstr]);
while (currOrigInstr < currOrigBlock.Cmds.Count)
{
var cmd = currOrigBlock.Cmds[currOrigInstr] as CallCmd;
if (cmd != null && cmd.callee == calleeName)
{
break;
}
currOrigInstr++;
}
Debug.Assert(currOrigInstr != currOrigBlock.Cmds.Count);
newTraceCallees.Add(new TraceLocation(newTrace.Count - 1, currOrigInstr), calleeInfo);
}
// increment location
currLocation.numInstr++;
if (currLocation.numInstr >= trace.Trace[currLocation.numBlock].Cmds.Count)
{
currLocation.numBlock++;
currLocation.numInstr = 0;
}
if (currLocation.numBlock == trace.Trace.Count)
{
break;
}
}
var ret = new AssertCounterexample(newTrace, null, null, trace.Model, trace.MvInfo, trace.Context);
ret.calleeCounterexamples = newTraceCallees;
return(ret);
}
public abstract Task NotifyCounterexampleAsync(Counterexample counterexample);
internal void ReportCounterexample(Counterexample error)
{
int WindowWidth;
try {
WindowWidth = Console.WindowWidth;
} catch (IOException) {
WindowWidth = 20;
}
for (int i = 0; i < WindowWidth; i++)
{
Console.Error.Write("-");
}
if (error is CallCounterexample)
{
CallCounterexample CallCex = (CallCounterexample)error;
if (QKeyValue.FindBoolAttribute(CallCex.FailingRequires.Attributes, "barrier_divergence"))
{
ReportBarrierDivergence(CallCex.FailingCall);
}
else if (QKeyValue.FindBoolAttribute(CallCex.FailingRequires.Attributes, "race"))
{
ReportRace(CallCex);
}
else
{
ReportRequiresFailure(CallCex.FailingCall, CallCex.FailingRequires);
}
}
else if (error is ReturnCounterexample)
{
ReturnCounterexample ReturnCex = (ReturnCounterexample)error;
ReportEnsuresFailure(ReturnCex.FailingEnsures);
}
else
{
AssertCounterexample AssertCex = (AssertCounterexample)error;
if (AssertCex.FailingAssert is LoopInitAssertCmd)
{
ReportInvariantEntryFailure(AssertCex);
}
else if (AssertCex.FailingAssert is LoopInvMaintainedAssertCmd)
{
ReportInvariantMaintedFailure(AssertCex);
}
else if (QKeyValue.FindBoolAttribute(AssertCex.FailingAssert.Attributes, "barrier_invariant"))
{
ReportFailingBarrierInvariant(AssertCex);
}
else if (QKeyValue.FindBoolAttribute(AssertCex.FailingAssert.Attributes, "barrier_invariant_access_check"))
{
ReportFailingBarrierInvariantAccessCheck(AssertCex);
}
else if (QKeyValue.FindBoolAttribute(AssertCex.FailingAssert.Attributes, "constant_write"))
{
ReportFailingConstantWriteCheck(AssertCex);
}
else if (QKeyValue.FindBoolAttribute(AssertCex.FailingAssert.Attributes, "bad_pointer_access"))
{
ReportFailingBadPointerAccess(AssertCex);
}
else if (QKeyValue.FindBoolAttribute(AssertCex.FailingAssert.Attributes, "array_bounds"))
{
ReportFailingArrayBounds(AssertCex);
}
else
{
ReportFailingAssert(AssertCex);
}
}
DisplayParameterValues(error);
if (((GVCommandLineOptions)CommandLineOptions.Clo).DisplayLoopAbstractions)
{
DisplayLoopAbstractions(error);
}
}
private static string BuildMessage(
Counterexample <object?> counterexample,
int iterations,
int shrinks,
Func <string, string>?formatReproduction) =>
string.Join(Environment.NewLine, BuildLines(counterexample, iterations, shrinks, formatReproduction));
/// <summary>
/// Instantiates a new error.
/// </summary>
/// <param name="counterExample">The counter example.</param>
/// <param name="implementation">The implementation.</param>
public Error(Counterexample counterExample, Implementation implementation)
{
CounterExample = counterExample;
Implementation = implementation;
}
public override void OnCounterexample(Counterexample ce, string message)
{
this.modelCount++;
this.PrintSummary(VC.ConditionGeneration.Outcome.Errors);
this.errorHandler.ReportCounterexample(ce, message);
}
private static string ReproductionLine(
Counterexample <object?> counterexample,
Func <string, string>?formatReproduction)
{
private void OnCreateCounterexample(Counterexample response, Dictionary <string, object> customData)
{
Log.Debug("ExampleAssistant.OnCreateCounterexample()", "Response: {0}", customData["json"].ToString());
_createCounterexampleTested = true;
}
private Tuple<List<Tuple<string, List<Model.Element>>>, List<Tuple<string, List<Model.Element>>>> P_ExtractState(string impl, Counterexample error)
{
var lastBlock = error.Trace.Last() as Block;
AssertCmd failingAssert = null;
CallCounterexample callCounterexample = error as CallCounterexample;
if (callCounterexample != null)
{
Procedure failingProcedure = callCounterexample.FailingCall.Proc;
Requires failingRequires = callCounterexample.FailingRequires;
failingAssert = lastBlock.Cmds.OfType<AssertRequiresCmd>().FirstOrDefault(ac => ac.Requires == failingRequires);
}
ReturnCounterexample returnCounterexample = error as ReturnCounterexample;
if (returnCounterexample != null)
{
Ensures failingEnsures = returnCounterexample.FailingEnsures;
failingAssert = lastBlock.Cmds.OfType<AssertEnsuresCmd>().FirstOrDefault(ac => ac.Ensures == failingEnsures);
}
AssertCounterexample assertCounterexample = error as AssertCounterexample;
if (assertCounterexample != null)
{
failingAssert = lastBlock.Cmds.OfType<AssertCmd>().FirstOrDefault(ac => ac == assertCounterexample.FailingAssert);
}
Debug.Assert(failingAssert != null);
// extract the lhs of the returned tuple from the AssumeCmds
List<Tuple<string, List<Model.Element>>> lhs = new List<Tuple<string, List<Model.Element>>>();
foreach (var cmd in error.AssumedCmds)
{
AssumeCmd assumeCmd = cmd as AssumeCmd;
Debug.Assert(assumeCmd != null);
lhs.AddRange(P_ExtractState(impl, assumeCmd.Expr, error.Model));
}
List<Tuple<string, List<Model.Element>>> rhs = new List<Tuple<string, List<Model.Element>>>();
rhs = P_ExtractState(impl, failingAssert.Expr, error.Model);
return Tuple.Create(lhs, rhs);
}
public override Counterexample extractLoopTrace(Counterexample cex, string mainProcName, Program program, Dictionary<string, Dictionary<string, Block>> extractLoopMappingInfo)
{
// Construct the set of inlined procs in the original program
var inlinedProcs = new HashSet<string>();
foreach (var decl in program.TopLevelDeclarations)
{
// Implementations
if (decl is Implementation)
{
var impl = decl as Implementation;
if (!(impl.Proc is LoopProcedure))
{
inlinedProcs.Add(impl.Name);
}
}
// And recording procedures
if (decl is Procedure)
{
var proc = decl as Procedure;
if (proc.Name.StartsWith(recordProcName))
{
// Debug.Assert(!(decl is LoopProcedure));
inlinedProcs.Add(proc.Name);
}
}
}
return extractLoopTraceRec(
new CalleeCounterexampleInfo(cex, new List<object>()),
mainProcName, inlinedProcs, extractLoopMappingInfo).counterexample;
}
public override void OnCounterexample(Counterexample ce, string reason)
{
//numErrors++;
if (container.HandleCounterExample(currImpl, ce))
{
real_errors.Add(ce);
}
else
{
conjecture_errors.Add(ce);
}
//funcsChanged.UnionWith(
// container.HandleCounterExample(currImpl, ce));
}
/*
public void AddNewInvConstraintToZ3Context()
{
List<Term> args = new List<Term>();
foreach(var funcName in function2Value.Keys)
{
args.Add(function2Value[funcName].currLearnedInvAsTerm(ref z3Context));
}
Context context = z3Context.context;
context.AssertCnstr(context.MkNot(context.MkAnd(args.ToArray())));
}*/
public bool HandleCounterExample(string impl, Counterexample error)
{
// return true if a true error encountered.
// return false if the error is due to a wrong choice of current conjecture.
VCisValid = false;
var cex = P_ExtractState(impl, error);
// the counter-example does not involve any existential function ==> Is a real counter-example !
if (cex.Item1.Count == 0 && cex.Item2.Count == 0)
{
realErrorEncountered = true;
return true;
}
AddCounterExample(cex);
AddCounterExampleToZ3Context(cex);
/*
AddNewInvConstraintToZ3Context();
*/
newSamplesAdded = true;
return false;
}
private List<Tuple<string, List<Model.Element>>> ExtractState(string impl, Counterexample error)
{
var lastBlock = error.Trace.Last() as Block;
AssertCmd failingAssert = null;
CallCounterexample callCounterexample = error as CallCounterexample;
if (callCounterexample != null)
{
Procedure failingProcedure = callCounterexample.FailingCall.Proc;
Requires failingRequires = callCounterexample.FailingRequires;
failingAssert = lastBlock.Cmds.OfType<AssertRequiresCmd>().FirstOrDefault(ac => ac.Requires == failingRequires);
}
ReturnCounterexample returnCounterexample = error as ReturnCounterexample;
if (returnCounterexample != null)
{
Ensures failingEnsures = returnCounterexample.FailingEnsures;
failingAssert = lastBlock.Cmds.OfType<AssertEnsuresCmd>().FirstOrDefault(ac => ac.Ensures == failingEnsures);
}
AssertCounterexample assertCounterexample = error as AssertCounterexample;
if (assertCounterexample != null)
{
failingAssert = lastBlock.Cmds.OfType<AssertCmd>().FirstOrDefault(ac => ac == assertCounterexample.FailingAssert);
}
Debug.Assert(failingAssert != null);
return ExtractState(impl, failingAssert.Expr, error.Model);
}
public bool HandleCounterExample(string impl, Counterexample error, out bool counterExampleAdded)
{
// return true if a true error encountered.
// return false if the error is due to a wrong choice of current conjecture.
counterExampleAdded = false;
VCisValid = false;
var cex = P_ExtractState(impl, error);
// the counter-example does not involve any existential function ==> Is a real counter-example !
if (cex.Item1.Count == 0 && cex.Item2.Count == 0)
{
realErrorEncountered = true;
return true;
}
if (!newSamplesAdded || (cex.Item1.Count == 1 && cex.Item2.Count == 0) || (cex.Item2.Count == 1 && cex.Item1.Count == 0))
{
AddCounterExample(cex);
counterExampleAdded = true;
}
newSamplesAdded = true;
return false;
}
private static ErrorInformation CreateErrorInformation(Counterexample error, VC.VCGen.Outcome outcome)
{
// BP1xxx: Parsing errors
// BP2xxx: Name resolution errors
// BP3xxx: Typechecking errors
// BP4xxx: Abstract interpretation errors (Is there such a thing?)
// BP5xxx: Verification errors
ErrorInformation errorInfo;
var cause = "Error";
if (outcome == VCGen.Outcome.TimedOut)
{
cause = "Timed out on";
}
else if (outcome == VCGen.Outcome.OutOfMemory)
{
cause = "Out of memory on";
}
var callError = error as CallCounterexample;
var returnError = error as ReturnCounterexample;
var assertError = error as AssertCounterexample;
if (callError != null)
{
errorInfo = errorInformationFactory.CreateErrorInformation(callError.FailingCall.tok, callError.FailingCall.ErrorData as string ?? "A precondition for this call might not hold.", callError.RequestId, callError.OriginalRequestId, cause);
errorInfo.BoogieErrorCode = "BP5002";
errorInfo.Kind = ErrorKind.Precondition;
errorInfo.AddAuxInfo(callError.FailingRequires.tok, callError.FailingRequires.ErrorData as string ?? "This is the precondition that might not hold.", "Related location");
if (!CommandLineOptions.Clo.ForceBplErrors && callError.FailingRequires.ErrorMessage != null)
{
errorInfo = errorInformationFactory.CreateErrorInformation(null, callError.FailingRequires.ErrorMessage, callError.RequestId, callError.OriginalRequestId, cause);
}
}
else if (returnError != null)
{
errorInfo = errorInformationFactory.CreateErrorInformation(returnError.FailingReturn.tok, "A postcondition might not hold on this return path.", returnError.RequestId, returnError.OriginalRequestId, cause);
errorInfo.BoogieErrorCode = "BP5003";
errorInfo.Kind = ErrorKind.Postcondition;
errorInfo.AddAuxInfo(returnError.FailingEnsures.tok, returnError.FailingEnsures.ErrorData as string ?? "This is the postcondition that might not hold.", "Related location");
if (!CommandLineOptions.Clo.ForceBplErrors && returnError.FailingEnsures.ErrorMessage != null)
{
errorInfo = errorInformationFactory.CreateErrorInformation(null, returnError.FailingEnsures.ErrorMessage, returnError.RequestId, returnError.OriginalRequestId, cause);
}
}
else // error is AssertCounterexample
{
if (assertError.FailingAssert is LoopInitAssertCmd)
{
errorInfo = errorInformationFactory.CreateErrorInformation(assertError.FailingAssert.tok, "This loop invariant might not hold on entry.", assertError.RequestId, assertError.OriginalRequestId, cause);
errorInfo.BoogieErrorCode = "BP5004";
errorInfo.Kind = ErrorKind.InvariantEntry;
}
else if (assertError.FailingAssert is LoopInvMaintainedAssertCmd)
{
errorInfo = errorInformationFactory.CreateErrorInformation(assertError.FailingAssert.tok, "This loop invariant might not be maintained by the loop.", assertError.RequestId, assertError.OriginalRequestId, cause);
errorInfo.BoogieErrorCode = "BP5005";
errorInfo.Kind = ErrorKind.InvariantMaintainance;
}
else
{
var msg = assertError.FailingAssert.ErrorData as string;
var tok = assertError.FailingAssert.tok;
if (!CommandLineOptions.Clo.ForceBplErrors && assertError.FailingAssert.ErrorMessage != null)
{
msg = assertError.FailingAssert.ErrorMessage;
tok = null;
if (cause == "Error")
{
cause = null;
}
}
string bec = null;
if (msg == null)
{
msg = "This assertion might not hold.";
bec = "BP5001";
}
errorInfo = errorInformationFactory.CreateErrorInformation(tok, msg, assertError.RequestId, assertError.OriginalRequestId, cause);
errorInfo.BoogieErrorCode = bec;
errorInfo.Kind = ErrorKind.Assertion;
}
}
return errorInfo;
}
public bool HandleCounterExample(string impl, Counterexample error, out bool cexAdded)
{
// return true if a true error encountered.
// return false if the error is due to a wrong choice of current conjecture.
VCisValid = false;
var cex = P_ExtractState(impl, error);
// the counter-example does not involve any existential function ==> Is a real counter-example !
if (cex.Item1.Count == 0 && cex.Item2.Count == 0)
{
//realErrorEncountered = true;
cexAdded = false;
return true;
}
#if true
if (cex.Item1.Count == 0 || cex.Item2.Count == 0)
{
cexAdded = true;
AddCounterExample(cex);
return false;
}
else
{
cexAdded = false;
implicationCounterExamples.Add(cex);
return false;
}
/*
if (!this.posNegCexAdded || (cex.Item1.Count == 0 || cex.Item2.Count == 0))
{
// Record the cex. Is a positive or negative cex or is the first occurence of the implications
if(cex.Item1.Count == 0 || cex.Item2.Count == 0)
this.posNegCexAdded = true;
cexAdded = true;
AddCounterExample(cex);
newSamplesAdded = true;
return false;
}
else
{
#if false
AddCounterExample(cex, false);
#endif
cexAdded = false;
return false;
}
*/
#else
cexAdded = true;
AddCounterExample(cex);
newSamplesAdded = true;
return false;
#endif
}
/// <summary>
/// Instantiates a new error.
/// </summary>
/// <param name="counterExample">The counter example.</param>
/// <param name="implementation">The implementation.</param>
public RaceError(Counterexample counterExample, Implementation implementation)
: base(counterExample, implementation)
{
}
public override void OnCounterexample(Counterexample ce, string reason)
{
//numErrors++;
#if Pranav
bool counterExampleAdded;
if (container.HandleCounterExample(currImpl, ce, out counterExampleAdded))
{
real_errors.Add(ce);
}
else
{
if (counterExampleAdded)
{
conjecture_errors.Add(ce);
}
}
#endif
bool cexAdded;
if (container.HandleCounterExample(currImpl, ce, out cexAdded))
{
real_errors.Add(ce);
}
else
{
if (cexAdded)
{
conjecture_errors.Add(ce);
}
else
{
implication_errors.Add(ce);
}
}
//funcsChanged.UnionWith(
// container.HandleCounterExample(currImpl, ce));
}
