fixed few bugs based on broken invariant

Author: arcuri82

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

@@ -141,6 +141,8 @@ class ArrayGene<T>(
         }
         if (this.template::class.simpleName != other.template::class.simpleName) return false
 
+        if(this.elements.size != other.elements.size) return false
+
         return this.elements.zip(other.elements) { thisElem, otherElem ->
             thisElem.containsSameValueAs(otherElem)
         }.all { it }

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

@@ -210,7 +210,7 @@ class EnumGene<T : Comparable<T>>(
 
         val phenotype = other.getPhenotype()
         when(phenotype) {
-            is EnumGene<*> -> index == phenotype.index
+            is EnumGene<*> -> index = phenotype.index
             else -> {
                 // since the binding is derived, it is not always true.
                 log.info("cannot bind EnumGene with ${phenotype::class.java.simpleName}")

core/src/main/kotlin/org/evomaster/core/search/gene/datetime/TimeGene.kt

@@ -201,8 +201,8 @@ class TimeGene(
         return when (gene) {
             is TimeGene -> {
                 hour.unsafeCopyValueFrom(gene.hour)
-                        && second.unsafeCopyValueFrom(gene.minute)
-                        && minute.unsafeCopyValueFrom(gene.second)
+                        && second.unsafeCopyValueFrom(gene.second)
+                        && minute.unsafeCopyValueFrom(gene.minute)
                         && millisecond.unsafeCopyValueFrom(gene.millisecond)
                         && offset.unsafeCopyValueFrom(gene.offset)
             }

core/src/main/kotlin/org/evomaster/core/search/gene/sql/SqlRangeGene.kt

@@ -92,7 +92,7 @@ class SqlRangeGene<T>(
         if (other !is SqlRangeGene<*>) {
             throw IllegalArgumentException("Invalid gene type ${other.javaClass}")
         }
-        return isLeftClosed.containsSameValueAs(other.isRightClosed)
+        return isLeftClosed.containsSameValueAs(other.isLeftClosed)
                 && left.containsSameValueAs(other.left as Gene)
                 && right.containsSameValueAs(other.right as Gene)
                 && isRightClosed.containsSameValueAs(other.isRightClosed)

core/src/main/kotlin/org/evomaster/core/search/gene/uri/UriGene.kt

@@ -81,6 +81,9 @@ class UriGene(name: String,
     }
 
     override fun unsafeCopyValueFrom(other: Gene): Boolean {
+        if(other is UriGene){
+            return gene.unsafeCopyValueFrom(other.gene)
+        }
         return gene.unsafeCopyValueFrom(other)
     }
 

core/src/main/kotlin/org/evomaster/core/search/gene/wrapper/FlexibleGene.kt

@@ -131,24 +131,17 @@ class FlexibleGene(name: String,
     }
 
     override fun unsafeCopyValueFrom(other: Gene): Boolean {
-        if (other !is FlexibleGene)
+        if (other !is FlexibleGene) {
             return false
-        if (replaceable){
-
-            if (!other.isLocallyValid())
-                return false
-
-            try {
-                geneCheck(other)
-            }catch (e: Exception){
-                return false
-            }
+        }
 
+        if (replaceable){
             val replaced = other.gene.copy()
             replaced.resetLocalIdRecursively()
             replaceGeneTo(replaced)
+            return true
 
-        }else{
+        } else {
             // TODO need to refactor
             log.warn("TOCHECK, attempt to copyValueFrom when it is not replaceable")
         }

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

@@ -4,6 +4,7 @@ package org.evomaster.core.search.gene
 import org.evomaster.core.search.gene.interfaces.WrapperGene
 import org.evomaster.core.search.service.Randomness
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.DynamicTest
 import org.junit.jupiter.api.TestFactory
@@ -26,26 +27,65 @@ class GeneRandomizedTest : AbstractGeneTest(){
         rand.updateSeed(seed)
         val sample = getSample(seed)
 
-        sample.filter { it.isMutable() }
-                .forEach { root ->
-                    root.doInitialize(rand)
-                    checkInvariants(root) // all invariants should hold
-
-                    val copy = root.copy()
-                    checkInvariants(copy) //same for a copy
-
-                    if(root.isGloballyValid()) { //in these tests, global constraints are not handled
-                        if (root.isPrintable()) {
-                            val x = root.getValueAsRawString()
-                            val y = copy.getValueAsRawString()
-                            assertEquals(x, y) // the copy should result in same phenotype
-                        } else {
-                            assertThrows<Exception>("Should throw exception when trying to print ${root.javaClass}") {
-                                root.getValueAsRawString()
-                            }
-                        }
+        val mutable = sample.filter { it.isMutable() }
+
+        mutable.forEach { root ->
+            root.doInitialize(rand)
+            checkInvariants(root) // all invariants should hold
+
+            val copy = root.copy()
+            checkInvariants(copy) //same for a copy
+
+            if(root.isGloballyValid()) { //in these tests, global constraints are not handled
+                if (root.isPrintable()) {
+                    val x = root.getValueAsRawString()
+                    val y = copy.getValueAsRawString()
+                    assertEquals(x, y) // the copy should result in same phenotype
+                } else {
+                    assertThrows<Exception>("Should throw exception when trying to print ${root.javaClass}") {
+                        root.getValueAsRawString()
                     }
                 }
+            }
+        }
+
+        //FIXME put back once fix all issues it finds
+        //verifyCopyValueFrom(mutable, rand)
+    }
+
+    private fun verifyCopyValueFrom(
+        mutable: List<Gene>,
+        rand: Randomness
+    ) {
+        val printable = mutable.filter { it.isGloballyValid() && it.isPrintable() }
+
+        printable.forEach { root ->
+
+            val x = root.copy()
+            val sx = x.getValueAsRawString()
+
+            val y = x.copy().apply { randomize(rand, true) }
+            val sy = y.getValueAsRawString()
+
+            if (sx == sy) {
+                //randomization did not change phenotype... but might still change the genotype!!!
+                //rare but this can happen, eg when internal genes in a collection are not printable
+                //assertTrue(x.containsSameValueAs(y))
+            } else {
+                //they must be different. the same genotype must not lead to different phenotypes
+                assertFalse(x.containsSameValueAs(y))
+
+                //with same type and constraints, even "unsafe" should always work
+                val wasCopied = x.unsafeCopyValueFrom(y)
+                assertTrue(wasCopied)
+
+                assertTrue(x.containsSameValueAs(y))
+            }
+
+            val other = rand.choose(printable)
+            //this should not crash, ie throw any exception
+            x.copyValueFrom(other)
+        }
     }
 
 
@@ -78,6 +118,9 @@ class GeneRandomizedTest : AbstractGeneTest(){
             assertEquals(gene, leaf)
         }
 
+        //must contain same value as itself
+        assertTrue(gene.containsSameValueAs(gene))
+
         //TODO add more invariants here
     }
 }