* @return The configuration to unmarshal into the bean or {@code null} if none.
     */
    Object getConfiguration();

    /**
     * Sets the configuration to unmarshal into the bean. The configuration should be taken from
     * {@link org.apache.maven.model.ConfigurationContainer#getConfiguration()} or a similar source.
     * Fully equivalent to {@code setConfiguration(configuration, null)}.
     *

import org.junit.jupiter.api.Test;

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

/**
 * A test which demonstrates maven's recursive inheritance where
 * a distinct value is taken from each parent contributing to
 * 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

    // We are going to take the project packaging and find all plugin in the default lifecycle and create
    // fully populated Plugin objects, including executions with goals and default configuration taken
    // from the plugin.xml inside a plugin.
    //
    // TODO This whole method could probably removed by injecting lifeCyclePluginAnalyzer straight into client site.

            /*
             * JAR file: can contain only one module, with descriptor at the root.
             * If no descriptor, the "Automatic-Module-Name" manifest attribute is
             * taken as a fallback.
             */
            try (JarFile jar = new JarFile(path.toFile())) {
                ZipEntry entry = jar.getEntry(MODULE_INFO);
                if (entry != null) {

          <name>optional</name>
          <version>4.0.0+</version>
          <description>
            Indicates the dependency is optional for use of this library. While the
            version of the dependency will be taken into account for dependency calculation if the
            library is used elsewhere, it will not be passed on transitively. Note: While the type

 * </p>
 * <p>
 * With changes during 3.2.2 release MavenProject is closer to being immutable after construction with the removal of
 * all components from this class, and the upfront construction taken care of entirely by the {@link ProjectBuilder}.
 * There is still the issue of having to run the lifecycle in order to find all the compile source roots and resource

        // Value taken from p2
        // ----------------------------------------------------------------------

        assertEquals("mailing-list", p4.getMailingLists().get(0).getName());

        // ----------------------------------------------------------------------
        // Value taken from p1
        // ----------------------------------------------------------------------

    // We are going to take the project packaging and find all plugins in the default lifecycle and create
    // fully populated Plugin objects, including executions with goals and default configuration taken
    // from the plugin.xml inside a plugin.
    //

    @Override
    public Set<Plugin> getPluginsBoundByDefaultToAllLifecycles(String packaging) {
        if (logger.isDebugEnabled()) {

        // The root artifact may, or may not be resolved so we need to check before we attempt to resolve.
        // This is often an artifact like a POM that is taken from disk and we already have hold of the
        // file reference. But this may be a Maven Plugin that we need to resolve from a remote repository
        // as well as its dependencies.

                project.setInjectedProfileIds(modelId, getProfileIds(result.getActivePomProfiles(modelId)));
            }

            //
            // All the parts that were taken out of MavenProject for Maven 4.0.0
            //

            project.setProjectBuildingRequest(request);

            // pluginArtifacts
            Set<Artifact> pluginArtifacts = new HashSet<>();