parent.getVersion(),
                        true,
                        false);
            }

            Build build = project.getModel().getDelegate().getBuild();
            if (build != null) {
                for (Plugin plugin : build.getPlugins()) {
                    addEdge(
                            projectMap,
                            vertexMap,

        logger.debug("Resolving plugin prefix {} from {}", request.getPrefix(), request.getPluginGroups());

        Model pom = request.getPom();
        Build build = pom != null ? pom.getBuild() : null;
        PluginManagement management = build != null ? build.getPluginManagement() : null;

        // map of groupId -> Set(artifactId) plugin candidates:

                visit(model.getPrerequisites());
                visit(model.getScm());
                visit(model.getIssueManagement());
                visit(model.getCiManagement());
                visit(model.getBuild());
                for (Profile profile : model.getProfiles()) {
                    visit(profile);
                }
            }
        }

        private void visit(Parent parent) {

        public String getGroupId() {
            return groupId;
        }

        public List<Dependency> getDependencies() {
            return dependencies;
        }

        public Build getBuild() {
            return build;
        }

        public String getArtifactId() {
            return artifactId;
        }

        public String getName() {
            return name;
        }

        return session;
    }

    @Test
    public void testTwoExpressions() throws Exception {
        MavenProject project = createDefaultProject();
        Build build = project.getBuild();
        build.setDirectory("expected-directory");
        build.setFinalName("expected-finalName");

        ExpressionEvaluator expressionEvaluator = createExpressionEvaluator(project, new Properties());

            validateRawRepositories(
                    problems, m.getPluginRepositories(), "pluginRepositories.pluginRepository.", EMPTY, request);

            Build build = m.getBuild();
            if (build != null) {
                validate20RawPlugins(problems, build.getPlugins(), "build.plugins.plugin.", EMPTY, request);

                PluginManagement mgmt = build.getPluginManagement();

                        .collect(Collectors.toSet());
                for (BuildStep step : planSteps) {
                    MavenProject project = step.project;
                    for (Plugin plugin : project.getBuild().getPlugins()) {
                        for (PluginExecution execution : plugin.getExecutions()) {
                            for (String goal : execution.getGoals()) {

                .collect(Collectors.toList());
    }

    private static boolean isEmpty(Profile profile) {
        return profile.getActivation() == null
                && profile.getBuild() == null
                && profile.getDependencies().isEmpty()
                && (profile.getDependencyManagement() == null
                        || profile.getDependencyManagement().getDependencies().isEmpty())

        // =============================================
        assertEquals("||${project.basedir}||", originalModel.getProperties().get("prop-outside"));

        List<Plugin> outsidePlugins = originalModel.getBuild().getPlugins();
        assertEquals(1, outsidePlugins.size());

        checkBuildPluginWithArtifactId(
                outsidePlugins,
                "plugin-all-profiles",

        Build src = source.getBuild();
        if (src != null) {
            Build tgt = target.getBuild();
            if (tgt == null) {
                tgt = new Build();
                target.setBuild(tgt);
            }
            mergeBuild(tgt, src, sourceDominant, context);
        }
    }