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.

PR-URL: #13770
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

Author: vsemozhetbyt

test/common/index.js

@@ -267,8 +267,9 @@ if (exports.isWindows) {
 }
 
 const ifaces = os.networkInterfaces();
+const re = /lo/;
 exports.hasIPv6 = Object.keys(ifaces).some(function(name) {
-  return /lo/.test(name) && ifaces[name].some(function(info) {
+  return re.test(name) && ifaces[name].some(function(info) {
     return info.family === 'IPv6';
   });
 });
@@ -433,7 +434,7 @@ function leakedGlobals() {
       leaked.push(val);
 
   if (global.__coverage__) {
-    return leaked.filter((varname) => !/^(cov_|__cov)/.test(varname));
+    return leaked.filter((varname) => !/^(?:cov_|__cov)/.test(varname));
   } else {
     return leaked;
   }

test/debugger/helper-debugger-repl.js

@@ -51,12 +51,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}`);
 
     const expectedLine = 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) {
       const callback = expected[0].callback;

test/doctool/test-doctool-html.js

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

test/inspector/inspector-helper.js

@@ -521,11 +521,11 @@ exports.startNodeForInspectorTest = function(callback,
     clearTimeout(timeoutId);
     console.log('[err]', text);
     if (found) return;
-    const match = text.match(/Debugger listening on ws:\/\/(.+):(\d+)\/(.+)/);
+    const match = text.match(/Debugger listening on ws:\/\/.+:(\d+)\/.+/);
     found = true;
     child.stderr.removeListener('data', dataCallback);
     assert.ok(match, text);
-    callback(new Harness(match[2], child));
+    callback(new Harness(match[1], child));
   });
 
   child.stderr.on('data', dataCallback);

test/inspector/test-inspector.js

@@ -13,8 +13,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']));
 }
 
 function checkVersion(err, response) {

test/parallel/test-assert-checktag.js

@@ -7,10 +7,11 @@ const util = require('util');
 // for assert.throws()
 function re(literals, ...values) {
   let result = literals[0];
+  const escapeRE = /[\\^$.*+?()[\]{}|=!<>:-]/g;
   for (const [i, value] of values.entries()) {
     const str = util.inspect(value);
     // Need to escape special characters.
-    result += str.replace(/[\\^$.*+?()[\]{}|=!<>:-]/g, '\\$&');
+    result += str.replace(escapeRE, '\\$&');
     result += literals[i + 1];
   }
   return common.expectsError({

test/parallel/test-assert-deep.js

@@ -7,10 +7,11 @@ const util = require('util');
 // for assert.throws()
 function re(literals, ...values) {
   let result = literals[0];
+  const escapeRE = /[\\^$.*+?()[\]{}|=!<>:-]/g;
   for (const [i, value] of values.entries()) {
     const str = util.inspect(value);
     // Need to escape special characters.
-    result += str.replace(/[\\^$.*+?()[\]{}|=!<>:-]/g, '\\$&');
+    result += str.replace(escapeRE, '\\$&');
     result += literals[i + 1];
   }
   return common.expectsError({

test/parallel/test-assert.js

@@ -722,13 +722,14 @@ assert.throws(() => {
 {
   // bad args to AssertionError constructor should throw TypeError
   const args = [1, true, false, '', null, Infinity, Symbol('test'), undefined];
+  const re = /^The "options" argument must be of type object$/;
   args.forEach((input) => {
     assert.throws(
       () => new assert.AssertionError(input),
       common.expectsError({
         code: 'ERR_INVALID_ARG_TYPE',
         type: TypeError,
-        message: /^The "options" argument must be of type object$/
+        message: re
       }));
   });
 }

test/parallel/test-buffer-bytelength.js

@@ -7,14 +7,11 @@ const SlowBuffer = require('buffer').SlowBuffer;
 const vm = require('vm');
 
 // coerce values to string
-assert.throws(() => { Buffer.byteLength(32, 'latin1'); },
-              /"string" must be a string, Buffer, or ArrayBuffer/);
-assert.throws(() => { Buffer.byteLength(NaN, 'utf8'); },
-              /"string" must be a string, Buffer, or ArrayBuffer/);
-assert.throws(() => { Buffer.byteLength({}, 'latin1'); },
-              /"string" must be a string, Buffer, or ArrayBuffer/);
-assert.throws(() => { Buffer.byteLength(); },
-              /"string" must be a string, Buffer, or ArrayBuffer/);
+const re = /"string" must be a string, Buffer, or ArrayBuffer/;
+assert.throws(() => { Buffer.byteLength(32, 'latin1'); }, re);
+assert.throws(() => { Buffer.byteLength(NaN, 'utf8'); }, re);
+assert.throws(() => { Buffer.byteLength({}, 'latin1'); }, re);
+assert.throws(() => { Buffer.byteLength(); }, re);
 
 assert.strictEqual(Buffer.byteLength('', undefined, true), -1);
 

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

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