yet more cleaning and refactoring

Author: arcuri82

core/src/main/kotlin/org/evomaster/core/Main.kt

@@ -271,7 +271,7 @@ class Main {
             solution = phaseHttpOracle(injector, config, epc, solution)
             solution = phaseFlaky(injector, config, epc, solution)
 
-            epc.startWriteOutput()
+            epc.markStartingWriteOutput()
             val suites = writeTests(injector, solution, controllerInfo)
             writeWFCReport(injector, solution, suites)
 
@@ -300,7 +300,7 @@ class Main {
 
             solution.statistics = data.toMutableList()
 
-            epc.finishSession()
+            epc.markFinishedSession()
 
             return solution
         }
@@ -425,7 +425,7 @@ class Main {
             return when (config.problemType) {
                 EMConfig.ProblemType.REST -> {
                     LoggingUtil.getInfoLogger().info("Starting to apply flaky detection")
-                    epc.startFlakiness()
+                    epc.markStartingFlakiness()
 
                     val flakinessDetector = injector.getInstance(Key.get(object : TypeLiteral<FlakinessDetector<RestIndividual>>() {}))
                     flakinessDetector.reexecuteToDetectFlakiness()
@@ -452,7 +452,7 @@ class Main {
             }
             //apply security testing phase
             LoggingUtil.getInfoLogger().info("Starting to apply security testing")
-            epc.startSecurity()
+            epc.markStartingSecurity()
 
             //TODO might need to reset stc, and print some updated info again
 
@@ -479,7 +479,7 @@ class Main {
 
             return if (config.httpOracles && config.problemType == EMConfig.ProblemType.REST) {
                 LoggingUtil.getInfoLogger().info("Starting to apply HTTP")
-                epc.startHttpOracles()
+                epc.markStartingAdditionalOracles()
 
                 val httpSemanticsService = injector.getInstance(HttpSemanticsService::class.java)
                 httpSemanticsService.applyHttpSemanticsPhase()
@@ -832,7 +832,7 @@ class Main {
 
             val config = injector.getInstance(EMConfig::class.java)
             val epc = injector.getInstance(ExecutionPhaseController::class.java)
-            epc.startSearch()
+            epc.markStartingSearch()
 
             if (!config.blackBox || config.bbExperiments) {
                 val rc = injector.getInstance(RemoteController::class.java)

core/src/main/kotlin/org/evomaster/core/search/service/SearchAlgorithm.kt

@@ -104,7 +104,7 @@ abstract class SearchAlgorithm<T> where T : Individual {
         time.doStopRecording()
 
         if(config.minimize){
-            epc.startMinimization()
+            epc.markStartingMinimization()
 
             minimizer.doStartTheTimer()
             minimizer.minimizeMainActionsPerCoveredTargetInArchive()

core/src/main/kotlin/org/evomaster/core/search/service/time/ExecutionPhaseController.kt

@@ -5,14 +5,18 @@ import org.evomaster.core.logging.LoggingUtil
 import org.evomaster.core.utils.TimeUtils
 import javax.inject.Inject
 
+/**
+ * Service used to keep track of which phase of the fuzzing we are currently in,
+ * and how long we have spent in them.
+ */
 class ExecutionPhaseController {
 
     enum class Phase{
         NOT_STARTED,
         SEARCH,
         MINIMIZATION,
         SECURITY,
-        HTTP_ORACLES,
+        ADDITIONAL_ORACLES,
         FLAKINESS,
         WRITE_OUTPUT,
         FINISHED
@@ -37,46 +41,46 @@ class ExecutionPhaseController {
 
     fun isInSearch() = phase == Phase.SEARCH
 
-    fun startSearch() {
+    fun markStartingSearch() {
         if(isRunning()){
             throw IllegalStateException("Illegal state to start new search: $phase")
         }
         startPhase(Phase.SEARCH)
     }
 
-    fun finishSession() {
+    fun markFinishedSession() {
         startPhase(Phase.FINISHED)
     }
 
-    fun startMinimization() {
+    fun markStartingMinimization() {
         if(!isRunning()) {
             throw IllegalStateException("Illegal state to start minimization: $phase")
         }
         startPhase(Phase.MINIMIZATION)
     }
 
-    fun startSecurity(){
+    fun markStartingSecurity(){
         if(!isRunning()) {
             throw IllegalStateException("Illegal state to start security: $phase")
         }
         startPhase(Phase.SECURITY)
     }
 
-    fun startFlakiness() {
+    fun markStartingFlakiness() {
         if (!isRunning()) {
             throw IllegalStateException("Illegal state to start flakiness detection: $phase")
         }
         startPhase(Phase.FLAKINESS)
     }
 
-    fun startHttpOracles(){
+    fun markStartingAdditionalOracles(){
         if(!isRunning()) {
-            throw IllegalStateException("Illegal state to start http oracles: $phase")
+            throw IllegalStateException("Illegal state to start additional oracles: $phase")
         }
-        startPhase(Phase.HTTP_ORACLES)
+        startPhase(Phase.ADDITIONAL_ORACLES)
     }
 
-    fun startWriteOutput (){
+    fun markStartingWriteOutput (){
         if(!isRunning()) {
             throw IllegalStateException("Illegal state to start write output: $phase")
         }

core/src/main/kotlin/org/evomaster/core/search/service/time/TimeBoxedPhase.kt

@@ -0,0 +1,17 @@
+package org.evomaster.core.search.service.time
+
+/**
+ * A service representing one phase of fuzzing that is time-boxed.
+ * This means that the phase should not run more than a certain amount of time.
+ * If such limit is reached, the phase is prematurely stopped.
+ * Ideally, most of the time we would expect the phase to finish way earlier than the timeout.
+ *
+ * Note: this is quite different from typical "search" phase, where we usually run for all
+ * the available budget
+ */
+interface TimeBoxedPhase {
+
+    fun applyPhase()
+
+    fun hasPhaseTimedOut(): Boolean
+}

core/src/test/kotlin/org/evomaster/core/search/algorithms/BreederGeneticAlgorithmTest.kt

@@ -44,9 +44,9 @@ class BreederGeneticAlgorithmTest {
             config.stoppingCriterion = EMConfig.StoppingCriterion.ACTION_EVALUATIONS
 
             val epc = injector.getInstance(ExecutionPhaseController::class.java)
-            epc.startSearch()
+            epc.markStartingSearch()
             val solution = breederGA.search()
-            epc.finishSession()
+            epc.markFinishedSession()
 
             assertTrue(solution.individuals.size == 1)
             assertEquals(OneMaxSampler.DEFAULT_N.toDouble(), solution.overall.computeFitnessScore(), 0.001)

core/src/test/kotlin/org/evomaster/core/search/algorithms/CellularGeneticAlgorithmTest.kt

@@ -88,9 +88,9 @@ class CellularGeneticAlgorithmTest {
             config.stoppingCriterion = EMConfig.StoppingCriterion.ACTION_EVALUATIONS
 
             val epc = injector.getInstance(ExecutionPhaseController::class.java)
-            epc.startSearch()
+            epc.markStartingSearch()
             val solution = cga.search()
-            epc.finishSession()
+            epc.markFinishedSession()
 
             assertTrue(solution.individuals.size == 1)
             assertEquals(OneMaxSampler.DEFAULT_N.toDouble(), solution.overall.computeFitnessScore(), 0.001)

core/src/test/kotlin/org/evomaster/core/search/algorithms/CroAlgorithmTest.kt

@@ -56,9 +56,9 @@ class CroAlgorithmTest {
             config.stoppingCriterion = EMConfig.StoppingCriterion.ACTION_EVALUATIONS
 
             val epc = injector.getInstance(ExecutionPhaseController::class.java)
-            epc.startSearch()
+            epc.markStartingSearch()
             val solution = cro.search()
-            epc.finishSession()
+            epc.markFinishedSession()
 
             assertTrue(solution.individuals.size == 1)
             assertEquals(OneMaxSampler.DEFAULT_N.toDouble(), solution.overall.computeFitnessScore(), 0.001)

core/src/test/kotlin/org/evomaster/core/search/algorithms/LIPSAlgorithmTest.kt

@@ -42,9 +42,9 @@ class LIPSAlgorithmTest {
         config.stoppingCriterion = EMConfig.StoppingCriterion.ACTION_EVALUATIONS
 
         val epc = injector.getInstance(ExecutionPhaseController::class.java)
-        epc.startSearch()
+        epc.markStartingSearch()
         val solution = lips.search()
-        epc.finishSession()
+        epc.markFinishedSession()
 
         assertTrue(solution.individuals.size == 1)
         assertEquals(

core/src/test/kotlin/org/evomaster/core/search/algorithms/MioAlgorithmOnConstantTest.kt

@@ -36,11 +36,11 @@ class MioAlgorithmOnConstantTest {
         config.maxEvaluations = 200
         config.stoppingCriterion = EMConfig.StoppingCriterion.ACTION_EVALUATIONS
         val epc = injector.getInstance(ExecutionPhaseController::class.java)
-        epc.startSearch()
+        epc.markStartingSearch()
 
         val solution = mio.search()
 
         Assertions.assertEquals(1.0, solution.overall.computeFitnessScore(), 0.001);
         Assertions.assertEquals(1, solution.individuals.size)
     }
-}
+}

core/src/test/kotlin/org/evomaster/core/search/algorithms/MioAlgorithmOnOneMaxTest.kt

@@ -37,7 +37,7 @@ class MioAlgorithmOnOneMaxTest {
         config.maxEvaluations = 30000
         config.stoppingCriterion = EMConfig.StoppingCriterion.ACTION_EVALUATIONS
         val epc = injector.getInstance(ExecutionPhaseController::class.java)
-        epc.startSearch()
+        epc.markStartingSearch()
 
         val n = 20
         sampler.n = n
@@ -47,4 +47,4 @@ class MioAlgorithmOnOneMaxTest {
         Assertions.assertEquals(n.toDouble(), solution.overall.computeFitnessScore(), 0.001);
         Assertions.assertEquals(1, solution.individuals.size)
     }
-}
+}