Register throw statements of the wrapper's methods in the global graph

Author: CaelmBleidd

utbot-framework/src/main/java/org/utbot/engine/overrides/collections/UtArrayList.java

@@ -82,7 +82,8 @@ void preconditionCheck() {
 
  int size = elementData.end;
  assume(elementData.begin == 0);
- assume(size >= 0 & size <= MAX_LIST_SIZE);
+ assume(size >= 0);
+ assume(size <= MAX_LIST_SIZE);
 
  visit(this);
  }

utbot-framework/src/main/java/org/utbot/engine/overrides/collections/UtLinkedList.java

@@ -78,7 +78,8 @@ private void preconditionCheck() {
  parameter(elementData);
  parameter(elementData.storage);
  assume(elementData.begin == 0);
- assume(elementData.end >= 0 & elementData.end <= MAX_LIST_SIZE);
+ assume(elementData.end >= 0);
+ assume(elementData.end <= MAX_LIST_SIZE);
 
  visit(this);
  }

utbot-framework/src/main/kotlin/org/utbot/engine/InterProceduralUnitGraph.kt

@@ -7,6 +7,7 @@ import soot.jimple.Stmt
 import soot.jimple.SwitchStmt
 import soot.jimple.internal.JReturnStmt
 import soot.jimple.internal.JReturnVoidStmt
+import soot.jimple.internal.JThrowStmt
 import soot.toolkits.graph.ExceptionalUnitGraph
 
 private const val EXCEPTION_DECISION_SHIFT = 100000
@@ -22,7 +23,16 @@ class InterProceduralUnitGraph(graph: ExceptionalUnitGraph) {
  private var attachAllowed = true
  val graphs = mutableListOf(graph)
  private val statistics = mutableListOf<TraverseGraphStatistics>()
- private val methods = mutableListOf(graph.body.method)
+ // All the methods in the InterProceduralUnitGraph
+ private val methods: MutableSet<SootMethod> = mutableSetOf(graph.body.method)
+ // Methods with registered edges
+ private val registeredMethods: MutableSet<SootMethod> = mutableSetOf(graph.body.method)
+
+ // We use this field for exceptional statements of the methods from the [registeredMethods] map.
+ // Points of interest are statements of the graph that must be covered during the exploration.
+ // Therefore, there is no need to put here statements from registered methods since
+ // we try to cover all of their edges.
+ private val methodToUncoveredThrowStatements: MutableMap<SootMethod, MutableSet<Stmt>> = mutableMapOf()
 
  private val unexceptionalSuccsCache = mutableMapOf<ExceptionalUnitGraph, Map<Stmt, Set<Stmt>>>()
  private val exceptionalSuccsCache = mutableMapOf<ExceptionalUnitGraph, Map<Stmt, Set<Stmt>>>()
@@ -41,9 +51,10 @@ class InterProceduralUnitGraph(graph: ExceptionalUnitGraph) {
  private val unexceptionalSuccs: MutableMap<Stmt, Set<Stmt>> = graph.unexceptionalSuccs.toMutableMap()
 
  private val stmtToGraph: MutableMap<Stmt, ExceptionalUnitGraph> = stmts.associateWithTo(mutableMapOf()) { graph }
+ private val edgeToGraph: MutableMap<Edge, ExceptionalUnitGraph> = graph.edges.associateWithTo(mutableMapOf()) { graph }
 
- val registeredEdgesCount: MutableMap<Stmt, Int> = graph.outgoingEdgesCount
- val outgoingEdgesCount: MutableMap<Stmt, Int> = graph.outgoingEdgesCount
+ private val registeredEdgesCount: MutableMap<Stmt, Int> = graph.outgoingEdgesCount
+ private val outgoingEdgesCount: MutableMap<Stmt, Int> = graph.outgoingEdgesCount
 
  fun method(stmt: Stmt): SootMethod = stmtToGraph[stmt]?.body?.method ?: error("$stmt not in graph.")
 
@@ -79,42 +90,65 @@ class InterProceduralUnitGraph(graph: ExceptionalUnitGraph) {
  private val ExceptionalUnitGraph.outgoingEdgesCount: MutableMap<Stmt, Int>
  get() = stmts.associateWithTo(mutableMapOf()) { succ(it).count() }
 
+ /**
+ * Returns a method that the [edge] is belongs to. If the [edge] does not
+ * have such method, null will be returned.
+ *
+ * Note: for example, implicit edges and edges produced by an invocation
+ * does not have a method they could belong to.
+ */
+ private fun methodByEdge(edge: Edge): SootMethod? = edgeToGraph[edge]?.body?.method
 
  /**
- * join new graph to stmt.
- * @param registerEdges - if true than edges
+ * Joins a new [graph] to the [stmt]. Depending on the [registerEdges], edges of the [graph]
+ * might be either registered in the global graph or not.
+ *
+ * If they are registered, path selector tries to cover all edges from the [graph].
  */
  fun join(stmt: Stmt, graph: ExceptionalUnitGraph, registerEdges: Boolean) {
  attachAllowed = false
+
  val invokeEdge = Edge(stmt, graph.head, CALL_DECISION_NUM)
- val alreadyJoined = graph.body.method in methods
+ val method = graph.body.method
+ val alreadyJoined = method in methods
+
  if (!alreadyJoined) {
  graphs += graph
- methods += graph.body.method
+ methods += method
  traps += graph.traps
  exceptionalSuccs += graph.exceptionalSuccs
  unexceptionalSuccs += graph.unexceptionalSuccs
 
- val joinedStmts = graph.stmts
- stmts += joinedStmts
- joinedStmts.forEach { stmtToGraph[it] = graph }
+ graph.edges.forEach { edgeToGraph[it] = graph }
+
+ val joinedStmts = graph.stmts.onEach { stmtToGraph[it] = graph }
  outgoingEdgesCount += graph.outgoingEdgesCount
+ stmts += joinedStmts
+
  if (registerEdges) {
+ registeredMethods += method
  registeredEdgesCount += graph.outgoingEdgesCount
  registeredEdges += graph.edges
  registeredEdgesCount.computeIfPresent(stmt) { _, value ->
  value + 1
  }
  }
+
+ // it is important to have this method call after we register the given method
+ // because we find uncoveredPoints for unregistered methods only
+ method.uncoveredThrowStatements()
  }
+
  invokeSuccessors.compute(stmt) { _, value ->
  value?.apply { add(graph.head) } ?: mutableSetOf(graph.head)
  }
+
  registeredEdges += invokeEdge
 
  outgoingEdgesCount.computeIfPresent(stmt) { _, value ->
  value + 1
  }
+
  statistics.forEach {
  it.onJoin(stmt, graph, registerEdges)
  }
@@ -129,9 +163,15 @@ class InterProceduralUnitGraph(graph: ExceptionalUnitGraph) {
  coveredOutgoingEdges.putIfAbsent(executionState.stmt, 0)
 
  for (edge in executionState.edges) {
+ markAsCoveredStmt(edge.src)
+ markAsCoveredStmt(edge.dst)
+
  when (edge) {
  in implicitEdges -> coveredImplicitEdges += edge
- !in registeredEdges -> coveredOutgoingEdges.putIfAbsent(edge.src, 0)
+ !in registeredEdges -> {
+ coveredOutgoingEdges.putIfAbsent(edge.src, 0)
+ coveredEdges += edge
+ }
  !in coveredEdges -> {
  coveredOutgoingEdges.compute(edge.src) { _, value -> (value ?: 0) + 1 }
  coveredEdges += edge
@@ -143,6 +183,43 @@ class InterProceduralUnitGraph(graph: ExceptionalUnitGraph) {
  }
  }
 
+ /**
+ * Returns uncovered throw statements for [this] method.
+ */
+ private fun SootMethod.uncoveredThrowStatements(): Set<Stmt> {
+ val throwStatements = methodToUncoveredThrowStatements[this]
+
+ if (throwStatements != null) {
+ return throwStatements
+ }
+
+ // We don't have to additionally specify throw statements
+ // since for the registeredMethods we try to cover all of their edges.
+ if (this in registeredMethods) {
+ return emptySet()
+ }
+
+ // We don't want to cover all the exceptions in not overridden library classes
+ if (declaringClass.isLibraryClass && !declaringClass.isOverridden) {
+ return emptySet()
+ }
+
+ val uncoveredThrowStatements = methodToUncoveredThrowStatements.getOrPut(this) { mutableSetOf() }
+
+ if (!canRetrieveBody()) {
+ return uncoveredThrowStatements
+ }
+
+ uncoveredThrowStatements += jimpleBody().units.filterIsInstance<JThrowStmt>()
+
+ return uncoveredThrowStatements
+ }
+
+ private fun markAsCoveredStmt(stmt: Stmt) {
+ val method = methodByStmt(stmt)
+ methodToUncoveredThrowStatements[method]?.remove(stmt)
+ }
+
  /**
  * register new implicit edge, that is not represented in graph
  */
@@ -215,11 +292,34 @@ class InterProceduralUnitGraph(graph: ExceptionalUnitGraph) {
  (edge in coveredEdges || edge !in registeredEdges)
  }
 
+ /**
+ * If the [edge] does not have associated method, returns a result of [isCovered] call.
+ * Otherwise, there are several cases:
+ * * If the [edge] in [coveredEdges], returns true;
+ * * If the [edge] belongs to a method of some overridden class and there is
+ * uncovered throw statements in it, returns false;
+ * * In all other cases, returns whether the [edge] absent in [registeredEdges].
+ */
+ fun isCoveredWithAllThrowStatements(edge: Edge): Boolean {
+ val method = methodByEdge(edge) ?: return isCovered(edge)
+ 
+ if (edge in coveredEdges) {
+ return true
+ }
+
+ if (method.declaringClass.isOverridden && method.uncoveredThrowStatements().isNotEmpty()) {
+ return false
+ }
+
+ return edge !in registeredEdges
+ }
 
  /**
  * @return true if stmt has more than one outgoing edge
  */
  fun isFork(stmt: Stmt): Boolean = (outgoingEdgesCount[stmt] ?: 0) > 1
+
+ private fun methodByStmt(stmt: Stmt) = stmtToGraph.getValue(stmt).body.method
 }
 
 private fun ExceptionalUnitGraph.succ(stmt: Stmt): Sequence<Stmt> = exceptionalSucc(stmt) + unexceptionalSucc(stmt)

utbot-framework/src/main/kotlin/org/utbot/engine/selectors/strategies/DistanceStatistics.kt

@@ -35,11 +35,11 @@ class DistanceStatistics(
  graph.stmts.associateWithTo(mutableMapOf()) { 0 }
 
  /**
- * Drops executionState if all the edges on path are covered and
- * there is no reachable uncovered statement
+ * Drops executionState if all the edges on path are covered (with respect to uncovered
+ * throw statements of the methods they belong to) and there is no reachable and uncovered statement.
  */
  override fun shouldDrop(state: ExecutionState) =
- state.edges.all { graph.isCovered(it) } && distanceToUncovered(state) == Int.MAX_VALUE
+ state.edges.all { graph.isCoveredWithAllThrowStatements(it) } && distanceToUncovered(state) == Int.MAX_VALUE
 
  fun isCovered(edge: Edge): Boolean = graph.isCovered(edge)
 

utbot-framework/src/main/kotlin/org/utbot/engine/selectors/strategies/EdgeVisitCountingStatistics.kt

@@ -31,7 +31,7 @@ class EdgeVisitCountingStatistics(
  * - all statements are already covered and execution is complete
  */
  override fun shouldDrop(state: ExecutionState): Boolean {
- return state.edges.all { graph.isCovered(it) } && state.isComplete()
+ return state.edges.all { graph.isCoveredWithAllThrowStatements(it) } && state.isComplete()
  }
 
  /**

utbot-framework/src/test/kotlin/org/utbot/examples/strings/StringExamplesTest.kt

@@ -328,7 +328,7 @@ internal class StringExamplesTest : AbstractTestCaseGeneratorTest(
  fun testSubstringWithEndIndex() {
  checkWithException(
  StringExamples::substringWithEndIndex,
- between(6..8),
+ ignoreExecutionsNumber,
  { s, _, _, r -> s == null && r.isException<NullPointerException>() },
  { s, b, e, r -> s != null && b < 0 || e > s.length || b > e && r.isException<StringIndexOutOfBoundsException>() },
  { s, b, e, r -> r.getOrThrow() == s.substring(b, e) && s.substring(b, e) != "password" },
@@ -346,7 +346,7 @@ internal class StringExamplesTest : AbstractTestCaseGeneratorTest(
  fun testSubstringWithEndIndexNotEqual() {
  checkWithException(
  StringExamples::substringWithEndIndexNotEqual,
- between(3..4),
+ ignoreExecutionsNumber,
  { s, _, r -> s == null && r.isException<NullPointerException>() },
  { s, e, r -> s != null && e < 1 || e > s.length && r.isException<StringIndexOutOfBoundsException>() },
  { s, e, r -> s != null && r.getOrThrow() == s.substring(1, e) },