def absolutePaths = []
        snapshot.accept(new RootTrackingFileSystemSnapshotHierarchyVisitor() {
            @Override
            SnapshotVisitResult visitEntry(FileSystemLocationSnapshot entrySnapshot, boolean isRoot) {
                if (includeRoots || !isRoot) {
                    absolutePaths << entrySnapshot.absolutePath
                }
                CONTINUE
            }

        final List<String> absolutePaths = new ArrayList<String>(changedPaths.size());
        for (Path changedPath : changedPaths) {
            if (!changedPath.isAbsolute()) {
                throw new IllegalArgumentException(String.format("Changed path '%s' is not absolute", changedPath));
            }
            absolutePaths.add(changedPath.toString());
        }

        then:
        visited.contains(rootTextFile.absolutePath)
        visited.contains(nestedTextFile.absolutePath)
        visited.contains(nestedSiblingTextFile.absolutePath)
        visited.contains(notTextFile.absolutePath)
        visited.contains(excludedFile.absolutePath)
        !visited.contains(notUnderRoot.absolutePath)
        !visited.contains(doesNotExist.absolutePath)
        relativePaths as Set == [
            '',

    public Optional<FileSystemLocationSnapshot> findSnapshot(String absolutePath) {
        return root.findSnapshot(absolutePath);
    }

    @Override
    public Optional<MetadataSnapshot> findMetadata(String absolutePath) {
        return root.findMetadata(absolutePath);
    }

    @Override
    public Stream<FileSystemLocationSnapshot> findRootSnapshotsUnder(String absolutePath) {
        return root.rootSnapshotsUnder(absolutePath);
    }

            apply from: "${normaliseFileSeparators(otherScript2.absolutePath)}"
        """
        def initScript = file("init.gradle") << """
            apply from: "${normaliseFileSeparators(otherScript1.absolutePath)}"
        """

        when:
        succeeds "help", "-I", initScript.absolutePath

        then:
        def ops = operations.all(ApplyScriptPluginBuildOperationType) {

        s.hasDescendantsUnder(dir1.absolutePath)
        collectSnapshots(s, dir1.absolutePath)*.absolutePath == [dir1dir2dir3.absolutePath, dir1dir2dir4.absolutePath, dir1dir5.absolutePath]

        def pathWithPostfix = dir1dir2.absolutePath + "a"
        !s.hasDescendantsUnder(pathWithPostfix)
        collectSnapshots(s, pathWithPostfix).empty

    }

    FileSystemLocationSnapshot regularFile(String absolutePath, FileMetadata.AccessType accessType = DIRECT) {
        regularFile(absolutePath, accessType, null)
    }

    FileSystemLocationSnapshot regularFile(String absolutePath, @Nullable Long hashCode) {
        regularFile(absolutePath, DIRECT, hashCode)
    }

    FileSystemLocationSnapshot regularFile(String absolutePath, FileMetadata.AccessType accessType, @Nullable Long hashCode) {

            targetDir.file("child").absolutePath,
            targetDir.file("child/child.txt").absolutePath,
            targetDir.file("parent.txt").absolutePath,
        ] as Set

        index.values()*.name as Set == [
            targetDir.name,
            childDir.name,
            childFile.name,
            parentFile.name,
        ] as Set

        index.values().forEach(this::assertInterned)
    }

        hierarchy.recordNodeAccessingLocations(rootNode, [root.absolutePath])
        hierarchy.recordNodeAccessingLocations(node1, [root.file("location").absolutePath])
        hierarchy.recordNodeAccessingLocations(node2, [root.file("sub/location").absolutePath])
        hierarchy.recordNodeAccessingLocations(node3, [root.file("third/within").absolutePath])

        if (absolutePath.isEmpty() || absolutePath.equals("/")) {
            return absolutePath;
        }
        return isFileSeparator(absolutePath.charAt(absolutePath.length() - 1))
            ? absolutePath.substring(0, absolutePath.length() - 1)
            : absolutePath;
    }

    private static int determineOffset(String absolutePath) {
        for (int i = 0; i < absolutePath.length(); i++) {