test: make WeakReference tests robust

Previously we assume that the objects are GC'ed after one
global.gc() returns, which is not necessarily always the case. Use
gcUntil() to run GC multiple times if they are not GC'ed in the
first time around.
PR-URL: #49053
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

Author: joyeecheung

test/fixtures/snapshot/weak-reference-gc.js

@@ -5,16 +5,27 @@ const { WeakReference } = internalBinding('util');
 const{
  setDeserializeMainFunction
 }=require('v8').startupSnapshot
-constassert=require('assert');
 
 letobj={hello: 'world'};
 constref=newWeakReference(obj);
+letgcCount=0;
+letmaxGC=10;
 
-setDeserializeMainFunction(()=>{
-obj=null;
+functionrun(){
 globalThis.gc();
-
 setImmediate(()=>{
-assert.strictEqual(ref.get(),undefined);
+gcCount++;
+if(ref.get()===undefined){
+return;
+}elseif(gcCount<maxGC){
+run();
+}else{
+thrownewError(`Reference is still around after ${maxGC} GC`);
+}
 });
+}
+
+setDeserializeMainFunction(()=>{
+obj=null;
+run();
 });

test/parallel/test-domain-async-id-map-leak.js

@@ -13,6 +13,8 @@ const isEnumerable = Function.call.bind(Object.prototype.propertyIsEnumerable);
 // See: https://github.com/nodejs/node/issues/23862
 
 letd=domain.create();
+letresourceGCed=false;letdomainGCed=false;let
+emitterGCed=false;
 d.run(()=>{
 constresource=newasync_hooks.AsyncResource('TestResource');
 constemitter=newEventEmitter();
@@ -30,10 +32,17 @@ d.run(() => {
 // emitter → resource → async id ⇒ domain → emitter.
 // Make sure that all of these objects are released:
 
-onGC(resource,{ongc: common.mustCall()});
-onGC(d,{ongc: common.mustCall()});
-onGC(emitter,{ongc: common.mustCall()});
+onGC(resource,{ongc: common.mustCall(()=>{resourceGCed=true;})});
+onGC(d,{ongc: common.mustCall(()=>{domainGCed=true;})});
+onGC(emitter,{ongc: common.mustCall(()=>{emitterGCed=true;})});
 });
 
 d=null;
-global.gc();
+
+asyncfunctionmain(){
+awaitcommon.gcUntil(
+'All objects garbage collected',
+()=>resourceGCed&&domainGCed&&emitterGCed);
+}
+
+main();

test/parallel/test-internal-util-weakreference.js

@@ -1,6 +1,6 @@
 // Flags: --expose-internals --expose-gc
 'use strict';
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 const{ internalBinding }=require('internal/test/binding');
 const{ WeakReference }=internalBinding('util');
@@ -9,9 +9,11 @@ let obj = { hello: 'world' };
 constref=newWeakReference(obj);
 assert.strictEqual(ref.get(),obj);
 
-setImmediate(()=>{
+asyncfunctionmain(){
 obj=null;
-global.gc();
+awaitcommon.gcUntil(
+'Reference is garbage collected',
+()=>ref.get()===undefined);
+}
 
-assert.strictEqual(ref.get(),undefined);
-});
+main();