ProjectDependency projectDependency = (ProjectDependency) dependency;
                    Path identityPath = ((ProjectDependencyInternal) projectDependency).getIdentityPath();
                    SwiftPmTarget identifier = publicationResolver.resolveComponent(SwiftPmTarget.class, identityPath);
                    target.getRequiredTargets().add(identifier.getTargetName());

                            def builds = []
                            registry.visitBuilds { b ->
                                builds.add(b.identityPath.path)
                                if (b.projectsLoaded) {
                                    projects.addAll(b.projects.allProjects.collect { p -> p.identityPath.path })
                                }
                            }
                            println "projects = " + projects

        addBuilderRegisteringPluginImplementation(childBuildName, "MyModelBuilder", """
            def model = project.extensions.create("myExtension", MyExtension)
            model.message = "It works from project \${project.identityPath}"
        """)
    }

    void withParameterizedSomeToolingModelBuilderPluginInChildBuild(String childBuildName, String builderContent = "") {
        addPluginBuildScript(childBuildName)

        public ScriptScopedContext(DomainObjectContext delegate) {
            this.delegate = delegate;
        }

        @Override
        public Path identityPath(String name) {
            return delegate.identityPath(name);
        }

        @Override
        public Path projectPath(String name) {
            return delegate.projectPath(name);
        }

        @Override

            services.stop()
        }
        return result
    }

    BuildServices build(TreeServices services, BuildIdentifier identifier) {
        def identityPath = Stub(Path)
        def gradle = Stub(GradleInternal) {
            getIdentityPath() >> identityPath
        }
        return new BuildServices(services, identifier, gradle)
    }

    TaskInternal task(BuildServices services, Node dependsOn) {

    withIsolate(IsolateOwners.OwnerTask(task), codec) {
        withPropertyTrace(PropertyTrace.Task(taskType, task.identityPath.path)) {
            if (task.isCompatibleWithConfigurationCache) {
                action()
            } else {
                forIncompatibleType(task.identityPath.path, action)
            }
        }
    }
}


private
sealed class RegisteredProperty {

        projectDependency.getGroup() >> "pub-group"
        projectDependency.getName() >> "pub-name"
        projectDependencyResolver.resolveComponent(ModuleVersionIdentifier, projectDependency.identityPath) >> DefaultModuleVersionIdentifier.newId("pub-group", "pub-name", "pub-version")

        when:
        publication.from(componentWithDependency(projectDependency))

        then:

        }
        return new TaskCreationException(String.format("Could not create task '%s'.", project.identityPath(name)), cause);
    }

    private static BuildOperationDescriptor.Builder realizeDescriptor(TaskIdentity<?> identity, boolean replacement, boolean eager) {
        return BuildOperationDescriptor.displayName("Realize task " + identity.identityPath)
            .details(new RealizeDetails(identity, replacement, eager));
    }

    }

    @Override
    public String toString() {
        return "DefaultProjectDependency{" + "identityPath='" + getIdentityPath() + '\'' + ", configuration='"
            + (getTargetConfiguration() == null ? Dependency.DEFAULT_CONFIGURATION : getTargetConfiguration()) + '\'' + '}';
    }

                b { id = "b.plugin" }
            }
        }

        then:
        def publications = project.services.get(ProjectPublicationRegistry).getPublications(PluginPublication, project.identityPath)
        publications.size() == 2
        publications[0].pluginId == DefaultPluginId.of("a.plugin")
        publications[1].pluginId == DefaultPluginId.of("b.plugin")
    }