Merge pull request #1478 from WebFuzzing/fix-GeneRandomizedTest

bugfixes BigDecimalGene.setValueWithDecimal() and MapGene.randomize() / enhancing  GeneSamplerForTest

Author: arcuri82

core/src/main/kotlin/org/evomaster/core/search/gene/GeneRandomizationFailed.kt

@@ -0,0 +1,12 @@
+package org.evomaster.core.search.gene
+
+/**
+ * Exception thrown to indicate that a failure occurred during the process
+ * of gene randomization. This exception typically signifies that an it was
+ * not possible to generate a random valid gene value given the gene constraints.
+ *
+ * @param message The detail message providing more context about the specific failure.
+ */
+class GeneRandomizationFailed(message: String) : RuntimeException(message) {
+
+}

core/src/main/kotlin/org/evomaster/core/search/gene/collection/MapGene.kt

@@ -4,6 +4,7 @@ import org.evomaster.client.java.instrumentation.shared.TaintInputName
 import org.evomaster.core.output.OutputFormat
 import org.evomaster.core.problem.util.ParamUtil
 import org.evomaster.core.search.gene.Gene
+import org.evomaster.core.search.gene.GeneRandomizationFailed
 import org.evomaster.core.search.gene.interfaces.CollectionGene
 import org.evomaster.core.search.gene.numeric.IntegerGene
 import org.evomaster.core.search.gene.numeric.LongGene
@@ -49,6 +50,8 @@ abstract class MapGene<K, V>(
         private val log: Logger = LoggerFactory.getLogger(MapGene::class.java)
         const val MAX_SIZE = 5
 
+        const val MAX_RANDOMIZE_ATTEMPTS = 100
+
         fun isStringMap(gene: MapGene<*, *>) = gene.template.first is StringGene && gene.template.second is StringGene
     }
 
@@ -61,17 +64,31 @@ abstract class MapGene<K, V>(
     }
 
     override fun randomize(randomness: Randomness, tryToForceNewValue: Boolean) {
-
-        //maybe not so important here to complicate code to enable forceNewValue
+        /*
+         * tryToForceNewValue is not supported for MapGene, as the value of MapGene is determined by its elements,
+         * and it is hard to determine whether the value is new or not. thus we ignore tryToForceNewValue for MapGene.
+         */
 
         killAllChildren()
         log.trace("Randomizing MapGene")
-        val n = randomness.nextInt(getMinSizeOrDefault(), getMaxSizeUsedInRandomize())
-        (0 until n).forEach {
+
+        val minSize = getMinSizeOrDefault()
+        val targetSize = randomness.nextInt(minSize, getMaxSizeUsedInRandomize())
+        val maxAddElementCount = maxOf(MAX_RANDOMIZE_ATTEMPTS, targetSize)
+        var addElementCount = 0
+
+        while (elements.size < targetSize && addElementCount < maxAddElementCount) {
             val gene = createRandomElement(randomness, false)
-            // if the key of gene exists, the value would be replaced with the latest one
+
+            // Observe that, if the key of gene exists, the value would be replaced with the latest one
             addElement(gene)
+            addElementCount++
         }
+
+        if (elements.size < minSize) {
+            throw GeneRandomizationFailed("Couldn't generate a valid MapGene after $addElementCount attempts.")
+        }
+
     }
 
     override fun adaptiveSelectSubsetToMutate(randomness: Randomness, internalGenes: List<Gene>, mwc: MutationWeightControl, additionalGeneMutationInfo: AdditionalGeneMutationInfo): List<Pair<Gene, AdditionalGeneMutationInfo?>> {
@@ -303,4 +320,4 @@ abstract class MapGene<K, V>(
 
     override fun getDefaultMaxSize() = (if (getMinSizeOrDefault() >= MAX_SIZE) (getMinSizeOrDefault() + MAX_SIZE) else MAX_SIZE)
 
-}
+}

core/src/main/kotlin/org/evomaster/core/search/gene/numeric/BigDecimalGene.kt

@@ -284,7 +284,7 @@ class BigDecimalGene(
     private fun getRoundingMode() = DEFAULT_ROUNDING_MODE
 
     private fun setValueWithDecimal(bd: BigDecimal, precision: Int?, scale: Int?){
-        value = if (precision == null){
+        val nextValue = if (precision == null){
             if (scale == null) bd
             else bd.setScale(scale, getRoundingMode())
         } else{
@@ -294,6 +294,7 @@ class BigDecimalGene(
                 else this
             }
         }
+        value = nextValue
     }
 
     private fun getMaxUsedInSearchAsLong() : Long{
@@ -385,9 +386,9 @@ class BigDecimalGene(
     override fun checkForLocallyValidIgnoringChildren(): Boolean {
         if (!super.checkForLocallyValidIgnoringChildren())
             return false
-        if (max != null && value > getMaximum())
+        if (value > getMaximum())
             return false
-        if (min != null && value < getMinimum())
+        if (value < getMinimum())
             return false
         return true
     }

core/src/test/kotlin/org/evomaster/core/search/gene/BigDecimalGeneTest.kt

@@ -11,6 +11,8 @@ import org.evomaster.core.search.service.Randomness
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 import java.math.BigDecimal
+import java.math.MathContext
+import java.math.RoundingMode
 
 class BigDecimalGeneTest {
 
@@ -45,4 +47,5 @@ class BigDecimalGeneTest {
             assertTrue(gene.isLocallyValid(), "BigDecimalRange with range [${gene.min},${gene.max}] and initial value ${initialValue} lead to ${gene.value} after ${it} mutations")
         }
     }
-}
+
+}

core/src/test/kotlin/org/evomaster/core/search/gene/GeneSamplerForTests.kt

@@ -623,23 +623,58 @@ object GeneSamplerForTests {
 
         val min = rand.nextInt(0, 2)
 
+        val minSize = rand.choose(listOf(null, min))
+        val maxSize = rand.choose(listOf(null, min + rand.nextInt(1, 3)))
+        val printablePairGene = if (minSize == 2) {
+            samplePairGeneWithAtLeastTwoKeyValues(rand) { samplePrintablePairGene(rand) }
+        } else {
+            samplePrintablePairGene(rand)
+        }
+
         return FixedMapGene(
                 name = "rand MapGene",
-                minSize = rand.choose(listOf(null, min)),
-                maxSize = rand.choose(listOf(null, min + rand.nextInt(1, 3))),
-                template = samplePrintablePairGene(rand)
+                minSize = minSize,
+                maxSize = maxSize,
+                template = printablePairGene
         )
     }
 
-    fun sampleFlexibleMapGene(rand: Randomness): FlexibleMapGene<*> {
 
+    private fun <T : PairGene<*, *>> samplePairGeneWithAtLeastTwoKeyValues(rand: Randomness, sampler: () -> T): T {
+        return generateSequence { sampler() }
+            .first { genePair ->
+                val keyGene = genePair.first
+
+                // If it cannot change, it cannot have "at least two values"
+                if (!keyGene.isMutable()) return@first false
+
+                // Initialize the first instance and compare to the second instance with forced new value
+                val firstInstance = keyGene.copy().apply { doInitialize(rand) }
+                val secondInstance = firstInstance.copy().apply { randomize(rand, true) }
+
+                !firstInstance.containsSameValueAs(secondInstance)
+            }
+    }
+
+    fun sampleFlexibleMapGene(rand: Randomness): FlexibleMapGene<*> {
+        // 1. Sample minSize and maxSize
         val min = rand.nextInt(0, 2)
+        val minSize = rand.choose(listOf(null, min))
+        val maxSize = rand.choose(listOf(null, min + rand.nextInt(1, 3)))
+
+        // 2. Sample pairGeneTemplate
+        val printableFlexiblePairGene = if (minSize == 2) {
+            samplePairGeneWithAtLeastTwoKeyValues(rand) { samplePrintableFlexiblePairGene(rand) }
+        } else {
+            samplePrintableFlexiblePairGene(rand)
+        }
 
+        // 3. Create FlexibleMapGene
         return FlexibleMapGene(
             name = "rand MapGene",
-            minSize = rand.choose(listOf(null, min)),
-            maxSize = rand.choose(listOf(null, min + rand.nextInt(1, 3))),
-            template = samplePrintableFlexiblePairGene(rand)
+            minSize = minSize,
+            maxSize = maxSize,
+            template = printableFlexiblePairGene
         )
     }
 

core/src/test/kotlin/org/evomaster/core/search/gene/MapGeneTest.kt

@@ -8,6 +8,7 @@ import org.evomaster.core.search.gene.collection.PairGene
 import org.evomaster.core.search.gene.numeric.IntegerGene
 import org.evomaster.core.search.gene.wrapper.FlexibleGene
 import org.evomaster.core.search.gene.string.StringGene
+import org.evomaster.core.search.service.Randomness
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
@@ -120,4 +121,21 @@ internal class MapGeneTest{
         assertEquals(1, fMap.getAllElements().size)
         assertEquals(element, fMap.getViewOfChildren().first() as PairGene<*,*>)
     }
-}
+
+    @Test
+    fun testGeneRandomizationFailedIsRisen() {
+        val enumValues = listOf("ONE") // Only one value, so we can't have more than one entry in the map
+        val enumKey = EnumGene("key", enumValues)
+        val strValue = StringGene("value", "foo")
+        
+        // minSize is 2, but only 1 unique key is available
+        val map = FixedMapGene("FailMap", enumKey, strValue, minSize = 2, maxSize = 5)
+        
+        val randomness = Randomness()
+        
+        assertThrows(GeneRandomizationFailed::class.java) {
+            map.randomize(randomness, false)
+        }
+    }
+
+}