* Returns if this task was executed incrementally.
         *
         * See {@code org.gradle.work.InputChanges#isIncremental()}.
         */
        @NotUsedByScanPlugin("used to report incrementality to TAPI progress listeners")
        boolean isIncremental();

    }

    private ExecuteTaskBuildOperationType() {

    }

import org.slf4j.LoggerFactory;

/**
 * Loads the tooling API implementation of the Gradle version that will run the build (the "provider").
 * Adapts the rather clunky cross-version interface to the more readable interface of the TAPI client.
 */
public class DefaultToolingImplementationLoader implements ToolingImplementationLoader {
    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultToolingImplementationLoader.class);

            .withCommandLineGradleOpts("-Dorg.gradle.deprecation.trace=false") //suppress deprecation stack trace

        if (targetDist.toolingApiMergesStderrIntoStdout) {
            // The TAPI provider merges the streams, so need to merge the streams for command-line execution too
            executer.withArgument("--console=plain")
            executer.withTestConsoleAttached()

        def topLevelFunctions = topLevelReceiverType.memberFunctions.collect { toString() }
        !topLevelFunctions.find { it.contains("simpleName=testSoftwareType") }
    }

    def 'interpretation sequences obtained via TAPI are suitable for analysis'() {
        given:
        withSoftwareTypePlugins().prepareToExecute()

        file("settings.gradle.dcl") << """
            $ecosystemPluginInSettings
            conventions {

import static spock.lang.Retry.Mode.SETUP_FEATURE_CLEANUP

@Timeout(180)
@Retry(condition = { onContinuousBuildTimeout(instance, failure) }, mode = SETUP_FEATURE_CLEANUP, count = 2)
// Can't use the FS watching, embedded executor and TAPI together
@Requires(IntegTestPreconditions.NotEmbeddedExecutor)
abstract class ContinuousBuildToolingApiSpecification extends ToolingApiSpecification {

    public static final String BUILD_CANCELLED = "Build cancelled."

        return new TestVariant(rootId, "selected", discoveryRequest);
    }

    static TestVariant tapiTargetLoaded(UniqueId rootId, EngineDiscoveryRequest discoveryRequest) {
        String variant = "tapi";
        TestVariant testVariant = new TestVariant(rootId, variant, new ToolingApiClassloaderDiscoveryRequest(discoveryRequest, variant));

        } else if (daemonParameters.getRequestedJvmBasedOnJavaHome() != null && daemonParameters.getRequestedJvmBasedOnJavaHome() != Jvm.current()) {
            // Either the TAPI client or org.gradle.java.home has been provided
            resolvedJvm = Jvm.forHome(daemonParameters.getRequestedJvmBasedOnJavaHome().getJavaHome());
        } else {
            resolvedJvm = Jvm.current();
        }

        } else if (daemonParameters.getRequestedJvmBasedOnJavaHome() != null && daemonParameters.getRequestedJvmBasedOnJavaHome() != Jvm.current()) {
            // Either the TAPI client or org.gradle.java.home has been provided
            JavaLanguageVersion detectedVersion = JavaLanguageVersion.of(jvmVersionDetector.getJavaVersionMajor(daemonParameters.getRequestedJvmBasedOnJavaHome()));

/**
 * A {@link TestExecutionListener} that maps JUnit5 events to Gradle test events.
 * Most importantly, it will map assertion and platform failures to Gradle's {@link TestFailure} class, which we can send through the TAPI.
 */
@NonNullApi
public class JUnitPlatformTestExecutionListener implements TestExecutionListener {

    private final static List<TestFailureMapper> MAPPERS = Arrays.asList(
        new OpenTestAssertionFailedMapper(),

abstract class ToolingApiSpecification extends Specification implements KotlinDslTestProjectInitiation {
    /**
     * See https://github.com/gradle/gradle-private/issues/3216
     * To avoid flakiness when reusing daemons between CLI and TAPI
     */
    public static final List NORMALIZED_BUILD_JVM_OPTS = ["-Dfile.encoding=UTF-8", "-Duser.country=US", "-Duser.language=en", "-Duser.variant"]

    @Rule