test: merge ongc and gcutil into gc.js

PR-URL: #54355
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>

Author: tannal

test/addons/cppgc-object/test.js

@@ -3,7 +3,7 @@
 // Flags: --expose-gc
 
 constcommon=require('../../common');
-
+const{ gcUntil }=require('../../common/gc');
 // Verify that addons can create GarbageCollected objects and
 // have them traced properly.
 
@@ -35,7 +35,7 @@ setTimeout(async function() {
 for(leti=0;i<count;++i){
 array[i]=newCppGCed();
 }
-awaitcommon.gcUntil(
+awaitgcUntil(
 'All old CppGCed are destroyed',
 ()=>states[kDestructCount]===count,
 );
@@ -44,7 +44,7 @@ setTimeout(async function() {
 array=null;
 globalThis.gc();
 
-awaitcommon.gcUntil(
+awaitgcUntil(
 'All old CppGCed are destroyed',
 ()=>states[kDestructCount]===count*2,
 );

test/async-hooks/test-async-local-storage-gcable.js

@@ -6,7 +6,7 @@
 
 constcommon=require('../common');
 const{ AsyncLocalStorage }=require('async_hooks');
-constonGC=require('../common/ongc');
+const{onGC }=require('../common/gc');
 
 letasyncLocalStorage=newAsyncLocalStorage();
 

test/common/README.md

@@ -982,7 +982,7 @@ module exports a single `onGC()` function.
 
 ```js
 require('../common');
-constonGC=require('../common/ongc');
+const{ onGC} =require('../common/gc');
 
 onGC({}, { ongc() { console.log('collected'); } });
 ```

test/common/gc.js

@@ -1,9 +1,72 @@
 'use strict';
 
 constwait=require('timers/promises').setTimeout;
+constassert=require('assert');
+constcommon=require('../common');
+constgcTrackerMap=newWeakMap();
+constgcTrackerTag='NODE_TEST_COMMON_GC_TRACKER';
 
-// TODO(joyeecheung): merge ongc.js and gcUntil from common/index.js
-// into this.
+/**
+ * Installs a garbage collection listener for the specified object.
+ * Uses async_hooks for GC tracking, which may affect test functionality.
+ * A full setImmediate() invocation passes between a global.gc() call and the listener being invoked.
+ * @param {object} obj - The target object to track for garbage collection.
+ * @param {object} gcListener - The listener object containing the ongc callback.
+ * @param {Function} gcListener.ongc - The function to call when the target object is garbage collected.
+ */
+functiononGC(obj,gcListener){
+constasync_hooks=require('async_hooks');
+
+constonGcAsyncHook=async_hooks.createHook({
+init: common.mustCallAtLeast(function(id,type){
+if(this.trackedId===undefined){
+assert.strictEqual(type,gcTrackerTag);
+this.trackedId=id;
+}
+}),
+destroy(id){
+assert.notStrictEqual(this.trackedId,-1);
+if(id===this.trackedId){
+this.gcListener.ongc();
+onGcAsyncHook.disable();
+}
+},
+}).enable();
+onGcAsyncHook.gcListener=gcListener;
+
+gcTrackerMap.set(obj,newasync_hooks.AsyncResource(gcTrackerTag));
+obj=null;
+}
+
+/**
+ * Repeatedly triggers garbage collection until a specified condition is met or a maximum number of attempts is reached.
+ * @param {string|Function} [name] - Optional name, used in the rejection message if the condition is not met.
+ * @param {Function} condition - A function that returns true when the desired condition is met.
+ * @returns {Promise} A promise that resolves when the condition is met, or rejects after 10 failed attempts.
+ */
+functiongcUntil(name,condition){
+if(typeofname==='function'){
+condition=name;
+name=undefined;
+}
+returnnewPromise((resolve,reject)=>{
+letcount=0;
+functiongcAndCheck(){
+setImmediate(()=>{
+count++;
+global.gc();
+if(condition()){
+resolve();
+}elseif(count<10){
+gcAndCheck();
+}else{
+reject(name===undefined ? undefined : 'Test '+name+' failed');
+}
+});
+}
+gcAndCheck();
+});
+}
 
 // This function can be used to check if an object factor leaks or not,
 // but it needs to be used with care:
@@ -124,4 +187,6 @@ module.exports = {
  checkIfCollectable,
  runAndBreathe,
  checkIfCollectableByCounting,
+ onGC,
+ gcUntil,
 };

test/common/index.js

@@ -837,30 +837,6 @@ function skipIfDumbTerminal() {
 }
 }
 
-functiongcUntil(name,condition){
-if(typeofname==='function'){
-condition=name;
-name=undefined;
-}
-returnnewPromise((resolve,reject)=>{
-letcount=0;
-functiongcAndCheck(){
-setImmediate(()=>{
-count++;
-global.gc();
-if(condition()){
-resolve();
-}elseif(count<10){
-gcAndCheck();
-}else{
-reject(name===undefined ? undefined : 'Test '+name+' failed');
-}
-});
-}
-gcAndCheck();
-});
-}
-
 functionrequireNoPackageJSONAbove(dir=__dirname){
 letpossiblePackage=path.join(dir,'..','package.json');
 letlastPackage=null;
@@ -966,7 +942,6 @@ const common = {
  expectsError,
  expectRequiredModule,
  expectWarning,
- gcUntil,
  getArrayBufferViews,
  getBufferSources,
  getCallSite,

test/common/ongc.js

@@ -3,11 +3,12 @@
 'use strict';
 constcommon=require('../../common');
 constaddon=require(`./build/${common.buildType}/6_object_wrap`);
+const{ gcUntil }=require('../../common/gc');
 
 (functionscope(){
 addon.objectWrapDanglingReference({});
 })();
 
-common.gcUntil('object-wrap-ref',()=>{
+gcUntil('object-wrap-ref',()=>{
 returnaddon.objectWrapDanglingReferenceTest();
 });

test/js-native-api/6_object_wrap/test-object-wrap-ref.js

@@ -4,6 +4,7 @@
 constcommon=require('../../common');
 constassert=require('assert');
 consttest=require(`./build/${common.buildType}/7_factory_wrap`);
+const{ gcUntil }=require('../../common/gc');
 
 assert.strictEqual(test.finalizeCount,0);
 asyncfunctionrunGCTests(){
@@ -13,14 +14,14 @@ async function runGCTests() {
 assert.strictEqual(obj.plusOne(),12);
 assert.strictEqual(obj.plusOne(),13);
 })();
-awaitcommon.gcUntil('test 1',()=>(test.finalizeCount===1));
+awaitgcUntil('test 1',()=>(test.finalizeCount===1));
 
 (()=>{
 constobj2=test.createObject(20);
 assert.strictEqual(obj2.plusOne(),21);
 assert.strictEqual(obj2.plusOne(),22);
 assert.strictEqual(obj2.plusOne(),23);
 })();
-awaitcommon.gcUntil('test 2',()=>(test.finalizeCount===2));
+awaitgcUntil('test 2',()=>(test.finalizeCount===2));
 }
 runGCTests();

test/js-native-api/7_factory_wrap/test.js

@@ -4,6 +4,7 @@
 constcommon=require('../../common');
 constassert=require('assert');
 constaddon=require(`./build/${common.buildType}/8_passing_wrapped`);
+const{ gcUntil }=require('../../common/gc');
 
 asyncfunctionrunTest(){
 letobj1=addon.createObject(10);
@@ -14,7 +15,7 @@ async function runTest() {
 // Make sure the native destructor gets called.
 obj1=null;
 obj2=null;
-awaitcommon.gcUntil('8_passing_wrapped',
-()=>(addon.finalizeCount()===2));
+awaitgcUntil('8_passing_wrapped',
+()=>(addon.finalizeCount()===2));
 }
 runTest();

test/js-native-api/8_passing_wrapped/test.js

@@ -5,8 +5,10 @@ const common = require('../../common');
 consttest_finalizer=require(`./build/${common.buildType}/test_finalizer`);
 constassert=require('assert');
 
+const{ gcUntil }=require('../../common/gc');
+
 // The goal of this test is to show that we can run "pure" finalizers in the
-// current JS loop tick. Thus, we do not use common.gcUntil function works
+// current JS loop tick. Thus, we do not use gcUntil function works
 // asynchronously using micro tasks.
 // We use IIFE for the obj scope instead of {} to be compatible with
 // non-V8 JS engines that do not support scoped variables.
@@ -25,7 +27,7 @@ for (let i = 0; i < 10; ++i) {
 assert.strictEqual(test_finalizer.getFinalizerCallCount(),1);
 
 // The finalizer that access JS cannot run synchronously. They are run in the
-// next JS loop tick. Thus, we must use common.gcUntil.
+// next JS loop tick. Thus, we must use gcUntil.
 asyncfunctionrunAsyncTests(){
 // We do not use common.mustCall() because we want to see the finalizer
 // called in response to GC and not as a part of env destruction.
@@ -36,8 +38,8 @@ async function runAsyncTests() {
 constobj={};
 test_finalizer.addFinalizerWithJS(obj,()=>{js_is_called=true;});
 })();
-awaitcommon.gcUntil('ensure JS finalizer called',
-()=>(test_finalizer.getFinalizerCallCount()===2));
+awaitgcUntil('ensure JS finalizer called',
+()=>(test_finalizer.getFinalizerCallCount()===2));
 assert(js_is_called);
 }
 runAsyncTests();