}
        return tree;
    }

    public void setClasspath(List<ArtifactMetadata> classpath) {
        this.classpath = classpath;
    }

    public ArtifactScopeEnum getScope() {
        return scope;
    }

    public void setScope(ArtifactScopeEnum scope) {
        this.scope = scope;
    }

    // -------------------------------------------------------------------------------------------
    @Override

                Artifact artifact;
                if (d.getScope().equals(Artifact.SCOPE_TEST) || d.getScope().equals(Artifact.SCOPE_PROVIDED)) {
                    /* don't call createDependencyArtifact as it'll ignore test and provided scopes */
                    artifact = artifactFactory.createArtifact(
                            d.getGroupId(), d.getArtifactId(), d.getVersion(), d.getScope(), d.getType());
                } else {

                    session,
                    new org.eclipse.aether.graph.Dependency(
                            new org.eclipse.aether.artifact.DefaultArtifact(request.getCoordinateString()),
                            request.getScope(),
                            request.isOptional(),
                            map(request.getExclusions(), this::toExclusion)));
        } else {
            return new DefaultDependencyCoordinate(

        assertEquals("system", artifact.getScope());
        assertEquals("system", artifact2.getScope());
        assertEquals("system", artifact3.getScope());
        assertEquals("system", artifact4.getScope());
        assertEquals("system", artifact5.getScope());
    }

        // and we want artifact resolution to only return the system scoped artifact itself.
        //
        if (artifact.getScope() != null && artifact.getScope().equals(Artifact.SCOPE_SYSTEM)) {
            return new ResolutionGroup(null, null, null);
        }

        ResolutionGroup cached = cache.get(
                artifact,

        return DefaultModelVersionParser.checkSnapshot(dependency.getArtifact().getVersion());
    }

    @Nonnull
    @Override
    public DependencyScope getScope() {
        return session.requireDependencyScope(dependency.getScope());
    }

    @Nullable
    @Override
    public boolean isOptional() {
        return dependency.isOptional();
    }

    @Nonnull
    @Override

            if (isCompilePathElement(a.getScope())) {
                Dependency dependency = new Dependency();

                dependency.setArtifactId(a.getArtifactId());
                dependency.setGroupId(a.getGroupId());
                dependency.setVersion(a.getVersion());
                dependency.setScope(a.getScope());
                dependency.setType(a.getType());

                    session,
                    new org.eclipse.aether.graph.Dependency(
                            new org.eclipse.aether.artifact.DefaultArtifact(request.getCoordinateString()),
                            request.getScope(),
                            request.isOptional(),
                            map(request.getExclusions(), this::toExclusion)));
        } else {
            return new DefaultDependencyCoordinate(

/**
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface DependencyCoordinateFactoryRequest extends ArtifactCoordinateFactoryRequest {

    String getScope();

    boolean isOptional();

    @Nonnull
    Collection<Exclusion> getExclusions();

    @Nonnull
    static DependencyCoordinateFactoryRequest build(
            @Nonnull Session session,

                return session.requireType(type);
            }

            @Nonnull
            @Override
            public DependencyScope getScope() {
                String scope = dependency.getScope() != null ? dependency.getScope() : "";
                return session.requireDependencyScope(scope);
            }

            @Override
            public Boolean getOptional() {