@PlexusTest
class PomConstructionTest {
    private static final String BASE_DIR = "src/test";

    private static final String BASE_POM_DIR = BASE_DIR + "/resources-project-builder";

    private static final String BASE_MIXIN_DIR = BASE_DIR + "/resources-mixins";

    @Inject
    private DefaultProjectBuilder projectBuilder;

    @Inject
    private MavenRepositorySystem repositorySystem;

    @Inject

            result = determineVersionMatch(os.getVersion());
        }
        return result;
    }

    private boolean ensureAtLeastOneNonNull(ActivationOS os) {
        return os.getArch() != null || os.getFamily() != null || os.getName() != null || os.getVersion() != null;
    }

    private boolean determineVersionMatch(String version) {
        String test = version;
        boolean reverse = false;

/**
 * DefaultLifecycleMapping
 */
public class DefaultLifecycleMapping implements LifecycleMapping {

    private List<Lifecycle> lifecycles;

    private Map<String, Lifecycle> lifecycleMap;

    /** @deprecated use lifecycles instead */
    @Deprecated
    private Map<String, LifecyclePhase> phases;

    /**

import org.w3c.dom.Element
import gradlebuild.docs.dsl.source.model.TypeMetaData

class BlockDoc implements DslElementDoc {
    private final MethodDoc blockMethod
    private final PropertyDoc blockProperty
    private final TypeMetaData type
    private boolean multiValued

    BlockDoc(MethodDoc blockMethod, PropertyDoc blockProperty, TypeMetaData type, boolean multiValued) {
        this.blockMethod = blockMethod

    protected Set<String> excludedArtifacts;

    private final Set<String> coreArtifacts;

    @Inject
    public DefaultArtifactFilterManager(List<ArtifactFilterManagerDelegate> delegates, CoreExports coreExports) {
        this.delegates = delegates;
        this.coreArtifacts = coreExports.getExportedArtifacts();
    }

    private synchronized Set<String> getExcludedArtifacts() {

import static org.mockito.Mockito.mock;

/**
 */
@Deprecated
class ArtifactDeployerTest extends AbstractArtifactComponentTestCase {
    @Inject
    private ArtifactDeployer artifactDeployer;

    @Inject
    private SessionScope sessionScope;

    protected String component() {
        return "deployer";
    }

    @Test
    void testArtifactInstallation() throws Exception {

import org.apache.maven.api.model.Plugin;
import org.apache.maven.plugin.descriptor.PluginDescriptor;

class PluginLifecycle implements Lifecycle {
    private final org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle lifecycleOverlay;
    private final PluginDescriptor pluginDescriptor;

    PluginLifecycle(
            org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle lifecycleOverlay,

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Log at debug level the mojo configuration.
 *
 */
@Deprecated
public class DebugConfigurationListener implements ConfigurationListener {
    private final Logger logger;

    /**
     * @deprecated Use {@link #DebugConfigurationListener(Logger)} instead.
     */
    @Deprecated
    public DebugConfigurationListener(org.codehaus.plexus.logging.Logger logger) {

    }

    /**
     * Applies limited parent-related inference optimizations for Maven 4.0.0+ models.
     * Removes redundant child groupId/version that can be inferred from parent.
     */
    private boolean applyLimitedParentInference(UpgradeContext context, Document pomDocument) {
        Element root = pomDocument.root();

        // Check if this POM has a parent

/**
 * Forwards execution events to EventSpies.
 * @since 3.0.2
 */
class EventSpyExecutionListener extends AbstractExecutionListener {

    private final EventSpyDispatcher dispatcher;

    private final ExecutionListener delegate;

    EventSpyExecutionListener(EventSpyDispatcher dispatcher, ExecutionListener delegate) {
        this.dispatcher = dispatcher;
        this.delegate = delegate;