benchmark: avoid switch in test runner benchmarks

Select each benchmark variant before starting the timer so the
measured loop does not include dispatch overhead.

Signed-off-by: Luan Muniz <luan@luanmuniz.com.br>

Author: luanmuniz

benchmark/test_runner/hooks.js

@@ -13,51 +13,44 @@ const {
 } = require('node:test');
 
 const bench = common.createBenchmark(main, {
-  n: [10, 100, 1000],
-  hook: ['none', 'before', 'after', 'beforeEach', 'afterEach'],
+  n: [1, 10, 100, 1000],
+  hook: ['before', 'after', 'beforeEach', 'afterEach'],
 }, {
   // We don't want to test the reporter here.
   flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
 });
 
-async function run({ n, hook }) {
-  // eslint-disable-next-line no-unused-vars
-  let avoidV8Optimization;
+const noop = () => {};
 
-  const noop = () => {};
+const hookList = {
+  before: before,
+  after: after,
+  beforeEach: beforeEach,
+  afterEach: afterEach,
+};
 
-  for (let i = 0; i < n; i++) {
+function run(loopAmount, avoidV8Optimization, hookFn) {
+  for (let i = 0; i < loopAmount; i++) {
     describe(`${i}`, () => {
-      switch (hook) {
-        case 'before':
-          before(noop);
-          break;
-        case 'after':
-          after(noop);
-          break;
-        case 'beforeEach':
-          beforeEach(noop);
-          break;
-        case 'afterEach':
-          afterEach(noop);
-          break;
-        case 'none':
-          break;
-      }
+      hookFn(noop);
 
       it(`${i}`, () => {
         avoidV8Optimization = i;
       });
     });
   }
 
-  await finished(reporter);
+  return finished(reporter);
 }
 
 function main(params) {
+  // eslint-disable-next-line prefer-const
+  let avoidV8Optimization = 0;
+  const hookFn = hookList[params.hook];
+
   bench.start();
 
-  run(params).then(() => {
+  run(params.n, avoidV8Optimization, hookFn).then(() => {
     bench.end(params.n);
   });
 }

benchmark/test_runner/test-options.js

@@ -6,7 +6,7 @@ const reporter = require('../fixtures/empty-test-reporter');
 const { it } = require('node:test');
 
 const bench = common.createBenchmark(main, {
-  n: [100, 1000],
+  n: [1, 10, 100, 1000],
   option: [
     'none',
     'skip',
@@ -23,72 +23,102 @@ const bench = common.createBenchmark(main, {
   flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
 });
 
-async function run({ n, option }) {
-  // eslint-disable-next-line no-unused-vars
-  let avoidV8Optimization;
+const allTests = {
+  'none': (loopAmount, avoidV8Optimization) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, () => {
+        avoidV8Optimization = i;
+      });
+    }
 
-  for (let i = 0; i < n; i++) {
-    switch (option) {
-      case 'none':
-        it(`${i}`, () => {
-          avoidV8Optimization = i;
-        });
-        break;
-      case 'skip':
-        it(`${i}`, { skip: true }, () => {
-          throw new Error('This test should not run.');
-        });
-        break;
-      case 'skip-with-message':
-        it(`${i}`, { skip: 'skip reason' }, () => {
-          throw new Error('This test should not run.');
-        });
-        break;
-      case 'skip-method':
-        it(`${i}`, (t) => {
-          avoidV8Optimization = i;
-          t.skip();
-        });
-        break;
-      case 'skip-method-with-message':
-        it(`${i}`, (t) => {
-          avoidV8Optimization = i;
-          t.skip('skip reason');
-        });
-        break;
-      case 'todo':
-        it(`${i}`, { todo: true }, () => {
-          avoidV8Optimization = i;
-        });
-        break;
-      case 'todo-with-message':
-        it(`${i}`, { todo: 'todo reason' }, () => {
-          avoidV8Optimization = i;
-        });
-        break;
-      case 'todo-method':
-        it(`${i}`, (t) => {
-          avoidV8Optimization = i;
-          t.todo();
-        });
-        break;
-      case 'todo-method-with-message':
-        it(`${i}`, (t) => {
-          avoidV8Optimization = i;
-          t.todo('todo reason');
-        });
-        break;
+    return finished(reporter);
+  },
+  'skip': (loopAmount) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, { skip: true }, () => {
+        throw new Error('This test should not run.');
+      });
     }
-  }
 
-  await finished(reporter);
-  return n;
-}
+    return finished(reporter);
+  },
+  'skip-with-message': (loopAmount) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, { skip: 'skip reason' }, () => {
+        throw new Error('This test should not run.');
+      });
+    }
+
+    return finished(reporter);
+  },
+  'skip-method': (loopAmount, avoidV8Optimization) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, (t) => {
+        avoidV8Optimization = i;
+        t.skip();
+      });
+    }
+
+    return finished(reporter);
+  },
+  'skip-method-with-message': (loopAmount, avoidV8Optimization) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, (t) => {
+        avoidV8Optimization = i;
+        t.skip('skip reason');
+      });
+    }
+
+    return finished(reporter);
+  },
+  'todo': (loopAmount, avoidV8Optimization) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, { todo: true }, () => {
+        avoidV8Optimization = i;
+      });
+    }
+
+    return finished(reporter);
+  },
+  'todo-with-message': (loopAmount, avoidV8Optimization) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, { todo: 'todo reason' }, () => {
+        avoidV8Optimization = i;
+      });
+    }
+
+    return finished(reporter);
+  },
+  'todo-method': (loopAmount, avoidV8Optimization) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, (t) => {
+        avoidV8Optimization = i;
+        t.todo();
+      });
+    }
+
+    return finished(reporter);
+  },
+  'todo-method-with-message': (loopAmount, avoidV8Optimization) => {
+    for (let i = 0; i < loopAmount; i++) {
+      it(`${i}`, (t) => {
+        avoidV8Optimization = i;
+        t.todo('todo reason');
+      });
+    }
+
+    return finished(reporter);
+  },
+};
+
+function main({ n, option }) {
+  // eslint-disable-next-line prefer-const
+  let avoidV8Optimization = 0;
+  const runOption = allTests[option];
 
-function main(params) {
   bench.start();
 
-  run(params).then((ops) => {
-    bench.end(ops);
+  runOption(n, avoidV8Optimization).then(() => {
+    bench.end(n);
   });
 }