import com.carrotsearch.junitbenchmarks.Result; //导入依赖的package包/类
public void visit(Class<?> clazz, Method method, Result result)
{
    boolean onMethod = method != null && method.isAnnotationPresent(BenchmarkHistoryChart.class);
    boolean onClass = clazz.isAnnotationPresent(BenchmarkHistoryChart.class);

    if (onMethod || onClass)
    {
        if (!types.containsKey(clazz))
        {
            types.put(clazz, new ArrayList<Method>());
        }
     
        if (onMethod)
        {
            types.get(clazz).add(method);
        }
    }
}
 

import com.carrotsearch.junitbenchmarks.Result; //导入依赖的package包/类
public void visit(Class<?> clazz, Method method, Result result)
{
    if (clazz.isAnnotationPresent(BenchmarkMethodChart.class)
        && !types.contains(clazz))
    {
        types.add(clazz);
    }
}
 

import com.carrotsearch.junitbenchmarks.Result; //导入依赖的package包/类
/**
 * Accept a single benchmark result.
 */
@Override
public void accept(Result result)
{
    // Visit chart collectors.
    final Class<?> clazz = result.getTestClass();
    final Method method = result.getTestMethod();
    for (IChartAnnotationVisitor v : chartVisitors)
    {
        v.visit(clazz, method, result);
    }
    try
    {
        PreparedStatement testInsertStatement = getTestInsertStatement();
        testInsertStatement.setString(CLASSNAME, result.getTestClassName());
        testInsertStatement.setString(NAME, result.getTestMethodName());
        testInsertStatement.setInt(BENCHMARK_ROUNDS, result.benchmarkRounds);
        testInsertStatement.setInt(WARMUP_ROUNDS, result.warmupRounds);
        testInsertStatement.setDouble(ROUND_AVG, result.roundAverage.avg);
        testInsertStatement.setDouble(ROUND_STDDEV, result.roundAverage.stddev);
        testInsertStatement.setDouble(GC_AVG, result.gcAverage.avg);
        testInsertStatement.setDouble(GC_STDDEV, result.gcAverage.stddev);
        testInsertStatement.setInt(GC_INVOCATIONS, (int) result.gcInfo.accumulatedInvocations());
        testInsertStatement.setDouble(GC_TIME, result.gcInfo.accumulatedTime() / 1000.0);
        testInsertStatement.setDouble(TIME_WARMUP, result.warmupTime / 1000.0);
        testInsertStatement.setDouble(TIME_BENCHMARK, result.benchmarkTime / 1000.0);
        testInsertStatement.executeUpdate();
    }
    catch (SQLException e)
    {
        throw new RuntimeException("Error while saving the benchmark result to H2.", e);
    }
}
 

import com.carrotsearch.junitbenchmarks.Result; //导入依赖的package包/类
@Override
public void accept(Result result) throws IOException {

    // Result's javadoc says roundAvg.avg is ms, but it seems to be s in reality
    double millis = 1000D * result.roundAverage.avg;
    double scalar = Math.max(1D, TARGET_RUNTIME_MS / Math.max(1D, millis));

    String testClass = result.getTestClassName();
    String testName = result.getTestMethodName();
    writer.write(String.format("%s.%s %.3f%n", testClass, testName, scalar));
    writer.flush();
}
 

import com.carrotsearch.junitbenchmarks.Result; //导入依赖的package包/类
public synchronized void accept(Result r) throws IOException {
    Joiner j = Joiner.on(separator);
    List<String> fields = new ArrayList<String>(Column.values().length);
    for (Column c : Column.values()) {
        fields.add(c.get(r));
    }
    csv.write(String.format("%s%n", j.join(fields)));
    log.debug("Wrote {} to {}", r, csvFile);
    csv.flush();
}
 

import com.carrotsearch.junitbenchmarks.Result; //导入依赖的package包/类
public void accept(Result result) throws IOException {
    String line =
        String.format(Locale.ROOT, "%s,%f,%f,%f,%f,%d,%d,%d,%d,%d,%d%n", prefixCSV, result.roundAverage.avg,
            result.roundAverage.stddev, result.gcAverage.avg, result.gcAverage.stddev,
            result.gcInfo.accumulatedInvocations(), result.gcInfo.accumulatedTime(), result.benchmarkRounds,
            result.benchmarkTime, result.warmupRounds, result.warmupTime);
    System.out.print(line);
    writer.write(line);
    writer.flush();
    writer.close();
}
 

import com.carrotsearch.junitbenchmarks.Result; //导入依赖的package包/类
public void accept(Result result)
{
    results.put(result.getTestMethodName(), result);
}
 

import com.carrotsearch.junitbenchmarks.Result; //导入依赖的package包/类
@Override public String get(Result r) {
    return r.getShortTestClassName();
}