assert: align argument names

This makes sure the documented argument names and the ones thrown
in errors is aligned with the actual argument name.
PR-URL: #22760
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
Reviewed-By: Yuta Hiroto <hello@hiroppy.me>

Author: BridgeAR

lib/assert.js

@@ -557,12 +557,12 @@ function expectedException(actual, expected, msg) {
 returnexpected.call({},actual)===true;
 }
 
-functiongetActual(block){
-if(typeofblock!=='function'){
-thrownewERR_INVALID_ARG_TYPE('block','Function',block);
+functiongetActual(fn){
+if(typeoffn!=='function'){
+thrownewERR_INVALID_ARG_TYPE('fn','Function',fn);
 }
 try{
-block();
+fn();
 }catch(e){
 returne;
 }
@@ -579,20 +579,21 @@ function checkIsPromise(obj) {
 typeofobj.catch==='function';
 }
 
-asyncfunctionwaitForActual(block){
+asyncfunctionwaitForActual(promiseFn){
 letresultPromise;
-if(typeofblock==='function'){
-// Return a rejected promise if `block` throws synchronously.
-resultPromise=block();
+if(typeofpromiseFn==='function'){
+// Return a rejected promise if `promiseFn` throws synchronously.
+resultPromise=promiseFn();
 // Fail in case no promise is returned.
 if(!checkIsPromise(resultPromise)){
 thrownewERR_INVALID_RETURN_VALUE('instance of Promise',
-'block',resultPromise);
+'promiseFn',resultPromise);
 }
-}elseif(checkIsPromise(block)){
-resultPromise=block;
+}elseif(checkIsPromise(promiseFn)){
+resultPromise=promiseFn;
 }else{
-thrownewERR_INVALID_ARG_TYPE('block',['Function','Promise'],block);
+thrownewERR_INVALID_ARG_TYPE(
+'promiseFn',['Function','Promise'],promiseFn);
 }
 
 try{
@@ -672,20 +673,20 @@ function expectsNoError(stackStartFn, actual, error, message) {
 throwactual;
 }
 
-assert.throws=functionthrows(block, ...args){
-expectsError(throws,getActual(block), ...args);
+assert.throws=functionthrows(promiseFn, ...args){
+expectsError(throws,getActual(promiseFn), ...args);
 };
 
-assert.rejects=asyncfunctionrejects(block, ...args){
-expectsError(rejects,awaitwaitForActual(block), ...args);
+assert.rejects=asyncfunctionrejects(promiseFn, ...args){
+expectsError(rejects,awaitwaitForActual(promiseFn), ...args);
 };
 
-assert.doesNotThrow=functiondoesNotThrow(block, ...args){
-expectsNoError(doesNotThrow,getActual(block), ...args);
+assert.doesNotThrow=functiondoesNotThrow(fn, ...args){
+expectsNoError(doesNotThrow,getActual(fn), ...args);
 };
 
-assert.doesNotReject=asyncfunctiondoesNotReject(block, ...args){
-expectsNoError(doesNotReject,awaitwaitForActual(block), ...args);
+assert.doesNotReject=asyncfunctiondoesNotReject(fn, ...args){
+expectsNoError(doesNotReject,awaitwaitForActual(fn), ...args);
 };
 
 assert.ifError=functionifError(err){

test/parallel/test-assert-async.js

@@ -41,7 +41,7 @@ const promises = [];
 name: 'TypeError [ERR_INVALID_RETURN_VALUE]',
 code: 'ERR_INVALID_RETURN_VALUE',
 message: 'Expected instance of Promise to be returned '+
-'from the "block" function but got type undefined.'
+'from the "promiseFn" function but got type undefined.'
 }));
 
 promise=assert.rejects(Promise.resolve(),common.mustNotCall());
@@ -62,7 +62,7 @@ promises.push(assert.rejects(
 assert.rejects('fail',{}),
 {
 code: 'ERR_INVALID_ARG_TYPE',
-message: 'The "block" argument must be one of type '+
+message: 'The "promiseFn" argument must be one of type '+
 'Function or Promise. Received type string'
 }
 ));
@@ -73,7 +73,7 @@ promises.push(assert.rejects(
 constpromise=assert.doesNotReject(()=>newMap(),common.mustNotCall());
 promises.push(assert.rejects(promise,{
 message: 'Expected instance of Promise to be returned '+
-'from the "block" function but got instance of Map.',
+'from the "promiseFn" function but got instance of Map.',
 code: 'ERR_INVALID_RETURN_VALUE',
 name: 'TypeError [ERR_INVALID_RETURN_VALUE]'
 }));
@@ -116,7 +116,7 @@ promises.push(assert.rejects(
 assert.doesNotReject(123),
 {
 code: 'ERR_INVALID_ARG_TYPE',
-message: 'The "block" argument must be one of type '+
+message: 'The "promiseFn" argument must be one of type '+
 'Function or Promise. Received type number'
 }
 ));

test/parallel/test-assert.js

@@ -341,15 +341,15 @@ try {
 }
 
 {
-// Verify that throws() and doesNotThrow() throw on non-function block.
-consttestBlockTypeError=(method,block)=>{
+// Verify that throws() and doesNotThrow() throw on non-functions.
+consttestBlockTypeError=(method,fn)=>{
 common.expectsError(
-()=>method(block),
+()=>method(fn),
 {
 code: 'ERR_INVALID_ARG_TYPE',
 type: TypeError,
-message: 'The "block" argument must be of type Function. Received '+
-`type ${typeofblock}`
+message: 'The "fn" argument must be of type Function. Received '+
+`type ${typeoffn}`
 }
 );
 };

test/parallel/test-file-write-stream3.js

@@ -178,7 +178,7 @@ function run_test_3() {
 
 construn_test_4=common.mustCall(function(){
 // Error: start must be >= zero
-constblock=()=>{
+constfn=()=>{
 fs.createWriteStream(filepath,{start: -5,flags: 'r+'});
 };
 consterr={
@@ -187,7 +187,7 @@ const run_test_4 = common.mustCall(function() {
 'It must be >= 0. Received {start: -5}',
 type: RangeError
 };
-common.expectsError(block,err);
+common.expectsError(fn,err);
 });
 
 run_test_1();

test/parallel/test-net-connect-options-port.js

@@ -62,8 +62,8 @@ const net = require('net');
 consthints=(dns.ADDRCONFIG|dns.V4MAPPED)+42;
 consthintOptBlocks=doConnect([{ hints }],
 ()=>common.mustNotCall());
-for(constblockofhintOptBlocks){
-common.expectsError(block,{
+for(constfnofhintOptBlocks){
+common.expectsError(fn,{
 code: 'ERR_INVALID_OPT_VALUE',
 type: TypeError,
 message: /Thevalue"\d+"isinvalidforoption"hints"/
@@ -136,67 +136,59 @@ function doConnect(args, getCb) {
 functionsyncFailToConnect(port,assertErr,optOnly){
 if(!optOnly){
 // connect(port, cb) and connect(port)
-constportArgBlocks=doConnect([port],()=>common.mustNotCall());
-for(constblockofportArgBlocks){
-assert.throws(block,
-assertErr,
-`${block.name}(${port})`);
+constportArgFunctions=doConnect([port],()=>common.mustNotCall());
+for(constfnofportArgFunctions){
+assert.throws(fn,assertErr,`${fn.name}(${port})`);
 }
 
 // connect(port, host, cb) and connect(port, host)
-constportHostArgBlocks=doConnect([port,'localhost'],
-()=>common.mustNotCall());
-for(constblockofportHostArgBlocks){
-assert.throws(block,
-assertErr,
-`${block.name}(${port}, 'localhost')`);
+constportHostArgFunctions=doConnect([port,'localhost'],
+()=>common.mustNotCall());
+for(constfnofportHostArgFunctions){
+assert.throws(fn,assertErr,`${fn.name}(${port}, 'localhost')`);
 }
 }
 // connect({port}, cb) and connect({port})
-constportOptBlocks=doConnect([{ port }],
-()=>common.mustNotCall());
-for(constblockofportOptBlocks){
-assert.throws(block,
-assertErr,
-`${block.name}({port: ${port}})`);
+constportOptFunctions=doConnect([{ port }],()=>common.mustNotCall());
+for(constfnofportOptFunctions){
+assert.throws(fn,assertErr,`${fn.name}({port: ${port}})`);
 }
 
 // connect({port, host}, cb) and connect({port, host})
-constportHostOptBlocks=doConnect([{port: port,host: 'localhost'}],
-()=>common.mustNotCall());
-for(constblockofportHostOptBlocks){
-assert.throws(block,
+constportHostOptFunctions=doConnect([{port: port,host: 'localhost'}],
+()=>common.mustNotCall());
+for(constfnofportHostOptFunctions){
+assert.throws(fn,
 assertErr,
-`${block.name}({port: ${port}, host: 'localhost'})`);
+`${fn.name}({port: ${port}, host: 'localhost'})`);
 }
 }
 
 functioncanConnect(port){
 constnoop=()=>common.mustCall();
 
 // connect(port, cb) and connect(port)
-constportArgBlocks=doConnect([port],noop);
-for(constblockofportArgBlocks){
-block();
+constportArgFunctions=doConnect([port],noop);
+for(constfnofportArgFunctions){
+fn();
 }
 
 // connect(port, host, cb) and connect(port, host)
-constportHostArgBlocks=doConnect([port,'localhost'],noop);
-for(constblockofportHostArgBlocks){
-block();
+constportHostArgFunctions=doConnect([port,'localhost'],noop);
+for(constfnofportHostArgFunctions){
+fn();
 }
 
 // connect({port}, cb) and connect({port})
-constportOptBlocks=doConnect([{ port }],noop);
-for(constblockofportOptBlocks){
-block();
+constportOptFunctions=doConnect([{ port }],noop);
+for(constfnofportOptFunctions){
+fn();
 }
 
 // connect({port, host}, cb) and connect({port, host})
-constportHostOptBlocks=doConnect([{port: port,host: 'localhost'}],
-noop);
-for(constblockofportHostOptBlocks){
-block();
+constportHostOptFns=doConnect([{ port,host: 'localhost'}],noop);
+for(constfnofportHostOptFns){
+fn();
 }
 }
 
@@ -208,21 +200,20 @@ function asyncFailToConnect(port) {
 
 constdont=()=>common.mustNotCall();
 // connect(port, cb) and connect(port)
-constportArgBlocks=doConnect([port],dont);
-for(constblockofportArgBlocks){
-block().on('error',onError());
+constportArgFunctions=doConnect([port],dont);
+for(constfnofportArgFunctions){
+fn().on('error',onError());
 }
 
 // connect({port}, cb) and connect({port})
-constportOptBlocks=doConnect([{ port }],dont);
-for(constblockofportOptBlocks){
-block().on('error',onError());
+constportOptFunctions=doConnect([{ port }],dont);
+for(constfnofportOptFunctions){
+fn().on('error',onError());
 }
 
 // connect({port, host}, cb) and connect({port, host})
-constportHostOptBlocks=doConnect([{port: port,host: 'localhost'}],
-dont);
-for(constblockofportHostOptBlocks){
-block().on('error',onError());
+constportHostOptFns=doConnect([{ port,host: 'localhost'}],dont);
+for(constfnofportHostOptFns){
+fn().on('error',onError());
 }
 }

test/parallel/test-net-server-listen-options.js

@@ -54,10 +54,10 @@ const listenOnPort = [
 
 {
 functionshouldFailToListen(options){
-constblock=()=>{
+constfn=()=>{
 net.createServer().listen(options,common.mustNotCall());
 };
-common.expectsError(block,
+common.expectsError(fn,
 {
 code: 'ERR_INVALID_OPT_VALUE',
 type: TypeError,