*/
    private void checkUtSimpleArtifactDependencies(Dependency dep1, Dependency dep2) {
        assertEquals("compile", dep1.getScope());
        assertFalse(dep1.isOptional(), "Expected " + dep1 + ".isOptional() to return false");
        assertEquals(0, dep1.getExclusions().size());
        Artifact depArtifact = dep1.getArtifact();
        assertEquals("ut.simple", depArtifact.getGroupId());

     *
     * @return {@code true} if the dependency is optional, or {@code false} if mandatory
     * @see DependencyCoordinates#getOptional()
     */
    boolean isOptional();

    /**
     * {@return coordinates with the same identifiers as this dependency}.
     */
    @Nonnull
    @Override
    DependencyCoordinates toCoordinates();

/**
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface DependencyCoordinatesFactoryRequest extends ArtifactCoordinatesFactoryRequest {

    String getScope();

    boolean isOptional();

    @Nonnull
    Collection<Exclusion> getExclusions();

    @Nonnull
    static DependencyCoordinatesFactoryRequest build(
            @Nonnull Session session,
            String groupId,

    boolean isRelease();

    void setRelease(boolean release);

    List<ArtifactVersion> getAvailableVersions();

    void setAvailableVersions(List<ArtifactVersion> versions);

    boolean isOptional();

    void setOptional(boolean optional);

    ArtifactVersion getSelectedVersion() throws OverConstrainedVersionException;

    boolean isSelectedVersionKnown() throws OverConstrainedVersionException;

                && Objects.equals(a1.getScope(), a2.getScope())
                && Objects.equals(a1.getDependencyFilter(), a2.getDependencyFilter())
                && a1.isOptional() == a2.isOptional();
    }

    private static int repositoryHashCode(ArtifactRepository repository) {
        int result = 17;
        result = 31 * result + (repository.getId() != null ? repository.getId().hashCode() : 0);

    public void setAvailableVersions(List<ArtifactVersion> versions) {
        artifact.setAvailableVersions(versions);
    }

    /** {@inheritDoc} */
    @Override
    public boolean isOptional() {
        return artifact.isOptional();
    }

    /** {@inheritDoc} */
    @Override
    public ArtifactVersion getSelectedVersion() throws OverConstrainedVersionException {
        return artifact.getSelectedVersion();

    }

    @Override
    public void setAvailableVersions(List<ArtifactVersion> availableVersions) {
        this.availableVersions = availableVersions;
    }

    @Override
    public boolean isOptional() {
        return optional;
    }

    @Override
    public ArtifactVersion getSelectedVersion() throws OverConstrainedVersionException {
        return versionRange.getSelectedVersion(this);
    }

                            // we don't add it or its children, just allow the update of the version and artifactScope
                            if (node.isChildOfRootNode() || !artifact.isOptional()) {
                                artifact.setDependencyTrail(node.getDependencyTrail());

                                set.add(node);

                                // This is required right now.

            return null;
        }

        org.apache.maven.artifact.Artifact result = toArtifact(dependency.getArtifact());
        result.setScope(dependency.getScope());
        result.setOptional(dependency.isOptional());

        return result;
    }

    public static org.apache.maven.artifact.Artifact toArtifact(Artifact artifact) {
        if (artifact == null) {
            return null;
        }

                range,
                artifact.getScope(),
                artifact.getType(),
                artifact.getClassifier(),
                artifact.getArtifactHandler(),
                artifact.isOptional());
        clone.setRelease(artifact.isRelease());
        clone.setResolvedVersion(artifact.getVersion());
        clone.setResolved(artifact.isResolved());
        clone.setFile(artifact.getFile());