default:
                        throw new UnresolvableModelException(
                                "Cannot resolve",
                                dependency.getGroupId(),
                                dependency.getArtifactId(),
                                dependency.getVersion());
                }
            }
        });

        Iterator<MavenProject> iterator = projects.iterator();
        while (iterator.hasNext()) {
            MavenProject project = iterator.next();
            projectNames.append(project.getGroupId()).append(":").append(project.getArtifactId());
            if (iterator.hasNext()) {
                projectNames.append(", ");
            }
        }
        return projectNames.toString();
    }

                }
            }
        }
        return version;
    }

    public static String versionlessKey(Artifact artifact) {
        return versionlessKey(artifact.getGroupId(), artifact.getArtifactId());
    }

    public static String versionlessKey(String groupId, String artifactId) {
        notBlank(groupId, "groupId can neither be null, empty nor blank");

    }

    protected static Metadata createMetadata(Artifact artifact, Versioning versioning) {
        Metadata metadata = new Metadata();
        metadata.setGroupId(artifact.getGroupId());
        metadata.setArtifactId(artifact.getArtifactId());
        metadata.setVersion(artifact.getVersion());
        metadata.setVersioning(versioning);
        return metadata;
    }

/**
 *
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface ArtifactFactoryRequest {

    @Nonnull
    Session getSession();

    String getGroupId();

    String getArtifactId();

    String getVersion();

    String getClassifier();

    String getExtension();

    String getType();

    static ArtifactFactoryRequest build(

        }
        */
    }
    // ------------------------------------------------------------------
    //    public void init( ArtifactMetadata af )
    //    {
    //        setGroupId( af.getGroupId() );
    //        setArtifactId( af.getArtifactId() );
    //        setVersion( af.getVersion() );
    //        setType( af.getType() );
    //        setScope( af.getScope() );

        assertFalse(dep1.isOptional());
        assertEquals(0, dep1.getExclusions().size());
        Artifact depArtifact = dep1.getArtifact();
        assertEquals("ut.simple", depArtifact.getGroupId());
        assertEquals("dependency", depArtifact.getArtifactId());
        assertEquals("1.0", depArtifact.getVersion());
        assertEquals("1.0", depArtifact.getBaseVersion());
        assertNull(depArtifact.getFile());

        return result;
    }

    private static boolean artifactEquals(Artifact a1, Artifact a2) {
        if (a1 == a2) {
            return true;
        }

        return Objects.equals(a1.getGroupId(), a2.getGroupId())
                && Objects.equals(a1.getArtifactId(), a2.getArtifactId())
                && Objects.equals(a1.getType(), a2.getType())
                && Objects.equals(a1.getVersion(), a2.getVersion())

        source.setGroupId("source-group");
        source.setVersion("2.0");
        assertFalse(target.merge(source));
        assertEquals("myArtifact", target.getArtifactId());
        assertEquals("myGroup", target.getGroupId());
        assertEquals("1.0-SNAPSHOT", target.getVersion());
    }
    /*--- END test common metadata ---*/

    /*--- START test "groupId/artifactId/version" metadata ---*/
    @Test

            ArrayList<Artifact> result = new ArrayList<>(artifacts);
            for (Artifact main : mains) {
                result.remove(main);
                result.add(new DefaultArtifact(
                        main.getGroupId(),
                        main.getArtifactId(),
                        BUILD_POM_CLASSIFIER,
                        main.getExtension(),
                        main.getVersion(),