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()
    }

            invoker = GradleBuildInvoker.AndroidStudio;
        } else if (invocationSpec.isUseToolingApi()) {
            invoker = invocationSpec.isUseDaemon()
                ? GradleBuildInvoker.ToolingApi
                : GradleBuildInvoker.ToolingApi.withColdDaemon();
        } else {
            invoker = invocationSpec.isUseDaemon()
                ? GradleBuildInvoker.Cli
                : GradleBuildInvoker.CliNoDaemon;
        }

    implementation(projects.processServices)
    implementation(projects.serialization)
    implementation(projects.stdlibKotlinExtensions)
    implementation(projects.stdlibSerializationCodecs)
    implementation(projects.toolingApi)

    implementation(libs.fastutil)
    implementation(libs.groovyJson)
    implementation(libs.guava)
    implementation(libs.slf4jApi)

    runtimeOnly(project(":composite-builds"))

To use the Tooling API, add the following repository and dependency declarations to your build script:

.Using the tooling API
====
include::sample[dir="snippets/toolingApi/runBuild/kotlin",files="build.gradle.kts[tags=use-tooling-api]"]
include::sample[dir="snippets/toolingApi/runBuild/groovy",files="build.gradle[tags=use-tooling-api]"]
====

        when:
        def nullModel = withConnection { it.action(new NullAction()).run() }

        then:
        nullModel == null
    }

    def "action classes are reused in daemon"() {
        toolingApi.requireIsolatedDaemons()

        expect:
        def result1 = withConnection { it.action(new CounterAction()).run() }
        def result2 = withConnection { it.action(new CounterAction()).run() }

class CrossVersionToolingApiSpecificationRetryTest extends ToolingApiSpecification {

    def setup() {
        //these meta tests mess with the daemon log: do not interfere with other tests when running in parallel
        toolingApi.requireIsolatedDaemons()
    }

    def iteration = 0

    def "does not retry if NPE is thrown in daemon registry in >=1.8"() {
        given:
        iteration++

        when:

    }

    @Issue("gradle/gradle#1641")
    @TargetGradleVersion(">=3.5 <4.0")
    def "generates download events during maven publish"() {
        given:
        toolingApi.requireIsolatedUserHome()
        if (targetDist.version.version == "3.5-rc-1") {
            return
        }
        def module = mavenHttpRepo.module('group', 'publish', '1')