In order the understand how inheritance works in Maven there are a few notions that you must be familiar with:

 * The maven super model

 * how parent poms are processed

 * the order in which elements in the POM are overridden

 * minimum element-set for a valid project pom


Maven super model

 Inheritance is recursive in Maven but there is a special model which is the implicit super parent in the lineage
 of models you may specify:

          <name>licenses</name>
          <version>3.0.0+</version>
          <description>
            <![CDATA[
            This element describes all the licenses for this project.
            Each license is described by a {@code license} element, which
            is then described by additional elements.
            Projects should only list the license(s) that applies to the project
            and not the licenses that apply to dependencies.

import org.apache.maven.api.annotations.Nonnull;

/**
 * Information about the modules contained in a path element.
 * The path element may be a JAR file or a directory. Directories may use either package hierarchy
 * or module hierarchy, but not module source hierarchy. The latter is excluded because this class
 * is for path elements of compiled codes.
 */
class PathModularization {
    /**

     * If {@code element} is not {@code null}, child configuration element with the specified name will
     * be unmarshalled.
     *
     * @param configuration The configuration to unmarshal, may be {@code null}.
     * @param element Configuration element name to unmarshal or {@code null} to unmarshal entire configuration.

    /**
     * Returns a filtered list of classpath elements. This method is invoked when the caller
     * requested that all dependencies are placed on the classpath, with no module-path element.
     *
     * @param scopeFilter a filter returning {@code true} for the artifact scopes to accept.
     * @param includeTestDir whether to include the test directory in the classpath elements.
     * @return paths of all artifacts placed on the classpath.

  <artifactId>test3</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>Maven Integration Test :: MNG-4053</name>
  <description>
    Verify that attributes in plugin configuration elements are not erroneously duplicated to other elements when
    plugin management and a profile are used.
  </description>

  <build>
    <!-- NOTE: This test used plugin management for the IT plugin -->
    <pluginManagement>
      <plugins>

import org.apache.maven.project.ExtensionDescriptorBuilder;
import org.codehaus.plexus.classworlds.realm.ClassRealm;

/**
 * Provides information about artifacts (identified by groupId:artifactId string key) and classpath elements exported by
 * Maven core itself or a Maven core extension.
 *
 * @since 3.3.0
 */
public class CoreExtensionEntry {
    private final ClassRealm realm;

    private final Set<String> artifacts;

    </default>
  </defaults>
  <classes>
    <class rootElement="true" xml.tagName="extension">
      <name>ExtensionDescriptor</name>
      <version>1.0.0</version>
      <description><![CDATA[Root element of the <code>extension.xml</code> file.]]></description>
      <fields>
        <field>
          <name>exportedPackages</name>
          <version>1.0.0</version>
          <association>
            <type>String</type>

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * The annotated element must not be null.
 * <p>
 * Annotated fields must not be null after construction has completed.
 * <p>
 * When this annotation is applied to a method it applies to the method return value.
 *
 * @see Nullable

        try (InputStream is = Files.newInputStream(pom)) {
            XMLStreamReader parser = new WstxInputFactory().createXMLStreamReader(is);
            if (parser.nextTag() == XMLStreamReader.START_ELEMENT
                    && parser.getLocalName().equals("project")) {
                for (int i = 0; i < parser.getAttributeCount(); i++) {
                    if ("root".equals(parser.getAttributeLocalName(i))) {