refactoring and fixes

UnitTestBot · DaniilStepanov · Nov 9, 2022 · Nov 15, 2022 · Nov 10, 2022 · Nov 10, 2022
commit 1dbcde789064ed5ee948636e71e6f03d334f3ad9
diff --git a/utbot-framework/build.gradle b/utbot-framework/build.gradle
@@ -6,6 +6,7 @@ repositories {
 
 configurations {
     z3native
+    fetchInstrumentationJar
 }
 
 dependencies {
@@ -49,6 +50,9 @@ dependencies {
     z3native group: 'com.microsoft.z3', name: 'z3-native-win64', version: z3Version, ext: 'zip'
     z3native group: 'com.microsoft.z3', name: 'z3-native-linux64', version: z3Version, ext: 'zip'
     z3native group: 'com.microsoft.z3', name: 'z3-native-osx', version: z3Version, ext: 'zip'
+
+    //For my tests
+    fetchInstrumentationJar project(path: ':utbot-instrumentation', configuration:'instrumentationArchive')
 }
 
 processResources {
@@ -57,4 +61,7 @@ processResources {
             into "lib/x64"
         }
     }
+    from(configurations.fetchInstrumentationJar) {
+        into "lib"
+    }
 }
diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/GreyBoxFuzzer.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/GreyBoxFuzzer.kt
@@ -11,10 +11,11 @@ import org.utbot.framework.plugin.api.*
 import org.utbot.framework.plugin.api.util.*
 import org.utbot.framework.util.sootMethod
 import org.utbot.instrumentation.ConcreteExecutor
-import org.utbot.quickcheck.generator.GeneratorContext
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.GeneratorContext
 import java.lang.reflect.Field
 import java.lang.reflect.Method
 import kotlin.random.Random
+import kotlin.system.exitProcess
 
 class GreyBoxFuzzer(
     private val pathsToUserClasses: String,
@@ -29,6 +30,7 @@ class GreyBoxFuzzer(
             .filter { it != -1 }
             .toSet()
     private val seeds = SeedCollector(methodLines = methodLines)
+    private val succeededExecutions = mutableListOf<UtGreyBoxFuzzedExecution>()
     private val timeRemain
         get() = timeOfStart + timeBudgetInMillis - System.currentTimeMillis()
     private val timeOfStart = System.currentTimeMillis()
@@ -42,37 +44,26 @@ class GreyBoxFuzzer(
         val sootMethod = methodUnderTest.sootMethod
         val javaMethod = sootMethod.toJavaMethod()!!
         val classFieldsUsedByFunc = sootMethod.getClassFieldsUsedByFunc(javaClazz)
-        val currentCoverageByLines = CoverageCollector.coverage
-            .filter { it.methodSignature == methodUnderTest.signature }
-            .map { it.lineNumber }
-            .toSet()
-        //TODO repeat or while
-        while (timeRemain > 0) {
+        while (timeRemain > 0 || !isMethodCovered()) {
             explorationStage(
                 javaMethod,
-                methodLines,
                 classFieldsUsedByFunc,
                 methodUnderTest,
-                currentCoverageByLines,
                 generatorContext
             )
             logger.debug { "SEEDS AFTER EXPLORATION STAGE = ${seeds.seedsSize()}" }
-            if (timeRemain < 0) break
-            exploitationStage(
-                methodLines,
-                currentCoverageByLines
-            )
+            if (timeRemain < 0 || isMethodCovered()) break
+            exploitationStage()
         }
+        seeds.getBestSeed()
         //UtModelGenerator.reset()
         return sequenceOf()
     }
 
     private suspend fun explorationStage(
         method: Method,
-        methodLinesToCover: Set<Int>,
         classFieldsUsedByFunc: Set<Field>,
         methodUnderTest: ExecutableId,
-        prevMethodCoverage: Set<Int>,
         generatorContext: GeneratorContext
     ) {
         val parametersToGenericsReplacer = method.parameters.map { it to GenericsReplacer() }
@@ -83,10 +74,9 @@ class GreyBoxFuzzer(
         var iterationNumber = 0
         while (System.currentTimeMillis() < endTime) {
             try {
-                logger.debug { "Iteration number $iterationNumber" }
-                if (timeRemain < 0) return
+                if (timeRemain < 0 || isMethodCovered()) return
+                logger.debug { "Func: ${methodUnderTest.name} Iteration number $iterationNumber" }
                 iterationNumber++
-                if (isMethodCovered(methodLinesToCover)) return
                 while (thisInstancesHistory.size > 1) {
                     thisInstancesHistory.removeLast()
                 }
@@ -137,16 +127,22 @@ class GreyBoxFuzzer(
                     logger.debug { "Execution started" }
                     val executionResult = execute(stateBefore, methodUnderTest)
                     logger.debug { "Execution result: $executionResult" }
-                    val seedCoverage =
-                        handleCoverage(
-                            executionResult,
-                            prevMethodCoverage,
-                            methodLinesToCover
-                        )
+                    val seedCoverage = getCoverage(executionResult)
                     logger.debug { "Calculating seed score" }
                     val seedScore = seeds.calcSeedScore(seedCoverage)
                     logger.debug { "Adding seed" }
-                    seeds.addSeed(Seed(thisInstance, generatedParameters, seedCoverage, seedScore))
+                    val seed = Seed(thisInstance, generatedParameters, seedCoverage, seedScore)
+                    if (seeds.isSeedOpensNewCoverage(seed)) {
+                        succeededExecutions.add(
+                            UtGreyBoxFuzzedExecution(
+                                stateBefore,
+                                executionResult.result,
+                                coverage = executionResult.coverage,
+                                testMethodName = methodUnderTest.name
+                            )
+                        )
+                    }
+                    seeds.addSeed(seed)
                     logger.debug { "Execution result: ${executionResult.result}" }
                     logger.debug { "Seed score = $seedScore" }
                 } catch (e: Throwable) {
@@ -161,38 +157,48 @@ class GreyBoxFuzzer(
         }
     }
 
-    private suspend fun exploitationStage(
-        methodLinesToCover: Set<Int>,
-        prevMethodCoverage: Set<Int>
-    ) {
+    private suspend fun exploitationStage() {
         logger.debug { "Exploitation began" }
+        if (seeds.seedsSize() == 0) return
+        if (seeds.all { it.parameters.isEmpty() }) return
         val startTime = System.currentTimeMillis()
         val endTime = startTime + timeBudgetInMillis / percentageOfTimeBudgetToChangeMode
         var iterationNumber = 0
         while (System.currentTimeMillis() < endTime) {
-            if (timeRemain < 0) return
-            logger.debug { "Mutation iteration $iterationNumber" }
+            if (timeRemain < 0 || isMethodCovered()) return
+            //Infinite cycle of cant mutate seed
+            if (iterationNumber > 30_000) return
+            logger.debug { "Func: ${methodUnderTest.name} Mutation iteration number $iterationNumber" }
             iterationNumber++
-            if (isMethodCovered(methodLinesToCover)) return
-            val randomSeed = seeds.getRandomWeightedSeed() ?: continue
+            val randomSeed = seeds.getRandomWeightedSeed()
             logger.debug { "Random seed params = ${randomSeed.parameters}" }
-            val mutatedSeed = Mutator.mutateSeed(
-                randomSeed,
-                GreyBoxFuzzerGenerators.sourceOfRandomness,
-                GreyBoxFuzzerGenerators.genStatus
-            )
+            val mutatedSeed =
+                Mutator.mutateSeed(
+                    randomSeed,
+                    GreyBoxFuzzerGenerators.sourceOfRandomness,
+                    GreyBoxFuzzerGenerators.genStatus
+                )
+            if (mutatedSeed == randomSeed) {
+                logger.debug { "Cant mutate seed" }
+                continue
+            }
             logger.debug { "Mutated params = ${mutatedSeed.parameters}" }
             val stateBefore = mutatedSeed.createEnvironmentModels()
             try {
                 val executionResult = execute(stateBefore, methodUnderTest)
                 logger.debug { "Execution result: $executionResult" }
-                val seedScore =
-                    handleCoverage(
-                        executionResult,
-                        prevMethodCoverage,
-                        methodLinesToCover
-                    )
+                val seedScore = getCoverage(executionResult)
                 mutatedSeed.score = 0.0
+                if (seeds.isSeedOpensNewCoverage(mutatedSeed)) {
+                    succeededExecutions.add(
+                        UtGreyBoxFuzzedExecution(
+                            stateBefore,
+                            executionResult.result,
+                            coverage = executionResult.coverage,
+                            testMethodName = methodUnderTest.name
+                        )
+                    )
+                }
                 seeds.addSeed(mutatedSeed)
                 logger.debug { "Execution result: ${executionResult.result}" }
                 logger.debug { "Seed score = $seedScore" }
@@ -203,27 +209,25 @@ class GreyBoxFuzzer(
         }
     }
 
-    private fun handleCoverage(
-        executionResult: UtFuzzingConcreteExecutionResult,
-        prevMethodCoverage: Set<Int>,
-        currentMethodLines: Set<Int>
+    private fun getCoverage(
+        executionResult: UtFuzzingConcreteExecutionResult
     ): Set<Int> {
         val currentMethodCoverage = executionResult.coverage.coveredInstructions
             .asSequence()
             .filter { it.methodSignature == methodUnderTest.signature }
             .map { it.lineNumber }
-            .filter { it in currentMethodLines }
+            .filter { it in methodLines }
             .toSet()
-        logger.debug { "Covered lines $currentMethodCoverage from $currentMethodLines" }
+        logger.debug { "Covered lines $currentMethodCoverage from $methodLines" }
         executionResult.coverage.coveredInstructions.forEach { CoverageCollector.coverage.add(it) }
         return currentMethodCoverage
     }
 
-    private fun isMethodCovered(methodLinesToCover: Set<Int>): Boolean {
+    private fun isMethodCovered(): Boolean {
         val coveredLines =
             CoverageCollector.coverage.filter { it.methodSignature == methodUnderTest.signature }.map { it.lineNumber }
                 .toSet()
-        return coveredLines.containsAll(methodLinesToCover)
+        return coveredLines.containsAll(methodLines)
     }
 
     private suspend fun ConcreteExecutor<UtFuzzingConcreteExecutionResult, UtFuzzingExecutionInstrumentation>.executeConcretely(

diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/DataGenerator.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/DataGenerator.kt
@@ -1,10 +1,10 @@
 package org.utbot.engine.greyboxfuzzer.generator
 
 import org.utbot.engine.greyboxfuzzer.util.FuzzerIllegalStateException
-import org.utbot.quickcheck.generator.GenerationStatus
-import org.utbot.quickcheck.generator.Generator
-import org.utbot.quickcheck.internal.ParameterTypeContext
-import org.utbot.quickcheck.random.SourceOfRandomness
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.GenerationStatus
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.Generator
+import org.utbot.engine.greyboxfuzzer.quickcheck.internal.ParameterTypeContext
+import org.utbot.engine.greyboxfuzzer.quickcheck.random.SourceOfRandomness
 import org.utbot.engine.logger
 import org.utbot.external.api.classIdForType
 import org.utbot.framework.plugin.api.ClassId
@@ -13,8 +13,8 @@ import org.utbot.framework.plugin.api.UtNullModel
 import org.utbot.framework.plugin.api.util.id
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.plugin.api.util.objectClassId
-import org.utbot.quickcheck.generator.GenerationState
-import org.utbot.quickcheck.generator.GeneratorContext
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.GenerationState
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.GeneratorContext
 import java.lang.reflect.Parameter
 
 object DataGenerator {
@@ -28,16 +28,16 @@ object DataGenerator {
         random: SourceOfRandomness,
         status: GenerationStatus
     ): UtModel {
-        logger.debug { "Trying to generate UtModel of type 3 times" }
         val classId = parameterTypeContext.rawClass.id
+        logger.debug { "Trying to generate UtModel of type ${classId.name} 3 times" }
         var generatedInstance: UtModel? = null
         repeat(3) {
             generatedInstance =
                 try {
                     val generator =
                         generatorRepository.getOrProduceGenerator(parameterTypeContext, generatorContext, depth)
                             ?: return@repeat
-                    generator.generatorContext.startCheckpoint()
+                    //generator.generatorContext.startCheckpoint()
                     generator.generateImpl(random, status)
                 } catch (_: Throwable) {
                     null

diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/FField.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/FField.kt
@@ -1,6 +1,6 @@
 package org.utbot.engine.greyboxfuzzer.generator
 
-import org.utbot.quickcheck.generator.Generator
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.Generator
 import org.utbot.engine.greyboxfuzzer.util.toClass
 import org.utbot.external.api.classIdForType
 import org.utbot.framework.plugin.api.ClassId

diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/FParameter.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/FParameter.kt
@@ -3,7 +3,7 @@ package org.utbot.engine.greyboxfuzzer.generator
 import org.utbot.engine.greyboxfuzzer.mutator.Mutator
 import org.utbot.engine.greyboxfuzzer.util.copy
 import org.utbot.engine.greyboxfuzzer.util.getAllDeclaredFields
-import org.utbot.quickcheck.generator.Generator
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.Generator
 import org.utbot.external.api.classIdForType
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.UtAssembleModel

diff --git a/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/FThisInstance.kt b/utbot-framework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/FThisInstance.kt
@@ -3,7 +3,7 @@ package org.utbot.engine.greyboxfuzzer.generator
 import org.utbot.engine.greyboxfuzzer.util.copy
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.UtModel
-import org.utbot.quickcheck.generator.Generator
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.Generator
 
 sealed interface ThisInstance {
     val utModelForExecution: UtModel?

diff --git a/...amework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/GeneratorConfigurator.kt b/...amework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/GeneratorConfigurator.kt
@@ -1,13 +1,13 @@
 package org.utbot.engine.greyboxfuzzer.generator
 
-import org.utbot.quickcheck.generator.Generator
-import org.utbot.quickcheck.generator.InRange
-import org.utbot.quickcheck.generator.Size
-import org.utbot.quickcheck.generator.java.util.CollectionGenerator
-import org.utbot.quickcheck.generator.java.util.MapGenerator
-import org.utbot.quickcheck.internal.generator.ArrayGenerator
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.Generator
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.InRange
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.Size
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.java.util.CollectionGenerator
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.java.util.MapGenerator
+import org.utbot.engine.greyboxfuzzer.quickcheck.internal.generator.ArrayGenerator
 import org.utbot.engine.greyboxfuzzer.util.getTrue
-import org.utbot.quickcheck.generator.java.lang.*
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.java.lang.*
 import kotlin.random.Random
 
 object GeneratorConfigurator {

diff --git a/...ework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/GreyBoxFuzzerGenerators.kt b/...ework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/GreyBoxFuzzerGenerators.kt
@@ -1,20 +1,21 @@
 package org.utbot.engine.greyboxfuzzer.generator
 
 
-import org.utbot.quickcheck.NonTrackingGenerationStatus
-import org.utbot.quickcheck.generator.*
-import org.utbot.quickcheck.generator.java.time.*
-import org.utbot.quickcheck.generator.java.util.*
-import org.utbot.quickcheck.generator.java.lang.*
-import org.utbot.quickcheck.generator.java.math.*
-import org.utbot.quickcheck.generator.java.nio.charset.CharsetGenerator
-import org.utbot.quickcheck.random.SourceOfRandomness
+import org.utbot.engine.greyboxfuzzer.quickcheck.NonTrackingGenerationStatus
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.*
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.java.time.*
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.java.util.*
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.java.lang.*
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.java.math.*
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.java.nio.charset.CharsetGenerator
+import org.utbot.engine.greyboxfuzzer.quickcheck.random.SourceOfRandomness
 import java.util.*
+import java.util.concurrent.atomic.AtomicInteger
 
 object GreyBoxFuzzerGenerators {
 
     const val seed = 42L
-    const val maxDepthOfGeneration = 7
+    val maxDepthOfGeneration = AtomicInteger(5)
     val sourceOfRandomness = SourceOfRandomness(Random(seed))
     val genStatus = NonTrackingGenerationStatus(sourceOfRandomness)
 

diff --git a/...ramework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/QuickCheckExtensions.kt b/...ramework/src/main/kotlin/org/utbot/engine/greyboxfuzzer/generator/QuickCheckExtensions.kt
@@ -10,13 +10,13 @@ import org.utbot.engine.greyboxfuzzer.generator.userclasses.UserClassGenerator
 import org.utbot.engine.greyboxfuzzer.util.*
 import org.utbot.engine.logger
 import org.utbot.engine.rawType
-import org.utbot.quickcheck.generator.ComponentizedGenerator
-import org.utbot.quickcheck.generator.Generator
-import org.utbot.quickcheck.generator.GeneratorContext
-import org.utbot.quickcheck.internal.FakeAnnotatedTypeFactory
-import org.utbot.quickcheck.internal.ParameterTypeContext
-import org.utbot.quickcheck.internal.generator.ArrayGenerator
-import org.utbot.quickcheck.internal.generator.GeneratorRepository
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.ComponentizedGenerator
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.Generator
+import org.utbot.engine.greyboxfuzzer.quickcheck.generator.GeneratorContext
+import org.utbot.engine.greyboxfuzzer.quickcheck.internal.FakeAnnotatedTypeFactory
+import org.utbot.engine.greyboxfuzzer.quickcheck.internal.ParameterTypeContext
+import org.utbot.engine.greyboxfuzzer.quickcheck.internal.generator.ArrayGenerator
+import org.utbot.engine.greyboxfuzzer.quickcheck.internal.generator.GeneratorRepository
 import ru.vyarus.java.generics.resolver.GenericsResolver
 import ru.vyarus.java.generics.resolver.context.ConstructorGenericsContext
 import ru.vyarus.java.generics.resolver.context.GenericsContext
@@ -40,7 +40,7 @@ fun Generator.getAllComponents(): List<Generator> {
 
 fun Generator.getComponents(): List<Generator> =
     when (this) {
-        is ComponentizedGenerator -> this.componentGenerators()
+        is org.utbot.engine.greyboxfuzzer.quickcheck.generator.ComponentizedGenerator -> this.componentGenerators()
         is ArrayGenerator -> listOf(this.component)
         else -> emptyList()
     }