Collect info about Invoke, Iterate, and Return sections #565

Author: onewhl

utbot-summary/src/main/kotlin/org/utbot/summary/comment/CustomJavaDocComment.kt

@@ -4,13 +4,13 @@ package org.utbot.summary.comment
  * Represents a set of plugin's custom JavaDoc tags.
  */
 data class CustomJavaDocComment(
-    val classUnderTest: String,
-    val methodUnderTest: String,
-    val expectedResult: String?,
-    val actualResult: String?,
-    var executesCondition: String?,
-    var invokes: String?,
-    var iterates: String?,
-    var returnsFrom: String?,
-    var throwsException: String?
+    val classUnderTest: String = "",
+    val methodUnderTest: String = "",
+    val expectedResult: String = "",
+    val actualResult: String = "",
+    var executesCondition: List<String> = listOf(),
+    var invokes: List<String> = listOf(),
+    var iterates: List<String> = listOf(),
+    var returnsFrom: String = "",
+    var throwsException: String = ""
 )

utbot-summary/src/main/kotlin/org/utbot/summary/comment/CustomJavaDocCommentBuilder.kt

@@ -23,42 +23,51 @@ class CustomJavaDocCommentBuilder(
 
         docStatementList += DocRegularStmt("@utbot.classUnderTest ${comment.classUnderTest}\n")
         docStatementList += DocRegularStmt("@utbot.methodUnderTest ${comment.methodUnderTest}\n")
-        if (comment.expectedResult != null)
+
+        if (comment.expectedResult.isNotEmpty())
             docStatementList += DocRegularStmt("@utbot.expectedResult ${comment.expectedResult}\n")
-        if (comment.actualResult != null)
+        if (comment.actualResult.isNotEmpty())
             docStatementList += DocRegularStmt("@utbot.actualResult ${comment.actualResult}\n")
-        if (comment.executesCondition != null)
-            docStatementList += DocRegularStmt("@utbot.executesCondition ${comment.executesCondition}\n")
-        if (comment.invokes != null)
-            docStatementList += DocRegularStmt("@utbot.invokes ${comment.invokes}\n")
-        if (comment.iterates != null)
-            docStatementList += DocRegularStmt("@utbot.iterates ${comment.iterates}\n")
-        if (comment.returnsFrom != null)
+        if (comment.executesCondition.isNotEmpty()) {
+            val statement =
+                "@utbot.executesCondition ${comment.executesCondition.joinToString(separator = ",\n")}\n"
+            docStatementList += DocRegularStmt(statement)
+        }
+        if (comment.invokes.isNotEmpty()) {
+            val statement = "@utbot.invokes ${comment.invokes.joinToString(separator = ",\n")}\n"
+            docStatementList += DocRegularStmt(statement)
+        }
+        if (comment.iterates.isNotEmpty()) {
+            val statement = "@utbot.iterates ${comment.iterates.joinToString(separator = ",\n")}\n"
+            docStatementList += DocRegularStmt(statement)
+        }
+        if (comment.returnsFrom.isNotEmpty())
             docStatementList += DocRegularStmt("@utbot.returnsFrom ${comment.returnsFrom}\n")
-        if (comment.throwsException != null)
+        if (comment.throwsException.isNotEmpty())
             docStatementList += DocRegularStmt("@utbot.throwsException ${comment.throwsException}")
 
         return listOf<DocStatement>(DocPreTagStatement(docStatementList))
     }
 
     private fun buildCustomJavaDocComment(currentMethod: SootMethod): CustomJavaDocComment {
-        val methodReference =
-            getMethodReference(currentMethod.declaringClass.name, currentMethod.name, currentMethod.parameterTypes)
+        val methodReference = getMethodReference(
+            currentMethod.declaringClass.name,
+            currentMethod.name,
+            currentMethod.parameterTypes
+        )
         val classReference = getClassReference(currentMethod.declaringClass.javaStyleName)
 
         val customJavaDocComment = CustomJavaDocComment(
             classUnderTest = classReference,
             methodUnderTest = methodReference,
-            expectedResult = null,
-            actualResult = null,
-            executesCondition = null,
-            invokes = null,
-            iterates = null,
-            returnsFrom = null,
-            throwsException = null
         )
 
-        // build throws exception section
+        val rootSentenceBlock = SimpleSentenceBlock(stringTemplates = stringTemplates)
+        skippedIterations()
+        buildSentenceBlock(traceTag.rootStatementTag, rootSentenceBlock, currentMethod)
+        rootSentenceBlock.squashStmtText()
+
+        // builds Throws exception section
         val thrownException = traceTag.result.exceptionOrNull()
         val exceptionThrow: String? = if (thrownException == null) {
             traceTag.result.exceptionOrNull()?.let { it::class.qualifiedName }
@@ -67,40 +76,43 @@ class CustomJavaDocCommentBuilder(
             val reason = findExceptionReason(currentMethod, thrownException)
             "{@link $exceptionName} $reason"
         }
-        customJavaDocComment.throwsException = exceptionThrow
-
-        val rootSentenceBlock = SimpleSentenceBlock(stringTemplates = stringTemplates)
-        skippedIterations()
-        buildSentenceBlock(traceTag.rootStatementTag, rootSentenceBlock, currentMethod)
+        if (exceptionThrow != null) {
+            customJavaDocComment.throwsException = exceptionThrow
+        }
 
-        // builds iterates section
+        // builds Iterates section
         rootSentenceBlock.iterationSentenceBlocks.forEach { (loopDesc, sentenceBlocks) ->
-            customJavaDocComment.iterates = stringTemplates.iterationSentence.format(
+            customJavaDocComment.iterates += stringTemplates.iterationSentence.format(
                 stringTemplates.codeSentence.format(loopDesc),
                 numberOccurrencesToText(
                     sentenceBlocks.size
                 )
             )
         }
 
-        // build invokes, executes, and returns from sections
-        for (stmtDescription: StmtDescription in rootSentenceBlock.stmtTexts) {
-            when (stmtDescription.stmtType.name) {
-                //TODO: support multiple invokes (calls)
-                "Invoke" -> {
-                    val info = stmtDescription.description
-                    customJavaDocComment.invokes = "{@code $info}"
-                }
-                "Return" -> {
-                    val info = stmtDescription.description
-                    customJavaDocComment.returnsFrom = "{@code $info}"
-                }
-                //TODO: support multiple conditions
-                "Condition" -> {
-                    val info = stmtDescription.description
-                    customJavaDocComment.executesCondition = "{@code $info}"
+        // builds Invoke, Execute, Return sections
+        var currentBlock: SimpleSentenceBlock? = rootSentenceBlock
+        while (currentBlock != null) {
+            for (statement in currentBlock.stmtTexts) {
+                when (statement.stmtType) {
+                    StmtType.Invoke -> {
+                        val info = statement.description
+                        customJavaDocComment.invokes += "{@code $info}"
+                    }
+                    StmtType.Condition -> {
+                        val info = statement.description
+                        customJavaDocComment.executesCondition += "{@code $info}"
+                    }
+                    StmtType.Return -> {
+                        val info = statement.description
+                        customJavaDocComment.returnsFrom = "{@code $info}"
+                    }
+                    else -> {
+                        //TODO
+                    }
                 }
             }
+            currentBlock = currentBlock.nextBlock
         }
 
         return customJavaDocComment