Fix no targets for invocation for abstract this type

Author: CaelmBleidd

utbot-framework-test/src/test/kotlin/org/utbot/examples/objects/AbstractAnonymousClassTest.kt

@@ -0,0 +1,27 @@
+package org.utbot.examples.objects
+
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.utbot.testcheckers.eq
+import org.utbot.testing.UtValueTestCaseChecker
+
+class AbstractAnonymousClassTest : UtValueTestCaseChecker(testClass = AbstractAnonymousClass::class) {
+    @Test
+    fun testNonOverriddenMethod() {
+        check(
+            AbstractAnonymousClass::methodWithoutOverrides,
+            eq(1)
+        )
+    }
+
+    @Test
+    fun testOverriddenMethod() {
+        // check we have error during execution
+        assertThrows<org.opentest4j.AssertionFailedError> {
+            check(
+                AbstractAnonymousClass::methodWithOverride,
+                eq(0)
+            )
+        }
+    }
+}

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

@@ -1365,7 +1365,45 @@ class Traverser(
                 possibleConcreteTypes
             )
         } else {
-            typeStoragePossiblyWithOverriddenTypes
+            if (addr.isThisAddr) {
+                val possibleTypes = typeStoragePossiblyWithOverriddenTypes.possibleConcreteTypes
+                val isTypeInappropriate = type.sootClass?.isInappropriate == true
+
+                // If we're trying to construct this instance and it has an inappropriate type,
+                // we won't be able to instantiate its instance in resulting tests.
+                // Therefore, we have to test one of its inheritors that does not override
+                // the method under test
+                if (isTypeInappropriate) {
+                    require(possibleTypes.isNotEmpty()) {
+                        "We do not support testing for abstract classes (or interfaces) without any non-abstract " +
+                                "inheritors (implementors). Probably, it'll be supported in the future."
+                    }
+
+                    val possibleTypesWithNonOverriddenMethod = possibleTypes
+                        .filterTo(mutableSetOf()) {
+                            val methods = (it as RefType).sootClass.methods
+                            methods.none { method ->
+                                val methodUnderTest = environment.method
+                                val parameterTypes = method.parameterTypes
+
+                                method.name == methodUnderTest.name && parameterTypes == methodUnderTest.parameterTypes
+                            }
+                        }
+
+                    require(possibleTypesWithNonOverriddenMethod.isNotEmpty()) {
+                        "There is no instantiatable inheritor of the class under test that does not override " +
+                                "a method given for testing"
+                    }
+
+                    TypeStorage.constructTypeStorageUnsafe(type, possibleTypesWithNonOverriddenMethod)
+                } else {
+                    // If we create a `this` instance and its type is instantiatable,
+                    // we should construct a type storage with single type
+                    TypeStorage.constructTypeStorageWithSingleType(type)
+                }
+            } else {
+                typeStoragePossiblyWithOverriddenTypes
+            }
         }
 
         val typeHardConstraint = typeRegistry.typeConstraint(addr, typeStorage).all().asHardConstraint()
@@ -2238,7 +2276,7 @@ class Traverser(
                 if (type.sootClass.isEnum) {
                     createEnum(type, addr)
                 } else {
-                    createObject(addr, type, useConcreteType = addr.isThisAddr, mockInfoGenerator)
+                    createObject(addr, type, useConcreteType = false, mockInfoGenerator)
                 }
             }
             is VoidType -> voidValue

utbot-sample/src/main/java/org/utbot/examples/objects/AbstractAnonymousClass.java

@@ -4,6 +4,22 @@ abstract class AbstractAnonymousClass {
     abstract int constValue();
     abstract int add(int x);
 
+    public int methodWithoutOverrides(int x, int y) {
+        return y + addFortyTwo(x);
+    }
+
+    public int methodWithOverride(int x, int y) {
+        return y + addNumber(x);
+    }
+
+    public int addFortyTwo(int x) {
+        return x + 42;
+    }
+
+    public int addNumber(int x) {
+        return x + 27;
+    }
+
     public static AbstractAnonymousClass getInstance(int x) {
         if (x % 2 == 0) {
             return new AnonymousClassAlternative();
@@ -19,6 +35,11 @@ int constValue() {
             int add(int x) {
                 return x + 15;
             }
+
+            @Override
+            public int methodWithOverride(int x, int y) {
+                return x + 37;
+            }
         };
     }
 }
@@ -33,4 +54,9 @@ int constValue() {
     int add(int x) {
         return x + 1;
     }
+
+    @Override
+    public int methodWithOverride(int x, int y) {
+        return x + 17;
+    }
 }