""".stripIndent()

        when:
        succeedsWithTestTaskArguments("test", "--tests=Ok2*")

        then:
        def testResult = new DefaultTestExecutionResult(testDirectory)
        testResult.assertTestClassesExecuted('Ok2')

        when:
        succeedsWithTestTaskArguments("cleanTest", "test", "--tests=Ok*")

        then:

        return "eclipseClasspath"
    }

    @Override
    void ideFileContainsEntry(String jar, List<String> sources, List<String> javadoc) {
        def classpath = EclipseClasspathFixture.create(testDirectory, executer.gradleUserHomeDir)
        def lib = classpath.lib(jar)

        // Eclipse only retains the first source/javadoc file
        if (!sources.isEmpty()) {

    def "using #snippetsFactory.summary in task configuration is a problem"() {
        given:
        def snippets = snippetsFactory.newSnippets(execOperationsFixture)
        testDirectory.file("buildSrc/src/main/java/SneakyTask.java") << """
            import ${DefaultTask.name};
            import ${ExecOperations.name};
            import ${Inject.name};
            import ${TaskAction.name};

        when:
        def jansiStorage = locator.locate(tmpDir.testDirectory)

        then:
        1 * factory.create() >> jansiLibrary
        jansiStorage.jansiLibrary == jansiLibrary
        jansiStorage.targetLibFile == new File(locator.makeVersionSpecificDir(tmpDir.testDirectory), "$platform/$nativeLibraryName")
    }

class JUnitPlatformParameterizedTestIntegrationTest extends JUnitPlatformIntegrationSpec implements JUnitPlatformTestFixture {
    @Override
    TestFile getProjectDir() {
        return testDirectory
    }

    @Rule BlockingHttpServer server = new BlockingHttpServer()

    @Issue("https://github.com/gradle/gradle/issues/20081")
    def "test report receives events for disabled parameterized test"() {

            library {
                linkage = [Linkage.STATIC]
            }
        """
        settingsFile << """
            rootProject.name = 'foo'
        """
        library.writeToProject(testDirectory)

        when:
        succeeds('assemble')

        then:
        result.assertTasksExecuted(':compileDebugSwift', ':createDebug', ':assemble')
        staticLibrary('build/lib/main/debug/Foo').assertExists()

        then:
        failure.assertHasDescription("Directory '$testDirectory' does not contain a Gradle build.")
        failure.assertHasResolutions(
            "Run gradle init to create a new Gradle build in this directory.",
            STACKTRACE_MESSAGE,
            INFO_DEBUG,
            GET_HELP) // Don't suggest running with --scan for a missing build

        testDirectory.assertIsEmptyDir()

        runIdeStarterWith(gradleDist, testDirectory.toPath(), ideHome, ide)
    }

    protected TestFile getTestDirectory() {
        temporaryFolder.testDirectory
    }

    protected TestFile file(Object... path) {
        if (path.length == 1 && path[0] instanceof TestFile) {
            return path[0] as TestFile
        }
        testDirectory.file(path)
    }

    private void runIdeStarterWith(

    @DisplayName("╯°□°）╯")
    void testWithDisplayNameContainingSpecialCharacters() {
    }
}
'''
        when:
        succeeds('test')

        then:
        def result = new DefaultTestExecutionResult(testDirectory)
        result.assertTestClassesExecutedJudgementByHtml('org.gradle.DisplayNameDemo', 'org.gradle.DisplayNameDemo2')
            .assertTestClassesExecutedJudgementByXml('A special test case', 'A special test case2')

            scriptRuntimeClassPath
        )
}


class DslTestFixture(private val testDirectory: File) {

    val kotlinDslEvalBaseCacheDir: File by lazy {
        testDirectory.resolve("kotlin-dsl-eval-cache").apply {
            mkdirs()
        }
    }

    val kotlinDslEvalBaseTempDir: File by lazy {
        testDirectory.resolve("kotlin-dsl-eval-temp").apply {
            mkdirs()
        }
    }

    /**