*
     * @see #getModuleInfo(Path)
     */
    private final Map<Path, PathModularization> moduleInfo;

    /**
     * Whether JAR files are modular. This map is redundant with {@link #moduleInfo},
     * but cheaper to compute when the module names are not needed.
     *
     * @see #getPathType(Path)
     */
    private final Map<Path, PathType> pathTypes;

    /**
     * Creates an initially empty cache.

    through a medium customarily used for software exchange.

    3.2. Modifications.

    The Modifications that You create or to which You contribute are
    governed by the terms of this License. You represent that You
    believe Your Modifications are Your original creation(s) and/or You
    have sufficient rights to grant the rights conveyed by this License.

    3.3. Required Notices.

The most important stubs are:
LifecycleExecutionPlanCalculatorStub
ProjectDependencyGraphStub

Since they define the primary structure of the project/build.

The stubs define three top-level targets that are defined in  LifecycleTaskSegmentCalculatorStub;
clean, aggr and install. "aggr" is an aggregating task while clean and install are lifecyclephases.

    /**
     * The path separator.
     */
    private static final String PATH_SEP = System.getProperty("path.separator");

    static {
        // Those two public constants are initialized here, as they need all the private constants
        // above to be initialized first, but the code style imposes the public constants to be
        // defined above the private ones...
        OS_FAMILY = getOsFamily();

  <artifactId>parent</artifactId>
  <version>1</version>
  <packaging>pom</packaging>

  <name>Maven Integration Test :: MNG-3023</name>
  <description>Test that reactor projects are included in dependency resolution.</description>

  <modules>
    <module>dependency</module>
    <module>consumer</module>
  </modules>

 * 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.api.services.model;

import java.util.Properties;

import org.apache.maven.api.services.ModelBuilderRequest;

/**
 * Allows a fixed set of properties that are valid inside a version and that could be overwritten for example on the
 * commandline
 */
public interface ModelVersionProcessor {

    /**
     * @param property the property to check

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.building;

import java.util.ArrayList;
import java.util.List;

/**
 * Collects problems that are encountered during settings building.
 *
 */
class DefaultProblemCollector implements ProblemCollector {

    private final List<Problem> problems;

    private String source;

specific language governing permissions and limitations
under the License.
-->

<project>
  <modelVersion>4.0.0</modelVersion>

  <!--
  While <contributors> are inherited, they are not aggregated, only the child elements are used.
  -->

  <parent>
    <groupId>org.apache.maven.its.mng3843</groupId>
    <artifactId>parent-1</artifactId>
    <version>0.1</version>
  </parent>

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * A test which demonstrates maven's recursive inheritance where
 * we are testing to make sure that elements stated in a model are
 * not clobbered by the same elements elsewhere in the lineage.
 *
 */
@Deprecated
class ProjectInheritanceTest extends AbstractProjectInheritanceTestCase {