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

    def "detects no change between empty current and previous"() {
        when:
        detector.visitChangesSince([:], [:], "test", visitor)
        then:
        0 * _
    }

    def "detects no change between the same one item"() {
        when:

    /**
     * Any attribute change in the watched directory or subtree causes a change notification wait operation to return.
     */
    public static final int FILE_NOTIFY_CHANGE_ATTRIBUTES = 0x00000004;

    /**
     * Any file-size change in the watched directory or subtree causes a change notification wait operation to return.

    public ChangeTypeInternal getType() {
        return change;
    }

    @Override
    public boolean isAdded() {
        return change == ChangeTypeInternal.ADDED;
    }

    @Override
    public boolean isModified() {
        return change == ChangeTypeInternal.MODIFIED;
    }

    @Override
    public boolean isRemoved() {
        return change == ChangeTypeInternal.REMOVED;
    }

        inputChanges.getFileChanges(classesDir)
            .filter { change -> change.fileType == FileType.FILE }
            .forEach { change ->
                when {
                    change.normalizedPath.endsWith(".class") -> handleClassChange(change, superTypes)
                    // "instrumented-classes.txt" is always just one in a classes dir

	sct.lock.Lock()
	defer sct.lock.Unlock()

	change, exists := sct.items[namespacedName]
	if !exists {
		change = &serviceChange{}
		change.previous = sct.serviceToServiceMap(previous)
		sct.items[namespacedName] = change
	}
	change.current = sct.serviceToServiceMap(current)
	// if change.previous equal to change.current, it means no change
	if reflect.DeepEqual(change.previous, change.current) {
		delete(sct.items, namespacedName)

        )

        // tag::process-file-changes[]
        inputChanges.getFileChanges(inputDir).each { change ->
            if (change.fileType == FileType.DIRECTORY) return

            println "${change.changeType}: ${change.normalizedPath}"
            def targetFile = outputDir.file(change.normalizedPath).get().asFile
            if (change.changeType == ChangeType.REMOVED) {
                targetFile.delete()
            } else {

        }

        @Override
        public boolean visitChange(Change change) {
            if (numChanges < maxCachedChanges) {
                numChanges++;
                cache.add(change);
            } else {
                overrun = true;
                cache.clear();
            }
            return delegate.visitChange(change);
        }
    }

import java.util.List;

public class CollectingChangeVisitor implements ChangeVisitor {
    private List<Change> changes = new ArrayList<Change>();

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

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

        inputChanges.getFileChanges(input).forEach { change ->          // <2>
            val changedFile = change.file
            if (change.fileType != FileType.FILE) {
                return@forEach
            }
            val outputLocation = outputDir.resolve("${change.normalizedPath}.loc")
            when (change.changeType) {
                ChangeType.ADDED, ChangeType.MODIFIED -> {

        // tag::process-changed-inputs[]
        inputChanges.getFileChanges(inputDir).forEach { change ->
            if (change.fileType == FileType.DIRECTORY) return@forEach

            println("${change.changeType}: ${change.normalizedPath}")
            val targetFile = outputDir.file(change.normalizedPath).get().asFile
            if (change.changeType == ChangeType.REMOVED) {
                targetFile.delete()
            } else {