added tests on gradle configuration producers

2026-09-27 10:03:11 +07:00 · 2019-02-11 19:31:55 +03:00
parent 57915f88c6
commit d80f62063a
8 changed files with 487 additions and 47 deletions
@@ -18,6 +18,7 @@ package com.intellij.execution.actions;
 import com.intellij.execution.RunnerAndConfigurationSettings;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.TestOnly;

 /**
 * @author yole
@@ -69,4 +70,9 @@ public class ConfigurationFromContextImpl extends ConfigurationFromContext {
  public void onFirstRun(ConfigurationContext context, Runnable startRunnable) {
    myConfigurationProducer.onFirstRun(this, context, startRunnable);
  }
+
+  @TestOnly
+  public RunConfigurationProducer getConfigurationProducer() {
+    return myConfigurationProducer;
+  }
 }
@@ -42,6 +42,7 @@ import java.util.List;
 import static com.intellij.util.containers.ContainerUtil.filterIsInstance;
 import static org.jetbrains.plugins.gradle.execution.test.runner.GradleTestRunConfigurationProducer.findAllTestsTaskToRun;
 import static org.jetbrains.plugins.gradle.execution.test.runner.TestGradleConfigurationProducerUtilKt.applyTestConfiguration;
+import static org.jetbrains.plugins.gradle.execution.test.runner.TestGradleConfigurationProducerUtilKt.escapeIfNeeded;
 import static org.jetbrains.plugins.gradle.util.GradleRerunFailedTasksActionUtilsKt.containsSubSequenceInSequence;
 import static org.jetbrains.plugins.gradle.util.GradleRerunFailedTasksActionUtilsKt.containsTasksInScriptParameters;

@@ -83,8 +84,9 @@ public class GradleRerunFailedTestsAction extends JavaRerunFailedTestsAction {
          List<List<String>> tasksToRun = new ArrayList<>();
          boolean isSpecificTask = false;
          for (List<String> tasks : foundTasksToRun) {
-            if (containsSubSequenceInSequence(runProfile.getSettings().getTaskNames(), tasks) ||
-                containsTasksInScriptParameters(runProfile.getSettings().getScriptParameters(), tasks)) {
+            List<String> escapedTasks = ContainerUtil.map(tasks, it -> escapeIfNeeded(it));
+            if (containsSubSequenceInSequence(runProfile.getSettings().getTaskNames(), escapedTasks) ||
+                containsTasksInScriptParameters(runProfile.getSettings().getScriptParameters(), escapedTasks)) {
              ContainerUtil.addAllNotNull(tasksToRun, tasks);
              isSpecificTask = true;
            }
@@ -113,7 +113,7 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio

  public static boolean hasTasksInConfiguration(VirtualFile source, Project project, ExternalSystemTaskExecutionSettings settings) {
    List<TasksToRun> tasksToRun = findAllTestsTaskToRun(source, project);
-    List<String> taskNames = settings.getTaskNames();
+    List<String> taskNames = ContainerUtil.map(settings.getTaskNames(), StringUtil::stripQuotesAroundValue);
    return tasksToRun.stream().anyMatch(taskNames::containsAll);
  }

@@ -1,4 +1,5 @@
 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+@file:ApiStatus.Experimental
 package org.jetbrains.plugins.gradle.execution.test.runner

 import com.intellij.openapi.externalSystem.model.execution.ExternalSystemTaskExecutionSettings
@@ -8,6 +9,7 @@ import com.intellij.openapi.roots.ProjectFileIndex
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFileSystemItem
+import org.jetbrains.annotations.ApiStatus
 import org.jetbrains.plugins.gradle.execution.GradleRunnerUtil
 import org.jetbrains.plugins.gradle.execution.test.runner.GradleTestRunConfigurationProducer.findTestsTaskToRun
 import java.util.*
@@ -89,7 +91,7 @@ fun <E : PsiElement, T> ExternalSystemTaskExecutionSettings.applyTestConfigurati
    module = projectFileIndex.getModuleForFile(sourceFile) ?: return false
    if (!GradleRunnerUtil.isGradleModule(module)) return false
    val (_, arguments) = testRunConfigurations.getOrPut(module.name) { Pair(sourceFile, ArrayList()) }
-    arguments.add(createFilter(sourceElement, test))
+    arguments.add(createFilter(sourceElement, test).trim())
  }
  if (module == null) return false
  externalProjectPath = GradleRunnerUtil.resolveProjectPath(module) ?: return false
@@ -117,10 +119,7 @@ private fun ExternalSystemTaskExecutionSettings.setFrom(taskSettings: List<Pair<
  if (hasTasksAfterTaskWithArguments) {
    val joiner = StringJoiner(" ")
    for ((task, arguments) in taskSettings) {
-      when {
-        task.contains(' ') -> joiner.add("'$task'")
-        else -> joiner.add(task)
-      }
+      joiner.add(task.escapeIfNeeded())
      joiner.addAll(arguments)
    }
    joiner.addAll(unorderedParameters)
@@ -131,11 +130,16 @@ private fun ExternalSystemTaskExecutionSettings.setFrom(taskSettings: List<Pair<
    val joiner = StringJoiner(" ")
    joiner.addAll(taskSettings.lastOrNull()?.second ?: emptyList())
    joiner.addAll(unorderedParameters)
-    taskNames = taskSettings.map { it.first }
+    taskNames = taskSettings.map { it.first.escapeIfNeeded() }
    scriptParameters = joiner.toString()
  }
 }

+fun String.escapeIfNeeded() = when {
+  contains(' ') -> "'$this'"
+  else -> this
+}
+
 private fun StringJoiner.addAll(elements: Iterable<String>) = apply {
  for (element in elements) {
    add(element)
@@ -7,7 +7,9 @@ import com.intellij.execution.junit2.PsiMemberParameterizedLocation
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiPackage
+import org.jetbrains.annotations.ApiStatus

+@ApiStatus.Experimental
 object GradleExecutionSettingsUtil {

  private fun createTestFilter(filter: String, hasSuffix: Boolean): String {
@@ -0,0 +1,239 @@
+// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+package org.jetbrains.plugins.gradle.execution.test.runner
+
+import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration
+import com.intellij.openapi.util.Ref
+import org.jetbrains.plugins.gradle.util.runReadActionAndWait
+import org.junit.Test
+
+class GradleTestRunConfigurationProducerTest : GradleTestRunConfigurationProducerTestCase() {
+
+  @Test
+  fun `test simple configuration`() {
+    val projectData = generateAndImportTemplateProject()
+    runReadActionAndWait {
+      val context = getContextByLocation(projectData["project"]["TestCase"]["test1"].element)
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as TestMethodGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      assertTrue(producer.isConfigurationFromContext(configuration, context))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(configuration, """:cleanTest :test --tests "TestCase.test1"""")
+    }
+    runReadActionAndWait {
+      val context = getContextByLocation(projectData["project"]["TestCase"].element)
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as TestClassGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      assertTrue(producer.isConfigurationFromContext(configuration, context))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(configuration, """:cleanTest :test --tests "TestCase"""")
+    }
+  }
+
+  @Test
+  fun `test package configuration`() {
+    val projectData = generateAndImportTemplateProject()
+    runReadActionAndWait {
+      val context = getContextByLocation(projectData["project"]["pkg.TestCase"].element.containingFile.containingDirectory)
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as AllInPackageGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      assertTrue(producer.isConfigurationFromContext(configuration, context))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(configuration, """:cleanTest :test --tests "pkg.*"""")
+    }
+  }
+
+  @Test
+  fun `test pattern configuration`() {
+    val projectData = generateAndImportTemplateProject()
+    runReadActionAndWait {
+      val context = getContextByLocation(
+        projectData["project"]["TestCase"]["test1"].element,
+        projectData["project"]["pkg.TestCase"]["test1"].element,
+        projectData["module"]["ModuleTestCase"]["test1"].element
+      )
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(
+        configuration,
+        """:cleanTest :test --tests "TestCase.test1" --tests "pkg.TestCase.test1" """ +
+        """:module:cleanTest :module:test --tests "ModuleTestCase.test1" --continue"""
+      )
+    }
+    runReadActionAndWait {
+      val context = getContextByLocation(
+        projectData["project"]["TestCase"].element,
+        projectData["project"]["pkg.TestCase"].element,
+        projectData["module"]["ModuleTestCase"].element
+      )
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(
+        configuration,
+        """:cleanTest :test --tests "TestCase" --tests "pkg.TestCase" """ +
+        """:module:cleanTest :module:test --tests "ModuleTestCase" --continue"""
+      )
+    }
+    runReadActionAndWait {
+      val context = getContextByLocation(
+        projectData["project"]["TestCase"]["test1"].element,
+        projectData["project"]["pkg.TestCase"]["test1"].element,
+        projectData["module"]["ModuleTestCase"].element
+      )
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(
+        configuration,
+        """:cleanTest :test --tests "TestCase.test1" --tests "pkg.TestCase.test1" """ +
+        """:module:cleanTest :module:test --tests "ModuleTestCase" --continue"""
+      )
+    }
+  }
+
+  @Test
+  fun `test configuration from context`() {
+    val projectData = generateAndImportTemplateProject()
+    runReadActionAndWait {
+      val context1 = getContextByLocation(projectData["project"]["TestCase"]["test1"].element)
+      val context2 = getContextByLocation(projectData["project"]["TestCase"].element)
+      val context3 = getContextByLocation(projectData["project"]["pkg.TestCase"].element.containingFile.containingDirectory)
+      val context4 = getContextByLocation(projectData["project"]["TestCase"]["test2"].element)
+      val context5 = getContextByLocation(projectData["project"]["TestCase"]["test1"].element)
+      val context6 = getContextByLocation(projectData["project"]["TestCase"].element)
+      val context7 = getContextByLocation(projectData["project"]["pkg.TestCase"].element.containingFile.containingDirectory)
+      val context8 = getContextByLocation(projectData["project"]["TestCase"]["test2"].element)
+      val configurationFromContext1 = getConfigurationFromContext(context1)
+      val configurationFromContext2 = getConfigurationFromContext(context2)
+      val configurationFromContext3 = getConfigurationFromContext(context3)
+      val configurationFromContext4 = getConfigurationFromContext(context4)
+      val configurationFromContext5 = getConfigurationFromContext(context5)
+      val configurationFromContext6 = getConfigurationFromContext(context6)
+      val configurationFromContext7 = getConfigurationFromContext(context7)
+      val configurationFromContext8 = getConfigurationFromContext(context8)
+      val configuration1 = configurationFromContext1.configuration as ExternalSystemRunConfiguration
+      val configuration2 = configurationFromContext2.configuration as ExternalSystemRunConfiguration
+      val configuration3 = configurationFromContext3.configuration as ExternalSystemRunConfiguration
+      val configuration4 = configurationFromContext4.configuration as ExternalSystemRunConfiguration
+      val configuration5 = configurationFromContext5.configuration as ExternalSystemRunConfiguration
+      val configuration6 = configurationFromContext6.configuration as ExternalSystemRunConfiguration
+      val configuration7 = configurationFromContext7.configuration as ExternalSystemRunConfiguration
+      val configuration8 = configurationFromContext8.configuration as ExternalSystemRunConfiguration
+      val producer1 = configurationFromContext1.configurationProducer
+      val producer2 = configurationFromContext2.configurationProducer
+      val producer3 = configurationFromContext3.configurationProducer
+      val producer4 = configurationFromContext4.configurationProducer
+      assertTrue(producer1.isConfigurationFromContext(configuration1, context1))
+      assertFalse(producer1.isConfigurationFromContext(configuration1, context2))
+      assertFalse(producer1.isConfigurationFromContext(configuration1, context3))
+      assertFalse(producer1.isConfigurationFromContext(configuration1, context4))
+      assertFalse(producer2.isConfigurationFromContext(configuration2, context1))
+      assertTrue(producer2.isConfigurationFromContext(configuration2, context2))
+      assertFalse(producer2.isConfigurationFromContext(configuration2, context3))
+      assertFalse(producer2.isConfigurationFromContext(configuration2, context4))
+      assertFalse(producer3.isConfigurationFromContext(configuration3, context1))
+      assertFalse(producer3.isConfigurationFromContext(configuration3, context2))
+      assertTrue(producer3.isConfigurationFromContext(configuration3, context3))
+      assertFalse(producer3.isConfigurationFromContext(configuration3, context4))
+      assertFalse(producer4.isConfigurationFromContext(configuration4, context1))
+      assertFalse(producer4.isConfigurationFromContext(configuration4, context2))
+      assertFalse(producer4.isConfigurationFromContext(configuration4, context3))
+      assertTrue(producer4.isConfigurationFromContext(configuration4, context4))
+      assertTrue(producer1.isConfigurationFromContext(configuration5, context5))
+      assertTrue(producer2.isConfigurationFromContext(configuration6, context6))
+      assertTrue(producer3.isConfigurationFromContext(configuration7, context7))
+      assertTrue(producer4.isConfigurationFromContext(configuration8, context8))
+      assertTrue(producer1.isConfigurationFromContext(configuration1, context5))
+      assertTrue(producer2.isConfigurationFromContext(configuration2, context6))
+      assertTrue(producer3.isConfigurationFromContext(configuration3, context7))
+      assertTrue(producer4.isConfigurationFromContext(configuration4, context8))
+      assertTrue(producer1.isConfigurationFromContext(configuration5, context1))
+      assertTrue(producer2.isConfigurationFromContext(configuration6, context2))
+      assertTrue(producer3.isConfigurationFromContext(configuration7, context3))
+      assertTrue(producer4.isConfigurationFromContext(configuration8, context4))
+      val context = getContextByLocation(
+        projectData["project"]["TestCase"]["test1"].element,
+        projectData["project"]["pkg.TestCase"]["test1"].element,
+        projectData["module"]["ModuleTestCase"]["test1"].element
+      )
+      assertFalse(producer1.isConfigurationFromContext(configuration1, context))
+      assertFalse(producer2.isConfigurationFromContext(configuration2, context))
+      assertFalse(producer3.isConfigurationFromContext(configuration3, context))
+      assertFalse(producer4.isConfigurationFromContext(configuration4, context))
+    }
+  }
+
+  @Test
+  fun `test configuration escaping`() {
+    val projectData = generateAndImportTemplateProject()
+    runReadActionAndWait {
+      val context = getContextByLocation(projectData["my module"]["MyModuleTestCase"]["test1"].element)
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as TestMethodGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      assertTrue(producer.isConfigurationFromContext(configuration, context))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(configuration, """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase.test1"""")
+    }
+    runReadActionAndWait {
+      val context = getContextByLocation(projectData["my module"]["MyModuleTestCase"].element)
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as TestClassGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      assertTrue(producer.isConfigurationFromContext(configuration, context))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(configuration, """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase"""")
+    }
+    runReadActionAndWait {
+      val context = getContextByLocation(
+        projectData["my module"]["MyModuleTestCase"]["test1"].element,
+        projectData["my module"]["MyModuleTestCase"]["test2"].element
+      )
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(
+        configuration, """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase.test1" --tests "MyModuleTestCase.test2"""")
+    }
+    runReadActionAndWait {
+      val context = getContextByLocation(projectData["project"]["GroovyTestCase"]["""Don\'t use single . quo\"tes"""].element)
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as TestMethodGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      assertTrue(producer.isConfigurationFromContext(configuration, context))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(configuration, """:cleanTest :test --tests "GroovyTestCase.Don\'t use single * quo\*tes"""")
+    }
+    runReadActionAndWait {
+      val context = getContextByLocation(
+        projectData["project"]["GroovyTestCase"]["""Don\'t use single . quo\"tes"""].element,
+        projectData["project"]["GroovyTestCase"]["test2"].element
+      )
+      val configurationFromContext = getConfigurationFromContext(context)
+      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
+      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+      producer.onFirstRun(configurationFromContext, context, Runnable {})
+      assertEqualsConfigurationSettings(
+        configuration, """:cleanTest :test --tests "GroovyTestCase.Don\'t use single * quo\*tes" --tests "GroovyTestCase.test2"""")
+    }
+  }
+}
@@ -0,0 +1,219 @@
+// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+package org.jetbrains.plugins.gradle.execution.test.runner
+
+import com.intellij.execution.Location
+import com.intellij.execution.PsiLocation
+import com.intellij.execution.actions.ConfigurationContext
+import com.intellij.execution.actions.ConfigurationFromContextImpl
+import com.intellij.openapi.actionSystem.LangDataKeys
+import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration
+import com.intellij.openapi.module.ModuleUtilCore
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiManager
+import com.intellij.psi.PsiMethod
+import com.intellij.testFramework.MapDataContext
+import org.jetbrains.plugins.gradle.importing.GradleBuildScriptBuilderEx
+import org.jetbrains.plugins.gradle.importing.GradleImportingTestCase
+import org.jetbrains.plugins.gradle.util.findChildByElementType
+import org.jetbrains.plugins.gradle.util.findChildByType
+import org.jetbrains.plugins.gradle.util.findChildrenByType
+import org.jetbrains.plugins.gradle.util.runReadActionAndWait
+import org.junit.runners.Parameterized
+
+abstract class GradleTestRunConfigurationProducerTestCase : GradleImportingTestCase() {
+
+  protected fun getContextByLocation(vararg elements: PsiElement): ConfigurationContext {
+    assertTrue(elements.isNotEmpty())
+    val dataContext = MapDataContext().apply {
+      put(LangDataKeys.PROJECT, myProject)
+      put(LangDataKeys.MODULE, ModuleUtilCore.findModuleForPsiElement(elements[0]))
+      put(Location.DATA_KEY, PsiLocation.fromPsiElement(elements[0]))
+      put(Location.DATA_KEYS, elements.map { PsiLocation.fromPsiElement(it) }.toTypedArray())
+    }
+    return object : ConfigurationContext(elements[0]) {
+      override fun getDataContext() = dataContext
+      override fun containsMultipleSelection() = elements.size > 1
+
+    }
+  }
+
+  protected fun getConfigurationFromContext(context: ConfigurationContext): ConfigurationFromContextImpl {
+    val fromContexts = context.configurationsFromContext
+    val fromContext = fromContexts?.firstOrNull()
+    assertNotNull("Gradle configuration from context not found", fromContext)
+    return fromContext as ConfigurationFromContextImpl
+  }
+
+  protected fun assertEqualsConfigurationSettings(configuration: ExternalSystemRunConfiguration, settings: String) {
+    assertEquals(settings, configuration.settings.toString().trim())
+  }
+
+  protected fun generateAndImportTemplateProject(): ProjectData {
+    val testCaseFile = createProjectSubFile("src/test/java/TestCase.java", """
+      import org.junit.Test;
+      public class TestCase extends AbstractTestCase {
+        @Test public void test1() {}
+        @Test public void test2() {}
+        @Test public void test3() {}
+      }
+    """.trimIndent())
+    val packageTestCaseFile = createProjectSubFile("src/test/java/pkg/TestCase.java", """
+      package pkg;
+      import org.junit.Test;
+      public class TestCase extends AbstractTestCase {
+        @Test public void test1() {}
+        @Test public void test2() {}
+        @Test public void test3() {}
+      }
+    """.trimIndent())
+    val automationTestCaseFile = createProjectSubFile("automation/AutomationTestCase.java", """
+      import org.junit.Test;
+      public class AutomationTestCase extends AbstractTestCase {
+        @Test public void test1() {}
+        @Test public void test2() {}
+        @Test public void test3() {}
+      }
+    """.trimIndent())
+    val abstractTestCaseFile = createProjectSubFile("src/test/java/AbstractTestCase.java", """
+      import org.junit.Test;
+      public class AbstractTestCase {
+        @Test public void test() {}
+      }
+    """.trimIndent())
+    val moduleTestCaseFile = createProjectSubFile("module/src/test/java/ModuleTestCase.java", """
+      import org.junit.Test;
+      public class ModuleTestCase extends AbstractTestCase {
+        @Test public void test1() {}
+        @Test public void test2() {}
+        @Test public void test3() {}
+      }
+    """.trimIndent())
+    val groovyTestCaseFile = createProjectSubFile("src/test/groovy/GroovyTestCase.groovy", """
+      import org.junit.Test;
+      public class GroovyTestCase extends AbstractTestCase {
+        @Test public void 'Don\\\'t use single . quo\\"tes'() {}
+        @Test public void test1() {}
+        @Test public void test2() {}
+        @Test public void test3() {}
+      }
+    """.trimIndent())
+    val myModuleTestCaseFile = createProjectSubFile("my module/src/test/groovy/MyModuleTestCase.groovy", """
+      import org.junit.Test;
+      public class MyModuleTestCase extends AbstractTestCase {
+        @Test public void test1() {}
+        @Test public void test2() {}
+        @Test public void test3() {}
+      }
+    """.trimIndent())
+    val buildScript = GradleBuildScriptBuilderEx()
+      .withJavaPlugin()
+      .withJUnit("4.12")
+      .withGroovyPlugin("2.4.14")
+      .addPrefix("""
+        sourceSets {
+          automation.java.srcDirs = ['automation']
+          automation.compileClasspath += sourceSets.test.runtimeClasspath
+        }
+        task autoTest(type: Test) {
+          testClassesDirs = sourceSets.automation.output.classesDirs
+        }
+        task automationTest(type: Test) {
+          testClassesDirs = sourceSets.automation.output.classesDirs
+        }
+      """.trimIndent())
+      .addPrefix("""
+        task myTestsJar(type: Jar, dependsOn: testClasses) {
+          baseName = "test-${'$'}{project.archivesBaseName}"
+          from sourceSets.automation.output
+        }
+        configurations {
+          testArtifacts
+        }
+        artifacts {
+          testArtifacts  myTestsJar
+        }
+      """.trimIndent())
+    val moduleBuildScript = GradleBuildScriptBuilderEx()
+      .withJavaPlugin()
+      .withJUnit("4.12")
+      .withGroovyPlugin("2.4.14")
+      .addDependency("testCompile project(path: ':', configuration: 'testArtifacts')")
+    createSettingsFile("""
+      rootProject.name = 'project'
+      include 'module', 'my module'
+    """.trimIndent())
+    createProjectSubFile("module/build.gradle", moduleBuildScript.generate())
+    createProjectSubFile("my module/build.gradle", moduleBuildScript.generate())
+    importProject(buildScript.generate())
+    assertModules("project", "project.main", "project.test", "project.automation",
+                  "project.module", "project.module.main", "project.module.test",
+                  "project.my_module", "project.my_module.main", "project.my_module.test")
+    val automationTestCase = extractJavaClassData(automationTestCaseFile)
+    val testCase = extractJavaClassData(testCaseFile)
+    val abstractTestCase = extractJavaClassData(abstractTestCaseFile)
+    val moduleTestCase = extractJavaClassData(moduleTestCaseFile)
+    val packageTestCase = extractJavaClassData(packageTestCaseFile)
+    val groovyTestCase = extractGroovyClassData(groovyTestCaseFile)
+    val myModuleTestCase = extractGroovyClassData(myModuleTestCaseFile)
+    return ProjectData(
+      ModuleData("project", testCase, packageTestCase, automationTestCase, abstractTestCase, groovyTestCase),
+      ModuleData("module", moduleTestCase),
+      ModuleData("my module", myModuleTestCase)
+    )
+  }
+
+  private fun extractJavaClassData(file: VirtualFile) = runReadActionAndWait {
+    val psiManager = PsiManager.getInstance(myProject)
+    val psiFile = psiManager.findFile(file)!!
+    val psiClass = psiFile.findChildByType<PsiClass>()
+    val psiMethods = psiClass.findChildrenByType<PsiMethod>()
+    val methods = psiMethods.map { MethodData(it.name, it) }
+    ClassData(psiClass.qualifiedName!!, psiClass, methods)
+  }
+
+  private fun extractGroovyClassData(file: VirtualFile) = runReadActionAndWait {
+    val psiManager = PsiManager.getInstance(myProject)
+    val psiFile = psiManager.findFile(file)!!
+    val psiClass = psiFile.findChildByType<PsiClass>()
+    val classBody = psiClass.findChildByElementType("CLASS_BODY")
+    val psiMethods = classBody.findChildrenByType<PsiMethod>()
+    val methods = psiMethods.map { MethodData(it.name, it) }
+    ClassData(psiClass.qualifiedName!!, psiClass, methods)
+  }
+
+
+  protected open class Mapping<D>(val data: Map<String, D>) {
+    operator fun get(key: String): D = data.getValue(key)
+  }
+
+  protected class ProjectData(
+    vararg modules: ModuleData
+  ) : Mapping<ModuleData>(modules.map { it.name to it }.toMap())
+
+  protected class ModuleData(
+    val name: String,
+    vararg classes: ClassData
+  ) : Mapping<ClassData>(classes.map { it.name to it }.toMap())
+
+  protected class ClassData(
+    val name: String,
+    val element: PsiClass,
+    methods: List<MethodData>
+  ) : Mapping<MethodData>(methods.map { it.name to it }.toMap())
+
+  protected class MethodData(
+    val name: String,
+    val element: PsiMethod
+  )
+
+  companion object {
+    /**
+     * It's sufficient to run the test against one gradle version
+     */
+    @Parameterized.Parameters(name = "with Gradle-{0}")
+    @JvmStatic
+    fun tests(): Collection<Array<out String>> = arrayListOf(arrayOf(GradleImportingTestCase.BASE_GRADLE_VERSION))
+  }
+}
@@ -1,7 +1,6 @@
 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package org.jetbrains.plugins.gradle.execution.test.runner

-import org.jetbrains.plugins.gradle.importing.GradleBuildScriptBuilderEx
 import org.jetbrains.plugins.gradle.settings.TestRunner
 import org.junit.Test

@@ -56,43 +55,12 @@ class TestMethodGradleConfigurationProducerTest : GradleConfigurationProducerTes

    currentExternalProjectSettings.testRunner = TestRunner.GRADLE
    assertTestFilter("package1.T1Test", null, "--tests \"package1.T1Test\"")
-    assertTestFilter("package1.T1Test", "testFoo", "--tests \"package1.T1Test.testFoo[*]\" ")
-    assertParameterizedLocationTestFilter("package1.T1Test", "testFoo", "param1", "--tests \"package1.T1Test.testFoo[*param1*]\" ")
-    assertParameterizedLocationTestFilter("package1.T1Test", "testFoo", "param2", "--tests \"package1.T1Test.testFoo[*param2*]\" ")
+    assertTestFilter("package1.T1Test", "testFoo", "--tests \"package1.T1Test.testFoo[*]\"")
+    assertParameterizedLocationTestFilter("package1.T1Test", "testFoo", "param1", "--tests \"package1.T1Test.testFoo[*param1*]\"")
+    assertParameterizedLocationTestFilter("package1.T1Test", "testFoo", "param2", "--tests \"package1.T1Test.testFoo[*param2*]\"")
    assertTestFilter("package1.T2Test", null, "--tests \"package1.T2Test\"")
-    assertTestFilter("package1.T2Test", "testFoo2", "--tests \"package1.T2Test.testFoo2[*]\" ")
-    assertParameterizedLocationTestFilter("package1.T2Test", "testFoo2", "param1", "--tests \"package1.T2Test.testFoo2[*param1*]\" ")
-    assertParameterizedLocationTestFilter("package1.T2Test", "testFoo2", "param2", "--tests \"package1.T2Test.testFoo2[*param2*]\" ")
-  }
-
-  @Test
-  fun `test pattern gradle run configuration`() {
-    val virtualFile = createProjectSubFile("src/test/groovy/Test.groovy", """
-      import static org.junit.Assert.fail
-      import org.junit.Test
-
-      class MyGroovyTest {
-          @Test
-          void 'Don\\\'t use single . quo\\"tes'() {
-              fail()
-          }
-          @Test
-          void test1() {
-              fail()
-          }
-          @Test
-          void test2() {
-              fail()
-          }
-      }
-    """.trimIndent())
-    val buildScript = GradleBuildScriptBuilderEx()
-      .withGroovyPlugin("2.4.14")
-      .withJUnit("4.12")
-    importProject(buildScript.generate())
-
-    currentExternalProjectSettings.testRunner = TestRunner.GRADLE
-    val filter = "--tests \"MyGroovyTest.Don\\'t use single * quo\\*tes\"  --tests \"MyGroovyTest.test2\" "
-    assertTestPatternFilter(filter, virtualFile, "Don\\'t use single . quo\\\"tes", "test2")
+    assertTestFilter("package1.T2Test", "testFoo2", "--tests \"package1.T2Test.testFoo2[*]\"")
+    assertParameterizedLocationTestFilter("package1.T2Test", "testFoo2", "param1", "--tests \"package1.T2Test.testFoo2[*param1*]\"")
+    assertParameterizedLocationTestFilter("package1.T2Test", "testFoo2", "param2", "--tests \"package1.T2Test.testFoo2[*param2*]\"")
  }
 }