Artifact artifact = artifactFactory.createBuildArtifact("test", "test", version, type);
        artifact.setFile(new File(
                testData,
                "test-" + version + "." + artifact.getArtifactHandler().getExtension()));
        assertFalse(artifact.getFile().exists());
        return artifact;
    }

    private ArtifactRepository createStringRepo() {
        return artifactRepositoryFactory.createArtifactRepository(

    Language getLanguage();

    /**
     * Get the file extension of artifacts of this type.
     *
     * @return the file extension, never {@code null}.
     */
    @Nonnull
    String getExtension();

    /**
     * Get the default classifier associated to the dependency type.
     * The default classifier can be overridden when specifying
     * the {@link Dependency#getClassifier()}.
     *

                            ? session.parseVersion(project.getVersion()).toString()
                            : artifact.getBaseVersion().toString(),
                    artifact.getClassifier(),
                    artifact.getExtension(),
                    null);
        }
        // Verify groupId and version, intentionally allow artifactId to differ as Maven project may be

    }

    private static String getId(Artifact artifact) {
        return getId(
                artifact.getGroupId(),
                artifact.getArtifactId(),
                artifact.getExtension(),
                artifact.getClassifier(),
                artifact.getBaseVersion());
    }

    private static String getId(ClassRealmConstituent constituent) {
        return getId(

        <codeSegment>
          <version>1.0.0/1.1.0</version>
          <code><![CDATA[
    private String getSnapshotVersionKey( SnapshotVersion sv )
    {
        return sv.getClassifier() + ":" + sv.getExtension();
    }

    public boolean merge( Metadata sourceMetadata )
    {
        boolean changed = false;

        for ( Plugin plugin : sourceMetadata.getPlugins() )
        {
            boolean found = false;

    /**
     * Returns the extension of the path.
     *
     * @param path
     *            The path. Must not be {@literal null}.
     * @return The extension.
     */
    public static String getExtension(final String path) {
        assertArgumentNotNull("path", path);

        final int extPos = path.lastIndexOf(".");
        if (extPos >= 0) {
            return path.substring(extPos + 1);
        }

                    extensions = new java.util.ArrayList<CoreExtension>();
                }
                extensions.add(parseCoreExtension(parser, strict));
                coreExtensions.setExtensions(extensions);
            } else {
                checkUnknownElement(parser, strict);
            }
        }
        return coreExtensions;

                }
                // Extensions
                org = plugin.getExtensions();
                val = interpolate(org);
                if (org != val) {
                    plugin.setExtensions(val);
                }
                // Executions
                for (PluginExecution execution : plugin.getExecutions()) {
                    visit(execution);
                }

            }
        }
    }

    protected void mergeBuild_Extensions(
            Build target, Build source, boolean sourceDominant, Map<Object, Object> context) {
        target.setExtensions(
                merge(target.getExtensions(), source.getExtensions(), sourceDominant, new ExtensionKeyComputer()));
    }

    protected void mergeExtension(

            ]]>
          </code>
        </codeSegment>
        <codeSegment>
          <version>4.0.0/4.0.99</version>
          <code>
            <![CDATA[
    public void setExtensions(boolean extensions) {
        setExtensions(String.valueOf(extensions));
    }

    /**
     * Reset the {@code executionMap} field to {@code null}
     */
     @Deprecated
    public void flushExecutionMap() {