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

     * 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,

        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

package P

var x int

func foo() {
	print(P.x);  // ERROR "undefined"
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug085.go
bug085.go:6: P: undefined
Bus error
*/

/* expected scope hierarchy (outermost to innermost)

universe scope (contains predeclared identifiers int, float32, int32, len, etc.)
"solar" scope (just holds the package name P so it can be found but doesn't conflict)

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.
     */

// E.g. if the devices cgroup for the container is stored in /sys/fs/cgroup/devices/docker/nginx,
// return docker/nginx. Assumes that the process is part of exactly one cgroup hierarchy.
func (fakePfs *FakeProcFS) GetFullContainerName(pid int) (string, error) {
	return "", nil

        then:
        1 * statisticsCollector.recordVisitHierarchy()

        then:
        1 * statisticsCollector.recordVisitDirectory()
        0 * _
    }

    def "can visit directory hierarchy"() {
        given:
        def root = tmpDir.createDir("root")
        def subDir1 = root.createDir("sub-dir-1")
        subDir1.createFile("file.txt")
        def subDir2 = root.createDir("sub-dir-2")

/**
 * Determines how exceptions are formatted in test logging.
 */
public enum TestExceptionFormat {
    /**
     * Short display of exceptions.  Shows the exception types and locations as well as the hierarchy of causes, but not exception messages or full stack traces.
     */
    SHORT,
    /**
     * Full display of exceptions.
     */
    FULL

    default void enterDirectory(DirectorySnapshot directorySnapshot) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */
    SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot);

    /**
     * Called after all entries in the directory has been visited.
     */

import spock.lang.Issue

class TaskFactoryIntegrationTest extends AbstractIntegrationSpec {
    @Issue("GRADLE-3317")
    def "can generate a task when the inject annotation is not present on all of the methods in the hierarchy"() {
        given:
        buildFile """
            //getInputs() and getOutputs() exists on both org.gradle.api.Task and org.gradle.api.internal.AbstractTask
            //Only AbstractTask has the @Inject annotation