From 5beb38e2da12b4e8fdb1348f7c20493e495412ae Mon Sep 17 00:00:00 2001
From: ivakertusha <iva.kertusha@gmail.com>
Date: Wed, 30 Apr 2025 09:48:54 +0200
Subject: [PATCH 01/15] Dropdown test

---
 .../dropdown/DropDownWebApplication.java      |  1 -
 .../dropdownselector/DropDownController.java  | 11 ++++++
 .../web/dropdownselector/DropDownEMTest.java  | 39 +++++++++++++++++++
 3 files changed, 50 insertions(+), 1 deletion(-)
 create mode 100644 e2e-tests/spring-web/src/test/java/com/foo/web/examples/spring/dropdownselector/DropDownController.java
 create mode 100644 e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java

diff --git a/e2e-tests/spring-web/src/main/java/com/foo/web/examples/spring/dropdown/DropDownWebApplication.java b/e2e-tests/spring-web/src/main/java/com/foo/web/examples/spring/dropdown/DropDownWebApplication.java
index 310f5e638f..dde33a761e 100644
--- a/e2e-tests/spring-web/src/main/java/com/foo/web/examples/spring/dropdown/DropDownWebApplication.java
+++ b/e2e-tests/spring-web/src/main/java/com/foo/web/examples/spring/dropdown/DropDownWebApplication.java
@@ -3,7 +3,6 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
-import org.springframework.web.bind.annotation.GetMapping;
 
 @SpringBootApplication(exclude = SecurityAutoConfiguration.class)
 public class DropDownWebApplication {
diff --git a/e2e-tests/spring-web/src/test/java/com/foo/web/examples/spring/dropdownselector/DropDownController.java b/e2e-tests/spring-web/src/test/java/com/foo/web/examples/spring/dropdownselector/DropDownController.java
new file mode 100644
index 0000000000..d1d9f72d55
--- /dev/null
+++ b/e2e-tests/spring-web/src/test/java/com/foo/web/examples/spring/dropdownselector/DropDownController.java
@@ -0,0 +1,11 @@
+package com.foo.web.examples.spring.dropdownselector;
+
+import com.foo.web.examples.spring.SpringController;
+import com.foo.web.examples.spring.base.BaseWebApplication;
+
+public class DropDownController extends SpringController {
+    public DropDownController() {
+        super(BaseWebApplication.class, "/dropdown/index.html");
+    }
+
+}
diff --git a/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java b/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
new file mode 100644
index 0000000000..e8c1206980
--- /dev/null
+++ b/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
@@ -0,0 +1,39 @@
+package org.evomaster.e2etests.spring.web.dropdownselector;
+
+import com.foo.web.examples.spring.dropdownselector.DropDownController;
+import org.evomaster.core.problem.webfrontend.WebIndividual;
+import org.evomaster.core.search.Solution;
+import org.evomaster.e2etests.spring.web.SpringTestBase;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class DropDownEMTest extends SpringTestBase {
+    @BeforeAll
+    public static void initClass() throws Exception {
+        SpringTestBase.initClass(new DropDownController());
+    }
+
+    @Disabled
+    @Test
+    public void testRunEM() throws Throwable {
+
+        runTestHandlingFlakyAndCompilation(
+                "DropDownEM",
+                "org.DropDownEM",
+                50,
+                (args) -> {
+
+                    Solution<WebIndividual> solution = initAndRun(args);
+
+                    assertTrue(solution.getIndividuals().size() > 0);
+
+                    assertHasVisitedUrlPath(solution, "/dropdown/index.html", "/dropdown/page1.html", "/dropdown/page2.html", "/dropdown/page3.html");
+                    assertNoHtmlErrors(solution); // statement ok - gives no errors
+                }
+        );
+    }
+
+}

From cea4aec95ea5f9873b09740ee8f562c12f8432b5 Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Wed, 30 Apr 2025 10:16:42 +0200
Subject: [PATCH 02/15] starting handling DropDown, but realized cannot use
 Jsoup. need refactoring

---
 .../webfrontend/BrowserActionBuilder.kt       | 37 ++++++++++++++++---
 .../problem/webfrontend/UserActionType.kt     | 12 +++++-
 2 files changed, 43 insertions(+), 6 deletions(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
index 8d4dcab9cd..115d681c9c 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
@@ -1,13 +1,22 @@
 package org.evomaster.core.problem.webfrontend
 
 import org.jsoup.Jsoup
+import org.jsoup.nodes.Document
+import org.openqa.selenium.WebElement
+import org.openqa.selenium.support.ui.Select
 import java.net.URI
 import java.net.URISyntaxException
-import java.net.URL
 
 object BrowserActionBuilder {
 
 
+    /**
+     * FIXME this might require refactoring
+     * checking on HTML as string might (or might not???) lose dynamic info added to the page.
+     * TODO need to verify this.
+     * Might be better to pass in a Selenium Document.
+     * We need to verify before making the refactoring
+     */
     fun computePossibleUserInteractions(html: String) : List<WebUserInteraction>{
 
 
@@ -22,10 +31,30 @@ object BrowserActionBuilder {
 
         //TODO all cases
 
+        handleALinks(document, list)
+        handleDropDowns(document, list)
+
+        return list
+    }
+
+    private fun handleDropDowns(document: Document, list: MutableList<WebUserInteraction>) {
+
+        document.getElementsByTag("select")
+            .forEach {
+                //TODO
+               // val type =
+               // list.add(WebUserInteraction(it.cssSelector(), UserActionType.SELECT))
+            }
+    }
+
+    private fun handleALinks(
+        document: Document,
+        list: MutableList<WebUserInteraction>
+    ) {
         document.getElementsByTag("a")
             .forEach {
                 val href = it.attr("href")
-                val canClick = if(!href.isNullOrBlank()) {
+                val canClick = if (!href.isNullOrBlank()) {
                     val uri = try {
                         URI(href)
                     } catch (e: URISyntaxException) {
@@ -38,12 +67,10 @@ object BrowserActionBuilder {
                     val onclick = it.attr("onclick")
                     !onclick.isNullOrBlank()
                 }
-                if(canClick){
+                if (canClick) {
                     list.add(WebUserInteraction(it.cssSelector(), UserActionType.CLICK))
                 }
             }
-
-        return list
     }
 
 
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt
index b209079254..aacd11f04c 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt
@@ -4,5 +4,15 @@ enum class UserActionType {
 
     CLICK,
 
-    FILL_TEXT
+    FILL_TEXT,
+
+    /**
+     * Select only a single element in a dropdown <select> element
+     */
+    SELECT_SINGLE,
+
+    /**
+     * Some dropdown <select> elements might allow to select more than one element
+     */
+    SELECT_MULTI,
 }
\ No newline at end of file

From 9f360cfdd2ab4f705deb1dece51f4f4f037a75a9 Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Wed, 30 Apr 2025 10:40:03 +0200
Subject: [PATCH 03/15] defining actions for Select

---
 .../webfrontend/BrowserActionBuilder.kt       | 42 +++++++++++--------
 .../problem/webfrontend/WebUserInteraction.kt |  3 +-
 .../webfrontend/service/BrowserController.kt  |  6 ++-
 .../problem/webfrontend/service/WebFitness.kt |  2 +-
 4 files changed, 33 insertions(+), 20 deletions(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
index 115d681c9c..2762a3436d 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
@@ -2,7 +2,8 @@ package org.evomaster.core.problem.webfrontend
 
 import org.jsoup.Jsoup
 import org.jsoup.nodes.Document
-import org.openqa.selenium.WebElement
+import org.openqa.selenium.By
+import org.openqa.selenium.remote.RemoteWebDriver
 import org.openqa.selenium.support.ui.Select
 import java.net.URI
 import java.net.URISyntaxException
@@ -11,17 +12,12 @@ object BrowserActionBuilder {
 
 
     /**
-     * FIXME this might require refactoring
-     * checking on HTML as string might (or might not???) lose dynamic info added to the page.
-     * TODO need to verify this.
-     * Might be better to pass in a Selenium Document.
-     * We need to verify before making the refactoring
      */
-    fun computePossibleUserInteractions(html: String) : List<WebUserInteraction>{
+    fun computePossibleUserInteractions(driver: RemoteWebDriver) : List<WebUserInteraction>{
 
 
         val document = try{
-            Jsoup.parse(html)
+            Jsoup.parse(driver.pageSource)
         }catch (e: Exception){
             //TODO double-check
             return listOf()
@@ -31,24 +27,36 @@ object BrowserActionBuilder {
 
         //TODO all cases
 
-        handleALinks(document, list)
-        handleDropDowns(document, list)
+        handleALinks(document, driver, list)
+        handleDropDowns(document, driver, list)
 
         return list
     }
 
-    private fun handleDropDowns(document: Document, list: MutableList<WebUserInteraction>) {
+    private fun handleDropDowns(
+        document: Document,
+        driver: RemoteWebDriver,
+        list: MutableList<WebUserInteraction>
+    ) {
 
         document.getElementsByTag("select")
-            .forEach {
-                //TODO
-               // val type =
-               // list.add(WebUserInteraction(it.cssSelector(), UserActionType.SELECT))
+            .forEach { jsoup ->
+                val dropdown = Select(driver.findElement(By.cssSelector(jsoup.cssSelector())))
+                val type = if(dropdown.isMultiple) {
+                    UserActionType.SELECT_MULTI
+                }  else {
+                    UserActionType.SELECT_SINGLE
+                }
+                val options = dropdown.options
+                    .filter{it.isEnabled}
+                    .map{it.text}
+                list.add(WebUserInteraction(jsoup.cssSelector(), type, options))
             }
     }
 
     private fun handleALinks(
         document: Document,
+        driver: RemoteWebDriver,
         list: MutableList<WebUserInteraction>
     ) {
         document.getElementsByTag("a")
@@ -74,9 +82,9 @@ object BrowserActionBuilder {
     }
 
 
-    fun createPossibleActions(html: String) : List<WebAction>{
+    fun createPossibleActions(driver: RemoteWebDriver) : List<WebAction>{
 
-        val interactions = computePossibleUserInteractions(html)
+        val interactions = computePossibleUserInteractions(driver)
 
         val inputs = interactions.filter { it.userActionType == UserActionType.FILL_TEXT }
         val others = interactions.filter { it.userActionType != UserActionType.FILL_TEXT }
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebUserInteraction.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebUserInteraction.kt
index 2254755e5a..ba16764f67 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebUserInteraction.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebUserInteraction.kt
@@ -3,5 +3,6 @@ package org.evomaster.core.problem.webfrontend
 
 data class WebUserInteraction(
     val cssSelector : String,
-    val userActionType : UserActionType
+    val userActionType : UserActionType,
+    val inputs : List<String> = listOf()
     )
\ No newline at end of file
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
index 2e28dcb3f8..cdde0cd2ed 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
@@ -67,7 +67,7 @@ class BrowserController {
     }
 
     fun computePossibleUserInteractions() : List<WebUserInteraction>{
-        return BrowserActionBuilder.computePossibleUserInteractions(getCurrentPageSource())
+        return BrowserActionBuilder.computePossibleUserInteractions(driver)
     }
 
     fun getCurrentPageSource(): String {
@@ -78,6 +78,10 @@ class BrowserController {
         return driver.currentUrl
     }
 
+    fun getDriver(): RemoteWebDriver{
+        return driver
+    }
+
     fun clickAndWaitPageLoad(cssSelector: String){
         SeleniumEMUtils.clickAndWaitPageLoad(driver, cssSelector)
     }
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
index 38659dacde..0081fb6e07 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
@@ -104,7 +104,7 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
 
         val pageBeforeExecutingAction = browserController.getCurrentPageSource()
         val urlBeforeExecutingAction = browserController.getCurrentUrl()
-        val possibilities = BrowserActionBuilder.createPossibleActions(pageBeforeExecutingAction)
+        val possibilities = BrowserActionBuilder.createPossibleActions(browserController.getDriver())
 
         var blocking = false
 

From fb289bd4aca65c5ad3afca3ec4a8da8b0ece915d Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Wed, 30 Apr 2025 11:06:32 +0200
Subject: [PATCH 04/15] starting points for dropdown

---
 .../service/BrowserControllerDockerTest.kt    |  3 +++
 .../webfrontend/BrowserActionBuilder.kt       | 17 ++++++++++++-
 .../core/problem/webfrontend/WebAction.kt     | 25 ++++++++++++++++---
 .../webfrontend/service/BrowserController.kt  |  4 +++
 .../problem/webfrontend/service/WebFitness.kt |  7 ++++++
 5 files changed, 52 insertions(+), 4 deletions(-)

diff --git a/core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt b/core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt
index 27ae64125b..5f705a0ffa 100644
--- a/core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt
+++ b/core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt
@@ -83,4 +83,7 @@ internal class BrowserControllerDockerTest{
         browser.goBack()
         assertEquals(aPage, browser.getCurrentUrl())
     }
+
+    //TODO @IVa add test for Select
+
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
index 2762a3436d..7552ab1cc9 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
@@ -1,5 +1,6 @@
 package org.evomaster.core.problem.webfrontend
 
+import org.evomaster.core.search.gene.numeric.IntegerGene
 import org.jsoup.Jsoup
 import org.jsoup.nodes.Document
 import org.openqa.selenium.By
@@ -7,6 +8,7 @@ import org.openqa.selenium.remote.RemoteWebDriver
 import org.openqa.selenium.support.ui.Select
 import java.net.URI
 import java.net.URISyntaxException
+import kotlin.math.min
 
 object BrowserActionBuilder {
 
@@ -91,7 +93,20 @@ object BrowserActionBuilder {
 
         //TODO genes for inputs
 
-        return others.map { WebAction(mutableListOf(it)) }
+        return others.map {
+            when(it.userActionType) {
+                UserActionType.CLICK -> WebAction(mutableListOf(it))
+                UserActionType.SELECT_SINGLE -> {
+                    val selection = IntegerGene(it.cssSelector, min=0, max=it.inputs.size)
+                    WebAction(mutableListOf(it), singleSelection = mutableMapOf(it.cssSelector to selection))
+                }
+                //TODO multi
+                else -> {
+                    //TODO log warn
+                    WebAction(mutableListOf(it))
+                }
+            }
+        }
     }
 
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
index dd46ef791c..796ed9477e 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
@@ -2,7 +2,10 @@ package org.evomaster.core.problem.webfrontend
 
 import org.evomaster.core.problem.gui.GuiAction
 import org.evomaster.core.search.StructuralElement
+import org.evomaster.core.search.gene.BooleanGene
 import org.evomaster.core.search.gene.Gene
+import org.evomaster.core.search.gene.collection.ArrayGene
+import org.evomaster.core.search.gene.numeric.IntegerGene
 import org.evomaster.core.search.gene.string.StringGene
 import org.jsoup.Jsoup
 
@@ -15,8 +18,20 @@ class WebAction(
     /**
      * Map from cssLocator (coming from [userInteractions]) for text input to StringGene representing its value
      */
-    val textData : MutableMap<String, StringGene> = mutableMapOf()
-) : GuiAction(textData.values.map { it }) {
+    val textData : MutableMap<String, StringGene> = mutableMapOf(),
+    /**
+     * TODO explanation
+     */
+    val singleSelection: MutableMap<String, IntegerGene> = mutableMapOf(),
+    /**
+     * TODO explanation
+     */
+    val multiSelection: MutableMap<String, ArrayGene<BooleanGene>> = mutableMapOf(),
+) : GuiAction(
+    textData.values.map { it }
+        .plus(singleSelection.values.map { it })
+        .plus(multiSelection.values.map { it })
+) {
 
     init {
         val nFillText = userInteractions.count { it.userActionType == UserActionType.FILL_TEXT }
@@ -28,6 +43,7 @@ class WebAction(
                 throw IllegalArgumentException("Missing info for input: $key")
             }
         }
+        //TODO constraint checks on singleSelection and multiSelection
     }
 
     override fun isDefined() : Boolean {
@@ -65,7 +81,9 @@ class WebAction(
     override fun copyContent(): StructuralElement {
         return WebAction(
             userInteractions.map { it.copy() }.toMutableList(),
-            textData.entries.associate { it.key to it.value.copy() as StringGene }.toMutableMap()
+            textData.entries.associate { it.key to it.value.copy() as StringGene }.toMutableMap(),
+            singleSelection.entries.associate { it.key to it.value.copy() as IntegerGene }.toMutableMap(),
+            multiSelection.entries.associate { it.key to it.value.copy() as ArrayGene<BooleanGene> }.toMutableMap(),
         )
     }
 
@@ -74,6 +92,7 @@ class WebAction(
         userInteractions.addAll(other.userInteractions) //immutable elements
         textData.clear()
         textData.putAll(other.textData.entries.associate { it.key to it.value.copy() as StringGene })
+        //TODO singleSelection multiSelection
     }
 
     fun getIdentifier() : String {
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
index cdde0cd2ed..045c8cc546 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
@@ -86,6 +86,10 @@ class BrowserController {
         SeleniumEMUtils.clickAndWaitPageLoad(driver, cssSelector)
     }
 
+    fun selectAndWaitPageLoad(cssSelector: String, values: List<String>){
+        //TODO
+    }
+
     fun goBack(){
         driver.navigate().back()
         SeleniumEMUtils.waitForPageToLoad(driver,2)
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
index 0081fb6e07..7c702cce53 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
@@ -140,6 +140,13 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
                         browserController.clickAndWaitPageLoad(it.cssSelector)
                         //TODO better wait
                     }
+                    UserActionType.SELECT_SINGLE, UserActionType.SELECT_MULTI -> {
+                        //TODO
+                        /*
+                            not just clicking, but deciding which options to select.
+                            this is based on values in the genes
+                         */
+                    }
                     else -> {
                         log.error("Not handled action type ${it.userActionType}")
                     }

From 69a6d7c857add265a0444397dfece888b2e5fc9c Mon Sep 17 00:00:00 2001
From: ivakertusha <iva.kertusha@gmail.com>
Date: Wed, 30 Apr 2025 11:26:07 +0200
Subject: [PATCH 05/15] different user action types

---
 .../core/problem/webfrontend/UserActionType.kt      | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt
index aacd11f04c..02b26711b2 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/UserActionType.kt
@@ -15,4 +15,17 @@ enum class UserActionType {
      * Some dropdown <select> elements might allow to select more than one element
      */
     SELECT_MULTI,
+
+    DOUBLE_CLICK,
+    RIGHT_CLICK,
+    HOVER_OVER_ELEMENT,
+    VERTICAL_SCROLLING,
+    HORIZONTAL_SCROLLING,
+    DRAG_AND_DROP,
+
+    CHECK_CHECKBOX,
+    UNCHECK_CHECKBOX,
+    CHOOSE_RADIO_BUTTON,
+    SELECT,
+    UPLOAD_FILE,
 }
\ No newline at end of file

From dea9264a18e4d39413d4f1e9fb884f6d76418ca1 Mon Sep 17 00:00:00 2001
From: ivakertusha <iva.kertusha@gmail.com>
Date: Wed, 18 Jun 2025 09:45:11 +0200
Subject: [PATCH 06/15] selenium select minor fix plus some other changes

---
 .../evomaster/test/utils/SeleniumEMUtils.java |  19 +++
 .../core/output/service/WebTestCaseWriter.kt  |   4 +
 .../webfrontend/BrowserActionBuilder.kt       |   2 +
 .../core/problem/webfrontend/WebAction.kt     |   6 +-
 .../core/problem/webfrontend/WebIndividual.kt |   3 +-
 .../webfrontend/service/BrowserController.kt  |   6 +
 .../problem/webfrontend/service/WebFitness.kt | 146 +++++++++++++-----
 .../webfrontend/service/WebPageIdentifier.kt  |  12 +-
 .../problem/webfrontend/service/WebSampler.kt |  12 +-
 .../web/dropdownselector/DropDownEMTest.java  |   2 +-
 10 files changed, 163 insertions(+), 49 deletions(-)

diff --git a/client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java b/client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java
index d69504d1b5..1a03442d66 100644
--- a/client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java
+++ b/client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java
@@ -2,6 +2,7 @@
 
 import org.openqa.selenium.*;
 import org.openqa.selenium.support.ui.ExpectedCondition;
+import org.openqa.selenium.support.ui.Select;
 import org.openqa.selenium.support.ui.WebDriverWait;
 import org.testcontainers.Testcontainers;
 
@@ -127,6 +128,24 @@ public static void clickAndWaitPageLoad(WebDriver driver, String cssSelector){
         //TODO will need to check if JS executing in background
     }
 
+    public static void selectAndWaitPageLoad(WebDriver driver, String cssSelector, String value) {
+        Select element;
+        try {
+            WebElement el = driver.findElement(By.cssSelector(cssSelector));
+            element = new Select(el);
+        } catch (NoSuchElementException e) {
+            throw new RuntimeException("Cannot locate element with '" + cssSelector + "'." +
+                    "\nCurrent URL is: " + driver.getCurrentUrl() +
+                    "\nCurrent page is: " + driver.getPageSource());
+        }
+        element.selectByValue(value);
+        try {
+            Thread.sleep(50);
+        } catch (Exception e) {
+        }
+        waitForPageToLoad(driver, 2);
+    }
+
     public static void goToPage(WebDriver driver, String pageURL, int timeoutSeconds){
         driver.get(pageURL);
         waitForPageToLoad(driver, timeoutSeconds);
diff --git a/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt b/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
index 4fad8836ba..f832838b4b 100644
--- a/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
+++ b/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
@@ -77,6 +77,10 @@ class WebTestCaseWriter : TestCaseWriter() {
                     lines.addStatement("clickAndWaitPageLoad($driver, \"${it.cssSelector}\")")
                     lines.append(getCommentOnPage("on page", r.getUrlPageStart()!!, r.getUrlPageEnd(), r.getValidHtml()))
                 }
+                UserActionType.SELECT_SINGLE-> {
+                    lines.addStatement("selectAndWaitPageLoad($driver, \"${it.cssSelector}\")")
+                    lines.append(getCommentOnPage("on page", r.getUrlPageStart()!!, r.getUrlPageEnd(), r.getValidHtml()))
+                }
                 //TODO all other cases
                 else -> throw IllegalStateException("Not handled action type: ${it.userActionType}")
             }
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
index 7552ab1cc9..579048a8af 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
@@ -56,6 +56,8 @@ object BrowserActionBuilder {
             }
     }
 
+
+/* Analyze anchor tags to identify clickable elements*/
     private fun handleALinks(
         document: Document,
         driver: RemoteWebDriver,
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
index 796ed9477e..1840200a04 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
@@ -11,12 +11,14 @@ import org.jsoup.Jsoup
 
 class WebAction(
     /**
-     * Different interactions could be squizzed into a single action, like filling all text inputs
-     * of a form and then submit it
+     * Different interactions could be squeezed into a single action, like filling all text inputs
+     * of a form and then submit it -
+     * ie. filling a form and submitting - would be considered one action
      */
     val userInteractions: MutableList<WebUserInteraction> = mutableListOf(),
     /**
      * Map from cssLocator (coming from [userInteractions]) for text input to StringGene representing its value
+     * MutableMap<csslocator, gene>
      */
     val textData : MutableMap<String, StringGene> = mutableMapOf(),
     /**
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebIndividual.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebIndividual.kt
index c4a3192287..66dc1dc4c3 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebIndividual.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebIndividual.kt
@@ -11,6 +11,7 @@ import org.evomaster.core.search.Individual
 import org.evomaster.core.search.StructuralElement
 import org.evomaster.core.search.gene.Gene
 
+//A test case or test suite (?)
 class WebIndividual(
     sampleType: SampleType,
     children: MutableList<out ActionComponent>,
@@ -25,7 +26,7 @@ class WebIndividual(
     childTypeVerifier = EnterpriseChildTypeVerifier(WebAction::class.java),
     groups = groups
 ) {
-
+    // to support genetic operation (?)
     override fun copyContent(): Individual {
         return WebIndividual(
             sampleType,
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
index 045c8cc546..1ffec3e696 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
@@ -51,6 +51,8 @@ class BrowserController {
 
     fun cleanBrowser(){
         //TODO clean cookies
+        driver.manage().deleteAllCookies();
+        //maybe also clean cache?
     }
 
     fun goToStartingPage(){
@@ -86,8 +88,12 @@ class BrowserController {
         SeleniumEMUtils.clickAndWaitPageLoad(driver, cssSelector)
     }
 
+    //fun selectAndWaitPageLoad(cssSelector: String, values: List<String>){
     fun selectAndWaitPageLoad(cssSelector: String, values: List<String>){
         //TODO
+        if(values.size == 1) // if single select
+            SeleniumEMUtils.selectAndWaitPageLoad(driver,cssSelector,values[0]);
+        //TODO for multi
     }
 
     fun goBack(){
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
index 7c702cce53..f5bd2721cd 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
@@ -9,7 +9,9 @@ import org.evomaster.core.problem.webfrontend.*
 import org.evomaster.core.search.action.ActionResult
 import org.evomaster.core.search.EvaluatedIndividual
 import org.evomaster.core.search.FitnessValue
+import org.evomaster.core.search.gene.numeric.IntegerGene
 import org.evomaster.core.taint.TaintAnalysis
+import org.openqa.selenium.WebDriver
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import java.net.MalformedURLException
@@ -17,7 +19,11 @@ import java.net.URI
 import java.net.URISyntaxException
 import java.net.URL
 import javax.inject.Inject
+import javax.net.ssl.HttpsURLConnection
 
+/*  ftiness fuction - given an input text case- tell me how good it is. 0- not covered, 1 - covered.
+*
+* */
 
 class WebFitness : EnterpriseFitness<WebIndividual>() {
 
@@ -46,15 +52,22 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
         rc.resetSUT()
         browserController.cleanBrowser() //TODO these 2 calls could be made in parallel
 
-        val actionResults: MutableList<ActionResult> = mutableListOf()
+        val actionResults: MutableList<ActionResult> =
+            mutableListOf() // keep track of results - for each action we execute we need to know the result of the action. ex: the response of an http call
 
-        doDbCalls(individual.seeInitializingActions().filterIsInstance<SqlAction>(), actionResults = actionResults)
+        //initialization
+        doDbCalls(
+            individual.seeInitializingActions().filterIsInstance<SqlAction>(),
+            actionResults = actionResults
+        )// to think about it later, next year - it is setting up the environment
 
+        //data structure representing the fitness of the individual
         val fv = FitnessValue(individual.size().toDouble())
 
         val actions = individual.seeMainExecutableActions()
 
         browserController.goToStartingPage()
+        //read what this functions does - checks if URLs are malformed
         checkHtmlGlobalOracle(browserController.getCurrentPageSource(), browserController.getCurrentUrl(), fv)
         //if starting page is invalid, not much we can do at all...
         //TODO maybe should have explicit check at the beginning of the search
@@ -64,31 +77,33 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
 
             val a = actions[i]
 
-            registerNewAction(a, i)
+            registerNewAction(a, i) // needed to tell the driver about the action to be taken
 
             val ok = handleWebAction(a, actionResults, fv)
             actionResults.filterIsInstance<WebResult>()[i].stopping = !ok
+            // the concept of stopping - stopping the execution of  all suggested test cases ( instead of 5 for instance, execute only 3)
 
             if (!ok) {
                 break
             }
         }
-
+        // once stopped, ask the driver to give all the heuristics collected
         val dto = updateFitnessAfterEvaluation(targets, allTargets, fullyCovered, descriptiveIds, individual, fv)
             ?: return null
 
         handleExtra(dto, fv)
 
+        //
         val webResults = actionResults.filterIsInstance<WebResult>()
-        handleResponseTargets(fv, actions, webResults, dto.additionalInfoList)
+        handleResponseTargets(fv, actions, webResults, dto.additionalInfoList)// handles black box interaction
 
 
-        if (config.isEnabledTaintAnalysis()) {
+        if (config.isEnabledTaintAnalysis()) {// skip for now
             Lazy.assert { webResults.size == dto.additionalInfoList.size }
             TaintAnalysis.doTaintAnalysis(individual, dto.additionalInfoList, randomness, config)
         }
 
-        return EvaluatedIndividual(
+        return EvaluatedIndividual( //
             fv,
             individual.copy() as WebIndividual,
             actionResults,
@@ -98,40 +113,44 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
         )
     }
 
-    private fun handleWebAction(a: WebAction, actionResults: MutableList<ActionResult>, fv: FitnessValue): Boolean {
+    //the actual execution
+    private fun handleWebAction(wa: WebAction, actionResults: MutableList<ActionResult>, fv: FitnessValue): Boolean {
 
-        //TODO should check if current "page" is not html, eg an image
+        //TODO should check if current "page" is not html, eg an image -done - to be checked
 
         val pageBeforeExecutingAction = browserController.getCurrentPageSource()
         val urlBeforeExecutingAction = browserController.getCurrentUrl()
         val possibilities = BrowserActionBuilder.createPossibleActions(browserController.getDriver())
 
+        if (isNotHtmlPage(browserController.getDriver(), pageBeforeExecutingAction, urlBeforeExecutingAction)) {
+            log.error("Not an HTML page"); // to be amended
+        }
+
         var blocking = false
 
-        if(!a.isDefined() ||
-            !a.isApplicableInGivenPage(pageBeforeExecutingAction)){
+        if (!wa.isDefined() || !wa.isApplicableInGivenPage(pageBeforeExecutingAction)) {
             //not applicable might happen if mutation in previous action led to different page
 
             //TODO possibly add "back" and "refresh" actions, but with a probability
 
             //TODO if page is invalid, should always return with "back"
 
-            if(possibilities.isEmpty()){
+            if (possibilities.isEmpty()) {
                 blocking = true
             } else {
                 //TODO check archive for missing targets when choosing possibilities
                 val chosen = randomness.choose(possibilities)
                 assert(chosen.isDefined())
-                a.copyValueFrom(chosen)
+                wa.copyValueFrom(chosen)
             }
         }
-        assert(blocking || (a.isDefined() && a.isApplicableInGivenPage(pageBeforeExecutingAction)))
+        assert(blocking || (wa.isDefined() && wa.isApplicableInGivenPage(pageBeforeExecutingAction)))
 
-        if(!blocking) {
-            val inputs = a.userInteractions.filter { it.userActionType == UserActionType.FILL_TEXT }
+        if (!blocking) {
+            val inputs = wa.userInteractions.filter { it.userActionType == UserActionType.FILL_TEXT }
             //TODO first fill all inputs
 
-            val interactions = a.userInteractions.filter { it.userActionType != UserActionType.FILL_TEXT }
+            val interactions = wa.userInteractions.filter { it.userActionType != UserActionType.FILL_TEXT }
             interactions.forEach {
 
                 when (it.userActionType) {
@@ -140,13 +159,27 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
                         browserController.clickAndWaitPageLoad(it.cssSelector)
                         //TODO better wait
                     }
+
                     UserActionType.SELECT_SINGLE, UserActionType.SELECT_MULTI -> {
                         //TODO
                         /*
                             not just clicking, but deciding which options to select.
                             this is based on values in the genes
                          */
+                        wa.seeTopGenes().size // size 0 ? No genes in webaction
+
+
+                       // val selectedValues = listOf("")  // select options coming from genes
+
+                        // from webaction, check if it is a single selector or multi,
+                        // then extract the gene, then from the browser controller extract the value
+
+
+                            browserController.selectAndWaitPageLoad(it.cssSelector, selectedValues)
+
+
                     }
+
                     else -> {
                         log.error("Not handled action type ${it.userActionType}")
                     }
@@ -155,22 +188,22 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
         }
 
 
-        val result = WebResult(a.getLocalId(), blocking)
+        val result = WebResult(wa.getLocalId(), blocking)
 
         val start = pageIdentifier.registerShape(HtmlUtils.computeIdentifyingShape(pageBeforeExecutingAction))
         result.setIdentifyingPageIdStart(start)
         result.setUrlPageStart(urlBeforeExecutingAction)
         result.setPossibleActionIds(possibilities.map { it.getIdentifier() })
 
-        if(!blocking) {
+        if (!blocking) {
             //TODO all needed info
             val endPageSource = browserController.getCurrentPageSource()
-            val end   = pageIdentifier.registerShape(HtmlUtils.computeIdentifyingShape(endPageSource))
+            val end = pageIdentifier.registerShape(HtmlUtils.computeIdentifyingShape(endPageSource))
             result.setIdentifyingPageIdEnd(end)
             val endUrl = browserController.getCurrentUrl()
             result.setUrlPageEnd(endUrl)
 
-            if(start != end){
+            if (start != end) { // navigation occurred
                 val valid = checkHtmlGlobalOracle(endPageSource, endUrl, fv)
                 result.setValidHtml(valid)
             }
@@ -180,7 +213,7 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
         return !blocking
     }
 
-    private fun checkHtmlGlobalOracle(html: String, urlOfHtmlPage: String, fv: FitnessValue) : Boolean{
+    private fun checkHtmlGlobalOracle(html: String, urlOfHtmlPage: String, fv: FitnessValue): Boolean {
 
         var issues = false
 
@@ -200,9 +233,9 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
          */
 
         HtmlUtils.getUrlInALinks(html).forEach {
-            try{
+            try {
                 URI(it)
-            } catch (e: URISyntaxException){
+            } catch (e: URISyntaxException) {
                 //FIXME URI should not be used in Java, as implementing deprecated specs
                 webGlobalState.addMalformedUri(it, urlOfHtmlPage)
                 issues = true
@@ -215,26 +248,31 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
             }
 
             //external links should be valid URL
-            val url = try{
+            val url = try {
                 URL(it)
-            } catch (e: MalformedURLException){
+            } catch (e: MalformedURLException) {
                 return@forEach
             }
 
             val external = !url.host.isNullOrBlank()
-            if(external){
-                if(! webGlobalState.hasAlreadySeenExternalLink(url)){
+            if (external) {
+                if (!webGlobalState.hasAlreadySeenExternalLink(url)) {
                     val found = HtmlUtils.checkLink(url)
-                    if(!found){
+                    if (!found) {
                         issues = true
 
-                        val id = idMapper.handleLocalTarget(idMapper.getFaultDescriptiveId(FaultCategory.WEB_BROKEN_LINK,it))
+                        val id = idMapper.handleLocalTarget(
+                            idMapper.getFaultDescriptiveId(
+                                FaultCategory.WEB_BROKEN_LINK,
+                                it
+                            )
+                        )
                         fv.updateTarget(id, 1.0)
                     }
                     webGlobalState.addExternalLink(url, found, urlOfHtmlPage)
-                }  else {
+                } else {
                     webGlobalState.updateExternalLink(url, urlOfHtmlPage)
-                    if(webGlobalState.isBrokenLink(url)){
+                    if (webGlobalState.isBrokenLink(url)) {
                         issues = true
                     }
                 }
@@ -244,8 +282,6 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
         return !issues
     }
 
-
-
     private fun handleResponseTargets(
         fv: FitnessValue,
         actions: List<WebAction>,
@@ -255,11 +291,11 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
 
         fv.updateTarget(idMapper.handleLocalTarget("WEB_HOME_PAGE"), 1.0)
 
-        for(i in actions.indices){
+        for (i in actions.indices) {
             val a = actions[i]
             val r = actionResults[i]
 
-            if(r.stopping){
+            if (r.stopping) {
                 return
             }
 
@@ -268,22 +304,52 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
             fv.updateTarget(pageId, 1.0, i)
 
             //target for transaction S->E
-            val transactionId = idMapper.handleLocalTarget("WEB_TRANSACTION:${r.getIdentifyingPageIdStart()}->${r.getIdentifyingPageIdEnd()}")
+            val transactionId =
+                idMapper.handleLocalTarget("WEB_TRANSACTION:${r.getIdentifyingPageIdStart()}->${r.getIdentifyingPageIdEnd()}")
             fv.updateTarget(transactionId, 1.0, i)
 
             val executedActionId = a.getIdentifier()
             r.getPossibleActionIds().forEach {
                 val actionInPageId = idMapper.handleLocalTarget("WEB_ACTION:${r.getIdentifyingPageIdStart()}@$it")
-                val h = if(it == executedActionId) 1.0 else 0.5
+                val h = if (it == executedActionId) 1.0 else 0.5
                 fv.updateTarget(actionInPageId, h, i)
             }
             Lazy.assert { r.getPossibleActionIds().contains(executedActionId) }
 
 
-
             //TODO possibly check error logs in Chrome Tool
             //TODO targets for HTTP calls through reverse-proxy
         }
 
     }
-}
\ No newline at end of file
+
+    private fun isNotHtmlPage(driver: WebDriver, pageSource: String, pageURL: String): Boolean {
+        return when {
+            //check if it contains html or body tags
+            !pageSource.contains("<html", ignoreCase = true) || !pageSource.contains("<body", ignoreCase = true) -> true
+            //check headers
+            else -> {
+                try {
+                    val url = URL(pageURL)
+                    val connection = url.openConnection() as HttpsURLConnection
+                    connection.requestMethod = "HEAD"
+                    connection.connect()
+                    val contentType = connection.contentType?.lowercase() ?: ""
+                    connection.disconnect()
+
+                    contentType.isNotEmpty() && contentType.startsWith("application/") && !contentType.contains("html") //to be revised
+                } catch (e: Exception) {
+                    false
+                }
+            }
+        }
+    }
+
+}
+/* Common content-type values
+HTML - text/html
+JPEG - image/jpeg
+PNG  - image/png
+PDF  - application/pdf
+JSON - application/json
+* */
\ No newline at end of file
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebPageIdentifier.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebPageIdentifier.kt
index ccf9089642..5131c5e3a5 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebPageIdentifier.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebPageIdentifier.kt
@@ -18,14 +18,15 @@ class WebPageIdentifier {
 
     private var counter = 0
 
-    fun registerShape(shape: String) : String{
+    fun registerShape(html: String) : String{
 
+        val shape = normalizeHtml(html);
         var id = shapeToId[shape]
         if(id != null){
             //already registered
             return id
         }
-
+        // shape is new  -> generate id and update both maps
         id = "P$counter"
         counter++
         shapeToId[shape] = id
@@ -33,4 +34,11 @@ class WebPageIdentifier {
 
         return id
     }
+
+    // normalize html -> remove white spaces and dynamic ids
+    private fun normalizeHtml(html: String): String {
+        return html
+            .replace(Regex("\\s+"), " ") // Collapse whitespace
+            .replace(Regex("id=\"[^\"]+\""), "id=\"*\"") // Remove dynamic IDs
+    }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebSampler.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebSampler.kt
index 27137ac709..47117174a7 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebSampler.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebSampler.kt
@@ -14,6 +14,11 @@ import org.slf4j.LoggerFactory
 import javax.annotation.PostConstruct
 import javax.inject.Inject
 
+//gives a random test case -
+//problem - the actions we are sampling are undefined ->
+//different from rest or graphql where there is a schema that defines all possible cases and interactions
+//in front-end you would have to visit a page to know what u can do there.
+//exploring pages and different inputs
 class WebSampler : EnterpriseSampler<WebIndividual>() {
 
     companion object {
@@ -74,12 +79,13 @@ class WebSampler : EnterpriseSampler<WebIndividual>() {
     }
 
 
+    //Create a random test case
     override fun sampleAtRandom(): WebIndividual {
         val actions = mutableListOf<EnterpriseActionGroup<*>>()
-        val n = randomness.nextInt(1, getMaxTestSizeDuringSampler())
-
+        val n = randomness.nextInt(1, getMaxTestSizeDuringSampler()) // random test length ?
+        //sample n random actions
         (0 until n).forEach {
-            val a = sampleUndefinedAction()
+            val a = sampleUndefinedAction()// when we sample it will be a list of undefined actions
             actions.add(EnterpriseActionGroup(mutableListOf(a), WebAction::class.java))
         }
         val ind =  WebIndividual(SampleType.RANDOM, actions)
diff --git a/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java b/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
index e8c1206980..4ee30dee51 100644
--- a/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
+++ b/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
@@ -16,7 +16,7 @@ public static void initClass() throws Exception {
         SpringTestBase.initClass(new DropDownController());
     }
 
-    @Disabled
+    //@Disabled
     @Test
     public void testRunEM() throws Throwable {
 

From a51849b363514be448035ca14c9b2cafcf628173 Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Wed, 18 Jun 2025 09:57:36 +0200
Subject: [PATCH 07/15] setting up how to access genes

---
 .../core/problem/webfrontend/service/WebFitness.kt       | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
index f5bd2721cd..a21f70b966 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
@@ -160,7 +160,14 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
                         //TODO better wait
                     }
 
-                    UserActionType.SELECT_SINGLE, UserActionType.SELECT_MULTI -> {
+                    UserActionType.SELECT_SINGLE ->{
+                        for(select in wa.singleSelection){
+                            val css = select.key
+                            val index = select.value.value
+                            browserController.selectAndWaitPageLoad(css, TODO)
+                        }
+                    }
+                    UserActionType.SELECT_MULTI -> {
                         //TODO
                         /*
                             not just clicking, but deciding which options to select.

From 63438175e814a60ed6d5767eccaab76e34063c5b Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Mon, 30 Jun 2025 13:42:51 +0200
Subject: [PATCH 08/15] fixing compilation

---
 .../evomaster/test/utils/SeleniumEMUtils.java |  7 +++-
 .../webfrontend/BrowserActionBuilder.kt       | 13 +++++--
 .../core/problem/webfrontend/WebAction.kt     |  9 +++--
 .../webfrontend/service/BrowserController.kt  |  7 ++--
 .../problem/webfrontend/service/WebFitness.kt | 35 +++++++++----------
 5 files changed, 44 insertions(+), 27 deletions(-)

diff --git a/client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java b/client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java
index 1a03442d66..322a997887 100644
--- a/client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java
+++ b/client-java/test-utils-java/src/main/java/org/evomaster/test/utils/SeleniumEMUtils.java
@@ -138,7 +138,12 @@ public static void selectAndWaitPageLoad(WebDriver driver, String cssSelector, S
                     "\nCurrent URL is: " + driver.getCurrentUrl() +
                     "\nCurrent page is: " + driver.getPageSource());
         }
-        element.selectByValue(value);
+        try {
+            element.selectByValue(value);
+        } catch (NoSuchElementException e){
+            element.selectByVisibleText(value);
+        }
+
         try {
             Thread.sleep(50);
         } catch (Exception e) {
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
index 579048a8af..b6904ba450 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
@@ -1,5 +1,6 @@
 package org.evomaster.core.problem.webfrontend
 
+import org.evomaster.core.search.gene.collection.EnumGene
 import org.evomaster.core.search.gene.numeric.IntegerGene
 import org.jsoup.Jsoup
 import org.jsoup.nodes.Document
@@ -51,7 +52,15 @@ object BrowserActionBuilder {
                 }
                 val options = dropdown.options
                     .filter{it.isEnabled}
-                    .map{it.text}
+                    .map{
+                        /*
+                            Look at "value" attribute. unfortunately, it is not mandatory.
+                            in such case, we rather use the visible text.
+                            note: prefer avoiding indices, as they are not reliable, eg, if changes, it would not
+                            break the test, unless out of bounds
+                         */
+                        it.getAttribute("value") ?: it.text
+                    }
                 list.add(WebUserInteraction(jsoup.cssSelector(), type, options))
             }
     }
@@ -99,7 +108,7 @@ object BrowserActionBuilder {
             when(it.userActionType) {
                 UserActionType.CLICK -> WebAction(mutableListOf(it))
                 UserActionType.SELECT_SINGLE -> {
-                    val selection = IntegerGene(it.cssSelector, min=0, max=it.inputs.size)
+                    val selection = EnumGene<String>(it.cssSelector, it.inputs)
                     WebAction(mutableListOf(it), singleSelection = mutableMapOf(it.cssSelector to selection))
                 }
                 //TODO multi
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
index 1840200a04..6c752b7e81 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
@@ -5,6 +5,7 @@ import org.evomaster.core.search.StructuralElement
 import org.evomaster.core.search.gene.BooleanGene
 import org.evomaster.core.search.gene.Gene
 import org.evomaster.core.search.gene.collection.ArrayGene
+import org.evomaster.core.search.gene.collection.EnumGene
 import org.evomaster.core.search.gene.numeric.IntegerGene
 import org.evomaster.core.search.gene.string.StringGene
 import org.jsoup.Jsoup
@@ -22,11 +23,13 @@ class WebAction(
      */
     val textData : MutableMap<String, StringGene> = mutableMapOf(),
     /**
-     * TODO explanation
+     * For a dropdown menu, where only one selection is possible, specify which one to choose.
+     * This is based on the "value" attribute, or the visible text if not available.
      */
-    val singleSelection: MutableMap<String, IntegerGene> = mutableMapOf(),
+    val singleSelection: MutableMap<String, EnumGene<String>> = mutableMapOf(),
     /**
      * TODO explanation
+     * TODO might change ArrayGene<BooleanGene>
      */
     val multiSelection: MutableMap<String, ArrayGene<BooleanGene>> = mutableMapOf(),
 ) : GuiAction(
@@ -84,7 +87,7 @@ class WebAction(
         return WebAction(
             userInteractions.map { it.copy() }.toMutableList(),
             textData.entries.associate { it.key to it.value.copy() as StringGene }.toMutableMap(),
-            singleSelection.entries.associate { it.key to it.value.copy() as IntegerGene }.toMutableMap(),
+            singleSelection.entries.associate { it.key to it.value.copy() as EnumGene<String> }.toMutableMap(),
             multiSelection.entries.associate { it.key to it.value.copy() as ArrayGene<BooleanGene> }.toMutableMap(),
         )
     }
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
index 1ffec3e696..9ced1ba3ce 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserController.kt
@@ -88,11 +88,12 @@ class BrowserController {
         SeleniumEMUtils.clickAndWaitPageLoad(driver, cssSelector)
     }
 
-    //fun selectAndWaitPageLoad(cssSelector: String, values: List<String>){
+    //
     fun selectAndWaitPageLoad(cssSelector: String, values: List<String>){
         //TODO
-        if(values.size == 1) // if single select
-            SeleniumEMUtils.selectAndWaitPageLoad(driver,cssSelector,values[0]);
+        if(values.size == 1) { // if single select
+            SeleniumEMUtils.selectAndWaitPageLoad(driver, cssSelector, values[0])
+        }
         //TODO for multi
     }
 
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
index dd294b5231..dfc3a409f2 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
@@ -162,28 +162,27 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
                     UserActionType.SELECT_SINGLE ->{
                         for(select in wa.singleSelection){
                             val css = select.key
-                            val index = select.value.value
-                            browserController.selectAndWaitPageLoad(css, TODO)
+                            val valueAttributeOrText = select.value.getValueAsRawString()
+                            browserController.selectAndWaitPageLoad(css, listOf(valueAttributeOrText))
                         }
                     }
                     UserActionType.SELECT_MULTI -> {
                         //TODO
-                        /*
-                            not just clicking, but deciding which options to select.
-                            this is based on values in the genes
-                         */
-                        wa.seeTopGenes().size // size 0 ? No genes in webaction
-
-
-                       // val selectedValues = listOf("")  // select options coming from genes
-
-                        // from webaction, check if it is a single selector or multi,
-                        // then extract the gene, then from the browser controller extract the value
-
-
-                            browserController.selectAndWaitPageLoad(it.cssSelector, selectedValues)
-
-
+//                        /*
+//                            not just clicking, but deciding which options to select.
+//                            this is based on values in the genes
+//                         */
+//                        wa.seeTopGenes().size // size 0 ? No genes in webaction
+//
+//
+//                       // val selectedValues = listOf("")  // select options coming from genes
+//
+//                        // from webaction, check if it is a single selector or multi,
+//                        // then extract the gene, then from the browser controller extract the value
+//
+//
+//                            browserController.selectAndWaitPageLoad(it.cssSelector, selectedValues)
+//
                     }
 
                     else -> {

From 894e33397f159cf274ea2c9db507a6e2df8734dc Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Mon, 30 Jun 2025 14:21:40 +0200
Subject: [PATCH 09/15] fixing selection

---
 .../core/output/service/WebTestCaseWriter.kt       |  3 ++-
 .../core/problem/webfrontend/WebAction.kt          | 14 +++++++++++++-
 .../core/problem/webfrontend/service/WebFitness.kt |  1 +
 .../web/dropdownselector/DropDownEMTest.java       |  3 +++
 4 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt b/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
index f832838b4b..5f60f40972 100644
--- a/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
+++ b/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
@@ -78,7 +78,8 @@ class WebTestCaseWriter : TestCaseWriter() {
                     lines.append(getCommentOnPage("on page", r.getUrlPageStart()!!, r.getUrlPageEnd(), r.getValidHtml()))
                 }
                 UserActionType.SELECT_SINGLE-> {
-                    lines.addStatement("selectAndWaitPageLoad($driver, \"${it.cssSelector}\")")
+                    val selectedValue = a.singleSelection[it.cssSelector]?.getValueAsRawString() // TODO what if missing?
+                    lines.addStatement("selectAndWaitPageLoad($driver, \"${it.cssSelector}\", \"$selectedValue\")")
                     lines.append(getCommentOnPage("on page", r.getUrlPageStart()!!, r.getUrlPageEnd(), r.getValidHtml()))
                 }
                 //TODO all other cases
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
index 6c752b7e81..1601284869 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
@@ -92,12 +92,24 @@ class WebAction(
         )
     }
 
+    /**
+     * Given another WebAction, copy its entire genotype into this.
+     */
     fun copyValueFrom(other: WebAction){
+
+        killAllChildren()
+
         userInteractions.clear()
         userInteractions.addAll(other.userInteractions) //immutable elements
         textData.clear()
         textData.putAll(other.textData.entries.associate { it.key to it.value.copy() as StringGene })
-        //TODO singleSelection multiSelection
+        singleSelection.clear()
+        singleSelection.putAll(other.singleSelection.entries.associate { it.key to it.value.copy() as EnumGene<String> })
+        //TODO  multiSelection
+
+        addChildren(textData.values.toList())
+        addChildren(singleSelection.values.toList())
+        addChildren(multiSelection.values.toList())
     }
 
     fun getIdentifier() : String {
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
index dfc3a409f2..72e24036c7 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
@@ -140,6 +140,7 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
                 //TODO check archive for missing targets when choosing possibilities
                 val chosen = randomness.choose(possibilities)
                 assert(chosen.isDefined())
+                chosen.doInitialize(randomness)
                 wa.copyValueFrom(chosen)
             }
         }
diff --git a/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java b/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
index 4ee30dee51..718fd02601 100644
--- a/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
+++ b/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
@@ -26,6 +26,9 @@ public void testRunEM() throws Throwable {
                 50,
                 (args) -> {
 
+                    //TODO need to ask Man
+                    setOption(args, "adaptiveGeneSelectionMethod", "NONE");
+
                     Solution<WebIndividual> solution = initAndRun(args);
 
                     assertTrue(solution.getIndividuals().size() > 0);

From 06982d2cc4cbdad68cf62132fa1792e6b4f448ce Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Mon, 30 Jun 2025 15:06:06 +0200
Subject: [PATCH 10/15] removed unecessary changes

---
 .../core/problem/webfrontend/service/WebPageIdentifier.kt      | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebPageIdentifier.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebPageIdentifier.kt
index 5131c5e3a5..b650073ef3 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebPageIdentifier.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebPageIdentifier.kt
@@ -20,7 +20,8 @@ class WebPageIdentifier {
 
     fun registerShape(html: String) : String{
 
-        val shape = normalizeHtml(html);
+        val shape = html
+        //normalizeHtml(html); -> if needed, should go to HtmlUtils.computeIdentifyingShape
         var id = shapeToId[shape]
         if(id != null){
             //already registered

From d001f2125bf06eba342c2b26030bba9eb27b1826 Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Mon, 30 Jun 2025 15:32:03 +0200
Subject: [PATCH 11/15] adding explicit target for selected values

---
 .../core/problem/webfrontend/service/WebFitness.kt | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
index 72e24036c7..e58b9e9dec 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/service/WebFitness.kt
@@ -312,7 +312,19 @@ class WebFitness : EnterpriseFitness<WebIndividual>() {
 
             val executedActionId = a.getIdentifier()
             r.getPossibleActionIds().forEach {
-                val actionInPageId = idMapper.handleLocalTarget("WEB_ACTION:${r.getIdentifyingPageIdStart()}@$it")
+                val prefix = "WEB_ACTION:${r.getIdentifyingPageIdStart()}@$it"
+                val actionInPageId = idMapper.handleLocalTarget(
+                    if(a.singleSelection.isEmpty()){
+                        prefix
+                    } else {
+                        prefix + a.singleSelection.values.joinToString(",") { g -> g.getValueAsRawString() }
+                    }
+                )
+                /*
+                    on a page, there could be several interesting actions to do... we don't want to lose info on them.
+                    we give as such a non-zero score.
+                    of course, for action we actually made, it is covered (ie score 1)
+                 */
                 val h = if(it == executedActionId) 1.0 else 0.5
                 fv.updateTarget(actionInPageId, h, i)
             }

From f535b563d07def5476c74639cc3a5ef42ecc5685 Mon Sep 17 00:00:00 2001
From: arcuri82 <arcuri82@gmail.com>
Date: Tue, 1 Jul 2025 13:46:43 +0200
Subject: [PATCH 12/15] getting single selection to work

---
 .../core/output/service/WebTestCaseWriter.kt        | 13 ++++++++++---
 .../spring/web/dropdownselector/DropDownEMTest.java |  3 ++-
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt b/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
index 5f60f40972..6ba5079497 100644
--- a/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
+++ b/core/src/main/kotlin/org/evomaster/core/output/service/WebTestCaseWriter.kt
@@ -34,7 +34,12 @@ class WebTestCaseWriter : TestCaseWriter() {
         lines.addStatement("goToPage($driver, $baseUrlOfSut, 5)")
 
         if(ind.individual is WebIndividual){
-            ind.evaluatedMainActions().forEachIndexed { index,  a ->
+            val all = ind.evaluatedMainActions()
+            for(index in all.indices) {
+                val a = all[index]
+                if(a.result.stopping){
+                    break
+                }
                 addActionLines(a.action, index, testCaseName, lines, a.result, testSuitePath, baseUrlOfSut)
             }
             val lastEvaluated = ind.evaluatedMainActions().last()
@@ -44,8 +49,10 @@ class WebTestCaseWriter : TestCaseWriter() {
                  lastResult.getUrlPageEnd()!!
             } else {
                 //if stopping, it means nothing could be done, and no info on where it went.
-                //it also implies that such entry itself was printed out in the test
-                assert(lastAction.userInteractions.isEmpty())
+                //it also implies that such entry itself was printed out in the test.
+                //however, it might be that a mutated test ends up on a page in which action is not applicable
+                //TODO should check lastAction.isApplicableInGivenPage(pageBeforeExecutingAction)
+                //assert(lastAction.userInteractions.isEmpty())
                 lastResult.getUrlPageStart()!!
             }
             lines.add(getCommentOnPage("ended on page", url,null,lastResult.getValidHtml()))
diff --git a/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java b/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
index 718fd02601..84ad430df8 100644
--- a/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
+++ b/e2e-tests/spring-web/src/test/java/org/evomaster/e2etests/spring/web/dropdownselector/DropDownEMTest.java
@@ -33,7 +33,8 @@ public void testRunEM() throws Throwable {
 
                     assertTrue(solution.getIndividuals().size() > 0);
 
-                    assertHasVisitedUrlPath(solution, "/dropdown/index.html", "/dropdown/page1.html", "/dropdown/page2.html", "/dropdown/page3.html");
+//                    assertHasVisitedUrlPath(solution, "/dropdown/index.html", "/dropdown/page1.html", "/dropdown/page2.html", "/dropdown/page3.html");
+                    assertHasVisitedUrlPath(solution, "/dropdown/index.html", "/navigate/1", "/navigate/2", "/navigate/3");
                     assertNoHtmlErrors(solution); // statement ok - gives no errors
                 }
         );

From 3f1a87f07d065f0a30536bff5aae55fbcf0c5cf7 Mon Sep 17 00:00:00 2001
From: ivakertusha <iva.kertusha@gmail.com>
Date: Wed, 6 Aug 2025 08:45:29 +0200
Subject: [PATCH 13/15] single selection Constraints

---
 .../core/problem/webfrontend/WebAction.kt     | 59 ++++++++++++++-----
 1 file changed, 45 insertions(+), 14 deletions(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
index 1601284869..e0a167e3e0 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
@@ -21,7 +21,7 @@ class WebAction(
      * Map from cssLocator (coming from [userInteractions]) for text input to StringGene representing its value
      * MutableMap<csslocator, gene>
      */
-    val textData : MutableMap<String, StringGene> = mutableMapOf(),
+    val textData: MutableMap<String, StringGene> = mutableMapOf(),
     /**
      * For a dropdown menu, where only one selection is possible, specify which one to choose.
      * This is based on the "value" attribute, or the visible text if not available.
@@ -40,18 +40,49 @@ class WebAction(
 
     init {
         val nFillText = userInteractions.count { it.userActionType == UserActionType.FILL_TEXT }
-        if(nFillText != textData.size){
+        if (nFillText != textData.size) {
             throw IllegalArgumentException("Mismatch between $nFillText fill text actions and ${textData.size} genes for it")
         }
-        for(key in textData.keys){
-            if(! userInteractions.any { it.cssSelector == key }){
+        for (key in textData.keys) {
+            if (!userInteractions.any { it.cssSelector == key }) {
                 throw IllegalArgumentException("Missing info for input: $key")
             }
         }
         //TODO constraint checks on singleSelection and multiSelection
+
+        for ((key, value) in singleSelection) {
+            val selectedValue = singleSelection.getValue(key).index
+            val allowedValues = singleSelection.getValue(key).values
+
+            val duplicates = allowedValues
+                .groupingBy { it }
+                .eachCount()
+                .filter { it.value > 1 }
+                .keys
+
+
+            //Constraint: Empty option list
+            if (allowedValues.isNullOrEmpty()) {
+                throw IllegalArgumentException("List is Empty")
+            }
+            //Constraint: No duplicate values
+            if (duplicates.isNotEmpty()) {
+                throw IllegalArgumentException("Selection contains duplicate values")
+            }
+
+            // Constraint: Selection must empty?
+            if (selectedValue == 0) {
+                throw IllegalArgumentException("Selection for '$selectedValue' is missing.")
+            }
+
+            // Constraint: Selection must be in the allowed values
+            if (!allowedValues.contains(selectedValue.toString())) {
+                throw IllegalArgumentException("Invalid selection for '$selectedValue': '$selectedValue' is not among allowed values $allowedValues.")
+            }
+        }
     }
 
-    override fun isDefined() : Boolean {
+    override fun isDefined(): Boolean {
         return userInteractions.isNotEmpty()
     }
 
@@ -59,19 +90,19 @@ class WebAction(
         TODO("Not yet implemented")
     }
 
-    fun isApplicableInGivenPage(page: String) : Boolean{
+    fun isApplicableInGivenPage(page: String): Boolean {
 
-        val document = try{
+        val document = try {
             Jsoup.parse(page)
-        }catch (e: Exception){
+        } catch (e: Exception) {
             return false
         }
 
-        return userInteractions.all { document.select(it.cssSelector).size > 0   }
+        return userInteractions.all { document.select(it.cssSelector).size > 0 }
     }
 
     override fun getName(): String {
-        if(userInteractions.isEmpty()){
+        if (userInteractions.isEmpty()) {
             return "Undefined"
         }
         val x = userInteractions.last()
@@ -79,7 +110,7 @@ class WebAction(
     }
 
     override fun seeTopGenes(): List<out Gene> {
-        return  children as List<out Gene>
+        return children as List<out Gene>
     }
 
 
@@ -95,7 +126,7 @@ class WebAction(
     /**
      * Given another WebAction, copy its entire genotype into this.
      */
-    fun copyValueFrom(other: WebAction){
+    fun copyValueFrom(other: WebAction) {
 
         killAllChildren()
 
@@ -112,7 +143,7 @@ class WebAction(
         addChildren(multiSelection.values.toList())
     }
 
-    fun getIdentifier() : String {
-        return "A:" + userInteractions.joinToString(","){"${it.userActionType}:${it.cssSelector}"}
+    fun getIdentifier(): String {
+        return "A:" + userInteractions.joinToString(",") { "${it.userActionType}:${it.cssSelector}" }
     }
 }
\ No newline at end of file

From 518a9415b850b7bf562f83acb96ec296bb25effc Mon Sep 17 00:00:00 2001
From: ivakertusha <iva.kertusha@gmail.com>
Date: Wed, 6 Aug 2025 08:48:33 +0200
Subject: [PATCH 14/15] single selection Constraints

---
 .../org/evomaster/core/problem/webfrontend/WebAction.kt     | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
index e0a167e3e0..4e8572a935 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
@@ -71,9 +71,9 @@ class WebAction(
             }
 
             // Constraint: Selection must empty?
-            if (selectedValue == 0) {
-                throw IllegalArgumentException("Selection for '$selectedValue' is missing.")
-            }
+//            if (selectedValue == 0) {
+//                throw IllegalArgumentException("Selection for '$selectedValue' is missing.")
+//            }
 
             // Constraint: Selection must be in the allowed values
             if (!allowedValues.contains(selectedValue.toString())) {

From 66ce50b4aafcba03b0c1f4e58eeb9ddfcbb266dd Mon Sep 17 00:00:00 2001
From: ivakertusha <iva.kertusha@gmail.com>
Date: Mon, 11 Aug 2025 11:09:23 +0200
Subject: [PATCH 15/15] browsercontrollerdockertest for single selection. Check
 single selection constraints. updated pom for servlet 4.0 ( originally 3.1)
 as it was incompatible with Tomcat (version 9)

---
 .../service/BrowserControllerDockerTest.kt    | 42 +++++++++++++
 .../webfrontend/BrowserActionBuilder.kt       |  1 +
 .../core/problem/webfrontend/WebAction.kt     | 61 ++++++++++---------
 e2e-tests/spring-web/pom.xml                  |  7 +++
 .../spring/dropdown/DropDownController.java   |  2 +
 5 files changed, 84 insertions(+), 29 deletions(-)

diff --git a/core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt b/core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt
index 5f705a0ffa..ee67708e19 100644
--- a/core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt
+++ b/core-it/src/test/kotlin/org/evomaster/core/problem/webfrontend/service/BrowserControllerDockerTest.kt
@@ -85,5 +85,47 @@ internal class BrowserControllerDockerTest{
     }
 
     //TODO @IVa add test for Select
+    @Test
+    fun testSingleSelect(){
+        browser.initUrlOfStartingPage("http://localhost:8080/",true)
+        //browser.initUrlOfStartingPage("http://localhost:${getPort()}",true)// to double check
+        browser.goToStartingPage()
+
+        var actions = browser.computePossibleUserInteractions()
+        assertEquals(1, actions.size)
+        val homePage = browser.getCurrentUrl()
+        assertTrue(homePage.endsWith("/"), homePage)
+        val a = actions[0] // first action is the dropdown list
+        assertEquals(UserActionType.SELECT_SINGLE, a.userActionType)
+
+        browser.selectAndWaitPageLoad(a.cssSelector, listOf(a.inputs[1].toString()))
+        val page1 = browser.getCurrentUrl()
+        assertTrue(page1.endsWith("1?"), page1)// ? to be fixed
+
+        actions = browser.computePossibleUserInteractions()
+        assertEquals(1, actions.size)
+        var backHome = actions.first { it.cssSelector.contains("a") }
+        browser.clickAndWaitPageLoad(backHome.cssSelector)
+        assertEquals(homePage, browser.getCurrentUrl())
+
+        browser.selectAndWaitPageLoad(a.cssSelector, listOf(a.inputs[2].toString()))
+        val page2 = browser.getCurrentUrl()
+        assertTrue(page2.endsWith("2?"), page2)
+        actions = browser.computePossibleUserInteractions()
+        assertEquals(1, actions.size)
+        backHome = actions.first { it.cssSelector.contains("a") }
+        browser.clickAndWaitPageLoad(backHome.cssSelector)
+        assertEquals(homePage, browser.getCurrentUrl())
+
+        browser.selectAndWaitPageLoad(a.cssSelector, listOf(a.inputs[3].toString()))
+        val page3 = browser.getCurrentUrl()
+        assertTrue(page3.endsWith("3?"), page3)
+        actions = browser.computePossibleUserInteractions()
+        assertEquals(1, actions.size)
+        backHome = actions.first { it.cssSelector.contains("a") }
+        browser.clickAndWaitPageLoad(backHome.cssSelector)
+        assertEquals(homePage, browser.getCurrentUrl())
+
+    }
 
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
index b6904ba450..f5643612c9 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/BrowserActionBuilder.kt
@@ -15,6 +15,7 @@ object BrowserActionBuilder {
 
 
     /**
+     * Given the current page we need to see what can we do in the page, what kind of interactions we can have.
      */
     fun computePossibleUserInteractions(driver: RemoteWebDriver) : List<WebUserInteraction>{
 
diff --git a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
index 4e8572a935..0c59b9e541 100644
--- a/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
+++ b/core/src/main/kotlin/org/evomaster/core/problem/webfrontend/WebAction.kt
@@ -48,36 +48,39 @@ class WebAction(
                 throw IllegalArgumentException("Missing info for input: $key")
             }
         }
-        //TODO constraint checks on singleSelection and multiSelection
-
-        for ((key, value) in singleSelection) {
-            val selectedValue = singleSelection.getValue(key).index
-            val allowedValues = singleSelection.getValue(key).values
-
-            val duplicates = allowedValues
-                .groupingBy { it }
-                .eachCount()
-                .filter { it.value > 1 }
-                .keys
 
-
-            //Constraint: Empty option list
-            if (allowedValues.isNullOrEmpty()) {
-                throw IllegalArgumentException("List is Empty")
-            }
-            //Constraint: No duplicate values
-            if (duplicates.isNotEmpty()) {
-                throw IllegalArgumentException("Selection contains duplicate values")
-            }
-
-            // Constraint: Selection must empty?
-//            if (selectedValue == 0) {
-//                throw IllegalArgumentException("Selection for '$selectedValue' is missing.")
-//            }
-
-            // Constraint: Selection must be in the allowed values
-            if (!allowedValues.contains(selectedValue.toString())) {
-                throw IllegalArgumentException("Invalid selection for '$selectedValue': '$selectedValue' is not among allowed values $allowedValues.")
+        //TODO constraint checks on singleSelection and multiSelection
+        //SingleSelection
+        if (singleSelection.isNotEmpty()) {
+            for ((key, value) in singleSelection) {
+                val selectedValue = value.getValueAsRawString()
+                val allowedValues = value.values
+
+                //check for duplicated option values?
+                val duplicates = allowedValues
+                    .groupingBy { it }
+                    .eachCount()
+                    .filter { it.value > 1 }
+                    .keys
+
+                //Constraint: Empty option list
+                if (allowedValues.isNullOrEmpty()) {
+                    throw Exception("List is Empty")
+                }
+                //Constraint: duplicated values
+                if (duplicates.isNotEmpty()) {
+                    throw Exception("Selection contains duplicate values")
+                }
+
+                // Constraint: Selection Shouldnt be empty?  the first option can be- to be removed
+                /*if (selectedValue.isNullOrEmpty()) {
+                    throw Exception("Selection for '$selectedValue' is missing.")
+                }*/
+
+                // Constraint: Selection must be in the allowed values -> for autocomplete cases when the user can type the option
+                if (!allowedValues.contains(selectedValue.toString())) {
+                    throw Exception("Invalid selection for '$selectedValue': '$selectedValue' is not among allowed values $allowedValues.")
+                }
             }
         }
     }
diff --git a/e2e-tests/spring-web/pom.xml b/e2e-tests/spring-web/pom.xml
index 37f15e5561..ee562d7a87 100644
--- a/e2e-tests/spring-web/pom.xml
+++ b/e2e-tests/spring-web/pom.xml
@@ -24,6 +24,13 @@
         </dependency>
 
 
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+            <version>4.0.1</version>
+            <scope>provided</scope> <!-- Tomcat provides this at runtime -->
+        </dependency>
+
         <dependency>
             <groupId>org.evomaster</groupId>
             <artifactId>evomaster-e2e-tests-utils</artifactId>
diff --git a/e2e-tests/spring-web/src/main/java/com/foo/web/examples/spring/dropdown/DropDownController.java b/e2e-tests/spring-web/src/main/java/com/foo/web/examples/spring/dropdown/DropDownController.java
index 6c3090f46a..3d748a2f70 100644
--- a/e2e-tests/spring-web/src/main/java/com/foo/web/examples/spring/dropdown/DropDownController.java
+++ b/e2e-tests/spring-web/src/main/java/com/foo/web/examples/spring/dropdown/DropDownController.java
@@ -11,6 +11,8 @@ public class DropDownController {
 
     @GetMapping("/")
     public String index0() {
+        System.out.println("Servlet API Version: " +
+                javax.servlet.ServletRequest.class.getPackage().getSpecificationVersion());
         return "/dropdown/index.html";
     }