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"))

        buildFile << '''
            allprojects {
                tasks.register('foo')
            }
        '''
        file('sub1/sub2').mkdirs()

        when:
        launchTestWithTestFilter(toolingApi.connector().forProjectDirectory(projectDir.file('sub1'))) {
            it.forTasks('foo')
        }

        then:
        !taskExecuted(':foo')
        taskExecuted(':sub1:foo')

            Rel(pluginPlugin, pluginPrecompiled, "Configures")
            Rel_Neighbor(pluginPrecompiled, pluginDevPlugin, "Applies", "and configures")
        }


        Container_Boundary(tapiBuilder, "IDE ToolingAPI Models") {

            Component(tapiModels, "TAPI Models", "classpath, sourcepath, implicit imports, user reports")

        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:

        }

        then:
        noExceptionThrown()
    }

    def "can cancel build through forced stop"() {
        // in-process call does not support forced stop
        toolingApi.requireDaemons()
        buildFile << """
task hang {
    doLast {
        ${server.callFromBuild("waiting")}
    }
}
"""
        def cancel = GradleConnector.newCancellationTokenSource()

    }

    @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')

    private RepositoryHttpServer server

    def setup() {
        server = new RepositoryHttpServer(temporaryFolder, targetDist.version.version)
        server.before()
        toolingApi.requireIsolatedUserHome()
    }

    def cleanup() {
        server.after()
    }

    private String expectedDisplayName(String name, String extension, String version) {

        PerformanceTestJvmOptions.normalizeGradleJvmOptions(useDaemon, PerformanceTestJvmOptions.normalizeJvmOptions(this.gradleOpts))
    }

    def <T extends LongRunningOperation> ToolingApiAction<T> toolingApi(String displayName, Function<ProjectConnection, T> initialAction) {
        useToolingApi = true
        def tapiAction = new ToolingApiAction<T>(displayName, initialAction)
        this.buildAction = tapiAction

    }

    @TargetGradleVersion('>=7.3')
    def "generates success event for failing first attempt to get dependency"() {
        toolingApi.requireIsolatedUserHome()

        def projectFModuleMissing = mavenHttpRepo.module('group', 'projectF', '2.0')
        projectFModuleMissing.missing()