Plugin cur = plugins.putIfAbsent(plugin, plugin);
        if (cur != null) {
            Map<String, PluginExecution> execs = new LinkedHashMap<>();
            cur.getExecutions().forEach(e -> execs.put(e.getId(), e));
            plugin.getExecutions().forEach(e -> {
                int i = 0;
                String id = e.getId();
                while (execs.putIfAbsent(id, e.withId(id)) != null) {

                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 : src) {

    }

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

    @Override
    public List<? extends PerformanceTestExecution> getExecutions() {
        return ImmutableList.of();
    }

    @Override
    public int getScenarioCount() {
        return 0;
    }

    @Override
    public List<String> getScenarioLabels() {

                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 : src) {

        for (Plugin plugin : plugins) {
            XmlNode pluginConfiguration = plugin.getDelegate().getConfiguration();

            if (pluginConfiguration != null) {
                for (PluginExecution execution : plugin.getExecutions()) {
                    XmlNode executionConfiguration = execution.getDelegate().getConfiguration();
                    executionConfiguration = XmlNode.merge(executionConfiguration, pluginConfiguration);

    PerformanceExperiment getExperiment();

    /**
     * The results of all executions of this performance test, ordered from most recent to least recent.
     */
    List<? extends PerformanceTestExecution> getExecutions();

    /**
     * Returns the number of scenarios for this performance test.
     */
    int getScenarioCount();

    /**
     * Returns the display names for the scenarios of this performance test.

public interface PerformanceExecutionGraphRenderer {
    default List<ExecutionGraph> getGraphs(PerformanceTestHistory history) {
        List<PerformanceTestExecution> executions = history.getExecutions()
            .stream()
            .filter(this::sameCommit)
            .filter(this::hasTwoDataLines)
            .collect(toList());

                }

                if (mojo.getDependencies() != null) {
                    plugin.setDependencies(mojo.getDependencies());
                }
                plugin.getExecutions().add(execution);
            }
        }
    }

    private GoalSpec parseGoalSpec(String goalSpec) {
        GoalSpec gs = new GoalSpec();

        String[] p = goalSpec.trim().split(":");

                if (existing != null) {
                    if (version == null) {
                        version = existing.getVersion();
                    }
                    execs.addAll(existing.getExecutions());
                    deps.addAll(existing.getDependencies());
                }

                PluginExecution execution = PluginExecution.newBuilder()
                        .id(getExecutionId(existing, goal))

        PrintWriter out = new PrintWriter(output);
        List<? extends PerformanceTestExecution> sortedResults = Lists.reverse(testHistory.getExecutions());

        List<ExecutionLabel> executionLabels = sortedResults.stream().map(ExecutionLabel::new).collect(Collectors.toList());
        List<ExecutionData> totalTimeData = testHistory.getScenarioLabels()