import javax.annotation.Nullable;
import java.io.File;
import java.util.Optional;

public class WorkspaceContext extends IdentityContext {
    private final File workspace;
    private final ExecutionHistoryStore history;
    private final boolean captureBeforeExecutionState;

    public WorkspaceContext(IdentityContext parent, File workspace, @Nullable ExecutionHistoryStore history, boolean captureBeforeExecutionState) {

public class AssignMutableWorkspaceStep<C extends IdentityContext> implements Step<C, WorkspaceResult> {
    private final Step<? super WorkspaceContext, ? extends CachingResult> delegate;

    public AssignMutableWorkspaceStep(Step<? super WorkspaceContext, ? extends CachingResult> delegate) {
        this.delegate = delegate;
    }

    @Override
    public WorkspaceResult execute(UnitOfWork work, C context) {

 * limitations under the License.
 */

package org.gradle.internal.execution.steps

abstract class TestCachingContext extends WorkspaceContext implements CachingContext {
    TestCachingContext(WorkspaceContext parent) {
        super(parent)
    }

    private static class MockStep implements Step<WorkspaceContext, CachingResult> {
        BiFunction<UnitOfWork, WorkspaceContext, CachingResult> expectCall

        @Override
        CachingResult execute(UnitOfWork work, WorkspaceContext context) {
            def call = expectCall
            expectCall = null
            return call.apply(work, context)

        }

        then:
        1 * fileSystemAccess.invalidate([temporaryWorkspace.absolutePath])

        then:
        1 * delegate.execute(work, _ as WorkspaceContext) >> { UnitOfWork work, WorkspaceContext delegateContext ->
            assert delegateContext.workspace == temporaryWorkspace
            temporaryWorkspace.file("output.txt").text = "output"
            return delegateResult
        }

public interface AfterExecutionOutputFilter<C extends WorkspaceContext> {
    ImmutableSortedMap<String, FileSystemSnapshot> filterOutputs(C context, BeforeExecutionState beforeExecutionState, ImmutableSortedMap<String, FileSystemSnapshot> outputSnapshotsAfterExecution);

    AfterExecutionOutputFilter<WorkspaceContext> NO_FILTER = (context, beforeExecutionState, outputSnapshotsAfterExecution) -> outputSnapshotsAfterExecution;

import javax.annotation.Nullable;
import java.util.Optional;

public class PreviousExecutionContext extends WorkspaceContext {
    private final PreviousExecutionState previousExecutionState;

    public PreviousExecutionContext(WorkspaceContext parent, @Nullable PreviousExecutionState previousExecutionState) {
        super(parent);
        this.previousExecutionState = previousExecutionState;
    }

            def actionResult = action.executeInWorkspace(workspace, null)
            return actionResult
        }
        1 * delegate.execute(work, _ as WorkspaceContext) >> { UnitOfWork work, WorkspaceContext context ->
            assert context.workspace == workspace
            return delegateResult
        }
        0 * _

        when:
        def output = result.getOutputAs(Object)

import org.gradle.internal.execution.UnitOfWork;
import org.gradle.internal.execution.UnitOfWork.Identity;
import org.gradle.internal.execution.history.PreviousExecutionState;

public class LoadPreviousExecutionStateStep<C extends WorkspaceContext, R extends AfterExecutionResult> implements Step<C, R> {
    private final Step<? super PreviousExecutionContext, ? extends R> delegate;

import static org.gradle.internal.execution.ExecutionEngine.ExecutionOutcome.SHORT_CIRCUITED
import static org.gradle.internal.properties.InputBehavior.PRIMARY

abstract class AbstractSkipEmptyWorkStepTest<C extends WorkspaceContext> extends StepSpec<C> {
    def workInputListeners = Mock(WorkInputListeners)
    def inputFingerprinter = Mock(InputFingerprinter)
    def primaryFileInputs = EnumSet.of(PRIMARY)