Refactoring

Author: sofurihafe

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

@@ -282,12 +282,12 @@ sealed class UtReferenceModel(
 ) : UtModel(classId)
 
 /**
- * Checks if [UtModel] is a null.
+ * Checks if [UtModel] is a [UtNullModel].
  */
 fun UtModel.isNull() = this is UtNullModel
 
 /**
- * Checks if [UtModel] is not a null.
+ * Checks if [UtModel] is not a [UtNullModel].
  */
 fun UtModel.isNotNull() = !isNull()
 

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgMethodConstructor.kt

@@ -167,7 +167,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
 
     private lateinit var methodType: CgTestMethodType
 
-    private val cachedFieldsFromAllExecutions = mutableMapOf<Pair<FieldId, Int>, MutableList<UtModel>>()
+    private val fieldsOfExecutionResults = mutableMapOf<Pair<FieldId, Int>, MutableList<UtModel>>()
 
     private fun setupInstrumentation() {
         if (currentExecution is UtSymbolicExecution) {
@@ -831,27 +831,24 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
         depth: Int,
         visitedModels: MutableSet<UtModel>
     ) {
+        // if field is static, it is represents itself in "before" and
+        // "after" state: no need to assert its equality to itself.
+        if (fieldId.isStatic) {
+            return
+        }
+
+        // if model is already processed, so we don't want to add new statements
+        if (fieldModel in visitedModels) {
+            return
+        }
+
         when (parametrizedTestSource) {
             ParametrizedTestSource.DO_NOT_PARAMETRIZE -> {
-                traverseField(
-                    fieldId,
-                    fieldModel,
-                    expected,
-                    actual,
-                    depth,
-                    visitedModels
-                )
+                traverseField(fieldId, fieldModel, expected, actual, depth, visitedModels)
             }
 
             ParametrizedTestSource.PARAMETRIZE -> {
-                traverseFieldForParametrizedTest(
-                    fieldId,
-                    fieldModel,
-                    expected,
-                    actual,
-                    depth,
-                    visitedModels
-                )
+                traverseFieldForParametrizedTest(fieldId, fieldModel, expected, actual, depth, visitedModels)
             }
         }
     }
@@ -864,17 +861,6 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
         depth: Int,
         visitedModels: MutableSet<UtModel>
     ) {
-        // if field is static, it is represents itself in "before" and
-        // "after" state: no need to assert its equality to itself.
-        if (fieldId.isStatic) {
-            return
-        }
-
-        // if model is already processed, so we don't want to add new statements
-        if (fieldModel in visitedModels) {
-            return
-        }
-
         // fieldModel is not visited and will be marked in assertDeepEquals call
         val fieldName = fieldId.name
         var expectedVariable: CgVariable? = null
@@ -907,31 +893,25 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
         depth: Int,
         visitedModels: MutableSet<UtModel>
     ) {
-        // if field is static, it is represents itself in "before" and
-        // "after" state: no need to assert its equality to itself.
-        if (fieldId.isStatic) {
-            return
-        }
+        val fieldResultModels = fieldsOfExecutionResults[fieldId to depth]
+        val nullResultModelInExecutions = fieldResultModels?.find { it.isNull() }
+        val notNullResultModelInExecutions = fieldResultModels?.find { it.isNotNull() }
 
-        val hasNullModelFieldInOtherExecutions = cachedFieldsFromAllExecutions[fieldId to depth]?.any { it.isNull() } ?: false
-        val notNullModelFieldFromOtherExecution = cachedFieldsFromAllExecutions[fieldId to depth]?.find { it.isNotNull() }
+        val hasNullResultModel = nullResultModelInExecutions != null
+        val hasNotNullResultModel = notNullResultModelInExecutions != null
 
-        val needToSubstituteFieldModel = notNullModelFieldFromOtherExecution != null && fieldModel is UtNullModel
+        val needToSubstituteFieldModel = fieldModel is UtNullModel && hasNotNullResultModel
 
-        val fieldModel = if (needToSubstituteFieldModel) notNullModelFieldFromOtherExecution!! else fieldModel
+        val fieldModelForAssert = if (needToSubstituteFieldModel) notNullResultModelInExecutions!! else fieldModel
 
-        val needIfStatement = needToSubstituteFieldModel || hasNullModelFieldInOtherExecutions
-
-        // if model is already processed, so we don't want to add new statements
-        if (fieldModel in visitedModels) {
-            return
-        }
+//        val needIfStatement = needToSubstituteFieldModel || hasNullResultModel
 
         // fieldModel is not visited and will be marked in assertDeepEquals call
         val fieldName = fieldId.name
         var expectedVariable: CgVariable? = null
 
-        if (needExpectedDeclaration(fieldModel)) {
+        val needExpectedDeclaration = needExpectedDeclaration(fieldModelForAssert)
+        if (needExpectedDeclaration) {
             val expectedFieldDeclaration = createDeclarationForFieldFromVariable(fieldId, expected, fieldName)
 
             currentBlock += expectedFieldDeclaration
@@ -941,13 +921,13 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
         val actualFieldDeclaration = createDeclarationForFieldFromVariable(fieldId, actual, fieldName)
         currentBlock += actualFieldDeclaration
 
-        if (needExpectedDeclaration(fieldModel) && needIfStatement) {
+        if (needExpectedDeclaration && hasNullResultModel) {
             ifStatement(
                 CgEqualTo(expectedVariable!!, nullLiteral()),
                 trueBranch = { +testFrameworkManager.assertions[testFramework.assertNull](actualFieldDeclaration.variable).toStatement() },
                 falseBranch = {
                     assertDeepEquals(
-                        fieldModel,
+                        fieldModelForAssert,
                         expectedVariable,
                         actualFieldDeclaration.variable,
                         depth + 1,
@@ -957,7 +937,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
             )
         } else {
             assertDeepEquals(
-                fieldModel,
+                fieldModelForAssert,
                 expectedVariable,
                 actualFieldDeclaration.variable,
                 depth + 1,
@@ -967,7 +947,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
         emptyLineIfNeeded()
     }
 
-    private fun traverseExecutionsFieldsForParametrizedTest() {
+    private fun collectExecutionsResultFields() {
         val successfulExecutionsModels = allExecutions
             .filter {
                 it.result is UtExecutionSuccess
@@ -979,22 +959,31 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
             when (model) {
                 is UtCompositeModel -> {
                     for ((fieldId, fieldModel) in model.fields) {
-                        traverseExecutionsFieldsForParametrizedTestRecursively(fieldId, fieldModel, 0)
+                        collectExecutionsResultFieldsRecursively(fieldId, fieldModel, 0)
                     }
                 }
 
                 is UtAssembleModel -> {
-                    for ((fieldId, fieldModel) in model.origin!!.fields) {
-                        traverseExecutionsFieldsForParametrizedTestRecursively(fieldId, fieldModel, 0)
+                    model.origin?.let {
+                        for ((fieldId, fieldModel) in it.fields) {
+                            collectExecutionsResultFieldsRecursively(fieldId, fieldModel, 0)
+                        }
                     }
                 }
 
-                else -> {} // TODO: check this specific case
+                is UtNullModel,
+                is UtPrimitiveModel,
+                is UtArrayModel,
+                is UtClassRefModel,
+                is UtEnumConstantModel,
+                is UtVoidModel -> {
+                    // only [UtCompositeModel] and [UtAssembleModel] have fields to traverse
+                }
             }
         }
     }
 
-    private fun traverseExecutionsFieldsForParametrizedTestRecursively(
+    private fun collectExecutionsResultFieldsRecursively(
         fieldId: FieldId,
         fieldModel: UtModel,
         depth: Int,
@@ -1003,43 +992,32 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
             return
         }
 
+        val fieldKey = fieldId to depth
+        fieldsOfExecutionResults.getOrPut(fieldKey) { mutableListOf() } += fieldModel
+
         when (fieldModel) {
             is UtCompositeModel -> {
                 for ((id, model) in fieldModel.fields) {
-                    if (id.isInnerClassEnclosingClassReference) continue
-
-                    if (id.isStatic) {
-                        return
-                    }
-
-                    if (cachedFieldsFromAllExecutions[id to depth] != null) {
-                        cachedFieldsFromAllExecutions[id to depth]!!.add(model)
-                    } else {
-                        cachedFieldsFromAllExecutions[id to depth] = listOf(model).toMutableList()
-                    }
-
-                    traverseExecutionsFieldsForParametrizedTestRecursively(
-                        id,
-                        model,
-                        depth + 1,
-                    )
+                    collectExecutionsResultFieldsRecursively(id, model, depth + 1)
                 }
             }
 
             is UtAssembleModel -> {
                 fieldModel.origin?.let {
-                    traverseExecutionsFieldsForParametrizedTestRecursively(fieldId, it, depth)
+                    for ((id, model) in it.fields) {
+                        collectExecutionsResultFieldsRecursively(id, model, depth + 1)
+                    }
                 }
-                return
             }
 
-            else -> {} // TODO: check this specific case
-        }
-
-        if (cachedFieldsFromAllExecutions[fieldId to depth] != null) {
-            cachedFieldsFromAllExecutions[fieldId to depth]!!.add(fieldModel)
-        } else {
-            cachedFieldsFromAllExecutions[fieldId to depth] = listOf(fieldModel).toMutableList()
+            is UtNullModel,
+            is UtPrimitiveModel,
+            is UtArrayModel,
+            is UtClassRefModel,
+            is UtEnumConstantModel,
+            is UtVoidModel -> {
+                // only [UtCompositeModel] and [UtAssembleModel] have fields to traverse
+            }
         }
     }
 
@@ -1234,7 +1212,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
         when (parametrizedTestSource) {
             ParametrizedTestSource.DO_NOT_PARAMETRIZE -> generateDeepEqualsAssertion(expected, actual)
             ParametrizedTestSource.PARAMETRIZE -> {
-                traverseExecutionsFieldsForParametrizedTest()
+                collectExecutionsResultFields()
 
                 when {
                     actual.type.isPrimitive -> generateDeepEqualsAssertion(expected, actual)