List<PerformanceReportScenarioHistoryExecution> historyExecutions = removeEmptyExecution(history.getExecutions());
        return new PerformanceReportScenario(
            teamCityExecutionsOfSameScenario,
            historyExecutions,
            history instanceof CrossBuildPerformanceTestHistory,

        Map<String, List<String>> goals = new HashMap<>();
        lifecycle.phases().forEach(phase -> phase.plugins()
                .forEach(plugin -> plugin.getExecutions().forEach(exec -> exec.getGoals()
                        .forEach(goal -> goals.computeIfAbsent(phase.name(), n -> new ArrayList<>())

        // Goal specific configuration
        // ----------------------------------------------------------------------

        List<PluginExecution> executions = plugin.getExecutions();

        PluginExecution execution = executions.get(0);

        String g0 = execution.getGoals().get(0);

        assertEquals("plexus:runtime", g0);

            XmlNode pluginConfiguration = plugin.getConfiguration();
            if (pluginConfiguration != null) {
                return plugin.withExecutions(map(
                        plugin.getExecutions(),
                        execution -> execution.withConfiguration(
                                XmlNode.merge(execution.getConfiguration(), pluginConfiguration))));
            } else {
                return plugin;

                Plugin source,
                boolean sourceDominant,
                Map<Object, Object> context) {
            List<PluginExecution> src = source.getExecutions();
            if (!src.isEmpty()) {
                List<PluginExecution> tgt = target.getExecutions();
                Map<Object, PluginExecution> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);

                for (PluginExecution element : tgt) {

                Plugin source,
                boolean sourceDominant,
                Map<Object, Object> context) {
            List<PluginExecution> src = source.getExecutions();
            if (!src.isEmpty()) {
                List<PluginExecution> tgt = target.getExecutions();
                Map<Object, PluginExecution> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);

                for (PluginExecution element : tgt) {

        return newestFirst;
    }

    @Override
    public PerformanceExperiment getExperiment() {
        return experiment;
    }

    @Override
    public List<PerformanceTestExecution> getExecutions() {
        return newestFirst.stream().map(KnownBuildSpecificationsPerformanceTestExecution::new).collect(Collectors.toList());
    }

    @Override
    public int getScenarioCount() {
        return builds.size();

            count = count + 1;

            validPluginCounts.put(pluginArtifactId, count);
        }

        assertNotNull(testPlugin);

        List<PluginExecution> executions = testPlugin.getExecutions();

        assertEquals(1, executions.size());
    }

        }

        if (plugin != null) {
            PluginExecution pluginExecution =
                    findPluginExecution(mojoExecution.getExecutionId(), plugin.getExecutions());

            XmlNode pomConfiguration = null;

            if (pluginExecution != null) {
                pomConfiguration = pluginExecution.getDelegate().getConfiguration();

            }
        };
    }

    @Override
    public PluginExecution getModel() {
        return delegate.getPlugin().getExecutions().stream()
                .filter(pe -> Objects.equals(pe.getId(), getExecutionId()))
                .findFirst()
                .map(org.apache.maven.model.PluginExecution::getDelegate)
                .orElse(null);