* limitations under the License.
 */

package org.gradle.performance.results;

import java.util.Arrays;
import java.util.List;

public abstract class PerformanceTestResult {
    private String testId;
    private String testClass;
    private String testProject;
    private String teamCityBuildId;
    private String jvm;
    private String operatingSystem;

        this.flameGraphGenerator = new FlameGraphGenerator()
        this.dataReporter = gradleProfilerReporter.reportAlso(new DataReporter<PerformanceTestResult>() {
            @Override
            void report(PerformanceTestResult results) {
                if (AbstractBuildExperimentRunner.isProfilingActive()) {

import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.List;
import java.util.function.Consumer;

public class GradleProfilerReporter implements DataReporter<PerformanceTestResult> {
    private final OutputDirSelector outputDirSelector;
    private final CompositeReportGenerator compositeReportGenerator;
    private final BenchmarkResultCollector resultCollector;

 */

package org.gradle.performance.results;

import java.io.Closeable;
import java.util.Arrays;
import java.util.stream.Collectors;

public interface DataReporter<T extends PerformanceTestResult> extends Closeable {
    void report(T results);

    default String insertStatement(String table, String... columns) {
        return "insert into " +
            table +
            "(" +

 * limitations under the License.
 */

package org.gradle.performance.results

class NoResultsStore<T extends PerformanceTestResult> implements WritableResultsStore<T> {

    private static final INSTANCE = new NoResultsStore()

    static <T extends PerformanceTestResult> WritableResultsStore<T> getInstance() {
        return INSTANCE
    }

    @Override
    void report(T results) {
    }

import com.google.common.collect.ImmutableList;

import java.io.IOException;

public class CompositeDataReporter<T extends PerformanceTestResult> implements DataReporter<T> {
    private final ImmutableList<DataReporter<? super T>> reporters;

    @SafeVarargs
    public static <S extends PerformanceTestResult> CompositeDataReporter<S> of(DataReporter<? super S>... reporters) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.performance.results;

public interface WritableResultsStore<T extends PerformanceTestResult> extends DataReporter<T>, ResultsStore {

 */

package org.gradle.performance.results

import groovy.transform.CompileStatic
import org.gradle.api.Transformer

@CompileStatic
class CrossVersionPerformanceResults extends PerformanceTestResult {
    List<String> args
    List<String> tasks
    List<String> cleanTasks
    List<String> gradleOpts
    Boolean daemon

    private final Map<String, BaselineVersion> baselineVersions = new LinkedHashMap<>()

 * limitations under the License.
 */

package org.gradle.performance.results

import groovy.transform.CompileStatic

@CompileStatic
class CrossBuildPerformanceResults extends PerformanceTestResult {
    String testGroup

    private final Map<BuildDisplayInfo, MeasuredOperationList> buildResults = new LinkedHashMap<>()

    @Override
    String toString() {
        return testId
    }

import groovy.transform.CompileStatic

import javax.annotation.Nonnull
import java.sql.Timestamp
import java.time.LocalDateTime

@CompileStatic
abstract class AbstractWritableResultsStore<T extends PerformanceTestResult> implements WritableResultsStore<T> {
    private final PerformanceDatabase db

    AbstractWritableResultsStore(PerformanceDatabase db) {
        this.db = db
    }