}

    def "findSnapshot returns root node when queried at the root"() {
        def rootNode = Mock(FileSystemNode)
        def hierarchy = DefaultSnapshotHierarchy.from(rootNode, CASE_SENSITIVE)

        when:
        def foundSnapshot = hierarchy.findMetadata("/")
        then:
        foundSnapshot.present
        1 * rootNode.snapshot >> Optional.of(Mock(MetadataSnapshot))
        0 * _
    }

import org.gradle.internal.file.impl.DefaultFileMetadata
import org.gradle.internal.hash.TestHashCodes

class DirectorySnapshotTest extends AbstractFileSystemLocationSnapshotTest {
    def "snapshot hierarchy accessed directly is relocated"() {
        def testDirectory = temporaryFolder.createDir("test")
        def sourceDir = testDirectory.createDir("source-directory")
        def childDir = sourceDir.createDir("child")

 */
public interface TypeMetadataWalker<T, V extends TypeMetadataWalker.TypeMetadataVisitor<T>> {

    /**
     * A factory method for a walker that can visit the property hierarchy of an instance.
     *
     * When visiting a nested property, child properties are discovered using the type of the
     * return property value. This can be a more specific type than the return type of the property's

 *
 * @since 8.8
 */
@Incubating
public interface IsolatedProject {

    /**
     * <p>Returns the name of this project. The project's name is not necessarily unique within a project hierarchy. You
     * should use the {@link #getPath()} method for a unique identifier for the project.
     * If the root project is unnamed and is located on a file system root it will have a randomly-generated name
     * </p>
     *

        ImmutableSet<String> hierarchy = ImmutableSet.copyOf(readStringSet(decoder));
        List<ExcludeMetadata> excludeMetadata = readMavenExcludes(decoder);
        RealisedConfigurationMetadata realized = new RealisedConfigurationMetadata(
            resolveMetadata.getId(),
            name,
            transitive,
            visible,
            hierarchy,
            artifacts,

            .expectLegacyDeprecationWarning("Mutating the hierarchy of configuration ':apiElements' after it has been resolved or consumed. This behavior has been deprecated. This will fail with an error in Gradle 9.0. After a Configuration has been resolved, consumed as a variant, or used for generating published...

     * hierarchy containing a symlink, as we can't be sure if the snapshot would still be valid of
     * the relocated link.
     *
     * If performance around symlinks becomes more important, we can improve this in multiple ways:
     * - keep symlinks that don't point outside the relocated snapshot hierarchy,
     * - re-snapshot relocated locations pointed to by snapshots,

                transitive = configuration.isTransitive();
                visible = configuration.isVisible();
                hierarchy = LazyToRealisedModuleComponentResolveMetadataHelper.constructHierarchy(configuration, configurationDefinitions);
                excludes = configurationHelper.filterExcludes(hierarchy);
            } else {
                excludes = ImmutableList.of();
            }

        if (classLoaderStructure.getParent() == null) {
            // This is the highest parent in the hierarchy
            return createClassLoaderFromSpec(workerInfrastructureClassloader, classLoaderStructure.getSpec(), legacyTypesSupport);
        } else {
            // Climb up the hierarchy looking for the highest parent

import org.gradle.internal.declarativedsl.analysis.ParameterValueBinding


/**
 * Utilities for replacing receivers in an ObjectOrigin hierarchy.
 */
object OriginReplacement {
    /**
     * Replaces receivers matching a predicate with a replacement receiver.  The replacement returns a deep copy of the receiver hierarchy of the
     * supplied {@link ObjectOrigin} with the given replacement applied.
     */