import static java.util.stream.Collectors.toList;

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

        def set = [1] as Set
        toSet(set).is(set)
        toSet([]).empty
    }

    def "to list"() {
        expect:
        toList([1, 2, 3] as Set) == [1, 2, 3]
        toList([]).empty
        toList(([1, 2, 3] as Vector).elements()) == [1, 2, 3]
    }

    def "sorting with comparator"() {
        given:
        def naturalComparator = { a, b -> a <=> b } as Comparator

import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collector;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toCollection;
import static java.util.stream.Collectors.toList;

public abstract class PerformanceExecutionDataProvider {
    protected static final int PERFORMANCE_DATE_RETRIEVE_DAYS = 7;
    protected TreeSet<PerformanceReportScenario> scenarioExecutions;

        return experiment;
    }

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

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

    @Override
    public List<String> getScenarioLabels() {

                                List<String> tasksToRun = toList(resultSet.getObject(2));
                                List<String> cleanTasks = toList(resultSet.getObject(7));
                                List<String> args = toList(resultSet.getObject(3));
                                List<String> gradleOpts = toList(resultSet.getObject(4));

import org.gradle.tooling.BuildController;
import org.gradle.tooling.model.Task;
import org.gradle.tooling.model.gradle.BuildInvocations;

import java.util.List;

import static java.util.stream.Collectors.toList;

public class FetchBuildInvocationsTasks implements BuildAction<List<Task>> {
    @Override
    public List<Task> execute(BuildController controller) {
        return controller.getBuildModel().getEditableBuilds().stream()

        List<ExecutionData> totalTimeData = testHistory.getScenarioLabels()
            .stream()
            .map(label -> executionDataForLabel(testHistory, label, FormatSupport::getTotalTimeSeconds, Function.identity()))
            .collect(Collectors.toList());

        return libraries.keySet()
            .stream()
            .sorted()
            .collect(Collectors.toList());
    }

    public List<String> getBundleAliases() {
        return bundles.keySet()
            .stream()
            .sorted()
            .collect(Collectors.toList());
    }

    public DependencyModel getDependencyData(String alias) {
        return libraries.get(normalize(alias));
    }

        then:
        diagnostics.exception == exception
        diagnostics.stack == exception.stackTrace.toList()
        diagnostics.location == location

        1 * locationAnalyzer.locationForUsage(_, false) >> { Failure failure, b ->
            assert failure.stackTrace == exception.stackTrace.toList()
            location
        }
    }

    def "does not populate stack traces after limit has been reached"() {

import org.gradle.tooling.internal.gradle.DefaultProjectIdentifier;
import org.gradle.tooling.model.GradleProject;

import java.util.List;
import java.util.Objects;

import static java.util.stream.Collectors.toList;
import static org.gradle.api.internal.project.ProjectHierarchyUtils.getChildProjectsForInternalUse;
import static org.gradle.plugins.ide.internal.tooling.ToolingModelBuilderSupport.buildFromTask;

/**