List<ProjectReportModel> children,
            List<SoftwareTypeImplementation<?>> softwareTypes,
            boolean isRootProject,
            String tasksTaskPath,
            String rootProjectProjectsTaskPath,
            List<Path> includedBuildIdentityPaths
        ) {
            this.project = project;
            this.children = children;
            this.softwareTypes = softwareTypes;

        resolveB.children == [downloadBMetadata]
        resolveD.children == [downloadDMavenMetadata, downloadDPom]

        resolveCompileFiles.parent == applyRootBuildScript
        resolveCompileFiles.children.size() == 3 // resolution happens in parallel, so the operations may appear in any order
        resolveCompileFiles.children.contains(resolveArtifactB)

//		... processing BEFORE visiting children ...
//		if ... should visit children ... {
//			ir.DoChildren(x, do)
//		}
//		... processing AFTER visiting children ...
//		return false
//	}
//	do(root)
//
// The Visit function illustrates a further simplification of the pattern,
// only processing before visiting children and never stopping:
//
//	func Visit(n ir.Node, visit func(ir.Node)) {
//		if n == nil {
//			return

class UnknownFileSystemNodeTest extends AbstractIncompleteFileSystemNodeTest<UnknownFileSystemNode> {

    @Override
    protected UnknownFileSystemNode createInitialRootNode(ChildMap<FileSystemNode> children) {
        return new UnknownFileSystemNode(children)
    }

    @Override
    protected boolean isSameNodeType(FileSystemNode node) {
        return node instanceof UnknownFileSystemNode
    }

    @Override

        this.identifier = identifier;
        this.projectScopeName = projectScopeName;
        this.buildable = buildable;
        this.testSuite = testSuite;
        this.children = children != null ? children : Collections.<DependentBinariesResolvedResult>emptyList();
    }

    @Override
    public LibraryBinaryIdentifier getId() {
        return identifier;
    }

    @Override

        then:
        project.parent == null
        project.name == 'test project'
        project.description == null
        project.children.size() == 1
        project.children[0] instanceof IdeaModule
        project.children == project.modules
    }

    def "provides basic project information"() {

        buildFile.text = """
apply plugin: 'java'
apply plugin: 'idea'

    private final String projectDir;
    private final String buildFile;
    private final Set<BuildStructureOperationProject> children;

    public BuildStructureOperationProject(String name, String path, String identityPath, String projectDir, String buildFile, Set<BuildStructureOperationProject> children) {
        this.name = name;
        this.path = path;
        this.identityPath = identityPath;
        this.projectDir = projectDir;

class PartialDirectoryNodeTest extends AbstractIncompleteFileSystemNodeTest<PartialDirectoryNode> {

    @Override
    protected PartialDirectoryNode createInitialRootNode(ChildMap<FileSystemNode> children) {
        return new PartialDirectoryNode(children)
    }

    @Override
    protected boolean isSameNodeType(FileSystemNode node) {
        node instanceof PartialDirectoryNode
    }

    @Override

        when:
        EclipseProject eclipseProject = loadToolingModel(EclipseProject)

        then:
        def children = eclipseProject.children.sort { it.name }
        EclipseProject api = children[0]
        assert api.name == 'gradle-api'
        EclipseProject impl = children[1]
        assert impl.name == 'gradle-impl'
    }

    def "should deduplicate project names"() {

        }

        if (!progress.isEmpty()) {
            map.put("progress", transform(progress, Progress::toSerializable));
        }

        if (!children.isEmpty()) {
            map.put("children", transform(children, BuildOperationRecord::toSerializable));
        }

        return map;
    }

    public boolean hasDetailsOfType(Class<?> clazz) throws ClassNotFoundException {