expect:
        def id = build.idToReferenceProjectFromAnotherBuild(projectId)
        id.identityPath == projectId.identityPath
        id.identityPath.path == projectId.buildTreePath
        id.projectPath == projectId.projectPath
        id.projectName == projectId.projectName
    }

    def "can run action against build state"() {

import java.io.File;

public class DefaultIncludedBuild extends AbstractCompositeParticipantBuildState implements IncludedBuildState {
    private final BuildIdentifier buildIdentifier;
    private final Path identityPath;
    private final BuildDefinition buildDefinition;
    private final boolean isImplicit;
    private final IncludedBuildImpl model;

    public DefaultIncludedBuild(
        BuildIdentifier buildIdentifier,

                identity.identityPath.toString(),
                identity.type.getSimpleName()));
        } else {
            throw new InvalidUserDataException(String.format(
                "Cannot create task '%s' of type '%s' as directly extending AbstractTask is not supported.",
                identity.identityPath.toString(),
                identity.type.getSimpleName()));
        }

        }

        override fun <T> resolveScriptsForProject(identityPath: Path, action: () -> T): T {
            return fingerprintWriter.runCollectingFingerprintForProject(identityPath, action)
        }

        override fun <T> runCollectingFingerprintForProject(identityPath: Path, action: () -> T): T {
            return fingerprintWriter.runCollectingFingerprintForProject(identityPath, action)
        }

    private final BuildIdentifier buildIdentifier;
    private final Path identityPath;
    private final BuildTreeLifecycleController buildTreeLifecycleController;

    public RootOfNestedBuildTree(
        BuildDefinition buildDefinition,
        BuildIdentifier buildIdentifier,
        Path identityPath,
        BuildState owner,
        BuildTreeState buildTree
    ) {

        nestedBuild1.identityPath == Path.path(":buildSrc")

        def nestedBuild2 = registry.getBuildSrcNestedBuild(parent)
        // Shows current behaviour, not necessarily desired behaviour
        nestedBuild2.buildIdentifier == buildIdentifier(":parent:buildSrc")
        nestedBuild2.identityPath == Path.path(":parent:buildSrc")
    }

    def build(String name) {

        def projectState = Mock(ProjectState)

        def project = Mock(ProjectInternal, name: name)
        _ * project.identityPath >> (parent == null ? Path.ROOT : Path.ROOT.child(name))
        _ * project.projectPath(_) >> { taskName -> Path.ROOT.child(taskName) }
        _ * project.identityPath(_) >> { taskName -> (parent == null ? Path.ROOT : Path.ROOT.child(name)).child(taskName) }
        _ * project.gradle >> thisBuild

    }

    public StandAloneNestedBuild createNestedBuild(BuildIdentifier buildIdentifier, Path identityPath, BuildDefinition buildDefinition, BuildState owner) {
        DefaultNestedBuild build = new DefaultNestedBuild(buildIdentifier, identityPath, buildDefinition, owner, buildTreeState);
        // Expose any contributions from the parent's settings

    ProjectScopedScriptResolution NO_OP = new ProjectScopedScriptResolution() {
        @Override
        public <T> T resolveScriptsForProject(Path identityPath, Supplier<T> action) {
            return action.get();
        }
    };

    <T> T resolveScriptsForProject(Path identityPath, Supplier<T> action);

        rootProject.childProjects >> [].toSet()
        rootProject.identityPath >> Path.path(":some:identity:path")

        includedProject1.childProjects >> [].toSet()
        includedProject1.identityPath >> Path.path(":some:identity:path")
        includedProject2.childProjects >> [].toSet()
        includedProject2.identityPath >> Path.path(":some:identity:path")

        rootBuild.includedBuilds() >> [includedBuild1]