def toolingApi = new ToolingApi(distribution, testDirectoryProvider)
        toolingApi.withConnector {
            it.forProjectDirectory(workingDir)
        }

        def systemPropertiesBeforeInvocation = new HashMap<String, Object>(System.getProperties())

        try {
            toolingApi.withConnection {
                action.execute(it)
            }

            this.gradle = packagedDistribution
            this.toolingApi = loadedDistribution
        } else {
            // TAPI {target} -> Gradle current
            this.gradle = loadedDistribution
            this.toolingApi = packagedDistribution
        }
        this.toolingApiVersion = GradleVersion.version(toolingApi.version.version)
        this.gradleVersion = GradleVersion.version(gradle.version.version)

        hasSystemProperty('mySystemProperty', 'defined in the client JVM')
    }

    def "Client JVM system properties do not appear in the build if withSystemProperties() is called"() {
        setup:
        toolingApi.requireDaemons() // no separate daemon JVM -> all client JVM system properties are expected to be visible

        when:
        runTask { withSystemProperties('unrelated' : 'value') }

        then:

            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:

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

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

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:

                }
            }
        """

        return pluginBuilder
    }

    private <T> T fetchSchemaModel(Class<T> modelType) {
        toolingApi.withConnection() { connection ->
            ModelBuilder<T> modelBuilder = connection.model(modelType)
            collectOutputs(modelBuilder)
            modelBuilder.get()
        }
    }