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 {

        configureBuild.children.contains(configureRoot)

        def configureA = events.operation("Configure project :a")
        configureA.parent == configureRoot
        configureRoot.children == [configureA]

        def configureB = events.operation("Configure project :b")
        configureB.parent == configureA
        configureA.children == [configureB]
    }

 *                           "alreadyRendered" : true|false
 *                           "hasConflict" : true|false
 *                           "children" : [
 *                               same array as configurations.dependencies.children
 *                           ]
 *                       },
 *                       ...
 *                   ],
 *                   "moduleInsights : [

        if (sortPolicy == SortPolicy.BY_NAME) {
            Collections.sort(children, new Comparator<PBXReference>() {
                @Override
                public int compare(PBXReference o1, PBXReference o2) {
                    return o1.getName().compareTo(o2.getName());
                }
            });
        }

        s.addField("children", children);
    }

    /**
     * Method by which group contents will be sorted.

    checkNotNull(nodeToChildrenFunction);
    return new TreeTraverser<T>() {
      @Override
      public Iterable<T> children(T root) {
        return nodeToChildrenFunction.apply(root);
      }
    };
  }

  /** Returns the children of the specified node. Must not contain null. */
  public abstract Iterable<T> children(T root);

  /**

        this.reference = (reference != null) ? reference : "";
        this.children = (children != null) ? Collections.unmodifiableList(children) : Collections.emptyList();
    }

    public Throwable getException() {
        return exception;
    }

    public String getMessage() {
        return message;
    }

    public String getReference() {
        return reference;
    }

        then:
        resultRoot instanceof PartialDirectoryNode
        resultRoot.children == children
        removedNodes == [initialRoot.getSnapshot().get()]
        addedNodes == children.stream().map(ChildMap.Entry::getValue).toList()
        interaction { noMoreInteractions() }

        where:
        vfsSpec << onlyDirectChildren(NO_COMMON_PREFIX)
    }