private Collection<ARGState> getNonCoveredStatesInSubgraph(ARGState pRoot) {
Collection<ARGState> subgraph = new HashSet<>();
for (ARGState state : pRoot.getSubgraph()) {
if (!state.isCovered()) {
subgraph.add(state);
}
}
return subgraph;
}
protected boolean checkCertificate(
ReachedSet pReachedSet, ARGState pRoot, @Nullable List<ARGState> incompleteStates)
throws CPAException, InterruptedException {
// TODO does not account for strengthen yet (proof check will fail if strengthen is needed to
// explain successor states)
initChecking(pRoot);
logger.log(Level.INFO, "Proof check algorithm started");
ARGState initialState = (ARGState) pReachedSet.popFromWaitlist();
Precision initialPrecision = pReachedSet.getPrecision(initialState);
logger.log(Level.FINE, "Checking root state");
if (!checkCovering(initialState, pRoot, initialPrecision)) {
return false;
}
pReachedSet.add(pRoot, initialPrecision);
do {
if (!prepareNextWaitlistIteration(pReachedSet)) {
return false;
}
while (pReachedSet.hasWaitingState()) {
shutdownNotifier.shutdownIfNecessary();
stats.increaseIteration();
ARGState state = (ARGState) pReachedSet.popFromWaitlist();
logger.log(Level.FINE, "Looking at state", state);
if (!checkForStatePropertyAndOtherStateActions(state)) {
logger.log(Level.INFO, "Property violation at state", state);
return false;
}
if (state.isCovered()) {
if (!checkCoveredStates(state, pReachedSet, initialPrecision)) {
return false;
}
} else {
if (!checkAndAddSuccessors(state, pReachedSet, initialPrecision, incompleteStates)) {
return false;
}
}
}
} while (!isCheckComplete());
stats.increaseProofSize(pReachedSet.size() - 1);
return isCheckSuccessful();
}
private boolean isCoveringCycleFree(ARGState pState) {
HashSet<ARGState> seen = new HashSet<>();
seen.add(pState);
while (pState.isCovered()) {
pState = pState.getCoveringState();
boolean isNew = seen.add(pState);
if (!isNew) {
return false;
}
}
return true;
}
private VariableTrackingPrecision mergeAllValuePrecisionsFromSubgraph(
ARGState refinementRoot, UnmodifiableReachedSet reached) {
VariableTrackingPrecision rootPrecision =
Precisions.extractPrecisionByType(
reached.getPrecision(refinementRoot), VariableTrackingPrecision.class);
// find all distinct precisions to merge them
Set<Precision> precisions = Sets.newIdentityHashSet();
for (ARGState state : refinementRoot.getSubgraph()) {
if (!state.isCovered()) {
// covered states are not in reached set
precisions.add(reached.getPrecision(state));
}
}
for (Precision prec : precisions) {
rootPrecision =
rootPrecision.join(
Precisions.extractPrecisionByType(prec, VariableTrackingPrecision.class));
}
return rootPrecision;
}
private ARGState getUncoveredSuccessor(ARGState pMaybeCovered) {
while (pMaybeCovered.isCovered()) {
pMaybeCovered = pMaybeCovered.getCoveringState();
}
return pMaybeCovered;
}
public void writeCoverageReport(
final PrintStream pStatisticsOutput, final ReachedSet pReached, final CFA pCfa) {
if (!enabled) {
return;
}
Multiset<FunctionEntryNode> reachedLocations = getFunctionEntriesFromReached(pReached);
Map<String, FileCoverageInformation> infosPerFile = new HashMap<>();
// Add information about existing functions
for (FunctionEntryNode entryNode : pCfa.getAllFunctionHeads()) {
final FileLocation loc = entryNode.getFileLocation();
if (loc.getStartingLineNumber() == 0) {
// dummy location
continue;
}
final String functionName = entryNode.getFunctionName();
final FileCoverageInformation infos = getFileInfoTarget(loc, infosPerFile);
final int startingLine = loc.getStartingLineInOrigin();
final int endingLine = loc.getEndingLineInOrigin();
infos.addExistingFunction(functionName, startingLine, endingLine);
if (reachedLocations.contains(entryNode)) {
infos.addVisitedFunction(entryNode.getFunctionName(), reachedLocations.count(entryNode));
}
}
// Add information about existing locations
for (CFANode node : pCfa.getAllNodes()) {
for (int i = 0; i < node.getNumLeavingEdges(); i++) {
handleExistedEdge(node.getLeavingEdge(i), infosPerFile);
}
}
Set<CFANode> reachedNodes =
from(pReached).transform(EXTRACT_LOCATION).filter(notNull()).toSet();
// Add information about visited locations
for (AbstractState state : pReached) {
ARGState argState = AbstractStates.extractStateByType(state, ARGState.class);
if (argState != null) {
for (ARGState child : argState.getChildren()) {
if (!child.isCovered()) {
List<CFAEdge> edges = argState.getEdgesToChild(child);
if (edges.size() > 1) {
for (CFAEdge innerEdge : edges) {
handleCoveredEdge(innerEdge, infosPerFile);
}
// BAM produces paths with no edge connection thus the list will be empty
} else if (!edges.isEmpty()) {
handleCoveredEdge(Iterables.getOnlyElement(edges), infosPerFile);
}
}
}
} else {
// Simple kind of analysis
// Cover all edges from reached nodes
// It is less precise, but without ARG it is impossible to know what path we chose
CFANode node = AbstractStates.extractLocation(state);
for (int i = 0; i < node.getNumLeavingEdges(); i++) {
CFAEdge edge = node.getLeavingEdge(i);
if (reachedNodes.contains(edge.getSuccessor())) {
handleCoveredEdge(edge, infosPerFile);
}
}
}
}
for (CoverageWriter w : reportWriters) {
w.write(infosPerFile, pStatisticsOutput);
}
}
