1 files changed, 195 insertions, 10 deletions
diff --git a/std/testing/bench_test.ts b/std/testing/bench_test.ts
index ef004807f..8e34b27a9 100644
--- a/std/testing/bench_test.ts
+++ b/std/testing/bench_test.ts
@@ -1,5 +1,12 @@
 const { test } = Deno;
-import { bench, runBenchmarks, BenchmarkRunError } from "./bench.ts";
+import {
+  bench,
+  runBenchmarks,
+  BenchmarkRunError,
+  clearBenchmarks,
+  BenchmarkRunProgress,
+  ProgressState,
+} from "./bench.ts";
 import {
   assertEquals,
   assert,
@@ -63,26 +70,27 @@ test({
 
     const benchResult = await runBenchmarks({ skip: /throw/ });
 
-    assertEquals(benchResult.measured, 5);
     assertEquals(benchResult.filtered, 1);
     assertEquals(benchResult.results.length, 5);
 
     const resultWithMultipleRunsFiltered = benchResult.results.filter(
-      (r) => r.name === "runs100ForIncrementX1e6"
+      ({ name }) => name === "runs100ForIncrementX1e6"
     );
     assertEquals(resultWithMultipleRunsFiltered.length, 1);
 
     const resultWithMultipleRuns = resultWithMultipleRunsFiltered[0];
     assert(!!resultWithMultipleRuns.runsCount);
-    assert(!!resultWithMultipleRuns.runsAvgMs);
-    assert(!!resultWithMultipleRuns.runsMs);
+    assert(!!resultWithMultipleRuns.measuredRunsAvgMs);
+    assert(!!resultWithMultipleRuns.measuredRunsMs);
     assertEquals(resultWithMultipleRuns.runsCount, 100);
-    assertEquals(resultWithMultipleRuns.runsMs!.length, 100);
+    assertEquals(resultWithMultipleRuns.measuredRunsMs!.length, 100);
+
+    clearBenchmarks();
   },
 });
 
 test({
-  name: "benchWithoutName",
+  name: "Bench without name should throw",
   fn() {
     assertThrows(
       (): void => {
@@ -95,7 +103,7 @@ test({
 });
 
 test({
-  name: "benchWithoutStop",
+  name: "Bench without stop should throw",
   fn: async function (): Promise<void> {
     await assertThrowsAsync(
       async (): Promise<void> => {
@@ -112,7 +120,7 @@ test({
 });
 
 test({
-  name: "benchWithoutStart",
+  name: "Bench without start should throw",
   fn: async function (): Promise<void> {
     await assertThrowsAsync(
       async (): Promise<void> => {
@@ -129,7 +137,7 @@ test({
 });
 
 test({
-  name: "benchStopBeforeStart",
+  name: "Bench with stop before start should throw",
   fn: async function (): Promise<void> {
     await assertThrowsAsync(
       async (): Promise<void> => {
@@ -145,3 +153,180 @@ test({
     );
   },
 });
+
+test({
+  name: "clearBenchmarks should clear all candidates",
+  fn: async function (): Promise<void> {
+    dummyBench("test");
+
+    clearBenchmarks();
+    const benchingResults = await runBenchmarks({ silent: true });
+
+    assertEquals(benchingResults.filtered, 0);
+    assertEquals(benchingResults.results.length, 0);
+  },
+});
+
+test({
+  name: "clearBenchmarks with only as option",
+  fn: async function (): Promise<void> {
+    // to reset candidates
+    clearBenchmarks();
+
+    dummyBench("test");
+    dummyBench("onlyclear");
+
+    clearBenchmarks({ only: /only/ });
+    const benchingResults = await runBenchmarks({ silent: true });
+
+    assertEquals(benchingResults.filtered, 0);
+    assertEquals(benchingResults.results.length, 1);
+    assertEquals(benchingResults.results[0].name, "test");
+  },
+});
+
+test({
+  name: "clearBenchmarks with skip as option",
+  fn: async function (): Promise<void> {
+    // to reset candidates
+    clearBenchmarks();
+
+    dummyBench("test");
+    dummyBench("skipclear");
+
+    clearBenchmarks({ skip: /skip/ });
+    const benchingResults = await runBenchmarks({ silent: true });
+
+    assertEquals(benchingResults.filtered, 0);
+    assertEquals(benchingResults.results.length, 1);
+    assertEquals(benchingResults.results[0].name, "skipclear");
+  },
+});
+
+test({
+  name: "clearBenchmarks with only and skip as option",
+  fn: async function (): Promise<void> {
+    // to reset candidates
+    clearBenchmarks();
+
+    dummyBench("test");
+    dummyBench("clearonly");
+    dummyBench("clearskip");
+    dummyBench("clearonly");
+
+    clearBenchmarks({ only: /clear/, skip: /skip/ });
+    const benchingResults = await runBenchmarks({ silent: true });
+
+    assertEquals(benchingResults.filtered, 0);
+    assertEquals(benchingResults.results.length, 2);
+    assert(!!benchingResults.results.find(({ name }) => name === "test"));
+    assert(!!benchingResults.results.find(({ name }) => name === "clearskip"));
+  },
+});
+
+test({
+  name: "progressCallback of runBenchmarks",
+  fn: async function (): Promise<void> {
+    clearBenchmarks();
+    dummyBench("skip");
+    dummyBench("single");
+    dummyBench("multiple", 2);
+
+    const progressCallbacks: BenchmarkRunProgress[] = [];
+
+    const benchingResults = await runBenchmarks(
+      { skip: /skip/, silent: true },
+      (progress) => {
+        // needs to be deep copied
+        progressCallbacks.push(progress);
+      }
+    );
+
+    let pc = 0;
+    // Assert initial progress before running
+    let progress = progressCallbacks[pc++];
+    assertEquals(progress.state, ProgressState.BenchmarkingStart);
+    assertEquals(progress.filtered, 1);
+    assertEquals(progress.queued.length, 2);
+    assertEquals(progress.running, undefined);
+    assertEquals(progress.results, []);
+
+    // Assert start of bench "single"
+    progress = progressCallbacks[pc++];
+    assertEquals(progress.state, ProgressState.BenchStart);
+    assertEquals(progress.filtered, 1);
+    assertEquals(progress.queued.length, 1);
+    assert(!!progress.queued.find(({ name }) => name == "multiple"));
+    assertEquals(progress.running, {
+      name: "single",
+      runsCount: 1,
+      measuredRunsMs: [],
+    });
+    assertEquals(progress.results, []);
+
+    // Assert result of bench "single"
+    progress = progressCallbacks[pc++];
+    assertEquals(progress.state, ProgressState.BenchResult);
+    assertEquals(progress.queued.length, 1);
+    assertEquals(progress.running, undefined);
+    assertEquals(progress.results.length, 1);
+    assert(!!progress.results.find(({ name }) => name == "single"));
+
+    // Assert start of bench "multiple"
+    progress = progressCallbacks[pc++];
+    assertEquals(progress.state, ProgressState.BenchStart);
+    assertEquals(progress.queued.length, 0);
+    assertEquals(progress.running, {
+      name: "multiple",
+      runsCount: 2,
+      measuredRunsMs: [],
+    });
+    assertEquals(progress.results.length, 1);
+
+    // Assert first result of bench "multiple"
+    progress = progressCallbacks[pc++];
+    assertEquals(progress.state, ProgressState.BenchPartialResult);
+    assertEquals(progress.queued.length, 0);
+    assertEquals(progress.running!.measuredRunsMs.length, 1);
+    assertEquals(progress.results.length, 1);
+
+    // Assert second result of bench "multiple"
+    progress = progressCallbacks[pc++];
+    assertEquals(progress.state, ProgressState.BenchPartialResult);
+    assertEquals(progress.queued.length, 0);
+    assertEquals(progress.running!.measuredRunsMs.length, 2);
+    assertEquals(progress.results.length, 1);
+
+    // Assert finish of bench "multiple"
+    progress = progressCallbacks[pc++];
+    assertEquals(progress.state, ProgressState.BenchResult);
+    assertEquals(progress.queued.length, 0);
+    assertEquals(progress.running, undefined);
+    assertEquals(progress.results.length, 2);
+    assert(!!progress.results.find(({ name }) => name == "single"));
+    const resultOfMultiple = progress.results.filter(
+      ({ name }) => name == "multiple"
+    );
+    assertEquals(resultOfMultiple.length, 1);
+    assert(!!resultOfMultiple[0].measuredRunsMs);
+    assert(!!resultOfMultiple[0].measuredRunsAvgMs);
+    assertEquals(resultOfMultiple[0].measuredRunsMs!.length, 2);
+
+    // The last progress should equal the final result from promise except the state property
+    progress = progressCallbacks[pc++];
+    assertEquals(progress.state, ProgressState.BenchmarkingEnd);
+    delete progress.state;
+    assertEquals(progress, benchingResults);
+  },
+});
+
+function dummyBench(name: string, runs = 1): void {
+  bench({
+    name,
+    runs,
+    func(b) {
+      b.start();
+      b.stop();
+    },
+  });
+}