for (Dependency dependency : source.getDependencies()) {
                    String key = dependency.getManagementKey();
                    Dependency present = dependencies.putIfAbsent(key, dependency);
                    if (present != null && !equals(dependency, present) && !directDependencies.contains(key)) {
                        // TODO: https://issues.apache.org/jira/browse/MNG-8004
                        problems.add(

  <name>Maven Integration Test :: MNG-3886</name>
  <description>
    Test that the goals from a plugin execution are executed in the order given by the POM, regardless whether
    plugin management is present or not.
  </description>

  <build>
    <!-- This project does not use plugin management for the test plugin -->
    <plugins>
      <plugin>
        <groupId>org.apache.maven.its.plugins</groupId>

    DEACTIVATION_REQUIRED(false, false);

    /**
     * Should the target be active?
     */
    final boolean active;
    /**
     * Should the build continue if the target is not present?
     */
    final boolean optional;

    ActivationSettings(final boolean active, final boolean optional) {
        this.active = active;
        this.optional = optional;
    }

     * Injects plugin executions induced by lifecycle bindings into the specified model. The model has already undergone
     * injection of plugin management so any plugins that are injected by lifecycle bindings and are not already present
     * in the model's plugin section need to be subjected to the model's plugin management.
     *
     * @param model The model into which to inject the default plugin executions for its packaging, must not be

     * @return The extracted descriptor or {@code null} if no descriptor was found.
     * @throws IOException If the descriptor is present but could not be parsed.
     */
    public ExtensionDescriptor build(File extensionJar) throws IOException {
        ExtensionDescriptor extensionDescriptor = null;

        if (extensionJar.isFile()) {

         * by doing some change (for example by changing POM and fixing the problematic plugin configuration).
         */
        INTERNAL,

        /**
         * Issue (present in some plugin) is "developer actionable" (of given plugin, by changing code and doing
         * new release), is NOT local to the currently built project. It may be reparable by updating given plugin

// 2 tools for doing the mapping
// 3 the component model -> interfaces for the plugin

// The plugin manager should load up a directory structure of plugins.
// - a plugin per directory where the plugin is present with its deps
// - a plugin that has its dependencies packaged up with it
// - implement filters and create a test where a plugin fails if the right classes are not filtered

    public static final String CONSTITUTES_BUILD_PATH = "constitutesBuildPath";

    /**
     * The (expected) path to the artifact on the local filesystem. An artifact which has this property set is assumed
     * to be not present in any regular repository and likewise has no artifact descriptor. Artifact resolution will
     * verify the path and resolve the artifact if the path actually denotes an existing file. If the path isn't valid,

 * the final model of the project being assembled. There is no
 * overriding going on amongst the models being used in this test:
 * each model in the lineage is providing a value that is not present
 * anywhere else in the lineage. We are just making sure that values
 * down in the lineage are bubbling up where they should.
 *
 */
@Deprecated
class ProjectInheritanceTest extends AbstractProjectInheritanceTestCase {

 * under the License.
 */
package org.apache.maven.repository;

import java.util.ArrayList;
import java.util.Collection;

/**
 * This is the main graph data structure used by the RepositorySystem to present tree and graph objects.
 *
 *
 */
@Deprecated
public class MetadataGraph {
    /** all graph nodes */
    Collection<MetadataGraphNode> nodes;

    /** entry point for tree-like structures */