private final ChangeDetector<S> changeDetector;

    public CompareStrategy(
        Function<C, ? extends Map<String, S>> indexer,
        Function<C, ? extends Multimap<String, HashCode>> rootHasher,
        ChangeDetector<S> changeDetector
    ) {
        this.indexer = indexer;
        this.rootHasher = rootHasher;
        this.changeDetector = changeDetector;
    }

import org.gradle.internal.execution.history.changes.CompareStrategy.ChangeDetector;
import org.gradle.internal.execution.history.changes.CompareStrategy.ChangeFactory;

import java.util.Map;

/**
 * Compares collections if either current or previous are empty, or both current and previous have one element.
 */
public class TrivialChangeDetector<S> implements ChangeDetector<S> {
    private final ItemComparator<S> itemComparator;

    private final ExecutionStateChangeDetector changeDetector;

    private final Step<? super IncrementalChangesContext, R> delegate;

    public ResolveChangesStep(
        ExecutionStateChangeDetector changeDetector,
        Step<? super IncrementalChangesContext, R> delegate
    ) {
        this.changeDetector = changeDetector;
        this.delegate = delegate;
    }

    @Override

        }
    };

    public AbstractFingerprintCompareStrategy(ChangeDetector<FileSystemLocationFingerprint> changeDetector) {
        super(
            FileCollectionFingerprint::getFingerprints,
            FileCollectionFingerprint::getRootHashes,
            new TrivialChangeDetector<>(ITEM_COMPARATOR, FINGERPRINT_CHANGE_FACTORY, changeDetector)
        );
    }

import org.gradle.internal.execution.history.changes.CompareStrategy.ChangeDetector;

import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

/**
 * Compares by absolute paths and file contents. Order does not matter.
 */
public class AbsolutePathChangeDetector<S> implements ChangeDetector<S> {

    private final ItemComparator<S> itemComparator;

import org.gradle.internal.execution.history.changes.ExecutionStateChanges

class ResolveChangesStepTest extends StepSpec<ValidationFinishedContext> {
    def changeDetector = Mock(ExecutionStateChangeDetector)
    def step = new ResolveChangesStep<>(changeDetector, delegate)
    def beforeExecutionState = Stub(BeforeExecutionState) {
        inputFileProperties >> ImmutableSortedMap.of()
        inputProperties >> ImmutableSortedMap.of()

        BuildCacheController buildCacheController,
        BuildOperationRunner buildOperationRunner,
        ClassLoaderHierarchyHasher classloaderHierarchyHasher,
        Deleter deleter,
        ExecutionStateChangeDetector changeDetector,
        OutputChangeListener outputChangeListener,
        OutputSnapshotter outputSnapshotter,
        OverlappingOutputDetector overlappingOutputDetector,

        ClassLoaderHierarchyHasher classLoaderHierarchyHasher,
        CurrentBuildOperationRef currentBuildOperationRef,
        Deleter deleter,
        ExecutionStateChangeDetector changeDetector,
        FileSystemAccess fileSystemAccess,
        ImmutableWorkspaceMetadataStore immutableWorkspaceMetadataStore,
        OutputChangeListener outputChangeListener,

class TrivialChangeDetectorTest extends Specification {
    def itemComparator = Mock(TrivialChangeDetector.ItemComparator)
    def changeFactory = Mock(CompareStrategy.ChangeFactory)
    def delegate = Mock(CompareStrategy.ChangeDetector)
    def detector = new TrivialChangeDetector(itemComparator, changeFactory, delegate)

    def change = Mock(Change)
    def visitor = Mock(ChangeVisitor)

import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;

import static java.util.Map.Entry.comparingByKey;

public enum NormalizedPathChangeDetector implements CompareStrategy.ChangeDetector<FileSystemLocationFingerprint> {

    INSTANCE;

    /**
     * Determines changes by:
     *
     * <ul>