outputFile: outputFileSnapshot
        ]

        when:
        def result = packOperationExecutor.unpack(key, entity, input)

        then:
        1 * buildOperationRunner.call(_) >> { CallableBuildOperation action -> action.call(buildOperationContext)}
        1 * originFactory.createReader() >> originReader

        then:

     */
    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);
        }
    }

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

        when:
        module.ivy.expectMetadataRetrieve()

        then:
        fails 'retrieve'
        assertTaskFailureDescription(":retrieve")
        failure.assertHasCause("Could not resolve all files for configuration ':compile'.")
            .assertHasCause("""Could not find org.group.name:projectA:1.2.
Searched in the following locations:
  - ${module.ivy.uri}
Required by:
""")

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

        if (buildSrcBuild == null) {
            return ClassPath.EMPTY;
        }

        return buildOperationRunner.call(new CallableBuildOperation<ClassPath>() {
            @Override
            public ClassPath call(BuildOperationContext context) {
                ClassPath classPath = buildBuildSrc(buildSrcBuild);
                context.setResult(BUILD_BUILDSRC_RESULT);

    }

    @Override
    List<BuildOperationRecord> all() {
        return operations.records.values().toList()
    }

    @Override
    List<BuildOperationRecord> all(Pattern displayName) {
        return operations.records.values().findAll { it.displayName ==~ displayName }
    }

    @Override
    BuildOperationRecord only(Pattern displayName) {
        def records = all(displayName)
        if (records.isEmpty()) {

/**
 * The outputs of a graph resolution. All results on this type are lazy. Resolution is only performed
 * when the results are accessed.
 *
 * TODO: This type is intended to be made public in future Gradle versions, in some form.
 */
@HasInternalProtocol
public interface ResolutionOutputs {

    /**
     * A {@link FileCollection} containing all resolved files. The returned collection

import org.gradle.internal.HasInternalProtocol;

/**
 * Allows configuring dependency resolution for all projects of the build.
 *
 * @since 6.8
 *
 */
@HasInternalProtocol
public interface DependencyResolutionManagement {
    /**
     * Configures the repositories used by all projects
     * @param repositoryConfiguration the repositories configuration
     */
    @Incubating
    @Configuring