/**
 * 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);
                }
            };

        SnapshotDiffListener NOOP = (removedSnapshots, addedSnapshots) -> {};

        /**
         * Called after the update to {@link SnapshotHierarchy} finished.
         *
         * Only the roots of added/removed hierarchies are reported.
         */
        void changed(Collection<FileSystemLocationSnapshot> removedSnapshots, Collection<FileSystemLocationSnapshot> addedSnapshots);
    }

        when:
        ops.start("resolve", null, new OperationIdentifier(1), null).message == "resolve"

        then:
        thrown(IllegalStateException)
    }

    def "starts operations from different hierarchies"() {
        when:
        def op1 = ops.start("compile", null, new OperationIdentifier(1), null)
        def op2 = ops.start("resolve", null, new OperationIdentifier(2), null)

        then:

        result.output =~ /VFS> > Stat: Executed stat\(\) x 0. getUnixMode\(\) x 0/
        result.output =~ /VFS> > FileHasher: Hashed 0 files \(0 bytes\)/
        result.output =~ /VFS> > DirectorySnapshotter: Snapshot 0 directory hierarchies \(visited 0 directories, 0 files and 0 failed files\)/
        result.output =~ /Received \d+ file system events during the current build while watching \d+ locations/

    /**
     * Register a watchable hierarchy.
     *
     * Only locations within watchable hierarchies will be watched for changes.
     * This method is first called for the root directory of the root project.
     * It is also called for the root directories of included builds, and all other nested builds.
     */

        when:
        def out = serialize(snapshots, serializer)

        then:
        assertEqualSnapshots(out, snapshots)
    }

    def "reads and writes directory snapshot hierarchies"() {
        def snapshots = directory("/home/lptr/dev", [
            regularFile("/home/lptr/dev/one.txt"),
            regularFile("/home/lptr/dev/two.txt"),
            directory("/home/lptr/dev/empty", []),

## Adding New Feature Constants