test: fix RegExp nits

* Remove needless RegExp flag
In fixed case, `/g` flag is needless in the boolean context.
* Remove needless RegExp capturing
Use non-capturing grouping or remove capturing completely when:
* capturing is useless per se, e.g. in test() check;
* captured groups are not used afterward at all;
* some of the later captured groups are not used afterward.
* Use test, not match/exec in boolean context
match() and exec() return a complicated object,
unneeded in a boolean context.
* Do not needlessly repeat RegExp creation
This commit takes RegExp creation out of cycles and other repetitions.
As long as the RegExp does not use /g flag and match indices,
we are safe here.
In tests, this fix hardly gives a significant performance gain,
but it increases clarity and maintainability,
reassuring some RegExps to be identical.
RegExp in functions are not taken out of their functions:
while these functions are called many times
and their RegExps are recreated with each call,
the performance gain in test cases
does not seem to be worth decreasing function self-dependency.
Backport-PR-URL: #14370
PR-URL: #13770
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

Author: vsemozhetbyt

test/common/index.js

@@ -196,8 +196,9 @@ if (exports.isWindows) {
 }
 
 constifaces=os.networkInterfaces();
+constre=/lo/;
 exports.hasIPv6=Object.keys(ifaces).some(function(name){
-return/lo/.test(name)&&ifaces[name].some(function(info){
+returnre.test(name)&&ifaces[name].some(function(info){
 returninfo.family==='IPv6';
 });
 });

test/debugger/helper-debugger-repl.js

@@ -30,12 +30,12 @@ function startDebugger(scriptToDebug) {
 child.stderr.pipe(process.stderr);
 
 child.on('line',function(line){
-line=line.replace(/^(debug>*)+/,'');
+line=line.replace(/^(?:debug>*)+/,'');
 console.log(line);
 assert.ok(expected.length>0,`Got unexpected line: ${line}`);
 
 constexpectedLine=expected[0].lines.shift();
-assert.ok(line.match(expectedLine)!==null,`${line} != ${expectedLine}`);
+assert.ok(expectedLine.test(line),`${line} != ${expectedLine}`);
 
 if(expected[0].lines.length===0){
 constcallback=expected[0].callback;

test/doctool/test-doctool-html.js

@@ -80,9 +80,11 @@ const testData = [
 },
 ];
 
+constspaces=/\s/g;
+
 testData.forEach((item)=>{
 // Normalize expected data by stripping whitespace
-constexpected=item.html.replace(/\s/g,'');
+constexpected=item.html.replace(spaces,'');
 constincludeAnalytics=typeofitem.analyticsId!=='undefined';
 
 fs.readFile(item.file,'utf8',common.mustCall((err,input)=>{
@@ -101,7 +103,7 @@ testData.forEach((item) => {
 common.mustCall((err,output)=>{
 assert.ifError(err);
 
-constactual=output.replace(/\s/g,'');
+constactual=output.replace(spaces,'');
 // Assert that the input stripped of all whitespace contains the
 // expected list
 assert.notStrictEqual(actual.indexOf(expected),-1);

test/inspector/test-inspector.js

@@ -10,8 +10,8 @@ function checkListResponse(err, response) {
 assert.strictEqual(1,response.length);
 assert.ok(response[0]['devtoolsFrontendUrl']);
 assert.ok(
-response[0]['webSocketDebuggerUrl']
-.match(/ws:\/\/127.0.0.1:\d+\/[0-9A-Fa-f]{8}-/));
+/ws:\/\/127.0.0.1:\d+\/[0-9A-Fa-f]{8}-/
+.test(response[0]['webSocketDebuggerUrl']));
 }
 
 functioncheckVersion(err,response){

test/parallel/test-buffer-prototype-inspect.js

@@ -19,5 +19,5 @@ const util = require('util');
 
 {
 constbuf=Buffer.from('x'.repeat(51));
-assert.ok(/^<Buffer(78){50}\.\.\.>$/.test(util.inspect(buf)));
+assert.ok(/^<Buffer(?:78){50}\.\.\.>$/.test(util.inspect(buf)));
 }

test/parallel/test-cli-syntax.js

@@ -13,6 +13,9 @@ const syntaxArgs = [
 ['--check']
 ];
 
+constsyntaxErrorRE=/^SyntaxError:Unexpectedidentifier$/m;
+constnotFoundRE=/^Error:Cannotfindmodule/m;
+
 // test good syntax with and without shebang
 [
 'syntax/good_syntax.js',
@@ -53,8 +56,7 @@ const syntaxArgs = [
 assert.strictEqual(c.stdout,'','stdout produced');
 
 // stderr should have a syntax error message
-constmatch=c.stderr.match(/^SyntaxError:Unexpectedidentifier$/m);
-assert(match,'stderr incorrect');
+assert(syntaxErrorRE.test(c.stderr),'stderr incorrect');
 
 assert.strictEqual(c.status,1,`code == ${c.status}`);
 });
@@ -76,8 +78,7 @@ const syntaxArgs = [
 assert.strictEqual(c.stdout,'','stdout produced');
 
 // stderr should have a module not found error message
-constmatch=c.stderr.match(/^Error:Cannotfindmodule/m);
-assert(match,'stderr incorrect');
+assert(notFoundRE.test(c.stderr),'stderr incorrect');
 
 assert.strictEqual(c.status,1,`code == ${c.status}`);
 });

test/parallel/test-crypto-authenticated.js

@@ -307,6 +307,13 @@ const TEST_CASES = [
 tag: 'a44a8266ee1c8eb0c8b5d4cf5ae9f19a',tampered: false},
 ];
 
+consterrMessages={
+auth: /auth/,
+state: /state/,
+FIPS: /notsupportedinFIPSmode/,
+length: /InvalidIVlength/,
+};
+
 constciphers=crypto.getCiphers();
 
 for(constiinTEST_CASES){
@@ -357,14 +364,14 @@ for (const i in TEST_CASES) {
 assert.strictEqual(msg,test.plain);
 }else{
 // assert that final throws if input data could not be verified!
-assert.throws(function(){decrypt.final('ascii');},/auth/);
+assert.throws(function(){decrypt.final('ascii');},errMessages.auth);
 }
 }
 
 if(test.password){
 if(common.hasFipsCrypto){
 assert.throws(()=>{crypto.createCipher(test.algo,test.password);},
-/notsupportedinFIPSmode/);
+errMessages.FIPS);
 }else{
 constencrypt=crypto.createCipher(test.algo,test.password);
 if(test.aad)
@@ -383,7 +390,7 @@ for (const i in TEST_CASES) {
 if(test.password){
 if(common.hasFipsCrypto){
 assert.throws(()=>{crypto.createDecipher(test.algo,test.password);},
-/notsupportedinFIPSmode/);
+errMessages.FIPS);
 }else{
 constdecrypt=crypto.createDecipher(test.algo,test.password);
 decrypt.setAuthTag(Buffer.from(test.tag,'hex'));
@@ -395,7 +402,7 @@ for (const i in TEST_CASES) {
 assert.strictEqual(msg,test.plain);
 }else{
 // assert that final throws if input data could not be verified!
-assert.throws(function(){decrypt.final('ascii');},/auth/);
+assert.throws(function(){decrypt.final('ascii');},errMessages.auth);
 }
 }
 }
@@ -406,7 +413,7 @@ for (const i in TEST_CASES) {
 Buffer.from(test.key,'hex'),
 Buffer.from(test.iv,'hex'));
 encrypt.update('blah','ascii');
-assert.throws(function(){encrypt.getAuthTag();},/state/);
+assert.throws(function(){encrypt.getAuthTag();},errMessages.state);
 }
 
 {
@@ -415,15 +422,15 @@ for (const i in TEST_CASES) {
 Buffer.from(test.key,'hex'),
 Buffer.from(test.iv,'hex'));
 assert.throws(()=>{encrypt.setAuthTag(Buffer.from(test.tag,'hex'));},
-/state/);
+errMessages.state);
 }
 
 {
 // trying to read tag from decryption object:
 constdecrypt=crypto.createDecipheriv(test.algo,
 Buffer.from(test.key,'hex'),
 Buffer.from(test.iv,'hex'));
-assert.throws(function(){decrypt.getAuthTag();},/state/);
+assert.throws(function(){decrypt.getAuthTag();},errMessages.state);
 }
 
 {
@@ -434,7 +441,7 @@ for (const i in TEST_CASES) {
 Buffer.from(test.key,'hex'),
 Buffer.alloc(0)
 );
-},/InvalidIVlength/);
+},errMessages.length);
 }
 }
 
@@ -446,6 +453,7 @@ for (const i in TEST_CASES) {
 '6fKjEjR3Vl30EUYC');
 encrypt.update('blah','ascii');
 encrypt.final();
-assert.throws(()=>encrypt.getAuthTag(),/state/);
-assert.throws(()=>encrypt.setAAD(Buffer.from('123','ascii')),/state/);
+assert.throws(()=>encrypt.getAuthTag(),errMessages.state);
+assert.throws(()=>encrypt.setAAD(Buffer.from('123','ascii')),
+errMessages.state);
 }

test/parallel/test-crypto-cipheriv-decipheriv.js

@@ -66,12 +66,14 @@ testCipher2(Buffer.from('0123456789abcd0123456789'), Buffer.from('12345678'));
 // Zero-sized IV should be accepted in ECB mode.
 crypto.createCipheriv('aes-128-ecb',Buffer.alloc(16),Buffer.alloc(0));
 
+consterrMessage=/InvalidIVlength/;
+
 // But non-empty IVs should be rejected.
 for(letn=1;n<256;n+=1){
 assert.throws(
 ()=>crypto.createCipheriv('aes-128-ecb',Buffer.alloc(16),
 Buffer.alloc(n)),
-/InvalidIVlength/);
+errMessage);
 }
 
 // Correctly sized IV should be accepted in CBC mode.
@@ -83,14 +85,14 @@ for (let n = 0; n < 256; n += 1) {
 assert.throws(
 ()=>crypto.createCipheriv('aes-128-cbc',Buffer.alloc(16),
 Buffer.alloc(n)),
-/InvalidIVlength/);
+errMessage);
 }
 
 // Zero-sized IV should be rejected in GCM mode.
 assert.throws(
 ()=>crypto.createCipheriv('aes-128-gcm',Buffer.alloc(16),
 Buffer.alloc(0)),
-/InvalidIVlength/);
+errMessage);
 
 // But all other IV lengths should be accepted.
 for(letn=1;n<256;n+=1){

test/parallel/test-crypto-dh.js

@@ -280,14 +280,15 @@ if (availableCurves.has('prime256v1') && availableCurves.has('secp256k1')) {
 // rejected.
 ecdh5.setPrivateKey(cafebabeKey,'hex');
 
-[// Some invalid private keys for the secp256k1 curve.
-'0000000000000000000000000000000000000000000000000000000000000000',
-'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141',
-'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
+// Some invalid private keys for the secp256k1 curve.
+consterrMessage=/^Error:Privatekeyisnotvalidforspecifiedcurve.$/;
+['0000000000000000000000000000000000000000000000000000000000000000',
+'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141',
+'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
 ].forEach((element)=>{
 assert.throws(()=>{
 ecdh5.setPrivateKey(element,'hex');
-},/^Error:Privatekeyisnotvalidforspecifiedcurve.$/);
+},errMessage);
 // Verify object state did not change.
 assert.strictEqual(ecdh5.getPrivateKey('hex'),cafebabeKey);
 });

test/parallel/test-crypto.js

@@ -78,7 +78,8 @@ validateList(cryptoCiphers);
 consttlsCiphers=tls.getCiphers();
 assert(tls.getCiphers().includes('aes256-sha'));
 // There should be no capital letters in any element.
-assert(tlsCiphers.every((value)=>/^[^A-Z]+$/.test(value)));
+constnoCapitals=/^[^A-Z]+$/;
+assert(tlsCiphers.every((value)=>noCapitals.test(value)));
 validateList(tlsCiphers);
 
 // Assert that we have sha and sha1 but not SHA and SHA1.