test: split test-perf-hooks-timerify

This test has been flaky in the CI. It squeezes too many independent
test cases into one file, so split it up so that we can mark the
persistent flaky test case and leave the unproblematic ones alone.
PR-URL: #60568
Refs: #54803
Refs: https://github.com/nodejs/reliability/blob/main/reports/2025-11-03.md
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: joyeecheung

test/parallel/test-perf-hooks-timerify-basic.js

@@ -0,0 +1,25 @@
+// Test basic functionality of timerify and PerformanceObserver.
+'use strict';
+
+constcommon=require('../common');
+constassert=require('assert');
+const{ timerify, PerformanceObserver }=require('perf_hooks');
+
+// Verifies that `performance.timerify` is an alias of `perf_hooks.timerify`.
+assert.strictEqual(performance.timerify,timerify);
+
+// Intentional non-op. Do not wrap in common.mustCall();
+constn=timerify(functionnoop(){});
+
+constobs=newPerformanceObserver(common.mustCall((list)=>{
+constentries=list.getEntries();
+constentry=entries[0];
+assert(entry);
+assert.strictEqual(entry.name,'noop');
+assert.strictEqual(entry.entryType,'function');
+assert.strictEqual(typeofentry.duration,'number');
+assert.strictEqual(typeofentry.startTime,'number');
+obs.disconnect();
+}));
+obs.observe({entryTypes: ['function']});
+n();

test/parallel/test-perf-hooks-timerify-constructor.js

@@ -0,0 +1,27 @@
+// Test that timerify works with class constructors and creates performance
+// entries with the correct name.
+
+'use strict';
+
+constcommon=require('../common');
+constassert=require('assert');
+const{ timerify, PerformanceObserver }=require('perf_hooks');
+
+classN{}
+constn=timerify(N);
+
+constobs=newPerformanceObserver(common.mustCall((list)=>{
+constentries=list.getEntries();
+constentry=entries[0];
+assert.strictEqual(entry[0],1);
+assert.strictEqual(entry[1],'abc');
+assert(entry);
+assert.strictEqual(entry.name,'N');
+assert.strictEqual(entry.entryType,'function');
+assert.strictEqual(typeofentry.duration,'number');
+assert.strictEqual(typeofentry.startTime,'number');
+obs.disconnect();
+}));
+obs.observe({entryTypes: ['function']});
+
+newn(1,'abc');

test/parallel/test-perf-hooks-timerify-error.js

@@ -0,0 +1,16 @@
+// Test that errors thrown in timerified functions bubble up without creating
+// performance timeline entries.
+
+'use strict';
+
+constcommon=require('../common');
+constassert=require('assert');
+const{ timerify, PerformanceObserver }=require('perf_hooks');
+
+constobs=newPerformanceObserver(common.mustNotCall());
+obs.observe({entryTypes: ['function']});
+constn=timerify(()=>{
+thrownewError('test');
+});
+assert.throws(()=>n(),/^Error:test$/);
+obs.disconnect();

test/parallel/test-perf-hooks-timerify-histogram-async.mjs

@@ -0,0 +1,17 @@
+// Test that timerify works with histogram option for asynchronous functions.
+
+import'../common/index.mjs';
+importassertfrom'assert';
+import{createHistogram,timerify}from'perf_hooks';
+import{setTimeoutassleep}from'timers/promises';
+
+consthistogram=createHistogram();
+constm=async(a,b=1)=>{
+awaitsleep(10);
+};
+constn=timerify(m,{ histogram });
+assert.strictEqual(histogram.max,0);
+for(leti=0;i<10;i++){
+awaitn();
+}
+assert.notStrictEqual(histogram.max,0);

test/parallel/test-perf-hooks-timerify-histogram-sync.mjs

@@ -0,0 +1,22 @@
+// Test that timerify works with histogram option for synchronous functions.
+
+import'../common/index.mjs';
+importassertfrom'assert';
+import{createHistogram,timerify}from'perf_hooks';
+import{setTimeoutassleep}from'timers/promises';
+
+let_deadCode;
+
+consthistogram=createHistogram();
+constm=(a,b=1)=>{
+for(leti=0;i<1e3;i++)
+_deadCode=i;
+};
+constn=timerify(m,{ histogram });
+assert.strictEqual(histogram.max,0);
+for(leti=0;i<10;i++){
+n();
+awaitsleep(10);
+}
+assert(_deadCode>=0);
+assert.notStrictEqual(histogram.max,0);

test/parallel/test-perf-hooks-timerify-invalid-args.js

@@ -0,0 +1,28 @@
+// Test that timerify throws appropriate errors for invalid argument types.
+
+'use strict';
+
+require('../common');
+constassert=require('assert');
+const{ timerify }=require('perf_hooks');
+
+[1,{},[],null,undefined,Infinity].forEach((input)=>{
+assert.throws(()=>timerify(input),
+{
+code: 'ERR_INVALID_ARG_TYPE',
+name: 'TypeError',
+message: /The"fn"argumentmustbeoftypefunction/
+});
+});
+
+constasyncFunc=async(a,b=1)=>{};
+constsyncFunc=(a,b=1)=>{};
+
+[1,'',{},[],false].forEach((histogram)=>{
+assert.throws(()=>timerify(asyncFunc,{ histogram }),{
+code: 'ERR_INVALID_ARG_TYPE'
+});
+assert.throws(()=>timerify(syncFunc,{ histogram }),{
+code: 'ERR_INVALID_ARG_TYPE'
+});
+});

test/parallel/test-perf-hooks-timerify-multiple-wrapping.js

@@ -0,0 +1,19 @@
+// Test that functions can be wrapped multiple times and verify length and name
+// properties are preserved correctly.
+
+'use strict';
+
+require('../common');
+constassert=require('assert');
+const{ timerify }=require('perf_hooks');
+
+constm=(a,b=1)=>{};
+constn=timerify(m);
+consto=timerify(m);
+constp=timerify(n);
+assert.notStrictEqual(n,o);
+assert.notStrictEqual(n,p);
+assert.notStrictEqual(o,p);
+assert.strictEqual(n.length,m.length);
+assert.strictEqual(n.name,'timerified m');
+assert.strictEqual(p.name,'timerified timerified m');

test/parallel/test-perf-hooks-timerify-return-value.js

@@ -0,0 +1,24 @@
+// Regression tests for https://github.com/nodejs/node/issues/40623
+// Test that timerify preserves return values and class constructor behavior.
+
+'use strict';
+
+require('../common');
+constassert=require('assert');
+const{ timerify }=require('perf_hooks');
+
+assert.strictEqual(timerify(functionfunc(){
+return1;
+})(),1);
+assert.strictEqual(timerify(function(){
+return1;
+})(),1);
+assert.strictEqual(timerify(()=>{
+return1;
+})(),1);
+classC{}
+constwrap=timerify(C);
+assert.ok(newwrap()instanceofC);
+assert.throws(()=>wrap(),{
+name: 'TypeError',
+});