benchmark: add test-only and mock timers cases

The only benchmark covers creating selected and non-selected
tests when running with --test-only.
The mock timers benchmark covers enabling timer mocks, setTimeout,
setInterval, setImmediate, scheduler.wait, AbortSignal.timeout,
mocked Date.now(), setTime(), and runAll().
Refs: #55723
Signed-off-by: Luan Muniz <luan@luanmuniz.com.br>
PR-URL: #64097
Reviewed-By: Aviv Keller <me@aviv.sh>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>

Author: luanmuniz

benchmark/test_runner/mock-timers.js

@@ -0,0 +1,262 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+constbench=common.createBenchmark(main,{
+n: [1000],
+mode: [
+'enable-empty-apis',
+'enable-setTimeout',
+'enable-setInterval',
+'enable-setImmediate',
+'enable-Date',
+'enable-scheduler.wait',
+'enable-AbortSignal.timeout',
+'enable-all',
+'enable-default',
+'setTimeout',
+'setInterval',
+'setImmediate',
+'scheduler.wait',
+'AbortSignal.timeout',
+'Date',
+'setTime',
+'runAll',
+],
+},{
+// We don't want to test the reporter here.
+flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
+});
+
+functionbenchmarkEnable(n,mode){
+constenableMode=mode.replace('enable-','');
+letenableOptions={apis: [enableMode]};
+
+if(enableMode==='all'){
+enableOptions.apis=['setTimeout','setInterval','setImmediate','Date','scheduler.wait','AbortSignal.timeout'];
+}
+
+if(enableMode==='empty-apis'){
+enableOptions.apis=[];
+}
+
+if(enableMode==='default'){
+enableOptions=undefined;
+}
+
+test((t)=>{
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.enable(enableOptions);
+t.mock.timers.reset();
+}
+
+bench.end(n);
+});
+}
+
+functionbenchmarkSetTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+bench.start();
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead=i;
+},i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSetInterval(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setInterval']});
+
+setInterval(()=>{
+noDead++;
+},1);
+
+bench.start();
+
+t.mock.timers.tick(n);
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionbenchmarkSetImmediate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setImmediate']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+setImmediate(()=>{
+noDead=i;
+});
+}
+
+t.mock.timers.tick(0);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSchedulerWait(n){
+test(async(t)=>{
+constpromises=[];
+letnoDead;
+
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+promises.push(nodeTimersPromises.scheduler.wait(i+1).then(()=>{
+noDead=i;
+}));
+}
+
+t.mock.timers.tick(n+1);
+awaitPromise.all(promises);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkAbortSignalTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['AbortSignal.timeout']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=AbortSignal.timeout(i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead.aborted,true);
+});
+}
+
+functionbenchmarkDate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,0);
+});
+}
+
+functionbenchmarkSetTime(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.setTime(i);
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkRunAll(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead++;
+},i+1);
+}
+
+bench.start();
+
+t.mock.timers.runAll();
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionmain({ n, mode }){
+switch(mode){
+case'enable-empty-apis':
+case'enable-setTimeout':
+case'enable-setInterval':
+case'enable-setImmediate':
+case'enable-Date':
+case'enable-scheduler.wait':
+case'enable-AbortSignal.timeout':
+case'enable-all':
+case'enable-default':
+benchmarkEnable(n,mode);
+break;
+case'setTimeout':
+benchmarkSetTimeout(n);
+break;
+case'setInterval':
+benchmarkSetInterval(n);
+break;
+case'setImmediate':
+benchmarkSetImmediate(n);
+break;
+case'scheduler.wait':
+benchmarkSchedulerWait(n);
+break;
+case'AbortSignal.timeout':
+benchmarkAbortSignalTimeout(n);
+break;
+case'Date':
+benchmarkDate(n);
+break;
+case'setTime':
+benchmarkSetTime(n);
+break;
+case'runAll':
+benchmarkRunAll(n);
+break;
+}
+}

benchmark/test_runner/test-only.js

@@ -0,0 +1,39 @@
+'use strict';
+
+constcommon=require('../common');
+const{ finished }=require('node:stream/promises');
+constreporter=require('../fixtures/empty-test-reporter');
+const{ test }=require('node:test');
+
+constbench=common.createBenchmark(main,{
+n: [10000],
+selected: [1],
+},{
+// We don't want to test the reporter here.
+flags: [
+'--test-reporter=./benchmark/fixtures/empty-test-reporter.js',
+'--test-only',
+],
+});
+
+asyncfunctionrun({ n, selected }){
+for(leti=0;i<selected;i++){
+test(`selected-${i}`,{only: true},()=>{});
+}
+
+for(leti=0;i<n;i++){
+test(`not-selected-${i}`,()=>{
+thrownewError(`This test ${i} should not run.`);
+});
+}
+
+returnfinished(reporter);
+}
+
+functionmain(params){
+bench.start();
+
+run(params).then(()=>{
+bench.end(params.n);
+});
+}

benchmark/test_runner/mock-timers.js

@@ -0,0 +1,262 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+constbench=common.createBenchmark(main,{
+n: [1000],
+mode: [
+'enable-empty-apis',
+'enable-setTimeout',
+'enable-setInterval',
+'enable-setImmediate',
+'enable-Date',
+'enable-scheduler.wait',
+'enable-AbortSignal.timeout',
+'enable-all',
+'enable-default',
+'setTimeout',
+'setInterval',
+'setImmediate',
+'scheduler.wait',
+'AbortSignal.timeout',
+'Date',
+'setTime',
+'runAll',
+],
+},{
+// We don't want to test the reporter here.
+flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
+});
+
+functionbenchmarkEnable(n,mode){
+constenableMode=mode.replace('enable-','');
+letenableOptions={apis: [enableMode]};
+
+if(enableMode==='all'){
+enableOptions.apis=['setTimeout','setInterval','setImmediate','Date','scheduler.wait','AbortSignal.timeout'];
+}
+
+if(enableMode==='empty-apis'){
+enableOptions.apis=[];
+}
+
+if(enableMode==='default'){
+enableOptions=undefined;
+}
+
+test((t)=>{
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.enable(enableOptions);
+t.mock.timers.reset();
+}
+
+bench.end(n);
+});
+}
+
+functionbenchmarkSetTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+bench.start();
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead=i;
+},i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSetInterval(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setInterval']});
+
+setInterval(()=>{
+noDead++;
+},1);
+
+bench.start();
+
+t.mock.timers.tick(n);
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionbenchmarkSetImmediate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setImmediate']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+setImmediate(()=>{
+noDead=i;
+});
+}
+
+t.mock.timers.tick(0);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSchedulerWait(n){
+test(async(t)=>{
+constpromises=[];
+letnoDead;
+
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+promises.push(nodeTimersPromises.scheduler.wait(i+1).then(()=>{
+noDead=i;
+}));
+}
+
+t.mock.timers.tick(n+1);
+awaitPromise.all(promises);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkAbortSignalTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['AbortSignal.timeout']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=AbortSignal.timeout(i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead.aborted,true);
+});
+}
+
+functionbenchmarkDate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,0);
+});
+}
+
+functionbenchmarkSetTime(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.setTime(i);
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkRunAll(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead++;
+},i+1);
+}
+
+bench.start();
+
+t.mock.timers.runAll();
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionmain({ n, mode }){
+switch(mode){
+case'enable-empty-apis':
+case'enable-setTimeout':
+case'enable-setInterval':
+case'enable-setImmediate':
+case'enable-Date':
+case'enable-scheduler.wait':
+case'enable-AbortSignal.timeout':
+case'enable-all':
+case'enable-default':
+benchmarkEnable(n,mode);
+break;
+case'setTimeout':
+benchmarkSetTimeout(n);
+break;
+case'setInterval':
+benchmarkSetInterval(n);
+break;
+case'setImmediate':
+benchmarkSetImmediate(n);
+break;
+case'scheduler.wait':
+benchmarkSchedulerWait(n);
+break;
+case'AbortSignal.timeout':
+benchmarkAbortSignalTimeout(n);
+break;
+case'Date':
+benchmarkDate(n);
+break;
+case'setTime':
+benchmarkSetTime(n);
+break;
+case'runAll':
+benchmarkRunAll(n);
+break;
+}
+}

benchmark/test_runner/test-only.js

@@ -0,0 +1,39 @@
+'use strict';
+
+constcommon=require('../common');
+const{ finished }=require('node:stream/promises');
+constreporter=require('../fixtures/empty-test-reporter');
+const{ test }=require('node:test');
+
+constbench=common.createBenchmark(main,{
+n: [10000],
+selected: [1],
+},{
+// We don't want to test the reporter here.
+flags: [
+'--test-reporter=./benchmark/fixtures/empty-test-reporter.js',
+'--test-only',
+],
+});
+
+asyncfunctionrun({ n, selected }){
+for(leti=0;i<selected;i++){
+test(`selected-${i}`,{only: true},()=>{});
+}
+
+for(leti=0;i<n;i++){
+test(`not-selected-${i}`,()=>{
+thrownewError(`This test ${i} should not run.`);
+});
+}
+
+returnfinished(reporter);
+}
+
+functionmain(params){
+bench.start();
+
+run(params).then(()=>{
+bench.end(params.n);
+});
+}

benchmark/test_runner/mock-timers.js

@@ -0,0 +1,262 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+constbench=common.createBenchmark(main,{
+n: [1000],
+mode: [
+'enable-empty-apis',
+'enable-setTimeout',
+'enable-setInterval',
+'enable-setImmediate',
+'enable-Date',
+'enable-scheduler.wait',
+'enable-AbortSignal.timeout',
+'enable-all',
+'enable-default',
+'setTimeout',
+'setInterval',
+'setImmediate',
+'scheduler.wait',
+'AbortSignal.timeout',
+'Date',
+'setTime',
+'runAll',
+],
+},{
+// We don't want to test the reporter here.
+flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
+});
+
+functionbenchmarkEnable(n,mode){
+constenableMode=mode.replace('enable-','');
+letenableOptions={apis: [enableMode]};
+
+if(enableMode==='all'){
+enableOptions.apis=['setTimeout','setInterval','setImmediate','Date','scheduler.wait','AbortSignal.timeout'];
+}
+
+if(enableMode==='empty-apis'){
+enableOptions.apis=[];
+}
+
+if(enableMode==='default'){
+enableOptions=undefined;
+}
+
+test((t)=>{
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.enable(enableOptions);
+t.mock.timers.reset();
+}
+
+bench.end(n);
+});
+}
+
+functionbenchmarkSetTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+bench.start();
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead=i;
+},i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSetInterval(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setInterval']});
+
+setInterval(()=>{
+noDead++;
+},1);
+
+bench.start();
+
+t.mock.timers.tick(n);
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionbenchmarkSetImmediate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setImmediate']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+setImmediate(()=>{
+noDead=i;
+});
+}
+
+t.mock.timers.tick(0);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSchedulerWait(n){
+test(async(t)=>{
+constpromises=[];
+letnoDead;
+
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+promises.push(nodeTimersPromises.scheduler.wait(i+1).then(()=>{
+noDead=i;
+}));
+}
+
+t.mock.timers.tick(n+1);
+awaitPromise.all(promises);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkAbortSignalTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['AbortSignal.timeout']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=AbortSignal.timeout(i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead.aborted,true);
+});
+}
+
+functionbenchmarkDate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,0);
+});
+}
+
+functionbenchmarkSetTime(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.setTime(i);
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkRunAll(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead++;
+},i+1);
+}
+
+bench.start();
+
+t.mock.timers.runAll();
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionmain({ n, mode }){
+switch(mode){
+case'enable-empty-apis':
+case'enable-setTimeout':
+case'enable-setInterval':
+case'enable-setImmediate':
+case'enable-Date':
+case'enable-scheduler.wait':
+case'enable-AbortSignal.timeout':
+case'enable-all':
+case'enable-default':
+benchmarkEnable(n,mode);
+break;
+case'setTimeout':
+benchmarkSetTimeout(n);
+break;
+case'setInterval':
+benchmarkSetInterval(n);
+break;
+case'setImmediate':
+benchmarkSetImmediate(n);
+break;
+case'scheduler.wait':
+benchmarkSchedulerWait(n);
+break;
+case'AbortSignal.timeout':
+benchmarkAbortSignalTimeout(n);
+break;
+case'Date':
+benchmarkDate(n);
+break;
+case'setTime':
+benchmarkSetTime(n);
+break;
+case'runAll':
+benchmarkRunAll(n);
+break;
+}
+}

benchmark/test_runner/test-only.js

@@ -0,0 +1,39 @@
+'use strict';
+
+constcommon=require('../common');
+const{ finished }=require('node:stream/promises');
+constreporter=require('../fixtures/empty-test-reporter');
+const{ test }=require('node:test');
+
+constbench=common.createBenchmark(main,{
+n: [10000],
+selected: [1],
+},{
+// We don't want to test the reporter here.
+flags: [
+'--test-reporter=./benchmark/fixtures/empty-test-reporter.js',
+'--test-only',
+],
+});
+
+asyncfunctionrun({ n, selected }){
+for(leti=0;i<selected;i++){
+test(`selected-${i}`,{only: true},()=>{});
+}
+
+for(leti=0;i<n;i++){
+test(`not-selected-${i}`,()=>{
+thrownewError(`This test ${i} should not run.`);
+});
+}
+
+returnfinished(reporter);
+}
+
+functionmain(params){
+bench.start();
+
+run(params).then(()=>{
+bench.end(params.n);
+});
+}

benchmark/test_runner/mock-timers.js

@@ -0,0 +1,262 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+constbench=common.createBenchmark(main,{
+n: [1000],
+mode: [
+'enable-empty-apis',
+'enable-setTimeout',
+'enable-setInterval',
+'enable-setImmediate',
+'enable-Date',
+'enable-scheduler.wait',
+'enable-AbortSignal.timeout',
+'enable-all',
+'enable-default',
+'setTimeout',
+'setInterval',
+'setImmediate',
+'scheduler.wait',
+'AbortSignal.timeout',
+'Date',
+'setTime',
+'runAll',
+],
+},{
+// We don't want to test the reporter here.
+flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
+});
+
+functionbenchmarkEnable(n,mode){
+constenableMode=mode.replace('enable-','');
+letenableOptions={apis: [enableMode]};
+
+if(enableMode==='all'){
+enableOptions.apis=['setTimeout','setInterval','setImmediate','Date','scheduler.wait','AbortSignal.timeout'];
+}
+
+if(enableMode==='empty-apis'){
+enableOptions.apis=[];
+}
+
+if(enableMode==='default'){
+enableOptions=undefined;
+}
+
+test((t)=>{
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.enable(enableOptions);
+t.mock.timers.reset();
+}
+
+bench.end(n);
+});
+}
+
+functionbenchmarkSetTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+bench.start();
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead=i;
+},i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSetInterval(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setInterval']});
+
+setInterval(()=>{
+noDead++;
+},1);
+
+bench.start();
+
+t.mock.timers.tick(n);
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionbenchmarkSetImmediate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setImmediate']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+setImmediate(()=>{
+noDead=i;
+});
+}
+
+t.mock.timers.tick(0);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSchedulerWait(n){
+test(async(t)=>{
+constpromises=[];
+letnoDead;
+
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+promises.push(nodeTimersPromises.scheduler.wait(i+1).then(()=>{
+noDead=i;
+}));
+}
+
+t.mock.timers.tick(n+1);
+awaitPromise.all(promises);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkAbortSignalTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['AbortSignal.timeout']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=AbortSignal.timeout(i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead.aborted,true);
+});
+}
+
+functionbenchmarkDate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,0);
+});
+}
+
+functionbenchmarkSetTime(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.setTime(i);
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkRunAll(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead++;
+},i+1);
+}
+
+bench.start();
+
+t.mock.timers.runAll();
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionmain({ n, mode }){
+switch(mode){
+case'enable-empty-apis':
+case'enable-setTimeout':
+case'enable-setInterval':
+case'enable-setImmediate':
+case'enable-Date':
+case'enable-scheduler.wait':
+case'enable-AbortSignal.timeout':
+case'enable-all':
+case'enable-default':
+benchmarkEnable(n,mode);
+break;
+case'setTimeout':
+benchmarkSetTimeout(n);
+break;
+case'setInterval':
+benchmarkSetInterval(n);
+break;
+case'setImmediate':
+benchmarkSetImmediate(n);
+break;
+case'scheduler.wait':
+benchmarkSchedulerWait(n);
+break;
+case'AbortSignal.timeout':
+benchmarkAbortSignalTimeout(n);
+break;
+case'Date':
+benchmarkDate(n);
+break;
+case'setTime':
+benchmarkSetTime(n);
+break;
+case'runAll':
+benchmarkRunAll(n);
+break;
+}
+}

benchmark/test_runner/test-only.js

@@ -0,0 +1,39 @@
+'use strict';
+
+constcommon=require('../common');
+const{ finished }=require('node:stream/promises');
+constreporter=require('../fixtures/empty-test-reporter');
+const{ test }=require('node:test');
+
+constbench=common.createBenchmark(main,{
+n: [10000],
+selected: [1],
+},{
+// We don't want to test the reporter here.
+flags: [
+'--test-reporter=./benchmark/fixtures/empty-test-reporter.js',
+'--test-only',
+],
+});
+
+asyncfunctionrun({ n, selected }){
+for(leti=0;i<selected;i++){
+test(`selected-${i}`,{only: true},()=>{});
+}
+
+for(leti=0;i<n;i++){
+test(`not-selected-${i}`,()=>{
+thrownewError(`This test ${i} should not run.`);
+});
+}
+
+returnfinished(reporter);
+}
+
+functionmain(params){
+bench.start();
+
+run(params).then(()=>{
+bench.end(params.n);
+});
+}

benchmark/test_runner/mock-timers.js

@@ -0,0 +1,262 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+constbench=common.createBenchmark(main,{
+n: [1000],
+mode: [
+'enable-empty-apis',
+'enable-setTimeout',
+'enable-setInterval',
+'enable-setImmediate',
+'enable-Date',
+'enable-scheduler.wait',
+'enable-AbortSignal.timeout',
+'enable-all',
+'enable-default',
+'setTimeout',
+'setInterval',
+'setImmediate',
+'scheduler.wait',
+'AbortSignal.timeout',
+'Date',
+'setTime',
+'runAll',
+],
+},{
+// We don't want to test the reporter here.
+flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
+});
+
+functionbenchmarkEnable(n,mode){
+constenableMode=mode.replace('enable-','');
+letenableOptions={apis: [enableMode]};
+
+if(enableMode==='all'){
+enableOptions.apis=['setTimeout','setInterval','setImmediate','Date','scheduler.wait','AbortSignal.timeout'];
+}
+
+if(enableMode==='empty-apis'){
+enableOptions.apis=[];
+}
+
+if(enableMode==='default'){
+enableOptions=undefined;
+}
+
+test((t)=>{
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.enable(enableOptions);
+t.mock.timers.reset();
+}
+
+bench.end(n);
+});
+}
+
+functionbenchmarkSetTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+bench.start();
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead=i;
+},i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSetInterval(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setInterval']});
+
+setInterval(()=>{
+noDead++;
+},1);
+
+bench.start();
+
+t.mock.timers.tick(n);
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionbenchmarkSetImmediate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setImmediate']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+setImmediate(()=>{
+noDead=i;
+});
+}
+
+t.mock.timers.tick(0);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSchedulerWait(n){
+test(async(t)=>{
+constpromises=[];
+letnoDead;
+
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+promises.push(nodeTimersPromises.scheduler.wait(i+1).then(()=>{
+noDead=i;
+}));
+}
+
+t.mock.timers.tick(n+1);
+awaitPromise.all(promises);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkAbortSignalTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['AbortSignal.timeout']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=AbortSignal.timeout(i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead.aborted,true);
+});
+}
+
+functionbenchmarkDate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,0);
+});
+}
+
+functionbenchmarkSetTime(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.setTime(i);
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkRunAll(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead++;
+},i+1);
+}
+
+bench.start();
+
+t.mock.timers.runAll();
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionmain({ n, mode }){
+switch(mode){
+case'enable-empty-apis':
+case'enable-setTimeout':
+case'enable-setInterval':
+case'enable-setImmediate':
+case'enable-Date':
+case'enable-scheduler.wait':
+case'enable-AbortSignal.timeout':
+case'enable-all':
+case'enable-default':
+benchmarkEnable(n,mode);
+break;
+case'setTimeout':
+benchmarkSetTimeout(n);
+break;
+case'setInterval':
+benchmarkSetInterval(n);
+break;
+case'setImmediate':
+benchmarkSetImmediate(n);
+break;
+case'scheduler.wait':
+benchmarkSchedulerWait(n);
+break;
+case'AbortSignal.timeout':
+benchmarkAbortSignalTimeout(n);
+break;
+case'Date':
+benchmarkDate(n);
+break;
+case'setTime':
+benchmarkSetTime(n);
+break;
+case'runAll':
+benchmarkRunAll(n);
+break;
+}
+}

benchmark/test_runner/test-only.js

@@ -0,0 +1,39 @@
+'use strict';
+
+constcommon=require('../common');
+const{ finished }=require('node:stream/promises');
+constreporter=require('../fixtures/empty-test-reporter');
+const{ test }=require('node:test');
+
+constbench=common.createBenchmark(main,{
+n: [10000],
+selected: [1],
+},{
+// We don't want to test the reporter here.
+flags: [
+'--test-reporter=./benchmark/fixtures/empty-test-reporter.js',
+'--test-only',
+],
+});
+
+asyncfunctionrun({ n, selected }){
+for(leti=0;i<selected;i++){
+test(`selected-${i}`,{only: true},()=>{});
+}
+
+for(leti=0;i<n;i++){
+test(`not-selected-${i}`,()=>{
+thrownewError(`This test ${i} should not run.`);
+});
+}
+
+returnfinished(reporter);
+}
+
+functionmain(params){
+bench.start();
+
+run(params).then(()=>{
+bench.end(params.n);
+});
+}

benchmark/test_runner/mock-timers.js

@@ -0,0 +1,262 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+constbench=common.createBenchmark(main,{
+n: [1000],
+mode: [
+'enable-empty-apis',
+'enable-setTimeout',
+'enable-setInterval',
+'enable-setImmediate',
+'enable-Date',
+'enable-scheduler.wait',
+'enable-AbortSignal.timeout',
+'enable-all',
+'enable-default',
+'setTimeout',
+'setInterval',
+'setImmediate',
+'scheduler.wait',
+'AbortSignal.timeout',
+'Date',
+'setTime',
+'runAll',
+],
+},{
+// We don't want to test the reporter here.
+flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
+});
+
+functionbenchmarkEnable(n,mode){
+constenableMode=mode.replace('enable-','');
+letenableOptions={apis: [enableMode]};
+
+if(enableMode==='all'){
+enableOptions.apis=['setTimeout','setInterval','setImmediate','Date','scheduler.wait','AbortSignal.timeout'];
+}
+
+if(enableMode==='empty-apis'){
+enableOptions.apis=[];
+}
+
+if(enableMode==='default'){
+enableOptions=undefined;
+}
+
+test((t)=>{
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.enable(enableOptions);
+t.mock.timers.reset();
+}
+
+bench.end(n);
+});
+}
+
+functionbenchmarkSetTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+bench.start();
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead=i;
+},i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSetInterval(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setInterval']});
+
+setInterval(()=>{
+noDead++;
+},1);
+
+bench.start();
+
+t.mock.timers.tick(n);
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionbenchmarkSetImmediate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setImmediate']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+setImmediate(()=>{
+noDead=i;
+});
+}
+
+t.mock.timers.tick(0);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSchedulerWait(n){
+test(async(t)=>{
+constpromises=[];
+letnoDead;
+
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+promises.push(nodeTimersPromises.scheduler.wait(i+1).then(()=>{
+noDead=i;
+}));
+}
+
+t.mock.timers.tick(n+1);
+awaitPromise.all(promises);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkAbortSignalTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['AbortSignal.timeout']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=AbortSignal.timeout(i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead.aborted,true);
+});
+}
+
+functionbenchmarkDate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,0);
+});
+}
+
+functionbenchmarkSetTime(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.setTime(i);
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkRunAll(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead++;
+},i+1);
+}
+
+bench.start();
+
+t.mock.timers.runAll();
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionmain({ n, mode }){
+switch(mode){
+case'enable-empty-apis':
+case'enable-setTimeout':
+case'enable-setInterval':
+case'enable-setImmediate':
+case'enable-Date':
+case'enable-scheduler.wait':
+case'enable-AbortSignal.timeout':
+case'enable-all':
+case'enable-default':
+benchmarkEnable(n,mode);
+break;
+case'setTimeout':
+benchmarkSetTimeout(n);
+break;
+case'setInterval':
+benchmarkSetInterval(n);
+break;
+case'setImmediate':
+benchmarkSetImmediate(n);
+break;
+case'scheduler.wait':
+benchmarkSchedulerWait(n);
+break;
+case'AbortSignal.timeout':
+benchmarkAbortSignalTimeout(n);
+break;
+case'Date':
+benchmarkDate(n);
+break;
+case'setTime':
+benchmarkSetTime(n);
+break;
+case'runAll':
+benchmarkRunAll(n);
+break;
+}
+}

benchmark/test_runner/test-only.js

@@ -0,0 +1,39 @@
+'use strict';
+
+constcommon=require('../common');
+const{ finished }=require('node:stream/promises');
+constreporter=require('../fixtures/empty-test-reporter');
+const{ test }=require('node:test');
+
+constbench=common.createBenchmark(main,{
+n: [10000],
+selected: [1],
+},{
+// We don't want to test the reporter here.
+flags: [
+'--test-reporter=./benchmark/fixtures/empty-test-reporter.js',
+'--test-only',
+],
+});
+
+asyncfunctionrun({ n, selected }){
+for(leti=0;i<selected;i++){
+test(`selected-${i}`,{only: true},()=>{});
+}
+
+for(leti=0;i<n;i++){
+test(`not-selected-${i}`,()=>{
+thrownewError(`This test ${i} should not run.`);
+});
+}
+
+returnfinished(reporter);
+}
+
+functionmain(params){
+bench.start();
+
+run(params).then(()=>{
+bench.end(params.n);
+});
+}

benchmark/test_runner/mock-timers.js

@@ -0,0 +1,262 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+constbench=common.createBenchmark(main,{
+n: [1000],
+mode: [
+'enable-empty-apis',
+'enable-setTimeout',
+'enable-setInterval',
+'enable-setImmediate',
+'enable-Date',
+'enable-scheduler.wait',
+'enable-AbortSignal.timeout',
+'enable-all',
+'enable-default',
+'setTimeout',
+'setInterval',
+'setImmediate',
+'scheduler.wait',
+'AbortSignal.timeout',
+'Date',
+'setTime',
+'runAll',
+],
+},{
+// We don't want to test the reporter here.
+flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
+});
+
+functionbenchmarkEnable(n,mode){
+constenableMode=mode.replace('enable-','');
+letenableOptions={apis: [enableMode]};
+
+if(enableMode==='all'){
+enableOptions.apis=['setTimeout','setInterval','setImmediate','Date','scheduler.wait','AbortSignal.timeout'];
+}
+
+if(enableMode==='empty-apis'){
+enableOptions.apis=[];
+}
+
+if(enableMode==='default'){
+enableOptions=undefined;
+}
+
+test((t)=>{
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.enable(enableOptions);
+t.mock.timers.reset();
+}
+
+bench.end(n);
+});
+}
+
+functionbenchmarkSetTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+bench.start();
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead=i;
+},i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSetInterval(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setInterval']});
+
+setInterval(()=>{
+noDead++;
+},1);
+
+bench.start();
+
+t.mock.timers.tick(n);
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionbenchmarkSetImmediate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setImmediate']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+setImmediate(()=>{
+noDead=i;
+});
+}
+
+t.mock.timers.tick(0);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSchedulerWait(n){
+test(async(t)=>{
+constpromises=[];
+letnoDead;
+
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+promises.push(nodeTimersPromises.scheduler.wait(i+1).then(()=>{
+noDead=i;
+}));
+}
+
+t.mock.timers.tick(n+1);
+awaitPromise.all(promises);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkAbortSignalTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['AbortSignal.timeout']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=AbortSignal.timeout(i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead.aborted,true);
+});
+}
+
+functionbenchmarkDate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,0);
+});
+}
+
+functionbenchmarkSetTime(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.setTime(i);
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkRunAll(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead++;
+},i+1);
+}
+
+bench.start();
+
+t.mock.timers.runAll();
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionmain({ n, mode }){
+switch(mode){
+case'enable-empty-apis':
+case'enable-setTimeout':
+case'enable-setInterval':
+case'enable-setImmediate':
+case'enable-Date':
+case'enable-scheduler.wait':
+case'enable-AbortSignal.timeout':
+case'enable-all':
+case'enable-default':
+benchmarkEnable(n,mode);
+break;
+case'setTimeout':
+benchmarkSetTimeout(n);
+break;
+case'setInterval':
+benchmarkSetInterval(n);
+break;
+case'setImmediate':
+benchmarkSetImmediate(n);
+break;
+case'scheduler.wait':
+benchmarkSchedulerWait(n);
+break;
+case'AbortSignal.timeout':
+benchmarkAbortSignalTimeout(n);
+break;
+case'Date':
+benchmarkDate(n);
+break;
+case'setTime':
+benchmarkSetTime(n);
+break;
+case'runAll':
+benchmarkRunAll(n);
+break;
+}
+}

benchmark/test_runner/test-only.js

@@ -0,0 +1,39 @@
+'use strict';
+
+constcommon=require('../common');
+const{ finished }=require('node:stream/promises');
+constreporter=require('../fixtures/empty-test-reporter');
+const{ test }=require('node:test');
+
+constbench=common.createBenchmark(main,{
+n: [10000],
+selected: [1],
+},{
+// We don't want to test the reporter here.
+flags: [
+'--test-reporter=./benchmark/fixtures/empty-test-reporter.js',
+'--test-only',
+],
+});
+
+asyncfunctionrun({ n, selected }){
+for(leti=0;i<selected;i++){
+test(`selected-${i}`,{only: true},()=>{});
+}
+
+for(leti=0;i<n;i++){
+test(`not-selected-${i}`,()=>{
+thrownewError(`This test ${i} should not run.`);
+});
+}
+
+returnfinished(reporter);
+}
+
+functionmain(params){
+bench.start();
+
+run(params).then(()=>{
+bench.end(params.n);
+});
+}

benchmark/test_runner/mock-timers.js

@@ -0,0 +1,262 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+constbench=common.createBenchmark(main,{
+n: [1000],
+mode: [
+'enable-empty-apis',
+'enable-setTimeout',
+'enable-setInterval',
+'enable-setImmediate',
+'enable-Date',
+'enable-scheduler.wait',
+'enable-AbortSignal.timeout',
+'enable-all',
+'enable-default',
+'setTimeout',
+'setInterval',
+'setImmediate',
+'scheduler.wait',
+'AbortSignal.timeout',
+'Date',
+'setTime',
+'runAll',
+],
+},{
+// We don't want to test the reporter here.
+flags: ['--test-reporter=./benchmark/fixtures/empty-test-reporter.js'],
+});
+
+functionbenchmarkEnable(n,mode){
+constenableMode=mode.replace('enable-','');
+letenableOptions={apis: [enableMode]};
+
+if(enableMode==='all'){
+enableOptions.apis=['setTimeout','setInterval','setImmediate','Date','scheduler.wait','AbortSignal.timeout'];
+}
+
+if(enableMode==='empty-apis'){
+enableOptions.apis=[];
+}
+
+if(enableMode==='default'){
+enableOptions=undefined;
+}
+
+test((t)=>{
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.enable(enableOptions);
+t.mock.timers.reset();
+}
+
+bench.end(n);
+});
+}
+
+functionbenchmarkSetTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+bench.start();
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead=i;
+},i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSetInterval(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setInterval']});
+
+setInterval(()=>{
+noDead++;
+},1);
+
+bench.start();
+
+t.mock.timers.tick(n);
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionbenchmarkSetImmediate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['setImmediate']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+setImmediate(()=>{
+noDead=i;
+});
+}
+
+t.mock.timers.tick(0);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkSchedulerWait(n){
+test(async(t)=>{
+constpromises=[];
+letnoDead;
+
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+promises.push(nodeTimersPromises.scheduler.wait(i+1).then(()=>{
+noDead=i;
+}));
+}
+
+t.mock.timers.tick(n+1);
+awaitPromise.all(promises);
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkAbortSignalTimeout(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['AbortSignal.timeout']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=AbortSignal.timeout(i+1);
+}
+
+t.mock.timers.tick(n+1);
+bench.end(n);
+
+assert.strictEqual(noDead.aborted,true);
+});
+}
+
+functionbenchmarkDate(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,0);
+});
+}
+
+functionbenchmarkSetTime(n){
+test((t)=>{
+letnoDead;
+
+t.mock.timers.enable({apis: ['Date']});
+
+bench.start();
+
+for(leti=0;i<n;i++){
+t.mock.timers.setTime(i);
+noDead=Date.now();
+}
+
+bench.end(n);
+
+assert.strictEqual(noDead,n-1);
+});
+}
+
+functionbenchmarkRunAll(n){
+test((t)=>{
+letnoDead=0;
+
+t.mock.timers.enable({apis: ['setTimeout']});
+
+for(leti=0;i<n;i++){
+setTimeout(()=>{
+noDead++;
+},i+1);
+}
+
+bench.start();
+
+t.mock.timers.runAll();
+
+bench.end(n);
+
+assert.strictEqual(noDead,n);
+});
+}
+
+functionmain({ n, mode }){
+switch(mode){
+case'enable-empty-apis':
+case'enable-setTimeout':
+case'enable-setInterval':
+case'enable-setImmediate':
+case'enable-Date':
+case'enable-scheduler.wait':
+case'enable-AbortSignal.timeout':
+case'enable-all':
+case'enable-default':
+benchmarkEnable(n,mode);
+break;
+case'setTimeout':
+benchmarkSetTimeout(n);
+break;
+case'setInterval':
+benchmarkSetInterval(n);
+break;
+case'setImmediate':
+benchmarkSetImmediate(n);
+break;
+case'scheduler.wait':
+benchmarkSchedulerWait(n);
+break;
+case'AbortSignal.timeout':
+benchmarkAbortSignalTimeout(n);
+break;
+case'Date':
+benchmarkDate(n);
+break;
+case'setTime':
+benchmarkSetTime(n);
+break;
+case'runAll':
+benchmarkRunAll(n);
+break;
+}
+}

benchmark/test_runner/test-only.js

@@ -0,0 +1,39 @@
+'use strict';
+
+constcommon=require('../common');
+const{ finished }=require('node:stream/promises');
+constreporter=require('../fixtures/empty-test-reporter');
+const{ test }=require('node:test');
+
+constbench=common.createBenchmark(main,{
+n: [10000],
+selected: [1],
+},{
+// We don't want to test the reporter here.
+flags: [
+'--test-reporter=./benchmark/fixtures/empty-test-reporter.js',
+'--test-only',
+],
+});
+
+asyncfunctionrun({ n, selected }){
+for(leti=0;i<selected;i++){
+test(`selected-${i}`,{only: true},()=>{});
+}
+
+for(leti=0;i<n;i++){
+test(`not-selected-${i}`,()=>{
+thrownewError(`This test ${i} should not run.`);
+});
+}
+
+returnfinished(reporter);
+}
+
+functionmain(params){
+bench.start();
+
+run(params).then(()=>{
+bench.end(params.n);
+});
+}