String result;
        int idx = filename.indexOf('.');
        if (idx < 0) {
            result = filename + '-' + repositoryKey;
        } else {
            result = filename.substring(0, idx) + '-' + repositoryKey + filename.substring(idx);
        }
        return result;
    }

        ArtifactResolutionResult result = new ArtifactResolutionResult();

        if (request.isResolveRoot()) {
            try {
                resolve(request.getArtifact(), request);
                result.addArtifact(request.getArtifact());
            } catch (IOException e) {
                result.addMissingArtifact(request.getArtifact());
            }
        }

            throws ProjectBuildingException {
        ProjectBuildingResult result = super.build(pomFile, configuration);

        result.getProject().setRemoteArtifactRepositories(Collections.<ArtifactRepository>emptyList());

        return result;
    }

        BuilderCommon.attachToThread(mavenProject);

        List<ExecutionPlanItem> result = new ArrayList<>();
        for (MojoExecution mojoExecution : executions) {
            result.add(new ExecutionPlanItem(mojoExecution));
        }
        return result;
    }

    public MojoExecution getMojoExecution() {
        return mojoExecution;
    }

    private final MavenExecutionResult result;

    private final ClassLoader originalContextClassLoader;

    private final ReactorBuildStatus reactorBuildStatus;

    public ReactorContext(
            MavenExecutionResult result,
            ClassLoader originalContextClassLoader,
            ReactorBuildStatus reactorBuildStatus) {
        this.result = result;

        MavenSession session = newMavenSession();

        Object result = new PluginParameterExpressionEvaluator(session, exec).evaluate("${plugin}");

        System.out.println("Result: " + result);

        assertSame(
                exec.getMojoDescriptor().getPluginDescriptor(),
                result,
                "${plugin} expression does not return plugin descriptor.");
    }

    @Test

     */
    List<ModelProblem> getProblems();

    /**
     * Gets the result of the dependency resolution for the project.
     *
     * @return The result of the dependency resolution for the project or {@code null} if the project dependencies were
     *         not requested.
     */
    DependencyResolutionResult getDependencyResolutionResult();

    private final DependencyResolutionResult dependencyResolutionResult;

    /**
     * Creates a new result with the specified contents.
     *
     * @param project The project that was built, may be {@code null}.
     * @param problems The problems that were encountered, may be {@code null}.
     * @param dependencyResolutionResult The result of the resolution for the project dependencies, may be {@code null}.
     */
    DefaultProjectBuildingResult(

        Result<ProjectDependencyGraph> result = graphBuilder.build(session);

        assertThat(result.hasErrors())
                .withFailMessage("Expected result not to have errors")
                .isFalse();
        List<MavenProject> actualReactorProjects = result.get().getSortedProjects();
        assertEquals(2, actualReactorProjects.size());

            Model model, List<Profile> profiles, ModelBuilderRequest request, ModelProblemCollector problems) {
        Model result = CACHE.computeIfAbsent(model, k -> new ConcurrentHashMap<>())
                .computeIfAbsent(profiles, l -> doInjectProfiles(model, profiles));
        return result == KEY ? model : result;
    }

    private Model doInjectProfiles(Model model, List<Profile> profiles) {
        Model orgModel = model;