}

    abstract BuildOperationRecord first(Pattern displayName)

    abstract List<BuildOperationRecord> all();

    List<BuildOperationRecord> all(String displayName) {
        return all(Pattern.compile(Pattern.quote(displayName)))
    }

    abstract List<BuildOperationRecord> all(Pattern displayName)

    BuildOperationRecord only(String displayName) {

    def "can create from classpath"() {
        when:
        def versions = new ReleasedVersionDistributions(IntegrationTestBuildContext.INSTANCE)

        then:
        !versions.all.empty
        versions.all*.version == versions.all*.version.sort().reverse()
    }

    def "get most recent final does that"() {
        when:
        props.mostRecent = "1.2"

        then:

  // ::testing_internal and ::testing::internal2, i.e. the global
  // namespace.  For more details, refer to the C++ Standard section
  // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
  // testing::internal2::operator<< in case T doesn't come with a <<
  // operator.
  //
  // We cannot write 'using ::testing::internal2::operator<<;', which
  // gcc 3.3 fails to compile due to a compiler bug.

    }

    private void verifyTaskIds() {
        // all register ops have unique task id
        def allRegisterOps = buildOperations.all(RegisterTaskBuildOperationType)
        def allRegisterIds = allRegisterOps*.details*.taskId
        allRegisterIds == allRegisterIds as Set

        // all realize ops have unique task id
        def allRealizeOps = buildOperations.all(RealizeTaskBuildOperationType)

     */
    public interface Callable<T, E extends Throwable> {
        T call() throws E;
    }

    public <T, E extends Throwable> T with(@Nullable BuildOperationRef state, Callable<T, E> block) throws E {
        BuildOperationRef oldState = get();
        try {
            set(state);
            return block.call();
        } finally {
            set(oldState);
        }
    }

        String methodName = call.getMethodAsString();
        if (call.isImplicitThis() && methodName != null && methodName.equals(DOLLAR)) {
            visitInputMethod(call);
            return;
        }
        // visit the method call, because one of the args may be an input method call
        super.visitMethodCallExpression(call);
    }

            // https://github.com/gradle/gradle-private/issues/3991
            System.out.println("Gradle runner not finished correctly (the build may be canceled). Fall back to KILL_ALL_GRADLE_PROCESSES.");
            executionMode = ExecutionMode.KILL_ALL_GRADLE_PROCESSES;
        }
    }

    private static void writePsOutputToFile(File rootProjectDir, List<String> psOutput) {

            thread.blockUntil.running
            lifecycle.stop()
            instant.stopped
        }

        then:
        instant.finished < instant.stopped
    }

    def "multiple threads can call stop() concurrently"() {
        expect:
        async {
            start {
                lifecycle.use {
                    instant.running
                    thread.block()
                }

import java.util.Map;

/**
 * An immutable view of all properties available for build options, calculated from command-line options, the environment and the various
 * properties files.
 */
public interface AllProperties {
    /**
     * Returns the system properties defined as command-line options.
     */
    Map<String, String> getRequestedSystemProperties();

    /**

     */
    void enqueue(Runnable task);

    /**
     * Runs the given action, blocking until the result is available.
     *