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

        println "changing=" + context.details.changing
    }
}

dependencies {
    modules("org.test:moduleA:1.0") { changing = true }
    components {
        all(VerifyingRule)
    }
}
task resolve {
    def files = configurations.modules
    doLast {
        files*.name
    }
}
"""

        expect:
        succeeds("resolve")

 * requested by the user.
 *
 * <p>DO NOT CHANGE THIS INTERFACE - it is part of the cross-version protocol.
 *
 * <p>Consumer compatibility: This interface is used by all consumer versions from 4.8.</p>
 * <p>Provider compatibility: This interface is implemented by all provider versions from 4.8.</p>
 *
 * @since 4.8
 * @see org.gradle.tooling.internal.protocol.ConnectionVersion4
 */

 */

package org.gradle.tooling.internal.adapter;

import javax.annotation.Nullable;

public interface ViewBuilder<T> {

    /**
     * Mixes the given object into all views of the given type created using {@link #build(Object)}.
     * Applied to all views reachable from created views. The mix-in object should be serializable.
     *

}
// end::dependencies[]

if (project.hasProperty("useBom")) {
// tag::use_bom_rule[]
dependencies {
    components.all<JacksonBomAlignmentRule>()
}
// end::use_bom_rule[]
} else {
// tag::use_rule[]
dependencies {
    components.all<JacksonAlignmentRule>()
}
// end::use_rule[]
// tag::enforced_platform[]
dependencies {
    // Forcefully downgrade the virtual Jackson platform to 2.8.9

# tag::cli[]
# gradle dependentComponents --all
# end::cli[]
executable: gradle
args: dependentComponents --all

            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:
""")

# tag::cli[]
# gradle wrapper --gradle-version=4.0 --distribution-type=all
# end::cli[]
executable: gradle
args: "wrapper --gradle-version=4.0 --distribution-type=all"