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")

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

        }
    }

    @Override
    public ProjectState stateFor(Path identityPath) {
        synchronized (lock) {
            ProjectStateImpl projectState = projectsByPath.get(identityPath);
            if (projectState == null) {
                throw new IllegalArgumentException(identityPath.getPath() + " not found.");
            }
            return projectState;
        }
    }

        return withCoordinateResolver(coordsType, identityPath,
            VariantCoordinateResolver::getComponentCoordinates
        );
    }

    @Nullable
    @Override
    public <T> T resolveVariant(Class<T> coordsType, Path identityPath, String variantName) {
        return withCoordinateResolver(coordsType, identityPath, resolver ->

        }
    }

    private static class ProjectDependencyKey {
        private final Path identityPath;
        private final ModuleDependencyDetails details;

        public ProjectDependencyKey(Path identityPath, ModuleDependencyDetails details) {
            this.identityPath = identityPath;
            this.details = details;
        }

        @Override
        public boolean equals(Object o) {

        def selector = new DefaultProjectComponentSelector(new DefaultBuildIdentifier(path(":build")), identityPath, projectPath, projectName, AttributeTestUtil.attributes(foo: 'x', bar: 'y'), capabilities())

        when:
        def result = serialize(selector, serializer)

        then:
        result.identityPath == selector.identityPath
        result.projectPath == selector.projectPath

        }

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

        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) {

                Path identityPath = Path.path(decoder.readString());
                return new DefaultProjectComponentIdentifier(buildIdentifier, identityPath, Path.ROOT, identityPath.getName());
            }
            case OTHER_BUILD_PROJECT: {
                BuildIdentifier buildIdentifier = buildIdentifierSerializer.read(decoder);
                Path identityPath = Path.path(decoder.readString());

        Path identityPath = assignPath(owner, buildDefinition.getName(), buildDefinition.getBuildRootDir());
        BuildIdentifier buildIdentifier = idFor(identityPath);
        StandAloneNestedBuild build = buildStateFactory.createNestedBuild(buildIdentifier, identityPath, buildDefinition, owner);
        buildSrcBuildsByOwner.put(owner, build);