checking for unique taint id

Author: arcuri82

core/src/main/kotlin/org/evomaster/core/search/Individual.kt

@@ -1,5 +1,6 @@
 package org.evomaster.core.search
 
+import org.evomaster.client.java.instrumentation.shared.TaintInputName
 import org.evomaster.core.EMConfig
 import org.evomaster.core.sql.SqlAction
 import org.evomaster.core.sql.SqlActionUtils
@@ -196,8 +197,14 @@ abstract class Individual(
             }
         }
 
-        if(!areAllValidLocalIds()){
-            throw IllegalStateException("There are invalid local ids")
+        val localIdErrors = verifyAllLocalIds()
+        if(localIdErrors.isNotEmpty()){
+            throw IllegalStateException("There are invalid local ids:\n" + localIdErrors.joinToString("\n"))
+        }
+
+        val taintIdErrors = verifyTaintIds()
+        if(taintIdErrors.isNotEmpty()){
+            throw IllegalStateException("There are invalid taint ids:\n" + taintIdErrors.joinToString("\n"))
         }
     }
 
@@ -496,15 +503,48 @@ abstract class Individual(
                 && flatView().run { this.map { it.getLocalId() }.toSet().size == this.size }
     }
 
-    fun areAllValidLocalIds() : Boolean{
+
+    fun verifyTaintIds(): List<String>{
+
+        val all = flatViewAllStructuralElements()
+
+        val taintableGenes = all.filterIsInstance<TaintableGene>()
+            .filter { TaintInputName.isTaintInput(it.getPossiblyTaintedValue()) }
+
+        val duplicates = CollectionUtils.duplicates(taintableGenes.map { it.getPossiblyTaintedValue() })
+
+        if(duplicates.isEmpty()){
+            return listOf()
+        }
+
+        val errors = mutableListOf<String>()
+
+        duplicates.entries.forEach { d ->
+           val same = taintableGenes.filter { it.getPossiblyTaintedValue() == d.key }.map { it as Gene }
+           if(same.any{ x -> same.any { y -> y !=x && !y.hasAnyBindingRelationship(x)}}){
+               errors.add("Taint id ${d.key} has duplicate genes that are not bound}")
+           }
+        }
+        return errors
+    }
+
+    /**
+     * Return error messages in case of problems.
+     * If all valid, returned list is empty
+     */
+    fun verifyAllLocalIds() : List<String>{
+        val errors = mutableListOf<String>()
         val all = flatViewAllStructuralElements()
         val ids = all.map { it.getLocalId() }
         if(ids.contains(NONE_LOCAL_ID)){
-            return false
+            errors.add("Containing NONE_LOCAL_ID")
         }
         val duplicates = CollectionUtils.duplicates(ids)
         //check for duplicates
-        return duplicates.isEmpty()
+        if(duplicates.isNotEmpty()){
+            duplicates.entries.forEach { errors.add("Id ${it.key} is repeated ${it.value} times") }
+        }
+        return errors
     }
 
 

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

@@ -1076,6 +1076,17 @@ abstract class Gene(
         }
     }
 
+    fun hasAnyBindingRelationship(other: Gene): Boolean {
+        if (other == this) {
+            return false
+        }
+
+        return other.isDirectBoundWith(this)
+                || other.is2DepthDirectBoundWith(this)
+                || other.isAnyParentBoundWith(this)
+                || this.isAnyParentBoundWith(other)
+    }
+
     /**
      * @return whether [this] is directly bound with [gene]
      */

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

@@ -1,6 +1,7 @@
 package org.evomaster.core.search.gene.collection
 
 import org.evomaster.client.java.instrumentation.shared.TaintInputName
+import org.evomaster.core.StaticCounter
 import org.evomaster.core.output.OutputFormat
 import org.evomaster.core.search.gene.Gene
 import org.evomaster.core.search.gene.interfaces.TaintableGene
@@ -17,8 +18,6 @@ import org.evomaster.core.search.service.mutator.genemutation.SubsetGeneMutation
  *
  * This is needed in 2-phase marshalling, where a string is marshalled into an array of maps,
  * and then each map value is marshalled into a DTO.
- *
- * TODO needs refactoring
  */
 class TaintedArrayGene(
 
@@ -158,10 +157,10 @@ class TaintedArrayGene(
     }
 
     override fun hasDormantGenes(): Boolean {
-        return isResolved() && !isActive //TODO double-check
+        return isResolved() && !isActive
     }
 
     override fun forceNewTaintId() {
-        //TODO
+        taintedValue = TaintInputName.getTaintName(StaticCounter.getAndIncrease())
     }
 }

core/src/main/kotlin/org/evomaster/core/search/gene/string/StringGene.kt

@@ -462,9 +462,13 @@ class StringGene(
         handleBinding(allGenes)
     }
 
+    private fun verifyIfNewTaintWouldBeFine() : Boolean{
+        return TaintInputName.doesTaintNameSatisfiesLengthConstraints("${StaticCounter.get()}", actualMaxLength())
+    }
+
     fun redoTaint(apc: AdaptiveParameterControl, randomness: Randomness) : Boolean{
 
-        if(!TaintInputName.doesTaintNameSatisfiesLengthConstraints("${StaticCounter.get()}", actualMaxLength())){
+        if(!verifyIfNewTaintWouldBeFine()){
             return false
         }
 
@@ -1061,7 +1065,10 @@ class StringGene(
     }
 
     override fun forceNewTaintId() {
-        //TODO
+        if(TaintInputName.isTaintInput(value) && verifyIfNewTaintWouldBeFine()){
+            forceTaintedValue()
+            //note: selectedSpecialization is NOT modified here
+        }
     }
 
     /**

core/src/main/kotlin/org/evomaster/core/taint/TaintAnalysis.kt

@@ -467,15 +467,14 @@ object TaintAnalysis {
         } else {
             if (genes.size > 1
                     && TaintInputName.isTaintInput(taintedInput)
-                    && genes.none { x -> genes.any { y -> x.isDirectBoundWith(y) || x.is2DepthDirectBoundWith(y) || x.isAnyParentBoundWith(y) } }
+                    && genes.none { x -> genes.any { y -> y.hasAnyBindingRelationship(x) } }
             ) {
                 //shouldn't really be a problem... but let keep track for it, for now at least.
                 // note, cannot really guarantee that a taint from regex is unique, as regex could generate
                 // any kind of string...
                 // also if genes are bound, then of course going to be more than 2...
                 log.warn("More than 2 genes have the taint '{}'", taintedInput)
-                //FIXME possible bug in binding handling.
-//                assert(false)
+                assert(false)
             }
             genes
                 .filter { it.name != TaintInputName.TAINTED_MAP_EM_LABEL_IDENTIFIER /* should never be modified */ }