// 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")

        new HierarchicalFileWatcherUpdater(watcher, NO_VALIDATION, probeRegistry, watchableHierarchies, movedWatchedDirectoriesSupplier)
    }

    @Override
    int getIfNonHierarchical() { 0 }

    def "does not watch hierarchy to watch if no snapshot is inside"() {
        def watchableHierarchy = file("watchable").createDir()
        def secondWatchableHierarchy = file("watchable2").createDir()

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

        @Override String someOverloadedMethod(int param)
        @Override String someOverriddenCovariantMethod(Object param)
    }

    def "gets overridden methods from type hierarchy"() {
        expect:
        def overridden = ModelSchemaUtils.getCandidateMethods(SubTypeWithOverloadedMethods).overriddenMethodsNamed("someOverloadedMethod")
        overridden.size() == 2

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.snapshot;

/**
 * Ways to continue visiting a snapshot hierarchy after an entry has been visited.
 *
 * @see java.nio.file.FileVisitResult
 */
public enum SnapshotVisitResult {

    /**
     * Continue visiting. When returned after visiting a directory,

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

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

 */

package org.gradle.model.internal.type

import org.gradle.api.JavaVersion
import spock.lang.Specification

class ModelTypesTest extends Specification {
    def "collects type hierarchy of #types.simpleName to #closed.simpleName"() {
        expect:
        ModelTypes.collectHierarchy(types.collect { ModelType.of(it) }) == (closed.collect { ModelType.of(it) } as Set)

        where:

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class ClassLoaderDetails implements Serializable {
    // TODO:ADAM - using a UUID means we create a ClassLoader hierarchy for each daemon process we talk to. Instead, use the spec to decide whether to reuse a ClassLoader
    public final UUID uuid;
    public final ClassLoaderSpec spec;