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

import org.gradle.tooling.ProjectConnection
import spock.lang.Issue

@TargetGradleVersion(">=4.8")
class CustomToolingModelCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        toolingApi.requireDaemons()

        file('build.gradle') << """
import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
import org.gradle.tooling.provider.model.ToolingModelBuilder
import javax.inject.Inject

    }

    def cleanup() {
        server.after()
    }

    @Timeout(value = 10, unit = TimeUnit.MINUTES)
    def "generates download events during maven publish"() {
        given:
        toolingApi.requireIsolatedUserHome()

        int metadataDownloads = 1
        int metadataChecksumDownloads = 0
        // Older versions of Gradle use maven-aether for maven-publish, and perform additional downloads

        expect:
        buildPluginWith("3.2.1")
        assertWorks()
    }

    private void assertWorks() {
        // So we don't try to use a classpath distribution
        toolingApi.requireDaemons()

        withConnector {
            // TestKit builds that use debug will set this to true
            it.embedded(true)
        }

        // Run the build

class CapturingUserInputCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        if (!dist.toolingApiStdinInEmbeddedModeSupported) {
            // Did not work in embedded mode in older versions
            toolingApi.requireDaemons()
        }

        file('buildSrc/src/main/java/BuildScanPlugin.java') << buildScanPlugin()
        file('build.gradle') << buildScanPluginApplication()
    }