@Override
        void visit(NodeAccess value) {
            builder.add(value.getNode());
        }

        @Override
        ImmutableSet<Node> getResult() {
            return builder.build();
        }
    }

    private interface NodeAccess {
        Node getNode();

        boolean accessesChild(VfsRelativePath childPath);
    }

    }

    @Override
    public Stream<FileSystemLocationSnapshot> rootSnapshotsUnder(String absolutePath) {
        return getNode(absolutePath)
            .map(FileSystemNode::rootSnapshots)
            .orElseGet(Stream::empty);
    }

    private Optional<FileSystemNode> getNode(String absolutePath) {
        VfsRelativePath relativePath = VfsRelativePath.of(absolutePath);
        return relativePath.isEmpty()

    def "querying the node for non-existent child #vfsSpec.searchedPath yields a missing file (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        FileSystemLocationSnapshot foundSnapshot = initialRoot.getNode(searchedPath, CASE_SENSITIVE).get() as FileSystemLocationSnapshot
        then:
        foundSnapshot.type == FileType.Missing
        foundSnapshot.absolutePath == searchedPath.absolutePath

        where:

        @Override
        public ScheduledNodes getScheduledNodes() {
            return visitor -> visitor.accept(Collections.emptyList(), Collections.emptySet());
        }

        @Override
        public TaskNode getNode(Task task) {
            throw new IllegalStateException();
        }
    };

    /**

        }
    }

    RemoteRepository getRemoteRepository(org.eclipse.aether.repository.RemoteRepository repository);

    Node getNode(org.eclipse.aether.graph.DependencyNode node);

    Node getNode(org.eclipse.aether.graph.DependencyNode node, boolean verbose);

    @Nonnull
    Artifact getArtifact(@Nonnull org.eclipse.aether.artifact.Artifact artifact);

    @Nonnull

        this.parent = parent;
        this.node = (XmlNode) parent.getNode();
        this.children = this.node.getChildren();
        if (startWith != null) {
            Xpp3Dom startWithNode = (Xpp3Dom) startWith.getNode();
            for (; filteredIndex < children.size(); filteredIndex++) {
                if (startWithNode.equals(children.get(filteredIndex))) {

        childSnapshot.type == FileType.Missing
        childSnapshot.absolutePath == childAbsolutePath.absolutePath
    }

    def "getNode at child is missing"() {
        def childAbsolutePath = childAbsolutePath("some/child")

        when:
        FileSystemLocationSnapshot childSnapshot = initialRoot.getNode(childAbsolutePath, CASE_SENSITIVE).get() as FileSystemLocationSnapshot
        then:
        childSnapshot.type == FileType.Missing

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

package nodeagent

import (
	"fmt"
	"io/fs"
	"syscall"
)

func GetInode(fi fs.FileInfo) (uint64, error) {
	if stat, ok := fi.Sys().(*syscall.Stat_t); ok {
		return stat.Ino, nil
	}
	return 0, fmt.Errorf("unable to get inode")

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

package nodeagent

import (
	"fmt"
	"io/fs"
)

func GetInode(fi fs.FileInfo) (uint64, error) {
	return 0, fmt.Errorf("unable to get inode os not supported")

            @Override
            public void execute(ModelBinding modelBinding) {
                ModelNodeInternal node = modelBinding.getNode();
                BindingPredicate predicate = modelBinding.getPredicate();
                if (node.isAtLeast(predicate.getState())) {