def other = Mock(Node)
        def location = "/some/location"
        hierarchy.recordNodeAccessingLocations(node1, [location])
        hierarchy.recordNodeAccessingLocations(child, ["/some/location/second"])
        hierarchy.recordNodeAccessingLocations(node2, [location])
        hierarchy.recordNodeAccessingLocations(other, ["/some/other"])
        hierarchy.recordNodeAccessingLocations(node3, [location])

        expect:

            probe.trigger();
        }
    }

    @Override
    public File getProbeDirectory(File hierarchy) {
        WatchProbe watchProbe = watchProbesByHierarchy.get(hierarchy);
        if (watchProbe == null) {
            throw new IllegalStateException("Cannot find probe for hierarchy: " + hierarchy);
        }
        return watchProbe.getProbeFile().getParentFile();
    }

        def hierarchy = emptyHierarchy()
        hierarchy = hierarchy.recordValue(VfsRelativePath.of("some/location"), 1)
        hierarchy = hierarchy.recordValue(VfsRelativePath.of("some/other/location"), 2)
        hierarchy = hierarchy.recordValue(VfsRelativePath.of("some/location/intermediate/child/sub1/leaf1"), 5)
        hierarchy = hierarchy.recordValue(VfsRelativePath.of("some/location/intermediate/child/sub1/leaf2"), 6)

        def toConfig1 = configuration(toComponent, "to-1")
        def toConfig2 = configuration(toComponent, "to-2")
        fromConfig.hierarchy >> ImmutableSet.of("from")
        fromConfig2.hierarchy >> ImmutableSet.of("child", "from")
        fromConfig3.hierarchy >> ImmutableSet.of("other")

        Multimap<String, String>  configMapping = LinkedHashMultimap.create()
        configMapping.put("*", "to-2")

    ) {

        this.componentId = componentId;
        this.name = name;
        this.transitive = transitive;
        this.visible = visible;
        this.artifacts = artifacts;
        this.hierarchy = hierarchy;
        this.excludes = excludes;
        this.attributes = attributes;
        this.configDependencies = configDependencies;
        this.capabilities = capabilities;
        this.externalVariant = externalVariant;
    }

    /**
     * The empty hierarchy.
     */
    @CheckReturnValue
    SnapshotHierarchy empty();

    CaseSensitivity getCaseSensitivity();

    /**
     * Returns all root snapshots in the hierarchy.
     */
    Stream<FileSystemLocationSnapshot> rootSnapshots();

    /**
     * Returns all root snapshots in the hierarchy below {@code absolutePath}.
     */

        this.attribute = key;
        this.value = value;
        Map<Attribute<?>, DefaultImmutableAttributes> hierarchy = new LinkedHashMap<>();
        hierarchy.putAll(parent.hierarchy);
        hierarchy.put(attribute, this);
        this.hierarchy = ImmutableMap.copyOf(hierarchy);
        Map<String, DefaultImmutableAttributes> hierarchyByName = new LinkedHashMap<>();
        hierarchyByName.putAll(parent.hierarchyByName);

            val mapper = jacksonObjectMapper()
            val hierarchy = mapper.readValue<ClassLoaderHierarchy>(json)

            assertThat(hierarchy.classLoaders.size, equalTo(3))
            assertThat(hierarchy.scopes.size, equalTo(1))
            assertThat(hierarchy.classLoaders[0].parents, hasItem(hierarchy.classLoaders[1].id))
            assertThat(hierarchy.scopes[0].label, equalTo("the path"))

        antlr.Tool tool = new antlr.Tool();
        antlr.preprocessor.Hierarchy hierarchy = new antlr.preprocessor.Hierarchy(tool);

        // first let antlr preprocess the grammars...
        for (File grammarFileFile : sources) {
            final String grammarFilePath = grammarFileFile.getPath();

            try {
                hierarchy.readGrammarFile(grammarFilePath);
            } catch (FileNotFoundException e) {

     *
     * @see #getModuleNames()
     */
    private final Map<Path, String> descriptors;

    /**
     * Whether module hierarchy was detected. If false, then package hierarchy is assumed.
     * In a package hierarchy, the {@linkplain #descriptors} map has either zero or one entry.
     * In a module hierarchy, the descriptors map may have an arbitrary number of entries,
     * including one (so the map size cannot be used as a criterion).
     *