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,15 @@
+package org.utbot.examples.objects
+
+import org.junit.jupiter.api.Test
+import org.utbot.testcheckers.eq
+import org.utbot.testing.UtValueTestCaseChecker
+
+class AbstractAnonymousClassTest : UtValueTestCaseChecker(testClass = AbstractAnonymousClass::class) {
+    @Test
+    fun testNonOverriddenMethod() {
+        check(
+            AbstractAnonymousClass::methodWithoutOverrides,
+            eq(1)
+        )
+    }
+}

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

@@ -1365,7 +1365,34 @@ class Traverser(
                 possibleConcreteTypes
             )
         } else {
-            typeStoragePossiblyWithOverriddenTypes
+            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 (addr.isThisAddr && isTypeInappropriate) {
+                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()) {
+                    "We do not support testing for abstract classes (or interfaces) without any non-abstract " +
+                            "inheritors (implementors). Probably, it'll be supported in the future."
+                }
+
+                TypeStorage.constructTypeStorageUnsafe(type, possibleTypesWithNonOverriddenMethod)
+            } else {
+                typeStoragePossiblyWithOverriddenTypes
+            }
         }
 
         val typeHardConstraint = typeRegistry.typeConstraint(addr, typeStorage).all().asHardConstraint()
@@ -2238,7 +2265,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,14 @@ abstract class AbstractAnonymousClass {
     abstract int constValue();
     abstract int add(int x);
 
+    public int methodWithoutOverrides(int x, int y) {
+        return y + addFortyTwo(x);
+    }
+
+    public int addFortyTwo(int x) {
+        return x + 42;
+    }
+
     public static AbstractAnonymousClass getInstance(int x) {
         if (x % 2 == 0) {
             return new AnonymousClassAlternative();