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.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);

     *
     * @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).
     *

		}
		return r
	}, uid))
}

// Cgroup represents a linux cgroup.
type Cgroup struct {
	HierarchyID    string
	ControllerList string
	GroupPath      string
}

// GetCGroups returns a slice of cgroups for pid using fs for filesystem calls.
//
// The expected cgroup format is "hierarchy-ID:controller-list:cgroup-path", and
// this function will return an error if every cgroup does not meet that format.
//

        immutable.getConfiguration("compile").hierarchy as List == ["compile"]
        immutable.getConfiguration("runtime").hierarchy as List == ["runtime", "compile"]
        immutable.getConfiguration("master").hierarchy as List == ["master"]
        immutable.getConfiguration("test").hierarchy as List == ["test", "runtime", "compile"]
        immutable.getConfiguration("default").hierarchy as List == ["default", "runtime", "compile", "master"]

            }
        });

        // Collect all dependencies and excludes in hierarchy.
        // After running the dependency actions and preventing from mutation above, we know the
        // hierarchy will not change anymore and all configurations in the hierarchy
        // will no longer be mutated.
        ImmutableSet<String> hierarchy = Configurations.getNames(configuration.getHierarchy());

        0 * _
    }

    def "watchers are stopped when watched hierarchy is moved"() {
        def sourceDir = file("to-be-moved").createDir()
        def targetDir = file("target").createDir()
        def notMovedDir = file("normal").createDir()
        _ * probeRegistry.getProbeDirectory(_) >> { File hierarchy -> new File(hierarchy, ".gradle") }

        def watchableHierarchies = [sourceDir, notMovedDir]

        ImmutableSet<String> hierarchy = LazyToRealisedModuleComponentResolveMetadataHelper.constructHierarchy(configuration, configurationDefinitions);
        ImmutableList<ExcludeMetadata> excludes = configurationHelper.filterExcludes(hierarchy);

        ImmutableList<ModuleComponentArtifactMetadata> artifacts = configurationHelper.filterArtifacts(configurationName, hierarchy);

            return null;
        }

        ImmutableSet<String> hierarchy = constructHierarchy(descriptorConfiguration);
        boolean transitive = descriptorConfiguration.isTransitive();
        boolean visible = descriptorConfiguration.isVisible();
        return createConfiguration(getId(), name, transitive, visible, hierarchy, variantMetadataRules);
    }

            ImmutableSet<String> hierarchy, ImmutableList<? extends ModuleComponentArtifactMetadata> artifacts,
            VariantMetadataRules componentMetadataRules,
            ImmutableList<ExcludeMetadata> excludes,
            ImmutableAttributes componentLevelAttributes,
            boolean externalVariant
    ) {