Review fixes

Author: CaelmBleidd

utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt

@@ -510,12 +510,13 @@ object UtSettings : AbstractSettings(logger, defaultKeyForSettingsPath, defaultS
      * Depending on this option, <clinit> sections might be analyzed or not.
      * Note that some clinit sections still will be initialized using runtime information.
      */
-    var disableClinitSectionsAnalysis by getBooleanProperty(false)
+    var enableClinitSectionsAnalysis by getBooleanProperty(true)
 
     /**
      * Process all clinit sections concretely.
      *
-     * If [disableClinitSectionsAnalysis] is true, it disables effect of this function as well.
+     * If [enableClinitSectionsAnalysis] is true, it disables effect of this option as well.
+     * Note that values processed concretely won't be replaced with unbounded symbolic variables.
      */
     var processAllClinitSectionsConcretely by getBooleanProperty(false)
 }

utbot-framework-api/src/main/kotlin/org/utbot/testcheckers/SettingsModificators.kt

@@ -109,19 +109,19 @@ inline fun <reified T> withoutConcrete(block: () -> T): T {
     }
 }
 
-inline fun <reified T> withoutProcessingClinitSections(block: () -> T): T {
-    val prev = UtSettings.disableClinitSectionsAnalysis
-    UtSettings.disableClinitSectionsAnalysis = true
+inline fun <reified T> withProcessingClinitSections(value: Boolean, block: () -> T): T {
+    val prev = UtSettings.enableClinitSectionsAnalysis
+    UtSettings.enableClinitSectionsAnalysis = value
     try {
         return block()
     } finally {
-        UtSettings.disableClinitSectionsAnalysis = prev
+        UtSettings.enableClinitSectionsAnalysis = prev
     }
 }
 
-inline fun <reified T> withProcessingAllClinitSectionsConcretely(block: () -> T): T {
+inline fun <reified T> withProcessingAllClinitSectionsConcretely(value: Boolean, block: () -> T): T {
     val prev = UtSettings.processAllClinitSectionsConcretely
-    UtSettings.processAllClinitSectionsConcretely = true
+    UtSettings.processAllClinitSectionsConcretely = value
     try {
         return block()
     } finally {

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

@@ -3,50 +3,65 @@ package org.utbot.examples.objects
 import org.junit.jupiter.api.Test
 import org.utbot.testcheckers.eq
 import org.utbot.testcheckers.withProcessingAllClinitSectionsConcretely
-import org.utbot.testcheckers.withoutProcessingClinitSections
+import org.utbot.testcheckers.withoutConcrete
+import org.utbot.testcheckers.withProcessingClinitSections
 import org.utbot.testing.UtValueTestCaseChecker
 import org.utbot.testing.atLeast
 
 internal class ClassForTestClinitSectionsTest : UtValueTestCaseChecker(testClass = ClassForTestClinitSections::class) {
     @Test
     fun testClinitWithoutClinitAnalysis() {
-        withoutProcessingClinitSections {
-            check(
-                ClassForTestClinitSections::resultDependingOnStaticSection,
-                eq(2)
-            )
+        withoutConcrete {
+            withProcessingClinitSections(value = false) {
+                check(
+                    ClassForTestClinitSections::resultDependingOnStaticSection,
+                    eq(2),
+                    { r -> r == -1 },
+                    { r -> r == 1 }
+                )
+            }
         }
     }
 
     @Test
     fun testClinitWithClinitAnalysis() {
-        check(
-            ClassForTestClinitSections::resultDependingOnStaticSection,
-            eq(1),
-            coverage = atLeast(71)
-        )
+        withoutConcrete {
+            check(
+                ClassForTestClinitSections::resultDependingOnStaticSection,
+                eq(2),
+                { r -> r == -1 },
+                { r -> r == 1 }
+            )
+        }
     }
 
     @Test
     fun testProcessConcretelyWithoutClinitAnalysis() {
-        withoutProcessingClinitSections {
-            withProcessingAllClinitSectionsConcretely {
-                check(
-                    ClassForTestClinitSections::resultDependingOnStaticSection,
-                    eq(2)
-                )
+        withoutConcrete {
+            withProcessingClinitSections(value = false) {
+                withProcessingAllClinitSectionsConcretely(value = true) {
+                    check(
+                        ClassForTestClinitSections::resultDependingOnStaticSection,
+                        eq(2),
+                        { r -> r == -1 },
+                        { r -> r == 1 }
+                    )
+                }
             }
         }
     }
 
     @Test
     fun testProcessClinitConcretely() {
-        withProcessingAllClinitSectionsConcretely {
-            check(
-                ClassForTestClinitSections::resultDependingOnStaticSection,
-                eq(1),
-                coverage = atLeast(71)
-            )
+        withoutConcrete {
+            withProcessingAllClinitSectionsConcretely(value = true) {
+                check(
+                    ClassForTestClinitSections::resultDependingOnStaticSection,
+                    eq(1),
+                    { r -> r == -1 },
+                    coverage = atLeast(71)
+                )
+            }
         }
     }
 }

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

@@ -483,14 +483,19 @@ class Traverser(
         fieldRef: StaticFieldRef,
         stmt: Stmt
     ): Boolean {
+        // This order of processing options is important.
+        // First, we should process classes that
+        // cannot be analyzed without clinit sections, e.g., enums
         if (shouldProcessStaticFieldConcretely(fieldRef)) {
             return processStaticFieldConcretely(fieldRef, stmt)
         }
 
-        if (UtSettings.disableClinitSectionsAnalysis) {
+        // Then we should check if we should analyze clinit sections at all
+        if (!UtSettings.enableClinitSectionsAnalysis) {
             return false
         }
 
+        // Finally, we decide whether we should analyze clinit sections concretely or not
         if (UtSettings.processAllClinitSectionsConcretely) {
             return processStaticFieldConcretely(fieldRef, stmt)
         }