for (ClasspathEntry entry : entries) {
            if (entry instanceof ProjectDependency) {
                ProjectDependency projectDependency = (ProjectDependency) entry;
                if (!hasTestSourcesAttribute(projectDependency)) {
                    mainSourcePaths.add(projectDependency.getPath());
                }
            }
        }

        ProjectDependencyInternal projectDependency = (ProjectDependencyInternal) dependency;
        ComponentSelector selector = DefaultProjectComponentSelector.newSelector(projectDependency.getDependencyProject(),
            ((AttributeContainerInternal) projectDependency.getAttributes()).asImmutable(),
            projectDependency.getRequestedCapabilities());

        accessor.root instanceof ProjectDependency
        accessor.core instanceof ProjectDependency
        accessor.utils instanceof ProjectDependency
        accessor.lib instanceof ProjectDependency
        accessor.lib.sub instanceof ProjectDependency
        accessor.lib.sub.deep instanceof ProjectDependency
        accessor.utils.json instanceof ProjectDependency
        accessor.utils.xml instanceof ProjectDependency

        expect:
        converter.canConvert(Mock(ProjectDependency))
        !converter.canConvert(Mock(ExternalModuleDependency))
    }

    def "test create from project dependency"() {
        when:
        def configuration = withArtifacts ? null : TEST_DEP_CONF
        ProjectDependency projectDependency = createProjectDependency(configuration)
        setUpDependency(projectDependency, withArtifacts)

        given:
        settingsFile << """
            rootProject.name = '$root'
        """
        buildFile << """
            def projectDependency = projects.${accessor}
            assert projectDependency instanceof ProjectDependency
            println("Dependency path: \\"\${projectDependency.dependencyProject.path}\\"")
        """

        when:
        succeeds 'help'

        then:

        def created = dependencyDescriptorFactory.createDependencyMetadata(projectDependency)

        then:
        created == result

        and:
        1 * converter1.canConvert(projectDependency) >> false
        1 * converter2.canConvert(projectDependency) >> true
        1 * converter2.createDependencyMetadata(projectDependency) >> result
    }

        return library
    }

    private ProjectDependency createProjectDependency(String path, String publicationPath, Map entryAttributes) {
        def projectDependency = new ProjectDependency(path)
        projectDependency.publication = fileReferenceFactory.fromPath(publicationPath)
        projectDependency.entryAttributes.putAll(entryAttributes)
        return projectDependency
    }

    private InputStream getToXmlReader() {

                });
            } else if (dependency instanceof ProjectDependency) {
                ProjectDependency projectDependency = Cast.uncheckedCast(dependency);
                projectDependency.capabilities(new ProjectTestFixtures(projectDependency.getDependencyProject()));
            } else {

     * @return a {@link ProjectDependency} for the given path
     *
     * @see org.gradle.api.Project#project(String)
     */
    @Restricted
    default ProjectDependency project(String projectPath) {
        return getDependencyFactory().create(getProject().project(projectPath));
    }

    /**
     * Returns the current project as a {@link ProjectDependency}.
     *

            Set<ProjectDependency> projectDependencies = configuration.getAllDependencies().withType(ProjectDependency.class);
            for (ProjectDependency projectDependency : projectDependencies) {
                Path dependencyIdentityPath = ((ProjectDependencyInternal) projectDependency).getIdentityPath();
                if (dependencyIdentityPath.equals(identityPath)) {