*/
internal
sealed class CachedBuildState(
    val identityPath: Path,
)


/**
 * A build in the tree whose projects were loaded. May or may not have work scheduled.
 */
internal
sealed class BuildWithProjects(
    identityPath: Path,
    val rootProjectName: String,
    val projects: List<CachedProjectState>
) : CachedBuildState(identityPath)


/**
 * A build in the tree with work scheduled.
 */

        this.identityPath = identityPath;
        this.projectPath = projectPath;
        this.projectName = projectName;
        this.attributes = attributes;
        this.requestedCapabilities = requestedCapabilities;
    }

    @Override
    public String getDisplayName() {
        if (displayName == null) {
            displayName = "project " + identityPath;
        }
        return displayName;
    }

        def container = Mock(ProjectState)
        _ * container.projectPath >> (parent == null ? Path.ROOT : parent.projectPath.child(name))
        _ * container.identityPath >> (parent == null ? build.identityPath : build.identityPath.append(parent.projectPath).child(name))

        def descriptor = Mock(ProjectDescriptor) {
            getName() >> name
            getProjectDir() >> new File("project")

        when:
        def result = serialize(identifier, serializer)

        then:
        result.identityPath == identifier.identityPath
        result.projectPath == identifier.projectPath
        result.buildTreePath == identifier.buildTreePath
        result.projectPath() == identifier.projectPath()

        this.candidateClassFiles = candidateClassFiles;
        this.scanForTestClasses = scanForTestClasses;
        this.testClassesDirs = testClassesDirs;
        this.path = path;
        this.identityPath = identityPath;
        this.forkEvery = forkEvery;
        this.javaForkOptions = javaForkOptions;
        this.maxParallelForks = maxParallelForks;
        this.previousFailedTestClasses = previousFailedTestClasses;

    private final Path projectPath;
    private final Path identityPath;
    private final String projectName;
    private String displayName;

    public DefaultProjectComponentIdentifier(BuildIdentifier buildIdentifier, Path identityPath, Path projectPath, String projectName) {
        assert buildIdentifier != null : "build cannot be null";
        assert identityPath != null : "identity path cannot be null";

            readNonNull()
        }
    }

    fun <T> loadOrCreateIntermediateModel(identityPath: Path?, modelName: String, parameter: ToolingModelParameterCarrier?, creator: () -> T): T? {
        val key = ModelKey(identityPath, modelName, parameter?.hash)
        return loadOrCreateValue(key) {
            try {
                val model = if (identityPath != null) {

        registry.register(project.identityPath, publication, publication2, publication3, publication4)
    }

    class TestProjectPublicationRegistry implements ProjectPublicationRegistry {

        Map<Path, List<ProjectComponentPublication>> map = [:]

        void register(Path identityPath, ProjectComponentPublication... publications) {
            map.computeIfAbsent(identityPath, { [] }).addAll(publications)
        }

    public LifecycleAwareBuildCacheController createForRootBuild(Path identityPath, BuildCacheControllerFactory buildCacheControllerFactory, InstanceGenerator instanceGenerator) {
        return rootController.init(identityPath, buildCacheControllerFactory, instanceGenerator);
    }

    private final String name;
    private final String path;
    private final String identityPath;
    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;