def "can use multiple action implementations with different classpath roots and loaded from same ClassLoader"() {
        settingsFile.text = 'rootProject.name = "not broken"'

        // Ensure daemon is reused
        toolingApi.requireIsolatedDaemons()

        // Copy each of the action classes into its own classes directory and load into a single ClassLoader

        withBuildSrc()

        def initJar = withEmptyJar("classes_init.jar")
        def someInitJar = withEmptyJar("classes_some_init.jar")

        toolingApi.requireIsolatedUserHome()
        def gradleUserHomeDir = toolingApi.createExecuter().gradleUserHomeDir

        def init = gradleUserHomeDir.file("init.gradle.kts").tap {
            text = """
                initscript {

    @Rule BlockingHttpServer server = new BlockingHttpServer()
    boolean killed = false

    void setup() {
        toolingApi.requireIsolatedDaemons()
    }

    def "should received failed event when daemon disappears unexpectedly with TAPI higher 2.4"() {
        given:
        goodCode()
        def sync = server.expectAndBlock('sync')

    }

    private ToolingApiDistribution getToolingApi(final String versionToTestAgainst) {
        if (toolingApi == null) {
            toolingApi = ToolingApiDistributionResolver.use(new ToolingApiDistributionResolver.ResolverAction<ToolingApiDistribution>() {
                @Override

 */
abstract class ToolingApiLoggingSpecification extends ToolingApiSpecification {
    def setup() {
        if (!targetDist.toolingApiLoggingInEmbeddedModeSupported) {
            toolingApi.requireDaemons()
        }
    }

    @Issue("GRADLE-1799")
    @Timeout(60)
    def "promptly discovers rubbish jvm arguments"() {
        //jvm arguments cannot be set for an existing process
        //so we must not run in embedded mode
        toolingApi.requireDaemons()

        when:
        withConnection {
            it.newBuild()
                    .setJvmArguments("-Xasdf")
                    .run()
        }

        then:

        def packageExports = getPackageExports(packageNames, bundleVersion)
     """Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Gradle Tooling API
Bundle-Vendor: Gradle Inc.
Bundle-SymbolicName: org.gradle.toolingapi
Bundle-Version: ${bundleVersion}.v${qualifier}
Bundle-ClassPath: .
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Export-Package: ${packageExports}
Require-Bundle: org.slf4j.api;bundle-version="1.7.2"
"""
}

    /**
     * Additional classpath for given TAPI and target Gradle distribution to be added to the loader of the test class.
     */
    List<File> additionalClasspathFor(ToolingApiDistribution toolingApi, GradleDistribution distribution)

            rootProject.name = 'root'
        """
        buildFile << """
            plugins {
                id("my.plugin")
            }
        """

        when:
        def model = toolingApi.withConnection() { connection -> connection.getModel(BaseModel) }

        then:
        assertModelIsPolymorphic(model)
    }

    def "supports nested model polymorphism"() {
        given:

    def setup() {
        runner.minimumBaseVersion = "2.11"
    }

    def "get IDE model for Eclipse"() {
        given:
        setupRunner()

        runner.toolingApi("Eclipse model") {
            it.model(EclipseProject)
        }.run { builder ->
            def model = builder.get()
            // we must actually do something to highlight some performance issues