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

     * by getName() is not unique in the hierarchy.
     *
     * @param element the element, cannot be null
     * @return the identity name of the element, never null
     */
    String getIdentityName(T element);

    /**
     * Returns the parent in this element's hierarchy.
     *
     * @param element the child element, cannot be null

     *
     * For example, this removes everything from the root which can't be kept after the current build finished.
     * This is anything which is not within a watchable hierarchy or in a cache directory.
     *
     * @return the snapshot hierarchy without snapshots which can't be kept till the next build.
     */
    @CheckReturnValue