Fixed review issues

Author: Damtev

utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/visible/UtStreamConsumingException.kt

@@ -3,6 +3,9 @@ package org.utbot.framework.plugin.api.visible
 /**
  * An artificial exception that stores an exception that would be thrown in case of consuming stream by invoking terminal operations.
  * [innerException] stores this possible exception (null if [UtStreamConsumingException] was constructed by the engine).
+ *
+ * NOTE: this class should be visible in almost all parts of the tool - Soot, engine, concrete execution and code generation,
+ * that's the reason why this class is placed in this module and this package is called `visible`.
  */
 data class UtStreamConsumingException(private val innerException: Exception?) : RuntimeException() {
     /**

utbot-framework-test/src/test/kotlin/org/utbot/examples/threads/ExecutorServiceExamplesTest.kt

@@ -8,7 +8,8 @@ import org.utbot.testing.ignoreExecutionsNumber
 import org.utbot.testing.isException
 
 // IMPORTANT: most of the these tests test only the symbolic engine
-// and should not be used for testing conrete or code generation since they are possibly flaky in the real execution
+// and should not be used for testing conrete or code generation since they are possibly flaky in the concrete execution
+// (see https://github.com/UnitTestBot/UTBotJava/issues/1610)
 class ExecutorServiceExamplesTest : UtValueTestCaseChecker(testClass = ExecutorServiceExamples::class) {
     @Test
     fun testExceptionInExecute() {

utbot-framework-test/src/test/kotlin/org/utbot/examples/threads/FutureExamplesTest.kt

@@ -9,7 +9,8 @@ import org.utbot.testing.isException
 import java.util.concurrent.ExecutionException
 
 // IMPORTANT: most of the these tests test only the symbolic engine
-// and should not be used for testing conrete or code generation since they are possibly flaky in the real execution
+// and should not be used for testing conrete or code generation since they are possibly flaky in the concrete execution
+// (see https://github.com/UnitTestBot/UTBotJava/issues/1610)
 class FutureExamplesTest : UtValueTestCaseChecker(testClass = FutureExamples::class) {
     @Test
     fun testThrowingRunnable() {

utbot-framework-test/src/test/kotlin/org/utbot/examples/threads/ThreadExamplesTest.kt

@@ -8,7 +8,8 @@ import org.utbot.testing.ignoreExecutionsNumber
 import org.utbot.testing.isException
 
 // IMPORTANT: most of the these tests test only the symbolic engine
-// and should not be used for testing conrete or code generation since they are possibly flaky in the real execution
+// and should not be used for testing conrete or code generation since they are possibly flaky in the concrete execution
+// (see https://github.com/UnitTestBot/UTBotJava/issues/1610)
 class ThreadExamplesTest : UtValueTestCaseChecker(testClass = ThreadExamples::class) {
     @Test
     fun testExceptionInStart() {

utbot-framework/src/main/java/org/utbot/engine/overrides/threads/UtCompletableFuture.java

@@ -7,7 +7,6 @@
 import java.util.concurrent.Delayed;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
-import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
@@ -17,31 +16,23 @@
 import java.util.function.Function;
 
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
-import static org.utbot.engine.overrides.UtOverrideMock.alreadyVisited;
-import static org.utbot.engine.overrides.UtOverrideMock.visit;
 
-public class UtCompletableFuture<T> implements Future<T>, ScheduledFuture<T>, CompletionStage<T> {
+public class UtCompletableFuture<T> implements ScheduledFuture<T>, CompletionStage<T> {
     T result;
 
     Throwable exception;
 
     public UtCompletableFuture(T result) {
-        visit(this);
         this.result = result;
     }
 
-    public UtCompletableFuture() {
-        visit(this);
-    }
+    public UtCompletableFuture() {}
 
     public UtCompletableFuture(Throwable exception) {
-        visit(this);
         this.exception = exception;
     }
 
     public UtCompletableFuture(UtCompletableFuture<T> future) {
-        visit(this);
-
         result = future.result;
         exception = future.exception;
     }
@@ -51,12 +42,7 @@ public void eqGenericType(T ignoredValue) {
     }
 
     public void preconditionCheck() {
-        if (alreadyVisited(this)) {
-            return;
-        }
         eqGenericType(result);
-
-        visit(this);
     }
 
     @Override

utbot-framework/src/main/java/org/utbot/engine/overrides/threads/UtExecutorService.java

@@ -7,60 +7,36 @@
 import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
-import static org.utbot.engine.overrides.UtOverrideMock.alreadyVisited;
-import static org.utbot.engine.overrides.UtOverrideMock.visit;
-
-public class UtExecutorService implements ExecutorService, ScheduledExecutorService {
+public class UtExecutorService implements ScheduledExecutorService {
     private boolean isShutdown;
     private boolean isTerminated;
 
-    public UtExecutorService() {
-        visit(this);
-    }
-
-    private void preconditionCheck() {
-        if (alreadyVisited(this)) {
-            return;
-        }
-
-        visit(this);
-    }
-
     @Override
     public void shutdown() {
-        preconditionCheck();
-
         isShutdown = true;
         isTerminated = true;
     }
 
     @NotNull
     @Override
     public List<Runnable> shutdownNow() {
-        preconditionCheck();
-
         shutdown();
         // Since all tasks are processed immediately, there are no waiting tasks
         return new ArrayList<>();
     }
 
     @Override
     public boolean isShutdown() {
-        preconditionCheck();
-
         return isShutdown;
     }
 
     @Override
     public boolean isTerminated() {
-        preconditionCheck();
-
         return isTerminated;
     }
 
@@ -73,8 +49,6 @@ public boolean awaitTermination(long timeout, @NotNull TimeUnit unit) {
     @NotNull
     @Override
     public <T> Future<T> submit(@NotNull Callable<T> task) {
-        preconditionCheck();
-
         try {
             T result = task.call();
             return new UtCompletableFuture<>(result);
@@ -86,8 +60,6 @@ public <T> Future<T> submit(@NotNull Callable<T> task) {
     @NotNull
     @Override
     public <T> Future<T> submit(@NotNull Runnable task, T result) {
-        preconditionCheck();
-
         try {
             task.run();
             return new UtCompletableFuture<>(result);
@@ -105,8 +77,6 @@ public Future<?> submit(@NotNull Runnable task) {
     @NotNull
     @Override
     public <T> List<Future<T>> invokeAll(@NotNull Collection<? extends Callable<T>> tasks) {
-        preconditionCheck();
-
         List<Future<T>> results = new ArrayList<>();
         for (Callable<T> task : tasks) {
             results.add(submit(task));
@@ -124,8 +94,6 @@ public <T> List<Future<T>> invokeAll(@NotNull Collection<? extends Callable<T>>
     @NotNull
     @Override
     public <T> T invokeAny(@NotNull Collection<? extends Callable<T>> tasks) throws ExecutionException {
-        preconditionCheck();
-
         for (Callable<T> task : tasks) {
             try {
                 return task.call();
@@ -145,16 +113,12 @@ public <T> T invokeAny(@NotNull Collection<? extends Callable<T>> tasks, long ti
 
     @Override
     public void execute(@NotNull Runnable command) {
-        preconditionCheck();
-
         command.run();
     }
 
     @NotNull
     @Override
     public ScheduledFuture<?> schedule(@NotNull Runnable command, long delay, @NotNull TimeUnit unit) {
-        preconditionCheck();
-
         try {
             command.run();
             return new UtCompletableFuture<>();
@@ -166,8 +130,6 @@ public ScheduledFuture<?> schedule(@NotNull Runnable command, long delay, @NotNu
     @NotNull
     @Override
     public <V> ScheduledFuture<V> schedule(@NotNull Callable<V> callable, long delay, @NotNull TimeUnit unit) {
-        preconditionCheck();
-
         try {
             V result = callable.call();
             return new UtCompletableFuture<>(result);
@@ -179,8 +141,6 @@ public <V> ScheduledFuture<V> schedule(@NotNull Callable<V> callable, long delay
     @NotNull
     @Override
     public ScheduledFuture<?> scheduleAtFixedRate(@NotNull Runnable command, long initialDelay, long period, @NotNull TimeUnit unit) {
-        preconditionCheck();
-
         if (period <= 0) {
             throw new IllegalArgumentException();
         }
@@ -191,8 +151,6 @@ public ScheduledFuture<?> scheduleAtFixedRate(@NotNull Runnable command, long in
     @NotNull
     @Override
     public ScheduledFuture<?> scheduleWithFixedDelay(@NotNull Runnable command, long initialDelay, long delay, @NotNull TimeUnit unit) {
-        preconditionCheck();
-
         if (delay <= 0) {
             throw new IllegalArgumentException();
         }

utbot-framework/src/main/java/org/utbot/engine/overrides/threads/UtThreadGroup.java

@@ -101,7 +101,7 @@ public final void setMaxPriority(int pri) {
             return;
         }
 
-        for (int i = 0 ; i < ngroups ; i++) {
+        for (int i = 0; i < ngroups; i++) {
             groups[i].setMaxPriority(pri);
         }
     }
@@ -199,11 +199,11 @@ public final void stop() {
     public final void interrupt() {
         preconditionCheck();
 
-        for (int i = 0 ; i < nthreads ; i++) {
+        for (int i = 0; i < nthreads; i++) {
             threads[i].interrupt();
         }
 
-        for (int i = 0 ; i < ngroups ; i++) {
+        for (int i = 0; i < ngroups; i++) {
             groups[i].interrupt();
         }
     }
@@ -232,12 +232,12 @@ public final void destroy() {
             nthreads = 0;
             threads = null;
         }
-        for (int i = 0 ; i < ngroups ; i += 1) {
+        for (int i = 0; i < ngroups; i += 1) {
             groups[i].destroy();
         }
     }
 
-    private void add(ThreadGroup g){
+    private void add(ThreadGroup g) {
         preconditionCheck();
 
         if (destroyed) {
@@ -261,7 +261,7 @@ private void remove(ThreadGroup g) {
             return;
         }
 
-        for (int i = 0 ; i < ngroups ; i++) {
+        for (int i = 0; i < ngroups; i++) {
             if (groups[i] == g) {
                 ngroups -= 1;
                 System.arraycopy(groups, i + 1, groups, i, ngroups - i);

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

@@ -33,8 +33,10 @@ class Hierarchy(private val typeRegistry: TypeRegistry) {
         val realFieldDeclaringType = typeRegistry.findRealType(field.declaringClass.type) as RefType
 
         // java.lang.Thread class has package-private fields, that can be used outside the class.
-        // Since wrapper UtThread does not inherit java.lang.Thread, we cannot use this inheritance condition only
-        val realTypeHasFieldByName = realType.sootClass.getFieldByNameUnsafe(field.name) != null
+        // Since wrapper UtThread does not inherit java.lang.Thread, we cannot use this inheritance condition only.
+        // The possible presence of hidden field is not important here - we just need
+        // to know whether we have at least one such field.
+        val realTypeHasFieldByName = realType.sootClass.getFieldUnsafe(field.subSignature) != null
         val realTypeIsInheritor = realFieldDeclaringType.sootClass in ancestors(realType.sootClass.id)
 
         if (!realTypeIsInheritor && !realTypeHasFieldByName) {

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

@@ -65,7 +65,10 @@ import soot.Type
  *
  * Note: [staticInitial] contains mapping from [FieldId] to the memory state at the moment of the field initialization.
  *
- * [fieldValues] stores symbolic values for specified fields of the specified object instances.
+ * [fieldValues] stores symbolic values for specified fields of the concrete object instances.
+ * We need to associate field of a concrete instance with the created symbolic value to not lose an information about its type.
+ * For example, if field's declared type is Runnable but at the current state it is a specific lambda,
+ * we have to save this lambda as a type of this field to be able to retrieve it in the future.
  *
  * @see memoryForNestedMethod
  * @see FieldStates

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

@@ -75,6 +75,17 @@ val classToWrapper: MutableMap<TypeToBeWrapped, WrapperType> =
         putSootClass(java.lang.Thread::class, utThreadClass)
         putSootClass(java.lang.ThreadGroup::class, utThreadGroupClass)
 
+        // executors, futures and latches
+        putSootClass(ExecutorService::class, utExecutorServiceClass)
+        putSootClass(ThreadPoolExecutor::class, utExecutorServiceClass)
+        putSootClass(ForkJoinPool::class, utExecutorServiceClass)
+        putSootClass(ScheduledThreadPoolExecutor::class, utExecutorServiceClass)
+        putSootClass(CountDownLatch::class, utCountDownLatchClass)
+        putSootClass(CompletableFuture::class, utCompletableFutureClass)
+        putSootClass(CompletionStage::class, utCompletableFutureClass)
+        // A hack to be able to create UtCompletableFuture in its methods as a wrapper
+        putSootClass(UtCompletableFuture::class, utCompletableFutureClass)
+
         putSootClass(RangeModifiableUnlimitedArray::class, RangeModifiableUnlimitedArrayWrapper::class)
         putSootClass(AssociativeArray::class, AssociativeArrayWrapper::class)
 
@@ -228,9 +239,13 @@ private val wrappers = mapOf(
     wrap(SecurityManager::class) { type, addr -> objectValue(type, addr, SecurityManagerWrapper()) },
 ).also {
     // check every `wrapped` class has a corresponding value in [classToWrapper]
-    it.keys.all { key ->
+    val missedWrappers = it.keys.filterNot { key ->
         Scene.v().getSootClass(key.name).type in classToWrapper.keys
     }
+
+    require(missedWrappers.isEmpty()) {
+        "Missed wrappers for classes [${missedWrappers.joinToString(", ")}]"
+    }
 }
 
 private fun wrap(kClass: KClass<*>, implementation: (RefType, UtAddrExpression) -> ObjectValue) =