}
        });

        // 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());

/**
 * Searches an ObjectOrigin receiver hierarchy to find the parent software type or throws an error if a software type
 * is not in the hierarchy.
 */
private
fun getSoftwareType(objectOrigin: ObjectOrigin): ObjectOrigin.AccessAndConfigureReceiver =
    findSoftwareType(objectOrigin) ?: error("Could not discover softwareType for $objectOrigin")


/**

    ) {
        this.name = name;
        this.description = description;
        this.componentId = componentId;
        this.visible = visible;
        this.transitive = transitive;
        this.hierarchy = ImmutableSet.copyOf(hierarchy);
        this.attributes = attributes;
        this.capabilities = capabilities;
        this.canBeConsumed = canBeConsumed;
        this.deprecatedForConsumption = deprecatedForConsumption;

        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]

    }

    def "builds and caches hierarchy for a configuration"() {
        given:
        configuration("a")
        configuration("b", ["a"])
        configuration("c", ["a"])
        configuration("d", ["b", "c"])

        when:
        def md = metadata

        then:
        md.getConfiguration("a").hierarchy as List == ["a"]
        md.getConfiguration("b").hierarchy as List  == ["b", "a"]

 * limitations under the License.
 */

package org.gradle.internal.classloader;

import java.io.Serializable;

/**
 * An immutable description of a ClassLoader hierarchy that can be used to recreate the hierarchy in a different process.
 *
 * Subclasses should implement equals() and hashCode(), so that the spec can be used as a hashmap key.
 */
public abstract class ClassLoaderSpec implements Serializable {

 * limitations under the License.
 */

/**
 * Exceptions thrown when variant selection fails.
 *
 * The hierarchy of exceptions here should be kept small, and in sync with the 2
 * main branches of the {@link org.gradle.internal.component.resolution.failure.type.ResolutionFailure ResolutionFailure}
 * hierarchy, which represent a failure to select a variant of a component, and a failure to select
 * a configuration by name.
 *

         */
        ROLE("role"),

        /**
         * The mutation of the hierarchy of the configuration, i.e. which configurations this configuration extends from.
         */
        HIERARCHY("hierarchy");

        private final String displayName;

        MutationType(String displayName) {
            this.displayName = displayName;
        }

    def "emitsBuildOperationsForJUnitTests"() {
        given:
        executer.withRepositoryMirrors()

        when:
        run "test"

        then: "test build operations are emitted in expected hierarchy"
        def rootTestOp = operations.first(ExecuteTestBuildOperationType)
        rootTestOp.details.testDescriptor.name.startsWith("Gradle Test Run :test")
        rootTestOp.details.testDescriptor.className == null

import antlr.preprocessor.Hierarchy;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;

/**
 * Models cross-reference (x-ref) info about {@link GrammarFileMetadata grammar files} such as {@link #filesByPath}, {@link #filesByExportVocab} and {@link #filesByClassName}.
 */
public class XRef {
    private final Hierarchy antlrHierarchy;