when:
        withBuildCache().run(compilationTask)
        then:
        class1.isFile()
        class2.isFile()
        file(compiledFile).isFile()

        when:
        run("clean")
        withBuildCache().run(compilationTask)
        then:
        skipped(compilationTask)

        when:
        assert source2.delete()
        withBuildCache().run(compilationTask)
        then:

}

func TestEquivalents(t *testing.T) {
	t.Run("P224", func(t *testing.T) {
		testEquivalents(t, nistec.NewP224Point, elliptic.P224())
	})
	t.Run("P256", func(t *testing.T) {
		testEquivalents(t, nistec.NewP256Point, elliptic.P256())
	})
	t.Run("P384", func(t *testing.T) {
		testEquivalents(t, nistec.NewP384Point, elliptic.P384())
	})
	t.Run("P521", func(t *testing.T) {

    Object run(Long request) { throw new RuntimeException() }
}
""")

        when:
        def builder = workerFactory.singleRequestWorker(cl)
        builder.baseName = 'broken worker'
        def worker = builder.build()
        worker.run(12.toLong())

        then:
        def e = thrown(WorkerProcessException)
        e.message == 'Failed to run broken worker'

        impl.snapshot { run language.compileTaskName }

        when:
        source api: ["class B { /* remove extends */ }"]
        run "impl:${language.compileTaskName}"

        then:
        impl.recompiledClasses("ImplB", "ImplB2")

        when:
        impl.snapshot()
        source api: ["class A { /* change */ }"]
        run "impl:${language.compileTaskName}"

        then:

        withBuildCache().run task
        executedAndNotSkipped(task)
        cleanBuildDir()

        withBuildCache().run task
        executedAndNotSkipped(task)
    }

    void taskIsCached(String task) {
        withBuildCache().run task
        executedAndNotSkipped(task)
        cleanBuildDir()

        withBuildCache().run task
        skipped(task)
    }

                doLast {
                    project.javaexec {
                        if (run.executable) {
                            executable run.executable
                        }
                        classpath = run.classpath
                        mainClass = run.mainClass
                        args run.args
                    }
                }
            }

        newPluginAwareMock<PluginAware>().run {
            target.apply<AnyPlugin>()
            verify(configurationAction).plugin(AnyPlugin::class.java)
        }
        newPluginAwareMock<Gradle>().run {
            target.apply<GradlePlugin>()
            verify(configurationAction).plugin(GradlePlugin::class.java)
        }
        newPluginAwareMock<Settings>().run {
            target.apply<SettingsPlugin>()

        source api: ["class A {}", "class B {}"], impl: ["class ImplA extends A {}", "class ImplB extends B {}"]
        impl.snapshot { run language.compileTaskName }

        when:
        source api: ["class A { String change; }"]
        run "impl:${language.compileTaskName}"

        then:
        impl.recompiledClasses("ImplA")
    }

        and:
        commonJvmFilesGenerated(scriptDsl)
        dslFixture.assertDoesNotUseTestSuites()

        when:
        run("build")

        then:
        assertTestPassed("org.example.AppTest", "appHasAGreeting")

        when:
        run("run")

        then:
        outputContains("Hello World!")

        where:
        scriptDsl << ScriptDslFixture.SCRIPT_DSLS
    }

        impl.snapshot { run language.compileTaskName }

        when:
        source api: ["class B { final static $constantType x = $newValue; }"]
        run "impl:${language.compileTaskName}"

        then:
        impl.recompiledClasses('X')

        where: