}

    @Override
    public ExecutionResult<Void> execute(BuildTreeWorkGraph.FinalizedGraph graph) {
        return buildOperationRunner.call(new CallableBuildOperation<ExecutionResult<Void>>() {
            @Override
            public ExecutionResult<Void> call(BuildOperationContext context) {
                return delegate.execute(graph);
            }

            @Override

    }

    public IncrementalCompilation processSourceFiles(final Collection<File> sourceFiles) {
        return buildOperationExecutor.call(new CallableBuildOperation<IncrementalCompilation>() {
            @Override
            public IncrementalCompilation call(BuildOperationContext context) {
                CompilationState previousCompileState = previousCompileStateCache.get();

    /**
     * Visits a node of the graph. Includes the root. This method is called for all nodes before {@link #visitEdges(DependencyGraphNode)} is called.
     */
    default void visitNode(DependencyGraphNode node) {}

    /**
     * Visits a selector. This method is called for all selectors before {@link #visitEdges(DependencyGraphNode)} is called.
     */

            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