this.executionStateChanges = executionStateChanges;
    }

    protected IncrementalChangesContext(IncrementalChangesContext parent) {
        this(parent, parent.getRebuildReasons(), parent.getChanges().orElse(null));
    }

    /**
     * Returns the reasons to re-execute the work, empty if there's no reason to re-execute.
     */
    public ImmutableList<String> getRebuildReasons() {

        changes.accept(propertyName, visitor);
        return Cast.uncheckedNonnullCast(visitor.getChanges());
    }

    @Override
    public Iterable<InputFileDetails> getAllFileChanges() {
        CollectingChangeVisitor visitor = new CollectingChangeVisitor();
        changes.accept(visitor);
        return Cast.uncheckedNonnullCast(visitor.getChanges());
    }

    private List<Change> changes = new ArrayList<Change>();

    @Override
    public boolean visitChange(Change change) {
        changes.add(change);
        return true;
    }

    public Collection<Change> getChanges() {
        return changes;
    }

        then:
        interaction {
            receivesChanges(change1, change2)
        }
        0 * _

        when:
        cachingChanges.accept(collectingVisitor)
        def reported = collectingVisitor.getChanges()

        then:
        0 * _

        and:
        reported == [change1, change2]
    }

    def "does not cache once reported changes exceed cache size"() {
        when:

        when:
        state.accept(visitor)

        then:
        1 * state1.accept(_) >> true
        1 * state2.accept(_) >> true
        0 * _

        and:
        visitor.getChanges().empty
    }

    def "only returns changes from a single delegate"() {
        def change1 = Mock(Change)

        when:
        state.accept(visitor)

        then:

    ) {
        super(buildCache, emitDebugLogging);
        this.delegate = delegate;
    }

    @Override
    protected Optional<HashCode> getPreviousCacheKeyIfApplicable(C context) {
        return context.getChanges()
            .flatMap(changes -> context.getPreviousExecutionState()
                .filter(__ -> changes.getChangeDescriptions().isEmpty())
                .map(PreviousExecutionState::getCacheKey));
    }

        if (work.getExecutionBehavior() == NON_INCREMENTAL) {
            return null;
        }
        ExecutionStateChanges changes = context.getChanges()
            .orElseThrow(() -> new IllegalStateException("Changes are not tracked, unable determine incremental changes."));
        InputChangesInternal inputChanges = changes.createInputChanges();

        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Determining if {} is up-to-date", work.getDisplayName());
        }
        ImmutableList<String> reasons = context.getRebuildReasons();
        return context.getChanges()
            .filter(__ -> reasons.isEmpty())
            .map(changes -> skipExecution(work, context))
            .orElseGet(() -> executeBecause(work, reasons, context));
    }

        def outputFileChanges = new OutputFileChanges(ImmutableSortedMap.of("test", previousSnapshot), ImmutableSortedMap.of("test", currentSnapshot))
        outputFileChanges.accept(visitor)
        visitor.getChanges().collect {new DescriptiveChange(it.message) }.toList()
    }

    def added(String path) {
        new DescriptiveChange("Output property 'test' file ${FilenameUtils.separatorsToSystem(path)} has been added.")
    }

        CLASSPATH.visitChangesSince(previousFingerprint, currentFingerprint, "test", visitor)
        visitor.getChanges().toList()
    }

    def fingerprint(String normalizedPath, def hashCode = 0x1234abcd) {