}
            }
        """)

        and:
        def projectDependency = withEmptyJar("project-dependency.jar")
        file("build.gradle") << """
            buildscript {
                dependencies {
                    classpath(files("${normalizedPathOf(projectDependency)}"))
                }
            }
        """

        when:

        return minimalExternalModuleDependencyNotationParser;
    }

    public NotationParser<ProjectDependency, ? extends DependencyConstraint> getProjectDependencyNotationParser() {
        return projectDependencyNotationParser;
    }

    private static class ProjectDependencyNotationConverter extends TypedNotationConverter<ProjectDependency, DependencyConstraint> {
        private final Instantiator instantiator;

        file('other/settings.gradle') << """
            rootProject.name = 'other'
        """

        buildFile << """
            def projectDependency = projects.other
            assert projectDependency instanceof ProjectDependency
            println("Dependency path: \\"\${projectDependency.dependencyProject.path}\\"")
        """

        when:
        fails 'help'

        then:

        projectDependency from: 'a', to: ['b', 'c', 'd']

        expect:
        blockingServer.expectConcurrent(':b:pingServer', ':c:pingServer', ':d:pingServer')
        blockingServer.expect(':a:pingServer')

        run ':a:pingServer'
    }

    def "executes dependency project targets concurrently where possible"() {

        projectDependency from: 'a', to: ['b', 'c']

                    classpathElements.getBuildDependencies().add(projectDependency.getBuildDependencies());
                } else {

        TaskDependencyResolveContext context,
        Set<ProjectDependency> projectDependencies,
        ProjectStateRegistry projectStateRegistry,
        String taskName
    ) {
        for (ProjectDependency projectDependency : projectDependencies) {
            Path identityPath = ((ProjectDependencyInternal) projectDependency).getIdentityPath();

        return eclipseProject != null ? eclipseProject.hasJavaTestFixtures() : false;
    }

    private ProjectDependency buildProjectDependency(String path) {
        final ProjectDependency out = new ProjectDependency(path);
        out.setExported(false);
        return out;
    }

            ProjectDependency projectDependency = ((DefaultProjectDependencyConstraint) dependencyConstraint).getProjectDependency();
            return DefaultProjectComponentSelector.newSelector(
                projectDependency.getDependencyProject(),
                ((ImmutableAttributes) projectDependency.getAttributes()).asImmutable(),
                Collections.emptyList()

    public ProjectDependencyFactory(DefaultProjectDependencyFactory factory) {
        this.factory = factory;
    }

    public ProjectDependency createFromMap(ProjectFinder projectFinder, Map<? extends String, ?> map) {
        return NotationParserBuilder.toType(ProjectDependency.class)
                .converter(new ProjectDependencyMapNotationConverter(projectFinder, factory)).toComposite().parseNotation(map);
    }

        def publication = createPublication()
        def projectDependency = Mock(ProjectDependencyInternal) {
            getIdentityPath() >> Mock(Path)
        }

        and:
        projectDependency.excludeRules >> []
        projectDependency.getAttributes() >> ImmutableAttributes.EMPTY
        projectDependency.requestedCapabilities >> []
        projectDependency.getArtifacts() >> []