if (isClassloadedVersionCurrent()) {
            // Gradle current -> TAPI {source}
            this.gradle = packagedDistribution
            this.toolingApi = loadedDistribution
        } else {
            // TAPI {target} -> Gradle current
            this.gradle = loadedDistribution
            this.toolingApi = packagedDistribution
        }

import java.lang.annotation.Target;

/**
 * Annotation used to mark TAPI model interfaces. On the client side such interfaces
 * are instantiated via Java dynamic proxies, and we use this annotation when we want
 * these proxies to have richer behaviour than just implementing the base interface.
 * <p>
 * For example. Let's say the TAPI model interface is {@code Animal}, but which also

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

        
        gradle["Gradle CLI client"]
    
        gradlew["Gradlew CLI client"]
    
        subgraph IDE    
            tapi["Tooling API client"]
        end
        
        daemon["Gradle daemon"]
        gradle --> daemon
        gradlew --> daemon
        tapi --> daemon
        
        worker["Worker process"]
        daemon --> worker

        worker2["Worker process"]
        daemon --> worker2

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification
import spock.lang.Issue

/**
 * Tests for the tooling API, which check fetching models and running actions using different
 * combinations of versions of the TAPI and Gradle.
 *
 * Support for clients using a tooling API version older than 3.0 was removed in Gradle 5.0, so
 * there is a class-level lower bound for both versions.
 *

    else -> sameType(valueType, isAssignableTo)
}


/**
 * Can't check for equality: TAPI proxies are not equal to the original implementations.
 * TODO: maybe "reify" the TAPI proxies to ensure equality?
 */
private
fun sameType(left: DataType, right: DataType) = when (left) {

    testImplementation(testFixtures(project(":core"))) {
        because("ConcurrentSpecification")
    }
    testImplementation(project(":tooling-api")) {
        because("Unit tests verify serialization works with TAPI types")
    }
    testImplementation(testFixtures(project(":daemon-protocol")))

    // Newer clients no longer kill the JVM when a distribution is invalid.
    @TargetGradleVersion(">=3.0 <6.3")
    def "invalid Gradle distribution does not kill the TAPI client with older Gradle versions"() {
        given:
        toolingApi.requireDaemons()
        toolingApi.requireIsolatedUserHome()
        withConnection { connection ->

        mavenRepo.module("org.example", "example-lib", "1.0").publish()
        localMaven = "maven { url '${mavenRepo.uri}' }"
    }

    // TODO (donat) add more coverage after all classpath entry types are exposed via the TAPI

    def "respects manipulation done in the eclipse.classpath.whenMerged closure"() {
        setup:
        settingsFile << 'rootProject.name = "root"'
        buildFile <<
        """apply plugin: 'java'

            "gradleEnvironmentVariables" to mapOf("myEnvVar" to "envValue")
        )
    }

    @Test
    fun `report file fatality on TAPI failure`() {
        // thus disabling syntax highlighting

        val editedScript = withBuildScript("")

        val wrongEnv = arrayOf("gradleHome" to existing("absent"))