then:
        1 * statisticsCollector.recordVisitHierarchy()

        then:
        1 * statisticsCollector.recordVisitDirectory()
        0 * _
    }

    def "can visit directory hierarchy"() {
        given:
        def root = tmpDir.createDir("root")
        def subDir1 = root.createDir("sub-dir-1")
        subDir1.createFile("file.txt")
        def subDir2 = root.createDir("sub-dir-2")

        new HierarchicalFileWatcherUpdater(watcher, NO_VALIDATION, probeRegistry, watchableHierarchies, movedWatchedDirectoriesSupplier)
    }

    @Override
    int getIfNonHierarchical() { 0 }

    def "does not watch hierarchy to watch if no snapshot is inside"() {
        def watchableHierarchy = file("watchable").createDir()
        def secondWatchableHierarchy = file("watchable2").createDir()

/**
 * Determines how exceptions are formatted in test logging.
 */
public enum TestExceptionFormat {
    /**
     * Short display of exceptions.  Shows the exception types and locations as well as the hierarchy of causes, but not exception messages or full stack traces.
     */
    SHORT,
    /**
     * Full display of exceptions.
     */
    FULL

    default void enterDirectory(DirectorySnapshot directorySnapshot) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */
    SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot);

    /**
     * Called after all entries in the directory has been visited.
     */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.snapshot;

/**
 * Ways to continue visiting a snapshot hierarchy after an entry has been visited.
 *
 * @see java.nio.file.FileVisitResult
 */
public enum SnapshotVisitResult {

    /**
     * Continue visiting. When returned after visiting a directory,

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */
    SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot, RelativePathSupplier relativePath);

    /**
     * Called after all entries in the directory has been visited.
     */

1. We generate interceptors from the annotations declared in the source code 
2. We collect Gradle API type hierarchy

The first one is important for both configuration cache instrumentation and API upgrades while the second one is used just for API upgrades. 
Collecting the Gradle API type hierarchy is fully automatic, while declaring interceptors have to be done by Gradle developers. 

```mermaid
flowchart TB

 */

package org.gradle.model.internal.type

import org.gradle.api.JavaVersion
import spock.lang.Specification

class ModelTypesTest extends Specification {
    def "collects type hierarchy of #types.simpleName to #closed.simpleName"() {
        expect:
        ModelTypes.collectHierarchy(types.collect { ModelType.of(it) }) == (closed.collect { ModelType.of(it) } as Set)

        where:

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class ClassLoaderDetails implements Serializable {
    // TODO:ADAM - using a UUID means we create a ClassLoader hierarchy for each daemon process we talk to. Instead, use the spec to decide whether to reuse a ClassLoader
    public final UUID uuid;
    public final ClassLoaderSpec spec;

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */
    public abstract SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot, boolean isRoot);

    /**
     * Called after all entries in the directory has been visited.
     */