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

            tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            def buildAction = connection.action(new LoadCompositeModel(GradleProject))
            collectOutputs(buildAction)

            tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->
            ModelBuilder<GradleProject> modelBuilder = connection.model(GradleProject.class)
            collectOutputs(modelBuilder)

class BuildActionCrossVersionSpec extends ToolingApiSpecification {

    @Issue("https://github.com/gradle/gradle/issues/1180")
    def "can load custom action from url containing whitespaces"() {
        setup:
        toolingApi.requireIsolatedDaemons()
        def builder = new GradleBackedArtifactBuilder(new NoDaemonGradleExecuter(dist, temporaryFolder).withWarningMode(null), temporaryFolder.testDirectory.file("action"))

    private String buildOutput

    def setup() {
        // TODO(mlopatkin) Figure a way to have agent-based instrumentation in the embedded TAPI mode.
        toolingApi.requireDaemons()
    }

    def "agent is enabled in TAPI by default"() {
        withDumpAgentStatusTask()

        when:
        runDumpTaskWithTapi()

        then:
        agentWasApplied()
    }

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

    def "run compileJava via Tooling API"() {
        given:
        setupRunner()

        runner.toolingApi("Run task") {
            it.newBuild()
        }.run { builder ->
            builder.addProgressListener(new ProgressListener() {
                @Override
                void statusChanged(ProgressEvent event) {

        settingsFile << """
            includeBuild 'includedBuild'
        """
        singleProjectBuildInSubfolder("includedBuild")

        when:
        withConnection(toolingApi.connector().forProjectDirectory(projectDir.file('sub1')).searchUpwards(true)) {
            BuildInvocations invocations = getModel(BuildInvocations)
            def task = invocations.tasks.find { it.name.contains 'tasks' }

@CompileStatic
abstract class AbstractKotlinScriptModelCrossVersionTest extends ToolingApiSpecification implements KotlinDslTestProjectInitiation {

    def setup() {
        // Required for the lenient classpath mode
        toolingApi.requireDaemons()
        // Only Kotlin settings scripts
        settingsFile.delete()
        file("settings.gradle.kts").touch()
        // Gradle 6.5.1 instrumented jar cache has concurrency issues causing flakiness

            return cleanProjectDir(specification)
        }
        false
    }

    static boolean cleanProjectDir(Object specification) {
        if (specification.hasProperty("toolingApi")) {
            specification.toolingApi.cleanUpIsolatedDaemonsAndServices()
        }
        if (specification.hasProperty("caughtGradleConnectionException")) {
            specification.caughtGradleConnectionException = null
        }