}

        // tag::problems-tapi-event[]
        @Override
        public void statusChanged(ProgressEvent progressEvent) {
            prettyPrint(((ProblemDescriptor) progressEvent.getDescriptor()));
        }
        // end::problems-tapi-event[]

        static void prettyPrint(ProblemDescriptor problem) {
            System.out.println("Problem:");

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.
 *

import java.lang.annotation.Inherited
import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy
import java.lang.annotation.Target


/**
 * Declares the provider to use for TAPI client additional classpath.
 *
 * @see ToolingApiAdditionalClasspathProvider
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@interface ToolingApiAdditionalClasspath {

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

    private final BuildCancellationToken token;
    private final BuildEventConsumer buildEventConsumer;
    private final BuildRequestMetaData metaData;

    // TODO: Decide if we want to push the gate concept into TAPI or other entry points
    // currently, a gate is only used by continuous build and can only be controlled from within the build.

    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'

/**
 * Transformation for legacy instrumentation when transformed JARs are part of the classpath.
 * This is still used when TestKit and TAPI run Gradle in embedded or debug mode.
 * <p>
 * This transformation filters out not yet supported versioned directories of the multi-release JARs.
 */

        Rel_U(tapiBuilder, provider, "Uses")
        Rel_Neighbor(plugin, provider, "Uses")
        Rel_Neighbor(resolver, tapiBuilder, "Uses", "TAPI")
    }

    Rel(gradle, provider, "Uses", "Script compilation")
    Rel(gradle, plugin, "Uses", "e.g. in `buildSrc`")
}

System_Boundary(ide, "IntelliJ IDE") {