*     This helps decide whether or not something is being watched in a quick way.</dd>
 *
 *     <dt>watched hierarchies</dt>
 *     <dd>The list of file system hierarchies we are currently watching.
 *     When hierarchies are nested inside each other, this includes only the outermost hierarchies.
 *     On OSs with hierarchical file system events (currently Windows and macOS) this is what we tell the
 *     operating system to watch.

import java.util.Collection;
import java.util.List;

/**
 * Updater for hierarchical file watchers.
 *
 * For hierarchical watchers, we can use the registered watchable hierarchies as watched directories.
 * Build root directories are always watchable hierarchies.
 * Watching the build root directories is better since they are less likely to be deleted and

    /**
     * Retain only those classes in the keep package hierarchies, plus any classes that are reachable from these classes.
     */
    abstract val keepPackages: SetProperty<String>

    /**
     * Do not rename classes in the unshaded package hierarchies. Always includes 'java'.
     */
    abstract val unshadedPackages: SetProperty<String>

    /**

        MODIFIED,
        REMOVED,
        INVALIDATED,
        OVERFLOW
    }

    /**
     * Registers a watchable hierarchy.
     *
     * The watcher registry will only watch for changes in watchable hierarchies.
     *
     * @throws WatchingNotSupportedException when the native watchers can't be updated.
     */
    void registerWatchableHierarchy(File watchableHierarchy, SnapshotHierarchy root);

    /**

    }

    @Provides
    MissingTaskDependencyDetector createMissingTaskDependencyDetector(ExecutionNodeAccessHierarchies hierarchies) {
        return new MissingTaskDependencyDetector(hierarchies.getOutputHierarchy(), hierarchies.createInputHierarchy());
    }

    @Provides
    TaskExecuter createTaskExecuter(
        AsyncWorkTracker asyncWorkTracker,

     *
     * @param file the jar/directory to transform
     * @param classTransform the transform that will be applied to every class
     * @param typeRegistry the registry of type hierarchies
     * @return the transformation that will transform the file upon request.
     */
    ClasspathElementTransform createTransformer(File file, ClassTransform classTransform, InstrumentationTypeRegistry typeRegistry);

/**
 * Represents some resource that may have content.
 *
 * <p>This type is currently pretty much empty. It's here as a place to extract and reuse stuff from the various subtypes, which all stared off as separate hierarchies.
 */
public interface Resource extends Describable {
    /**
     * Returns a display name for this resource. This can be used in log and error messages.
     *
     * @return the display name
     */

 * Once the event arrives, {@link #triggerWatchProbe(String)} is called with the path,
 * and the probe becomes triggered (or proven).
 *
 * The {@link #unprovenHierarchies()} stream returns any hierarchies that were armed, but never received
 * a file system event.
 * These locations cannot be trusted to receive file system events in a timely manner.
 *

    }

    @Override
    int getIfNonHierarchical() { 1 }

    def "only watches directories in hierarchies to watch"() {
        def watchableHierarchies = ["first", "second", "third"].collect { file(it).createDir() }
        def fileInWatchableHierarchies = file("first/inside/root/dir/file.txt")

                    return failedFileCount;
                }

                @Override
                public String toString() {
                    return MessageFormat.format("Snapshot {0,number,integer} directory hierarchies (visited {1,number,integer} directories, {2,number,integer} files and {3,number,integer} failed files)",
                        hierarchyCount, directoryCount, fileCount, failedFileCount);
                }
            };