1 * delegate.execute(work, _ as IncrementalChangesContext) >> { UnitOfWork work, IncrementalChangesContext delegateContext ->
            assert delegateContext.changes.get() == changes
            return delegateResult
        }
        _ * changes.changeDescriptions >> ImmutableList.of("changed")
        _ * context.nonIncrementalReason >> Optional.empty()
        _ * context.beforeExecutionState >> Optional.of(beforeExecutionState)

    def "empty snapshots"() {
        expect:
        changes(
            [:],
            [:]
        ) == []
    }

    def "trivial addition"() {
        expect:
        changes(
            ["one-new": fingerprint("one")],
            [:]
        ) == [added("one-new": "one")]
    }

    def "non-trivial addition"() {
        expect:
        changes(

 */

package org.gradle.internal.execution.steps

import com.google.common.collect.ImmutableList
import org.gradle.internal.execution.history.PreviousExecutionState
import org.gradle.internal.execution.history.changes.ExecutionStateChanges
import org.gradle.internal.hash.TestHashCodes

        oldMethods.removeAll(newMethods)

        if (oldMethods.isEmpty()) {
            return null
        }

        List<String> changes = filterChangesToReport(oldClass, oldMethods)
        if (changes.isEmpty()) {
            return null
        }
        return acceptOrReject(c, changes, Violation.error(c, " methods removed in internal super class"))
    }

    private Set<CtMethod> collectAllPublicApiMethods(CtClass c) {

    }

    def "trivial content change"() {
        expect:
        changes(
            regularFile("one", 0x1234),
            regularFile("one", 0xffff)
        ) == [modified("one")]
    }

    def "deep equality"() {
        expect:
        changes(
            directory("root", [
                regularFile("root/one", 0x1234),

package org.gradle.internal.execution.history.changes


import spock.lang.Specification

class LimitingChangeVisitorTest extends Specification {

    def collectingVisitor = new CollectingChangeVisitor()
    def visitor = new LimitingChangeVisitor(2, collectingVisitor)

    def "will not accept more changes than specified"() {
        def change1 = Mock(Change)
        def change2 = Mock(Change)

        expect:

        visitor.getChanges().empty
    }

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

        when:
        state.accept(visitor)

        then:
        1 * state1.accept(_) >> { args ->
            args[0].visitChange(change1)
        }
        0 * _

        and:
        visitor.changes == [change1]
    }

        executedAndNotSkipped(":myTask")

        when:
        withWatchFs().run "myTask"
        then:
        skipped(":myTask")
    }

    @Issue("https://github.com/gradle/gradle/issues/11851")
    def "changes to #description are detected"() {
        file(fileToChange).createFile()
        file(linkSource).createLink(file(linkTarget))

        buildFile << """
            task myTask {

        def changes = new NonIncrementalInputChanges(ImmutableSortedMap.<String, CurrentFileCollectionFingerprint>of("input", fingerprint), new DefaultIncrementalInputProperties(ImmutableBiMap.of("input", value)))
        def expectedChangedFiles = [new File("/some/where")]

        when:
        def allFileChanges = changes.allFileChanges
        def fileChanges = changes.getFileChanges(value)

        then:

            List<String> changes = []
            if (operatorChanged) {
                changes.add(modifierChangeDetail("operator", newIsOperator))
            }
            if (infixChanged) {
                changes.add(modifierChangeDetail("infix", newIsInfix))
            }
            return acceptOrReject(member, changes, Violation.error(member, "Breaking Kotlin modifier change"))
        }

        return null