this.version = Objects.requireNonNull(version, "version cannot be null");
    }

    public Severity getSeverity() {
        return severity;
    }

    public Version getVersion() {
        return version;
    }

    public Exception getException() {
        return exception;
    }

    public ModelProblemCollectorRequest setException(Exception exception) {

                        relocation.getGroupId(),
                        relocation.getArtifactId(),
                        null,
                        null,
                        relocation.getVersion(),
                        relocation.getMessage());
                LOGGER.debug(
                        "The artifact {} has been relocated to {}: {}",

        String realmId = "coreExtension>" + extension.getGroupId() + ":" + extension.getArtifactId() + ":"
                + extension.getVersion();
        final ClassRealm realm = classWorld.newRealm(realmId, null);
        Set<String> providedArtifacts = Collections.emptySet();
        String classLoadingStrategy = extension.getClassLoadingStrategy();

        PluginDescriptor pd = build("/plugin.xml");

        assertEquals("org.apache.maven.plugins", pd.getGroupId());
        assertEquals("maven-jar-plugin", pd.getArtifactId());
        assertEquals("2.3-SNAPSHOT", pd.getVersion());
        assertEquals("jar", pd.getGoalPrefix());
        assertEquals("plugin-description", pd.getDescription());
        assertFalse(pd.isIsolatedRealm());
        assertTrue(pd.isInheritedByDefault());

        assertCollectorState(0, 0, 0, collector);

        assertEquals("3.8.1", (out.getDependencies().get(0)).getVersion());
    }

    @Test
    public void testShouldNotInterpolateDependencyVersionWithInvalidReference() throws Exception {
        Model model = Model.newBuilder()
                .version("3.8.1")

            changed = true;
        } else {
            changed = metadata.merge(this.metadata);
        }

        // beware meta-versions!
        String version = metadata.getVersion();
        if (Artifact.LATEST_VERSION.equals(version) || Artifact.RELEASE_VERSION.equals(version)) {
            // meta-versions are not valid <version/> values...don't write them.
            metadata.setVersion(null);

    }

    private static String getKey(Model model) {
        return "project>" + model.getGroupId() + ":" + model.getArtifactId() + ":" + model.getVersion();
    }

    public ClassRealm createExtensionRealm(Plugin plugin, List<Artifact> artifacts) {
        Objects.requireNonNull(plugin, "plugin cannot be null");

                        main.getGroupId(),
                        main.getArtifactId(),
                        BUILD_POM_CLASSIFIER,
                        main.getExtension(),
                        main.getVersion(),
                        main.getProperties(),
                        main.getFile()));
            }
            for (Artifact consumer : consumers) {
                result.remove(consumer);

    public PluginDescriptor(PluginDescriptor original) {
        this.setGroupId(original.getGroupId());
        this.setArtifactId(original.getArtifactId());
        this.setVersion(original.getVersion());
        this.setGoalPrefix(original.getGoalPrefix());
        this.setInheritedByDefault(original.isInheritedByDefault());
        this.setName(original.getName());

    }

    public String getType() {
        return artifact.getExtension();
    }

    public String getClassifier() {
        return artifact.getClassifier();
    }

    public String getVersion() {
        return artifact.getBaseVersion();
    }

    public File getFile() {
        return artifact.getFile();
    }

    @Override
    public String toString() {
        return artifact.toString();