Fix filtering of UtMockAssumptionViolatedException

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

@@ -248,6 +248,11 @@ class UtBotSymbolicEngine(
                             val concreteExecutionResult =
                                 concreteExecutor.executeConcretely(methodUnderTest, stateBefore, instrumentation)
 
+                            if (concreteExecutionResult.violatesUtMockAssumption()) {
+                                logger.debug { "Generated test case violates the UtMock assumption: $concreteExecutionResult" }
+                                return@bracket
+                            }
+
                             val concreteUtExecution = UtSymbolicExecution(
                                 stateBefore,
                                 concreteExecutionResult.stateAfter,
@@ -368,8 +373,8 @@ class UtBotSymbolicEngine(
             // in case an exception occurred from the concrete execution
             concreteExecutionResult ?: return@runJavaFuzzing BaseFeedback(result = Trie.emptyNode(), control = Control.PASS)
 
-            if (concreteExecutionResult.result.exceptionOrNull() is UtMockAssumptionViolatedException) {
-                logger.debug { "Generated test case by fuzzer violates the UtMock assumption" }
+            if (concreteExecutionResult.violatesUtMockAssumption()) {
+                logger.debug { "Generated test case by fuzzer violates the UtMock assumption: $concreteExecutionResult" }
                 return@runJavaFuzzing BaseFeedback(result = Trie.emptyNode(), control = Control.PASS)
             }
 
@@ -497,6 +502,11 @@ class UtBotSymbolicEngine(
                     instrumentation
                 )
 
+                if (concreteExecutionResult.violatesUtMockAssumption()) {
+                    logger.debug { "Generated test case violates the UtMock assumption: $concreteExecutionResult" }
+                    return
+                }
+
                 val concolicUtExecution = symbolicUtExecution.copy(
                     stateAfter = concreteExecutionResult.stateAfter,
                     result = concreteExecutionResult.result,
@@ -593,3 +603,11 @@ private fun makeWrapperConsistencyCheck(
     val visitedSelectExpression = memory.isVisited(symbolicValue.addr)
     visitedConstraints += mkEq(visitedSelectExpression, mkInt(1))
 }
+
+private fun UtConcreteExecutionResult.violatesUtMockAssumption(): Boolean {
+    // We should compare FQNs instead of `if (... is UtMockAssumptionViolatedException)`
+    // because the exception from the `concreteExecutionResult` is loaded by user's ClassLoader,
+    // but the `UtMockAssumptionViolatedException` is loaded by the current ClassLoader,
+    // so we can't cast them to each other.
+    return result.exceptionOrNull()?.javaClass?.name == UtMockAssumptionViolatedException::class.java.name
+}

utbot-instrumentation/src/main/kotlin/org/utbot/instrumentation/util/KryoHelper.kt

@@ -12,6 +12,7 @@ import com.esotericsoftware.kryo.kryo5.serializers.JavaSerializer
 import com.esotericsoftware.kryo.kryo5.util.DefaultInstantiatorStrategy
 import com.jetbrains.rd.util.lifetime.Lifetime
 import com.jetbrains.rd.util.lifetime.throwIfNotAlive
+import org.utbot.api.exception.UtMockAssumptionViolatedException
 import org.utbot.framework.plugin.api.TimeoutException
 import java.io.ByteArrayOutputStream
 
@@ -123,6 +124,7 @@ internal class TunedKryo : Kryo() {
 
         this.setOptimizedGenerics(false)
         register(TimeoutException::class.java, TimeoutExceptionSerializer())
+        register(UtMockAssumptionViolatedException::class.java, UtMockAssumptionViolatedExceptionSerializer())
 
         // TODO: JIRA:1492
         addDefaultSerializer(java.lang.Throwable::class.java, JavaSerializer())
@@ -149,4 +151,19 @@ internal class TunedKryo : Kryo() {
         override fun read(kryo: Kryo?, input: Input, type: Class<out TimeoutException>?): TimeoutException =
             TimeoutException(input.readString())
     }
+
+    /**
+     * Specific serializer for [UtMockAssumptionViolatedException] - [JavaSerializer] is not applicable
+     * because [UtMockAssumptionViolatedException] is not in class loader.
+     */
+    private class UtMockAssumptionViolatedExceptionSerializer : Serializer<UtMockAssumptionViolatedException>() {
+        override fun write(kryo: Kryo, output: Output, value: UtMockAssumptionViolatedException) {
+            output.writeString(value.message)
+        }
+
+        override fun read(kryo: Kryo?, input: Input, type: Class<out UtMockAssumptionViolatedException>?): UtMockAssumptionViolatedException {
+            input.readString() // shift the reading position
+            return UtMockAssumptionViolatedException()
+        }
+    }
 }