* processes one artifact at a time and hence cannot associate the artifacts from the same project to use the
         * same version index. Allowing the caller to pass in metadata from a previous deployment allows to re-establish
         * the association between the artifacts of the same project.
         */
        for (Iterator<? extends Metadata> it = metadatas.iterator(); it.hasNext(); ) {

public class MavenExecutionPlan implements Iterable<ExecutionPlanItem> {

    /*
      At the moment, this class is totally immutable, and this is in line with thoughts about the
      pre-calculated execution plan that stays the same during the execution.

      If deciding to add mutable state to this class, it should be at least considered to
      separate this into a separate mutable structure.

    */

 * <p>
 * Unlike a cache, this session data is not subject to purging. For this same reason, session data should also not be
 * abused as a cache (i.e. for storing values that can be re-calculated) to avoid memory exhaustion.
 * <p>
 * <strong>Note:</strong> Actual implementations must be thread-safe.
 *
 * @see Session#getData()
 * @since 4.0.0
 */
@Experimental
@ThreadSafe
@Provider

 * <tr><td><code>project.*</code></td>         <td></td>               <td></td></tr>
 * <tr><td><code>pom.*</code></td>             <td>(since Maven 3)</td><td>same as <code>project.*</code></td></tr>
 * <tr><td><code>executedProject</code></td>   <td></td>
 *                                             <td>{@link MavenProject#getExecutionProject()}</td></tr>

main channel of communication for contributors.  
There are some guidelines which will make applying PRs easier for us:
+ Create a topic branch from where you want to base your work (this is usually the master branch).
  Push your changes to a topic branch in your fork of the repository.
+ Make commits of logical units.
+ Respect the original code style: by using the same [codestyle][code-style],

import org.apache.maven.api.PathType;

/**
 * Cache of {@link PathModularization} instances computed for given {@link Path} elements.
 * The cache is used for avoiding the need to reopen the same files many times when the
 * same dependency is used for different scope. For example a path used for compilation
 * is typically also used for tests.
 */
class PathModularizationCache {
    /**

        assertSame(range, VersionRange.createFromVersionSpec("[1.0,1.2]")); // same instance from spec cache

        VersionRange spec = VersionRange.createFromVersionSpec("1.0");
        assertSame(spec, VersionRange.createFromVersionSpec("1.0")); // same instance from spec cache
        List<Restriction> restrictions = spec.getRestrictions();

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

import org.apache.maven.artifact.Artifact;

/**
 * This exception is thrown if an application attempts to attach
 * two of the same artifacts to a single project.
 *
 * TODO Make this a checked exception, and modify the API of MavenProjectHelper.
 * Currently, this modification would create compatibility problems for existing plugins.
 */

public class DefaultMavenPluginManager implements MavenPluginManager {

    /**
     * <p>
     * PluginId =&gt; ExtensionRealmCache.CacheRecord map MavenProject context value key. The map is used to ensure the
     * same class realm is used to load build extensions and load mojos for extensions=true plugins.
     * </p>
     * <strong>Note:</strong> This is part of internal implementation and may be changed or removed without notice
     *

        // Check p0 value for org name
        // ----------------------------------------------------------------------

        MavenProject p0 = getProject(projectFile("maven.t01", "p0"));

        assertEquals("p0-org", p0.getOrganization().getName());

        // ----------------------------------------------------------------------
        // Check p1 value for org name