Disabled concrete enums processing for when initializing from external statics

Author: Kamenev Yury

utbot-framework/src/main/kotlin/org/utbot/engine/util/statics/concrete/EnumConcreteUtils.kt

@@ -15,6 +15,7 @@ import soot.SootClass
 import soot.SootField
 import soot.SootMethod
 import soot.Type
+import soot.Value
 import soot.jimple.StaticFieldRef
 import soot.jimple.Stmt
 import soot.jimple.internal.JAssignStmt
@@ -154,18 +155,23 @@ fun SootClass.isEnumAffectingExternalStatics(typeResolver: TypeResolver): Boolea
     // enum <clinit> active body contains <init> invocations so we can check only <clinit>
     val staticInitializer = staticInitializerOrNull() ?: return false
 
-    return staticInitializer.isAffectingExternalStatics(this, mutableSetOf(), typeResolver)
+    val implementedInterfaces = typeResolver
+        .findOrConstructAncestorsIncludingTypes(type)
+        .filter { type -> type.sootClass.isInterface }
+
+    return staticInitializer.isTouchingExternalStatics(this, mutableSetOf(), implementedInterfaces)
 }
 
 /**
- * Returns whether [this] method affects any statics from any types except [currentClass] and its interfaces.
+ * Returns whether [this] method touches any statics from any types
+ * except [currentClass] and its interfaces in [currentClassImplementedInterfaces].
  *
- * NOTE: see org.utbot.examples.enums.ClassWithEnum.EnumWithStaticAffectingInit for examples.
+ * NOTE: see org.utbot.examples.enums.ClassWithEnum.{EnumWithStaticAffectingInit, OuterStaticUsageEnum} for examples.
  */
-fun SootMethod.isAffectingExternalStatics(
+fun SootMethod.isTouchingExternalStatics(
     currentClass: SootClass,
     alreadyProcessed: MutableSet<SootMethod>,
-    typeResolver: TypeResolver
+    currentClassImplementedInterfaces: List<Type>
 ): Boolean {
     if (this in alreadyProcessed) {
         return false
@@ -187,28 +193,48 @@ fun SootMethod.isAffectingExternalStatics(
         when (it) {
             is JAssignStmt -> {
                 val leftOp = it.leftOp
+                val rightOp = it.rightOp
 
-                if (leftOp !is StaticFieldRef) {
-                    return@any false
-                }
-
-                val declaringClass = leftOp.field.declaringClass
+                val assigningOuterStatics =
+                    isExternalStaticField(leftOp, currentClassImplementedInterfaces, currentClass)
 
-                val currentClassImplementedInterfaces = typeResolver
-                    .findOrConstructAncestorsIncludingTypes(currentClass.type)
-                    .filter { type -> type.sootClass.isInterface }
-                val inImplementedInterfaces = declaringClass.type in currentClassImplementedInterfaces
+                val assignmentFromOuterStatics =
+                    isExternalStaticField(rightOp, currentClassImplementedInterfaces, currentClass)
 
-                // check that no system statics are affected (but implemented interfaces fields are allowed)
-                !(inImplementedInterfaces || declaringClass == currentClass)
+                assigningOuterStatics || assignmentFromOuterStatics
             }
             else -> {
                 if (it.containsInvokeExpr()) {
-                    it.invokeExpr.method.isAffectingExternalStatics(currentClass, alreadyProcessed, typeResolver)
+                    it.invokeExpr.method.isTouchingExternalStatics(
+                        currentClass,
+                        alreadyProcessed,
+                        currentClassImplementedInterfaces
+                    )
                 } else {
                     false
                 }
             }
         }
     }
 }
+
+/**
+ * Determines whether [fieldRef] is static field not from [currentClass]
+ * (except static fields from all interfaces implemented by [currentClass], stored in [currentClassImplementedInterfaces]).
+ */
+private fun isExternalStaticField(
+    fieldRef: Value,
+    currentClassImplementedInterfaces: List<Type>,
+    currentClass: SootClass
+): Boolean {
+    if (fieldRef !is StaticFieldRef) {
+        return false
+    }
+
+    val declaringClass = fieldRef.field.declaringClass
+
+    val classInImplementedInterfaces =
+        declaringClass.type in currentClassImplementedInterfaces
+
+    return !(classInImplementedInterfaces || declaringClass == currentClass)
+}

utbot-framework/src/test/kotlin/org/utbot/examples/enums/ClassWithEnumTest.kt

@@ -174,4 +174,24 @@ class ClassWithEnumTest : AbstractTestCaseGeneratorTest(testClass = ClassWithEnu
             )
         }
     }
+
+    @Test
+    fun testAffectSystemStaticAndUseInitEnumFromIt() {
+        check(
+            ClassWithEnum::affectSystemStaticAndInitEnumFromItAndReturnField,
+            eq(1),
+            { r -> r == true },
+            coverage = DoNotCalculate
+        )
+    }
+
+    @Test
+    fun testAffectSystemStaticAndInitEnumFromItAndGetItFromEnumFun() {
+        check(
+            ClassWithEnum::affectSystemStaticAndInitEnumFromItAndGetItFromEnumFun,
+            eq(1),
+            { r -> r == true },
+            coverage = DoNotCalculate
+        )
+    }
 }

utbot-sample/src/main/java/org/utbot/examples/enums/ClassWithEnum.java

@@ -208,4 +208,34 @@ enum EnumImplementingInterface implements InterfaceWithField {
         I_INHERITOR, J_INHERITOR, K_INHERITOR, L_INHERITOR,
         M_INHERITOR, N_INHERITOR, O_INHERITOR, P_INHERITOR,
     }
+
+    boolean affectSystemStaticAndInitEnumFromItAndReturnField() {
+        int prevStaticValue = ClassWithEnum.staticInt;
+        staticInt++;
+
+        return OuterStaticUsageEnum.A.y != prevStaticValue;
+    }
+
+    boolean affectSystemStaticAndInitEnumFromItAndGetItFromEnumFun() {
+        int prevStaticValue = ClassWithEnum.staticInt;
+        staticInt++;
+
+        return OuterStaticUsageEnum.A.getOuterStatic() != prevStaticValue;
+    }
+
+    static int staticInt = 0;
+
+    enum OuterStaticUsageEnum {
+        A;
+
+        int y;
+
+        OuterStaticUsageEnum() {
+            y = staticInt;
+        }
+
+        int getOuterStatic() {
+            return staticInt;
+        }
+    }
 }