}

    public void execute(final MavenSession session, final List<MojoExecution> mojoExecutions)
            throws LifecycleExecutionException {

        final DependencyContext dependencyContext = newDependencyContext(session, mojoExecutions);

        final PhaseRecorder phaseRecorder = new PhaseRecorder(session.getCurrentProject());

            this.unprefixedPathKeys = unprefixedPathKeys;
            this.projectDir = projectDir;
            this.pathTranslator = pathTranslator;
        }

        @Override
        public Object execute(String expression, Object value) {
            if (value != null) {
                expression = ValueSourceUtils.trimPrefix(expression, expressionPrefixes, true);
                if (unprefixedPathKeys.contains(expression)) {

        this.projectSelector = new ProjectSelector(); // if necessary switch to DI
    }

    @Override
    public MavenExecutionResult execute(MavenExecutionRequest request) {
        MavenExecutionResult result;

        try {
            result = doExecute(request);
        } catch (OutOfMemoryError e) {
            result = addExceptionToResult(new DefaultMavenExecutionResult(), e);

        MojoWrapper(org.apache.maven.api.plugin.Mojo mojoV4) {
            this.mojoV4 = mojoV4;
        }

        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
            try {
                mojoV4.execute();
            } catch (MojoException e) {
                throw new MojoExecutionException(e.getMessage(), e);
            }
        }

        @Override

    @Inject
    private LegacySupport legacySupport;

    private final Executor executor;

    public DefaultArtifactResolver() {
        int threads = Integer.getInteger("maven.artifact.threads", 5);
        if (threads <= 1) {
            executor = Runnable::run;
        } else {
            executor = new ThreadPoolExecutor(

     * the current build.
     */
    @Test
    void testMojoThatIsPresentInTheCurrentBuild() throws Exception {}

    /**
     * This is the case where the Mojo wants to execute on every project and then do something at the end
     * with the results of each project.
     */
    @Test
    void testAggregatorMojo() throws Exception {}

    /**

            } else {
                // goal was missing - pass through to MojoNotFoundException
                goal = "";
            }

            // This is the case where someone has executed a single goal from the command line
            // of the form:
            //
            // mvn remote-resources:process
            //

     * @see Project#getRootDirectory()
     */
    @Nonnull
    Path getRootDirectory();

    @Nonnull
    List<Project> getProjects();

    /**
     * Returns the plugin context for mojo being executed and the specified
     * {@link Project}, never returns {@code null} as if context not present, creates it.
     *
     * <strong>Implementation note:</strong> while this method return type is {@link Map}, the

    protected String getProjectsDirectory() {
        return "src/test/projects/lifecycle-executor";
    }

    // -----------------------------------------------------------------------------------------------
    // Tests which exercise the lifecycle executor when it is dealing with default lifecycle phases.