import org.gradle.internal.snapshot.ValueSnapshot;

public class IdentityContext extends ExecutionRequestContext {

    private final ImmutableSortedMap<String, ValueSnapshot> inputProperties;
    private final ImmutableSortedMap<String, CurrentFileCollectionFingerprint> inputFileProperties;
    private final Identity identity;

public class ChoosePipelineStep<C extends IdentityContext, R extends Result> implements Step<C, R> {

    private final Step<? super IdentityContext, ? extends R> immutablePipeline;
    private final Step<? super IdentityContext, ? extends R> mutablePipeline;

    public ChoosePipelineStep(
        Step<? super IdentityContext, ? extends R> immutablePipeline, Step<? super IdentityContext, ? extends R> mutablePipeline
    ) {

    }

    @Nonnull
    private IdentityContext createIdentityContext(UnitOfWork work, C context) {
        Class<? extends UnitOfWork> workType = work.getClass();
        return operation(operationContext -> {
                IdentityContext identityContext = createIdentityContextInternal(work, context);
                Identity identity = identityContext.getIdentity();

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) {
        super(parent);

public class IdentityCacheStep<C extends IdentityContext, R extends WorkspaceResult> implements DeferredExecutionAwareStep<C, R> {

    private final BuildOperationProgressEventEmitter progressEventEmitter;
    private final Step<? super IdentityContext, ? extends R> delegate;

    public IdentityCacheStep(BuildOperationProgressEventEmitter progressEventEmitter, Step<? super IdentityContext, ? extends R> delegate) {

            ImmutableSortedMap.of(),
            ImmutableSortedMap.of("input-files", inputFilesFingerprint),
            ImmutableSet.of()
        )

        1 * delegate.execute(work, _ as IdentityContext) >> { UnitOfWork work, IdentityContext delegateContext ->
            assert delegateContext.inputProperties as Map == ["input": inputSnapshot]
            assert delegateContext.inputFileProperties as Map == ["input-files": inputFilesFingerprint]

 */

package org.gradle.internal.execution.steps

import org.gradle.internal.execution.ImmutableUnitOfWork
import org.gradle.internal.execution.MutableUnitOfWork

class ChoosePipelineStepTest extends StepSpec<IdentityContext> {
    def incrementalPipeline = Mock(Step)
    def nonIncrementalPipeline = Mock(Step)
    def step = new ChoosePipelineStep(nonIncrementalPipeline, incrementalPipeline)

 */

package org.gradle.internal.execution.steps;

import org.gradle.internal.execution.MutableUnitOfWork;
import org.gradle.internal.execution.UnitOfWork;

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) {

import org.gradle.internal.execution.steps.HandleStaleOutputsStep;
import org.gradle.internal.execution.steps.IdentifyStep;
import org.gradle.internal.execution.steps.IdentityCacheStep;
import org.gradle.internal.execution.steps.IdentityContext;
import org.gradle.internal.execution.steps.LoadPreviousExecutionStateStep;
import org.gradle.internal.execution.steps.NeverUpToDateStep;
import org.gradle.internal.execution.steps.NoInputChangesStep;

import org.gradle.internal.execution.UnitOfWork
import org.gradle.internal.execution.workspace.MutableWorkspaceProvider

import java.time.Duration

class AssignMutableWorkspaceStepTest extends StepSpec<IdentityContext> {
    def delegateExecution = Mock(ExecutionEngine.Execution)
    def delegateResult = Stub(CachingResult) {
        duration >> Duration.ZERO
        execution >> Try.successful(delegateExecution)
    }