From 7bda9957ff1325eec6f98e8021255a54ccd36ecb Mon Sep 17 00:00:00 2001
From: Nate Brunette <n@tebru.net>
Date: Tue, 8 Jul 2025 18:30:53 -0500
Subject: [PATCH 1/8] Adding support for running tests on a single file or
 directory

---
 .../Run IDE for UI Tests.run.xml              |  7 +-
 src/main/kotlin/org/elm/ide/icons/ElmIcons.kt |  4 +
 .../ide/lineMarkers/ElmLineMarkerProvider.kt  |  3 +-
 .../org/elm/ide/lineMarkers/ElmRunActions.kt  | 38 ++++++++
 .../lineMarkers/ElmTestLineMarkerProvider.kt  | 70 +++++++++++++++
 .../ElmTestModuleLineMarkerProvider.kt        | 32 +++++++
 .../ide/test/run/ElmTestRunConfiguration.kt   | 90 +++++++++++++++++--
 .../run/ElmTestRunConfigurationProducer.kt    | 14 ++-
 .../ElmTestRunConfigurationSettingsBuilder.kt | 31 +++++++
 .../test/run/ElmTestRunConfigurationType.kt   |  5 ++
 .../ide/test/run/ElmTestRunProfileState.kt    |  4 +-
 .../ide/test/run/ElmTestSettingsEditor.form   | 20 ++++-
 .../elm/ide/test/run/ElmTestSettingsEditor.kt | 12 ++-
 .../workspace/commandLineTools/ElmTestCLI.kt  |  7 +-
 src/main/resources/icons/runAll.svg           |  6 ++
 src/main/resources/icons/runAll_dark.svg      |  6 ++
 .../ElmTestModuleLineMarkerProviderTest.kt    | 25 ++++++
 .../test/run/ElmTestRunConfigurationTest.kt   | 35 ++++++++
 18 files changed, 387 insertions(+), 22 deletions(-)
 create mode 100644 src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
 create mode 100644 src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
 create mode 100644 src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
 create mode 100644 src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
 create mode 100644 src/main/resources/icons/runAll.svg
 create mode 100644 src/main/resources/icons/runAll_dark.svg
 create mode 100644 src/test/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProviderTest.kt

diff --git a/.idea/runConfigurations/Run IDE for UI Tests.run.xml b/.idea/runConfigurations/Run IDE for UI Tests.run.xml
index 9b028c30..ee99b7ed 100644
--- a/.idea/runConfigurations/Run IDE for UI Tests.run.xml	
+++ b/.idea/runConfigurations/Run IDE for UI Tests.run.xml	
@@ -5,18 +5,21 @@
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
       <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="runIdeForUiTests" />
+      <option name="scriptParameters" value="" />
       <option name="taskDescriptions">
         <list />
       </option>
       <option name="taskNames">
-        <list />
+        <list>
+          <option value="runIdeForUiTests" />
+        </list>
       </option>
       <option name="vmOptions" />
     </ExternalSystemSettings>
     <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
     <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
     <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
     <method v="2" />
   </configuration>
 </component>
\ No newline at end of file
diff --git a/src/main/kotlin/org/elm/ide/icons/ElmIcons.kt b/src/main/kotlin/org/elm/ide/icons/ElmIcons.kt
index f37cc4ee..3e799775 100644
--- a/src/main/kotlin/org/elm/ide/icons/ElmIcons.kt
+++ b/src/main/kotlin/org/elm/ide/icons/ElmIcons.kt
@@ -27,6 +27,10 @@ object ElmIcons {
     val UNION_TYPE = getIcon("type.png")
     val TYPE_ALIAS = getIcon("type.png")
 
+    // TEST ICONS
+
+    val RUN_ALL = getIcon("runAll.svg")
+
     private fun getIcon(path: String): Icon {
         return IconLoader.getIcon("/icons/$path", ElmIcons::class.java)
     }
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmLineMarkerProvider.kt
index c3a6ff81..17b46c52 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmLineMarkerProvider.kt
@@ -42,7 +42,8 @@ class ElmLineMarkerProvider : LineMarkerProviderDescriptor() {
 
 private val optionProviders = mapOf(
     ElmExposureLineMarkerProvider.OPTION to { ElmExposureLineMarkerProvider() },
-    ElmRecursiveCallLineMarkerProvider.OPTION to { ElmRecursiveCallLineMarkerProvider() }
+    ElmRecursiveCallLineMarkerProvider.OPTION to { ElmRecursiveCallLineMarkerProvider() },
+    ElmTestModuleLineMarkerProvider.OPTION to { ElmTestModuleLineMarkerProvider() }
 )
 
 private val OPTIONS = optionProviders.keys.toTypedArray()
\ No newline at end of file
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
new file mode 100644
index 00000000..97e2eb0f
--- /dev/null
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
@@ -0,0 +1,38 @@
+package org.elm.ide.lineMarkers
+
+import com.intellij.execution.ProgramRunnerUtil
+import com.intellij.execution.executors.DefaultRunExecutor
+import com.intellij.execution.impl.SingleConfigurationConfigurable
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.options.ShowSettingsUtil
+import com.intellij.psi.PsiElement
+import org.elm.ide.test.run.ElmTestRunConfiguration
+import org.elm.ide.test.run.ElmTestRunConfigurationSettingsBuilder
+
+/**
+ * Action to run all tests for a given file or directory
+ */
+class RunAllTestsAction(private val element: PsiElement) : AnAction("Run All Tests") {
+    override fun actionPerformed(event: AnActionEvent) {
+        ProgramRunnerUtil.executeConfiguration(
+            ElmTestRunConfigurationSettingsBuilder.createAndRegisterFromElement(element),
+            DefaultRunExecutor.getRunExecutorInstance()
+        )
+    }
+}
+
+/**
+ * Creates a run configuration and opens editor
+ */
+class ModifyRunConfiguration(private val element: PsiElement) : AnAction("Modify Run Configuration") {
+    override fun actionPerformed(event: AnActionEvent) {
+        ShowSettingsUtil.getInstance().editConfigurable(
+            element.project,
+            SingleConfigurationConfigurable.editSettings<ElmTestRunConfiguration>(
+                ElmTestRunConfigurationSettingsBuilder.createAndRegisterFromElement(element),
+                null
+            )
+        )
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
new file mode 100644
index 00000000..937dbc58
--- /dev/null
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
@@ -0,0 +1,70 @@
+package org.elm.ide.lineMarkers
+
+import com.intellij.codeInsight.daemon.GutterIconNavigationHandler
+import com.intellij.codeInsight.daemon.LineMarkerInfo
+import com.intellij.codeInsight.daemon.LineMarkerProvider
+import com.intellij.ide.DataManager
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.DefaultActionGroup
+import com.intellij.openapi.editor.markup.GutterIconRenderer
+import com.intellij.openapi.ui.popup.JBPopupFactory
+import com.intellij.psi.PsiElement
+import com.intellij.ui.awt.RelativePoint
+import com.intellij.util.FunctionUtil
+import java.awt.event.MouseEvent
+import javax.swing.Icon
+
+/**
+ * Abstract class to handle common operations for all test marker classes
+ */
+abstract class ElmTestLineMarkerProvider : LineMarkerProvider {
+    /**
+     * Create a popup with a list of given actions
+     */
+    private class PopupHandler(val actions: List<AnAction>) : GutterIconNavigationHandler<PsiElement> {
+        override fun navigate(e: MouseEvent, elt: PsiElement) {
+            val group = DefaultActionGroup().apply {
+                addAll(actions)
+            }
+
+            val popup = JBPopupFactory.getInstance()
+                .createActionGroupPopup(
+                    null,
+                    group,
+                    DataManager.getInstance().getDataContext(e.component),
+                    JBPopupFactory.ActionSelectionAid.MNEMONICS,
+                    true
+                )
+
+            popup.show(RelativePoint(e))
+        }
+    }
+
+    /**
+     * Returns true if the line should contain a gutter icon for the type of marker
+     */
+    abstract fun shouldAddGutterIcon(element: PsiElement): Boolean
+
+    /**
+     * Returns true if the file contains tests
+     */
+    protected fun isTestFile(element: PsiElement): Boolean {
+        return element.containingFile.text.contains("import Test exposing")
+    }
+
+    /**
+     * Create a gutter icon on a given line with an icon, tooltip, and list of popup actions
+     */
+    protected fun createLineMarkerInfo(element: PsiElement, icon: Icon, tooltip: String, actions: List<AnAction>, ): LineMarkerInfo<*>? {
+        if (!isTestFile(element) || !shouldAddGutterIcon(element)) return null
+
+        return LineMarkerInfo(
+            element,
+            element.textRange,
+            icon,
+            FunctionUtil.constant(tooltip),
+            PopupHandler(actions),
+            GutterIconRenderer.Alignment.LEFT
+        ) { tooltip }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
new file mode 100644
index 00000000..b08a3d24
--- /dev/null
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
@@ -0,0 +1,32 @@
+package org.elm.ide.lineMarkers
+
+import com.intellij.codeInsight.daemon.GutterIconDescriptor
+import com.intellij.codeInsight.daemon.LineMarkerInfo
+import com.intellij.psi.PsiElement
+import org.elm.ide.icons.ElmIcons
+import org.elm.lang.core.psi.ElmTypes
+
+/**
+ * Handles adding a gutter icon for running all tests in a module
+ */
+class ElmTestModuleLineMarkerProvider : ElmTestLineMarkerProvider() {
+    companion object {
+        val OPTION = GutterIconDescriptor.Option("elm.test", "Test module", ElmIcons.RUN_ALL)
+    }
+
+    /**
+     * Add gutter icons for the module line
+     */
+    override fun shouldAddGutterIcon(element: PsiElement): Boolean {
+        return element.node.elementType == ElmTypes.MODULE
+    }
+
+    override fun getLineMarkerInfo(element: PsiElement): LineMarkerInfo<*>? {
+        return createLineMarkerInfo(
+            element,
+            ElmIcons.RUN_ALL,
+            "Run all tests in this module",
+            listOf(RunAllTestsAction(element), ModifyRunConfiguration(element))
+        )
+    }
+}
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
index e68e3157..fbfd6f72 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
@@ -9,7 +9,14 @@ import com.intellij.openapi.options.SettingsEditor
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.InvalidDataException
 import com.intellij.openapi.util.WriteExternalException
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileManager
+import com.intellij.psi.PsiDirectory
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiManager
 import org.elm.ide.test.run.ElmTestConfigurationFactory.Companion.RUN_ICON
+import org.elm.lang.core.psi.ElmFile
 import org.jdom.Element
 import java.nio.file.Paths
 
@@ -18,6 +25,12 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
 
     var options = Options()
 
+    override fun clone(): RunConfiguration {
+        val copy = super.clone() as ElmTestRunConfiguration
+        copy.options = options.copy()
+        return copy
+    }
+
     override fun getConfigurationEditor(): SettingsEditor<out RunConfiguration> =
             ElmTestSettingsEditor(project)
 
@@ -26,8 +39,49 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
     override fun getState(executor: Executor, executionEnvironment: ExecutionEnvironment) =
             ElmTestRunProfileState(executionEnvironment, this)
 
-    class Options {
-        var elmFolder: String? = null
+    data class Options(var elmFolder: String? = null, var testFile: FilteredTest? = null)
+
+    data class FilteredTest(val filePath: String, val label: String) {
+        companion object {
+            fun from(path: String?, project: Project): FilteredTest? {
+                if (path == null || path.isEmpty())  return null
+
+                val virtualFile = VirtualFileManager.getInstance().findFileByUrl("file://$path") ?: return null
+
+                return from(virtualFile, project)
+            }
+
+            fun from(path: String?, label: String?): FilteredTest? {
+                if (path.isNullOrBlank() || label.isNullOrBlank()) return null
+
+                return FilteredTest(path, label)
+            }
+
+            fun from(virtualFile: VirtualFile, project: Project): FilteredTest? {
+                val psiManager = PsiManager.getInstance(project)
+                val psiFile = psiManager.findFile(virtualFile) ?: return null
+
+                return from(psiFile)
+            }
+
+            fun from(element: PsiElement): FilteredTest? {
+                return when (element) {
+                    is PsiDirectory -> from(element)
+                    else -> element.containingFile?.let { from(it) }
+                }
+            }
+
+            fun from(psiFile: PsiFile): FilteredTest? {
+                val elmFile = psiFile as? ElmFile ?: return null
+                val moduleName = elmFile.getModuleDecl()?.name ?: return null
+
+                return FilteredTest(psiFile.virtualFile.path, moduleName)
+            }
+
+            fun from(psiDirectory: PsiDirectory): FilteredTest? {
+                return FilteredTest(psiDirectory.virtualFile.path, psiDirectory.name)
+            }
+        }
     }
 
     override fun getIcon() = RUN_ICON
@@ -43,8 +97,17 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
     }
 
     override fun suggestedName(): String? {
-        val elmFolder = options.elmFolder ?: return null
-        return "Tests in ${Paths.get(elmFolder).fileName}"
+        val elmFolder = options.elmFolder
+
+        if (!options.testFile?.label.isNullOrBlank()) {
+            return "Tests in ${options.testFile?.label}"
+        }
+
+        if (elmFolder != null) {
+            return "Tests in ${Paths.get(elmFolder).fileName}"
+        }
+
+        return null
     }
 
     companion object {
@@ -52,17 +115,26 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
         // <ElmTestRunConfiguration elm-folder="" />
 
         fun writeOptions(options: Options, element: Element) {
-            val e = Element(ElmTestRunConfiguration::class.java.simpleName)
-            if (options.elmFolder != null) {
-                e.setAttribute("elm-folder", options.elmFolder)
+            val name = ElmTestRunConfiguration::class.java.simpleName
+            val e = element.getChild(name) ?: Element(name).also { element.addContent(it) }
+
+            e.setAttribute("elm-folder", options.elmFolder ?: "")
+            if (options.testFile != null) {
+                e.setAttribute("test-file-path", options.testFile?.filePath)
+                e.setAttribute("test-file-module", options.testFile?.label)
             }
-            element.addContent(e)
         }
 
         fun readOptions(element: Element): Options {
             return Options().apply {
                 val name = ElmTestRunConfiguration::class.java.simpleName
-                elmFolder = element.getChild(name)?.getAttribute("elm-folder")?.value
+                val child = element.getChild(name)
+                elmFolder = child?.getAttribute("elm-folder")?.value
+                testFile = FilteredTest.from(
+                    child?.getAttribute("test-file-path")?.value,
+                    child?.getAttribute("test-file-module")?.value
+                )
+
             }
         }
     }
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
index 41092073..718f639a 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
@@ -9,18 +9,28 @@ import org.elm.workspace.elmWorkspace
 class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunConfiguration>() {
 
     override fun getConfigurationFactory() =
-            ElmTestConfigurationFactory(ElmTestRunConfigurationType())
+        ElmTestRunConfigurationType.instance.configurationFactories.single()
 
     override fun setupConfigurationFromContext(configuration: ElmTestRunConfiguration, context: ConfigurationContext, sourceElement: Ref<PsiElement>): Boolean {
         val elmFolder = getCandidateElmFolder(context) ?: return false
+        val vfile = context.location?.virtualFile
+
         configuration.options.elmFolder = elmFolder
+        if (vfile != null) {
+            configuration.options.testFile = ElmTestRunConfiguration.FilteredTest.from(sourceElement.get())
+        }
+
         configuration.setGeneratedName()
+
         return true
     }
 
     override fun isConfigurationFromContext(configuration: ElmTestRunConfiguration, context: ConfigurationContext): Boolean {
         val elmFolder = getCandidateElmFolder(context) ?: return false
-        return elmFolder == configuration.options.elmFolder
+        val vfile = context.location?.virtualFile
+
+        return configuration.options.elmFolder == elmFolder &&
+            configuration.options.testFile?.filePath == vfile?.path
     }
 
     private fun getCandidateElmFolder(context: ConfigurationContext): String? {
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
new file mode 100644
index 00000000..1ae455bf
--- /dev/null
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
@@ -0,0 +1,31 @@
+package org.elm.ide.test.run
+
+import com.intellij.execution.RunManager
+import com.intellij.execution.RunnerAndConfigurationSettings
+import com.intellij.psi.PsiElement
+import org.elm.workspace.elmWorkspace
+import kotlin.io.path.pathString
+
+/**
+ * Helper object to create a run configuration and add it to the run manager. Returns the config settings.
+ */
+object ElmTestRunConfigurationSettingsBuilder {
+    fun createAndRegisterFromElement(element: PsiElement): RunnerAndConfigurationSettings {
+        val project = element.project
+        val runManager = RunManager.getInstance(project)
+        val configurationFactory = ElmTestRunConfigurationType.instance.configurationFactories.single()
+
+        val configuration = configurationFactory.createTemplateConfiguration(project)
+        configuration.options.elmFolder =
+            project.elmWorkspace.findProjectForFile(element.containingFile.virtualFile)?.projectDirPath?.pathString
+        configuration.options.testFile = ElmTestRunConfiguration.FilteredTest.from(element)
+        configuration.setGeneratedName()
+
+        val configSettings = runManager.createConfiguration(configuration, configurationFactory)
+        configSettings.isTemporary = false
+        runManager.addConfiguration(configSettings)
+        runManager.selectedConfiguration = configSettings
+
+        return configSettings
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationType.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationType.kt
index f80e0408..56e11784 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationType.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationType.kt
@@ -1,6 +1,7 @@
 package org.elm.ide.test.run
 
 import com.intellij.execution.configurations.ConfigurationType
+import com.intellij.execution.configurations.ConfigurationTypeUtil
 import org.elm.ide.test.run.ElmTestConfigurationFactory.Companion.RUN_ICON
 
 class ElmTestRunConfigurationType : ConfigurationType {
@@ -15,4 +16,8 @@ class ElmTestRunConfigurationType : ConfigurationType {
 
     override fun getConfigurationFactories() = arrayOf(ElmTestConfigurationFactory(this))
 
+    companion object {
+        val instance: ElmTestRunConfigurationType
+            get() = ConfigurationTypeUtil.findConfigurationType(ElmTestRunConfigurationType::class.java)
+    }
 }
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
index ec43ed80..87eb30ea 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
@@ -63,7 +63,9 @@ class ElmTestRunProfileState internal constructor(
             return handleBadConfiguration(project, "Could not find the Elm compiler ")
         }
 
-        return elmTestCLI.runTestsProcessHandler(elmCompilerBinary, elmProject)
+        val testFilePath = (environment.runProfile as? ElmTestRunConfiguration)?.options?.testFile?.filePath
+
+        return elmTestCLI.runTestsProcessHandler(elmCompilerBinary, elmProject, testFilePath)
     }
 
     @Throws(ExecutionException::class)
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.form b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.form
index a673d246..159da245 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.form
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.form
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="org.elm.ide.test.run.ElmTestSettingsEditor">
-  <grid id="27dc6" binding="myPanel" layout-manager="GridLayoutManager" row-count="5" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+  <grid id="27dc6" binding="myPanel" layout-manager="GridLayoutManager" row-count="6" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
     <margin top="0" left="0" bottom="0" right="0"/>
     <constraints>
       <xy x="20" y="20" width="517" height="400"/>
@@ -18,7 +18,7 @@
       </component>
       <vspacer id="f7dc7">
         <constraints>
-          <grid row="3" column="0" row-span="2" col-span="1" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
+          <grid row="4" column="0" row-span="2" col-span="1" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
         </constraints>
       </vspacer>
       <component id="3b5" class="com.intellij.openapi.ui.ComboBox" binding="projectChooser">
@@ -27,6 +27,22 @@
         </constraints>
         <properties/>
       </component>
+      <component id="4cc4" class="javax.swing.JLabel">
+        <constraints>
+          <grid row="3" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value="Filtered File Path"/>
+        </properties>
+      </component>
+      <component id="c4db4" class="javax.swing.JTextField" binding="testFilePathField">
+        <constraints>
+          <grid row="3" column="1" row-span="1" col-span="1" vsize-policy="0" hsize-policy="6" anchor="8" fill="1" indent="0" use-parent-layout="false">
+            <preferred-size width="150" height="-1"/>
+          </grid>
+        </constraints>
+        <properties/>
+      </component>
     </children>
   </grid>
 </form>
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
index 72a1294e..aa6fd1e5 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
@@ -19,11 +19,13 @@ import com.intellij.openapi.ui.ComboBox
 import org.elm.ide.test.core.ElmProjectTestsHelper
 import javax.swing.JComponent
 import javax.swing.JPanel
+import javax.swing.JTextField
 
 class ElmTestSettingsEditor internal constructor(project: Project) : SettingsEditor<ElmTestRunConfiguration>() {
     private val helper: ElmProjectTestsHelper = ElmProjectTestsHelper(project)
     private var myPanel: JPanel? = null
     private var projectChooser: ComboBox<String>? = null
+    private var testFilePathField: JTextField? = null
 
     override fun createEditor(): JComponent {
         helper.allNames().forEach { projectChooser!!.addItem(it) }
@@ -35,12 +37,16 @@ class ElmTestSettingsEditor internal constructor(project: Project) : SettingsEdi
                 configuration.options.elmFolder?.let {
                     helper.nameByProjectDirPath(it)
                 }
+        this.testFilePathField!!.text = configuration.options.testFile?.filePath
     }
 
     override fun applyEditorTo(configuration: ElmTestRunConfiguration) {
-        val selectedItem = projectChooser!!.selectedItem
-        if (selectedItem != null && selectedItem is String) {
-            configuration.options.elmFolder = helper.projectDirPathByName(selectedItem)
+        val selectedProject = projectChooser!!.selectedItem
+        if (selectedProject != null && selectedProject is String) {
+            configuration.options.elmFolder = helper.projectDirPathByName(selectedProject)
         }
+
+        val field = testFilePathField!!.text.trim().ifEmpty { null }
+        configuration.options.testFile = ElmTestRunConfiguration.FilteredTest.from(field, configuration.project)
     }
 }
diff --git a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
index f1da4362..fa51027a 100644
--- a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
+++ b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
@@ -31,7 +31,7 @@ class ElmTestCLI(private val executablePath: Path) {
      * @param elmCompilerPath The path to the Elm compiler.
      * @param elmProject The [ElmProject] containing the tests to be run.
      */
-    fun runTestsProcessHandler(elmCompilerPath: Path, elmProject: ElmProject): ProcessHandler {
+    fun runTestsProcessHandler(elmCompilerPath: Path, elmProject: ElmProject, testFilePath: String?): ProcessHandler {
         val commandLine = GeneralCommandLine(executablePath.toString(), "--report=json")
                 .withWorkDirectory(elmProject.projectDirPath.toString())
                 .withParameters("--compiler", elmCompilerPath.toString())
@@ -41,7 +41,10 @@ class ElmTestCLI(private val executablePath: Path) {
         // By default elm-test will process tests in a folder called "tests", under the current working directory
         // (in this case elmProject.projectDirPath). If the project has a custom location for tests we need to supply a
         // path to that folder.
-        if (elmProject.isCustomTestsDir) {
+        if (testFilePath != null) {
+            log.debug { """Test file or directory was provided: "${elmProject.testsRelativeDirPath}". Will specify this path as argument to elm-test.""" }
+            commandLine.withParameters(testFilePath)
+        } else if (elmProject.isCustomTestsDir) {
             log.debug { """Tests are in custom location: "${elmProject.testsRelativeDirPath}". Will specify this path as argument to elm-test.""" }
             commandLine.withParameters(elmProject.testsRelativeDirPath)
         } else {
diff --git a/src/main/resources/icons/runAll.svg b/src/main/resources/icons/runAll.svg
new file mode 100644
index 00000000..9ba2ad2c
--- /dev/null
+++ b/src/main/resources/icons/runAll.svg
@@ -0,0 +1,6 @@
+<!-- Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M9.35558 7.25929C9.81637 7.65809 9.81637 8.37278 9.35558 8.77157L4.15681 13.2709C3.5091 13.8315 2.5024 13.3714 2.5024 12.5148L2.5024 3.5161C2.5024 2.6595 3.5091 2.19939 4.15681 2.75996L9.35558 7.25929Z" fill="#F2FCF3"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M9.68279 6.88122C10.374 7.47941 10.374 8.55145 9.68279 9.14964L4.48401 13.649C3.51245 14.4898 2.0024 13.7997 2.0024 12.5148L2.0024 3.51609C2.0024 2.23119 3.51245 1.54103 4.48402 2.38188L9.68279 6.88122ZM9.02838 8.3935C9.25877 8.1941 9.25877 7.83675 9.02838 7.63736L3.82961 3.13802C3.50575 2.85774 3.0024 3.08779 3.0024 3.51609L3.0024 12.5148C3.0024 12.9431 3.50575 13.1731 3.8296 12.8928L9.02838 8.3935Z" fill="#208A3C"/>
+<path d="M7.85764 2.5L13.3568 7.2593C13.8176 7.65809 13.8176 8.37279 13.3568 8.77158L7.8933 13.5" stroke="#208A3C" stroke-linecap="round"/>
+</svg>
diff --git a/src/main/resources/icons/runAll_dark.svg b/src/main/resources/icons/runAll_dark.svg
new file mode 100644
index 00000000..03616d3a
--- /dev/null
+++ b/src/main/resources/icons/runAll_dark.svg
@@ -0,0 +1,6 @@
+<!-- Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M9.35558 7.25929C9.81637 7.65809 9.81637 8.37278 9.35558 8.77157L4.15681 13.2709C3.5091 13.8315 2.5024 13.3714 2.5024 12.5148L2.5024 3.5161C2.5024 2.6595 3.5091 2.19939 4.15681 2.75996L9.35558 7.25929Z" fill="#253627"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M9.68279 6.88122C10.374 7.47941 10.374 8.55145 9.68279 9.14964L4.48401 13.649C3.51245 14.4898 2.0024 13.7997 2.0024 12.5148L2.0024 3.51609C2.0024 2.23119 3.51245 1.54103 4.48402 2.38188L9.68279 6.88122ZM9.02838 8.3935C9.25877 8.1941 9.25877 7.83675 9.02838 7.63736L3.82961 3.13802C3.50575 2.85774 3.0024 3.08779 3.0024 3.51609L3.0024 12.5148C3.0024 12.9431 3.50575 13.1731 3.8296 12.8928L9.02838 8.3935Z" fill="#57965C"/>
+<path d="M7.85764 2.5L13.3568 7.2593C13.8176 7.65809 13.8176 8.37279 13.3568 8.77158L7.8933 13.5" stroke="#57965C" stroke-linecap="round"/>
+</svg>
diff --git a/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProviderTest.kt b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProviderTest.kt
new file mode 100644
index 00000000..c0dbb8e0
--- /dev/null
+++ b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProviderTest.kt
@@ -0,0 +1,25 @@
+package org.elm.ide.lineMarkers
+
+import org.junit.Test
+
+
+class ElmTestModuleLineMarkerProviderTest : ElmLineMarkerProviderTestBase() {
+
+
+    @Test
+    fun `test test module can run all tests`() = doTestByText(
+            """
+module Main exposing (..) --> Run all tests in this module
+
+import Test exposing (..)
+
+""")
+
+    @Test
+    fun `test non-test module can't run tests`() = doTestByText(
+        """
+module Main exposing (..)
+
+""")
+
+}
diff --git a/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt b/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
index e9e29017..e009adaf 100644
--- a/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
+++ b/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
@@ -13,6 +13,25 @@ class ElmTestRunConfigurationTest {
     fun writeOptions() {
         val root = Element("ROOT")
 
+        val options = Options()
+        options.elmFolder = "folder"
+        options.testFile = ElmTestRunConfiguration.FilteredTest.from("foo", "foo")
+
+        writeOptions(options, root)
+
+        assertEquals(1, root.children.size.toLong())
+        assertEquals(ElmTestRunConfiguration::class.java.simpleName, root.children[0].name)
+        assertEquals(3, root.children[0].attributes.size.toLong())
+        assertEquals("elm-folder", root.children[0].attributes[0].name)
+        assertEquals("folder", root.children[0].attributes[0].value)
+        assertEquals("test-file-path", root.children[0].attributes[1].name)
+        assertEquals("foo", root.children[0].attributes[1].value)
+    }
+
+    @Test
+    fun writeOptionsWithNullTestFile() {
+        val root = Element("ROOT")
+
         val options = Options()
         options.elmFolder = "folder"
 
@@ -29,6 +48,21 @@ class ElmTestRunConfigurationTest {
     fun roundTrip() {
         val root = Element("ROOT")
 
+        val options = Options()
+        options.elmFolder = "folder"
+        options.testFile = ElmTestRunConfiguration.FilteredTest("foo", "foo")
+
+        writeOptions(options, root)
+        val options2 = readOptions(root)
+
+        assertEquals(options.elmFolder, options2.elmFolder)
+        assertEquals(options.testFile, options2.testFile)
+    }
+
+    @Test
+    fun roundTripWithNullTestFile() {
+        val root = Element("ROOT")
+
         val options = Options()
         options.elmFolder = "folder"
 
@@ -36,6 +70,7 @@ class ElmTestRunConfigurationTest {
         val options2 = readOptions(root)
 
         assertEquals(options.elmFolder, options2.elmFolder)
+        assertEquals(options.testFile, options2.testFile)
     }
 
 }
\ No newline at end of file

From 3b6236a2c8fcbd5ccbda5d82cedb8c73b1f27c54 Mon Sep 17 00:00:00 2001
From: Nate Brunette <n@tebru.net>
Date: Fri, 11 Jul 2025 18:37:51 -0500
Subject: [PATCH 2/8] Adding basic support for elm-test-rs

---
 .../elm/ide/test/core/ElmTestJsonProcessor.kt |  3 +-
 .../ide/test/run/ElmTestRunConfiguration.kt   | 24 +++++++---
 .../ide/test/run/ElmTestRunProfileState.kt    |  2 +-
 .../workspace/commandLineTools/ElmTestCLI.kt  |  6 ++-
 .../test/run/ElmTestRunConfigurationTest.kt   | 45 ++++++++++++++++++-
 5 files changed, 68 insertions(+), 12 deletions(-)

diff --git a/src/main/kotlin/org/elm/ide/test/core/ElmTestJsonProcessor.kt b/src/main/kotlin/org/elm/ide/test/core/ElmTestJsonProcessor.kt
index 1362f189..0c3670b4 100644
--- a/src/main/kotlin/org/elm/ide/test/core/ElmTestJsonProcessor.kt
+++ b/src/main/kotlin/org/elm/ide/test/core/ElmTestJsonProcessor.kt
@@ -12,6 +12,7 @@ import org.elm.ide.test.core.LabelUtils.toLocationUrl
 import org.elm.ide.test.core.json.CompileErrors
 import org.elm.ide.test.core.json.Error
 import java.nio.file.Path
+import kotlin.math.roundToLong
 
 /**
  * Processes events from a test run by elm-test.
@@ -75,7 +76,7 @@ class ElmTestJsonProcessor(private val testsRelativeDirPath: String) {
     fun testEvents(path: Path, obj: JsonObject): Sequence<TreeNodeEvent> {
         return when (getStatus(obj)) {
             "pass" -> {
-                val duration = java.lang.Long.parseLong(obj.get("duration").asString)
+                val duration = obj.get("duration").asDouble.roundToLong()
                 sequenceOf(newTestStartedEvent(path))
                         .plus(newTestFinishedEvent(path, duration))
             }
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
index fbfd6f72..1f96bb14 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
@@ -41,10 +41,10 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
 
     data class Options(var elmFolder: String? = null, var testFile: FilteredTest? = null)
 
-    data class FilteredTest(val filePath: String, val label: String) {
+    data class FilteredTest(val filePath: String, val label: String, val testIsDirectory: Boolean) {
         companion object {
             fun from(path: String?, project: Project): FilteredTest? {
-                if (path == null || path.isEmpty())  return null
+                if (path.isNullOrBlank())  return null
 
                 val virtualFile = VirtualFileManager.getInstance().findFileByUrl("file://$path") ?: return null
 
@@ -53,15 +53,21 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
 
             fun from(path: String?, label: String?): FilteredTest? {
                 if (path.isNullOrBlank() || label.isNullOrBlank()) return null
+                val isDirectory = !path.substringAfterLast('/').contains('.')
 
-                return FilteredTest(path, label)
+                return FilteredTest(path, label, isDirectory)
             }
 
             fun from(virtualFile: VirtualFile, project: Project): FilteredTest? {
                 val psiManager = PsiManager.getInstance(project)
-                val psiFile = psiManager.findFile(virtualFile) ?: return null
 
-                return from(psiFile)
+                if (virtualFile.isDirectory) {
+                    val psiDirectory = psiManager.findDirectory(virtualFile) ?: return null
+                    return from(psiDirectory)
+                } else {
+                    val psiFile = psiManager.findFile(virtualFile) ?: return null
+                    return from(psiFile)
+                }
             }
 
             fun from(element: PsiElement): FilteredTest? {
@@ -75,13 +81,17 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
                 val elmFile = psiFile as? ElmFile ?: return null
                 val moduleName = elmFile.getModuleDecl()?.name ?: return null
 
-                return FilteredTest(psiFile.virtualFile.path, moduleName)
+                return FilteredTest(psiFile.virtualFile.path, moduleName, false)
             }
 
             fun from(psiDirectory: PsiDirectory): FilteredTest? {
-                return FilteredTest(psiDirectory.virtualFile.path, psiDirectory.name)
+                return FilteredTest(psiDirectory.virtualFile.path, psiDirectory.name, true)
             }
         }
+
+        fun runnableFilePath(): String {
+            return if (testIsDirectory) "$filePath/**/*.elm" else filePath
+        }
     }
 
     override fun getIcon() = RUN_ICON
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
index 87eb30ea..fb34ec8b 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
@@ -63,7 +63,7 @@ class ElmTestRunProfileState internal constructor(
             return handleBadConfiguration(project, "Could not find the Elm compiler ")
         }
 
-        val testFilePath = (environment.runProfile as? ElmTestRunConfiguration)?.options?.testFile?.filePath
+        val testFilePath = (environment.runProfile as? ElmTestRunConfiguration)?.options?.testFile?.runnableFilePath()
 
         return elmTestCLI.runTestsProcessHandler(elmCompilerBinary, elmProject, testFilePath)
     }
diff --git a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
index fa51027a..be68e96c 100644
--- a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
+++ b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
@@ -71,7 +71,11 @@ class ElmTestCLI(private val executablePath: Path) {
             return Result.Err("no output from elm-test")
         }
 
-        val trimmedFirstLine = firstLine.takeWhile { it != '-' }
+        val trimmedFirstLine = if (firstLine.startsWith("elm-test-rs")) {
+            firstLine.removePrefix("elm-test-rs").trim()
+        } else {
+            firstLine.takeWhile { it != '-' }
+        }
 
         return try {
             Result.Ok(Version.parse(trimmedFirstLine))
diff --git a/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt b/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
index e009adaf..87b82893 100644
--- a/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
+++ b/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
@@ -15,7 +15,28 @@ class ElmTestRunConfigurationTest {
 
         val options = Options()
         options.elmFolder = "folder"
-        options.testFile = ElmTestRunConfiguration.FilteredTest.from("foo", "foo")
+        options.testFile = ElmTestRunConfiguration.FilteredTest.from("Foo.elm", "Foo")
+
+        writeOptions(options, root)
+
+        assertEquals(1, root.children.size.toLong())
+        assertEquals(ElmTestRunConfiguration::class.java.simpleName, root.children[0].name)
+        assertEquals(3, root.children[0].attributes.size.toLong())
+        assertEquals("elm-folder", root.children[0].attributes[0].name)
+        assertEquals("folder", root.children[0].attributes[0].value)
+        assertEquals("test-file-path", root.children[0].attributes[1].name)
+        assertEquals("Foo.elm", root.children[0].attributes[1].value)
+        assertEquals(false, options.testFile?.testIsDirectory)
+        assertEquals("Foo.elm", options.testFile?.runnableFilePath())
+    }
+
+    @Test
+    fun writeOptionsWithDirectory() {
+        val root = Element("ROOT")
+
+        val options = Options()
+        options.elmFolder = "folder"
+        options.testFile = ElmTestRunConfiguration.FilteredTest.from("foo", "Foo")
 
         writeOptions(options, root)
 
@@ -26,6 +47,8 @@ class ElmTestRunConfigurationTest {
         assertEquals("folder", root.children[0].attributes[0].value)
         assertEquals("test-file-path", root.children[0].attributes[1].name)
         assertEquals("foo", root.children[0].attributes[1].value)
+        assertEquals(true, options.testFile?.testIsDirectory)
+        assertEquals("foo/**/*.elm", options.testFile?.runnableFilePath())
     }
 
     @Test
@@ -50,13 +73,30 @@ class ElmTestRunConfigurationTest {
 
         val options = Options()
         options.elmFolder = "folder"
-        options.testFile = ElmTestRunConfiguration.FilteredTest("foo", "foo")
+        options.testFile = ElmTestRunConfiguration.FilteredTest.from("Foo.elm", "foo")
+
+        writeOptions(options, root)
+        val options2 = readOptions(root)
+
+        assertEquals(options.elmFolder, options2.elmFolder)
+        assertEquals(options.testFile, options2.testFile)
+        assertEquals(options.testFile?.runnableFilePath(), options2.testFile?.runnableFilePath())
+    }
+
+    @Test
+    fun roundTripWithDirectory() {
+        val root = Element("ROOT")
+
+        val options = Options()
+        options.elmFolder = "folder"
+        options.testFile = ElmTestRunConfiguration.FilteredTest.from("foo", "foo")
 
         writeOptions(options, root)
         val options2 = readOptions(root)
 
         assertEquals(options.elmFolder, options2.elmFolder)
         assertEquals(options.testFile, options2.testFile)
+        assertEquals(options.testFile?.runnableFilePath(), options2.testFile?.runnableFilePath())
     }
 
     @Test
@@ -71,6 +111,7 @@ class ElmTestRunConfigurationTest {
 
         assertEquals(options.elmFolder, options2.elmFolder)
         assertEquals(options.testFile, options2.testFile)
+        assertEquals(options.testFile?.runnableFilePath(), options2.testFile?.runnableFilePath())
     }
 
 }
\ No newline at end of file

From 1e6d0ebdb890e8a378396da062135971cc40215b Mon Sep 17 00:00:00 2001
From: Nate Brunette <n@tebru.net>
Date: Mon, 14 Jul 2025 17:18:51 -0500
Subject: [PATCH 3/8] Adding support for running a describe block or single
 test using elm-test-rs

---
 src/main/kotlin/org/elm/ide/icons/ElmIcons.kt |  1 +
 .../ide/lineMarkers/ElmLineMarkerProvider.kt  |  4 +-
 .../org/elm/ide/lineMarkers/ElmRunActions.kt  | 16 ++++-
 .../ElmTestDescribeLineMarkerProvider.kt      | 35 ++++++++++
 .../ElmTestModuleLineMarkerProvider.kt        |  4 +-
 .../ElmTestSingleLineMarkerProvider.kt        | 35 ++++++++++
 .../ide/test/core/ElmTestElementNavigator.kt  | 50 ++++++++++++++
 .../ide/test/run/ElmTestRunConfiguration.kt   | 56 ++++++++-------
 .../run/ElmTestRunConfigurationProducer.kt    | 10 ++-
 .../ElmTestRunConfigurationSettingsBuilder.kt |  6 +-
 .../ide/test/run/ElmTestRunProfileState.kt    |  4 +-
 .../ide/test/run/ElmTestSettingsEditor.form   | 22 +++++-
 .../elm/ide/test/run/ElmTestSettingsEditor.kt |  7 +-
 .../workspace/commandLineTools/ElmTestCLI.kt  | 12 +++-
 src/main/resources/icons/run.svg              |  4 ++
 src/main/resources/icons/run_dark.svg         |  4 ++
 .../ElmTestModuleLineMarkerProviderTest.kt    | 25 -------
 .../ElmTestTestLineMarkerProviderTest.kt      | 31 +++++++++
 .../test/core/ElmTestElementNavigatorTest.kt  | 49 +++++++++++++
 .../test/run/ElmTestRunConfigurationTest.kt   | 68 +++++++++++++++----
 ...TestRunConfigurationSettingsBuilderTest.kt | 58 ++++++++++++++++
 21 files changed, 418 insertions(+), 83 deletions(-)
 create mode 100644 src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
 create mode 100644 src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
 create mode 100644 src/main/kotlin/org/elm/ide/test/core/ElmTestElementNavigator.kt
 create mode 100644 src/main/resources/icons/run.svg
 create mode 100644 src/main/resources/icons/run_dark.svg
 delete mode 100644 src/test/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProviderTest.kt
 create mode 100644 src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
 create mode 100644 src/test/kotlin/org/elm/ide/test/core/ElmTestElementNavigatorTest.kt
 create mode 100644 src/test/kotlin/org/elm/workspace/ElmTestRunConfigurationSettingsBuilderTest.kt

diff --git a/src/main/kotlin/org/elm/ide/icons/ElmIcons.kt b/src/main/kotlin/org/elm/ide/icons/ElmIcons.kt
index 3e799775..7bac03f2 100644
--- a/src/main/kotlin/org/elm/ide/icons/ElmIcons.kt
+++ b/src/main/kotlin/org/elm/ide/icons/ElmIcons.kt
@@ -29,6 +29,7 @@ object ElmIcons {
 
     // TEST ICONS
 
+    val RUN = getIcon("run.svg")
     val RUN_ALL = getIcon("runAll.svg")
 
     private fun getIcon(path: String): Icon {
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmLineMarkerProvider.kt
index 17b46c52..2dc1e665 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmLineMarkerProvider.kt
@@ -43,7 +43,9 @@ class ElmLineMarkerProvider : LineMarkerProviderDescriptor() {
 private val optionProviders = mapOf(
     ElmExposureLineMarkerProvider.OPTION to { ElmExposureLineMarkerProvider() },
     ElmRecursiveCallLineMarkerProvider.OPTION to { ElmRecursiveCallLineMarkerProvider() },
-    ElmTestModuleLineMarkerProvider.OPTION to { ElmTestModuleLineMarkerProvider() }
+    ElmTestModuleLineMarkerProvider.OPTION to { ElmTestModuleLineMarkerProvider() },
+    ElmTestDescribeLineMarkerProvider.OPTION to { ElmTestDescribeLineMarkerProvider() },
+    ElmTestSingleLineMarkerProvider.OPTION to { ElmTestSingleLineMarkerProvider() }
 )
 
 private val OPTIONS = optionProviders.keys.toTypedArray()
\ No newline at end of file
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
index 97e2eb0f..ba1468bd 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
@@ -22,15 +22,27 @@ class RunAllTestsAction(private val element: PsiElement) : AnAction("Run All Tes
     }
 }
 
+/**
+ * Action to run a test filtered by test or describe description
+ */
+class RunFilteredTestAction(private val element: PsiElement, private val filter: String) : AnAction("Run Filtered Test") {
+    override fun actionPerformed(event: AnActionEvent) {
+        ProgramRunnerUtil.executeConfiguration(
+            ElmTestRunConfigurationSettingsBuilder.createAndRegisterFromElement(element, filter),
+            DefaultRunExecutor.getRunExecutorInstance()
+        )
+    }
+}
+
 /**
  * Creates a run configuration and opens editor
  */
-class ModifyRunConfiguration(private val element: PsiElement) : AnAction("Modify Run Configuration") {
+class ModifyRunConfiguration(private val element: PsiElement, private val filter: String? = null) : AnAction("Modify Run Configuration") {
     override fun actionPerformed(event: AnActionEvent) {
         ShowSettingsUtil.getInstance().editConfigurable(
             element.project,
             SingleConfigurationConfigurable.editSettings<ElmTestRunConfiguration>(
-                ElmTestRunConfigurationSettingsBuilder.createAndRegisterFromElement(element),
+                ElmTestRunConfigurationSettingsBuilder.createAndRegisterFromElement(element, filter),
                 null
             )
         )
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
new file mode 100644
index 00000000..ad69499e
--- /dev/null
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
@@ -0,0 +1,35 @@
+package org.elm.ide.lineMarkers
+
+import com.intellij.codeInsight.daemon.GutterIconDescriptor
+import com.intellij.codeInsight.daemon.LineMarkerInfo
+import com.intellij.psi.PsiElement
+import org.elm.ide.icons.ElmIcons
+import org.elm.ide.test.core.ElmTestElementNavigator
+
+/**
+ * Handles adding a gutter icon for running tests under a describe
+ */
+class ElmTestDescribeLineMarkerProvider : ElmTestLineMarkerProvider() {
+    companion object {
+        val OPTION = GutterIconDescriptor.Option("elm.testDescribe", "Test describe", ElmIcons.RUN)
+    }
+
+    /**
+     * Add gutter icons for the describe line
+     */
+    override fun shouldAddGutterIcon(element: PsiElement): Boolean {
+        return element.text == "describe"
+    }
+
+    override fun getLineMarkerInfo(element: PsiElement): LineMarkerInfo<*>? {
+        if (!shouldAddGutterIcon(element)) return null
+        val filter = ElmTestElementNavigator.findTestDescription(element) ?: return null
+
+        return createLineMarkerInfo(
+            element,
+            ElmIcons.RUN,
+            "Run describe",
+            listOf(RunFilteredTestAction(element, filter), ModifyRunConfiguration(element, filter))
+        )
+    }
+}
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
index b08a3d24..b633e0d6 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
@@ -11,7 +11,7 @@ import org.elm.lang.core.psi.ElmTypes
  */
 class ElmTestModuleLineMarkerProvider : ElmTestLineMarkerProvider() {
     companion object {
-        val OPTION = GutterIconDescriptor.Option("elm.test", "Test module", ElmIcons.RUN_ALL)
+        val OPTION = GutterIconDescriptor.Option("elm.testModule", "Test module", ElmIcons.RUN_ALL)
     }
 
     /**
@@ -22,6 +22,8 @@ class ElmTestModuleLineMarkerProvider : ElmTestLineMarkerProvider() {
     }
 
     override fun getLineMarkerInfo(element: PsiElement): LineMarkerInfo<*>? {
+        if (!shouldAddGutterIcon(element)) return null
+
         return createLineMarkerInfo(
             element,
             ElmIcons.RUN_ALL,
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
new file mode 100644
index 00000000..34d63796
--- /dev/null
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
@@ -0,0 +1,35 @@
+package org.elm.ide.lineMarkers
+
+import com.intellij.codeInsight.daemon.GutterIconDescriptor
+import com.intellij.codeInsight.daemon.LineMarkerInfo
+import com.intellij.psi.PsiElement
+import org.elm.ide.icons.ElmIcons
+import org.elm.ide.test.core.ElmTestElementNavigator
+
+/**
+ * Handles adding a gutter icon for running a specific test
+ */
+class ElmTestSingleLineMarkerProvider : ElmTestLineMarkerProvider() {
+    companion object {
+        val OPTION = GutterIconDescriptor.Option("elm.testSingle", "Test single", ElmIcons.RUN)
+    }
+
+    /**
+     * Add gutter icons for the test line
+     */
+    override fun shouldAddGutterIcon(element: PsiElement): Boolean {
+        return element.text == "test"
+    }
+
+    override fun getLineMarkerInfo(element: PsiElement): LineMarkerInfo<*>? {
+        if (!shouldAddGutterIcon(element)) return null
+        val filter = ElmTestElementNavigator.findTestDescription(element) ?: return null
+
+        return createLineMarkerInfo(
+            element,
+            ElmIcons.RUN,
+            "Run test",
+            listOf(RunFilteredTestAction(element, filter), ModifyRunConfiguration(element, filter))
+        )
+    }
+}
diff --git a/src/main/kotlin/org/elm/ide/test/core/ElmTestElementNavigator.kt b/src/main/kotlin/org/elm/ide/test/core/ElmTestElementNavigator.kt
new file mode 100644
index 00000000..1f427d06
--- /dev/null
+++ b/src/main/kotlin/org/elm/ide/test/core/ElmTestElementNavigator.kt
@@ -0,0 +1,50 @@
+package org.elm.ide.test.core
+
+import com.intellij.psi.PsiComment
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiWhiteSpace
+import org.elm.lang.core.psi.elements.ElmBinOpExpr
+import org.elm.lang.core.psi.elements.ElmFunctionCallExpr
+import org.elm.lang.core.psi.elements.ElmStringConstantExpr
+
+object ElmTestElementNavigator {
+    /**
+     * Find the test or describe description text without surrounding quotes
+     *
+     * This will only match
+     *   - test "this works"
+     *   - describe "this test"
+     *
+     * Exactly and not any programatic calls
+     */
+    fun findTestDescription(element: PsiElement?): String? {
+        if (element == null) return null
+        val callExpr = getFunctionCallExpr(element) ?: return null
+
+        // look for a string directly after the test or describe function call
+        return (callExpr
+            .children
+            .filterNot { it is PsiWhiteSpace || it is PsiComment }
+            .getOrNull(1) as? ElmStringConstantExpr)
+            ?.text
+            ?.removeSurrounding("\"")
+    }
+
+    /**
+     * Find the next parent function call given a list of target names
+     */
+    private fun getFunctionCallExpr(element: PsiElement?, targets: List<String> = listOf("test", "describe")): ElmFunctionCallExpr? {
+        var current = element
+        while (current != null) {
+            val unwrapped = if (current is ElmBinOpExpr) {
+                // handles creating a run config from in a test body
+                current.children.firstOrNull { it is ElmFunctionCallExpr } ?: current
+            } else {
+                current
+            }
+            if (unwrapped is ElmFunctionCallExpr && unwrapped.target.text.substringAfterLast(".") in targets) return unwrapped
+            current = current.parent
+        }
+        return null
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
index 1f96bb14..65060a79 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfiguration.kt
@@ -39,53 +39,53 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
     override fun getState(executor: Executor, executionEnvironment: ExecutionEnvironment) =
             ElmTestRunProfileState(executionEnvironment, this)
 
-    data class Options(var elmFolder: String? = null, var testFile: FilteredTest? = null)
+    data class Options(var elmFolder: String? = null, var filteredTestConfig: FilteredTest? = null)
 
-    data class FilteredTest(val filePath: String, val label: String, val testIsDirectory: Boolean) {
+    data class FilteredTest(val filePath: String, val moduleName: String, val testIsDirectory: Boolean, val filter: String?) {
         companion object {
-            fun from(path: String?, project: Project): FilteredTest? {
+            fun from(path: String?, project: Project, filter: String? = null): FilteredTest? {
                 if (path.isNullOrBlank())  return null
 
                 val virtualFile = VirtualFileManager.getInstance().findFileByUrl("file://$path") ?: return null
 
-                return from(virtualFile, project)
+                return from(virtualFile, project, filter)
             }
 
-            fun from(path: String?, label: String?): FilteredTest? {
-                if (path.isNullOrBlank() || label.isNullOrBlank()) return null
+            fun from(path: String?, moduleName: String?, filter: String? = null): FilteredTest? {
+                if (path.isNullOrBlank() || moduleName.isNullOrBlank()) return null
                 val isDirectory = !path.substringAfterLast('/').contains('.')
 
-                return FilteredTest(path, label, isDirectory)
+                return FilteredTest(path, moduleName, isDirectory, filter)
             }
 
-            fun from(virtualFile: VirtualFile, project: Project): FilteredTest? {
+            fun from(virtualFile: VirtualFile, project: Project, filter: String? = null): FilteredTest? {
                 val psiManager = PsiManager.getInstance(project)
 
                 if (virtualFile.isDirectory) {
                     val psiDirectory = psiManager.findDirectory(virtualFile) ?: return null
-                    return from(psiDirectory)
+                    return from(psiDirectory, filter)
                 } else {
                     val psiFile = psiManager.findFile(virtualFile) ?: return null
-                    return from(psiFile)
+                    return from(psiFile, filter)
                 }
             }
 
-            fun from(element: PsiElement): FilteredTest? {
+            fun from(element: PsiElement, filter: String? = null): FilteredTest? {
                 return when (element) {
-                    is PsiDirectory -> from(element)
-                    else -> element.containingFile?.let { from(it) }
+                    is PsiDirectory -> from(element, filter)
+                    else -> element.containingFile?.let { from(it, filter) }
                 }
             }
 
-            fun from(psiFile: PsiFile): FilteredTest? {
+            fun from(psiFile: PsiFile, filter: String? = null): FilteredTest? {
                 val elmFile = psiFile as? ElmFile ?: return null
                 val moduleName = elmFile.getModuleDecl()?.name ?: return null
 
-                return FilteredTest(psiFile.virtualFile.path, moduleName, false)
+                return FilteredTest(psiFile.virtualFile.path, moduleName, false, filter)
             }
 
-            fun from(psiDirectory: PsiDirectory): FilteredTest? {
-                return FilteredTest(psiDirectory.virtualFile.path, psiDirectory.name, true)
+            fun from(psiDirectory: PsiDirectory, filter: String? = null): FilteredTest? {
+                return FilteredTest(psiDirectory.virtualFile.path, psiDirectory.name, true, filter)
             }
         }
 
@@ -109,8 +109,12 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
     override fun suggestedName(): String? {
         val elmFolder = options.elmFolder
 
-        if (!options.testFile?.label.isNullOrBlank()) {
-            return "Tests in ${options.testFile?.label}"
+        if (!options.filteredTestConfig?.moduleName.isNullOrBlank()) {
+            return if (options.filteredTestConfig?.filter.isNullOrBlank()) {
+                "Tests in ${options.filteredTestConfig?.moduleName}"
+            } else {
+                "Tests in ${options.filteredTestConfig?.moduleName}: ${options.filteredTestConfig?.filter}"
+            }
         }
 
         if (elmFolder != null) {
@@ -129,9 +133,12 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
             val e = element.getChild(name) ?: Element(name).also { element.addContent(it) }
 
             e.setAttribute("elm-folder", options.elmFolder ?: "")
-            if (options.testFile != null) {
-                e.setAttribute("test-file-path", options.testFile?.filePath)
-                e.setAttribute("test-file-module", options.testFile?.label)
+            if (options.filteredTestConfig != null) {
+                e.setAttribute("test-file-path", options.filteredTestConfig?.filePath)
+                e.setAttribute("test-file-module", options.filteredTestConfig?.moduleName)
+                if (!options.filteredTestConfig?.filter.isNullOrBlank()) {
+                    e.setAttribute("test-filter", options.filteredTestConfig?.filter)
+                }
             }
         }
 
@@ -140,9 +147,10 @@ class ElmTestRunConfiguration internal constructor(project: Project, factory: Co
                 val name = ElmTestRunConfiguration::class.java.simpleName
                 val child = element.getChild(name)
                 elmFolder = child?.getAttribute("elm-folder")?.value
-                testFile = FilteredTest.from(
+                filteredTestConfig = FilteredTest.from(
                     child?.getAttribute("test-file-path")?.value,
-                    child?.getAttribute("test-file-module")?.value
+                    child?.getAttribute("test-file-module")?.value,
+                    child?.getAttribute("test-filter")?.value
                 )
 
             }
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
index 718f639a..8d17bc52 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
@@ -4,6 +4,7 @@ import com.intellij.execution.actions.ConfigurationContext
 import com.intellij.execution.actions.LazyRunConfigurationProducer
 import com.intellij.openapi.util.Ref
 import com.intellij.psi.PsiElement
+import org.elm.ide.test.core.ElmTestElementNavigator
 import org.elm.workspace.elmWorkspace
 
 class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunConfiguration>() {
@@ -17,7 +18,8 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
 
         configuration.options.elmFolder = elmFolder
         if (vfile != null) {
-            configuration.options.testFile = ElmTestRunConfiguration.FilteredTest.from(sourceElement.get())
+            val filter = ElmTestElementNavigator.findTestDescription(context.psiLocation)
+            configuration.options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from(sourceElement.get(), filter)
         }
 
         configuration.setGeneratedName()
@@ -28,9 +30,11 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
     override fun isConfigurationFromContext(configuration: ElmTestRunConfiguration, context: ConfigurationContext): Boolean {
         val elmFolder = getCandidateElmFolder(context) ?: return false
         val vfile = context.location?.virtualFile
+        val filter = ElmTestElementNavigator.findTestDescription(context.psiLocation)
 
-        return configuration.options.elmFolder == elmFolder &&
-            configuration.options.testFile?.filePath == vfile?.path
+        return configuration.options.elmFolder == elmFolder
+                && configuration.options.filteredTestConfig?.filePath == vfile?.path
+                && configuration.options.filteredTestConfig?.filter == filter
     }
 
     private fun getCandidateElmFolder(context: ConfigurationContext): String? {
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
index 1ae455bf..79489dd2 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
@@ -10,7 +10,7 @@ import kotlin.io.path.pathString
  * Helper object to create a run configuration and add it to the run manager. Returns the config settings.
  */
 object ElmTestRunConfigurationSettingsBuilder {
-    fun createAndRegisterFromElement(element: PsiElement): RunnerAndConfigurationSettings {
+    fun createAndRegisterFromElement(element: PsiElement, filter: String? = null): RunnerAndConfigurationSettings {
         val project = element.project
         val runManager = RunManager.getInstance(project)
         val configurationFactory = ElmTestRunConfigurationType.instance.configurationFactories.single()
@@ -18,11 +18,11 @@ object ElmTestRunConfigurationSettingsBuilder {
         val configuration = configurationFactory.createTemplateConfiguration(project)
         configuration.options.elmFolder =
             project.elmWorkspace.findProjectForFile(element.containingFile.virtualFile)?.projectDirPath?.pathString
-        configuration.options.testFile = ElmTestRunConfiguration.FilteredTest.from(element)
+        configuration.options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from(element, filter)
         configuration.setGeneratedName()
 
         val configSettings = runManager.createConfiguration(configuration, configurationFactory)
-        configSettings.isTemporary = false
+        configSettings.isTemporary = true
         runManager.addConfiguration(configSettings)
         runManager.selectedConfiguration = configSettings
 
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
index fb34ec8b..345546b6 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
@@ -63,9 +63,9 @@ class ElmTestRunProfileState internal constructor(
             return handleBadConfiguration(project, "Could not find the Elm compiler ")
         }
 
-        val testFilePath = (environment.runProfile as? ElmTestRunConfiguration)?.options?.testFile?.runnableFilePath()
+        val filteredTest = (environment.runProfile as? ElmTestRunConfiguration)?.options?.filteredTestConfig
 
-        return elmTestCLI.runTestsProcessHandler(elmCompilerBinary, elmProject, testFilePath)
+        return elmTestCLI.runTestsProcessHandler(elmCompilerBinary, elmProject, filteredTest)
     }
 
     @Throws(ExecutionException::class)
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.form b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.form
index 159da245..1e900a7d 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.form
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.form
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <form xmlns="http://www.intellij.com/uidesigner/form/" version="1" bind-to-class="org.elm.ide.test.run.ElmTestSettingsEditor">
-  <grid id="27dc6" binding="myPanel" layout-manager="GridLayoutManager" row-count="6" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
+  <grid id="27dc6" binding="myPanel" layout-manager="GridLayoutManager" row-count="7" column-count="2" same-size-horizontally="false" same-size-vertically="false" hgap="-1" vgap="-1">
     <margin top="0" left="0" bottom="0" right="0"/>
     <constraints>
       <xy x="20" y="20" width="517" height="400"/>
@@ -18,7 +18,7 @@
       </component>
       <vspacer id="f7dc7">
         <constraints>
-          <grid row="4" column="0" row-span="2" col-span="1" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
+          <grid row="5" column="0" row-span="2" col-span="1" vsize-policy="6" hsize-policy="1" anchor="0" fill="2" indent="0" use-parent-layout="false"/>
         </constraints>
       </vspacer>
       <component id="3b5" class="com.intellij.openapi.ui.ComboBox" binding="projectChooser">
@@ -29,7 +29,7 @@
       </component>
       <component id="4cc4" class="javax.swing.JLabel">
         <constraints>
-          <grid row="3" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="8" fill="0" indent="0" use-parent-layout="false"/>
+          <grid row="3" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="4" fill="0" indent="0" use-parent-layout="false"/>
         </constraints>
         <properties>
           <text value="Filtered File Path"/>
@@ -43,6 +43,22 @@
         </constraints>
         <properties/>
       </component>
+      <component id="d37b4" class="javax.swing.JLabel">
+        <constraints>
+          <grid row="4" column="0" row-span="1" col-span="1" vsize-policy="0" hsize-policy="0" anchor="4" fill="0" indent="0" use-parent-layout="false"/>
+        </constraints>
+        <properties>
+          <text value="Filter"/>
+        </properties>
+      </component>
+      <component id="cd25b" class="javax.swing.JTextField" binding="testFilter">
+        <constraints>
+          <grid row="4" column="1" row-span="1" col-span="1" vsize-policy="0" hsize-policy="6" anchor="8" fill="1" indent="0" use-parent-layout="false">
+            <preferred-size width="150" height="-1"/>
+          </grid>
+        </constraints>
+        <properties/>
+      </component>
     </children>
   </grid>
 </form>
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
index aa6fd1e5..c09821f4 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
@@ -26,6 +26,7 @@ class ElmTestSettingsEditor internal constructor(project: Project) : SettingsEdi
     private var myPanel: JPanel? = null
     private var projectChooser: ComboBox<String>? = null
     private var testFilePathField: JTextField? = null
+    private var testFilter: JTextField? = null
 
     override fun createEditor(): JComponent {
         helper.allNames().forEach { projectChooser!!.addItem(it) }
@@ -37,7 +38,8 @@ class ElmTestSettingsEditor internal constructor(project: Project) : SettingsEdi
                 configuration.options.elmFolder?.let {
                     helper.nameByProjectDirPath(it)
                 }
-        this.testFilePathField!!.text = configuration.options.testFile?.filePath
+        this.testFilePathField!!.text = configuration.options.filteredTestConfig?.filePath
+        this.testFilter!!.text = configuration.options.filteredTestConfig?.filter
     }
 
     override fun applyEditorTo(configuration: ElmTestRunConfiguration) {
@@ -47,6 +49,7 @@ class ElmTestSettingsEditor internal constructor(project: Project) : SettingsEdi
         }
 
         val field = testFilePathField!!.text.trim().ifEmpty { null }
-        configuration.options.testFile = ElmTestRunConfiguration.FilteredTest.from(field, configuration.project)
+        val filter = testFilter!!.text.trim().ifEmpty { null }
+        configuration.options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from(field, configuration.project, filter)
     }
 }
diff --git a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
index be68e96c..ee5c9c76 100644
--- a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
+++ b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
@@ -7,6 +7,7 @@ import com.intellij.execution.process.ProcessHandler
 import com.intellij.openapi.diagnostic.debug
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.project.Project
+import org.elm.ide.test.run.ElmTestRunConfiguration
 import org.elm.openapiext.GeneralCommandLine
 import org.elm.openapiext.Result
 import org.elm.openapiext.execute
@@ -31,7 +32,7 @@ class ElmTestCLI(private val executablePath: Path) {
      * @param elmCompilerPath The path to the Elm compiler.
      * @param elmProject The [ElmProject] containing the tests to be run.
      */
-    fun runTestsProcessHandler(elmCompilerPath: Path, elmProject: ElmProject, testFilePath: String?): ProcessHandler {
+    fun runTestsProcessHandler(elmCompilerPath: Path, elmProject: ElmProject, filteredTest: ElmTestRunConfiguration.FilteredTest?): ProcessHandler {
         val commandLine = GeneralCommandLine(executablePath.toString(), "--report=json")
                 .withWorkDirectory(elmProject.projectDirPath.toString())
                 .withParameters("--compiler", elmCompilerPath.toString())
@@ -41,9 +42,14 @@ class ElmTestCLI(private val executablePath: Path) {
         // By default elm-test will process tests in a folder called "tests", under the current working directory
         // (in this case elmProject.projectDirPath). If the project has a custom location for tests we need to supply a
         // path to that folder.
-        if (testFilePath != null) {
+        if (filteredTest != null) {
             log.debug { """Test file or directory was provided: "${elmProject.testsRelativeDirPath}". Will specify this path as argument to elm-test.""" }
-            commandLine.withParameters(testFilePath)
+
+            if (!filteredTest.filter.isNullOrBlank()) {
+                commandLine.withParameters("--filter", filteredTest.filter)
+            }
+
+            commandLine.withParameters(filteredTest.runnableFilePath())
         } else if (elmProject.isCustomTestsDir) {
             log.debug { """Tests are in custom location: "${elmProject.testsRelativeDirPath}". Will specify this path as argument to elm-test.""" }
             commandLine.withParameters(elmProject.testsRelativeDirPath)
diff --git a/src/main/resources/icons/run.svg b/src/main/resources/icons/run.svg
new file mode 100644
index 00000000..dd11f50d
--- /dev/null
+++ b/src/main/resources/icons/run.svg
@@ -0,0 +1,4 @@
+<!-- Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M13.5 7.13397C14.1667 7.51888 14.1667 8.48112 13.5 8.86602L4.5 14.0622C3.83333 14.4471 3 13.966 3 13.1962L3 2.80385C3 2.03405 3.83333 1.55292 4.5 1.93782L13.5 7.13397Z" fill="#F2FCF3" stroke="#208A3C"/>
+</svg>
diff --git a/src/main/resources/icons/run_dark.svg b/src/main/resources/icons/run_dark.svg
new file mode 100644
index 00000000..0c199c7d
--- /dev/null
+++ b/src/main/resources/icons/run_dark.svg
@@ -0,0 +1,4 @@
+<!-- Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M13.5 7.13397C14.1667 7.51888 14.1667 8.48112 13.5 8.86602L4.5 14.0622C3.83333 14.4471 3 13.966 3 13.1962L3 2.80385C3 2.03405 3.83333 1.55292 4.5 1.93782L13.5 7.13397Z" fill="#253627" stroke="#57965C"/>
+</svg>
diff --git a/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProviderTest.kt b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProviderTest.kt
deleted file mode 100644
index c0dbb8e0..00000000
--- a/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProviderTest.kt
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.elm.ide.lineMarkers
-
-import org.junit.Test
-
-
-class ElmTestModuleLineMarkerProviderTest : ElmLineMarkerProviderTestBase() {
-
-
-    @Test
-    fun `test test module can run all tests`() = doTestByText(
-            """
-module Main exposing (..) --> Run all tests in this module
-
-import Test exposing (..)
-
-""")
-
-    @Test
-    fun `test non-test module can't run tests`() = doTestByText(
-        """
-module Main exposing (..)
-
-""")
-
-}
diff --git a/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
new file mode 100644
index 00000000..46ab6646
--- /dev/null
+++ b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
@@ -0,0 +1,31 @@
+package org.elm.ide.lineMarkers
+
+import org.junit.Test
+
+
+class ElmTestTestLineMarkerProviderTest : ElmLineMarkerProviderTestBase() {
+
+
+    @Test
+    fun `test test module properly adds markers`() = doTestByText(
+            """
+module Main --> Run all tests in this module
+
+import Test exposing (..)
+
+myTest : Test
+myTest =
+    describe "my test" --> Run describe
+        [ test "1 == 1" <| \_ -> Expect.equal 1 1 --> Run test
+        ]
+
+""")
+
+    @Test
+    fun `test non-test module can't run tests`() = doTestByText(
+        """
+module Main exposing (..)
+
+""")
+
+}
diff --git a/src/test/kotlin/org/elm/ide/test/core/ElmTestElementNavigatorTest.kt b/src/test/kotlin/org/elm/ide/test/core/ElmTestElementNavigatorTest.kt
new file mode 100644
index 00000000..3efd27ad
--- /dev/null
+++ b/src/test/kotlin/org/elm/ide/test/core/ElmTestElementNavigatorTest.kt
@@ -0,0 +1,49 @@
+package org.elm.ide.test.core
+
+import org.elm.lang.ElmTestBase
+import org.junit.Test
+
+class ElmTestElementNavigatorTest : ElmTestBase() {
+    @Test
+    fun `find description from test`() {
+        val psiFile = myFixture.configureByText("ElmTest.elm", getTestFile())
+        val testElement = psiFile.findElementAt(psiFile.text.indexOf("test \"1 == 1\" <|"))
+        val result = ElmTestElementNavigator.findTestDescription(testElement)
+
+        assertEquals("1 == 1", result)
+    }
+
+    @Test
+    fun `find description from describe`() {
+        val psiFile = myFixture.configureByText("ElmTest.elm", getTestFile())
+        val testElement = psiFile.findElementAt(psiFile.text.indexOf("describe \"my suite\""))
+        val result = ElmTestElementNavigator.findTestDescription(testElement)
+
+        assertEquals("my suite", result)
+    }
+
+    @Test
+    fun `walk up to find first test`() {
+        val psiFile = myFixture.configureByText("ElmTest.elm", getTestFile())
+        val testElement = psiFile.findElementAt(psiFile.text.indexOf("\\_ -> Expect.equal 1 1"))
+        val result = ElmTestElementNavigator.findTestDescription(testElement)
+
+        assertEquals("1 == 1", result)
+    }
+
+    private fun getTestFile(): String {
+        return """
+    module Example exposing (..)
+    
+    import Test exposing (test)
+    import Expect
+    
+    suite : Test
+    suite =
+        describe "my suite"
+            [ test "1 == 1" <|
+                \_ -> Expect.equal 1 1
+            ]
+    """.trimIndent()
+    }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt b/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
index 87b82893..d08f2345 100644
--- a/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
+++ b/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
@@ -15,7 +15,7 @@ class ElmTestRunConfigurationTest {
 
         val options = Options()
         options.elmFolder = "folder"
-        options.testFile = ElmTestRunConfiguration.FilteredTest.from("Foo.elm", "Foo")
+        options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from("Foo.elm", "Foo")
 
         writeOptions(options, root)
 
@@ -26,8 +26,8 @@ class ElmTestRunConfigurationTest {
         assertEquals("folder", root.children[0].attributes[0].value)
         assertEquals("test-file-path", root.children[0].attributes[1].name)
         assertEquals("Foo.elm", root.children[0].attributes[1].value)
-        assertEquals(false, options.testFile?.testIsDirectory)
-        assertEquals("Foo.elm", options.testFile?.runnableFilePath())
+        assertEquals(false, options.filteredTestConfig?.testIsDirectory)
+        assertEquals("Foo.elm", options.filteredTestConfig?.runnableFilePath())
     }
 
     @Test
@@ -36,7 +36,7 @@ class ElmTestRunConfigurationTest {
 
         val options = Options()
         options.elmFolder = "folder"
-        options.testFile = ElmTestRunConfiguration.FilteredTest.from("foo", "Foo")
+        options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from("foo", "Foo")
 
         writeOptions(options, root)
 
@@ -47,8 +47,31 @@ class ElmTestRunConfigurationTest {
         assertEquals("folder", root.children[0].attributes[0].value)
         assertEquals("test-file-path", root.children[0].attributes[1].name)
         assertEquals("foo", root.children[0].attributes[1].value)
-        assertEquals(true, options.testFile?.testIsDirectory)
-        assertEquals("foo/**/*.elm", options.testFile?.runnableFilePath())
+        assertEquals(true, options.filteredTestConfig?.testIsDirectory)
+        assertEquals("foo/**/*.elm", options.filteredTestConfig?.runnableFilePath())
+        assertEquals(null, options.filteredTestConfig?.filter)
+    }
+
+    @Test
+    fun writeOptionsWithFilter() {
+        val root = Element("ROOT")
+
+        val options = Options()
+        options.elmFolder = "folder"
+        options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from("Foo.elm", "Foo", filter = "bar")
+
+        writeOptions(options, root)
+
+        assertEquals(1, root.children.size.toLong())
+        assertEquals(ElmTestRunConfiguration::class.java.simpleName, root.children[0].name)
+        assertEquals(4, root.children[0].attributes.size.toLong())
+        assertEquals("elm-folder", root.children[0].attributes[0].name)
+        assertEquals("folder", root.children[0].attributes[0].value)
+        assertEquals("test-file-path", root.children[0].attributes[1].name)
+        assertEquals("Foo.elm", root.children[0].attributes[1].value)
+        assertEquals(false, options.filteredTestConfig?.testIsDirectory)
+        assertEquals("Foo.elm", options.filteredTestConfig?.runnableFilePath())
+        assertEquals("bar", options.filteredTestConfig?.filter)
     }
 
     @Test
@@ -73,14 +96,14 @@ class ElmTestRunConfigurationTest {
 
         val options = Options()
         options.elmFolder = "folder"
-        options.testFile = ElmTestRunConfiguration.FilteredTest.from("Foo.elm", "foo")
+        options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from("Foo.elm", "foo")
 
         writeOptions(options, root)
         val options2 = readOptions(root)
 
         assertEquals(options.elmFolder, options2.elmFolder)
-        assertEquals(options.testFile, options2.testFile)
-        assertEquals(options.testFile?.runnableFilePath(), options2.testFile?.runnableFilePath())
+        assertEquals(options.filteredTestConfig, options2.filteredTestConfig)
+        assertEquals(options.filteredTestConfig?.runnableFilePath(), options2.filteredTestConfig?.runnableFilePath())
     }
 
     @Test
@@ -89,14 +112,31 @@ class ElmTestRunConfigurationTest {
 
         val options = Options()
         options.elmFolder = "folder"
-        options.testFile = ElmTestRunConfiguration.FilteredTest.from("foo", "foo")
+        options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from("foo", "foo")
+
+        writeOptions(options, root)
+        val options2 = readOptions(root)
+
+        assertEquals(options.elmFolder, options2.elmFolder)
+        assertEquals(options.filteredTestConfig, options2.filteredTestConfig)
+        assertEquals(options.filteredTestConfig?.runnableFilePath(), options2.filteredTestConfig?.runnableFilePath())
+    }
+
+    @Test
+    fun roundTripWithFilter() {
+        val root = Element("ROOT")
+
+        val options = Options()
+        options.elmFolder = "folder"
+        options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from("Foo.elm", "foo", filter = "bar")
 
         writeOptions(options, root)
         val options2 = readOptions(root)
 
         assertEquals(options.elmFolder, options2.elmFolder)
-        assertEquals(options.testFile, options2.testFile)
-        assertEquals(options.testFile?.runnableFilePath(), options2.testFile?.runnableFilePath())
+        assertEquals(options.filteredTestConfig, options2.filteredTestConfig)
+        assertEquals(options.filteredTestConfig?.runnableFilePath(), options2.filteredTestConfig?.runnableFilePath())
+        assertEquals(options.filteredTestConfig?.filter, options2.filteredTestConfig?.filter)
     }
 
     @Test
@@ -110,8 +150,8 @@ class ElmTestRunConfigurationTest {
         val options2 = readOptions(root)
 
         assertEquals(options.elmFolder, options2.elmFolder)
-        assertEquals(options.testFile, options2.testFile)
-        assertEquals(options.testFile?.runnableFilePath(), options2.testFile?.runnableFilePath())
+        assertEquals(options.filteredTestConfig, options2.filteredTestConfig)
+        assertEquals(options.filteredTestConfig?.runnableFilePath(), options2.filteredTestConfig?.runnableFilePath())
     }
 
 }
\ No newline at end of file
diff --git a/src/test/kotlin/org/elm/workspace/ElmTestRunConfigurationSettingsBuilderTest.kt b/src/test/kotlin/org/elm/workspace/ElmTestRunConfigurationSettingsBuilderTest.kt
new file mode 100644
index 00000000..b811cafe
--- /dev/null
+++ b/src/test/kotlin/org/elm/workspace/ElmTestRunConfigurationSettingsBuilderTest.kt
@@ -0,0 +1,58 @@
+package org.elm.workspace
+
+import org.elm.FileTree
+import org.elm.ide.test.run.ElmTestRunConfigurationSettingsBuilder
+import org.elm.fileTree
+import org.elm.ide.test.run.ElmTestRunConfiguration
+
+class ElmTestRunConfigurationSettingsBuilderTest : ElmWorkspaceTestBase() {
+    fun `test createAndRegisterFromElement with test file`() {
+        val projectStructure = createProjectStructure()
+
+        val testProject = projectStructure.create(project, elmWorkspaceDirectory)
+        val psiElement = testProject.psiFile("tests/ExampleTest.elm")
+
+        val configSettings = ElmTestRunConfigurationSettingsBuilder.createAndRegisterFromElement(psiElement)
+
+        assertNotNull(configSettings)
+        val config = configSettings.configuration as ElmTestRunConfiguration
+
+        assertEquals(true, config.options.filteredTestConfig?.filePath?.contains("tests/ExampleTest.elm"))
+        assertEquals(false, config.options.filteredTestConfig?.testIsDirectory)
+        assertEquals(null, config.options.filteredTestConfig?.filter)
+        assertEquals(true, config.options.filteredTestConfig?.runnableFilePath()?.contains("tests/ExampleTest.elm"))
+    }
+
+    fun `test createAndRegisterFromElement with filter`() {
+        val projectStructure = createProjectStructure()
+
+        val testProject = projectStructure.create(project, elmWorkspaceDirectory)
+        val psiElement = testProject.psiFile("tests/ExampleTest.elm")
+
+        val configSettings = ElmTestRunConfigurationSettingsBuilder.createAndRegisterFromElement(psiElement, "my test")
+
+        assertNotNull(configSettings)
+        val config = configSettings.configuration as ElmTestRunConfiguration
+
+        assertEquals(true, config.options.filteredTestConfig?.filePath?.contains("tests/ExampleTest.elm"))
+        assertEquals(false, config.options.filteredTestConfig?.testIsDirectory)
+        assertEquals("my test", config.options.filteredTestConfig?.filter)
+        assertEquals(true, config.options.filteredTestConfig?.runnableFilePath()?.contains("tests/ExampleTest.elm"))
+    }
+
+    private fun createProjectStructure(): FileTree {
+        return fileTree {
+            dir("tests") {
+                elm(
+                    "ExampleTest.elm", """
+                module ExampleTest exposing (..)
+                import Test exposing (test)
+                foo = test "my test" <| \_ -> Expect.equal 1 1
+                bar = test "my second test" <| \_ -> Expect.equal 1 1
+                --^
+            """.trimIndent()
+                )
+            }
+        }
+    }
+}
\ No newline at end of file

From 7338a02ebac65bb6009c0a19b2561e50f2084305 Mon Sep 17 00:00:00 2001
From: Nate Brunette <n@tebru.net>
Date: Wed, 16 Jul 2025 13:03:18 -0500
Subject: [PATCH 4/8] Adding checkbox to enable elm-test-rs

---
 .../ElmTestDescribeLineMarkerProvider.kt      |  2 +-
 .../lineMarkers/ElmTestLineMarkerProvider.kt  |  8 ++++
 .../ElmTestSingleLineMarkerProvider.kt        |  2 +-
 .../run/ElmTestRunConfigurationProducer.kt    |  5 +-
 .../ide/test/run/ElmTestRunProfileState.kt    |  7 ++-
 .../elm/ide/test/run/ElmTestSettingsEditor.kt |  4 ++
 .../kotlin/org/elm/workspace/ElmToolchain.kt  | 15 ++++--
 .../org/elm/workspace/ElmWorkspaceService.kt  | 16 +++++++
 .../workspace/commandLineTools/ElmTestCLI.kt  | 22 +++++----
 .../workspace/ui/ElmWorkspaceConfigurable.kt  | 46 ++++++++++++++-----
 .../ElmTestTestLineMarkerProviderTest.kt      | 45 +++++++++++++++++-
 .../org/elm/workspace/ElmToolchainTest.kt     | 10 ++--
 12 files changed, 148 insertions(+), 34 deletions(-)

diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
index ad69499e..a0aeb856 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
@@ -18,7 +18,7 @@ class ElmTestDescribeLineMarkerProvider : ElmTestLineMarkerProvider() {
      * Add gutter icons for the describe line
      */
     override fun shouldAddGutterIcon(element: PsiElement): Boolean {
-        return element.text == "describe"
+        return usingElmTestRs(element.project) && element.text == "describe"
     }
 
     override fun getLineMarkerInfo(element: PsiElement): LineMarkerInfo<*>? {
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
index 937dbc58..9d59a297 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
@@ -6,11 +6,15 @@ import com.intellij.codeInsight.daemon.LineMarkerProvider
 import com.intellij.ide.DataManager
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.DefaultActionGroup
+import com.intellij.openapi.components.service
 import com.intellij.openapi.editor.markup.GutterIconRenderer
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.popup.JBPopupFactory
 import com.intellij.psi.PsiElement
 import com.intellij.ui.awt.RelativePoint
 import com.intellij.util.FunctionUtil
+import org.elm.workspace.ElmWorkspaceService
+import org.elm.workspace.elmToolchain
 import java.awt.event.MouseEvent
 import javax.swing.Icon
 
@@ -52,6 +56,10 @@ abstract class ElmTestLineMarkerProvider : LineMarkerProvider {
         return element.containingFile.text.contains("import Test exposing")
     }
 
+    protected fun usingElmTestRs(project: Project): Boolean {
+        return project.elmToolchain.isElmTestRsEnabled
+    }
+
     /**
      * Create a gutter icon on a given line with an icon, tooltip, and list of popup actions
      */
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
index 34d63796..d7937828 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
@@ -18,7 +18,7 @@ class ElmTestSingleLineMarkerProvider : ElmTestLineMarkerProvider() {
      * Add gutter icons for the test line
      */
     override fun shouldAddGutterIcon(element: PsiElement): Boolean {
-        return element.text == "test"
+        return usingElmTestRs(element.project) && element.text == "test"
     }
 
     override fun getLineMarkerInfo(element: PsiElement): LineMarkerInfo<*>? {
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
index 8d17bc52..8b97ff74 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
@@ -5,6 +5,7 @@ import com.intellij.execution.actions.LazyRunConfigurationProducer
 import com.intellij.openapi.util.Ref
 import com.intellij.psi.PsiElement
 import org.elm.ide.test.core.ElmTestElementNavigator
+import org.elm.workspace.elmToolchain
 import org.elm.workspace.elmWorkspace
 
 class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunConfiguration>() {
@@ -17,7 +18,7 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
         val vfile = context.location?.virtualFile
 
         configuration.options.elmFolder = elmFolder
-        if (vfile != null) {
+        if (vfile != null && context.project.elmToolchain.isElmTestRsEnabled) {
             val filter = ElmTestElementNavigator.findTestDescription(context.psiLocation)
             configuration.options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from(sourceElement.get(), filter)
         }
@@ -30,7 +31,7 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
     override fun isConfigurationFromContext(configuration: ElmTestRunConfiguration, context: ConfigurationContext): Boolean {
         val elmFolder = getCandidateElmFolder(context) ?: return false
         val vfile = context.location?.virtualFile
-        val filter = ElmTestElementNavigator.findTestDescription(context.psiLocation)
+        val filter = if (context.project.elmToolchain.isElmTestRsEnabled) ElmTestElementNavigator.findTestDescription(context.psiLocation) else null
 
         return configuration.options.elmFolder == elmFolder
                 && configuration.options.filteredTestConfig?.filePath == vfile?.path
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
index 345546b6..84ba8aa2 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
@@ -63,9 +63,14 @@ class ElmTestRunProfileState internal constructor(
             return handleBadConfiguration(project, "Could not find the Elm compiler ")
         }
 
+        if (toolchain.isElmTestRsEnabled) {
+            val version = elmTestCLI.queryVersion(project)
+            if (version is org.elm.openapiext.Result.Err) return handleBadConfiguration(project, version.reason)
+        }
+
         val filteredTest = (environment.runProfile as? ElmTestRunConfiguration)?.options?.filteredTestConfig
 
-        return elmTestCLI.runTestsProcessHandler(elmCompilerBinary, elmProject, filteredTest)
+        return elmTestCLI.runTestsProcessHandler(elmCompilerBinary, elmProject, filteredTest, toolchain.isElmTestRsEnabled)
     }
 
     @Throws(ExecutionException::class)
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
index c09821f4..ed7a6afa 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestSettingsEditor.kt
@@ -17,6 +17,7 @@ import com.intellij.openapi.options.SettingsEditor
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.ComboBox
 import org.elm.ide.test.core.ElmProjectTestsHelper
+import org.elm.workspace.elmToolchain
 import javax.swing.JComponent
 import javax.swing.JPanel
 import javax.swing.JTextField
@@ -27,9 +28,12 @@ class ElmTestSettingsEditor internal constructor(project: Project) : SettingsEdi
     private var projectChooser: ComboBox<String>? = null
     private var testFilePathField: JTextField? = null
     private var testFilter: JTextField? = null
+    private var isElmTestRsEnabled: Boolean = project.elmToolchain.isElmTestRsEnabled
 
     override fun createEditor(): JComponent {
         helper.allNames().forEach { projectChooser!!.addItem(it) }
+        testFilter?.setEnabled(isElmTestRsEnabled)
+
         return this.myPanel!!
     }
 
diff --git a/src/main/kotlin/org/elm/workspace/ElmToolchain.kt b/src/main/kotlin/org/elm/workspace/ElmToolchain.kt
index 0c58d8b8..b435eaaf 100644
--- a/src/main/kotlin/org/elm/workspace/ElmToolchain.kt
+++ b/src/main/kotlin/org/elm/workspace/ElmToolchain.kt
@@ -14,24 +14,29 @@ const val elmCompilerTool = "elm"
 const val lamderaCompilerTool = "lamdera"
 const val elmFormatTool = "elm-format"
 const val elmTestTool = "elm-test"
+const val elmTestRsTool = "elm-test-rs"
 const val elmReviewTool = "elm-review"
-val elmTools = listOf(elmCompilerTool, lamderaCompilerTool, elmFormatTool, elmTestTool, elmReviewTool)
+val elmTools = listOf(elmCompilerTool, lamderaCompilerTool, elmFormatTool, elmTestTool, elmTestRsTool, elmReviewTool)
 
 data class ElmToolchain(
         val elmCompilerPath: Path?,
         val lamderaCompilerPath: Path?,
         val elmFormatPath: Path?,
         val elmTestPath: Path?,
+        val elmTestRsPath: Path?,
         val elmReviewPath: Path?,
+        val isElmTestRsEnabled: Boolean,
         val isElmFormatOnSaveEnabled: Boolean
 ) {
-    constructor(elmCompilerPath: String, lamderaCompilerPath: String, elmFormatPath: String, elmTestPath: String, elmReviewPath: String, isElmFormatOnSaveEnabled: Boolean) :
+    constructor(elmCompilerPath: String, lamderaCompilerPath: String, elmFormatPath: String, elmTestPath: String, elmTestRsPath: String, elmReviewPath: String, isElmTestRsEnabled: Boolean, isElmFormatOnSaveEnabled: Boolean) :
             this(
                     if (elmCompilerPath.isNotBlank() && Files.exists(Paths.get(elmCompilerPath))) Paths.get(elmCompilerPath) else null,
                     if (lamderaCompilerPath.isNotBlank() && Files.exists(Paths.get(lamderaCompilerPath))) Paths.get(lamderaCompilerPath) else null,
                     if (elmFormatPath.isNotBlank() && Files.exists(Paths.get(elmFormatPath))) Paths.get(elmFormatPath) else null,
                     if (elmTestPath.isNotBlank() && Files.exists(Paths.get(elmTestPath))) Paths.get(elmTestPath) else null,
+                    if (elmTestRsPath.isNotBlank() && Files.exists(Paths.get(elmTestRsPath))) Paths.get(elmTestRsPath) else null,
                     if (elmReviewPath.isNotBlank() && Files.exists(Paths.get(elmReviewPath))) Paths.get(elmReviewPath) else null,
+                    isElmTestRsEnabled,
                     isElmFormatOnSaveEnabled
             )
 
@@ -41,7 +46,7 @@ data class ElmToolchain(
 
     val elmFormatCLI: ElmFormatCLI? = elmFormatPath?.let { ElmFormatCLI(it) }
 
-    val elmTestCLI: ElmTestCLI? = elmTestPath?.let { ElmTestCLI(it) }
+    val elmTestCLI: ElmTestCLI? = if (isElmTestRsEnabled) elmTestRsPath?.let { ElmTestCLI(it) } else elmTestPath?.let { ElmTestCLI(it) }
 
     val elmReviewCLI: ElmReviewCLI? = elmReviewPath?.let { ElmReviewCLI(it) }
 
@@ -72,6 +77,7 @@ data class ElmToolchain(
                 lamderaCompilerPath = lamderaCompilerPath ?: suggestions[lamderaCompilerTool],
                 elmFormatPath = elmFormatPath ?: suggestions[elmFormatTool],
                 elmTestPath = elmTestPath ?: suggestions[elmTestTool],
+                elmTestRsPath = elmTestRsPath ?: suggestions[elmTestRsTool],
                 elmReviewPath = elmReviewPath ?: suggestions[elmReviewTool]
         )
     }
@@ -89,6 +95,7 @@ data class ElmToolchain(
          */
         const val SIDECAR_FILENAME = "elm.intellij.json"
 
+        const val DEFAULT_ELM_TEST_RS = false
         const val DEFAULT_FORMAT_ON_SAVE = true
 
         /**
@@ -99,7 +106,9 @@ data class ElmToolchain(
                 lamderaCompilerPath = null,
                 elmFormatPath = null,
                 elmTestPath = null,
+                elmTestRsPath = null,
                 elmReviewPath = null,
+                isElmTestRsEnabled = DEFAULT_ELM_TEST_RS,
                 isElmFormatOnSaveEnabled = DEFAULT_FORMAT_ON_SAVE
         )
 
diff --git a/src/main/kotlin/org/elm/workspace/ElmWorkspaceService.kt b/src/main/kotlin/org/elm/workspace/ElmWorkspaceService.kt
index 5eb897b9..03e9e48e 100644
--- a/src/main/kotlin/org/elm/workspace/ElmWorkspaceService.kt
+++ b/src/main/kotlin/org/elm/workspace/ElmWorkspaceService.kt
@@ -34,6 +34,7 @@ import org.elm.openapiext.*
 import org.elm.utils.MyDirectoryIndex
 import org.elm.utils.joinAll
 import org.elm.utils.runAsyncTask
+import org.elm.workspace.ElmToolchain.Companion.DEFAULT_ELM_TEST_RS
 import org.elm.workspace.ElmToolchain.Companion.DEFAULT_FORMAT_ON_SAVE
 import org.elm.workspace.ElmToolchain.Companion.ELM_JSON
 import org.elm.workspace.commandLineTools.ElmCLI
@@ -92,6 +93,8 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
         val lamderaCompilerPath: String = "",
         val elmFormatPath: String = "",
         val elmTestPath: String = "",
+        val elmTestRsPath: String = "",
+        val isElmTestRsEnabled: Boolean = DEFAULT_ELM_TEST_RS,
         val elmReviewPath: String = "",
         val isElmFormatOnSaveEnabled: Boolean = DEFAULT_FORMAT_ON_SAVE
     )
@@ -105,7 +108,9 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
                 lamderaCompilerPath = raw.lamderaCompilerPath,
                 elmFormatPath = raw.elmFormatPath,
                 elmTestPath = raw.elmTestPath,
+                elmTestRsPath = raw.elmTestRsPath,
                 elmReviewPath = raw.elmReviewPath,
+                isElmTestRsEnabled = raw.isElmTestRsEnabled,
                 isElmFormatOnSaveEnabled = raw.isElmFormatOnSaveEnabled
             )
             return Settings(toolchain = toolchain)
@@ -135,7 +140,9 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
                 lamderaCompilerPath = toolchain.lamderaCompilerPath.toString(),
                 elmFormatPath = toolchain.elmFormatPath.toString(),
                 elmTestPath = toolchain.elmTestPath.toString(),
+                elmTestRsPath = toolchain.elmTestRsPath.toString(),
                 elmReviewPath = toolchain.elmReviewPath.toString(),
+                isElmTestRsEnabled = toolchain.isElmTestRsEnabled,
                 isElmFormatOnSaveEnabled = toolchain.isElmFormatOnSaveEnabled
             )
         }
@@ -439,6 +446,8 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
         settingsElement.setAttribute("lamderaCompilerPath", raw.lamderaCompilerPath)
         settingsElement.setAttribute("elmFormatPath", raw.elmFormatPath)
         settingsElement.setAttribute("elmTestPath", raw.elmTestPath)
+        settingsElement.setAttribute("elmTestRsPath", raw.elmTestRsPath)
+        settingsElement.setAttribute("isElmTestRsEnabled", raw.isElmTestRsEnabled.toString())
         settingsElement.setAttribute("elmReviewPath", raw.elmReviewPath)
         settingsElement.setAttribute("isElmFormatOnSaveEnabled", raw.isElmFormatOnSaveEnabled.toString())
 
@@ -457,7 +466,12 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
         val lamderaCompilerPath = settingsElement.getAttributeValue("lamderaCompilerPath") ?: ""
         val elmFormatPath = settingsElement.getAttributeValue("elmFormatPath") ?: ""
         val elmTestPath = settingsElement.getAttributeValue("elmTestPath") ?: ""
+        val elmTestRsPath = settingsElement.getAttributeValue("elmTestRsPath") ?: ""
         val elmReviewPath = settingsElement.getAttributeValue("elmReviewPath") ?: ""
+        val isElmTestRsEnabled = settingsElement
+            .getAttributeValue("isElmTestRsEnabled")
+            .takeIf { it != null && it.isNotBlank() }?.toBoolean()
+            ?: DEFAULT_ELM_TEST_RS
         val isElmFormatOnSaveEnabled = settingsElement
             .getAttributeValue("isElmFormatOnSaveEnabled")
             .takeIf { it != null && it.isNotBlank() }?.toBoolean()
@@ -469,6 +483,8 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
                 lamderaCompilerPath = lamderaCompilerPath,
                 elmFormatPath = elmFormatPath,
                 elmTestPath = elmTestPath,
+                elmTestRsPath = elmTestRsPath,
+                isElmTestRsEnabled = isElmTestRsEnabled,
                 elmReviewPath = elmReviewPath,
                 isElmFormatOnSaveEnabled = isElmFormatOnSaveEnabled
             )
diff --git a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
index ee5c9c76..270d0276 100644
--- a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
+++ b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
@@ -7,14 +7,16 @@ import com.intellij.execution.process.ProcessHandler
 import com.intellij.openapi.diagnostic.debug
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.project.Project
-import org.elm.ide.test.run.ElmTestRunConfiguration
+import org.elm.ide.test.run.ElmTestRunConfiguration.FilteredTest
 import org.elm.openapiext.GeneralCommandLine
 import org.elm.openapiext.Result
 import org.elm.openapiext.execute
 import org.elm.workspace.ElmProject
 import org.elm.workspace.ParseException
 import org.elm.workspace.Version
+import org.elm.workspace.elmTestRsTool
 import org.elm.workspace.elmTestTool
+import org.elm.workspace.elmToolchain
 import java.nio.file.Path
 
 private val log = logger<ElmTestCLI>()
@@ -32,24 +34,24 @@ class ElmTestCLI(private val executablePath: Path) {
      * @param elmCompilerPath The path to the Elm compiler.
      * @param elmProject The [ElmProject] containing the tests to be run.
      */
-    fun runTestsProcessHandler(elmCompilerPath: Path, elmProject: ElmProject, filteredTest: ElmTestRunConfiguration.FilteredTest?): ProcessHandler {
+    fun runTestsProcessHandler(elmCompilerPath: Path, elmProject: ElmProject, filteredTest: FilteredTest?, isElmTestRsEnabled: Boolean): ProcessHandler {
         val commandLine = GeneralCommandLine(executablePath.toString(), "--report=json")
                 .withWorkDirectory(elmProject.projectDirPath.toString())
                 .withParameters("--compiler", elmCompilerPath.toString())
                 .withRedirectErrorStream(true)
                 .withParentEnvironmentType(GeneralCommandLine.ParentEnvironmentType.CONSOLE)
 
-        // By default elm-test will process tests in a folder called "tests", under the current working directory
-        // (in this case elmProject.projectDirPath). If the project has a custom location for tests we need to supply a
-        // path to that folder.
         if (filteredTest != null) {
             log.debug { """Test file or directory was provided: "${elmProject.testsRelativeDirPath}". Will specify this path as argument to elm-test.""" }
 
-            if (!filteredTest.filter.isNullOrBlank()) {
+            if (isElmTestRsEnabled && !filteredTest.filter.isNullOrBlank()) {
                 commandLine.withParameters("--filter", filteredTest.filter)
             }
 
             commandLine.withParameters(filteredTest.runnableFilePath())
+        // By default elm-test will process tests in a folder called "tests", under the current working directory
+        // (in this case elmProject.projectDirPath). If the project has a custom location for tests we need to supply a
+        // path to that folder.
         } else if (elmProject.isCustomTestsDir) {
             log.debug { """Tests are in custom location: "${elmProject.testsRelativeDirPath}". Will specify this path as argument to elm-test.""" }
             commandLine.withParameters(elmProject.testsRelativeDirPath)
@@ -62,11 +64,13 @@ class ElmTestCLI(private val executablePath: Path) {
 
 
     fun queryVersion(project: Project): Result<Version> {
+        val tool = if (project.elmToolchain.isElmTestRsEnabled) elmTestRsTool else elmTestTool
+
         // Output of `elm-test --version` is a single line containing the version number,
         // e.g. `0.19.0-beta9\n`, trimming off the "-betaN" suffix, if present.
         val firstLine = try {
             GeneralCommandLine(executablePath).withParameters("--version")
-                    .execute(elmTestTool, project)
+                    .execute(tool, project)
                     .stdoutLines
                     .firstOrNull()
         } catch (e: ExecutionException) {
@@ -77,7 +81,9 @@ class ElmTestCLI(private val executablePath: Path) {
             return Result.Err("no output from elm-test")
         }
 
-        val trimmedFirstLine = if (firstLine.startsWith("elm-test-rs")) {
+        val trimmedFirstLine = if (project.elmToolchain.isElmTestRsEnabled) {
+            if (!firstLine.contains("elm-test-rs")) return Result.Err("Could not parse elm-test-rs version: $firstLine")
+
             firstLine.removePrefix("elm-test-rs").trim()
         } else {
             firstLine.takeWhile { it != '-' }
diff --git a/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt b/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
index 92dd349e..594f2ab7 100644
--- a/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
+++ b/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
@@ -59,9 +59,14 @@ class ElmWorkspaceConfigurable(
     private val elmFormatOnSaveCheckbox = JCheckBox()
     private val elmFormatShortcutLabel = HyperlinkLabel()
     private val elmTestVersionLabel = JLabel()
+    private val elmTestRsCheckbox = JCheckBox()
     private val elmReviewVersionLabel = JLabel()
 
     override fun createComponent(): JComponent {
+        elmTestRsCheckbox.addChangeListener {
+            elmTestPathField.text = autoDiscoverPathTo(elmTestTool())
+            update()
+        }
         elmFormatOnSaveCheckbox.addChangeListener { update() }
         elmFormatShortcutLabel.addHyperlinkListener {
             showActionShortcut(ElmExternalFormatAction.ID)
@@ -69,25 +74,26 @@ class ElmWorkspaceConfigurable(
 
         val panel = layout {
             block("Elm Compiler") {
-                row("Location:", pathFieldPlusAutoDiscoverButton(elmPathField, elmCompilerTool))
+                row("Location:", pathFieldPlusAutoDiscoverButton(elmPathField) { elmCompilerTool })
                 row("Version:", elmVersionLabel)
             }
             block(elmFormatTool) {
-                row("Location:", pathFieldPlusAutoDiscoverButton(elmFormatPathField, elmFormatTool))
+                row("Location:", pathFieldPlusAutoDiscoverButton(elmFormatPathField) { elmFormatTool })
                 row("Version:", elmFormatVersionLabel)
                 row("Keyboard shortcut:", elmFormatShortcutLabel)
                 row("Run when file saved?", elmFormatOnSaveCheckbox)
             }
             block(elmTestTool) {
-                row("Location:", pathFieldPlusAutoDiscoverButton(elmTestPathField, elmTestTool))
+                row("Location:", pathFieldPlusAutoDiscoverButton(elmTestPathField) { elmTestTool() })
                 row("Version:", elmTestVersionLabel)
+                row("Use elm-test-rs?:", elmTestRsCheckbox)
             }
             block(elmReviewTool) {
-                row("Location:", pathFieldPlusAutoDiscoverButton(elmReviewPathField, elmReviewTool))
+                row("Location:", pathFieldPlusAutoDiscoverButton(elmReviewPathField) { elmReviewTool })
                 row("Version:", elmReviewVersionLabel)
             }
             block("Lamdera Compiler") {
-                row("Location:", pathFieldPlusAutoDiscoverButton(lamderaPathField, lamderaCompilerTool))
+                row("Location:", pathFieldPlusAutoDiscoverButton(lamderaPathField) { lamderaCompilerTool })
                 row("Version:", lamderaVersionLabel)
             }
             block("") {
@@ -107,11 +113,11 @@ class ElmWorkspaceConfigurable(
         return panel
     }
 
-    private fun pathFieldPlusAutoDiscoverButton(field: TextFieldWithBrowseButton, executableName: String): JPanel {
+    private fun pathFieldPlusAutoDiscoverButton(field: TextFieldWithBrowseButton, getExecutableName: () -> String): JPanel {
         val panel = JPanel().apply { layout = BoxLayout(this, BoxLayout.X_AXIS) }
         with(panel) {
             add(field)
-            add(JButton("Auto Discover").apply { addActionListener { field.text = autoDiscoverPathTo(executableName) } })
+            add(JButton("Auto Discover").apply { addActionListener { field.text = autoDiscoverPathTo(getExecutableName()) } })
         }
         return panel
     }
@@ -127,6 +133,11 @@ class ElmWorkspaceConfigurable(
             keymapPanel.selectAction(actionId)
         }
     }
+
+    fun elmTestTool(): String {
+        return if (isElmTestRsEnabledAndSelected()) elmTestRsTool else elmTestTool
+    }
+
     data class Results(
             val compilerResult: Result<Version>,
             val lamderaResult: Result<Version>,
@@ -242,7 +253,7 @@ class ElmWorkspaceConfigurable(
                             }
                             is Result.Err -> {
                                 when {
-                                    !elmTestPath.isValidFor(elmTestTool) -> {
+                                    !elmTestPath.isValidFor(elmTestTool()) -> {
                                         text = ""
                                         foreground = JBColor.foreground()
                                     }
@@ -302,6 +313,8 @@ class ElmWorkspaceConfigurable(
         val elmFormatPath = settings?.elmFormatPath
         val isElmFormatOnSaveEnabled = settings?.isElmFormatOnSaveEnabled
         val elmTestPath = settings?.elmTestPath
+        val elmTestRsPath = settings?.elmTestRsPath
+        val isElmTestRsEnabled = settings?.isElmTestRsEnabled
         val elmReviewPath = settings?.elmReviewPath
 
         if (elmCompilerPath != null) {
@@ -314,9 +327,13 @@ class ElmWorkspaceConfigurable(
             elmFormatPathField.text = elmFormatPath
         }
         elmFormatOnSaveCheckbox.isSelected = isElmFormatOnSaveEnabled == true
-        if (elmTestPath != null) {
+        if (elmTestPath != null && (isElmTestRsEnabled == null || !isElmTestRsEnabled)) {
             elmTestPathField.text = elmTestPath
         }
+        if (elmTestRsPath != null && isElmTestRsEnabled == true) {
+            elmTestPathField.text = elmTestRsPath
+        }
+        elmTestRsCheckbox.isSelected = isElmTestRsEnabled == true
         if (elmReviewPath != null) {
             elmReviewPathField.text = elmReviewPath
         }
@@ -329,23 +346,30 @@ class ElmWorkspaceConfigurable(
             it.copy(elmCompilerPath = elmPathField.text,
                     lamderaCompilerPath = lamderaPathField.text,
                     elmFormatPath = elmFormatPathField.text,
-                    elmTestPath = elmTestPathField.text,
+                    elmTestPath = if (isElmTestRsEnabledAndSelected()) "" else elmTestPathField.text,
+                    elmTestRsPath = if (isElmTestRsEnabledAndSelected()) elmTestPathField.text else "",
                     elmReviewPath = elmReviewPathField.text,
+                    isElmTestRsEnabled = isElmTestRsEnabledAndSelected(),
                     isElmFormatOnSaveEnabled = isOnSaveHookEnabledAndSelected()
             )
         }
     }
+    private fun isElmTestRsEnabledAndSelected() =
+        elmTestRsCheckbox.isEnabled && elmTestRsCheckbox.isSelected
 
     private fun isOnSaveHookEnabledAndSelected() =
             elmFormatOnSaveCheckbox.isEnabled && elmFormatOnSaveCheckbox.isSelected
 
     override fun isModified(): Boolean {
         val settings = project.elmWorkspace.rawSettings
+        val isElmTestPathModified = if (isElmTestRsEnabledAndSelected()) elmTestPathField.text != settings?.elmTestRsPath else elmTestPathField.text != settings?.elmTestPath
+
         return elmPathField.text != settings?.elmCompilerPath
                 || lamderaPathField.text != settings.lamderaCompilerPath
                 || elmFormatPathField.text != settings.elmFormatPath
-                || elmTestPathField.text != settings.elmTestPath
+                || isElmTestPathModified
                 || elmReviewPathField.text != settings.elmReviewPath
+                || isElmTestRsEnabledAndSelected() != settings.isElmTestRsEnabled
                 || isOnSaveHookEnabledAndSelected() != settings.isElmFormatOnSaveEnabled
     }
 
diff --git a/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
index 46ab6646..a681ff37 100644
--- a/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
+++ b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
@@ -1,14 +1,52 @@
 package org.elm.ide.lineMarkers
 
+import org.elm.workspace.ElmToolchain
+import org.elm.workspace.elmWorkspace
 import org.junit.Test
 
 
 class ElmTestTestLineMarkerProviderTest : ElmLineMarkerProviderTestBase() {
+    fun withElmTestRsEnabled(enabled: Boolean, test: () -> Unit) {
+        val toolchain = ElmToolchain(
+            elmCompilerPath = "",
+            lamderaCompilerPath = "",
+            elmFormatPath = "",
+            elmTestPath = "",
+            elmTestRsPath = "",
+            elmReviewPath = "",
+            isElmTestRsEnabled = enabled,
+            isElmFormatOnSaveEnabled = false
+        )
 
+        project.elmWorkspace.useToolchain(toolchain)
+
+        test()
+    }
 
     @Test
-    fun `test test module properly adds markers`() = doTestByText(
+    fun `test with elm-test properly adds markers`() {
+        withElmTestRsEnabled(false) {
+            doTestByText(
+                """
+module Main --> Run all tests in this module
+
+import Test exposing (..)
+
+myTest : Test
+myTest =
+    describe "my test"
+        [ test "1 == 1" <| \_ -> Expect.equal 1 1
+        ]
             """
+            )
+        }
+    }
+
+    @Test
+    fun `test with elm-test-rs properly adds markers`() {
+        withElmTestRsEnabled(true) {
+            doTestByText(
+                """
 module Main --> Run all tests in this module
 
 import Test exposing (..)
@@ -18,8 +56,11 @@ myTest =
     describe "my test" --> Run describe
         [ test "1 == 1" <| \_ -> Expect.equal 1 1 --> Run test
         ]
+            """
+            )
+        }
+    }
 
-""")
 
     @Test
     fun `test non-test module can't run tests`() = doTestByText(
diff --git a/src/test/kotlin/org/elm/workspace/ElmToolchainTest.kt b/src/test/kotlin/org/elm/workspace/ElmToolchainTest.kt
index 742eec22..1a4e52aa 100644
--- a/src/test/kotlin/org/elm/workspace/ElmToolchainTest.kt
+++ b/src/test/kotlin/org/elm/workspace/ElmToolchainTest.kt
@@ -10,34 +10,34 @@ class ElmToolchainTest {
     @Test
     fun `looksLikeValidToolchain allows an executable file`() {
         val rawElmPath = Paths.get(ClassLoader.getSystemResource("org/elm/workspace/fixtures/elm-executable").toURI())
-        val toolchain = ElmToolchain(rawElmPath, null, null, null, null, false)
+        val toolchain = ElmToolchain(rawElmPath, null, null, null, null, null, false, false)
         assertTrue(toolchain.looksLikeValidToolchain())
     }
 
     @Test
     fun `looksLikeValidToolchain does not allow a non-executable file`() {
         val rawElmPath = Paths.get(ClassLoader.getSystemResource("org/elm/workspace/fixtures/non-executable").toURI())
-        val toolchain = ElmToolchain(rawElmPath, null, null, null,null, false)
+        val toolchain = ElmToolchain(rawElmPath, null, null, null, null, null, false, false)
         assertFalse(toolchain.looksLikeValidToolchain())
     }
 
     @Test
     fun `looksLikeValidToolchain allows bare elm if it is on the path`() {
         val pathSearchLocation = Paths.get(ClassLoader.getSystemResource("org/elm/workspace/fixtures/PATH").toURI())
-        val toolchain = ElmToolchain(Paths.get("elm"), null, null, null, null, false)
+        val toolchain = ElmToolchain(Paths.get("elm"), null, null, null, null, null, false, false)
         assertTrue(toolchain.looksLikeValidToolchain(sequenceOf(pathSearchLocation)))
     }
 
     @Test
     fun `looksLikeValidToolchain does not allow bare elm if it is not on the path`() {
         val pathSearchLocation = Paths.get(ClassLoader.getSystemResource("org/elm/workspace/fixtures/NOT_PATH").toURI())
-        val toolchain = ElmToolchain(Paths.get("elm"), null, null, null, null, false)
+        val toolchain = ElmToolchain(Paths.get("elm"), null, null, null, null, null, false, false)
         assertFalse(toolchain.looksLikeValidToolchain(sequenceOf(pathSearchLocation)))
     }
 
     @Test
     fun `looksLikeValidToolchain does not allow an empty path`() {
-        val toolchain = ElmToolchain(null, null, null, null, null, false)
+        val toolchain = ElmToolchain(null, null, null, null, null, null, false, false)
         assertFalse(toolchain.looksLikeValidToolchain())
     }
 }

From 9960f3280ee9ab4bc30c20abe9a725d659f88625 Mon Sep 17 00:00:00 2001
From: Nate Brunette <n@tebru.net>
Date: Wed, 16 Jul 2025 13:23:46 -0500
Subject: [PATCH 5/8] code cleanup

---
 .../Run IDE for UI Tests.run.xml              |  7 ++----
 .../org/elm/ide/lineMarkers/ElmRunActions.kt  | 14 +++--------
 .../ElmTestDescribeLineMarkerProvider.kt      | 10 +++-----
 .../lineMarkers/ElmTestLineMarkerProvider.kt  | 25 ++++++-------------
 .../ElmTestModuleLineMarkerProvider.kt        | 10 +++-----
 .../ElmTestSingleLineMarkerProvider.kt        | 10 +++-----
 .../ide/test/core/ElmTestElementNavigator.kt  |  6 ++---
 .../ElmTestRunConfigurationSettingsBuilder.kt |  6 ++---
 .../workspace/ui/ElmWorkspaceConfigurable.kt  |  1 +
 .../test/core/ElmTestElementNavigatorTest.kt  |  2 +-
 .../test/run/ElmTestRunConfigurationTest.kt   |  2 +-
 ...TestRunConfigurationSettingsBuilderTest.kt |  2 +-
 12 files changed, 30 insertions(+), 65 deletions(-)

diff --git a/.idea/runConfigurations/Run IDE for UI Tests.run.xml b/.idea/runConfigurations/Run IDE for UI Tests.run.xml
index ee99b7ed..9b028c30 100644
--- a/.idea/runConfigurations/Run IDE for UI Tests.run.xml	
+++ b/.idea/runConfigurations/Run IDE for UI Tests.run.xml	
@@ -5,21 +5,18 @@
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
       <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
+      <option name="scriptParameters" value="runIdeForUiTests" />
       <option name="taskDescriptions">
         <list />
       </option>
       <option name="taskNames">
-        <list>
-          <option value="runIdeForUiTests" />
-        </list>
+        <list />
       </option>
       <option name="vmOptions" />
     </ExternalSystemSettings>
     <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
     <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
     <DebugAllEnabled>false</DebugAllEnabled>
-    <RunAsTest>false</RunAsTest>
     <method v="2" />
   </configuration>
 </component>
\ No newline at end of file
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
index ba1468bd..605ed07d 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmRunActions.kt
@@ -10,9 +10,7 @@ import com.intellij.psi.PsiElement
 import org.elm.ide.test.run.ElmTestRunConfiguration
 import org.elm.ide.test.run.ElmTestRunConfigurationSettingsBuilder
 
-/**
- * Action to run all tests for a given file or directory
- */
+/** * Action to run all tests for a given file or directory */
 class RunAllTestsAction(private val element: PsiElement) : AnAction("Run All Tests") {
     override fun actionPerformed(event: AnActionEvent) {
         ProgramRunnerUtil.executeConfiguration(
@@ -22,9 +20,7 @@ class RunAllTestsAction(private val element: PsiElement) : AnAction("Run All Tes
     }
 }
 
-/**
- * Action to run a test filtered by test or describe description
- */
+/** * Action to run a test filtered by test or describe description */
 class RunFilteredTestAction(private val element: PsiElement, private val filter: String) : AnAction("Run Filtered Test") {
     override fun actionPerformed(event: AnActionEvent) {
         ProgramRunnerUtil.executeConfiguration(
@@ -34,9 +30,7 @@ class RunFilteredTestAction(private val element: PsiElement, private val filter:
     }
 }
 
-/**
- * Creates a run configuration and opens editor
- */
+/** * Creates a run configuration and opens editor */
 class ModifyRunConfiguration(private val element: PsiElement, private val filter: String? = null) : AnAction("Modify Run Configuration") {
     override fun actionPerformed(event: AnActionEvent) {
         ShowSettingsUtil.getInstance().editConfigurable(
@@ -47,4 +41,4 @@ class ModifyRunConfiguration(private val element: PsiElement, private val filter
             )
         )
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
index a0aeb856..b00c27a3 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
@@ -6,17 +6,13 @@ import com.intellij.psi.PsiElement
 import org.elm.ide.icons.ElmIcons
 import org.elm.ide.test.core.ElmTestElementNavigator
 
-/**
- * Handles adding a gutter icon for running tests under a describe
- */
+/** Handles adding a gutter icon for running tests under a describe */
 class ElmTestDescribeLineMarkerProvider : ElmTestLineMarkerProvider() {
     companion object {
         val OPTION = GutterIconDescriptor.Option("elm.testDescribe", "Test describe", ElmIcons.RUN)
     }
 
-    /**
-     * Add gutter icons for the describe line
-     */
+    /** Add gutter icons for the describe line */
     override fun shouldAddGutterIcon(element: PsiElement): Boolean {
         return usingElmTestRs(element.project) && element.text == "describe"
     }
@@ -29,7 +25,7 @@ class ElmTestDescribeLineMarkerProvider : ElmTestLineMarkerProvider() {
             element,
             ElmIcons.RUN,
             "Run describe",
-            listOf(RunFilteredTestAction(element, filter), ModifyRunConfiguration(element, filter))
+            listOf(RunFilteredTestAction(element, filter), ModifyRunConfiguration(element, filter)),
         )
     }
 }
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
index 9d59a297..a2582421 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
@@ -6,25 +6,19 @@ import com.intellij.codeInsight.daemon.LineMarkerProvider
 import com.intellij.ide.DataManager
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.DefaultActionGroup
-import com.intellij.openapi.components.service
 import com.intellij.openapi.editor.markup.GutterIconRenderer
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.popup.JBPopupFactory
 import com.intellij.psi.PsiElement
 import com.intellij.ui.awt.RelativePoint
 import com.intellij.util.FunctionUtil
-import org.elm.workspace.ElmWorkspaceService
 import org.elm.workspace.elmToolchain
 import java.awt.event.MouseEvent
 import javax.swing.Icon
 
-/**
- * Abstract class to handle common operations for all test marker classes
- */
+/** * Abstract class to handle common operations for all test marker classes */
 abstract class ElmTestLineMarkerProvider : LineMarkerProvider {
-    /**
-     * Create a popup with a list of given actions
-     */
+    /** * Create a popup with a list of given actions */
     private class PopupHandler(val actions: List<AnAction>) : GutterIconNavigationHandler<PsiElement> {
         override fun navigate(e: MouseEvent, elt: PsiElement) {
             val group = DefaultActionGroup().apply {
@@ -44,25 +38,20 @@ abstract class ElmTestLineMarkerProvider : LineMarkerProvider {
         }
     }
 
-    /**
-     * Returns true if the line should contain a gutter icon for the type of marker
-     */
+    /** * Returns true if the line should contain a gutter icon for the type of marker */
     abstract fun shouldAddGutterIcon(element: PsiElement): Boolean
 
-    /**
-     * Returns true if the file contains tests
-     */
+    /** * Returns true if the file contains tests */
     protected fun isTestFile(element: PsiElement): Boolean {
         return element.containingFile.text.contains("import Test exposing")
     }
 
+    /** Returns true if elm-test-rs is enabled */
     protected fun usingElmTestRs(project: Project): Boolean {
         return project.elmToolchain.isElmTestRsEnabled
     }
 
-    /**
-     * Create a gutter icon on a given line with an icon, tooltip, and list of popup actions
-     */
+    /** Create a gutter icon on a given line with an icon, tooltip, and list of popup actions */
     protected fun createLineMarkerInfo(element: PsiElement, icon: Icon, tooltip: String, actions: List<AnAction>, ): LineMarkerInfo<*>? {
         if (!isTestFile(element) || !shouldAddGutterIcon(element)) return null
 
@@ -75,4 +64,4 @@ abstract class ElmTestLineMarkerProvider : LineMarkerProvider {
             GutterIconRenderer.Alignment.LEFT
         ) { tooltip }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
index b633e0d6..21f64344 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestModuleLineMarkerProvider.kt
@@ -6,17 +6,13 @@ import com.intellij.psi.PsiElement
 import org.elm.ide.icons.ElmIcons
 import org.elm.lang.core.psi.ElmTypes
 
-/**
- * Handles adding a gutter icon for running all tests in a module
- */
+/** * Handles adding a gutter icon for running all tests in a module */
 class ElmTestModuleLineMarkerProvider : ElmTestLineMarkerProvider() {
     companion object {
         val OPTION = GutterIconDescriptor.Option("elm.testModule", "Test module", ElmIcons.RUN_ALL)
     }
 
-    /**
-     * Add gutter icons for the module line
-     */
+    /** * Add gutter icons for the module line */
     override fun shouldAddGutterIcon(element: PsiElement): Boolean {
         return element.node.elementType == ElmTypes.MODULE
     }
@@ -28,7 +24,7 @@ class ElmTestModuleLineMarkerProvider : ElmTestLineMarkerProvider() {
             element,
             ElmIcons.RUN_ALL,
             "Run all tests in this module",
-            listOf(RunAllTestsAction(element), ModifyRunConfiguration(element))
+            listOf(RunAllTestsAction(element), ModifyRunConfiguration(element)),
         )
     }
 }
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
index d7937828..76a67f41 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
@@ -6,17 +6,13 @@ import com.intellij.psi.PsiElement
 import org.elm.ide.icons.ElmIcons
 import org.elm.ide.test.core.ElmTestElementNavigator
 
-/**
- * Handles adding a gutter icon for running a specific test
- */
+/** * Handles adding a gutter icon for running a specific test */
 class ElmTestSingleLineMarkerProvider : ElmTestLineMarkerProvider() {
     companion object {
         val OPTION = GutterIconDescriptor.Option("elm.testSingle", "Test single", ElmIcons.RUN)
     }
 
-    /**
-     * Add gutter icons for the test line
-     */
+    /** * Add gutter icons for the test line */
     override fun shouldAddGutterIcon(element: PsiElement): Boolean {
         return usingElmTestRs(element.project) && element.text == "test"
     }
@@ -29,7 +25,7 @@ class ElmTestSingleLineMarkerProvider : ElmTestLineMarkerProvider() {
             element,
             ElmIcons.RUN,
             "Run test",
-            listOf(RunFilteredTestAction(element, filter), ModifyRunConfiguration(element, filter))
+            listOf(RunFilteredTestAction(element, filter), ModifyRunConfiguration(element, filter)),
         )
     }
 }
diff --git a/src/main/kotlin/org/elm/ide/test/core/ElmTestElementNavigator.kt b/src/main/kotlin/org/elm/ide/test/core/ElmTestElementNavigator.kt
index 1f427d06..4d4cc235 100644
--- a/src/main/kotlin/org/elm/ide/test/core/ElmTestElementNavigator.kt
+++ b/src/main/kotlin/org/elm/ide/test/core/ElmTestElementNavigator.kt
@@ -30,9 +30,7 @@ object ElmTestElementNavigator {
             ?.removeSurrounding("\"")
     }
 
-    /**
-     * Find the next parent function call given a list of target names
-     */
+    /** Find the next parent function call given a list of target names */
     private fun getFunctionCallExpr(element: PsiElement?, targets: List<String> = listOf("test", "describe")): ElmFunctionCallExpr? {
         var current = element
         while (current != null) {
@@ -47,4 +45,4 @@ object ElmTestElementNavigator {
         }
         return null
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
index 79489dd2..fd16e357 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationSettingsBuilder.kt
@@ -6,9 +6,7 @@ import com.intellij.psi.PsiElement
 import org.elm.workspace.elmWorkspace
 import kotlin.io.path.pathString
 
-/**
- * Helper object to create a run configuration and add it to the run manager. Returns the config settings.
- */
+/** * Helper object to create a run configuration and add it to the run manager. Returns the config settings. */
 object ElmTestRunConfigurationSettingsBuilder {
     fun createAndRegisterFromElement(element: PsiElement, filter: String? = null): RunnerAndConfigurationSettings {
         val project = element.project
@@ -28,4 +26,4 @@ object ElmTestRunConfigurationSettingsBuilder {
 
         return configSettings
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt b/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
index 594f2ab7..5ab25df3 100644
--- a/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
+++ b/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
@@ -354,6 +354,7 @@ class ElmWorkspaceConfigurable(
             )
         }
     }
+    
     private fun isElmTestRsEnabledAndSelected() =
         elmTestRsCheckbox.isEnabled && elmTestRsCheckbox.isSelected
 
diff --git a/src/test/kotlin/org/elm/ide/test/core/ElmTestElementNavigatorTest.kt b/src/test/kotlin/org/elm/ide/test/core/ElmTestElementNavigatorTest.kt
index 3efd27ad..4734a140 100644
--- a/src/test/kotlin/org/elm/ide/test/core/ElmTestElementNavigatorTest.kt
+++ b/src/test/kotlin/org/elm/ide/test/core/ElmTestElementNavigatorTest.kt
@@ -46,4 +46,4 @@ class ElmTestElementNavigatorTest : ElmTestBase() {
             ]
     """.trimIndent()
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt b/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
index d08f2345..d0142141 100644
--- a/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
+++ b/src/test/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationTest.kt
@@ -154,4 +154,4 @@ class ElmTestRunConfigurationTest {
         assertEquals(options.filteredTestConfig?.runnableFilePath(), options2.filteredTestConfig?.runnableFilePath())
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/test/kotlin/org/elm/workspace/ElmTestRunConfigurationSettingsBuilderTest.kt b/src/test/kotlin/org/elm/workspace/ElmTestRunConfigurationSettingsBuilderTest.kt
index b811cafe..51660b01 100644
--- a/src/test/kotlin/org/elm/workspace/ElmTestRunConfigurationSettingsBuilderTest.kt
+++ b/src/test/kotlin/org/elm/workspace/ElmTestRunConfigurationSettingsBuilderTest.kt
@@ -55,4 +55,4 @@ class ElmTestRunConfigurationSettingsBuilderTest : ElmWorkspaceTestBase() {
             }
         }
     }
-}
\ No newline at end of file
+}

From 9dee7a2674523f0cf443839f470a520b2556f7fc Mon Sep 17 00:00:00 2001
From: Nate Brunette <n@tebru.net>
Date: Wed, 16 Jul 2025 16:37:32 -0500
Subject: [PATCH 6/8] Fixing bug with running elm-test

---
 .../run/ElmTestRunConfigurationProducer.kt    | 21 ++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
index 8b97ff74..42345608 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
@@ -18,8 +18,8 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
         val vfile = context.location?.virtualFile
 
         configuration.options.elmFolder = elmFolder
-        if (vfile != null && context.project.elmToolchain.isElmTestRsEnabled) {
-            val filter = ElmTestElementNavigator.findTestDescription(context.psiLocation)
+        if (vfile != null) {
+            val filter = if (context.project.elmToolchain.isElmTestRsEnabled) ElmTestElementNavigator.findTestDescription(context.psiLocation) else null
             configuration.options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from(sourceElement.get(), filter)
         }
 
@@ -33,9 +33,20 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
         val vfile = context.location?.virtualFile
         val filter = if (context.project.elmToolchain.isElmTestRsEnabled) ElmTestElementNavigator.findTestDescription(context.psiLocation) else null
 
-        return configuration.options.elmFolder == elmFolder
-                && configuration.options.filteredTestConfig?.filePath == vfile?.path
-                && configuration.options.filteredTestConfig?.filter == filter
+        var result = configuration.options.elmFolder == elmFolder
+        val config = configuration.options.filteredTestConfig
+
+        if (config == null) return result
+
+        if (config.moduleName.isNotBlank()) {
+            result = result && config.filePath == vfile?.path
+        }
+
+        if (!config.filter.isNullOrBlank()) {
+            result = result && config.filter == filter
+        }
+
+        return result
     }
 
     private fun getCandidateElmFolder(context: ConfigurationContext): String? {

From e8ebbc3da4c588caa8f1f832a3056c636de0880c Mon Sep 17 00:00:00 2001
From: Nate Brunette <n@tebru.net>
Date: Wed, 16 Jul 2025 17:04:40 -0500
Subject: [PATCH 7/8] Removing extraneous elmTestRsPath field

---
 .../ElmTestDescribeLineMarkerProvider.kt          |  3 ++-
 .../ide/lineMarkers/ElmTestLineMarkerProvider.kt  |  5 -----
 .../ElmTestSingleLineMarkerProvider.kt            |  3 ++-
 .../test/run/ElmTestRunConfigurationProducer.kt   | 11 +++++++----
 .../elm/ide/test/run/ElmTestRunProfileState.kt    |  1 +
 src/main/kotlin/org/elm/workspace/ElmToolchain.kt | 10 +++-------
 .../org/elm/workspace/ElmWorkspaceService.kt      |  6 ------
 .../elm/workspace/commandLineTools/ElmTestCLI.kt  |  2 ++
 .../elm/workspace/ui/ElmWorkspaceConfigurable.kt  | 15 ++++-----------
 .../ElmTestTestLineMarkerProviderTest.kt          |  1 -
 .../kotlin/org/elm/workspace/ElmToolchainTest.kt  | 10 +++++-----
 .../org/elm/workspace/ElmWorkspaceServiceTest.kt  |  2 +-
 12 files changed, 27 insertions(+), 42 deletions(-)

diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
index b00c27a3..f347b255 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestDescribeLineMarkerProvider.kt
@@ -5,6 +5,7 @@ import com.intellij.codeInsight.daemon.LineMarkerInfo
 import com.intellij.psi.PsiElement
 import org.elm.ide.icons.ElmIcons
 import org.elm.ide.test.core.ElmTestElementNavigator
+import org.elm.workspace.elmToolchain
 
 /** Handles adding a gutter icon for running tests under a describe */
 class ElmTestDescribeLineMarkerProvider : ElmTestLineMarkerProvider() {
@@ -14,7 +15,7 @@ class ElmTestDescribeLineMarkerProvider : ElmTestLineMarkerProvider() {
 
     /** Add gutter icons for the describe line */
     override fun shouldAddGutterIcon(element: PsiElement): Boolean {
-        return usingElmTestRs(element.project) && element.text == "describe"
+        return element.project.elmToolchain.isElmTestRsEnabled && element.text == "describe"
     }
 
     override fun getLineMarkerInfo(element: PsiElement): LineMarkerInfo<*>? {
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
index a2582421..55bad147 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestLineMarkerProvider.kt
@@ -46,11 +46,6 @@ abstract class ElmTestLineMarkerProvider : LineMarkerProvider {
         return element.containingFile.text.contains("import Test exposing")
     }
 
-    /** Returns true if elm-test-rs is enabled */
-    protected fun usingElmTestRs(project: Project): Boolean {
-        return project.elmToolchain.isElmTestRsEnabled
-    }
-
     /** Create a gutter icon on a given line with an icon, tooltip, and list of popup actions */
     protected fun createLineMarkerInfo(element: PsiElement, icon: Icon, tooltip: String, actions: List<AnAction>, ): LineMarkerInfo<*>? {
         if (!isTestFile(element) || !shouldAddGutterIcon(element)) return null
diff --git a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
index 76a67f41..13674f35 100644
--- a/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
+++ b/src/main/kotlin/org/elm/ide/lineMarkers/ElmTestSingleLineMarkerProvider.kt
@@ -5,6 +5,7 @@ import com.intellij.codeInsight.daemon.LineMarkerInfo
 import com.intellij.psi.PsiElement
 import org.elm.ide.icons.ElmIcons
 import org.elm.ide.test.core.ElmTestElementNavigator
+import org.elm.workspace.elmToolchain
 
 /** * Handles adding a gutter icon for running a specific test */
 class ElmTestSingleLineMarkerProvider : ElmTestLineMarkerProvider() {
@@ -14,7 +15,7 @@ class ElmTestSingleLineMarkerProvider : ElmTestLineMarkerProvider() {
 
     /** * Add gutter icons for the test line */
     override fun shouldAddGutterIcon(element: PsiElement): Boolean {
-        return usingElmTestRs(element.project) && element.text == "test"
+        return element.project.elmToolchain.isElmTestRsEnabled && element.text == "test"
     }
 
     override fun getLineMarkerInfo(element: PsiElement): LineMarkerInfo<*>? {
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
index 42345608..07ecdc31 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunConfigurationProducer.kt
@@ -19,8 +19,7 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
 
         configuration.options.elmFolder = elmFolder
         if (vfile != null) {
-            val filter = if (context.project.elmToolchain.isElmTestRsEnabled) ElmTestElementNavigator.findTestDescription(context.psiLocation) else null
-            configuration.options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from(sourceElement.get(), filter)
+            configuration.options.filteredTestConfig = ElmTestRunConfiguration.FilteredTest.from(sourceElement.get(), getFilter(context))
         }
 
         configuration.setGeneratedName()
@@ -31,7 +30,6 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
     override fun isConfigurationFromContext(configuration: ElmTestRunConfiguration, context: ConfigurationContext): Boolean {
         val elmFolder = getCandidateElmFolder(context) ?: return false
         val vfile = context.location?.virtualFile
-        val filter = if (context.project.elmToolchain.isElmTestRsEnabled) ElmTestElementNavigator.findTestDescription(context.psiLocation) else null
 
         var result = configuration.options.elmFolder == elmFolder
         val config = configuration.options.filteredTestConfig
@@ -43,7 +41,7 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
         }
 
         if (!config.filter.isNullOrBlank()) {
-            result = result && config.filter == filter
+            result = result && config.filter == getFilter(context)
         }
 
         return result
@@ -54,4 +52,9 @@ class ElmTestRunConfigurationProducer : LazyRunConfigurationProducer<ElmTestRunC
         val elmProject = context.project.elmWorkspace.findProjectForFile(vfile) ?: return null
         return elmProject.projectDirPath.toString()
     }
+
+    /** Get the filter string or null if it couldn't be found */
+    private fun getFilter(context: ConfigurationContext): String? {
+        return if (context.project.elmToolchain.isElmTestRsEnabled) ElmTestElementNavigator.findTestDescription(context.psiLocation) else null
+    }
 }
diff --git a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
index 84ba8aa2..9c3986e6 100644
--- a/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
+++ b/src/main/kotlin/org/elm/ide/test/run/ElmTestRunProfileState.kt
@@ -64,6 +64,7 @@ class ElmTestRunProfileState internal constructor(
         }
 
         if (toolchain.isElmTestRsEnabled) {
+            // ensure that elm-test-rs is being used if the checkbox is enabled
             val version = elmTestCLI.queryVersion(project)
             if (version is org.elm.openapiext.Result.Err) return handleBadConfiguration(project, version.reason)
         }
diff --git a/src/main/kotlin/org/elm/workspace/ElmToolchain.kt b/src/main/kotlin/org/elm/workspace/ElmToolchain.kt
index b435eaaf..97fef513 100644
--- a/src/main/kotlin/org/elm/workspace/ElmToolchain.kt
+++ b/src/main/kotlin/org/elm/workspace/ElmToolchain.kt
@@ -23,18 +23,16 @@ data class ElmToolchain(
         val lamderaCompilerPath: Path?,
         val elmFormatPath: Path?,
         val elmTestPath: Path?,
-        val elmTestRsPath: Path?,
         val elmReviewPath: Path?,
         val isElmTestRsEnabled: Boolean,
         val isElmFormatOnSaveEnabled: Boolean
 ) {
-    constructor(elmCompilerPath: String, lamderaCompilerPath: String, elmFormatPath: String, elmTestPath: String, elmTestRsPath: String, elmReviewPath: String, isElmTestRsEnabled: Boolean, isElmFormatOnSaveEnabled: Boolean) :
+    constructor(elmCompilerPath: String, lamderaCompilerPath: String, elmFormatPath: String, elmTestPath: String, elmReviewPath: String, isElmTestRsEnabled: Boolean, isElmFormatOnSaveEnabled: Boolean) :
             this(
                     if (elmCompilerPath.isNotBlank() && Files.exists(Paths.get(elmCompilerPath))) Paths.get(elmCompilerPath) else null,
                     if (lamderaCompilerPath.isNotBlank() && Files.exists(Paths.get(lamderaCompilerPath))) Paths.get(lamderaCompilerPath) else null,
                     if (elmFormatPath.isNotBlank() && Files.exists(Paths.get(elmFormatPath))) Paths.get(elmFormatPath) else null,
                     if (elmTestPath.isNotBlank() && Files.exists(Paths.get(elmTestPath))) Paths.get(elmTestPath) else null,
-                    if (elmTestRsPath.isNotBlank() && Files.exists(Paths.get(elmTestRsPath))) Paths.get(elmTestRsPath) else null,
                     if (elmReviewPath.isNotBlank() && Files.exists(Paths.get(elmReviewPath))) Paths.get(elmReviewPath) else null,
                     isElmTestRsEnabled,
                     isElmFormatOnSaveEnabled
@@ -46,7 +44,7 @@ data class ElmToolchain(
 
     val elmFormatCLI: ElmFormatCLI? = elmFormatPath?.let { ElmFormatCLI(it) }
 
-    val elmTestCLI: ElmTestCLI? = if (isElmTestRsEnabled) elmTestRsPath?.let { ElmTestCLI(it) } else elmTestPath?.let { ElmTestCLI(it) }
+    val elmTestCLI: ElmTestCLI? = elmTestPath?.let { ElmTestCLI(it) }
 
     val elmReviewCLI: ElmReviewCLI? = elmReviewPath?.let { ElmReviewCLI(it) }
 
@@ -76,8 +74,7 @@ data class ElmToolchain(
                 elmCompilerPath = elmCompilerPath ?: suggestions[elmCompilerTool],
                 lamderaCompilerPath = lamderaCompilerPath ?: suggestions[lamderaCompilerTool],
                 elmFormatPath = elmFormatPath ?: suggestions[elmFormatTool],
-                elmTestPath = elmTestPath ?: suggestions[elmTestTool],
-                elmTestRsPath = elmTestRsPath ?: suggestions[elmTestRsTool],
+                elmTestPath = if (isElmTestRsEnabled) elmTestPath ?: suggestions[elmTestRsTool] else elmTestPath ?: suggestions[elmTestTool],
                 elmReviewPath = elmReviewPath ?: suggestions[elmReviewTool]
         )
     }
@@ -106,7 +103,6 @@ data class ElmToolchain(
                 lamderaCompilerPath = null,
                 elmFormatPath = null,
                 elmTestPath = null,
-                elmTestRsPath = null,
                 elmReviewPath = null,
                 isElmTestRsEnabled = DEFAULT_ELM_TEST_RS,
                 isElmFormatOnSaveEnabled = DEFAULT_FORMAT_ON_SAVE
diff --git a/src/main/kotlin/org/elm/workspace/ElmWorkspaceService.kt b/src/main/kotlin/org/elm/workspace/ElmWorkspaceService.kt
index 03e9e48e..73db3410 100644
--- a/src/main/kotlin/org/elm/workspace/ElmWorkspaceService.kt
+++ b/src/main/kotlin/org/elm/workspace/ElmWorkspaceService.kt
@@ -93,7 +93,6 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
         val lamderaCompilerPath: String = "",
         val elmFormatPath: String = "",
         val elmTestPath: String = "",
-        val elmTestRsPath: String = "",
         val isElmTestRsEnabled: Boolean = DEFAULT_ELM_TEST_RS,
         val elmReviewPath: String = "",
         val isElmFormatOnSaveEnabled: Boolean = DEFAULT_FORMAT_ON_SAVE
@@ -108,7 +107,6 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
                 lamderaCompilerPath = raw.lamderaCompilerPath,
                 elmFormatPath = raw.elmFormatPath,
                 elmTestPath = raw.elmTestPath,
-                elmTestRsPath = raw.elmTestRsPath,
                 elmReviewPath = raw.elmReviewPath,
                 isElmTestRsEnabled = raw.isElmTestRsEnabled,
                 isElmFormatOnSaveEnabled = raw.isElmFormatOnSaveEnabled
@@ -140,7 +138,6 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
                 lamderaCompilerPath = toolchain.lamderaCompilerPath.toString(),
                 elmFormatPath = toolchain.elmFormatPath.toString(),
                 elmTestPath = toolchain.elmTestPath.toString(),
-                elmTestRsPath = toolchain.elmTestRsPath.toString(),
                 elmReviewPath = toolchain.elmReviewPath.toString(),
                 isElmTestRsEnabled = toolchain.isElmTestRsEnabled,
                 isElmFormatOnSaveEnabled = toolchain.isElmFormatOnSaveEnabled
@@ -446,7 +443,6 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
         settingsElement.setAttribute("lamderaCompilerPath", raw.lamderaCompilerPath)
         settingsElement.setAttribute("elmFormatPath", raw.elmFormatPath)
         settingsElement.setAttribute("elmTestPath", raw.elmTestPath)
-        settingsElement.setAttribute("elmTestRsPath", raw.elmTestRsPath)
         settingsElement.setAttribute("isElmTestRsEnabled", raw.isElmTestRsEnabled.toString())
         settingsElement.setAttribute("elmReviewPath", raw.elmReviewPath)
         settingsElement.setAttribute("isElmFormatOnSaveEnabled", raw.isElmFormatOnSaveEnabled.toString())
@@ -466,7 +462,6 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
         val lamderaCompilerPath = settingsElement.getAttributeValue("lamderaCompilerPath") ?: ""
         val elmFormatPath = settingsElement.getAttributeValue("elmFormatPath") ?: ""
         val elmTestPath = settingsElement.getAttributeValue("elmTestPath") ?: ""
-        val elmTestRsPath = settingsElement.getAttributeValue("elmTestRsPath") ?: ""
         val elmReviewPath = settingsElement.getAttributeValue("elmReviewPath") ?: ""
         val isElmTestRsEnabled = settingsElement
             .getAttributeValue("isElmTestRsEnabled")
@@ -483,7 +478,6 @@ class ElmWorkspaceService(val intellijProject: Project) : PersistentStateCompone
                 lamderaCompilerPath = lamderaCompilerPath,
                 elmFormatPath = elmFormatPath,
                 elmTestPath = elmTestPath,
-                elmTestRsPath = elmTestRsPath,
                 isElmTestRsEnabled = isElmTestRsEnabled,
                 elmReviewPath = elmReviewPath,
                 isElmFormatOnSaveEnabled = isElmFormatOnSaveEnabled
diff --git a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
index 270d0276..45d29036 100644
--- a/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
+++ b/src/main/kotlin/org/elm/workspace/commandLineTools/ElmTestCLI.kt
@@ -33,6 +33,8 @@ class ElmTestCLI(private val executablePath: Path) {
      *
      * @param elmCompilerPath The path to the Elm compiler.
      * @param elmProject The [ElmProject] containing the tests to be run.
+     * @param filteredTest An instance of the filter parameters for the test
+     * @param isElmTestRsEnabled True if using elm-test-rs
      */
     fun runTestsProcessHandler(elmCompilerPath: Path, elmProject: ElmProject, filteredTest: FilteredTest?, isElmTestRsEnabled: Boolean): ProcessHandler {
         val commandLine = GeneralCommandLine(executablePath.toString(), "--report=json")
diff --git a/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt b/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
index 5ab25df3..87ca8f45 100644
--- a/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
+++ b/src/main/kotlin/org/elm/workspace/ui/ElmWorkspaceConfigurable.kt
@@ -313,7 +313,6 @@ class ElmWorkspaceConfigurable(
         val elmFormatPath = settings?.elmFormatPath
         val isElmFormatOnSaveEnabled = settings?.isElmFormatOnSaveEnabled
         val elmTestPath = settings?.elmTestPath
-        val elmTestRsPath = settings?.elmTestRsPath
         val isElmTestRsEnabled = settings?.isElmTestRsEnabled
         val elmReviewPath = settings?.elmReviewPath
 
@@ -327,12 +326,9 @@ class ElmWorkspaceConfigurable(
             elmFormatPathField.text = elmFormatPath
         }
         elmFormatOnSaveCheckbox.isSelected = isElmFormatOnSaveEnabled == true
-        if (elmTestPath != null && (isElmTestRsEnabled == null || !isElmTestRsEnabled)) {
+        if (elmTestPath != null) {
             elmTestPathField.text = elmTestPath
         }
-        if (elmTestRsPath != null && isElmTestRsEnabled == true) {
-            elmTestPathField.text = elmTestRsPath
-        }
         elmTestRsCheckbox.isSelected = isElmTestRsEnabled == true
         if (elmReviewPath != null) {
             elmReviewPathField.text = elmReviewPath
@@ -346,15 +342,14 @@ class ElmWorkspaceConfigurable(
             it.copy(elmCompilerPath = elmPathField.text,
                     lamderaCompilerPath = lamderaPathField.text,
                     elmFormatPath = elmFormatPathField.text,
-                    elmTestPath = if (isElmTestRsEnabledAndSelected()) "" else elmTestPathField.text,
-                    elmTestRsPath = if (isElmTestRsEnabledAndSelected()) elmTestPathField.text else "",
+                    elmTestPath = elmTestPathField.text,
                     elmReviewPath = elmReviewPathField.text,
                     isElmTestRsEnabled = isElmTestRsEnabledAndSelected(),
                     isElmFormatOnSaveEnabled = isOnSaveHookEnabledAndSelected()
             )
         }
     }
-    
+
     private fun isElmTestRsEnabledAndSelected() =
         elmTestRsCheckbox.isEnabled && elmTestRsCheckbox.isSelected
 
@@ -363,12 +358,10 @@ class ElmWorkspaceConfigurable(
 
     override fun isModified(): Boolean {
         val settings = project.elmWorkspace.rawSettings
-        val isElmTestPathModified = if (isElmTestRsEnabledAndSelected()) elmTestPathField.text != settings?.elmTestRsPath else elmTestPathField.text != settings?.elmTestPath
-
         return elmPathField.text != settings?.elmCompilerPath
                 || lamderaPathField.text != settings.lamderaCompilerPath
                 || elmFormatPathField.text != settings.elmFormatPath
-                || isElmTestPathModified
+                || elmTestPathField.text != settings.elmTestPath
                 || elmReviewPathField.text != settings.elmReviewPath
                 || isElmTestRsEnabledAndSelected() != settings.isElmTestRsEnabled
                 || isOnSaveHookEnabledAndSelected() != settings.isElmFormatOnSaveEnabled
diff --git a/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
index a681ff37..303288f5 100644
--- a/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
+++ b/src/test/kotlin/org/elm/ide/lineMarkers/ElmTestTestLineMarkerProviderTest.kt
@@ -12,7 +12,6 @@ class ElmTestTestLineMarkerProviderTest : ElmLineMarkerProviderTestBase() {
             lamderaCompilerPath = "",
             elmFormatPath = "",
             elmTestPath = "",
-            elmTestRsPath = "",
             elmReviewPath = "",
             isElmTestRsEnabled = enabled,
             isElmFormatOnSaveEnabled = false
diff --git a/src/test/kotlin/org/elm/workspace/ElmToolchainTest.kt b/src/test/kotlin/org/elm/workspace/ElmToolchainTest.kt
index 1a4e52aa..1add2dcd 100644
--- a/src/test/kotlin/org/elm/workspace/ElmToolchainTest.kt
+++ b/src/test/kotlin/org/elm/workspace/ElmToolchainTest.kt
@@ -10,34 +10,34 @@ class ElmToolchainTest {
     @Test
     fun `looksLikeValidToolchain allows an executable file`() {
         val rawElmPath = Paths.get(ClassLoader.getSystemResource("org/elm/workspace/fixtures/elm-executable").toURI())
-        val toolchain = ElmToolchain(rawElmPath, null, null, null, null, null, false, false)
+        val toolchain = ElmToolchain(rawElmPath, null, null, null, null, false, false)
         assertTrue(toolchain.looksLikeValidToolchain())
     }
 
     @Test
     fun `looksLikeValidToolchain does not allow a non-executable file`() {
         val rawElmPath = Paths.get(ClassLoader.getSystemResource("org/elm/workspace/fixtures/non-executable").toURI())
-        val toolchain = ElmToolchain(rawElmPath, null, null, null, null, null, false, false)
+        val toolchain = ElmToolchain(rawElmPath, null, null, null, null, false, false)
         assertFalse(toolchain.looksLikeValidToolchain())
     }
 
     @Test
     fun `looksLikeValidToolchain allows bare elm if it is on the path`() {
         val pathSearchLocation = Paths.get(ClassLoader.getSystemResource("org/elm/workspace/fixtures/PATH").toURI())
-        val toolchain = ElmToolchain(Paths.get("elm"), null, null, null, null, null, false, false)
+        val toolchain = ElmToolchain(Paths.get("elm"), null, null, null, null, false, false)
         assertTrue(toolchain.looksLikeValidToolchain(sequenceOf(pathSearchLocation)))
     }
 
     @Test
     fun `looksLikeValidToolchain does not allow bare elm if it is not on the path`() {
         val pathSearchLocation = Paths.get(ClassLoader.getSystemResource("org/elm/workspace/fixtures/NOT_PATH").toURI())
-        val toolchain = ElmToolchain(Paths.get("elm"), null, null, null, null, null, false, false)
+        val toolchain = ElmToolchain(Paths.get("elm"), null, null, null, null, false, false)
         assertFalse(toolchain.looksLikeValidToolchain(sequenceOf(pathSearchLocation)))
     }
 
     @Test
     fun `looksLikeValidToolchain does not allow an empty path`() {
-        val toolchain = ElmToolchain(null, null, null, null, null, null, false, false)
+        val toolchain = ElmToolchain(null, null, null, null, null, false, false)
         assertFalse(toolchain.looksLikeValidToolchain())
     }
 }
diff --git a/src/test/kotlin/org/elm/workspace/ElmWorkspaceServiceTest.kt b/src/test/kotlin/org/elm/workspace/ElmWorkspaceServiceTest.kt
index 7dee94ce..7c11aeef 100644
--- a/src/test/kotlin/org/elm/workspace/ElmWorkspaceServiceTest.kt
+++ b/src/test/kotlin/org/elm/workspace/ElmWorkspaceServiceTest.kt
@@ -265,7 +265,7 @@ class ElmWorkspaceServiceTest : ElmWorkspaceTestBase() {
               <elmProjects>
                 <project path="$projectPathString" />
               </elmProjects>
-              <settings elmCompilerPath="${toolchain.elmCompilerPath}" lamderaCompilerPath="" elmFormatPath="${toolchain.elmFormatPath}" elmTestPath="${toolchain.elmTestPath}" elmReviewPath="" isElmFormatOnSaveEnabled="true" />
+              <settings elmCompilerPath="${toolchain.elmCompilerPath}" lamderaCompilerPath="" elmFormatPath="${toolchain.elmFormatPath}" elmTestPath="${toolchain.elmTestPath}" isElmTestRsEnabled="false" elmReviewPath="" isElmFormatOnSaveEnabled="true" />
             </state>
             """.trimIndent()
 

From f7b7f3e49e2928f12a618744fd91b73df8ad6ac3 Mon Sep 17 00:00:00 2001
From: Nate Brunette <n@tebru.net>
Date: Thu, 17 Jul 2025 09:27:56 -0500
Subject: [PATCH 8/8] Adding elm-test-rs to build.yml

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 64e2ac6c..0eceb407 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -127,7 +127,7 @@ jobs:
           node-version: lts/*
 
       - name: Install elm tools
-        run: npm install --global elm elm-test elm-format elm-review lamdera
+        run: npm install --global elm elm-test elm-test-rs elm-format elm-review lamdera
 
       # Run tests
       - name: Run Tests