test {
                    java {}
                    resources {}
                }
            }
        }

        when:
        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }
        IdeaModule module = project.children[0]
        IdeaContentRoot root = module.contentRoots[0]

        then:
        root.sourceDirectories.size() == 1

    }

    @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()

        testInheritance(baseName, true);
    }

    public void testInheritance(String baseName, boolean fromRepo) throws IOException {
        Model parent = getModel(baseName + "-parent");

        Model child = getModel(baseName + "-child");

        if (fromRepo) {
            // when model is read from repo, a stream is used, then pomFile == null

class ModelStreamingBuildAction implements BuildAction<CustomModel> {
    @Override
    public CustomModel execute(BuildController controller) {
        EclipseProject eclipseProject = controller.getModel(EclipseProject.class);
        GradleProject gradleProject = controller.getModel(GradleProject.class);

        // Intentionally sending models in an order different from requesting models
        controller.send(gradleProject);

        file('build.gradle') << '''
task a {
   description = 'this is task a'
}
task b
task c
'''

        when:
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        GradleTask taskA = project.tasks.find { it.name == 'a' }
        taskA.path == ':a'
        taskA.description == 'this is task a'
        taskA.project == project

            }
            return relativePath;
        }

        @Override
        @Deprecated
        public int getMode() {
            DeprecationLogger.deprecateMethod(FileTreeElement.class, "getMode()")
                .replaceWith("getPermissions()")
                .willBeRemovedInGradle9()
                .withUpgradeGuideSection(8, "unix_file_permissions_deprecated")

        this.pomFile = pomFile;
        context = JXPathContext.newContext(mavenProject.getModel());
    }

    public PomTestWrapper(MavenProject mavenProject) {
        this.mavenProject = Objects.requireNonNull(mavenProject, "mavenProject cannot be null");
        context = JXPathContext.newContext(mavenProject.getModel());
    }

    public MavenProject getMavenProject() {
        return mavenProject;
    }

    //                                                                            ========
    public String[] getPermissions() {
        return user.getPermissions();
    }

    public String[] getRoles() {
        return user.getRoleNames();
    }

    public String[] getGroups() {
        return user.getGroupNames();
    }

    public boolean isEditable() {
        return user.isEditable();
    }

                return controller.getModel(project, GradleProject.class);
            }
        }
        for (GradleBuild editableBuild : buildModel.getEditableBuilds()) {
            for (BasicGradleProject project : editableBuild.getProjects()) {
                if (targetProject.equals(project.getBuildTreePath())) {
                    return controller.getModel(project, GradleProject.class);
                }

        @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);
    }