diff --git a/.gitignore b/.gitignore
index dad5a3efd8bcae..4ab96c80544963 100644
--- a/.gitignore
+++ b/.gitignore
@@ -135,3 +135,5 @@ deps/v8/gypfiles/Release/
 deps/v8/third_party/eu-strip/
 
 .DS_Store
+
+node_modules
diff --git a/package.json b/package.json
new file mode 100644
index 00000000000000..34a811578e24cd
--- /dev/null
+++ b/package.json
@@ -0,0 +1,9 @@
+{
+  "scripts": {
+    "format": "prettier --write \"{src,test}/**/*.{js,ts}\"",
+    "format:check": "prettier --list-different \"{src,test}/**/*.{js,ts}\""
+  },
+  "dependencies": {
+    "prettier": "^1.15.2"
+  }
+}
diff --git a/test/abort/test-abort-backtrace.js b/test/abort/test-abort-backtrace.js
index 7f87ef0e7f4559..0d1e1106d56f16 100644
--- a/test/abort/test-abort-backtrace.js
+++ b/test/abort/test-abort-backtrace.js
@@ -12,7 +12,10 @@ if (process.argv[2] === 'child') {
   assert.strictEqual(child.stdout.toString(), '');
   // stderr will be empty for systems that don't support backtraces.
   if (stderr !== '') {
-    const frames = stderr.trimRight().split('\n').map((s) => s.trim());
+    const frames = stderr
+      .trimRight()
+      .split('\n')
+      .map((s) => s.trim());
 
     if (!frames.every((frame, index) => frame.startsWith(`${index + 1}:`))) {
       assert.fail(`Each frame should start with a frame number:\n${stderr}`);
diff --git a/test/abort/test-abort-uncaught-exception.js b/test/abort/test-abort-uncaught-exception.js
index 718f456c9733c6..6c26e39c87f27b 100644
--- a/test/abort/test-abort-uncaught-exception.js
+++ b/test/abort/test-abort-uncaught-exception.js
@@ -14,27 +14,30 @@ if (process.argv[2] === 'child') {
   new vm.Script('[', {});
 } else {
   run('', 'child', null);
-  run('--abort-on-uncaught-exception', 'child',
-      ['SIGABRT', 'SIGTRAP', 'SIGILL']);
+  run('--abort-on-uncaught-exception', 'child', [
+    'SIGABRT',
+    'SIGTRAP',
+    'SIGILL'
+  ]);
   run('--abort-on-uncaught-exception', 'vm', ['SIGABRT', 'SIGTRAP', 'SIGILL']);
 }
 
 function run(flags, argv2, signals) {
   const args = [__filename, argv2];
-  if (flags)
-    args.unshift(flags);
+  if (flags) args.unshift(flags);
 
   const child = spawn(node, args);
-  child.on('exit', common.mustCall(function(code, sig) {
-    if (common.isWindows) {
-      if (signals)
-        assert.strictEqual(code, 0xC0000005);
-      else
-        assert.strictEqual(code, 1);
-    } else if (signals) {
-      assert(signals.includes(sig), `Unexpected signal ${sig}`);
-    } else {
-      assert.strictEqual(sig, null);
-    }
-  }));
+  child.on(
+    'exit',
+    common.mustCall(function(code, sig) {
+      if (common.isWindows) {
+        if (signals) assert.strictEqual(code, 0xc0000005);
+        else assert.strictEqual(code, 1);
+      } else if (signals) {
+        assert(signals.includes(sig), `Unexpected signal ${sig}`);
+      } else {
+        assert.strictEqual(sig, null);
+      }
+    })
+  );
 }
diff --git a/test/abort/test-addon-uv-handle-leak.js b/test/abort/test-addon-uv-handle-leak.js
index 96608f8dda95fd..188bf04dc8665e 100644
--- a/test/abort/test-addon-uv-handle-leak.js
+++ b/test/abort/test-addon-uv-handle-leak.js
@@ -11,23 +11,33 @@ const { spawnSync } = require('child_process');
 // This is a sibling test to test/addons/uv-handle-leak.
 
 const bindingPath = path.resolve(
-  __dirname, '..', 'addons', 'uv-handle-leak', 'build',
-  `${common.buildType}/binding.node`);
+  __dirname,
+  '..',
+  'addons',
+  'uv-handle-leak',
+  'build',
+  `${common.buildType}/binding.node`
+);
 
-if (!fs.existsSync(bindingPath))
-  common.skip('binding not built yet');
+if (!fs.existsSync(bindingPath)) common.skip('binding not built yet');
 
 if (process.argv[2] === 'child') {
-  new Worker(`
+  new Worker(
+    `
   const binding = require(${JSON.stringify(bindingPath)});
 
   binding.leakHandle();
   binding.leakHandle(0);
   binding.leakHandle(0x42);
-  `, { eval: true });
+  `,
+    { eval: true }
+  );
 } else {
-  const child = cp.spawnSync(process.execPath,
-                             ['--experimental-worker', __filename, 'child']);
+  const child = cp.spawnSync(process.execPath, [
+    '--experimental-worker',
+    __filename,
+    'child'
+  ]);
   const stderr = child.stderr.toString();
 
   assert.strictEqual(child.stdout.toString(), '');
@@ -53,23 +63,27 @@ if (process.argv[2] === 'child') {
   function isGlibc() {
     try {
       const lddOut = spawnSync('ldd', [process.execPath]).stdout;
-      const libcInfo = lddOut.toString().split('\n').map(
-        (line) => line.match(/libc\.so.+=>\s*(\S+)\s/)).filter((info) => info);
-      if (libcInfo.length === 0)
-        return false;
+      const libcInfo = lddOut
+        .toString()
+        .split('\n')
+        .map((line) => line.match(/libc\.so.+=>\s*(\S+)\s/))
+        .filter((info) => info);
+      if (libcInfo.length === 0) return false;
       const nmOut = spawnSync('nm', ['-D', libcInfo[0][1]]).stdout;
-      if (/gnu_get_libc_version/.test(nmOut))
-        return true;
+      if (/gnu_get_libc_version/.test(nmOut)) return true;
     } catch {
       return false;
     }
   }
 
-
-  if (!(common.isFreeBSD ||
-        common.isAIX ||
-        (common.isLinux && !isGlibc()) ||
-        common.isWindows)) {
+  if (
+    !(
+      common.isFreeBSD ||
+      common.isAIX ||
+      (common.isLinux && !isGlibc()) ||
+      common.isWindows
+    )
+  ) {
     assert(stderr.includes('ExampleOwnerClass'), stderr);
     assert(stderr.includes('CloseCallback'), stderr);
     assert(stderr.includes('example_instance'), stderr);
diff --git a/test/abort/test-http-parser-consume.js b/test/abort/test-http-parser-consume.js
index 13dc93874a226f..c4fcb5e359e022 100644
--- a/test/abort/test-http-parser-consume.js
+++ b/test/abort/test-http-parser-consume.js
@@ -7,27 +7,39 @@ const { spawn } = require('child_process');
 if (process.argv[2] === 'child') {
   // sub-process
   const server = createServer(common.mustCall((_, res) => res.end('h')));
-  server.listen(0, common.mustCall(() => {
-    const rr = get({ port: server.address().port }, common.mustCall(() => {
-      // This bad input (0) should abort the parser and the process
-      rr.parser.consume(0);
-      // This line should be unreachable.
-      assert.fail('this should be unreachable');
-    }));
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const rr = get(
+        { port: server.address().port },
+        common.mustCall(() => {
+          // This bad input (0) should abort the parser and the process
+          rr.parser.consume(0);
+          // This line should be unreachable.
+          assert.fail('this should be unreachable');
+        })
+      );
+    })
+  );
 } else {
   // super-process
   const child = spawn(process.execPath, [__filename, 'child']);
   child.stdout.on('data', common.mustNotCall());
 
   let stderr = '';
-  child.stderr.on('data', common.mustCallAtLeast((data) => {
-    assert(Buffer.isBuffer(data));
-    stderr += data.toString('utf8');
-  }, 1));
-  child.on('exit', common.mustCall((code, signal) => {
-    assert(stderr.includes('failed'), `stderr: ${stderr}`);
-    const didAbort = common.nodeProcessAborted(code, signal);
-    assert(didAbort, `process did not abort, code:${code} signal:${signal}`);
-  }));
+  child.stderr.on(
+    'data',
+    common.mustCallAtLeast((data) => {
+      assert(Buffer.isBuffer(data));
+      stderr += data.toString('utf8');
+    }, 1)
+  );
+  child.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert(stderr.includes('failed'), `stderr: ${stderr}`);
+      const didAbort = common.nodeProcessAborted(code, signal);
+      assert(didAbort, `process did not abort, code:${code} signal:${signal}`);
+    })
+  );
 }
diff --git a/test/abort/test-process-abort-exitcode.js b/test/abort/test-process-abort-exitcode.js
index 2aa44024ec05b9..8dec3a2c0d9001 100644
--- a/test/abort/test-process-abort-exitcode.js
+++ b/test/abort/test-process-abort-exitcode.js
@@ -12,13 +12,16 @@ if (process.argv[2] === 'child') {
   process.abort();
 } else {
   const child = spawn(process.execPath, [__filename, 'child']);
-  child.on('exit', common.mustCall((code, signal) => {
-    if (common.isWindows) {
-      assert.strictEqual(code, 134);
-      assert.strictEqual(signal, null);
-    } else {
-      assert.strictEqual(code, null);
-      assert.strictEqual(signal, 'SIGABRT');
-    }
-  }));
+  child.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      if (common.isWindows) {
+        assert.strictEqual(code, 134);
+        assert.strictEqual(signal, null);
+      } else {
+        assert.strictEqual(code, null);
+        assert.strictEqual(signal, 'SIGABRT');
+      }
+    })
+  );
 }
diff --git a/test/abort/test-zlib-invalid-internals-usage.js b/test/abort/test-zlib-invalid-internals-usage.js
index c218a5ee956f19..14a5c2576d10a6 100644
--- a/test/abort/test-zlib-invalid-internals-usage.js
+++ b/test/abort/test-zlib-invalid-internals-usage.js
@@ -6,15 +6,18 @@ const cp = require('child_process');
 
 if (process.argv[2] === 'child') {
   // This is the heart of the test.
-  new (process.binding('zlib').Zlib)(0).init(1, 2, 3, 4, 5);
+  new (process.binding('zlib')).Zlib(0).init(1, 2, 3, 4, 5);
 } else {
   const child = cp.spawnSync(`${process.execPath}`, [`${__filename}`, 'child']);
 
   assert.strictEqual(child.stdout.toString(), '');
-  assert.ok(child.stderr.includes(
-    'WARNING: You are likely using a version of node-tar or npm that ' +
-    `is incompatible with this version of Node.js.${os.EOL}` +
-    'Please use either the version of npm that is bundled with Node.js, or ' +
-    'a version of npm (> 5.5.1 or < 5.4.0) or node-tar (> 4.0.1) that is ' +
-    `compatible with Node.js 9 and above.${os.EOL}`));
+  assert.ok(
+    child.stderr.includes(
+      'WARNING: You are likely using a version of node-tar or npm that ' +
+        `is incompatible with this version of Node.js.${os.EOL}` +
+        'Please use either the version of npm that is bundled with Node.js, or ' +
+        'a version of npm (> 5.5.1 or < 5.4.0) or node-tar (> 4.0.1) that is ' +
+        `compatible with Node.js 9 and above.${os.EOL}`
+    )
+  );
 }
diff --git a/test/addons-napi/test_array/test.js b/test/addons-napi/test_array/test.js
index 75c181d9da8269..061947b319aa64 100644
--- a/test/addons-napi/test_array/test.js
+++ b/test/addons-napi/test_array/test.js
@@ -12,32 +12,21 @@ const array = [
   13493,
   9459324,
   { name: 'hello' },
-  [
-    'world',
-    'node',
-    'abi'
-  ]
+  ['world', 'node', 'abi']
 ];
 
-assert.throws(
-  () => {
-    test_array.TestGetElement(array, array.length + 1);
-  },
-  /^Error: assertion \(\(\(uint32_t\)index < length\)\) failed: Index out of bounds!$/
-);
+assert.throws(() => {
+  test_array.TestGetElement(array, array.length + 1);
+}, /^Error: assertion \(\(\(uint32_t\)index < length\)\) failed: Index out of bounds!$/);
 
-assert.throws(
-  () => {
-    test_array.TestGetElement(array, -2);
-  },
-  /^Error: assertion \(index >= 0\) failed: Invalid index\. Expects a positive integer\.$/
-);
+assert.throws(() => {
+  test_array.TestGetElement(array, -2);
+}, /^Error: assertion \(index >= 0\) failed: Invalid index\. Expects a positive integer\.$/);
 
 array.forEach(function(element, index) {
   assert.strictEqual(test_array.TestGetElement(array, index), element);
 });
 
-
 assert.deepStrictEqual(test_array.New(array), array);
 
 assert(test_array.TestHasElement(array, 0));
diff --git a/test/addons-napi/test_async/test-async-hooks.js b/test/addons-napi/test_async/test-async-hooks.js
index db6e0cbd1679e6..e683183c918844 100644
--- a/test/addons-napi/test_async/test-async-hooks.js
+++ b/test/addons-napi/test_async/test-async-hooks.js
@@ -8,49 +8,57 @@ const events = [];
 let testId;
 const initAsyncId = async_hooks.executionAsyncId();
 
-async_hooks.createHook({
-  init(id, provider, triggerAsyncId, resource) {
-    if (provider === 'TestResource') {
-      testId = id;
-      events.push({ type: 'init', id, provider, triggerAsyncId, resource });
+async_hooks
+  .createHook({
+    init(id, provider, triggerAsyncId, resource) {
+      if (provider === 'TestResource') {
+        testId = id;
+        events.push({ type: 'init', id, provider, triggerAsyncId, resource });
+      }
+    },
+    before(id) {
+      if (testId === id) {
+        events.push({ type: 'before', id });
+      }
+    },
+    after(id) {
+      if (testId === id) {
+        events.push({ type: 'after', id });
+      }
+    },
+    destroy(id) {
+      if (testId === id) {
+        events.push({ type: 'destroy', id });
+      }
     }
-  },
-  before(id) {
-    if (testId === id) {
-      events.push({ type: 'before', id });
-    }
-  },
-  after(id) {
-    if (testId === id) {
-      events.push({ type: 'after', id });
-    }
-  },
-  destroy(id) {
-    if (testId === id) {
-      events.push({ type: 'destroy', id });
-    }
-  }
-}).enable();
+  })
+  .enable();
 
 const resource = { foo: 'foo' };
 
 events.push({ type: 'start' });
-test_async.Test(5, resource, common.mustCall(function(err, val) {
-  assert.strictEqual(err, null);
-  assert.strictEqual(val, 10);
-  events.push({ type: 'complete' });
-  process.nextTick(common.mustCall());
-}));
+test_async.Test(
+  5,
+  resource,
+  common.mustCall(function(err, val) {
+    assert.strictEqual(err, null);
+    assert.strictEqual(val, 10);
+    events.push({ type: 'complete' });
+    process.nextTick(common.mustCall());
+  })
+);
 events.push({ type: 'scheduled' });
 
 process.on('exit', () => {
   assert.deepStrictEqual(events, [
     { type: 'start' },
-    { type: 'init',
+    {
+      type: 'init',
       id: testId,
       provider: 'TestResource',
       triggerAsyncId: initAsyncId,
-      resource },
+      resource
+    },
     { type: 'scheduled' },
     { type: 'before', id: testId },
     { type: 'complete' },
diff --git a/test/addons-napi/test_async/test-uncaught.js b/test/addons-napi/test_async/test-uncaught.js
index fdcb3203f54410..4c9b42c7f55366 100644
--- a/test/addons-napi/test_async/test-uncaught.js
+++ b/test/addons-napi/test_async/test-uncaught.js
@@ -3,16 +3,23 @@ const common = require('../../common');
 const assert = require('assert');
 const test_async = require(`./build/${common.buildType}/test_async`);
 
-process.on('uncaughtException', common.mustCall(function(err) {
-  try {
-    throw new Error('should not fail');
-  } catch (err) {
-    assert.strictEqual(err.message, 'should not fail');
-  }
-  assert.strictEqual(err.message, 'uncaught');
-}));
+process.on(
+  'uncaughtException',
+  common.mustCall(function(err) {
+    try {
+      throw new Error('should not fail');
+    } catch (err) {
+      assert.strictEqual(err.message, 'should not fail');
+    }
+    assert.strictEqual(err.message, 'uncaught');
+  })
+);
 
 // Successful async execution and completion callback.
-test_async.Test(5, {}, common.mustCall(function() {
-  throw new Error('uncaught');
-}));
+test_async.Test(
+  5,
+  {},
+  common.mustCall(function() {
+    throw new Error('uncaught');
+  })
+);
diff --git a/test/addons-napi/test_async/test.js b/test/addons-napi/test_async/test.js
index 34ecae08e67f2e..600ae73faecfef 100644
--- a/test/addons-napi/test_async/test.js
+++ b/test/addons-napi/test_async/test.js
@@ -9,22 +9,29 @@ const testException = 'test_async_cb_exception';
 // Exception thrown from async completion callback.
 // (Tested in a spawned process because the exception is fatal.)
 if (process.argv[2] === 'child') {
-  test_async.Test(1, {}, common.mustCall(function() {
-    throw new Error(testException);
-  }));
+  test_async.Test(
+    1,
+    {},
+    common.mustCall(function() {
+      throw new Error(testException);
+    })
+  );
   return;
 }
-const p = child_process.spawnSync(
-  process.execPath, [ __filename, 'child' ]);
+const p = child_process.spawnSync(process.execPath, [__filename, 'child']);
 assert.ifError(p.error);
 assert.ok(p.stderr.toString().includes(testException));
 
 // Successful async execution and completion callback.
-test_async.Test(5, {}, common.mustCall(function(err, val) {
-  assert.strictEqual(err, null);
-  assert.strictEqual(val, 10);
-  process.nextTick(common.mustCall());
-}));
+test_async.Test(
+  5,
+  {},
+  common.mustCall(function(err, val) {
+    assert.strictEqual(err, null);
+    assert.strictEqual(val, 10);
+    process.nextTick(common.mustCall());
+  })
+);
 
 // Async work item cancellation with callback.
 test_async.TestCancel(common.mustCall());
diff --git a/test/addons-napi/test_bigint/test.js b/test/addons-napi/test_bigint/test.js
index b92c810459321b..f4ff7c1abc9e92 100644
--- a/test/addons-napi/test_bigint/test.js
+++ b/test/addons-napi/test_bigint/test.js
@@ -6,7 +6,7 @@ const {
   TestInt64,
   TestUint64,
   TestWords,
-  CreateTooBigBigInt,
+  CreateTooBigBigInt
 } = require(`./build/${common.buildType}/test_bigint`);
 
 [
@@ -20,7 +20,7 @@ const {
   986583n,
   -976675n,
   98765432213456789876546896323445679887645323232436587988766545658n,
-  -4350987086545760976737453646576078997096876957864353245245769809n,
+  -4350987086545760976737453646576078997096876957864353245245769809n
 ].forEach((num) => {
   if (num > -(2n ** 63n) && num < 2n ** 63n) {
     assert.strictEqual(TestInt64(num), num);
@@ -41,5 +41,5 @@ const {
 
 assert.throws(CreateTooBigBigInt, {
   name: 'RangeError',
-  message: 'Maximum BigInt size exceeded',
+  message: 'Maximum BigInt size exceeded'
 });
diff --git a/test/addons-napi/test_callback_scope/test-async-hooks.js b/test/addons-napi/test_callback_scope/test-async-hooks.js
index 1a11bf60398f9b..c347205ae7a133 100644
--- a/test/addons-napi/test_callback_scope/test-async-hooks.js
+++ b/test/addons-napi/test_callback_scope/test-async-hooks.js
@@ -13,16 +13,18 @@ process.emitWarning = () => {};
 const { runInCallbackScope } = require(`./build/${common.buildType}/binding`);
 
 let insideHook = false;
-async_hooks.createHook({
-  before: common.mustCall((id) => {
-    assert.strictEqual(id, 1000);
-    insideHook = true;
-  }),
-  after: common.mustCall((id) => {
-    assert.strictEqual(id, 1000);
-    insideHook = false;
+async_hooks
+  .createHook({
+    before: common.mustCall((id) => {
+      assert.strictEqual(id, 1000);
+      insideHook = true;
+    }),
+    after: common.mustCall((id) => {
+      assert.strictEqual(id, 1000);
+      insideHook = false;
+    })
   })
-}).enable();
+  .enable();
 
 runInCallbackScope({}, 1000, 1000, () => {
   assert(insideHook);
diff --git a/test/addons-napi/test_callback_scope/test.js b/test/addons-napi/test_callback_scope/test.js
index 2f2efe5f47b98a..a2158fd5bcea2b 100644
--- a/test/addons-napi/test_callback_scope/test.js
+++ b/test/addons-napi/test_callback_scope/test.js
@@ -7,9 +7,12 @@ const { runInCallbackScope } = require(`./build/${common.buildType}/binding`);
 assert.strictEqual(runInCallbackScope({}, 0, 0, () => 42), 42);
 
 {
-  process.once('uncaughtException', common.mustCall((err) => {
-    assert.strictEqual(err.message, 'foo');
-  }));
+  process.once(
+    'uncaughtException',
+    common.mustCall((err) => {
+      assert.strictEqual(err.message, 'foo');
+    })
+  );
 
   runInCallbackScope({}, 0, 0, () => {
     throw new Error('foo');
diff --git a/test/addons-napi/test_cleanup_hook/test.js b/test/addons-napi/test_cleanup_hook/test.js
index 354f4449045c17..41a69572ff8234 100644
--- a/test/addons-napi/test_cleanup_hook/test.js
+++ b/test/addons-napi/test_cleanup_hook/test.js
@@ -6,7 +6,9 @@ const child_process = require('child_process');
 if (process.argv[2] === 'child') {
   require(`./build/${common.buildType}/binding`);
 } else {
-  const { stdout } =
-    child_process.spawnSync(process.execPath, [__filename, 'child']);
+  const { stdout } = child_process.spawnSync(process.execPath, [
+    __filename,
+    'child'
+  ]);
   assert.strictEqual(stdout.toString().trim(), 'cleanup(42)');
 }
diff --git a/test/addons-napi/test_constructor/test.js b/test/addons-napi/test_constructor/test.js
index 616ba6c2a2927e..6ab04bfab9af1b 100644
--- a/test/addons-napi/test_constructor/test.js
+++ b/test/addons-napi/test_constructor/test.js
@@ -13,8 +13,9 @@ assert.strictEqual(test_object.readwriteValue, 1);
 test_object.readwriteValue = 2;
 assert.strictEqual(test_object.readwriteValue, 2);
 
-assert.throws(() => { test_object.readonlyValue = 3; },
-              /^TypeError: Cannot assign to read only property 'readonlyValue' of object '#<MyObject>'$/);
+assert.throws(() => {
+  test_object.readonlyValue = 3;
+}, /^TypeError: Cannot assign to read only property 'readonlyValue' of object '#<MyObject>'$/);
 
 assert.ok(test_object.hiddenValue);
 
@@ -36,13 +37,15 @@ assert.ok(!propertyNames.includes('readonlyAccessor2'));
 test_object.readwriteAccessor1 = 1;
 assert.strictEqual(test_object.readwriteAccessor1, 1);
 assert.strictEqual(test_object.readonlyAccessor1, 1);
-assert.throws(() => { test_object.readonlyAccessor1 = 3; },
-              /^TypeError: Cannot assign to read only property 'readonlyAccessor1' of object '#<MyObject>'$/);
+assert.throws(() => {
+  test_object.readonlyAccessor1 = 3;
+}, /^TypeError: Cannot assign to read only property 'readonlyAccessor1' of object '#<MyObject>'$/);
 test_object.readwriteAccessor2 = 2;
 assert.strictEqual(test_object.readwriteAccessor2, 2);
 assert.strictEqual(test_object.readonlyAccessor2, 2);
-assert.throws(() => { test_object.readonlyAccessor2 = 3; },
-              /^TypeError: Cannot assign to read only property 'readonlyAccessor2' of object '#<MyObject>'$/);
+assert.throws(() => {
+  test_object.readonlyAccessor2 = 3;
+}, /^TypeError: Cannot assign to read only property 'readonlyAccessor2' of object '#<MyObject>'$/);
 
 // validate that static properties are on the class as opposed
 // to the instance
diff --git a/test/addons-napi/test_constructor/test2.js b/test/addons-napi/test_constructor/test2.js
index 64c03cbc684ac3..5d6e4a08e6c3d7 100644
--- a/test/addons-napi/test_constructor/test2.js
+++ b/test/addons-napi/test_constructor/test2.js
@@ -3,6 +3,7 @@ const common = require('../../common');
 const assert = require('assert');
 
 // Testing api calls for a constructor that defines properties
-const TestConstructor =
-    require(`./build/${common.buildType}/test_constructor_name`);
+const TestConstructor = require(`./build/${
+  common.buildType
+}/test_constructor_name`);
 assert.strictEqual(TestConstructor.name, 'MyObject');
diff --git a/test/addons-napi/test_conversions/test.js b/test/addons-napi/test_conversions/test.js
index b9e43da0c5ed20..66477c7b47d007 100644
--- a/test/addons-napi/test_conversions/test.js
+++ b/test/addons-napi/test_conversions/test.js
@@ -109,9 +109,9 @@ assert.ok(Number.isNaN(test.toNumber(undefined)));
 assert.throws(() => test.toNumber(testSym), TypeError);
 
 assert.deepStrictEqual({}, test.toObject({}));
-assert.deepStrictEqual({ 'test': 1 }, test.toObject({ 'test': 1 }));
+assert.deepStrictEqual({ test: 1 }, test.toObject({ test: 1 }));
 assert.deepStrictEqual([], test.toObject([]));
-assert.deepStrictEqual([ 1, 2, 3 ], test.toObject([ 1, 2, 3 ]));
+assert.deepStrictEqual([1, 2, 3], test.toObject([1, 2, 3]));
 assert.deepStrictEqual(new Boolean(false), test.toObject(false));
 assert.deepStrictEqual(new Boolean(true), test.toObject(true));
 assert.deepStrictEqual(new String(''), test.toObject(''));
@@ -136,5 +136,5 @@ assert.strictEqual(test.toString(Number.NaN), 'NaN');
 assert.strictEqual(test.toString({}), '[object Object]');
 assert.strictEqual(test.toString({ toString: () => 'test' }), 'test');
 assert.strictEqual(test.toString([]), '');
-assert.strictEqual(test.toString([ 1, 2, 3 ]), '1,2,3');
+assert.strictEqual(test.toString([1, 2, 3]), '1,2,3');
 assert.throws(() => test.toString(testSym), TypeError);
diff --git a/test/addons-napi/test_dataview/test.js b/test/addons-napi/test_dataview/test.js
index a6be58494069e5..5e7049374c64c7 100644
--- a/test/addons-napi/test_dataview/test.js
+++ b/test/addons-napi/test_dataview/test.js
@@ -11,8 +11,10 @@ const test_dataview = require(`./build/${common.buildType}/test_dataview`);
   const template = Reflect.construct(DataView, [buffer]);
 
   const theDataview = test_dataview.CreateDataViewFromJSDataView(template);
-  assert.ok(theDataview instanceof DataView,
-            `Expect ${theDataview} to be a DataView`);
+  assert.ok(
+    theDataview instanceof DataView,
+    `Expect ${theDataview} to be a DataView`
+  );
 }
 
 // Test for creating dataview with invalid range
diff --git a/test/addons-napi/test_env_sharing/test.js b/test/addons-napi/test_env_sharing/test.js
index 6e21bf4c638b80..7ab9fd26570db6 100644
--- a/test/addons-napi/test_env_sharing/test.js
+++ b/test/addons-napi/test_env_sharing/test.js
@@ -5,6 +5,8 @@ const storeEnv = require(`./build/${common.buildType}/store_env`);
 const compareEnv = require(`./build/${common.buildType}/compare_env`);
 const assert = require('assert');
 
-assert.strictEqual(compareEnv(storeEnv), true,
-                   'N-API environment pointers in two different modules have ' +
-                   'the same value');
+assert.strictEqual(
+  compareEnv(storeEnv),
+  true,
+  'N-API environment pointers in two different modules have ' + 'the same value'
+);
diff --git a/test/addons-napi/test_error/test.js b/test/addons-napi/test_error/test.js
index d4b1d8a971ee09..ba9311a30dd2c2 100644
--- a/test/addons-napi/test_error/test.js
+++ b/test/addons-napi/test_error/test.js
@@ -11,7 +11,7 @@ const theReferenceError = new ReferenceError('Some reference error');
 const theURIError = new URIError('Some URI error');
 const theEvalError = new EvalError('Some eval error');
 
-class MyError extends Error { }
+class MyError extends Error {}
 const myError = new MyError('Some MyError');
 
 // Test that native error object is correctly classed
@@ -66,7 +66,8 @@ function testThrowArbitrary(value) {
     (err) => {
       assert.strictEqual(err, value);
       return true;
-    });
+    }
+  );
 }
 
 testThrowArbitrary(42);
@@ -79,39 +80,37 @@ testThrowArbitrary(undefined);
 testThrowArbitrary(null);
 testThrowArbitrary(NaN);
 
-common.expectsError(
-  () => test_error.throwErrorCode(),
-  {
-    code: 'ERR_TEST_CODE',
-    message: 'Error [error]'
-  });
-
-common.expectsError(
-  () => test_error.throwRangeErrorCode(),
-  {
-    code: 'ERR_TEST_CODE',
-    message: 'RangeError [range error]'
-  });
-
-common.expectsError(
-  () => test_error.throwTypeErrorCode(),
-  {
-    code: 'ERR_TEST_CODE',
-    message: 'TypeError [type error]'
-  });
+common.expectsError(() => test_error.throwErrorCode(), {
+  code: 'ERR_TEST_CODE',
+  message: 'Error [error]'
+});
+
+common.expectsError(() => test_error.throwRangeErrorCode(), {
+  code: 'ERR_TEST_CODE',
+  message: 'RangeError [range error]'
+});
+
+common.expectsError(() => test_error.throwTypeErrorCode(), {
+  code: 'ERR_TEST_CODE',
+  message: 'TypeError [type error]'
+});
 
 let error = test_error.createError();
 assert.ok(error instanceof Error, 'expected error to be an instance of Error');
 assert.strictEqual(error.message, 'error');
 
 error = test_error.createRangeError();
-assert.ok(error instanceof RangeError,
-          'expected error to be an instance of RangeError');
+assert.ok(
+  error instanceof RangeError,
+  'expected error to be an instance of RangeError'
+);
 assert.strictEqual(error.message, 'range error');
 
 error = test_error.createTypeError();
-assert.ok(error instanceof TypeError,
-          'expected error to be an instance of TypeError');
+assert.ok(
+  error instanceof TypeError,
+  'expected error to be an instance of TypeError'
+);
 assert.strictEqual(error.message, 'type error');
 
 error = test_error.createErrorCode();
@@ -121,15 +120,19 @@ assert.strictEqual(error.message, 'Error [error]');
 assert.strictEqual(error.name, 'Error [ERR_TEST_CODE]');
 
 error = test_error.createRangeErrorCode();
-assert.ok(error instanceof RangeError,
-          'expected error to be an instance of RangeError');
+assert.ok(
+  error instanceof RangeError,
+  'expected error to be an instance of RangeError'
+);
 assert.strictEqual(error.message, 'RangeError [range error]');
 assert.strictEqual(error.code, 'ERR_TEST_CODE');
 assert.strictEqual(error.name, 'RangeError [ERR_TEST_CODE]');
 
 error = test_error.createTypeErrorCode();
-assert.ok(error instanceof TypeError,
-          'expected error to be an instance of TypeError');
+assert.ok(
+  error instanceof TypeError,
+  'expected error to be an instance of TypeError'
+);
 assert.strictEqual(error.message, 'TypeError [type error]');
 assert.strictEqual(error.code, 'ERR_TEST_CODE');
 assert.strictEqual(error.name, 'TypeError [ERR_TEST_CODE]');
diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
index b9311add6c92d7..7f3eaea7e20c32 100644
--- a/test/addons-napi/test_exception/test.js
+++ b/test/addons-napi/test_exception/test.js
@@ -22,7 +22,9 @@ const test_exception = (function() {
 })();
 
 {
-  const throwTheError = () => { throw theError; };
+  const throwTheError = () => {
+    throw theError;
+  };
 
   // Test that the native side successfully captures the exception
   let returnedError = test_exception.returnException(throwTheError);
@@ -30,22 +32,30 @@ const test_exception = (function() {
 
   // Test that the native side passes the exception through
   assert.throws(
-    () => { test_exception.allowException(throwTheError); },
+    () => {
+      test_exception.allowException(throwTheError);
+    },
     (err) => err === theError
   );
 
   // Test that the exception thrown above was marked as pending
   // before it was handled on the JS side
   const exception_pending = test_exception.wasPending();
-  assert.strictEqual(exception_pending, true,
-                     'Exception not pending as expected,' +
-                     ` .wasPending() returned ${exception_pending}`);
+  assert.strictEqual(
+    exception_pending,
+    true,
+    'Exception not pending as expected,' +
+      ` .wasPending() returned ${exception_pending}`
+  );
 
   // Test that the native side does not capture a non-existing exception
   returnedError = test_exception.returnException(common.mustCall());
-  assert.strictEqual(returnedError, undefined,
-                     'Returned error should be undefined when no exception is' +
-                     ` thrown, but ${returnedError} was passed`);
+  assert.strictEqual(
+    returnedError,
+    undefined,
+    'Returned error should be undefined when no exception is' +
+      ` thrown, but ${returnedError} was passed`
+  );
 }
 
 {
@@ -56,22 +66,30 @@ const test_exception = (function() {
   } catch (anError) {
     caughtError = anError;
   }
-  assert.strictEqual(caughtError, undefined,
-                     'No exception originated on the native side, but' +
-                     ` ${caughtError} was passed`);
+  assert.strictEqual(
+    caughtError,
+    undefined,
+    'No exception originated on the native side, but' +
+      ` ${caughtError} was passed`
+  );
 
   // Test that the exception state remains clear when no exception is thrown
   const exception_pending = test_exception.wasPending();
-  assert.strictEqual(exception_pending, false,
-                     'Exception state did not remain clear as expected,' +
-                     ` .wasPending() returned ${exception_pending}`);
+  assert.strictEqual(
+    exception_pending,
+    false,
+    'Exception state did not remain clear as expected,' +
+      ` .wasPending() returned ${exception_pending}`
+  );
 }
 
 // Make sure that exceptions that occur during finalization are propagated.
 function testFinalize(binding) {
   let x = test_exception[binding]();
   x = null;
-  assert.throws(() => { global.gc(); }, /Error during Finalize/);
+  assert.throws(() => {
+    global.gc();
+  }, /Error during Finalize/);
 
   // To assuage the linter's concerns.
   (function() {})(x);
diff --git a/test/addons-napi/test_fatal/test.js b/test/addons-napi/test_fatal/test.js
index 7ff9a395635dce..dac5546a5b2ab9 100644
--- a/test/addons-napi/test_fatal/test.js
+++ b/test/addons-napi/test_fatal/test.js
@@ -11,8 +11,8 @@ if (process.argv[2] === 'child') {
   return;
 }
 
-const p = child_process.spawnSync(
-  process.execPath, [ __filename, 'child' ]);
+const p = child_process.spawnSync(process.execPath, [__filename, 'child']);
 assert.ifError(p.error);
-assert.ok(p.stderr.toString().includes(
-  'FATAL ERROR: test_fatal::Test fatal message'));
+assert.ok(
+  p.stderr.toString().includes('FATAL ERROR: test_fatal::Test fatal message')
+);
diff --git a/test/addons-napi/test_fatal/test2.js b/test/addons-napi/test_fatal/test2.js
index b9bde8f13016cc..e2628446fc65cc 100644
--- a/test/addons-napi/test_fatal/test2.js
+++ b/test/addons-napi/test_fatal/test2.js
@@ -11,8 +11,12 @@ if (process.argv[2] === 'child') {
   return;
 }
 
-const p = child_process.spawnSync(
-  process.execPath, [ '--napi-modules', __filename, 'child' ]);
+const p = child_process.spawnSync(process.execPath, [
+  '--napi-modules',
+  __filename,
+  'child'
+]);
 assert.ifError(p.error);
-assert.ok(p.stderr.toString().includes(
-  'FATAL ERROR: test_fatal::Test fatal message'));
+assert.ok(
+  p.stderr.toString().includes('FATAL ERROR: test_fatal::Test fatal message')
+);
diff --git a/test/addons-napi/test_fatal_exception/test.js b/test/addons-napi/test_fatal_exception/test.js
index f02b9bce1e8169..97c2af027b0ac2 100644
--- a/test/addons-napi/test_fatal_exception/test.js
+++ b/test/addons-napi/test_fatal_exception/test.js
@@ -3,9 +3,12 @@ const common = require('../../common');
 const assert = require('assert');
 const test_fatal = require(`./build/${common.buildType}/test_fatal_exception`);
 
-process.on('uncaughtException', common.mustCall(function(err) {
-  assert.strictEqual(err.message, 'fatal error');
-}));
+process.on(
+  'uncaughtException',
+  common.mustCall(function(err) {
+    assert.strictEqual(err.message, 'fatal error');
+  })
+);
 
 const err = new Error('fatal error');
 test_fatal.Test(err);
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index fe38c1b9a2828c..a1be853bf02270 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -9,11 +9,9 @@ const val1 = '1';
 const val2 = 1;
 const val3 = 1;
 
-class BaseClass {
-}
+class BaseClass {}
 
-class ExtendedClass extends BaseClass {
-}
+class ExtendedClass extends BaseClass {}
 
 const baseObject = new BaseClass();
 const extendedObject = new ExtendedClass();
@@ -24,21 +22,29 @@ assert.strictEqual(test_general.testStrictEquals(val1, val2), false);
 assert.ok(test_general.testStrictEquals(val2, val3));
 
 // test napi_get_prototype
-assert.strictEqual(test_general.testGetPrototype(baseObject),
-                   Object.getPrototypeOf(baseObject));
-assert.strictEqual(test_general.testGetPrototype(extendedObject),
-                   Object.getPrototypeOf(extendedObject));
+assert.strictEqual(
+  test_general.testGetPrototype(baseObject),
+  Object.getPrototypeOf(baseObject)
+);
+assert.strictEqual(
+  test_general.testGetPrototype(extendedObject),
+  Object.getPrototypeOf(extendedObject)
+);
 // Prototypes for base and extended should be different.
-assert.notStrictEqual(test_general.testGetPrototype(baseObject),
-                      test_general.testGetPrototype(extendedObject));
+assert.notStrictEqual(
+  test_general.testGetPrototype(baseObject),
+  test_general.testGetPrototype(extendedObject)
+);
 
 // test version management functions
 // expected version is currently 3
 assert.strictEqual(test_general.testGetVersion(), 3);
 
-const [ major, minor, patch, release ] = test_general.testGetNodeVersion();
-assert.strictEqual(process.version.split('-')[0],
-                   `v${major}.${minor}.${patch}`);
+const [major, minor, patch, release] = test_general.testGetNodeVersion();
+assert.strictEqual(
+  process.version.split('-')[0],
+  `v${major}.${minor}.${patch}`
+);
 assert.strictEqual(release, process.release.name);
 
 [
@@ -64,17 +70,21 @@ test_general.wrap(w);
 w = null;
 global.gc();
 const derefItemWasCalled = test_general.derefItemWasCalled();
-assert.strictEqual(derefItemWasCalled, true,
-                   'deref_item() was called upon garbage collecting a ' +
-                   'wrapped object. test_general.derefItemWasCalled() ' +
-                   `returned ${derefItemWasCalled}`);
-
+assert.strictEqual(
+  derefItemWasCalled,
+  true,
+  'deref_item() was called upon garbage collecting a ' +
+    'wrapped object. test_general.derefItemWasCalled() ' +
+    `returned ${derefItemWasCalled}`
+);
 
 // Assert that wrapping twice fails.
 const x = {};
 test_general.wrap(x);
-common.expectsError(() => test_general.wrap(x),
-                    { type: Error, message: 'Invalid argument' });
+common.expectsError(() => test_general.wrap(x), {
+  type: Error,
+  message: 'Invalid argument'
+});
 
 // Ensure that wrapping, removing the wrap, and then wrapping again works.
 const y = {};
@@ -91,10 +101,13 @@ test_general.removeWrap(z);
 z = null;
 global.gc();
 const finalizeWasCalled = test_general.finalizeWasCalled();
-assert.strictEqual(finalizeWasCalled, false,
-                   'finalize callback was not called upon garbage collection.' +
-                   ' test_general.finalizeWasCalled() ' +
-                   `returned ${finalizeWasCalled}`);
+assert.strictEqual(
+  finalizeWasCalled,
+  false,
+  'finalize callback was not called upon garbage collection.' +
+    ' test_general.finalizeWasCalled() ' +
+    `returned ${finalizeWasCalled}`
+);
 
 // test napi_adjust_external_memory
 const adjustedValue = test_general.testAdjustExternalMemory();
diff --git a/test/addons-napi/test_general/testFinalizer.js b/test/addons-napi/test_general/testFinalizer.js
index b440ed5e501ad8..5be89135ee9012 100644
--- a/test/addons-napi/test_general/testFinalizer.js
+++ b/test/addons-napi/test_general/testFinalizer.js
@@ -13,12 +13,16 @@ test_general.addFinalizerOnly(finalized, callback);
 test_general.addFinalizerOnly(finalized, callback);
 
 // Ensure attached items cannot be retrieved.
-common.expectsError(() => test_general.unwrap(finalized),
-                    { type: Error, message: 'Invalid argument' });
+common.expectsError(() => test_general.unwrap(finalized), {
+  type: Error,
+  message: 'Invalid argument'
+});
 
 // Ensure attached items cannot be removed.
-common.expectsError(() => test_general.removeWrap(finalized),
-                    { type: Error, message: 'Invalid argument' });
+common.expectsError(() => test_general.removeWrap(finalized), {
+  type: Error,
+  message: 'Invalid argument'
+});
 finalized = null;
 global.gc();
 
diff --git a/test/addons-napi/test_general/testInstanceOf.js b/test/addons-napi/test_general/testInstanceOf.js
index 53455a0025a0e2..58a7a81c572332 100644
--- a/test/addons-napi/test_general/testInstanceOf.js
+++ b/test/addons-napi/test_general/testInstanceOf.js
@@ -10,8 +10,16 @@ const addon = require(`./build/${common.buildType}/test_general`);
 const path = require('path');
 
 // This test depends on a number of V8 tests.
-const v8TestsDir = path.resolve(__dirname, '..', '..', '..', 'deps', 'v8',
-                                'test', 'mjsunit');
+const v8TestsDir = path.resolve(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  'deps',
+  'v8',
+  'test',
+  'mjsunit'
+);
 const v8TestsDirExists = fs.existsSync(v8TestsDir);
 
 // The following assert functions are referenced by v8's unit tests
@@ -41,15 +49,18 @@ function assertThrows(statement) {
 function testFile(fileName) {
   try {
     const contents = fs.readFileSync(fileName, { encoding: 'utf8' });
-    eval(contents.replace(/[(]([^\s(]+)\s+instanceof\s+([^)]+)[)]/g,
-                          '(addon.doInstanceOf($1, $2))'));
+    eval(
+      contents.replace(
+        /[(]([^\s(]+)\s+instanceof\s+([^)]+)[)]/g,
+        '(addon.doInstanceOf($1, $2))'
+      )
+    );
   } catch (err) {
     // This test depends on V8 test files, which may not exist in downloaded
     // archives. Emit a warning if the tests cannot be found instead of failing.
     if (err.code === 'ENOENT' && !v8TestsDirExists)
       process.emitWarning(`test file ${fileName} does not exist.`);
-    else
-      throw err;
+    else throw err;
   }
 }
 
@@ -57,13 +68,15 @@ testFile(path.join(v8TestsDir, 'instanceof.js'));
 testFile(path.join(v8TestsDir, 'instanceof-2.js'));
 
 // We can only perform this test if we have a working Symbol.hasInstance
-if (typeof Symbol !== 'undefined' && 'hasInstance' in Symbol &&
-    typeof Symbol.hasInstance === 'symbol') {
-
+if (
+  typeof Symbol !== 'undefined' &&
+  'hasInstance' in Symbol &&
+  typeof Symbol.hasInstance === 'symbol'
+) {
   function compareToNative(theObject, theConstructor) {
     assert.strictEqual(
       addon.doInstanceOf(theObject, theConstructor),
-      (theObject instanceof theConstructor)
+      theObject instanceof theConstructor
     );
   }
 
diff --git a/test/addons-napi/test_handle_scope/test.js b/test/addons-napi/test_handle_scope/test.js
index 53abfe178c8d7d..6bbd3906aa66be 100644
--- a/test/addons-napi/test_handle_scope/test.js
+++ b/test/addons-napi/test_handle_scope/test.js
@@ -3,8 +3,9 @@ const common = require('../../common');
 const assert = require('assert');
 
 // testing handle scope api calls
-const testHandleScope =
-    require(`./build/${common.buildType}/test_handle_scope`);
+const testHandleScope = require(`./build/${
+  common.buildType
+}/test_handle_scope`);
 
 testHandleScope.NewScope();
 
@@ -12,8 +13,8 @@ assert.ok(testHandleScope.NewScopeEscape() instanceof Object);
 
 testHandleScope.NewScopeEscapeTwice();
 
-assert.throws(
-  () => {
-    testHandleScope.NewScopeWithException(() => { throw new RangeError(); });
-  },
-  RangeError);
+assert.throws(() => {
+  testHandleScope.NewScopeWithException(() => {
+    throw new RangeError();
+  });
+}, RangeError);
diff --git a/test/addons-napi/test_make_callback/test-async-hooks.js b/test/addons-napi/test_make_callback/test-async-hooks.js
index 755a2389c68591..def05c7e69797f 100644
--- a/test/addons-napi/test_make_callback/test-async-hooks.js
+++ b/test/addons-napi/test_make_callback/test-async-hooks.js
@@ -12,7 +12,7 @@ const hook_result = {
   init_called: false,
   before_called: false,
   after_called: false,
-  destroy_called: false,
+  destroy_called: false
 };
 const test_hook = async_hooks.createHook({
   init: (id, type) => {
@@ -29,7 +29,7 @@ const test_hook = async_hooks.createHook({
   },
   destroy: (id) => {
     if (id === hook_result.id) hook_result.destroy_called = true;
-  },
+  }
 });
 
 test_hook.enable();
diff --git a/test/addons-napi/test_make_callback/test.js b/test/addons-napi/test_make_callback/test.js
index f409bbc9d127d6..ea09f58fd0208e 100644
--- a/test/addons-napi/test_make_callback/test.js
+++ b/test/addons-napi/test_make_callback/test.js
@@ -13,21 +13,36 @@ function myMultiArgFunc(arg1, arg2, arg3) {
   return 42;
 }
 
-assert.strictEqual(makeCallback(process, common.mustCall(function() {
-  assert.strictEqual(arguments.length, 0);
-  assert.strictEqual(this, process);
-  return 42;
-})), 42);
+assert.strictEqual(
+  makeCallback(
+    process,
+    common.mustCall(function() {
+      assert.strictEqual(arguments.length, 0);
+      assert.strictEqual(this, process);
+      return 42;
+    })
+  ),
+  42
+);
 
-assert.strictEqual(makeCallback(process, common.mustCall(function(x) {
-  assert.strictEqual(arguments.length, 1);
-  assert.strictEqual(this, process);
-  assert.strictEqual(x, 1337);
-  return 42;
-}), 1337), 42);
+assert.strictEqual(
+  makeCallback(
+    process,
+    common.mustCall(function(x) {
+      assert.strictEqual(arguments.length, 1);
+      assert.strictEqual(this, process);
+      assert.strictEqual(x, 1337);
+      return 42;
+    }),
+    1337
+  ),
+  42
+);
 
-assert.strictEqual(makeCallback(this,
-                                common.mustCall(myMultiArgFunc), 1, 2, 3), 42);
+assert.strictEqual(
+  makeCallback(this, common.mustCall(myMultiArgFunc), 1, 2, 3),
+  42
+);
 
 // TODO(node-api): napi_make_callback needs to support
 // strings passed for the func argument
@@ -73,8 +88,7 @@ const forward = vm.runInNewContext(`
 
 // Runs in outer context.
 function endpoint($Object) {
-  if (Object === $Object)
-    throw new Error('bad');
+  if (Object === $Object) throw new Error('bad');
   return Object;
 }
 
diff --git a/test/addons-napi/test_make_callback_recurse/test.js b/test/addons-napi/test_make_callback_recurse/test.js
index f948103de1f4ec..4ca490390b89bb 100644
--- a/test/addons-napi/test_make_callback_recurse/test.js
+++ b/test/addons-napi/test_make_callback_recurse/test.js
@@ -9,7 +9,6 @@ const makeCallback = binding.makeCallback;
 // Make sure this is run in the future.
 const mustCallCheckDomains = common.mustCall(checkDomains);
 
-
 // Make sure that using MakeCallback allows the error to propagate.
 assert.throws(function() {
   makeCallback({}, function() {
@@ -17,7 +16,6 @@ assert.throws(function() {
   });
 }, /^Error: hi from domain error$/);
 
-
 // Check the execution order of the nextTickQueue and MicrotaskQueue in
 // relation to running multiple MakeCallback's from bootstrap,
 // node::MakeCallback() and node::AsyncWrap::MakeCallback().
@@ -28,116 +26,164 @@ assert.throws(function() {
 
   // Processing of the MicrotaskQueue is manually handled by node. They are not
   // processed until after the nextTickQueue has been processed.
-  Promise.resolve(1).then(common.mustCall(function() {
-    results.push(7);
-  }));
+  Promise.resolve(1).then(
+    common.mustCall(function() {
+      results.push(7);
+    })
+  );
 
   // The nextTick should run after all immediately invoked calls.
-  process.nextTick(common.mustCall(function() {
-    results.push(3);
-
-    // Run same test again but while processing the nextTickQueue to make sure
-    // the following MakeCallback call breaks in the middle of processing the
-    // queue and allows the script to run normally.
-    process.nextTick(common.mustCall(function() {
-      results.push(6);
-    }));
-
-    makeCallback({}, common.mustCall(function() {
-      results.push(4);
-    }));
-
-    results.push(5);
-  }));
+  process.nextTick(
+    common.mustCall(function() {
+      results.push(3);
+
+      // Run same test again but while processing the nextTickQueue to make sure
+      // the following MakeCallback call breaks in the middle of processing the
+      // queue and allows the script to run normally.
+      process.nextTick(
+        common.mustCall(function() {
+          results.push(6);
+        })
+      );
+
+      makeCallback(
+        {},
+        common.mustCall(function() {
+          results.push(4);
+        })
+      );
+
+      results.push(5);
+    })
+  );
 
   results.push(0);
 
   // MakeCallback is calling the function immediately, but should then detect
   // that a script is already in the middle of execution and return before
   // either the nextTickQueue or MicrotaskQueue are processed.
-  makeCallback({}, common.mustCall(function() {
-    results.push(1);
-  }));
+  makeCallback(
+    {},
+    common.mustCall(function() {
+      results.push(1);
+    })
+  );
 
   // This should run before either the nextTickQueue or MicrotaskQueue are
   // processed. Previously MakeCallback would not detect this circumstance
   // and process them immediately.
   results.push(2);
 
-  setImmediate(common.mustCall(function() {
-    for (let i = 0; i < results.length; i++) {
-      assert.strictEqual(results[i], i,
-                         `verifyExecutionOrder(${arg}) results: ${results}`);
-    }
-    if (arg === 1) {
-      // The tests are first run on bootstrap during LoadEnvironment() in
-      // src/node.cc. Now run the tests through node::MakeCallback().
-      setImmediate(function() {
-        makeCallback({}, common.mustCall(function() {
-          verifyExecutionOrder(2);
-        }));
-      });
-    } else if (arg === 2) {
-      // Make sure there are no conflicts using node::MakeCallback()
-      // within timers.
-      setTimeout(common.mustCall(function() {
-        verifyExecutionOrder(3);
-      }), 10);
-    } else if (arg === 3) {
-      mustCallCheckDomains();
-    } else {
-      throw new Error('UNREACHABLE');
-    }
-  }));
-}(1));
-
+  setImmediate(
+    common.mustCall(function() {
+      for (let i = 0; i < results.length; i++) {
+        assert.strictEqual(
+          results[i],
+          i,
+          `verifyExecutionOrder(${arg}) results: ${results}`
+        );
+      }
+      if (arg === 1) {
+        // The tests are first run on bootstrap during LoadEnvironment() in
+        // src/node.cc. Now run the tests through node::MakeCallback().
+        setImmediate(function() {
+          makeCallback(
+            {},
+            common.mustCall(function() {
+              verifyExecutionOrder(2);
+            })
+          );
+        });
+      } else if (arg === 2) {
+        // Make sure there are no conflicts using node::MakeCallback()
+        // within timers.
+        setTimeout(
+          common.mustCall(function() {
+            verifyExecutionOrder(3);
+          }),
+          10
+        );
+      } else if (arg === 3) {
+        mustCallCheckDomains();
+      } else {
+        throw new Error('UNREACHABLE');
+      }
+    })
+  );
+})(1);
 
 function checkDomains() {
   // Check that domains are properly entered/exited when called in multiple
   // levels from both node::MakeCallback() and AsyncWrap::MakeCallback
-  setImmediate(common.mustCall(function() {
-    const d1 = domain.create();
-    const d2 = domain.create();
-    const d3 = domain.create();
-
-    makeCallback({ domain: d1 }, common.mustCall(function() {
-      assert.strictEqual(d1, process.domain);
-      makeCallback({ domain: d2 }, common.mustCall(function() {
-        assert.strictEqual(d2, process.domain);
-        makeCallback({ domain: d3 }, common.mustCall(function() {
-          assert.strictEqual(d3, process.domain);
-        }));
-        assert.strictEqual(d2, process.domain);
-      }));
-      assert.strictEqual(d1, process.domain);
-    }));
-  }));
-
-  setTimeout(common.mustCall(function() {
-    const d1 = domain.create();
-    const d2 = domain.create();
-    const d3 = domain.create();
-
-    makeCallback({ domain: d1 }, common.mustCall(function() {
-      assert.strictEqual(d1, process.domain);
-      makeCallback({ domain: d2 }, common.mustCall(function() {
-        assert.strictEqual(d2, process.domain);
-        makeCallback({ domain: d3 }, common.mustCall(function() {
-          assert.strictEqual(d3, process.domain);
-        }));
-        assert.strictEqual(d2, process.domain);
-      }));
-      assert.strictEqual(d1, process.domain);
-    }));
-  }), 1);
+  setImmediate(
+    common.mustCall(function() {
+      const d1 = domain.create();
+      const d2 = domain.create();
+      const d3 = domain.create();
+
+      makeCallback(
+        { domain: d1 },
+        common.mustCall(function() {
+          assert.strictEqual(d1, process.domain);
+          makeCallback(
+            { domain: d2 },
+            common.mustCall(function() {
+              assert.strictEqual(d2, process.domain);
+              makeCallback(
+                { domain: d3 },
+                common.mustCall(function() {
+                  assert.strictEqual(d3, process.domain);
+                })
+              );
+              assert.strictEqual(d2, process.domain);
+            })
+          );
+          assert.strictEqual(d1, process.domain);
+        })
+      );
+    })
+  );
+
+  setTimeout(
+    common.mustCall(function() {
+      const d1 = domain.create();
+      const d2 = domain.create();
+      const d3 = domain.create();
+
+      makeCallback(
+        { domain: d1 },
+        common.mustCall(function() {
+          assert.strictEqual(d1, process.domain);
+          makeCallback(
+            { domain: d2 },
+            common.mustCall(function() {
+              assert.strictEqual(d2, process.domain);
+              makeCallback(
+                { domain: d3 },
+                common.mustCall(function() {
+                  assert.strictEqual(d3, process.domain);
+                })
+              );
+              assert.strictEqual(d2, process.domain);
+            })
+          );
+          assert.strictEqual(d1, process.domain);
+        })
+      );
+    }),
+    1
+  );
 
   function testTimer(id) {
     // Make sure nextTick, setImmediate and setTimeout can all recover properly
     // after a thrown makeCallback call.
     const d = domain.create();
-    d.on('error', common.mustCall(function(e) {
-      assert.strictEqual(e.message, `throw from domain ${id}`);
-    }));
+    d.on(
+      'error',
+      common.mustCall(function(e) {
+        assert.strictEqual(e.message, `throw from domain ${id}`);
+      })
+    );
     makeCallback({ domain: d }, function() {
       throw new Error(`throw from domain ${id}`);
     });
diff --git a/test/addons-napi/test_new_target/test.js b/test/addons-napi/test_new_target/test.js
index 702e8ca8b4387d..7849d1f4f813b9 100644
--- a/test/addons-napi/test_new_target/test.js
+++ b/test/addons-napi/test_new_target/test.js
@@ -18,4 +18,5 @@ assert.ok(new Class() instanceof binding.BaseClass);
 assert.ok(new Class().ok);
 assert.ok(binding.OrdinaryFunction());
 assert.ok(
-  new binding.Constructor(binding.Constructor) instanceof binding.Constructor);
+  new binding.Constructor(binding.Constructor) instanceof binding.Constructor
+);
diff --git a/test/addons-napi/test_null_init/test.js b/test/addons-napi/test_null_init/test.js
index 6e6bf51839bed0..ebbf6e2c9b8ca9 100644
--- a/test/addons-napi/test_null_init/test.js
+++ b/test/addons-napi/test_null_init/test.js
@@ -4,4 +4,5 @@ const assert = require('assert');
 
 assert.throws(
   () => require(`./build/${common.buildType}/test_null_init`),
-  /Module has no declared entry point[.]/);
+  /Module has no declared entry point[.]/
+);
diff --git a/test/addons-napi/test_number/test.js b/test/addons-napi/test_number/test.js
index 34f48aee578ac6..06a34fee4b6cd2 100644
--- a/test/addons-napi/test_number/test.js
+++ b/test/addons-napi/test_number/test.js
@@ -3,7 +3,6 @@ const common = require('../../common');
 const assert = require('assert');
 const test_number = require(`./build/${common.buildType}/test_number`);
 
-
 // testing api calls for number
 function testNumber(num) {
   assert.strictEqual(num, test_number.Test(num));
@@ -19,10 +18,8 @@ testNumber(-1233);
 testNumber(986583);
 testNumber(-976675);
 
-testNumber(
-  98765432213456789876546896323445679887645323232436587988766545658);
-testNumber(
-  -4350987086545760976737453646576078997096876957864353245245769809);
+testNumber(98765432213456789876546896323445679887645323232436587988766545658);
+testNumber(-4350987086545760976737453646576078997096876957864353245245769809);
 testNumber(Number.MIN_SAFE_INTEGER);
 testNumber(Number.MAX_SAFE_INTEGER);
 testNumber(Number.MAX_SAFE_INTEGER + 10);
@@ -84,8 +81,8 @@ testInt32(-Number.MAX_VALUE, 0);
 testInt32(Number.MAX_VALUE, 0);
 
 // Test outside int64_t range
-testInt32(-Math.pow(2, 63) + (Math.pow(2, 9)), 0);
-testInt32(Math.pow(2, 63) - (Math.pow(2, 9)), 0);
+testInt32(-Math.pow(2, 63) + Math.pow(2, 9), 0);
+testInt32(Math.pow(2, 63) - Math.pow(2, 9), 0);
 
 // Test non-finite numbers
 testInt32(Number.POSITIVE_INFINITY, 0);
@@ -122,8 +119,8 @@ testInt64(-Number.MAX_VALUE, RANGEERROR_NEGATIVE);
 testInt64(Number.MAX_VALUE, RANGEERROR_POSITIVE);
 
 // Test outside int64_t range
-testInt64(-Math.pow(2, 63) + (Math.pow(2, 9)), RANGEERROR_NEGATIVE);
-testInt64(Math.pow(2, 63) - (Math.pow(2, 9)), RANGEERROR_POSITIVE);
+testInt64(-Math.pow(2, 63) + Math.pow(2, 9), RANGEERROR_NEGATIVE);
+testInt64(Math.pow(2, 63) - Math.pow(2, 9), RANGEERROR_POSITIVE);
 
 // Test non-finite numbers
 testInt64(Number.POSITIVE_INFINITY, 0);
diff --git a/test/addons-napi/test_object/test.js b/test/addons-napi/test_object/test.js
index 8e44a1b5ed647f..4920322970ce7f 100644
--- a/test/addons-napi/test_object/test.js
+++ b/test/addons-napi/test_object/test.js
@@ -5,22 +5,25 @@ const assert = require('assert');
 // Testing api calls for objects
 const test_object = require(`./build/${common.buildType}/test_object`);
 
-
 const object = {
   hello: 'world',
-  array: [
-    1, 94, 'str', 12.321, { test: 'obj in arr' }
-  ],
+  array: [1, 94, 'str', 12.321, { test: 'obj in arr' }],
   newObject: {
     test: 'obj in obj'
   }
 };
 
 assert.strictEqual(test_object.Get(object, 'hello'), 'world');
-assert.deepStrictEqual(test_object.Get(object, 'array'),
-                       [ 1, 94, 'str', 12.321, { test: 'obj in arr' } ]);
-assert.deepStrictEqual(test_object.Get(object, 'newObject'),
-                       { test: 'obj in obj' });
+assert.deepStrictEqual(test_object.Get(object, 'array'), [
+  1,
+  94,
+  'str',
+  12.321,
+  { test: 'obj in arr' }
+]);
+assert.deepStrictEqual(test_object.Get(object, 'newObject'), {
+  test: 'obj in obj'
+});
 
 assert(test_object.Has(object, 'hello'));
 assert(test_object.Has(object, 'array'));
@@ -46,8 +49,10 @@ assert.strictEqual(newObject.test_string, 'test string');
   assert.strictEqual(test_object.Get(obj, 'foo'), 42);
   assert.strictEqual(test_object.Get(obj, 'bar'), 43);
   assert.strictEqual(test_object.Get(obj, 'baz'), 45);
-  assert.strictEqual(test_object.Get(obj, 'toString'),
-                     Object.prototype.toString);
+  assert.strictEqual(
+    test_object.Get(obj, 'toString'),
+    Object.prototype.toString
+  );
 }
 
 {
@@ -96,8 +101,12 @@ assert.strictEqual(newObject.test_string, 'test string');
   assert.deepStrictEqual(test_object.Inflate(cube), { x: 12, y: 12, z: 12 });
   assert.deepStrictEqual(test_object.Inflate(cube), { x: 13, y: 13, z: 13 });
   cube.t = 13;
-  assert.deepStrictEqual(
-    test_object.Inflate(cube), { x: 14, y: 14, z: 14, t: 14 });
+  assert.deepStrictEqual(test_object.Inflate(cube), {
+    x: 14,
+    y: 14,
+    z: 14,
+    t: 14
+  });
 
   const sym1 = Symbol('1');
   const sym2 = Symbol('2');
diff --git a/test/addons-napi/test_promise/test.js b/test/addons-napi/test_promise/test.js
index feaa4ebfef688a..ae92136b2e6ac3 100644
--- a/test/addons-napi/test_promise/test.js
+++ b/test/addons-napi/test_promise/test.js
@@ -15,19 +15,21 @@ const test_promise = require(`./build/${common.buildType}/test_promise`);
     common.mustCall(function(result) {
       assert.strictEqual(result, expected_result);
     }),
-    common.mustNotCall());
+    common.mustNotCall()
+  );
   test_promise.concludeCurrentPromise(expected_result, true);
 }
 
 // A rejection
 {
-  const expected_result = 'It\'s not you, it\'s me.';
+  const expected_result = "It's not you, it's me.";
   const promise = test_promise.createPromise();
   promise.then(
     common.mustNotCall(),
     common.mustCall(function(result) {
       assert.strictEqual(result, expected_result);
-    }));
+    })
+  );
   test_promise.concludeCurrentPromise(expected_result, false);
 }
 
@@ -39,7 +41,8 @@ const test_promise = require(`./build/${common.buildType}/test_promise`);
     common.mustCall(function(result) {
       assert.strictEqual(result, expected_result);
     }),
-    common.mustNotCall());
+    common.mustNotCall()
+  );
   test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true);
 }
 
diff --git a/test/addons-napi/test_properties/test.js b/test/addons-napi/test_properties/test.js
index 13a546c7b87f81..baff489895ddd4 100644
--- a/test/addons-napi/test_properties/test.js
+++ b/test/addons-napi/test_properties/test.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../../common');
 const assert = require('assert');
-const readonlyErrorRE =
-  /^TypeError: Cannot assign to read only property '.*' of object '#<Object>'$/;
+const readonlyErrorRE = /^TypeError: Cannot assign to read only property '.*' of object '#<Object>'$/;
 
 // Testing api calls for defining properties
 const test_object = require(`./build/${common.buildType}/test_properties`);
@@ -14,7 +13,9 @@ assert.strictEqual(test_object.readwriteValue, 1);
 test_object.readwriteValue = 2;
 assert.strictEqual(test_object.readwriteValue, 2);
 
-assert.throws(() => { test_object.readonlyValue = 3; }, readonlyErrorRE);
+assert.throws(() => {
+  test_object.readonlyValue = 3;
+}, readonlyErrorRE);
 
 assert.ok(test_object.hiddenValue);
 
@@ -36,22 +37,31 @@ assert.ok(!propertyNames.includes('readonlyAccessor2'));
 // validate property created with symbol
 const start = 'Symbol('.length;
 const end = start + 'NameKeySymbol'.length;
-const symbolDescription =
-    String(Object.getOwnPropertySymbols(test_object)[0]).slice(start, end);
+const symbolDescription = String(
+  Object.getOwnPropertySymbols(test_object)[0]
+).slice(start, end);
 assert.strictEqual(symbolDescription, 'NameKeySymbol');
 
 // The napi_writable attribute should be ignored for accessors.
 test_object.readwriteAccessor1 = 1;
 assert.strictEqual(test_object.readwriteAccessor1, 1);
 assert.strictEqual(test_object.readonlyAccessor1, 1);
-assert.throws(() => { test_object.readonlyAccessor1 = 3; }, readonlyErrorRE);
+assert.throws(() => {
+  test_object.readonlyAccessor1 = 3;
+}, readonlyErrorRE);
 test_object.readwriteAccessor2 = 2;
 assert.strictEqual(test_object.readwriteAccessor2, 2);
 assert.strictEqual(test_object.readonlyAccessor2, 2);
-assert.throws(() => { test_object.readonlyAccessor2 = 3; }, readonlyErrorRE);
+assert.throws(() => {
+  test_object.readonlyAccessor2 = 3;
+}, readonlyErrorRE);
 
 assert.strictEqual(test_object.hasNamedProperty(test_object, 'echo'), true);
-assert.strictEqual(test_object.hasNamedProperty(test_object, 'hiddenValue'),
-                   true);
-assert.strictEqual(test_object.hasNamedProperty(test_object, 'doesnotexist'),
-                   false);
+assert.strictEqual(
+  test_object.hasNamedProperty(test_object, 'hiddenValue'),
+  true
+);
+assert.strictEqual(
+  test_object.hasNamedProperty(test_object, 'doesnotexist'),
+  false
+);
diff --git a/test/addons-napi/test_reference/test.js b/test/addons-napi/test_reference/test.js
index 14932a74ca70b0..c052732d7cfca3 100644
--- a/test/addons-napi/test_reference/test.js
+++ b/test/addons-napi/test_reference/test.js
@@ -33,7 +33,6 @@ function runTests(i, title, tests) {
   }
 }
 runTests(0, undefined, [
-
   'External value without a finalizer',
   () => {
     const value = test_reference.createExternal();
@@ -116,5 +115,5 @@ runTests(0, undefined, [
   () => {
     // Value was already GC'd
     assert.strictEqual(test_reference.finalizeCount, 1);
-  },
+  }
 ]);
diff --git a/test/addons-napi/test_symbol/test3.js b/test/addons-napi/test_symbol/test3.js
index a7c6c18c025480..03f1d4759f6a53 100644
--- a/test/addons-napi/test_symbol/test3.js
+++ b/test/addons-napi/test_symbol/test3.js
@@ -13,7 +13,7 @@ const foo1 = test_symbol.New('foo');
 const foo2 = test_symbol.New('foo');
 const object = {
   [foo1]: 1,
-  [foo2]: 2,
+  [foo2]: 2
 };
 assert.strictEqual(object[foo1], 1);
 assert.strictEqual(object[foo2], 2);
diff --git a/test/addons-napi/test_threadsafe_function/test.js b/test/addons-napi/test_threadsafe_function/test.js
index cfd00285308f5d..cdff346f2070f9 100644
--- a/test/addons-napi/test_threadsafe_function/test.js
+++ b/test/addons-napi/test_threadsafe_function/test.js
@@ -17,13 +17,18 @@ const expectedArray = (function(arrayLength) {
 // process to exit and the environment cleanup handler to be invoked.
 if (process.argv[2] === 'child') {
   let callCount = 0;
-  binding.StartThread((value) => {
-    callCount++;
-    console.log(value);
-    if (callCount === 2) {
-      binding.Unref();
-    }
-  }, false /* abort */, true /* launchSecondary */, +process.argv[3]);
+  binding.StartThread(
+    (value) => {
+      callCount++;
+      console.log(value);
+      if (callCount === 2) {
+        binding.Unref();
+      }
+    },
+    false /* abort */,
+    true /* launchSecondary */,
+    +process.argv[3]
+  );
 
   // Release the thread-safe function from the main thread so that it may be
   // torn down via the environment cleanup handler.
@@ -36,19 +41,28 @@ function testWithJSMarshaller({
   quitAfter,
   abort,
   maxQueueSize,
-  launchSecondary }) {
+  launchSecondary
+}) {
   return new Promise((resolve) => {
     const array = [];
-    binding[threadStarter](function testCallback(value) {
-      array.push(value);
-      if (array.length === quitAfter) {
-        setImmediate(() => {
-          binding.StopThread(common.mustCall(() => {
-            resolve(array);
-          }), !!abort);
-        });
-      }
-    }, !!abort, !!launchSecondary, maxQueueSize);
+    binding[threadStarter](
+      function testCallback(value) {
+        array.push(value);
+        if (array.length === quitAfter) {
+          setImmediate(() => {
+            binding.StopThread(
+              common.mustCall(() => {
+                resolve(array);
+              }),
+              !!abort
+            );
+          });
+        }
+      },
+      !!abort,
+      !!launchSecondary,
+      maxQueueSize
+    );
     if (threadStarter === 'StartThreadNonblocking') {
       // Let's make this thread really busy for a short while to ensure that
       // the queue fills and the thread receives a napi_queue_full.
@@ -72,135 +86,164 @@ function testUnref(queueSize) {
       }
     });
     child.stdout.on('data', (data) => (output += data.toString()));
-  })
-  .then((result) => assert.strictEqual(result.indexOf(0), -1));
+  }).then((result) => assert.strictEqual(result.indexOf(0), -1));
 }
 
 new Promise(function testWithoutJSMarshaller(resolve) {
   let callCount = 0;
-  binding.StartThreadNoNative(function testCallback() {
-    callCount++;
-
-    // The default call-into-JS implementation passes no arguments.
-    assert.strictEqual(arguments.length, 0);
-    if (callCount === binding.ARRAY_LENGTH) {
-      setImmediate(() => {
-        binding.StopThread(common.mustCall(() => {
-          resolve();
-        }), false);
-      });
-    }
-  }, false /* abort */, false /* launchSecondary */, binding.MAX_QUEUE_SIZE);
+  binding.StartThreadNoNative(
+    function testCallback() {
+      callCount++;
+
+      // The default call-into-JS implementation passes no arguments.
+      assert.strictEqual(arguments.length, 0);
+      if (callCount === binding.ARRAY_LENGTH) {
+        setImmediate(() => {
+          binding.StopThread(
+            common.mustCall(() => {
+              resolve();
+            }),
+            false
+          );
+        });
+      }
+    },
+    false /* abort */,
+    false /* launchSecondary */,
+    binding.MAX_QUEUE_SIZE
+  );
 })
 
-// Start the thread in blocking mode, and assert that all values are passed.
-// Quit after it's done.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThread',
-  maxQueueSize: binding.MAX_QUEUE_SIZE,
-  quitAfter: binding.ARRAY_LENGTH
-}))
-.then((result) => assert.deepStrictEqual(result, expectedArray))
-
-// Start the thread in blocking mode with an infinite queue, and assert that all
-// values are passed. Quit after it's done.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThread',
-  maxQueueSize: 0,
-  quitAfter: binding.ARRAY_LENGTH
-}))
-.then((result) => assert.deepStrictEqual(result, expectedArray))
-
-// Start the thread in non-blocking mode, and assert that all values are passed.
-// Quit after it's done.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThreadNonblocking',
-  maxQueueSize: binding.MAX_QUEUE_SIZE,
-  quitAfter: binding.ARRAY_LENGTH
-}))
-.then((result) => assert.deepStrictEqual(result, expectedArray))
-
-// Start the thread in blocking mode, and assert that all values are passed.
-// Quit early, but let the thread finish.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThread',
-  maxQueueSize: binding.MAX_QUEUE_SIZE,
-  quitAfter: 1
-}))
-.then((result) => assert.deepStrictEqual(result, expectedArray))
-
-// Start the thread in blocking mode with an infinite queue, and assert that all
-// values are passed. Quit early, but let the thread finish.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThread',
-  maxQueueSize: 0,
-  quitAfter: 1
-}))
-.then((result) => assert.deepStrictEqual(result, expectedArray))
-
-// Start the thread in non-blocking mode, and assert that all values are passed.
-// Quit early, but let the thread finish.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThreadNonblocking',
-  maxQueueSize: binding.MAX_QUEUE_SIZE,
-  quitAfter: 1
-}))
-.then((result) => assert.deepStrictEqual(result, expectedArray))
-
-// Start the thread in blocking mode, and assert that all values are passed.
-// Quit early, but let the thread finish. Launch a secondary thread to test the
-// reference counter incrementing functionality.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThread',
-  quitAfter: 1,
-  maxQueueSize: binding.MAX_QUEUE_SIZE,
-  launchSecondary: true
-}))
-.then((result) => assert.deepStrictEqual(result, expectedArray))
-
-// Start the thread in non-blocking mode, and assert that all values are passed.
-// Quit early, but let the thread finish. Launch a secondary thread to test the
-// reference counter incrementing functionality.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThreadNonblocking',
-  quitAfter: 1,
-  maxQueueSize: binding.MAX_QUEUE_SIZE,
-  launchSecondary: true
-}))
-.then((result) => assert.deepStrictEqual(result, expectedArray))
-
-// Start the thread in blocking mode, and assert that it could not finish.
-// Quit early by aborting.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThread',
-  quitAfter: 1,
-  maxQueueSize: binding.MAX_QUEUE_SIZE,
-  abort: true
-}))
-.then((result) => assert.strictEqual(result.indexOf(0), -1))
-
-// Start the thread in blocking mode with an infinite queue, and assert that it
-// could not finish. Quit early by aborting.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThread',
-  quitAfter: 1,
-  maxQueueSize: 0,
-  abort: true
-}))
-.then((result) => assert.strictEqual(result.indexOf(0), -1))
-
-// Start the thread in non-blocking mode, and assert that it could not finish.
-// Quit early and aborting.
-.then(() => testWithJSMarshaller({
-  threadStarter: 'StartThreadNonblocking',
-  quitAfter: 1,
-  maxQueueSize: binding.MAX_QUEUE_SIZE,
-  abort: true
-}))
-.then((result) => assert.strictEqual(result.indexOf(0), -1))
-
-// Start a child process to test rapid teardown
-.then(() => testUnref(binding.MAX_QUEUE_SIZE))
-
-// Start a child process with an infinite queue to test rapid teardown
-.then(() => testUnref(0));
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit after it's done.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThread',
+      maxQueueSize: binding.MAX_QUEUE_SIZE,
+      quitAfter: binding.ARRAY_LENGTH
+    })
+  )
+  .then((result) => assert.deepStrictEqual(result, expectedArray))
+
+  // Start the thread in blocking mode with an infinite queue, and assert that all
+  // values are passed. Quit after it's done.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThread',
+      maxQueueSize: 0,
+      quitAfter: binding.ARRAY_LENGTH
+    })
+  )
+  .then((result) => assert.deepStrictEqual(result, expectedArray))
+
+  // Start the thread in non-blocking mode, and assert that all values are passed.
+  // Quit after it's done.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThreadNonblocking',
+      maxQueueSize: binding.MAX_QUEUE_SIZE,
+      quitAfter: binding.ARRAY_LENGTH
+    })
+  )
+  .then((result) => assert.deepStrictEqual(result, expectedArray))
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThread',
+      maxQueueSize: binding.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    })
+  )
+  .then((result) => assert.deepStrictEqual(result, expectedArray))
+
+  // Start the thread in blocking mode with an infinite queue, and assert that all
+  // values are passed. Quit early, but let the thread finish.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThread',
+      maxQueueSize: 0,
+      quitAfter: 1
+    })
+  )
+  .then((result) => assert.deepStrictEqual(result, expectedArray))
+
+  // Start the thread in non-blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThreadNonblocking',
+      maxQueueSize: binding.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    })
+  )
+  .then((result) => assert.deepStrictEqual(result, expectedArray))
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish. Launch a secondary thread to test the
+  // reference counter incrementing functionality.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThread',
+      quitAfter: 1,
+      maxQueueSize: binding.MAX_QUEUE_SIZE,
+      launchSecondary: true
+    })
+  )
+  .then((result) => assert.deepStrictEqual(result, expectedArray))
+
+  // Start the thread in non-blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish. Launch a secondary thread to test the
+  // reference counter incrementing functionality.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThreadNonblocking',
+      quitAfter: 1,
+      maxQueueSize: binding.MAX_QUEUE_SIZE,
+      launchSecondary: true
+    })
+  )
+  .then((result) => assert.deepStrictEqual(result, expectedArray))
+
+  // Start the thread in blocking mode, and assert that it could not finish.
+  // Quit early by aborting.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThread',
+      quitAfter: 1,
+      maxQueueSize: binding.MAX_QUEUE_SIZE,
+      abort: true
+    })
+  )
+  .then((result) => assert.strictEqual(result.indexOf(0), -1))
+
+  // Start the thread in blocking mode with an infinite queue, and assert that it
+  // could not finish. Quit early by aborting.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThread',
+      quitAfter: 1,
+      maxQueueSize: 0,
+      abort: true
+    })
+  )
+  .then((result) => assert.strictEqual(result.indexOf(0), -1))
+
+  // Start the thread in non-blocking mode, and assert that it could not finish.
+  // Quit early and aborting.
+  .then(() =>
+    testWithJSMarshaller({
+      threadStarter: 'StartThreadNonblocking',
+      quitAfter: 1,
+      maxQueueSize: binding.MAX_QUEUE_SIZE,
+      abort: true
+    })
+  )
+  .then((result) => assert.strictEqual(result.indexOf(0), -1))
+
+  // Start a child process to test rapid teardown
+  .then(() => testUnref(binding.MAX_QUEUE_SIZE))
+
+  // Start a child process with an infinite queue to test rapid teardown
+  .then(() => testUnref(0));
diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
index 2a8cf18feb866c..7c2eee345b4154 100644
--- a/test/addons-napi/test_typedarray/test.js
+++ b/test/addons-napi/test_typedarray/test.js
@@ -40,18 +40,30 @@ assert.strictEqual(externalResult[2], 2);
 
 // validate creation of all kinds of TypedArrays
 const buffer = new ArrayBuffer(128);
-const arrayTypes = [ Int8Array, Uint8Array, Uint8ClampedArray, Int16Array,
-                     Uint16Array, Int32Array, Uint32Array, Float32Array,
-                     Float64Array, BigInt64Array, BigUint64Array ];
+const arrayTypes = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array
+];
 
 arrayTypes.forEach((currentType) => {
   const template = Reflect.construct(currentType, buffer);
   const theArray = test_typedarray.CreateTypedArray(template, buffer);
 
-  assert.ok(theArray instanceof currentType,
-            'Type of new array should match that of the template. ' +
-            `Expected type: ${currentType.name}, ` +
-            `actual type: ${template.constructor.name}`);
+  assert.ok(
+    theArray instanceof currentType,
+    'Type of new array should match that of the template. ' +
+      `Expected type: ${currentType.name}, ` +
+      `actual type: ${template.constructor.name}`
+  );
   assert.notStrictEqual(theArray, template);
   assert.strictEqual(theArray.buffer, buffer);
 });
@@ -63,14 +75,25 @@ arrayTypes.forEach((currentType) => {
   }, RangeError);
 });
 
-const nonByteArrayTypes = [ Int16Array, Uint16Array, Int32Array, Uint32Array,
-                            Float32Array, Float64Array,
-                            BigInt64Array, BigUint64Array ];
+const nonByteArrayTypes = [
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array
+];
 nonByteArrayTypes.forEach((currentType) => {
   const template = Reflect.construct(currentType, buffer);
   assert.throws(() => {
-    test_typedarray.CreateTypedArray(template, buffer,
-                                     currentType.BYTES_PER_ELEMENT + 1, 1);
+    test_typedarray.CreateTypedArray(
+      template,
+      buffer,
+      currentType.BYTES_PER_ELEMENT + 1,
+      1
+    );
     console.log(`start of offset ${currentType}`);
   }, RangeError);
 });
diff --git a/test/addons/async-hello-world/test-makecallback-uncaught.js b/test/addons/async-hello-world/test-makecallback-uncaught.js
index c207f535bee6eb..a7f73a73726e75 100644
--- a/test/addons/async-hello-world/test-makecallback-uncaught.js
+++ b/test/addons/async-hello-world/test-makecallback-uncaught.js
@@ -4,6 +4,9 @@ const { runMakeCallback } = require(`./build/${common.buildType}/binding`);
 
 process.on('uncaughtException', common.mustCall());
 
-runMakeCallback(5, common.mustCall(() => {
-  throw new Error('foo');
-}));
+runMakeCallback(
+  5,
+  common.mustCall(() => {
+    throw new Error('foo');
+  })
+);
diff --git a/test/addons/async-hello-world/test-makecallback.js b/test/addons/async-hello-world/test-makecallback.js
index 0edf052e8c34fc..1a9f8b8a2d86c0 100644
--- a/test/addons/async-hello-world/test-makecallback.js
+++ b/test/addons/async-hello-world/test-makecallback.js
@@ -3,8 +3,11 @@ const common = require('../../common');
 const assert = require('assert');
 const { runMakeCallback } = require(`./build/${common.buildType}/binding`);
 
-runMakeCallback(5, common.mustCall(function(err, val) {
-  assert.strictEqual(err, null);
-  assert.strictEqual(val, 10);
-  process.nextTick(common.mustCall());
-}));
+runMakeCallback(
+  5,
+  common.mustCall(function(err, val) {
+    assert.strictEqual(err, null);
+    assert.strictEqual(val, 10);
+    process.nextTick(common.mustCall());
+  })
+);
diff --git a/test/addons/async-hello-world/test.js b/test/addons/async-hello-world/test.js
index f24071087c0629..24295f74c46d56 100644
--- a/test/addons/async-hello-world/test.js
+++ b/test/addons/async-hello-world/test.js
@@ -3,8 +3,11 @@ const common = require('../../common');
 const assert = require('assert');
 const { runCall } = require(`./build/${common.buildType}/binding`);
 
-runCall(5, common.mustCall(function(err, val) {
-  assert.strictEqual(err, null);
-  assert.strictEqual(val, 10);
-  process.nextTick(common.mustCall());
-}));
+runCall(
+  5,
+  common.mustCall(function(err, val) {
+    assert.strictEqual(err, null);
+    assert.strictEqual(val, 10);
+    process.nextTick(common.mustCall());
+  })
+);
diff --git a/test/addons/async-hooks-id/test.js b/test/addons/async-hooks-id/test.js
index e6c3cf612cacd5..714c4ebfcb1d00 100644
--- a/test/addons/async-hooks-id/test.js
+++ b/test/addons/async-hooks-id/test.js
@@ -9,18 +9,17 @@ assert.strictEqual(
   binding.getExecutionAsyncId(),
   async_hooks.executionAsyncId()
 );
-assert.strictEqual(
-  binding.getTriggerAsyncId(),
-  async_hooks.triggerAsyncId()
-);
+assert.strictEqual(binding.getTriggerAsyncId(), async_hooks.triggerAsyncId());
 
-process.nextTick(common.mustCall(function() {
-  assert.strictEqual(
-    binding.getExecutionAsyncId(),
-    async_hooks.executionAsyncId()
-  );
-  assert.strictEqual(
-    binding.getTriggerAsyncId(),
-    async_hooks.triggerAsyncId()
-  );
-}));
+process.nextTick(
+  common.mustCall(function() {
+    assert.strictEqual(
+      binding.getExecutionAsyncId(),
+      async_hooks.executionAsyncId()
+    );
+    assert.strictEqual(
+      binding.getTriggerAsyncId(),
+      async_hooks.triggerAsyncId()
+    );
+  })
+);
diff --git a/test/addons/async-hooks-promise/test.js b/test/addons/async-hooks-promise/test.js
index a6c48e94a34f07..dbcd2c452d795d 100644
--- a/test/addons/async-hooks-promise/test.js
+++ b/test/addons/async-hooks-promise/test.js
@@ -11,30 +11,26 @@ if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) {
 }
 
 // Baseline to make sure the internal field isn't being set.
-assert.strictEqual(
-  binding.getPromiseField(Promise.resolve(1)),
-  0);
+assert.strictEqual(binding.getPromiseField(Promise.resolve(1)), 0);
 
 const hook0 = async_hooks.createHook({}).enable();
 
 // Check that no PromiseWrap is created when there are no hook callbacks.
-assert.strictEqual(
-  binding.getPromiseField(Promise.resolve(1)),
-  0);
+assert.strictEqual(binding.getPromiseField(Promise.resolve(1)), 0);
 
 hook0.disable();
 
 let pwrap = null;
-const hook1 = async_hooks.createHook({
-  init(id, type, tid, resource) {
-    pwrap = resource;
-  }
-}).enable();
+const hook1 = async_hooks
+  .createHook({
+    init(id, type, tid, resource) {
+      pwrap = resource;
+    }
+  })
+  .enable();
 
 // Check that the internal field returns the same PromiseWrap passed to init().
-assert.strictEqual(
-  binding.getPromiseField(Promise.resolve(1)),
-  pwrap);
+assert.strictEqual(binding.getPromiseField(Promise.resolve(1)), pwrap);
 
 hook1.disable();
 
@@ -42,7 +38,5 @@ hook1.disable();
 // a bit because the `disable()` call only schedules disabling the hook in a
 // future microtask.
 setImmediate(() => {
-  assert.strictEqual(
-    binding.getPromiseField(Promise.resolve(1)),
-    0);
+  assert.strictEqual(binding.getPromiseField(Promise.resolve(1)), 0);
 });
diff --git a/test/addons/async-resource/test.js b/test/addons/async-resource/test.js
index c37d4df83d0103..bb00dab035ec4d 100644
--- a/test/addons/async-resource/test.js
+++ b/test/addons/async-resource/test.js
@@ -16,34 +16,38 @@ let before = 0;
 let after = 0;
 let destroy = 0;
 
-async_hooks.createHook({
-  init(id, type, triggerAsyncId, resource) {
-    assert.strictEqual(typeof id, 'number');
-    assert.strictEqual(typeof resource, 'object');
-    assert(id > 1);
-    if (type === 'foobär') {
-      assert.strictEqual(resource.kObjectTag, kObjectTag);
-      assert.strictEqual(triggerAsyncId, expectedTriggerId);
-      bindingUids.push(id);
-    }
-  },
+async_hooks
+  .createHook({
+    init(id, type, triggerAsyncId, resource) {
+      assert.strictEqual(typeof id, 'number');
+      assert.strictEqual(typeof resource, 'object');
+      assert(id > 1);
+      if (type === 'foobär') {
+        assert.strictEqual(resource.kObjectTag, kObjectTag);
+        assert.strictEqual(triggerAsyncId, expectedTriggerId);
+        bindingUids.push(id);
+      }
+    },
 
-  before(id) {
-    if (bindingUids.includes(id)) before++;
-  },
+    before(id) {
+      if (bindingUids.includes(id)) before++;
+    },
 
-  after(id) {
-    if (bindingUids.includes(id)) after++;
-  },
+    after(id) {
+      if (bindingUids.includes(id)) after++;
+    },
 
-  destroy(id) {
-    if (bindingUids.includes(id)) destroy++;
-  }
-}).enable();
+    destroy(id) {
+      if (bindingUids.includes(id)) destroy++;
+    }
+  })
+  .enable();
 
-for (const call of [binding.callViaFunction,
-                    binding.callViaString,
-                    binding.callViaUtf8Name]) {
+for (const call of [
+  binding.callViaFunction,
+  binding.callViaString,
+  binding.callViaUtf8Name
+]) {
   for (const passedTriggerId of [undefined, 12345]) {
     let uid;
     const object = {
@@ -56,10 +60,8 @@ for (const call of [binding.callViaFunction,
       kObjectTag
     };
 
-    if (passedTriggerId === undefined)
-      expectedTriggerId = rootAsyncId;
-    else
-      expectedTriggerId = passedTriggerId;
+    if (passedTriggerId === undefined) expectedTriggerId = rootAsyncId;
+    else expectedTriggerId = passedTriggerId;
 
     const resource = binding.createAsyncResource(object, passedTriggerId);
     uid = bindingUids[bindingUids.length - 1];
@@ -74,9 +76,11 @@ for (const call of [binding.callViaFunction,
   }
 }
 
-setImmediate(common.mustCall(() => {
-  assert.strictEqual(bindingUids.length, 6);
-  assert.strictEqual(before, bindingUids.length);
-  assert.strictEqual(after, bindingUids.length);
-  assert.strictEqual(destroy, bindingUids.length);
-}));
+setImmediate(
+  common.mustCall(() => {
+    assert.strictEqual(bindingUids.length, 6);
+    assert.strictEqual(before, bindingUids.length);
+    assert.strictEqual(after, bindingUids.length);
+    assert.strictEqual(destroy, bindingUids.length);
+  })
+);
diff --git a/test/addons/callback-scope/test-async-hooks.js b/test/addons/callback-scope/test-async-hooks.js
index 94b53efc53d78e..e2d86a7d6fe453 100644
--- a/test/addons/callback-scope/test-async-hooks.js
+++ b/test/addons/callback-scope/test-async-hooks.js
@@ -6,16 +6,18 @@ const async_hooks = require('async_hooks');
 const { runInCallbackScope } = require(`./build/${common.buildType}/binding`);
 
 let insideHook = false;
-async_hooks.createHook({
-  before: common.mustCall((id) => {
-    assert.strictEqual(id, 1000);
-    insideHook = true;
-  }),
-  after: common.mustCall((id) => {
-    assert.strictEqual(id, 1000);
-    insideHook = false;
+async_hooks
+  .createHook({
+    before: common.mustCall((id) => {
+      assert.strictEqual(id, 1000);
+      insideHook = true;
+    }),
+    after: common.mustCall((id) => {
+      assert.strictEqual(id, 1000);
+      insideHook = false;
+    })
   })
-}).enable();
+  .enable();
 
 runInCallbackScope({}, 1000, 1000, () => {
   assert(insideHook);
diff --git a/test/addons/callback-scope/test-resolve-async.js b/test/addons/callback-scope/test-resolve-async.js
index c2942397737359..dbec805cd8164e 100644
--- a/test/addons/callback-scope/test-resolve-async.js
+++ b/test/addons/callback-scope/test-resolve-async.js
@@ -7,6 +7,10 @@ const { testResolveAsync } = require(`./build/${common.buildType}/binding`);
 // Checks that resolving promises from C++ works.
 
 let called = false;
-testResolveAsync().then(() => { called = true; });
+testResolveAsync().then(() => {
+  called = true;
+});
 
-process.on('beforeExit', () => { assert(called); });
+process.on('beforeExit', () => {
+  assert(called);
+});
diff --git a/test/addons/callback-scope/test.js b/test/addons/callback-scope/test.js
index 2f2efe5f47b98a..a2158fd5bcea2b 100644
--- a/test/addons/callback-scope/test.js
+++ b/test/addons/callback-scope/test.js
@@ -7,9 +7,12 @@ const { runInCallbackScope } = require(`./build/${common.buildType}/binding`);
 assert.strictEqual(runInCallbackScope({}, 0, 0, () => 42), 42);
 
 {
-  process.once('uncaughtException', common.mustCall((err) => {
-    assert.strictEqual(err.message, 'foo');
-  }));
+  process.once(
+    'uncaughtException',
+    common.mustCall((err) => {
+      assert.strictEqual(err.message, 'foo');
+    })
+  );
 
   runInCallbackScope({}, 0, 0, () => {
     throw new Error('foo');
diff --git a/test/addons/dlopen-ping-pong/test.js b/test/addons/dlopen-ping-pong/test.js
index c533593496090a..1576e2e43a43d0 100644
--- a/test/addons/dlopen-ping-pong/test.js
+++ b/test/addons/dlopen-ping-pong/test.js
@@ -9,8 +9,11 @@ const path = require('path');
 const os = require('os');
 
 const bindingPath = require.resolve(`./build/${common.buildType}/binding`);
-process.dlopen(module, bindingPath,
-               os.constants.dlopen.RTLD_NOW | os.constants.dlopen.RTLD_GLOBAL);
+process.dlopen(
+  module,
+  bindingPath,
+  os.constants.dlopen.RTLD_NOW | os.constants.dlopen.RTLD_GLOBAL
+);
 module.exports.load(`${path.dirname(bindingPath)}/ping.so`);
 assert.strictEqual(module.exports.ping(), 'pong');
 
diff --git a/test/addons/hello-world-esm/test.js b/test/addons/hello-world-esm/test.js
index d0faf655400f13..c1c35d98220115 100644
--- a/test/addons/hello-world-esm/test.js
+++ b/test/addons/hello-world-esm/test.js
@@ -8,11 +8,15 @@ const { join } = require('path');
 
 const buildDir = join(__dirname, 'build');
 
-copyFileSync(join(buildDir, common.buildType, 'binding.node'),
-             join(buildDir, 'binding.node'));
+copyFileSync(
+  join(buildDir, common.buildType, 'binding.node'),
+  join(buildDir, 'binding.node')
+);
 
-const result = spawnSync(process.execPath,
-                         ['--experimental-modules', `${__dirname}/test.mjs`]);
+const result = spawnSync(process.execPath, [
+  '--experimental-modules',
+  `${__dirname}/test.mjs`
+]);
 
 assert.ifError(result.error);
 // TODO: Uncomment this once ESM is no longer experimental.
diff --git a/test/addons/load-long-path/test.js b/test/addons/load-long-path/test.js
index 7d1a37bd96055e..23a8edcb068351 100644
--- a/test/addons/load-long-path/test.js
+++ b/test/addons/load-long-path/test.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../../common');
-if (common.isWindows && (process.env.PROCESSOR_ARCHITEW6432 !== undefined))
-  common.skip('doesn\'t work on WOW64');
+if (common.isWindows && process.env.PROCESSOR_ARCHITEW6432 !== undefined)
+  common.skip("doesn't work on WOW64");
 
 const fs = require('fs');
 const path = require('path');
@@ -20,10 +20,12 @@ for (let i = 0; i < 10; i++) {
   fs.mkdirSync(addonDestinationDir);
 }
 
-const addonPath = path.join(__dirname,
-                            'build',
-                            common.buildType,
-                            'binding.node');
+const addonPath = path.join(
+  __dirname,
+  'build',
+  common.buildType,
+  'binding.node'
+);
 const addonDestinationPath = path.join(addonDestinationDir, 'binding.node');
 
 // Copy binary to long path destination
diff --git a/test/addons/make-callback-domain-warning/test.js b/test/addons/make-callback-domain-warning/test.js
index 2ea3c3f3d14b2b..9375d20ad4289e 100644
--- a/test/addons/make-callback-domain-warning/test.js
+++ b/test/addons/make-callback-domain-warning/test.js
@@ -17,19 +17,30 @@ process.on('warning', function(warning) {
 const d = domain.create();
 
 // When domain is disabled, no warning will be emitted
-makeCallback({ domain: d }, common.mustCall(function() {
-  assert.strictEqual(latestWarning, null);
+makeCallback(
+  { domain: d },
+  common.mustCall(function() {
+    assert.strictEqual(latestWarning, null);
 
-  d.run(common.mustCall(function() {
-    // No warning will be emitted when no domain property is applied
-    makeCallback({}, common.mustCall(function() {
-      assert.strictEqual(latestWarning, null);
+    d.run(
+      common.mustCall(function() {
+        // No warning will be emitted when no domain property is applied
+        makeCallback(
+          {},
+          common.mustCall(function() {
+            assert.strictEqual(latestWarning, null);
 
-      // Warning is emitted when domain property is used and domain is enabled
-      makeCallback({ domain: d }, common.mustCall(function() {
-        assert.strictEqual(latestWarning.name, 'DeprecationWarning');
-        assert.strictEqual(latestWarning.code, 'DEP0097');
-      }));
-    }));
-  }));
-}));
+            // Warning is emitted when domain property is used and domain is enabled
+            makeCallback(
+              { domain: d },
+              common.mustCall(function() {
+                assert.strictEqual(latestWarning.name, 'DeprecationWarning');
+                assert.strictEqual(latestWarning.code, 'DEP0097');
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/addons/make-callback-recurse/test.js b/test/addons/make-callback-recurse/test.js
index 102890cc964d2a..4ca490390b89bb 100644
--- a/test/addons/make-callback-recurse/test.js
+++ b/test/addons/make-callback-recurse/test.js
@@ -16,7 +16,6 @@ assert.throws(function() {
   });
 }, /^Error: hi from domain error$/);
 
-
 // Check the execution order of the nextTickQueue and MicrotaskQueue in
 // relation to running multiple MakeCallback's from bootstrap,
 // node::MakeCallback() and node::AsyncWrap::MakeCallback().
@@ -27,116 +26,164 @@ assert.throws(function() {
 
   // Processing of the MicrotaskQueue is manually handled by node. They are not
   // processed until after the nextTickQueue has been processed.
-  Promise.resolve(1).then(common.mustCall(function() {
-    results.push(7);
-  }));
+  Promise.resolve(1).then(
+    common.mustCall(function() {
+      results.push(7);
+    })
+  );
 
   // The nextTick should run after all immediately invoked calls.
-  process.nextTick(common.mustCall(function() {
-    results.push(3);
-
-    // Run same test again but while processing the nextTickQueue to make sure
-    // the following MakeCallback call breaks in the middle of processing the
-    // queue and allows the script to run normally.
-    process.nextTick(common.mustCall(function() {
-      results.push(6);
-    }));
-
-    makeCallback({}, common.mustCall(function() {
-      results.push(4);
-    }));
-
-    results.push(5);
-  }));
+  process.nextTick(
+    common.mustCall(function() {
+      results.push(3);
+
+      // Run same test again but while processing the nextTickQueue to make sure
+      // the following MakeCallback call breaks in the middle of processing the
+      // queue and allows the script to run normally.
+      process.nextTick(
+        common.mustCall(function() {
+          results.push(6);
+        })
+      );
+
+      makeCallback(
+        {},
+        common.mustCall(function() {
+          results.push(4);
+        })
+      );
+
+      results.push(5);
+    })
+  );
 
   results.push(0);
 
   // MakeCallback is calling the function immediately, but should then detect
   // that a script is already in the middle of execution and return before
   // either the nextTickQueue or MicrotaskQueue are processed.
-  makeCallback({}, common.mustCall(function() {
-    results.push(1);
-  }));
+  makeCallback(
+    {},
+    common.mustCall(function() {
+      results.push(1);
+    })
+  );
 
   // This should run before either the nextTickQueue or MicrotaskQueue are
   // processed. Previously MakeCallback would not detect this circumstance
   // and process them immediately.
   results.push(2);
 
-  setImmediate(common.mustCall(function() {
-    for (let i = 0; i < results.length; i++) {
-      assert.strictEqual(results[i], i,
-                         `verifyExecutionOrder(${arg}) results: ${results}`);
-    }
-    if (arg === 1) {
-      // The tests are first run on bootstrap during LoadEnvironment() in
-      // src/node.cc. Now run the tests through node::MakeCallback().
-      setImmediate(function() {
-        makeCallback({}, common.mustCall(function() {
-          verifyExecutionOrder(2);
-        }));
-      });
-    } else if (arg === 2) {
-      // Make sure there are no conflicts using node::MakeCallback()
-      // within timers.
-      setTimeout(common.mustCall(function() {
-        verifyExecutionOrder(3);
-      }), 10);
-    } else if (arg === 3) {
-      mustCallCheckDomains();
-    } else {
-      throw new Error('UNREACHABLE');
-    }
-  }));
-}(1));
-
+  setImmediate(
+    common.mustCall(function() {
+      for (let i = 0; i < results.length; i++) {
+        assert.strictEqual(
+          results[i],
+          i,
+          `verifyExecutionOrder(${arg}) results: ${results}`
+        );
+      }
+      if (arg === 1) {
+        // The tests are first run on bootstrap during LoadEnvironment() in
+        // src/node.cc. Now run the tests through node::MakeCallback().
+        setImmediate(function() {
+          makeCallback(
+            {},
+            common.mustCall(function() {
+              verifyExecutionOrder(2);
+            })
+          );
+        });
+      } else if (arg === 2) {
+        // Make sure there are no conflicts using node::MakeCallback()
+        // within timers.
+        setTimeout(
+          common.mustCall(function() {
+            verifyExecutionOrder(3);
+          }),
+          10
+        );
+      } else if (arg === 3) {
+        mustCallCheckDomains();
+      } else {
+        throw new Error('UNREACHABLE');
+      }
+    })
+  );
+})(1);
 
 function checkDomains() {
   // Check that domains are properly entered/exited when called in multiple
   // levels from both node::MakeCallback() and AsyncWrap::MakeCallback
-  setImmediate(common.mustCall(function() {
-    const d1 = domain.create();
-    const d2 = domain.create();
-    const d3 = domain.create();
-
-    makeCallback({ domain: d1 }, common.mustCall(function() {
-      assert.strictEqual(d1, process.domain);
-      makeCallback({ domain: d2 }, common.mustCall(function() {
-        assert.strictEqual(d2, process.domain);
-        makeCallback({ domain: d3 }, common.mustCall(function() {
-          assert.strictEqual(d3, process.domain);
-        }));
-        assert.strictEqual(d2, process.domain);
-      }));
-      assert.strictEqual(d1, process.domain);
-    }));
-  }));
-
-  setTimeout(common.mustCall(function() {
-    const d1 = domain.create();
-    const d2 = domain.create();
-    const d3 = domain.create();
-
-    makeCallback({ domain: d1 }, common.mustCall(function() {
-      assert.strictEqual(d1, process.domain);
-      makeCallback({ domain: d2 }, common.mustCall(function() {
-        assert.strictEqual(d2, process.domain);
-        makeCallback({ domain: d3 }, common.mustCall(function() {
-          assert.strictEqual(d3, process.domain);
-        }));
-        assert.strictEqual(d2, process.domain);
-      }));
-      assert.strictEqual(d1, process.domain);
-    }));
-  }), 1);
+  setImmediate(
+    common.mustCall(function() {
+      const d1 = domain.create();
+      const d2 = domain.create();
+      const d3 = domain.create();
+
+      makeCallback(
+        { domain: d1 },
+        common.mustCall(function() {
+          assert.strictEqual(d1, process.domain);
+          makeCallback(
+            { domain: d2 },
+            common.mustCall(function() {
+              assert.strictEqual(d2, process.domain);
+              makeCallback(
+                { domain: d3 },
+                common.mustCall(function() {
+                  assert.strictEqual(d3, process.domain);
+                })
+              );
+              assert.strictEqual(d2, process.domain);
+            })
+          );
+          assert.strictEqual(d1, process.domain);
+        })
+      );
+    })
+  );
+
+  setTimeout(
+    common.mustCall(function() {
+      const d1 = domain.create();
+      const d2 = domain.create();
+      const d3 = domain.create();
+
+      makeCallback(
+        { domain: d1 },
+        common.mustCall(function() {
+          assert.strictEqual(d1, process.domain);
+          makeCallback(
+            { domain: d2 },
+            common.mustCall(function() {
+              assert.strictEqual(d2, process.domain);
+              makeCallback(
+                { domain: d3 },
+                common.mustCall(function() {
+                  assert.strictEqual(d3, process.domain);
+                })
+              );
+              assert.strictEqual(d2, process.domain);
+            })
+          );
+          assert.strictEqual(d1, process.domain);
+        })
+      );
+    }),
+    1
+  );
 
   function testTimer(id) {
     // Make sure nextTick, setImmediate and setTimeout can all recover properly
     // after a thrown makeCallback call.
     const d = domain.create();
-    d.on('error', common.mustCall(function(e) {
-      assert.strictEqual(e.message, `throw from domain ${id}`);
-    }));
+    d.on(
+      'error',
+      common.mustCall(function(e) {
+        assert.strictEqual(e.message, `throw from domain ${id}`);
+      })
+    );
     makeCallback({ domain: d }, function() {
       throw new Error(`throw from domain ${id}`);
     });
diff --git a/test/addons/make-callback/test.js b/test/addons/make-callback/test.js
index c5a71b5ab7a3e0..85f0e47793e5a1 100644
--- a/test/addons/make-callback/test.js
+++ b/test/addons/make-callback/test.js
@@ -6,18 +6,31 @@ const vm = require('vm');
 const binding = require(`./build/${common.buildType}/binding`);
 const makeCallback = binding.makeCallback;
 
-assert.strictEqual(makeCallback(process, common.mustCall(function() {
-  assert.strictEqual(arguments.length, 0);
-  assert.strictEqual(process, this);
-  return 42;
-})), 42);
+assert.strictEqual(
+  makeCallback(
+    process,
+    common.mustCall(function() {
+      assert.strictEqual(arguments.length, 0);
+      assert.strictEqual(process, this);
+      return 42;
+    })
+  ),
+  42
+);
 
-assert.strictEqual(makeCallback(process, common.mustCall(function(x) {
-  assert.strictEqual(arguments.length, 1);
-  assert.strictEqual(process, this);
-  assert.strictEqual(x, 1337);
-  return 42;
-}), 1337), 42);
+assert.strictEqual(
+  makeCallback(
+    process,
+    common.mustCall(function(x) {
+      assert.strictEqual(arguments.length, 1);
+      assert.strictEqual(process, this);
+      assert.strictEqual(x, 1337);
+      return 42;
+    }),
+    1337
+  ),
+  42
+);
 
 const recv = {
   one: common.mustCall(function() {
@@ -30,7 +43,7 @@ const recv = {
     assert.strictEqual(recv, this);
     assert.strictEqual(x, 1337);
     return 42;
-  }),
+  })
 };
 
 assert.strictEqual(makeCallback(recv, 'one'), 42);
@@ -58,8 +71,7 @@ const forward = vm.runInNewContext(`
 `);
 // Runs in outer context.
 function endpoint($Object) {
-  if (Object === $Object)
-    throw new Error('bad');
+  if (Object === $Object) throw new Error('bad');
   return Object;
 }
 assert.strictEqual(makeCallback(process, forward, endpoint), Object);
diff --git a/test/addons/node-module-version/test.js b/test/addons/node-module-version/test.js
index 002e38134d76b6..00c19b4aa8ff47 100644
--- a/test/addons/node-module-version/test.js
+++ b/test/addons/node-module-version/test.js
@@ -4,11 +4,12 @@ const common = require('../../common');
 const assert = require('assert');
 
 const re = new RegExp(
-  '^Error: The module \'.+\'\n' +
-  'was compiled against a different Node\\.js version using\n' +
-  'NODE_MODULE_VERSION 42\\. This version of Node\\.js requires\n' +
-  `NODE_MODULE_VERSION ${process.versions.modules}\\. ` +
-  'Please try re-compiling or re-installing\n' +
-  'the module \\(for instance, using `npm rebuild` or `npm install`\\)\\.$');
+  "^Error: The module '.+'\n" +
+    'was compiled against a different Node\\.js version using\n' +
+    'NODE_MODULE_VERSION 42\\. This version of Node\\.js requires\n' +
+    `NODE_MODULE_VERSION ${process.versions.modules}\\. ` +
+    'Please try re-compiling or re-installing\n' +
+    'the module \\(for instance, using `npm rebuild` or `npm install`\\)\\.$'
+);
 
 assert.throws(() => require(`./build/${common.buildType}/binding`), re);
diff --git a/test/addons/non-node-context/test-make-buffer.js b/test/addons/non-node-context/test-make-buffer.js
index 9b17fa4ee930ae..a373537bae86b7 100644
--- a/test/addons/non-node-context/test-make-buffer.js
+++ b/test/addons/non-node-context/test-make-buffer.js
@@ -2,9 +2,9 @@
 
 const common = require('../../common');
 const assert = require('assert');
-const {
-  makeBufferInNewContext
-} = require(`./build/${common.buildType}/binding`);
+const { makeBufferInNewContext } = require(`./build/${
+  common.buildType
+}/binding`);
 
 // Because the `Buffer` function and its protoype property only (currently)
 // exist in a Node.js instance’s main context, trying to create buffers from
@@ -17,6 +17,8 @@ try {
   assert(!(exception.constructor instanceof Error));
 
   assert.strictEqual(exception.code, 'ERR_BUFFER_CONTEXT_NOT_AVAILABLE');
-  assert.strictEqual(exception.message,
-                     'Buffer is not available for the current Context');
+  assert.strictEqual(
+    exception.message,
+    'Buffer is not available for the current Context'
+  );
 }
diff --git a/test/addons/non-node-context/test-perf-hooks-timerify.js b/test/addons/non-node-context/test-perf-hooks-timerify.js
index 10a9ab8064227e..edf9470d078e12 100644
--- a/test/addons/non-node-context/test-perf-hooks-timerify.js
+++ b/test/addons/non-node-context/test-perf-hooks-timerify.js
@@ -8,10 +8,13 @@ const { performance } = require('perf_hooks');
 // Check that performance.timerify() works when called from another context,
 // for a function created in another context.
 
-const check = runInNewContext(`
+const check = runInNewContext(
+  `
 const { performance, assert } = data;
 const timerified = performance.timerify(function() { return []; });
 assert.strictEqual(timerified().constructor, Array);
 'success';
-`, { performance, assert });
+`,
+  { performance, assert }
+);
 assert.strictEqual(check, 'success');
diff --git a/test/addons/openssl-binding/test.js b/test/addons/openssl-binding/test.js
index 1e6c57ffd1e081..b88a36063429c9 100644
--- a/test/addons/openssl-binding/test.js
+++ b/test/addons/openssl-binding/test.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const binding = require(`./build/${common.buildType}/binding`);
diff --git a/test/addons/openssl-client-cert-engine/test.js b/test/addons/openssl-client-cert-engine/test.js
index 1c0e4564a5c3e9..414eb3b8b3f430 100644
--- a/test/addons/openssl-client-cert-engine/test.js
+++ b/test/addons/openssl-client-cert-engine/test.js
@@ -2,17 +2,17 @@
 const common = require('../../common');
 const fixture = require('../../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fs = require('fs');
 const path = require('path');
 
-const engine = path.join(__dirname,
-                         `/build/${common.buildType}/testengine.engine`);
+const engine = path.join(
+  __dirname,
+  `/build/${common.buildType}/testengine.engine`
+);
 
-if (!fs.existsSync(engine))
-  common.skip('no client cert engine');
+if (!fs.existsSync(engine)) common.skip('no client cert engine');
 
 const assert = require('assert');
 const https = require('https');
@@ -29,32 +29,40 @@ const serverOptions = {
   rejectUnauthorized: true
 };
 
-const server = https.createServer(serverOptions, (req, res) => {
-  res.writeHead(200);
-  res.end('hello world');
-}).listen(0, common.localhostIPv4, () => {
-  const clientOptions = {
-    method: 'GET',
-    host: common.localhostIPv4,
-    port: server.address().port,
-    path: '/test',
-    clientCertEngine: engine,  // engine will provide key+cert
-    rejectUnauthorized: false, // prevent failing on self-signed certificates
-    headers: {}
-  };
-
-  const req = https.request(clientOptions, common.mustCall(function(response) {
-    let body = '';
-    response.setEncoding('utf8');
-    response.on('data', function(chunk) {
-      body += chunk;
-    });
-
-    response.on('end', common.mustCall(function() {
-      assert.strictEqual(body, 'hello world');
-      server.close();
-    }));
-  }));
-
-  req.end();
-});
+const server = https
+  .createServer(serverOptions, (req, res) => {
+    res.writeHead(200);
+    res.end('hello world');
+  })
+  .listen(0, common.localhostIPv4, () => {
+    const clientOptions = {
+      method: 'GET',
+      host: common.localhostIPv4,
+      port: server.address().port,
+      path: '/test',
+      clientCertEngine: engine, // engine will provide key+cert
+      rejectUnauthorized: false, // prevent failing on self-signed certificates
+      headers: {}
+    };
+
+    const req = https.request(
+      clientOptions,
+      common.mustCall(function(response) {
+        let body = '';
+        response.setEncoding('utf8');
+        response.on('data', function(chunk) {
+          body += chunk;
+        });
+
+        response.on(
+          'end',
+          common.mustCall(function() {
+            assert.strictEqual(body, 'hello world');
+            server.close();
+          })
+        );
+      })
+    );
+
+    req.end();
+  });
diff --git a/test/addons/repl-domain-abort/test.js b/test/addons/repl-domain-abort/test.js
index 2049fe6e6a23f5..ba738b9e274d38 100644
--- a/test/addons/repl-domain-abort/test.js
+++ b/test/addons/repl-domain-abort/test.js
@@ -27,8 +27,7 @@ const stream = require('stream');
 const path = require('path');
 let buildPath = path.join(__dirname, 'build', common.buildType, 'binding');
 // On Windows, escape backslashes in the path before passing it to REPL.
-if (common.isWindows)
-  buildPath = buildPath.replace(/\\/g, '/');
+if (common.isWindows) buildPath = buildPath.replace(/\\/g, '/');
 let cb_ran = false;
 
 process.on('exit', function() {
@@ -39,9 +38,9 @@ process.on('exit', function() {
 const lines = [
   // This line shouldn't cause an assertion error.
   `require('${buildPath}')` +
-  // Log output to double check callback ran.
-  '.method(function(v1, v2) {' +
-  'console.log(\'cb_ran\'); return v1 === true && v2 === false; });',
+    // Log output to double check callback ran.
+    '.method(function(v1, v2) {' +
+    "console.log('cb_ran'); return v1 === true && v2 === false; });"
 ];
 
 const dInput = new stream.Readable();
@@ -49,13 +48,11 @@ const dOutput = new stream.Writable();
 
 dInput._read = function _read() {
   while (lines.length > 0 && this.push(lines.shift()));
-  if (lines.length === 0)
-    this.push(null);
+  if (lines.length === 0) this.push(null);
 };
 
 dOutput._write = function _write(chunk, encoding, cb) {
-  if (chunk.toString().startsWith('cb_ran'))
-    cb_ran = true;
+  if (chunk.toString().startsWith('cb_ran')) cb_ran = true;
   cb();
 };
 
diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js
index 820f71ec9e7a01..7caf36551dd252 100644
--- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js
+++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js
@@ -4,8 +4,7 @@
 const common = require('../../common');
 const { internalBinding } = require('internal/test/binding');
 const skipMessage = 'intensive toString tests due to memory confinements';
-if (!common.enoughTestMem)
-  common.skip(skipMessage);
+if (!common.enoughTestMem) common.skip(skipMessage);
 
 const binding = require(`./build/${common.buildType}/binding`);
 const assert = require('assert');
@@ -19,13 +18,12 @@ try {
   buf = Buffer.allocUnsafe(kStringMaxLength);
 } catch (e) {
   // If the exception is not due to memory confinement then rethrow it.
-  if (e.message !== 'Array buffer allocation failed') throw (e);
+  if (e.message !== 'Array buffer allocation failed') throw e;
   common.skip(skipMessage);
 }
 
 // Ensure we have enough memory available for future allocations to succeed.
-if (!binding.ensureAllocation(2 * kStringMaxLength))
-  common.skip(skipMessage);
+if (!binding.ensureAllocation(2 * kStringMaxLength)) common.skip(skipMessage);
 
 const maxString = buf.toString('latin1');
 assert.strictEqual(maxString.length, kStringMaxLength);
diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js
index 7f5a8347956e43..8f748b4d07a87e 100644
--- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js
+++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js
@@ -4,8 +4,7 @@
 const common = require('../../common');
 const { internalBinding } = require('internal/test/binding');
 const skipMessage = 'intensive toString tests due to memory confinements';
-if (!common.enoughTestMem)
-  common.skip(skipMessage);
+if (!common.enoughTestMem) common.skip(skipMessage);
 
 const binding = require(`./build/${common.buildType}/binding`);
 
@@ -18,20 +17,22 @@ try {
   buf = Buffer.allocUnsafe(kStringMaxLength + 1);
 } catch (e) {
   // If the exception is not due to memory confinement then rethrow it.
-  if (e.message !== 'Array buffer allocation failed') throw (e);
+  if (e.message !== 'Array buffer allocation failed') throw e;
   common.skip(skipMessage);
 }
 
 // Ensure we have enough memory available for future allocations to succeed.
-if (!binding.ensureAllocation(2 * kStringMaxLength))
-  common.skip(skipMessage);
+if (!binding.ensureAllocation(2 * kStringMaxLength)) common.skip(skipMessage);
 
 const stringLengthHex = kStringMaxLength.toString(16);
-common.expectsError(function() {
-  buf.toString('ascii');
-}, {
-  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
-           'characters',
-  code: 'ERR_STRING_TOO_LONG',
-  type: Error
-});
+common.expectsError(
+  function() {
+    buf.toString('ascii');
+  },
+  {
+    message:
+      `Cannot create a string longer than 0x${stringLengthHex} ` + 'characters',
+    code: 'ERR_STRING_TOO_LONG',
+    type: Error
+  }
+);
diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js
index d7fe26814f7b24..4e7f93de6a41be 100644
--- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js
+++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js
@@ -4,8 +4,7 @@
 const common = require('../../common');
 const { internalBinding } = require('internal/test/binding');
 const skipMessage = 'intensive toString tests due to memory confinements';
-if (!common.enoughTestMem)
-  common.skip(skipMessage);
+if (!common.enoughTestMem) common.skip(skipMessage);
 
 const binding = require(`./build/${common.buildType}/binding`);
 
@@ -18,20 +17,22 @@ try {
   buf = Buffer.allocUnsafe(kStringMaxLength + 1);
 } catch (e) {
   // If the exception is not due to memory confinement then rethrow it.
-  if (e.message !== 'Array buffer allocation failed') throw (e);
+  if (e.message !== 'Array buffer allocation failed') throw e;
   common.skip(skipMessage);
 }
 
 // Ensure we have enough memory available for future allocations to succeed.
-if (!binding.ensureAllocation(2 * kStringMaxLength))
-  common.skip(skipMessage);
+if (!binding.ensureAllocation(2 * kStringMaxLength)) common.skip(skipMessage);
 
 const stringLengthHex = kStringMaxLength.toString(16);
-common.expectsError(function() {
-  buf.toString('base64');
-}, {
-  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
-           'characters',
-  code: 'ERR_STRING_TOO_LONG',
-  type: Error
-});
+common.expectsError(
+  function() {
+    buf.toString('base64');
+  },
+  {
+    message:
+      `Cannot create a string longer than 0x${stringLengthHex} ` + 'characters',
+    code: 'ERR_STRING_TOO_LONG',
+    type: Error
+  }
+);
diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js
index 7e75ba1246662c..b8a22e47e4ca72 100644
--- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js
+++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js
@@ -4,8 +4,7 @@
 const common = require('../../common');
 const { internalBinding } = require('internal/test/binding');
 const skipMessage = 'intensive toString tests due to memory confinements';
-if (!common.enoughTestMem)
-  common.skip(skipMessage);
+if (!common.enoughTestMem) common.skip(skipMessage);
 
 const binding = require(`./build/${common.buildType}/binding`);
 const assert = require('assert');
@@ -19,23 +18,25 @@ try {
   buf = Buffer.allocUnsafe(kStringMaxLength + 1);
 } catch (e) {
   // If the exception is not due to memory confinement then rethrow it.
-  if (e.message !== 'Array buffer allocation failed') throw (e);
+  if (e.message !== 'Array buffer allocation failed') throw e;
   common.skip(skipMessage);
 }
 
 // Ensure we have enough memory available for future allocations to succeed.
-if (!binding.ensureAllocation(2 * kStringMaxLength))
-  common.skip(skipMessage);
+if (!binding.ensureAllocation(2 * kStringMaxLength)) common.skip(skipMessage);
 
 const stringLengthHex = kStringMaxLength.toString(16);
-common.expectsError(function() {
-  buf.toString('latin1');
-}, {
-  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
-           'characters',
-  code: 'ERR_STRING_TOO_LONG',
-  type: Error
-});
+common.expectsError(
+  function() {
+    buf.toString('latin1');
+  },
+  {
+    message:
+      `Cannot create a string longer than 0x${stringLengthHex} ` + 'characters',
+    code: 'ERR_STRING_TOO_LONG',
+    type: Error
+  }
+);
 
 // FIXME: Free the memory early to avoid OOM.
 // REF: https://github.com/nodejs/reliability/issues/12#issuecomment-412619655
diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js
index 57242399bb02b9..5705a7b65391f7 100644
--- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js
+++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js
@@ -4,8 +4,7 @@
 const common = require('../../common');
 const { internalBinding } = require('internal/test/binding');
 const skipMessage = 'intensive toString tests due to memory confinements';
-if (!common.enoughTestMem)
-  common.skip(skipMessage);
+if (!common.enoughTestMem) common.skip(skipMessage);
 
 const binding = require(`./build/${common.buildType}/binding`);
 
@@ -18,20 +17,22 @@ try {
   buf = Buffer.allocUnsafe(kStringMaxLength + 1);
 } catch (e) {
   // If the exception is not due to memory confinement then rethrow it.
-  if (e.message !== 'Array buffer allocation failed') throw (e);
+  if (e.message !== 'Array buffer allocation failed') throw e;
   common.skip(skipMessage);
 }
 
 // Ensure we have enough memory available for future allocations to succeed.
-if (!binding.ensureAllocation(2 * kStringMaxLength))
-  common.skip(skipMessage);
+if (!binding.ensureAllocation(2 * kStringMaxLength)) common.skip(skipMessage);
 
 const stringLengthHex = kStringMaxLength.toString(16);
-common.expectsError(function() {
-  buf.toString('hex');
-}, {
-  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
-           'characters',
-  code: 'ERR_STRING_TOO_LONG',
-  type: Error
-});
+common.expectsError(
+  function() {
+    buf.toString('hex');
+  },
+  {
+    message:
+      `Cannot create a string longer than 0x${stringLengthHex} ` + 'characters',
+    code: 'ERR_STRING_TOO_LONG',
+    type: Error
+  }
+);
diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js
index 4a0908290c1926..1ee636b8a0aac4 100644
--- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js
+++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js
@@ -4,8 +4,7 @@
 const common = require('../../common');
 const { internalBinding } = require('internal/test/binding');
 const skipMessage = 'intensive toString tests due to memory confinements';
-if (!common.enoughTestMem)
-  common.skip(skipMessage);
+if (!common.enoughTestMem) common.skip(skipMessage);
 
 const binding = require(`./build/${common.buildType}/binding`);
 const assert = require('assert');
@@ -19,37 +18,43 @@ try {
   buf = Buffer.allocUnsafe(kStringMaxLength + 1);
 } catch (e) {
   // If the exception is not due to memory confinement then rethrow it.
-  if (e.message !== 'Array buffer allocation failed') throw (e);
+  if (e.message !== 'Array buffer allocation failed') throw e;
   common.skip(skipMessage);
 }
 
 // Ensure we have enough memory available for future allocations to succeed.
-if (!binding.ensureAllocation(2 * kStringMaxLength))
-  common.skip(skipMessage);
+if (!binding.ensureAllocation(2 * kStringMaxLength)) common.skip(skipMessage);
 
 const stringLengthHex = kStringMaxLength.toString(16);
 
-assert.throws(function() {
-  buf.toString();
-}, function(e) {
-  if (e.message !== 'Array buffer allocation failed') {
-    common.expectsError({
-      message: `Cannot create a string longer than 0x${stringLengthHex} ` +
-               'characters',
-      code: 'ERR_STRING_TOO_LONG',
-      type: Error
-    })(e);
-    return true;
-  } else {
-    return true;
+assert.throws(
+  function() {
+    buf.toString();
+  },
+  function(e) {
+    if (e.message !== 'Array buffer allocation failed') {
+      common.expectsError({
+        message:
+          `Cannot create a string longer than 0x${stringLengthHex} ` +
+          'characters',
+        code: 'ERR_STRING_TOO_LONG',
+        type: Error
+      })(e);
+      return true;
+    } else {
+      return true;
+    }
+  }
+);
+
+common.expectsError(
+  function() {
+    buf.toString('utf8');
+  },
+  {
+    message:
+      `Cannot create a string longer than 0x${stringLengthHex} ` + 'characters',
+    code: 'ERR_STRING_TOO_LONG',
+    type: Error
   }
-});
-
-common.expectsError(function() {
-  buf.toString('utf8');
-}, {
-  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
-           'characters',
-  code: 'ERR_STRING_TOO_LONG',
-  type: Error
-});
+);
diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js
index 3c613a69fd3fcd..af18df46999359 100644
--- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js
+++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js
@@ -4,8 +4,7 @@
 const common = require('../../common');
 const { internalBinding } = require('internal/test/binding');
 const skipMessage = 'intensive toString tests due to memory confinements';
-if (!common.enoughTestMem)
-  common.skip(skipMessage);
+if (!common.enoughTestMem) common.skip(skipMessage);
 
 const binding = require(`./build/${common.buildType}/binding`);
 const assert = require('assert');
@@ -19,13 +18,12 @@ try {
   buf = Buffer.allocUnsafe(kStringMaxLength + 2);
 } catch (e) {
   // If the exception is not due to memory confinement then rethrow it.
-  if (e.message !== 'Array buffer allocation failed') throw (e);
+  if (e.message !== 'Array buffer allocation failed') throw e;
   common.skip(skipMessage);
 }
 
 // Ensure we have enough memory available for future allocations to succeed.
-if (!binding.ensureAllocation(2 * kStringMaxLength))
-  common.skip(skipMessage);
+if (!binding.ensureAllocation(2 * kStringMaxLength)) common.skip(skipMessage);
 
 const maxString = buf.toString('utf16le');
 assert.strictEqual(maxString.length, Math.floor((kStringMaxLength + 2) / 2));
diff --git a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js
index be571c5059ef8f..c77e5fd41d7137 100644
--- a/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js
+++ b/test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js
@@ -4,8 +4,7 @@
 const common = require('../../common');
 const { internalBinding } = require('internal/test/binding');
 const skipMessage = 'intensive toString tests due to memory confinements';
-if (!common.enoughTestMem)
-  common.skip(skipMessage);
+if (!common.enoughTestMem) common.skip(skipMessage);
 
 const binding = require(`./build/${common.buildType}/binding`);
 
@@ -18,21 +17,23 @@ try {
   buf = Buffer.allocUnsafe(kStringMaxLength * 2 + 2);
 } catch (e) {
   // If the exception is not due to memory confinement then rethrow it.
-  if (e.message !== 'Array buffer allocation failed') throw (e);
+  if (e.message !== 'Array buffer allocation failed') throw e;
   common.skip(skipMessage);
 }
 
 // Ensure we have enough memory available for future allocations to succeed.
-if (!binding.ensureAllocation(2 * kStringMaxLength))
-  common.skip(skipMessage);
+if (!binding.ensureAllocation(2 * kStringMaxLength)) common.skip(skipMessage);
 
 const stringLengthHex = kStringMaxLength.toString(16);
 
-common.expectsError(function() {
-  buf.toString('utf16le');
-}, {
-  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
-           'characters',
-  code: 'ERR_STRING_TOO_LONG',
-  type: Error
-});
+common.expectsError(
+  function() {
+    buf.toString('utf16le');
+  },
+  {
+    message:
+      `Cannot create a string longer than 0x${stringLengthHex} ` + 'characters',
+    code: 'ERR_STRING_TOO_LONG',
+    type: Error
+  }
+);
diff --git a/test/async-hooks/hook-checks.js b/test/async-hooks/hook-checks.js
index 44970378131c4a..378ba0527dc623 100644
--- a/test/async-hooks/hook-checks.js
+++ b/test/async-hooks/hook-checks.js
@@ -19,13 +19,14 @@ require('../common');
 exports.checkInvocations = function checkInvocations(activity, hooks, stage) {
   const stageInfo = `Checking invocations at stage "${stage}":\n   `;
 
-  assert.ok(activity != null,
-            `${stageInfo} Trying to check invocation for an activity, ` +
-            'but it was empty/undefined.'
+  assert.ok(
+    activity != null,
+    `${stageInfo} Trying to check invocation for an activity, ` +
+      'but it was empty/undefined.'
   );
 
   // Check that actual invocations for all hooks match the expected invocations
-  [ 'init', 'before', 'after', 'destroy', 'promiseResolve' ].forEach(checkHook);
+  ['init', 'before', 'after', 'destroy', 'promiseResolve'].forEach(checkHook);
 
   function checkHook(k) {
     const val = hooks[k];
@@ -35,19 +36,22 @@ exports.checkInvocations = function checkInvocations(activity, hooks, stage) {
     if (val === 0) {
       // Didn't expect any invocations, but it was actually invoked
       const invocations = activity[k].length;
-      const msg = `${stageInfo} Called "${k}" ${invocations} time(s), ` +
-                  'but expected no invocations.';
+      const msg =
+        `${stageInfo} Called "${k}" ${invocations} time(s), ` +
+        'but expected no invocations.';
       assert(activity[k] === null && activity[k] === undefined, msg);
     } else {
       // Expected some invocations, make sure that it was invoked at all
-      const msg1 = `${stageInfo} Never called "${k}", ` +
-                   `but expected ${val} invocation(s).`;
+      const msg1 =
+        `${stageInfo} Never called "${k}", ` +
+        `but expected ${val} invocation(s).`;
       assert(activity[k] !== null && activity[k] !== undefined, msg1);
 
       // Now make sure that the expected count and
       // the actual invocation count match
-      const msg2 = `${stageInfo}  Called "${k}" ${activity[k].length} ` +
-                   `time(s), but expected ${val} invocation(s).`;
+      const msg2 =
+        `${stageInfo}  Called "${k}" ${activity[k].length} ` +
+        `time(s), but expected ${val} invocation(s).`;
       assert.strictEqual(activity[k].length, val, msg2);
     }
   }
diff --git a/test/async-hooks/init-hooks.js b/test/async-hooks/init-hooks.js
index 817b2db0c781b4..78bdcf132cea92 100644
--- a/test/async-hooks/init-hooks.js
+++ b/test/async-hooks/init-hooks.js
@@ -19,16 +19,19 @@ if (typeof global.gc === 'function') {
 function noop() {}
 
 class ActivityCollector {
-  constructor(start, {
-    allowNoInit = false,
-    oninit,
-    onbefore,
-    onafter,
-    ondestroy,
-    onpromiseResolve,
-    logid = null,
-    logtype = null
-  } = {}) {
+  constructor(
+    start,
+    {
+      allowNoInit = false,
+      oninit,
+      onbefore,
+      onafter,
+      ondestroy,
+      onpromiseResolve,
+      logid = null,
+      logtype = null
+    } = {}
+  ) {
     this._start = start;
     this._allowNoInit = allowNoInit;
     this._activities = new Map();
@@ -40,8 +43,8 @@ class ActivityCollector {
     this.onbefore = typeof onbefore === 'function' ? onbefore : noop;
     this.onafter = typeof onafter === 'function' ? onafter : noop;
     this.ondestroy = typeof ondestroy === 'function' ? ondestroy : noop;
-    this.onpromiseResolve = typeof onpromiseResolve === 'function' ?
-      onpromiseResolve : noop;
+    this.onpromiseResolve =
+      typeof onpromiseResolve === 'function' ? onpromiseResolve : noop;
 
     // Create the hook with which we'll collect activity data
     this._asyncHook = async_hooks.createHook({
@@ -62,7 +65,7 @@ class ActivityCollector {
   }
 
   sanityCheck(types) {
-    if (types != null && !Array.isArray(types)) types = [ types ];
+    if (types != null && !Array.isArray(types)) types = [types];
 
     function activityString(a) {
       return util.inspect(a, false, 5, true);
@@ -71,51 +74,67 @@ class ActivityCollector {
     const violations = [];
     let tempActivityString;
 
-    function v(msg) { violations.push(msg); }
+    function v(msg) {
+      violations.push(msg);
+    }
     for (const a of this._activities.values()) {
       tempActivityString = activityString(a);
       if (types != null && !types.includes(a.type)) continue;
 
       if (a.init && a.init.length > 1) {
-        v(`Activity inited twice\n${tempActivityString}` +
-          '\nExpected "init" to be called at most once');
+        v(
+          `Activity inited twice\n${tempActivityString}` +
+            '\nExpected "init" to be called at most once'
+        );
       }
       if (a.destroy && a.destroy.length > 1) {
-        v(`Activity destroyed twice\n${tempActivityString}` +
-          '\nExpected "destroy" to be called at most once');
+        v(
+          `Activity destroyed twice\n${tempActivityString}` +
+            '\nExpected "destroy" to be called at most once'
+        );
       }
       if (a.before && a.after) {
         if (a.before.length < a.after.length) {
-          v('Activity called "after" without calling "before"\n' +
-            `${tempActivityString}` +
-            '\nExpected no "after" call without a "before"');
+          v(
+            'Activity called "after" without calling "before"\n' +
+              `${tempActivityString}` +
+              '\nExpected no "after" call without a "before"'
+          );
         }
         if (a.before.some((x, idx) => x > a.after[idx])) {
-          v('Activity had an instance where "after" ' +
-            'was invoked before "before"\n' +
-            `${tempActivityString}` +
-            '\nExpected "after" to be called after "before"');
+          v(
+            'Activity had an instance where "after" ' +
+              'was invoked before "before"\n' +
+              `${tempActivityString}` +
+              '\nExpected "after" to be called after "before"'
+          );
         }
       }
       if (a.before && a.destroy) {
         if (a.before.some((x, idx) => x > a.destroy[idx])) {
-          v('Activity had an instance where "destroy" ' +
-            'was invoked before "before"\n' +
-            `${tempActivityString}` +
-            '\nExpected "destroy" to be called after "before"');
+          v(
+            'Activity had an instance where "destroy" ' +
+              'was invoked before "before"\n' +
+              `${tempActivityString}` +
+              '\nExpected "destroy" to be called after "before"'
+          );
         }
       }
       if (a.after && a.destroy) {
         if (a.after.some((x, idx) => x > a.destroy[idx])) {
-          v('Activity had an instance where "destroy" ' +
-            'was invoked before "after"\n' +
-            `${tempActivityString}` +
-            '\nExpected "destroy" to be called after "after"');
+          v(
+            'Activity had an instance where "destroy" ' +
+              'was invoked before "after"\n' +
+              `${tempActivityString}` +
+              '\nExpected "destroy" to be called after "after"'
+          );
         }
       }
       if (!a.handleIsObject) {
-        v(`No resource object\n${tempActivityString}` +
-          '\nExpected "init" to be called with a resource object');
+        v(
+          `No resource object\n${tempActivityString}` +
+            '\nExpected "init" to be called with a resource object'
+        );
       }
     }
     if (violations.length) {
@@ -127,16 +146,17 @@ class ActivityCollector {
   inspect(opts = {}) {
     if (typeof opts === 'string') opts = { types: opts };
     const { types = null, depth = 5, stage = null } = opts;
-    const activities = types == null ?
-      Array.from(this._activities.values()) :
-      this.activitiesOfTypes(types);
+    const activities =
+      types == null
+        ? Array.from(this._activities.values())
+        : this.activitiesOfTypes(types);
 
     if (stage != null) console.log(`\n${stage}`);
     console.log(util.inspect(activities, false, depth, true));
   }
 
   activitiesOfTypes(types) {
-    if (!Array.isArray(types)) types = [ types ];
+    if (!Array.isArray(types)) types = [types];
     return this.activities.filter((x) => types.includes(x.type));
   }
 
@@ -148,7 +168,7 @@ class ActivityCollector {
     if (h == null) return;
     if (h[hook] == null) h[hook] = [];
     const time = process.hrtime(this._start);
-    h[hook].push((time[0] * 1e9) + time[1]);
+    h[hook].push(time[0] * 1e9 + time[1]);
   }
 
   _getActivity(uid, hook) {
@@ -166,8 +186,10 @@ class ActivityCollector {
         // callback, so we don't yield errors for these.
         return null;
       } else {
-        const err = new Error(`Found a handle whose ${hook}` +
-                              ' hook was invoked but not its init hook');
+        const err = new Error(
+          `Found a handle whose ${hook}` +
+            ' hook was invoked but not its init hook'
+        );
         // Don't throw if we see invocations due to an assertion in a test
         // failing since we want to list the assertion failure instead
         if (/process\._fatalException/.test(err.stack)) return null;
@@ -221,8 +243,10 @@ class ActivityCollector {
   }
 
   _maybeLog(uid, type, name) {
-    if (this._logid &&
-      (type == null || this._logtype == null || this._logtype === type)) {
+    if (
+      this._logid &&
+      (type == null || this._logtype == null || this._logtype === type)
+    ) {
       print(`${this._logid}.${name}.uid-${uid}`);
     }
   }
diff --git a/test/async-hooks/test-async-await.js b/test/async-hooks/test-async-await.js
index 0103f63621e3ba..57c45906651e40 100644
--- a/test/async-hooks/test-async-await.js
+++ b/test/async-hooks/test-async-await.js
@@ -21,7 +21,7 @@ const hooks = initHooks({
   oninit,
   onbefore,
   onafter,
-  ondestroy: null,  // Intentionally not tested, since it will be removed soon
+  ondestroy: null, // Intentionally not tested, since it will be removed soon
   onpromiseResolve
 });
 hooks.enable();
@@ -44,18 +44,24 @@ function onafter(asyncId) {
     return;
   }
 
-  assert.strictEqual(promisesExecutionState.get(asyncId), 'before',
-                     'after hook called for promise without prior call' +
-                     'to before hook');
-  assert.strictEqual(promisesInitState.get(asyncId), 'resolved',
-                     'after hook called for promise without prior call' +
-                     'to resolve hook');
+  assert.strictEqual(
+    promisesExecutionState.get(asyncId),
+    'before',
+    'after hook called for promise without prior call' + 'to before hook'
+  );
+  assert.strictEqual(
+    promisesInitState.get(asyncId),
+    'resolved',
+    'after hook called for promise without prior call' + 'to resolve hook'
+  );
   promisesExecutionState.set(asyncId, 'after');
 }
 
 function onpromiseResolve(asyncId) {
-  assert(promisesInitState.has(asyncId),
-         'resolve hook called for promise without prior call to init hook');
+  assert(
+    promisesInitState.has(asyncId),
+    'resolve hook called for promise without prior call to init hook'
+  );
 
   promisesInitState.set(asyncId, 'resolved');
 }
@@ -76,13 +82,16 @@ function checkPromisesExecutionState() {
   }
 }
 
-process.on('beforeExit', common.mustCall(() => {
-  hooks.disable();
-  hooks.sanityCheck('PROMISE');
+process.on(
+  'beforeExit',
+  common.mustCall(() => {
+    hooks.disable();
+    hooks.sanityCheck('PROMISE');
 
-  checkPromisesInitState();
-  checkPromisesExecutionState();
-}));
+    checkPromisesInitState();
+    checkPromisesExecutionState();
+  })
+);
 
 async function asyncFunc() {
   await sleep(timeout);
diff --git a/test/async-hooks/test-callback-error.js b/test/async-hooks/test-callback-error.js
index 07ed274342fd06..ef3602c226d8a1 100644
--- a/test/async-hooks/test-callback-error.js
+++ b/test/async-hooks/test-callback-error.js
@@ -9,14 +9,18 @@ const arg = process.argv[2];
 switch (arg) {
   case 'test_init_callback':
     initHooks({
-      oninit: common.mustCall(() => { throw new Error(arg); })
+      oninit: common.mustCall(() => {
+        throw new Error(arg);
+      })
     }).enable();
     new async_hooks.AsyncResource(`${arg}_type`);
     return;
 
   case 'test_callback':
     initHooks({
-      onbefore: common.mustCall(() => { throw new Error(arg); })
+      onbefore: common.mustCall(() => {
+        throw new Error(arg);
+      })
     }).enable();
     const resource = new async_hooks.AsyncResource(`${arg}_type`);
     resource.emitBefore();
@@ -24,7 +28,9 @@ switch (arg) {
 
   case 'test_callback_abort':
     initHooks({
-      oninit: common.mustCall(() => { throw new Error(arg); })
+      oninit: common.mustCall(() => {
+        throw new Error(arg);
+      })
     }).enable();
     new async_hooks.AsyncResource(`${arg}_type`);
     return;
diff --git a/test/async-hooks/test-crypto-pbkdf2.js b/test/async-hooks/test-crypto-pbkdf2.js
index 4788ce4a580656..e2cc6284a64d80 100644
--- a/test/async-hooks/test-crypto-pbkdf2.js
+++ b/test/async-hooks/test-crypto-pbkdf2.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 if (!common.isMainThread)
   common.skip('Worker bootstrapping works differently -> different async IDs');
 
@@ -12,7 +11,6 @@ const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const crypto = require('crypto');
 
-
 const hooks = initHooks();
 
 hooks.enable();
@@ -38,6 +36,9 @@ function onexit() {
   assert.strictEqual(a.type, 'PBKDF2REQUEST');
   assert.strictEqual(typeof a.uid, 'number');
   assert.strictEqual(a.triggerAsyncId, 1);
-  checkInvocations(a, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    a,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-crypto-randomBytes.js b/test/async-hooks/test-crypto-randomBytes.js
index 88cd4643ab6638..fb293d4c0d7934 100644
--- a/test/async-hooks/test-crypto-randomBytes.js
+++ b/test/async-hooks/test-crypto-randomBytes.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 if (!common.isMainThread)
   common.skip('Worker bootstrapping works differently -> different async IDs');
 
@@ -12,7 +11,6 @@ const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const crypto = require('crypto');
 
-
 const hooks = initHooks();
 
 hooks.enable();
@@ -21,8 +19,11 @@ crypto.randomBytes(1, common.mustCall(onrandomBytes));
 function onrandomBytes() {
   const as = hooks.activitiesOfTypes('RANDOMBYTESREQUEST');
   const a = as[0];
-  checkInvocations(a, { init: 1, before: 1 },
-                   'while in onrandomBytes callback');
+  checkInvocations(
+    a,
+    { init: 1, before: 1 },
+    'while in onrandomBytes callback'
+  );
   tick(2);
 }
 
@@ -39,6 +40,9 @@ function onexit() {
   assert.strictEqual(a.type, 'RANDOMBYTESREQUEST');
   assert.strictEqual(typeof a.uid, 'number');
   assert.strictEqual(a.triggerAsyncId, 1);
-  checkInvocations(a, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    a,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-disable-in-init.js b/test/async-hooks/test-disable-in-init.js
index b7ab31e6d97dc2..fa17799a093aac 100644
--- a/test/async-hooks/test-disable-in-init.js
+++ b/test/async-hooks/test-disable-in-init.js
@@ -6,18 +6,22 @@ const fs = require('fs');
 
 let nestedCall = false;
 
-async_hooks.createHook({
-  init: common.mustCall(function() {
-    nestedHook.disable();
-    if (!nestedCall) {
-      nestedCall = true;
-      fs.access(__filename, common.mustCall());
-    }
-  }, 2)
-}).enable();
+async_hooks
+  .createHook({
+    init: common.mustCall(function() {
+      nestedHook.disable();
+      if (!nestedCall) {
+        nestedCall = true;
+        fs.access(__filename, common.mustCall());
+      }
+    }, 2)
+  })
+  .enable();
 
-const nestedHook = async_hooks.createHook({
-  init: common.mustCall(2)
-}).enable();
+const nestedHook = async_hooks
+  .createHook({
+    init: common.mustCall(2)
+  })
+  .enable();
 
 fs.access(__filename, common.mustCall());
diff --git a/test/async-hooks/test-embedder.api.async-resource-no-type.js b/test/async-hooks/test-embedder.api.async-resource-no-type.js
index 69b6667edb674c..7c6c4328199d37 100644
--- a/test/async-hooks/test-embedder.api.async-resource-no-type.js
+++ b/test/async-hooks/test-embedder.api.async-resource-no-type.js
@@ -23,12 +23,13 @@ if (process.argv[2] === 'child') {
       type: TypeError
     });
   });
-
 } else {
   const args = process.argv.slice(1).concat('child');
-  spawn(process.execPath, args)
-    .on('close', common.mustCall((code) => {
+  spawn(process.execPath, args).on(
+    'close',
+    common.mustCall((code) => {
       // No error because the type was defaulted
       assert.strictEqual(code, 0);
-    }));
+    })
+  );
 }
diff --git a/test/async-hooks/test-embedder.api.async-resource.after-on-destroyed.js b/test/async-hooks/test-embedder.api.async-resource.after-on-destroyed.js
index 3cf0cc430f0fe0..d49897bacdf5f6 100644
--- a/test/async-hooks/test-embedder.api.async-resource.after-on-destroyed.js
+++ b/test/async-hooks/test-embedder.api.async-resource.after-on-destroyed.js
@@ -28,23 +28,32 @@ if (process.argv[2] === 'child') {
 
   console.log('heartbeat: still alive');
   event2.emitAfter();
-
 } else {
   const args = process.argv.slice(1).concat('child');
   let errData = Buffer.from('');
   let outData = Buffer.from('');
 
   const child = spawn(process.execPath, args);
-  child.stderr.on('data', (d) => { errData = Buffer.concat([ errData, d ]); });
-  child.stdout.on('data', (d) => { outData = Buffer.concat([ outData, d ]); });
-
-  child.on('close', common.mustCall((code) => {
-    assert.strictEqual(code, 1);
-    assert.ok(heartbeatMsg.test(outData.toString()),
-              'did not crash until we reached offending line of code ' +
-              `(found ${outData})`);
-    assert.ok(corruptedMsg.test(errData.toString()),
-              'printed error contains corrupted message ' +
-              `(found ${errData})`);
-  }));
+  child.stderr.on('data', (d) => {
+    errData = Buffer.concat([errData, d]);
+  });
+  child.stdout.on('data', (d) => {
+    outData = Buffer.concat([outData, d]);
+  });
+
+  child.on(
+    'close',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 1);
+      assert.ok(
+        heartbeatMsg.test(outData.toString()),
+        'did not crash until we reached offending line of code ' +
+          `(found ${outData})`
+      );
+      assert.ok(
+        corruptedMsg.test(errData.toString()),
+        'printed error contains corrupted message ' + `(found ${errData})`
+      );
+    })
+  );
 }
diff --git a/test/async-hooks/test-embedder.api.async-resource.before-on-destroyed.js b/test/async-hooks/test-embedder.api.async-resource.before-on-destroyed.js
index 6463c438ed9102..5d8bbcd766bb05 100644
--- a/test/async-hooks/test-embedder.api.async-resource.before-on-destroyed.js
+++ b/test/async-hooks/test-embedder.api.async-resource.before-on-destroyed.js
@@ -28,23 +28,32 @@ if (process.argv[2] === 'child') {
 
   console.log('heartbeat: still alive');
   event2.emitBefore();
-
 } else {
   const args = process.argv.slice(1).concat('child');
   let errData = Buffer.from('');
   let outData = Buffer.from('');
 
   const child = spawn(process.execPath, args);
-  child.stderr.on('data', (d) => { errData = Buffer.concat([ errData, d ]); });
-  child.stdout.on('data', (d) => { outData = Buffer.concat([ outData, d ]); });
-
-  child.on('close', common.mustCall((code) => {
-    assert.strictEqual(code, 1);
-    assert.ok(heartbeatMsg.test(outData.toString()),
-              'did not crash until we reached offending line of code ' +
-              `(found ${outData})`);
-    assert.ok(corruptedMsg.test(errData.toString()),
-              'printed error contains corrupted message ' +
-              `(found ${errData})`);
-  }));
+  child.stderr.on('data', (d) => {
+    errData = Buffer.concat([errData, d]);
+  });
+  child.stdout.on('data', (d) => {
+    outData = Buffer.concat([outData, d]);
+  });
+
+  child.on(
+    'close',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 1);
+      assert.ok(
+        heartbeatMsg.test(outData.toString()),
+        'did not crash until we reached offending line of code ' +
+          `(found ${outData})`
+      );
+      assert.ok(
+        corruptedMsg.test(errData.toString()),
+        'printed error contains corrupted message ' + `(found ${errData})`
+      );
+    })
+  );
 }
diff --git a/test/async-hooks/test-embedder.api.async-resource.improper-order.js b/test/async-hooks/test-embedder.api.async-resource.improper-order.js
index 048ae0841357ec..dbd1a879f12fd3 100644
--- a/test/async-hooks/test-embedder.api.async-resource.improper-order.js
+++ b/test/async-hooks/test-embedder.api.async-resource.improper-order.js
@@ -33,16 +33,26 @@ if (process.argv[2] === 'child') {
   let outData = Buffer.from('');
 
   const child = spawn(process.execPath, args);
-  child.stderr.on('data', (d) => { errData = Buffer.concat([ errData, d ]); });
-  child.stdout.on('data', (d) => { outData = Buffer.concat([ outData, d ]); });
-
-  child.on('close', common.mustCall((code) => {
-    assert.strictEqual(code, 1);
-    assert.ok(heartbeatMsg.test(outData.toString()),
-              'did not crash until we reached offending line of code ' +
-              `(found ${outData})`);
-    assert.ok(corruptedMsg.test(errData.toString()),
-              'printed error contains corrupted message ' +
-              `(found ${errData})`);
-  }));
+  child.stderr.on('data', (d) => {
+    errData = Buffer.concat([errData, d]);
+  });
+  child.stdout.on('data', (d) => {
+    outData = Buffer.concat([outData, d]);
+  });
+
+  child.on(
+    'close',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 1);
+      assert.ok(
+        heartbeatMsg.test(outData.toString()),
+        'did not crash until we reached offending line of code ' +
+          `(found ${outData})`
+      );
+      assert.ok(
+        corruptedMsg.test(errData.toString()),
+        'printed error contains corrupted message ' + `(found ${errData})`
+      );
+    })
+  );
 }
diff --git a/test/async-hooks/test-embedder.api.async-resource.improper-unwind.js b/test/async-hooks/test-embedder.api.async-resource.improper-unwind.js
index cb9e338905c386..c67260c7ba1694 100644
--- a/test/async-hooks/test-embedder.api.async-resource.improper-unwind.js
+++ b/test/async-hooks/test-embedder.api.async-resource.improper-unwind.js
@@ -42,16 +42,26 @@ if (process.argv[2] === 'child') {
   let outData = Buffer.from('');
 
   const child = spawn(process.execPath, args);
-  child.stderr.on('data', (d) => { errData = Buffer.concat([ errData, d ]); });
-  child.stdout.on('data', (d) => { outData = Buffer.concat([ outData, d ]); });
-
-  child.on('close', common.mustCall((code) => {
-    assert.strictEqual(code, 1);
-    assert.ok(heartbeatMsg.test(outData.toString()),
-              'did not crash until we reached offending line of code ' +
-              `(found ${outData})`);
-    assert.ok(corruptedMsg.test(errData.toString()),
-              'printed error contains corrupted message ' +
-              `(found ${errData})`);
-  }));
+  child.stderr.on('data', (d) => {
+    errData = Buffer.concat([errData, d]);
+  });
+  child.stdout.on('data', (d) => {
+    outData = Buffer.concat([outData, d]);
+  });
+
+  child.on(
+    'close',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 1);
+      assert.ok(
+        heartbeatMsg.test(outData.toString()),
+        'did not crash until we reached offending line of code ' +
+          `(found ${outData})`
+      );
+      assert.ok(
+        corruptedMsg.test(errData.toString()),
+        'printed error contains corrupted message ' + `(found ${errData})`
+      );
+    })
+  );
 }
diff --git a/test/async-hooks/test-embedder.api.async-resource.js b/test/async-hooks/test-embedder.api.async-resource.js
index 6f71a3e98cbf0f..6bdc6f2ddb7558 100644
--- a/test/async-hooks/test-embedder.api.async-resource.js
+++ b/test/async-hooks/test-embedder.api.async-resource.js
@@ -12,17 +12,19 @@ const { checkInvocations } = require('./hook-checks');
 const hooks = initHooks();
 hooks.enable();
 
-common.expectsError(
-  () => new AsyncResource(), {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-  });
-common.expectsError(() => {
-  new AsyncResource('invalid_trigger_id', { triggerAsyncId: null });
-}, {
-  code: 'ERR_INVALID_ASYNC_ID',
-  type: RangeError,
+common.expectsError(() => new AsyncResource(), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError
 });
+common.expectsError(
+  () => {
+    new AsyncResource('invalid_trigger_id', { triggerAsyncId: null });
+  },
+  {
+    code: 'ERR_INVALID_ASYNC_ID',
+    type: RangeError
+  }
+);
 
 assert.strictEqual(
   new AsyncResource('default_trigger_id').triggerAsyncId(),
@@ -33,7 +35,7 @@ assert.strictEqual(
 // from async_hooks executionAsyncId
 const alcaTriggerId = async_hooks.executionAsyncId();
 const alcaEvent = new AsyncResource('alcazares', alcaTriggerId);
-const alcazaresActivities = hooks.activitiesOfTypes([ 'alcazares' ]);
+const alcazaresActivities = hooks.activitiesOfTypes(['alcazares']);
 
 // alcazares event was constructed and thus only has an `init` call
 assert.strictEqual(alcazaresActivities.length, 1);
@@ -48,40 +50,53 @@ assert.notStrictEqual(alcaEvent.asyncId(), alcaTriggerId);
 assert.strictEqual(alcaEvent.triggerAsyncId(), alcaTriggerId);
 
 alcaEvent.emitBefore();
-checkInvocations(alcazares, { init: 1, before: 1 },
-                 'alcazares emitted before');
+checkInvocations(alcazares, { init: 1, before: 1 }, 'alcazares emitted before');
 alcaEvent.emitAfter();
-checkInvocations(alcazares, { init: 1, before: 1, after: 1 },
-                 'alcazares emitted after');
+checkInvocations(
+  alcazares,
+  { init: 1, before: 1, after: 1 },
+  'alcazares emitted after'
+);
 alcaEvent.emitBefore();
-checkInvocations(alcazares, { init: 1, before: 2, after: 1 },
-                 'alcazares emitted before again');
+checkInvocations(
+  alcazares,
+  { init: 1, before: 2, after: 1 },
+  'alcazares emitted before again'
+);
 alcaEvent.emitAfter();
-checkInvocations(alcazares, { init: 1, before: 2, after: 2 },
-                 'alcazares emitted after again');
+checkInvocations(
+  alcazares,
+  { init: 1, before: 2, after: 2 },
+  'alcazares emitted after again'
+);
 alcaEvent.emitDestroy();
 tick(1, common.mustCall(tick1));
 
 function tick1() {
-  checkInvocations(alcazares, { init: 1, before: 2, after: 2, destroy: 1 },
-                   'alcazares emitted destroy');
+  checkInvocations(
+    alcazares,
+    { init: 1, before: 2, after: 2, destroy: 1 },
+    'alcazares emitted destroy'
+  );
 
   // The below shows that we can pass any number as a trigger id
   const pobTriggerId = 111;
   const pobEvent = new AsyncResource('poblado', pobTriggerId);
-  const pobladoActivities = hooks.activitiesOfTypes([ 'poblado' ]);
+  const pobladoActivities = hooks.activitiesOfTypes(['poblado']);
   const poblado = pobladoActivities[0];
   assert.strictEqual(poblado.type, 'poblado');
   assert.strictEqual(typeof poblado.uid, 'number');
   assert.strictEqual(poblado.triggerAsyncId, pobTriggerId);
   checkInvocations(poblado, { init: 1 }, 'poblado constructed');
   pobEvent.emitBefore();
-  checkInvocations(poblado, { init: 1, before: 1 },
-                   'poblado emitted before');
+  checkInvocations(poblado, { init: 1, before: 1 }, 'poblado emitted before');
 
   pobEvent.emitAfter();
-  checkInvocations(poblado, { init: 1, before: 1, after: 1 },
-                   'poblado emitted after');
+  checkInvocations(
+    poblado,
+    { init: 1, before: 1, after: 1 },
+    'poblado emitted after'
+  );
 
   // after we disable the hooks we shouldn't receive any events anymore
   hooks.disable();
@@ -90,14 +105,19 @@ function tick1() {
 
   function tick2() {
     checkInvocations(
-      alcazares, { init: 1, before: 2, after: 2, destroy: 1 },
-      'alcazares emitted destroy a second time after hooks disabled');
+      alcazares,
+      { init: 1, before: 2, after: 2, destroy: 1 },
+      'alcazares emitted destroy a second time after hooks disabled'
+    );
     pobEvent.emitDestroy();
     tick(1, common.mustCall(tick3));
   }
 
   function tick3() {
-    checkInvocations(poblado, { init: 1, before: 1, after: 1 },
-                     'poblado emitted destroy after hooks disabled');
+    checkInvocations(
+      poblado,
+      { init: 1, before: 1, after: 1 },
+      'poblado emitted destroy after hooks disabled'
+    );
   }
 }
diff --git a/test/async-hooks/test-emit-before-after.js b/test/async-hooks/test-emit-before-after.js
index 6a9ceaeefb8c0a..28afd1a9857203 100644
--- a/test/async-hooks/test-emit-before-after.js
+++ b/test/async-hooks/test-emit-before-after.js
@@ -20,21 +20,26 @@ switch (process.argv[2]) {
 }
 assert.ok(!process.argv[2]);
 
-
 const c1 = spawnSync(process.execPath, [
-  '--expose-internals', __filename, 'test_invalid_async_id'
+  '--expose-internals',
+  __filename,
+  'test_invalid_async_id'
 ]);
 assert.strictEqual(
   c1.stderr.toString().split(/[\r\n]+/g)[0],
-  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid asyncId value: -2');
+  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid asyncId value: -2'
+);
 assert.strictEqual(c1.status, 1);
 
 const c2 = spawnSync(process.execPath, [
-  '--expose-internals', __filename, 'test_invalid_trigger_id'
+  '--expose-internals',
+  __filename,
+  'test_invalid_trigger_id'
 ]);
 assert.strictEqual(
   c2.stderr.toString().split(/[\r\n]+/g)[0],
-  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid triggerAsyncId value: -2');
+  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid triggerAsyncId value: -2'
+);
 assert.strictEqual(c2.status, 1);
 
 const expectedId = async_hooks.newAsyncId();
diff --git a/test/async-hooks/test-emit-init.js b/test/async-hooks/test-emit-init.js
index f5d5687cb4d11d..b4901fdc9975f4 100644
--- a/test/async-hooks/test-emit-init.js
+++ b/test/async-hooks/test-emit-init.js
@@ -36,34 +36,45 @@ switch (process.argv[2]) {
 }
 assert.ok(!process.argv[2]);
 
-
 const c1 = spawnSync(process.execPath, [
-  '--expose-internals', __filename, 'test_invalid_async_id'
+  '--expose-internals',
+  __filename,
+  'test_invalid_async_id'
 ]);
 assert.strictEqual(
   c1.stderr.toString().split(/[\r\n]+/g)[0],
-  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid asyncId value: undefined');
+  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid asyncId value: undefined'
+);
 assert.strictEqual(c1.status, 1);
 
 const c2 = spawnSync(process.execPath, [
-  '--expose-internals', __filename, 'test_invalid_trigger_id'
+  '--expose-internals',
+  __filename,
+  'test_invalid_trigger_id'
 ]);
 assert.strictEqual(
   c2.stderr.toString().split(/[\r\n]+/g)[0],
-  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid triggerAsyncId value: undefined');
+  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid triggerAsyncId value: undefined'
+);
 assert.strictEqual(c2.status, 1);
 
 const c3 = spawnSync(process.execPath, [
-  '--expose-internals', __filename, 'test_invalid_trigger_id_negative'
+  '--expose-internals',
+  __filename,
+  'test_invalid_trigger_id_negative'
 ]);
 assert.strictEqual(
   c3.stderr.toString().split(/[\r\n]+/g)[0],
-  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid triggerAsyncId value: -2');
+  'RangeError [ERR_INVALID_ASYNC_ID]: Invalid triggerAsyncId value: -2'
+);
 assert.strictEqual(c3.status, 1);
 
-
-async_hooks.emitInit(expectedId, expectedType, expectedTriggerId,
-                     expectedResource);
+async_hooks.emitInit(
+  expectedId,
+  expectedType,
+  expectedTriggerId,
+  expectedResource
+);
 
 hooks1.disable();
 
diff --git a/test/async-hooks/test-enable-disable.js b/test/async-hooks/test-enable-disable.js
index c14a125688d0f4..b6f9d07884215c 100644
--- a/test/async-hooks/test-enable-disable.js
+++ b/test/async-hooks/test-enable-disable.js
@@ -94,7 +94,7 @@ if (!common.isMainThread)
 
 // Include "Unknown"s because hook2 will not be able to identify
 // the type of the first Immediate  since it will miss its `init` invocation.
-const types = [ 'Immediate', 'Unknown' ];
+const types = ['Immediate', 'Unknown'];
 
 //
 // Initializing hooks
@@ -164,10 +164,16 @@ function onfirstImmediate() {
   assert.strictEqual(firstImmediate.type, 'Immediate');
   assert.strictEqual(typeof firstImmediate.uid, 'number');
   assert.strictEqual(typeof firstImmediate.triggerAsyncId, 'number');
-  checkInvocations(as1[0], { init: 1, before: 1 },
-                   'hook1[0]: on first immediate');
-  checkInvocations(as3[0], { init: 1, before: 1 },
-                   'hook3[0]: on first immediate');
+  checkInvocations(
+    as1[0],
+    { init: 1, before: 1 },
+    'hook1[0]: on first immediate'
+  );
+  checkInvocations(
+    as3[0],
+    { init: 1, before: 1 },
+    'hook3[0]: on first immediate'
+  );
 
   // Setup the second Immediate, note that now hook2 is enabled and thus
   // will capture all lifetime events of this Immediate
@@ -213,20 +219,38 @@ function onsecondImmediate() {
   assert.strictEqual(typeof secondImmediate.uid, 'number');
   assert.strictEqual(typeof secondImmediate.triggerAsyncId, 'number');
 
-  checkInvocations(hook1First, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'hook1First: on second immediate');
-  checkInvocations(hook1Second, { init: 1, before: 1 },
-                   'hook1Second: on second immediate');
+  checkInvocations(
+    hook1First,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'hook1First: on second immediate'
+  );
+  checkInvocations(
+    hook1Second,
+    { init: 1, before: 1 },
+    'hook1Second: on second immediate'
+  );
   // hook2 missed the "init" and "before" since it was enabled after they
   // occurred
-  checkInvocations(hook2First, { after: 1, destroy: 1 },
-                   'hook2First: on second immediate');
-  checkInvocations(hook2Second, { init: 1, before: 1 },
-                   'hook2Second: on second immediate');
-  checkInvocations(hook3First, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'hook3First: on second immediate');
-  checkInvocations(hook3Second, { init: 1, before: 1 },
-                   'hook3Second: on second immediate');
+  checkInvocations(
+    hook2First,
+    { after: 1, destroy: 1 },
+    'hook2First: on second immediate'
+  );
+  checkInvocations(
+    hook2Second,
+    { init: 1, before: 1 },
+    'hook2Second: on second immediate'
+  );
+  checkInvocations(
+    hook3First,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'hook3First: on second immediate'
+  );
+  checkInvocations(
+    hook3Second,
+    { init: 1, before: 1 },
+    'hook3Second: on second immediate'
+  );
   tick(1);
 }
 
@@ -247,22 +271,40 @@ function onexit() {
   hook2.sanityCheck();
   hook3.sanityCheck();
 
-  checkInvocations(hook1First, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'hook1First: when process exits');
+  checkInvocations(
+    hook1First,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'hook1First: when process exits'
+  );
   // hook1 was disabled during hook2's "before" of the second immediate
   // and thus did not see "after" and "destroy"
-  checkInvocations(hook1Second, { init: 1, before: 1 },
-                   'hook1Second: when process exits');
+  checkInvocations(
+    hook1Second,
+    { init: 1, before: 1 },
+    'hook1Second: when process exits'
+  );
   // hook2 missed the "init" and "before" since it was enabled after they
   // occurred
-  checkInvocations(hook2First, { after: 1, destroy: 1 },
-                   'hook2First: when process exits');
-  checkInvocations(hook2Second, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'hook2Second: when process exits');
-  checkInvocations(hook3First, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'hook3First: when process exits');
+  checkInvocations(
+    hook2First,
+    { after: 1, destroy: 1 },
+    'hook2First: when process exits'
+  );
+  checkInvocations(
+    hook2Second,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'hook2Second: when process exits'
+  );
+  checkInvocations(
+    hook3First,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'hook3First: when process exits'
+  );
   // we don't see a "destroy" invocation here since hook3 disabled itself
   // during its "after" invocation
-  checkInvocations(hook3Second, { init: 1, before: 1, after: 1 },
-                   'hook3Second: when process exits');
+  checkInvocations(
+    hook3Second,
+    { init: 1, before: 1, after: 1 },
+    'hook3Second: when process exits'
+  );
 }
diff --git a/test/async-hooks/test-enable-in-init.js b/test/async-hooks/test-enable-in-init.js
index e4be9f9f87e3eb..debab94ae97a53 100644
--- a/test/async-hooks/test-enable-in-init.js
+++ b/test/async-hooks/test-enable-in-init.js
@@ -9,14 +9,16 @@ const nestedHook = async_hooks.createHook({
 });
 let nestedCall = false;
 
-async_hooks.createHook({
-  init: common.mustCall(function(id, type) {
-    nestedHook.enable();
-    if (!nestedCall) {
-      nestedCall = true;
-      fs.access(__filename, common.mustCall());
-    }
-  }, 2)
-}).enable();
+async_hooks
+  .createHook({
+    init: common.mustCall(function(id, type) {
+      nestedHook.enable();
+      if (!nestedCall) {
+        nestedCall = true;
+        fs.access(__filename, common.mustCall());
+      }
+    }, 2)
+  })
+  .enable();
 
 fs.access(__filename, common.mustCall());
diff --git a/test/async-hooks/test-fseventwrap.js b/test/async-hooks/test-fseventwrap.js
index 8608075c822ded..dcc5eb3e91599a 100644
--- a/test/async-hooks/test-fseventwrap.js
+++ b/test/async-hooks/test-fseventwrap.js
@@ -14,7 +14,7 @@ const hooks = initHooks();
 
 hooks.enable();
 const watcher = fs.watch(__filename, onwatcherChanged);
-function onwatcherChanged() { }
+function onwatcherChanged() {}
 
 watcher.close();
 tick(2);
diff --git a/test/async-hooks/test-fsreqcallback-access.js b/test/async-hooks/test-fsreqcallback-access.js
index b1b75f5693050d..e7c53649785740 100644
--- a/test/async-hooks/test-fsreqcallback-access.js
+++ b/test/async-hooks/test-fsreqcallback-access.js
@@ -15,8 +15,7 @@ fs.access(__filename, common.mustCall(onaccess));
 function onaccess() {
   const as = hooks.activitiesOfTypes('FSREQCALLBACK');
   const a = as[0];
-  checkInvocations(a, { init: 1, before: 1 },
-                   'while in onaccess callback');
+  checkInvocations(a, { init: 1, before: 1 }, 'while in onaccess callback');
   tick(2);
 }
 
@@ -32,6 +31,9 @@ function onexit() {
   const a = as[0];
   assert.strictEqual(a.type, 'FSREQCALLBACK');
   assert.strictEqual(typeof a.uid, 'number');
-  checkInvocations(a, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    a,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-fsreqcallback-readFile.js b/test/async-hooks/test-fsreqcallback-readFile.js
index 3ae31378cd3199..6203f319db5286 100644
--- a/test/async-hooks/test-fsreqcallback-readFile.js
+++ b/test/async-hooks/test-fsreqcallback-readFile.js
@@ -25,17 +25,29 @@ function onread() {
     assert.strictEqual(a.triggerAsyncId, lastParent);
     lastParent = a.uid;
   }
-  checkInvocations(as[0], { init: 1, before: 1, after: 1, destroy: 1 },
-                   'reqwrap[0]: while in onread callback');
-  checkInvocations(as[1], { init: 1, before: 1, after: 1, destroy: 1 },
-                   'reqwrap[1]: while in onread callback');
-  checkInvocations(as[2], { init: 1, before: 1, after: 1, destroy: 1 },
-                   'reqwrap[2]: while in onread callback');
+  checkInvocations(
+    as[0],
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'reqwrap[0]: while in onread callback'
+  );
+  checkInvocations(
+    as[1],
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'reqwrap[1]: while in onread callback'
+  );
+  checkInvocations(
+    as[2],
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'reqwrap[2]: while in onread callback'
+  );
 
   // this callback is called from within the last fs req callback therefore
   // the last req is still going and after/destroy haven't been called yet
-  checkInvocations(as[3], { init: 1, before: 1 },
-                   'reqwrap[3]: while in onread callback');
+  checkInvocations(
+    as[3],
+    { init: 1, before: 1 },
+    'reqwrap[3]: while in onread callback'
+  );
   tick(2);
 }
 
@@ -46,6 +58,9 @@ function onexit() {
   hooks.sanityCheck('FSREQCALLBACK');
   const as = hooks.activitiesOfTypes('FSREQCALLBACK');
   const a = as.pop();
-  checkInvocations(a, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    a,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-getaddrinforeqwrap.js b/test/async-hooks/test-getaddrinforeqwrap.js
index f2a978d7640677..b88e242b4f0da5 100644
--- a/test/async-hooks/test-getaddrinforeqwrap.js
+++ b/test/async-hooks/test-getaddrinforeqwrap.js
@@ -37,6 +37,9 @@ function onexit() {
 
   const as = hooks.activitiesOfTypes('GETADDRINFOREQWRAP');
   const a = as[0];
-  checkInvocations(a, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    a,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-getnameinforeqwrap.js b/test/async-hooks/test-getnameinforeqwrap.js
index 9e06cbf9cbf174..e0885d58b143dc 100644
--- a/test/async-hooks/test-getnameinforeqwrap.js
+++ b/test/async-hooks/test-getnameinforeqwrap.js
@@ -25,8 +25,11 @@ function onlookupService() {
   assert.strictEqual(a.type, 'GETNAMEINFOREQWRAP');
   assert.strictEqual(typeof a.uid, 'number');
   assert.strictEqual(a.triggerAsyncId, 1);
-  checkInvocations(a, { init: 1, before: 1 },
-                   'while in onlookupService callback');
+  checkInvocations(
+    a,
+    { init: 1, before: 1 },
+    'while in onlookupService callback'
+  );
   tick(2);
 }
 
@@ -38,6 +41,9 @@ function onexit() {
 
   const as = hooks.activitiesOfTypes('GETNAMEINFOREQWRAP');
   const a = as[0];
-  checkInvocations(a, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    a,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-graph.fsreq-readFile.js b/test/async-hooks/test-graph.fsreq-readFile.js
index 0a310ed5774a67..ded03c2f01fc6a 100644
--- a/test/async-hooks/test-graph.fsreq-readFile.js
+++ b/test/async-hooks/test-graph.fsreq-readFile.js
@@ -16,11 +16,10 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  verifyGraph(
-    hooks,
-    [ { type: 'FSREQCALLBACK', id: 'fsreq:1', triggerAsyncId: null },
-      { type: 'FSREQCALLBACK', id: 'fsreq:2', triggerAsyncId: 'fsreq:1' },
-      { type: 'FSREQCALLBACK', id: 'fsreq:3', triggerAsyncId: 'fsreq:2' },
-      { type: 'FSREQCALLBACK', id: 'fsreq:4', triggerAsyncId: 'fsreq:3' } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'FSREQCALLBACK', id: 'fsreq:1', triggerAsyncId: null },
+    { type: 'FSREQCALLBACK', id: 'fsreq:2', triggerAsyncId: 'fsreq:1' },
+    { type: 'FSREQCALLBACK', id: 'fsreq:3', triggerAsyncId: 'fsreq:2' },
+    { type: 'FSREQCALLBACK', id: 'fsreq:4', triggerAsyncId: 'fsreq:3' }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.http.js b/test/async-hooks/test-graph.http.js
index 414ebabeeeaea4..357505a02a4323 100644
--- a/test/async-hooks/test-graph.http.js
+++ b/test/async-hooks/test-graph.http.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasIPv6)
-  common.skip('IPv6 support required');
+if (!common.hasIPv6) common.skip('IPv6 support required');
 
 const initHooks = require('./init-hooks');
 const verifyGraph = require('./verify-graph');
@@ -11,43 +10,38 @@ const http = require('http');
 const hooks = initHooks();
 hooks.enable();
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  res.end();
-  this.close(common.mustCall());
-}));
-server.listen(0, common.mustCall(function() {
-  http.get({
-    host: '::1',
-    family: 6,
-    port: server.address().port
-  }, common.mustCall());
-}));
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    res.end();
+    this.close(common.mustCall());
+  })
+);
+server.listen(
+  0,
+  common.mustCall(function() {
+    http.get(
+      {
+        host: '::1',
+        family: 6,
+        port: server.address().port
+      },
+      common.mustCall()
+    );
+  })
+);
 
 process.on('exit', function() {
   hooks.disable();
 
-  verifyGraph(
-    hooks,
-    [ { type: 'TCPSERVERWRAP',
-        id: 'tcpserver:1',
-        triggerAsyncId: null },
-      { type: 'TCPWRAP', id: 'tcp:1', triggerAsyncId: 'tcpserver:1' },
-      { type: 'TCPCONNECTWRAP',
-        id: 'tcpconnect:1',
-        triggerAsyncId: 'tcp:1' },
-      { type: 'HTTPPARSER',
-        id: 'httpparser:1',
-        triggerAsyncId: 'tcpserver:1' },
-      { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
-      { type: 'Timeout', id: 'timeout:1', triggerAsyncId: 'tcp:2' },
-      { type: 'HTTPPARSER',
-        id: 'httpparser:2',
-        triggerAsyncId: 'tcp:2' },
-      { type: 'Timeout',
-        id: 'timeout:2',
-        triggerAsyncId: 'httpparser:2' },
-      { type: 'SHUTDOWNWRAP',
-        id: 'shutdown:1',
-        triggerAsyncId: 'tcp:2' } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'TCPSERVERWRAP', id: 'tcpserver:1', triggerAsyncId: null },
+    { type: 'TCPWRAP', id: 'tcp:1', triggerAsyncId: 'tcpserver:1' },
+    { type: 'TCPCONNECTWRAP', id: 'tcpconnect:1', triggerAsyncId: 'tcp:1' },
+    { type: 'HTTPPARSER', id: 'httpparser:1', triggerAsyncId: 'tcpserver:1' },
+    { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
+    { type: 'Timeout', id: 'timeout:1', triggerAsyncId: 'tcp:2' },
+    { type: 'HTTPPARSER', id: 'httpparser:2', triggerAsyncId: 'tcp:2' },
+    { type: 'Timeout', id: 'timeout:2', triggerAsyncId: 'httpparser:2' },
+    { type: 'SHUTDOWNWRAP', id: 'shutdown:1', triggerAsyncId: 'tcp:2' }
+  ]);
 });
diff --git a/test/async-hooks/test-graph.intervals.js b/test/async-hooks/test-graph.intervals.js
index 8aa46ab07b5471..9d6452dba18eb3 100644
--- a/test/async-hooks/test-graph.intervals.js
+++ b/test/async-hooks/test-graph.intervals.js
@@ -27,9 +27,8 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  verifyGraph(
-    hooks,
-    [ { type: 'Timeout', id: 'timeout:1', triggerAsyncId: null },
-      { type: 'Timeout', id: 'timeout:2', triggerAsyncId: 'timeout:1' }]
-  );
+  verifyGraph(hooks, [
+    { type: 'Timeout', id: 'timeout:1', triggerAsyncId: null },
+    { type: 'Timeout', id: 'timeout:2', triggerAsyncId: 'timeout:1' }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.pipe.js b/test/async-hooks/test-graph.pipe.js
index 162fb3639bfbfc..4dcc5098dee8d3 100644
--- a/test/async-hooks/test-graph.pipe.js
+++ b/test/async-hooks/test-graph.pipe.js
@@ -8,7 +8,7 @@ const spawn = require('child_process').spawn;
 const hooks = initHooks();
 
 hooks.enable();
-const sleep = spawn('sleep', [ '0.1' ]);
+const sleep = spawn('sleep', ['0.1']);
 
 sleep
   .on('exit', common.mustCall(onsleepExit))
@@ -22,11 +22,10 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  verifyGraph(
-    hooks,
-    [ { type: 'PROCESSWRAP', id: 'process:1', triggerAsyncId: null },
-      { type: 'PIPEWRAP', id: 'pipe:1', triggerAsyncId: null },
-      { type: 'PIPEWRAP', id: 'pipe:2', triggerAsyncId: null },
-      { type: 'PIPEWRAP', id: 'pipe:3', triggerAsyncId: null } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'PROCESSWRAP', id: 'process:1', triggerAsyncId: null },
+    { type: 'PIPEWRAP', id: 'pipe:1', triggerAsyncId: null },
+    { type: 'PIPEWRAP', id: 'pipe:2', triggerAsyncId: null },
+    { type: 'PIPEWRAP', id: 'pipe:3', triggerAsyncId: null }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.pipeconnect.js b/test/async-hooks/test-graph.pipeconnect.js
index 03d2902c835d48..d0a018fcd10dcf 100644
--- a/test/async-hooks/test-graph.pipeconnect.js
+++ b/test/async-hooks/test-graph.pipeconnect.js
@@ -12,13 +12,18 @@ tmpdir.refresh();
 const hooks = initHooks();
 hooks.enable();
 
-net.createServer(function(c) {
-  c.end();
-  this.close();
-}).listen(common.PIPE, common.mustCall(onlisten));
+net
+  .createServer(function(c) {
+    c.end();
+    this.close();
+  })
+  .listen(common.PIPE, common.mustCall(onlisten));
 
 function onlisten() {
-  net.connect(common.PIPE, common.mustCall(onconnect));
+  net.connect(
+    common.PIPE,
+    common.mustCall(onconnect)
+  );
 }
 
 function onconnect() {}
@@ -27,13 +32,11 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  verifyGraph(
-    hooks,
-    [ { type: 'PIPESERVERWRAP', id: 'pipeserver:1', triggerAsyncId: null },
-      { type: 'PIPEWRAP', id: 'pipe:1', triggerAsyncId: 'pipeserver:1' },
-      { type: 'PIPECONNECTWRAP', id: 'pipeconnect:1',
-        triggerAsyncId: 'pipe:1' },
-      { type: 'PIPEWRAP', id: 'pipe:2', triggerAsyncId: 'pipeserver:1' },
-      { type: 'SHUTDOWNWRAP', id: 'shutdown:1', triggerAsyncId: 'pipe:2' } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'PIPESERVERWRAP', id: 'pipeserver:1', triggerAsyncId: null },
+    { type: 'PIPEWRAP', id: 'pipe:1', triggerAsyncId: 'pipeserver:1' },
+    { type: 'PIPECONNECTWRAP', id: 'pipeconnect:1', triggerAsyncId: 'pipe:1' },
+    { type: 'PIPEWRAP', id: 'pipe:2', triggerAsyncId: 'pipeserver:1' },
+    { type: 'SHUTDOWNWRAP', id: 'shutdown:1', triggerAsyncId: 'pipe:2' }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.shutdown.js b/test/async-hooks/test-graph.shutdown.js
index f4f077c0dd1c83..b7b6f50fcaf67a 100644
--- a/test/async-hooks/test-graph.shutdown.js
+++ b/test/async-hooks/test-graph.shutdown.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasIPv6)
-  common.skip('IPv6 support required');
+if (!common.hasIPv6) common.skip('IPv6 support required');
 
 const initHooks = require('./init-hooks');
 const verifyGraph = require('./verify-graph');
@@ -16,7 +15,10 @@ const server = net
   .on('listening', common.mustCall(onlistening));
 server.listen();
 function onlistening() {
-  net.connect(server.address().port, common.mustCall(onconnected));
+  net.connect(
+    server.address().port,
+    common.mustCall(onconnected)
+  );
 }
 
 function onconnection(c) {
@@ -32,15 +34,16 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  verifyGraph(
-    hooks,
-    [ { type: 'TCPSERVERWRAP', id: 'tcpserver:1', triggerAsyncId: null },
-      { type: 'TCPWRAP', id: 'tcp:1', triggerAsyncId: 'tcpserver:1' },
-      { type: 'GETADDRINFOREQWRAP',
-        id: 'getaddrinforeq:1', triggerAsyncId: 'tcp:1' },
-      { type: 'TCPCONNECTWRAP',
-        id: 'tcpconnect:1', triggerAsyncId: 'tcp:1' },
-      { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
-      { type: 'SHUTDOWNWRAP', id: 'shutdown:1', triggerAsyncId: 'tcp:2' } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'TCPSERVERWRAP', id: 'tcpserver:1', triggerAsyncId: null },
+    { type: 'TCPWRAP', id: 'tcp:1', triggerAsyncId: 'tcpserver:1' },
+    {
+      type: 'GETADDRINFOREQWRAP',
+      id: 'getaddrinforeq:1',
+      triggerAsyncId: 'tcp:1'
+    },
+    { type: 'TCPCONNECTWRAP', id: 'tcpconnect:1', triggerAsyncId: 'tcp:1' },
+    { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
+    { type: 'SHUTDOWNWRAP', id: 'shutdown:1', triggerAsyncId: 'tcp:2' }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.signal.js b/test/async-hooks/test-graph.signal.js
index 4c5b857fc2e08f..f5f318bc4d5e81 100644
--- a/test/async-hooks/test-graph.signal.js
+++ b/test/async-hooks/test-graph.signal.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (common.isWindows)
-  common.skip('no signals on Windows');
+if (common.isWindows) common.skip('no signals on Windows');
 if (!common.isMainThread)
   common.skip('No signal handling available in Workers');
 
@@ -42,21 +41,20 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  verifyGraph(
-    hooks,
-    [ { type: 'SIGNALWRAP', id: 'signal:1', triggerAsyncId: null },
-      { type: 'PROCESSWRAP', id: 'process:1', triggerAsyncId: null },
-      { type: 'PIPEWRAP', id: 'pipe:1', triggerAsyncId: null },
-      { type: 'PIPEWRAP', id: 'pipe:2', triggerAsyncId: null },
-      { type: 'PIPEWRAP', id: 'pipe:3', triggerAsyncId: null },
-      { type: 'PROCESSWRAP', id: 'process:2', triggerAsyncId: 'signal:1' },
-      { type: 'PIPEWRAP', id: 'pipe:4', triggerAsyncId: 'signal:1' },
-      { type: 'PIPEWRAP', id: 'pipe:5', triggerAsyncId: 'signal:1' },
-      { type: 'PIPEWRAP', id: 'pipe:6', triggerAsyncId: 'signal:1' },
-      { type: 'SIGNALWRAP', id: 'signal:2', triggerAsyncId: 'signal:1' },
-      { type: 'PROCESSWRAP', id: 'process:3', triggerAsyncId: 'signal:1' },
-      { type: 'PIPEWRAP', id: 'pipe:7', triggerAsyncId: 'signal:1' },
-      { type: 'PIPEWRAP', id: 'pipe:8', triggerAsyncId: 'signal:1' },
-      { type: 'PIPEWRAP', id: 'pipe:9', triggerAsyncId: 'signal:1' } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'SIGNALWRAP', id: 'signal:1', triggerAsyncId: null },
+    { type: 'PROCESSWRAP', id: 'process:1', triggerAsyncId: null },
+    { type: 'PIPEWRAP', id: 'pipe:1', triggerAsyncId: null },
+    { type: 'PIPEWRAP', id: 'pipe:2', triggerAsyncId: null },
+    { type: 'PIPEWRAP', id: 'pipe:3', triggerAsyncId: null },
+    { type: 'PROCESSWRAP', id: 'process:2', triggerAsyncId: 'signal:1' },
+    { type: 'PIPEWRAP', id: 'pipe:4', triggerAsyncId: 'signal:1' },
+    { type: 'PIPEWRAP', id: 'pipe:5', triggerAsyncId: 'signal:1' },
+    { type: 'PIPEWRAP', id: 'pipe:6', triggerAsyncId: 'signal:1' },
+    { type: 'SIGNALWRAP', id: 'signal:2', triggerAsyncId: 'signal:1' },
+    { type: 'PROCESSWRAP', id: 'process:3', triggerAsyncId: 'signal:1' },
+    { type: 'PIPEWRAP', id: 'pipe:7', triggerAsyncId: 'signal:1' },
+    { type: 'PIPEWRAP', id: 'pipe:8', triggerAsyncId: 'signal:1' },
+    { type: 'PIPEWRAP', id: 'pipe:9', triggerAsyncId: 'signal:1' }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.statwatcher.js b/test/async-hooks/test-graph.statwatcher.js
index 3067045d2bf8ac..1b0af1b8f0d88c 100644
--- a/test/async-hooks/test-graph.statwatcher.js
+++ b/test/async-hooks/test-graph.statwatcher.js
@@ -9,7 +9,7 @@ const fs = require('fs');
 const hooks = initHooks();
 hooks.enable();
 
-function onchange() { }
+function onchange() {}
 // install first file watcher
 fs.watchFile(__filename, onchange);
 
@@ -26,9 +26,8 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  verifyGraph(
-    hooks,
-    [ { type: 'STATWATCHER', id: 'statwatcher:1', triggerAsyncId: null },
-      { type: 'STATWATCHER', id: 'statwatcher:2', triggerAsyncId: null } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'STATWATCHER', id: 'statwatcher:1', triggerAsyncId: null },
+    { type: 'STATWATCHER', id: 'statwatcher:2', triggerAsyncId: null }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.tcp.js b/test/async-hooks/test-graph.tcp.js
index c2253486ee651e..c75908e5317ddb 100644
--- a/test/async-hooks/test-graph.tcp.js
+++ b/test/async-hooks/test-graph.tcp.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasIPv6)
-  common.skip('IPv6 support required');
+if (!common.hasIPv6) common.skip('IPv6 support required');
 
 const initHooks = require('./init-hooks');
 const verifyGraph = require('./verify-graph');
@@ -17,8 +16,10 @@ const server = net
 
 server.listen(0);
 
-net.connect({ port: server.address().port, host: '::1' },
-            common.mustCall(onconnected));
+net.connect(
+  { port: server.address().port, host: '::1' },
+  common.mustCall(onconnected)
+);
 
 function onlistening() {}
 
@@ -36,13 +37,11 @@ process.on('exit', onexit);
 function onexit() {
   hooks.disable();
 
-  verifyGraph(
-    hooks,
-    [ { type: 'TCPSERVERWRAP', id: 'tcpserver:1', triggerAsyncId: null },
-      { type: 'TCPWRAP', id: 'tcp:1', triggerAsyncId: null },
-      { type: 'TCPCONNECTWRAP',
-        id: 'tcpconnect:1', triggerAsyncId: 'tcp:1' },
-      { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
-      { type: 'SHUTDOWNWRAP', id: 'shutdown:1', triggerAsyncId: 'tcp:2' } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'TCPSERVERWRAP', id: 'tcpserver:1', triggerAsyncId: null },
+    { type: 'TCPWRAP', id: 'tcp:1', triggerAsyncId: null },
+    { type: 'TCPCONNECTWRAP', id: 'tcpconnect:1', triggerAsyncId: 'tcp:1' },
+    { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
+    { type: 'SHUTDOWNWRAP', id: 'shutdown:1', triggerAsyncId: 'tcp:2' }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.timeouts.js b/test/async-hooks/test-graph.timeouts.js
index 2ec1420f0c03b1..e8fb26cf677a1a 100644
--- a/test/async-hooks/test-graph.timeouts.js
+++ b/test/async-hooks/test-graph.timeouts.js
@@ -23,10 +23,9 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  verifyGraph(
-    hooks,
-    [ { type: 'Timeout', id: 'timeout:1', triggerAsyncId: null },
-      { type: 'Timeout', id: 'timeout:2', triggerAsyncId: 'timeout:1' },
-      { type: 'Timeout', id: 'timeout:3', triggerAsyncId: 'timeout:2' }]
-  );
+  verifyGraph(hooks, [
+    { type: 'Timeout', id: 'timeout:1', triggerAsyncId: null },
+    { type: 'Timeout', id: 'timeout:2', triggerAsyncId: 'timeout:1' },
+    { type: 'Timeout', id: 'timeout:3', triggerAsyncId: 'timeout:2' }
+  ]);
 }
diff --git a/test/async-hooks/test-graph.tls-write.js b/test/async-hooks/test-graph.tls-write.js
index 2ea03283e4c861..a0c504be1cd779 100644
--- a/test/async-hooks/test-graph.tls-write.js
+++ b/test/async-hooks/test-graph.tls-write.js
@@ -1,11 +1,9 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.hasIPv6)
-  common.skip('IPv6 support required');
+if (!common.hasIPv6) common.skip('IPv6 support required');
 
 const initHooks = require('./init-hooks');
 const verifyGraph = require('./verify-graph');
@@ -32,7 +30,10 @@ function onlistening() {
   // Creating client and connecting it to server
   //
   tls
-    .connect(server.address().port, { rejectUnauthorized: false })
+    .connect(
+      server.address().port,
+      { rejectUnauthorized: false }
+    )
     .on('secureConnect', common.mustCall(onsecureConnect));
 }
 
@@ -53,22 +54,23 @@ process.on('exit', onexit);
 function onexit() {
   hooks.disable();
 
-  verifyGraph(
-    hooks,
-    [ { type: 'TCPSERVERWRAP', id: 'tcpserver:1', triggerAsyncId: null },
-      { type: 'TCPWRAP', id: 'tcp:1', triggerAsyncId: 'tcpserver:1' },
-      { type: 'TLSWRAP', id: 'tls:1', triggerAsyncId: 'tcpserver:1' },
-      { type: 'GETADDRINFOREQWRAP',
-        id: 'getaddrinforeq:1', triggerAsyncId: 'tls:1' },
-      { type: 'TCPCONNECTWRAP',
-        id: 'tcpconnect:1', triggerAsyncId: 'tcp:1' },
-      { type: 'WRITEWRAP', id: 'write:1', triggerAsyncId: 'tcpconnect:1' },
-      { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
-      { type: 'TLSWRAP', id: 'tls:2', triggerAsyncId: 'tcpserver:1' },
-      { type: 'WRITEWRAP', id: 'write:2', triggerAsyncId: null },
-      { type: 'WRITEWRAP', id: 'write:3', triggerAsyncId: null },
-      { type: 'WRITEWRAP', id: 'write:4', triggerAsyncId: null },
-      { type: 'Immediate', id: 'immediate:1', triggerAsyncId: 'tcp:1' },
-      { type: 'Immediate', id: 'immediate:2', triggerAsyncId: 'tcp:2' } ]
-  );
+  verifyGraph(hooks, [
+    { type: 'TCPSERVERWRAP', id: 'tcpserver:1', triggerAsyncId: null },
+    { type: 'TCPWRAP', id: 'tcp:1', triggerAsyncId: 'tcpserver:1' },
+    { type: 'TLSWRAP', id: 'tls:1', triggerAsyncId: 'tcpserver:1' },
+    {
+      type: 'GETADDRINFOREQWRAP',
+      id: 'getaddrinforeq:1',
+      triggerAsyncId: 'tls:1'
+    },
+    { type: 'TCPCONNECTWRAP', id: 'tcpconnect:1', triggerAsyncId: 'tcp:1' },
+    { type: 'WRITEWRAP', id: 'write:1', triggerAsyncId: 'tcpconnect:1' },
+    { type: 'TCPWRAP', id: 'tcp:2', triggerAsyncId: 'tcpserver:1' },
+    { type: 'TLSWRAP', id: 'tls:2', triggerAsyncId: 'tcpserver:1' },
+    { type: 'WRITEWRAP', id: 'write:2', triggerAsyncId: null },
+    { type: 'WRITEWRAP', id: 'write:3', triggerAsyncId: null },
+    { type: 'WRITEWRAP', id: 'write:4', triggerAsyncId: null },
+    { type: 'Immediate', id: 'immediate:1', triggerAsyncId: 'tcp:1' },
+    { type: 'Immediate', id: 'immediate:2', triggerAsyncId: 'tcp:2' }
+  ]);
 }
diff --git a/test/async-hooks/test-httpparser.request.js b/test/async-hooks/test-httpparser.request.js
index cb56419137163a..abb852a183b52c 100644
--- a/test/async-hooks/test-httpparser.request.js
+++ b/test/async-hooks/test-httpparser.request.js
@@ -22,9 +22,7 @@ const REQUEST = HTTPParser.REQUEST;
 
 const kOnHeadersComplete = HTTPParser.kOnHeadersComplete | 0;
 
-const request = Buffer.from(
-  'GET /hello HTTP/1.1\r\n\r\n'
-);
+const request = Buffer.from('GET /hello HTTP/1.1\r\n\r\n');
 
 const parser = new HTTPParser(REQUEST);
 const as = hooks.activitiesOfTypes('HTTPPARSER');
@@ -39,8 +37,11 @@ parser[kOnHeadersComplete] = common.mustCall(onheadersComplete);
 parser.execute(request, 0, request.length);
 
 function onheadersComplete() {
-  checkInvocations(httpparser, { init: 1, before: 1 },
-                   'when onheadersComplete called');
+  checkInvocations(
+    httpparser,
+    { init: 1, before: 1 },
+    'when onheadersComplete called'
+  );
   tick(1, common.mustCall(tick1));
 }
 
@@ -54,6 +55,9 @@ process.on('exit', onexit);
 function onexit() {
   hooks.disable();
   hooks.sanityCheck('HTTPPARSER');
-  checkInvocations(httpparser, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    httpparser,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-httpparser.response.js b/test/async-hooks/test-httpparser.response.js
index b1f804ef7d42a9..df14eae50313c7 100644
--- a/test/async-hooks/test-httpparser.response.js
+++ b/test/async-hooks/test-httpparser.response.js
@@ -25,10 +25,10 @@ const kOnBody = HTTPParser.kOnBody | 0;
 
 const request = Buffer.from(
   'HTTP/1.1 200 OK\r\n' +
-  'Content-Type: text/plain\r\n' +
-  'Content-Length: 4\r\n' +
-  '\r\n' +
-  'pong'
+    'Content-Type: text/plain\r\n' +
+    'Content-Length: 4\r\n' +
+    '\r\n' +
+    'pong'
 );
 
 const parser = new HTTPParser(RESPONSE);
@@ -45,13 +45,19 @@ parser[kOnBody] = common.mustCall(onbody);
 parser.execute(request, 0, request.length);
 
 function onheadersComplete() {
-  checkInvocations(httpparser, { init: 1, before: 1 },
-                   'when onheadersComplete called');
+  checkInvocations(
+    httpparser,
+    { init: 1, before: 1 },
+    'when onheadersComplete called'
+  );
 }
 
 function onbody() {
-  checkInvocations(httpparser, { init: 1, before: 2, after: 1 },
-                   'when onbody called');
+  checkInvocations(
+    httpparser,
+    { init: 1, before: 2, after: 1 },
+    'when onbody called'
+  );
   tick(1, common.mustCall(tick1));
 }
 
@@ -65,6 +71,9 @@ process.on('exit', onexit);
 function onexit() {
   hooks.disable();
   hooks.sanityCheck('HTTPPARSER');
-  checkInvocations(httpparser, { init: 1, before: 2, after: 2, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    httpparser,
+    { init: 1, before: 2, after: 2, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-immediate.js b/test/async-hooks/test-immediate.js
index 7b51902f77cbeb..08cfd7df74bb0a 100644
--- a/test/async-hooks/test-immediate.js
+++ b/test/async-hooks/test-immediate.js
@@ -18,16 +18,18 @@ const imd1 = as[0];
 assert.strictEqual(imd1.type, 'Immediate');
 assert.strictEqual(typeof imd1.uid, 'number');
 assert.strictEqual(typeof imd1.triggerAsyncId, 'number');
-checkInvocations(imd1, { init: 1 },
-                 'imd1: when first set immediate installed');
+checkInvocations(imd1, { init: 1 }, 'imd1: when first set immediate installed');
 
 let imd2;
 
 function onimmediate() {
   let as = hooks.activitiesOfTypes('Immediate');
   assert.strictEqual(as.length, 1);
-  checkInvocations(imd1, { init: 1, before: 1 },
-                   'imd1: when first set immediate triggered');
+  checkInvocations(
+    imd1,
+    { init: 1, before: 1 },
+    'imd1: when first set immediate triggered'
+  );
 
   // install second immediate
   setImmediate(common.mustCall(onimmediateTwo));
@@ -37,17 +39,29 @@ function onimmediate() {
   assert.strictEqual(imd2.type, 'Immediate');
   assert.strictEqual(typeof imd2.uid, 'number');
   assert.strictEqual(typeof imd2.triggerAsyncId, 'number');
-  checkInvocations(imd1, { init: 1, before: 1 },
-                   'imd1: when second set immediate installed');
-  checkInvocations(imd2, { init: 1 },
-                   'imd2: when second set immediate installed');
+  checkInvocations(
+    imd1,
+    { init: 1, before: 1 },
+    'imd1: when second set immediate installed'
+  );
+  checkInvocations(
+    imd2,
+    { init: 1 },
+    'imd2: when second set immediate installed'
+  );
 }
 
 function onimmediateTwo() {
-  checkInvocations(imd1, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'imd1: when second set immediate triggered');
-  checkInvocations(imd2, { init: 1, before: 1 },
-                   'imd2: when second set immediate triggered');
+  checkInvocations(
+    imd1,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'imd1: when second set immediate triggered'
+  );
+  checkInvocations(
+    imd2,
+    { init: 1, before: 1 },
+    'imd2: when second set immediate triggered'
+  );
   tick(1);
 }
 
@@ -56,8 +70,14 @@ process.on('exit', onexit);
 function onexit() {
   hooks.disable();
   hooks.sanityCheck('Immediate');
-  checkInvocations(imd1, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'imd1: when process exits');
-  checkInvocations(imd2, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'imd2: when process exits');
+  checkInvocations(
+    imd1,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'imd1: when process exits'
+  );
+  checkInvocations(
+    imd2,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'imd2: when process exits'
+  );
 }
diff --git a/test/async-hooks/test-nexttick-default-trigger.js b/test/async-hooks/test-nexttick-default-trigger.js
index 1bc93f29737389..1559a7b3881ffc 100644
--- a/test/async-hooks/test-nexttick-default-trigger.js
+++ b/test/async-hooks/test-nexttick-default-trigger.js
@@ -14,15 +14,24 @@ hooks.enable();
 
 const rootAsyncId = async_hooks.executionAsyncId();
 
-process.nextTick(common.mustCall(function() {
-  assert.strictEqual(async_hooks.triggerAsyncId(), rootAsyncId);
-}));
+process.nextTick(
+  common.mustCall(function() {
+    assert.strictEqual(async_hooks.triggerAsyncId(), rootAsyncId);
+  })
+);
 
 process.on('exit', function() {
   hooks.sanityCheck();
 
   const as = hooks.activitiesOfTypes('TickObject');
-  checkInvocations(as[0], {
-    init: 1, before: 1, after: 1, destroy: 1
-  }, 'when process exits');
+  checkInvocations(
+    as[0],
+    {
+      init: 1,
+      before: 1,
+      after: 1,
+      destroy: 1
+    },
+    'when process exits'
+  );
 });
diff --git a/test/async-hooks/test-no-assert-when-disabled.js b/test/async-hooks/test-no-assert-when-disabled.js
index 70114d1e1140f8..c7ab6ca3efe45e 100644
--- a/test/async-hooks/test-no-assert-when-disabled.js
+++ b/test/async-hooks/test-no-assert-when-disabled.js
@@ -3,7 +3,7 @@
 const common = require('../common');
 
 if (!common.isMainThread)
-  common.skip('Workers don\'t inherit per-env state like the check flag');
+  common.skip("Workers don't inherit per-env state like the check flag");
 
 const async_hooks = require('internal/async_hooks');
 
diff --git a/test/async-hooks/test-pipeconnectwrap.js b/test/async-hooks/test-pipeconnectwrap.js
index 6c68186e2f239f..d55039b08ebab7 100644
--- a/test/async-hooks/test-pipeconnectwrap.js
+++ b/test/async-hooks/test-pipeconnectwrap.js
@@ -17,11 +17,15 @@ let pipe1, pipe2;
 let pipeserver;
 let pipeconnect;
 
-net.createServer(common.mustCall(function(c) {
-  c.end();
-  this.close();
-  process.nextTick(maybeOnconnect.bind(null, 'server'));
-})).listen(common.PIPE, common.mustCall(onlisten));
+net
+  .createServer(
+    common.mustCall(function(c) {
+      c.end();
+      this.close();
+      process.nextTick(maybeOnconnect.bind(null, 'server'));
+    })
+  )
+  .listen(common.PIPE, common.mustCall(onlisten));
 
 function onlisten() {
   const pipeservers = hooks.activitiesOfTypes('PIPESERVERWRAP');
@@ -29,8 +33,10 @@ function onlisten() {
   assert.strictEqual(pipeservers.length, 1);
   assert.strictEqual(pipeconnects.length, 0);
 
-  net.connect(common.PIPE,
-              common.mustCall(maybeOnconnect.bind(null, 'client')));
+  net.connect(
+    common.PIPE,
+    common.mustCall(maybeOnconnect.bind(null, 'client'))
+  );
 
   const pipes = hooks.activitiesOfTypes('PIPEWRAP');
   pipeconnects = hooks.activitiesOfTypes('PIPECONNECTWRAP');
@@ -44,7 +50,7 @@ function onlisten() {
   assert.strictEqual(pipeserver.type, 'PIPESERVERWRAP');
   assert.strictEqual(pipe1.type, 'PIPEWRAP');
   assert.strictEqual(pipeconnect.type, 'PIPECONNECTWRAP');
-  for (const a of [ pipeserver, pipe1, pipeconnect ]) {
+  for (const a of [pipeserver, pipe1, pipeconnect]) {
     assert.strictEqual(typeof a.uid, 'number');
     assert.strictEqual(typeof a.triggerAsyncId, 'number');
     checkInvocations(a, { init: 1 }, 'after net.connect');
@@ -68,11 +74,17 @@ function maybeOnconnect(source) {
   assert.strictEqual(typeof pipe2.uid, 'number');
   assert.strictEqual(typeof pipe2.triggerAsyncId, 'number');
 
-  checkInvocations(pipeserver, { init: 1, before: 1, after: 1 },
-                   'pipeserver, client connected');
+  checkInvocations(
+    pipeserver,
+    { init: 1, before: 1, after: 1 },
+    'pipeserver, client connected'
+  );
   checkInvocations(pipe1, { init: 1 }, 'pipe1, client connected');
-  checkInvocations(pipeconnect, { init: 1, before: 1 },
-                   'pipeconnect, client connected');
+  checkInvocations(
+    pipeconnect,
+    { init: 1, before: 1 },
+    'pipeconnect, client connected'
+  );
   checkInvocations(pipe2, { init: 1 }, 'pipe2, client connected');
   tick(5);
 }
@@ -85,12 +97,24 @@ function onexit() {
   hooks.sanityCheck('PIPESERVERWRAP');
   hooks.sanityCheck('PIPECONNECTWRAP');
   // TODO(thlorenz) why have some of those 'before' and 'after' called twice
-  checkInvocations(pipeserver, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'pipeserver, process exiting');
-  checkInvocations(pipe1, { init: 1, before: 2, after: 2, destroy: 1 },
-                   'pipe1, process exiting');
-  checkInvocations(pipeconnect, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'pipeconnect, process exiting');
-  checkInvocations(pipe2, { init: 1, before: 2, after: 2, destroy: 1 },
-                   'pipe2, process exiting');
+  checkInvocations(
+    pipeserver,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'pipeserver, process exiting'
+  );
+  checkInvocations(
+    pipe1,
+    { init: 1, before: 2, after: 2, destroy: 1 },
+    'pipe1, process exiting'
+  );
+  checkInvocations(
+    pipeconnect,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'pipeconnect, process exiting'
+  );
+  checkInvocations(
+    pipe2,
+    { init: 1, before: 2, after: 2, destroy: 1 },
+    'pipe2, process exiting'
+  );
 }
diff --git a/test/async-hooks/test-pipewrap.js b/test/async-hooks/test-pipewrap.js
index a632115d228d64..51f66546a96c43 100644
--- a/test/async-hooks/test-pipewrap.js
+++ b/test/async-hooks/test-pipewrap.js
@@ -16,7 +16,7 @@ if (!common.isMainThread)
 const hooks = initHooks();
 
 hooks.enable();
-const nodeVersionSpawn = spawn(process.execPath, [ '--version' ]);
+const nodeVersionSpawn = spawn(process.execPath, ['--version']);
 
 nodeVersionSpawn
   .on('exit', common.mustCall(onsleepExit))
@@ -36,18 +36,24 @@ const pipe3 = pipes[2];
 
 assert.strictEqual(processwrap.type, 'PROCESSWRAP');
 assert.strictEqual(processwrap.triggerAsyncId, 1);
-checkInvocations(processwrap, { init: 1 },
-                 'processwrap when sleep.spawn was called');
+checkInvocations(
+  processwrap,
+  { init: 1 },
+  'processwrap when sleep.spawn was called'
+);
 
-[ pipe1, pipe2, pipe3 ].forEach((x) => {
+[pipe1, pipe2, pipe3].forEach((x) => {
   assert.strictEqual(x.type, 'PIPEWRAP');
   assert.strictEqual(x.triggerAsyncId, 1);
   checkInvocations(x, { init: 1 }, 'pipe wrap when sleep.spawn was called');
 });
 
 function onsleepExit() {
-  checkInvocations(processwrap, { init: 1, before: 1 },
-                   'processwrap while in onsleepExit callback');
+  checkInvocations(
+    processwrap,
+    { init: 1, before: 1 },
+    'processwrap while in onsleepExit callback'
+  );
 }
 
 function onsleepClose() {
@@ -55,7 +61,8 @@ function onsleepClose() {
     checkInvocations(
       processwrap,
       { init: 1, before: 1, after: 1 },
-      'processwrap while in onsleepClose callback')
+      'processwrap while in onsleepClose callback'
+    )
   );
 }
 
@@ -69,9 +76,10 @@ function onexit() {
   checkInvocations(
     processwrap,
     { init: 1, before: 1, after: 1 },
-    'processwrap while in onsleepClose callback');
+    'processwrap while in onsleepClose callback'
+  );
 
-  [ pipe1, pipe2, pipe3 ].forEach((x) => {
+  [pipe1, pipe2, pipe3].forEach((x) => {
     assert.strictEqual(x.type, 'PIPEWRAP');
     assert.strictEqual(x.triggerAsyncId, 1);
   });
@@ -81,10 +89,19 @@ function onexit() {
   // Usually it is just one event, but it can be more.
   assert.ok(ioEvents >= 3, `at least 3 stdout io events, got ${ioEvents}`);
 
-  checkInvocations(pipe1, { init: 1, before: 1, after: 1 },
-                   'pipe wrap when sleep.spawn was called');
-  checkInvocations(pipe2, { init: 1, before: ioEvents, after: ioEvents },
-                   'pipe wrap when sleep.spawn was called');
-  checkInvocations(pipe3, { init: 1, before: 2, after: 2 },
-                   'pipe wrap when sleep.spawn was called');
+  checkInvocations(
+    pipe1,
+    { init: 1, before: 1, after: 1 },
+    'pipe wrap when sleep.spawn was called'
+  );
+  checkInvocations(
+    pipe2,
+    { init: 1, before: ioEvents, after: ioEvents },
+    'pipe wrap when sleep.spawn was called'
+  );
+  checkInvocations(
+    pipe3,
+    { init: 1, before: 2, after: 2 },
+    'pipe wrap when sleep.spawn was called'
+  );
 }
diff --git a/test/async-hooks/test-promise.chain-promise-before-init-hooks.js b/test/async-hooks/test-promise.chain-promise-before-init-hooks.js
index 9046bc3514abfc..83f5b0adafc9c5 100644
--- a/test/async-hooks/test-promise.chain-promise-before-init-hooks.js
+++ b/test/async-hooks/test-promise.chain-promise-before-init-hooks.js
@@ -8,9 +8,11 @@ const { checkInvocations } = require('./hook-checks');
 if (!common.isMainThread)
   common.skip('Worker bootstrapping works differently -> different async IDs');
 
-const p = new Promise(common.mustCall(function executor(resolve, reject) {
-  resolve(5);
-}));
+const p = new Promise(
+  common.mustCall(function executor(resolve, reject) {
+    resolve(5);
+  })
+);
 
 p.then(function afterresolution(val) {
   assert.strictEqual(val, 5);
@@ -22,7 +24,6 @@ const hooks = initHooks();
 hooks._allowNoInit = true;
 hooks.enable();
 
-
 process.on('exit', function onexit() {
   hooks.disable();
   hooks.sanityCheck('PROMISE');
diff --git a/test/async-hooks/test-promise.js b/test/async-hooks/test-promise.js
index 729704b7928f7d..3b6e36e39bd868 100644
--- a/test/async-hooks/test-promise.js
+++ b/test/async-hooks/test-promise.js
@@ -13,7 +13,7 @@ const hooks = initHooks();
 
 hooks.enable();
 
-const p = (new Promise(common.mustCall(executor)));
+const p = new Promise(common.mustCall(executor));
 p.then(afterresolution);
 
 function executor(resolve, reject) {
@@ -29,8 +29,11 @@ function afterresolution(val) {
   const as = hooks.activitiesOfTypes('PROMISE');
   assert.strictEqual(as.length, 2);
   checkInvocations(as[0], { init: 1 }, 'after resolution parent promise');
-  checkInvocations(as[1], { init: 1, before: 1 },
-                   'after resolution child promise');
+  checkInvocations(
+    as[1],
+    { init: 1, before: 1 },
+    'after resolution child promise'
+  );
 }
 
 process.on('exit', onexit);
diff --git a/test/async-hooks/test-promise.promise-before-init-hooks.js b/test/async-hooks/test-promise.promise-before-init-hooks.js
index 957d1a75e49f70..1950f27235d835 100644
--- a/test/async-hooks/test-promise.promise-before-init-hooks.js
+++ b/test/async-hooks/test-promise.promise-before-init-hooks.js
@@ -5,9 +5,11 @@ const assert = require('assert');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 
-const p = new Promise(common.mustCall(function executor(resolve, reject) {
-  resolve(5);
-}));
+const p = new Promise(
+  common.mustCall(function executor(resolve, reject) {
+    resolve(5);
+  })
+);
 
 // init hooks after promise was created
 const hooks = initHooks({ allowNoInit: true });
@@ -17,8 +19,11 @@ p.then(function afterresolution(val) {
   assert.strictEqual(val, 5);
   const as = hooks.activitiesOfTypes('PROMISE');
   assert.strictEqual(as.length, 1);
-  checkInvocations(as[0], { init: 1, before: 1 },
-                   'after resolution child promise');
+  checkInvocations(
+    as[0],
+    { init: 1, before: 1 },
+    'after resolution child promise'
+  );
   return val;
 });
 
diff --git a/test/async-hooks/test-querywrap.js b/test/async-hooks/test-querywrap.js
index f6e7e12e81e9c0..9c73bfb3ddcc90 100644
--- a/test/async-hooks/test-querywrap.js
+++ b/test/async-hooks/test-querywrap.js
@@ -19,7 +19,7 @@ function onresolved() {
   const a = as[0];
   assert.strictEqual(as.length, 1);
   checkInvocations(a, { init: 1, before: 1 }, 'while in onresolved callback');
-  tick(1E4);
+  tick(1e4);
 }
 
 process.on('exit', onexit);
@@ -35,6 +35,9 @@ function onexit() {
   assert.strictEqual(a.type, 'QUERYWRAP');
   assert.strictEqual(typeof a.uid, 'number');
   assert.strictEqual(typeof a.triggerAsyncId, 'number');
-  checkInvocations(a, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    a,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-queue-microtask.js b/test/async-hooks/test-queue-microtask.js
index dfa537752e37fc..a881026c63b4dd 100644
--- a/test/async-hooks/test-queue-microtask.js
+++ b/test/async-hooks/test-queue-microtask.js
@@ -11,15 +11,24 @@ hooks.enable();
 
 const rootAsyncId = async_hooks.executionAsyncId();
 
-queueMicrotask(common.mustCall(function() {
-  assert.strictEqual(async_hooks.triggerAsyncId(), rootAsyncId);
-}));
+queueMicrotask(
+  common.mustCall(function() {
+    assert.strictEqual(async_hooks.triggerAsyncId(), rootAsyncId);
+  })
+);
 
 process.on('exit', function() {
   hooks.sanityCheck();
 
   const as = hooks.activitiesOfTypes('Microtask');
-  checkInvocations(as[0], {
-    init: 1, before: 1, after: 1, destroy: 1
-  }, 'when process exits');
+  checkInvocations(
+    as[0],
+    {
+      init: 1,
+      before: 1,
+      after: 1,
+      destroy: 1
+    },
+    'when process exits'
+  );
 });
diff --git a/test/async-hooks/test-shutdownwrap.js b/test/async-hooks/test-shutdownwrap.js
index fea4a3a166a270..cf18b489541c8a 100644
--- a/test/async-hooks/test-shutdownwrap.js
+++ b/test/async-hooks/test-shutdownwrap.js
@@ -15,7 +15,10 @@ const server = net
   .on('listening', common.mustCall(onlistening));
 server.listen();
 function onlistening() {
-  net.connect(server.address().port, common.mustCall(onconnected));
+  net.connect(
+    server.address().port,
+    common.mustCall(onconnected)
+  );
 }
 
 // It is non-deterministic in which order onconnection and onconnected fire.
@@ -36,7 +39,6 @@ function onconnection(c) {
 function onconnected() {
   if (endedConnection) {
     assert.strictEqual(hooks.activitiesOfTypes('SHUTDOWNWRAP').length, 1);
-
   } else {
     assert.strictEqual(hooks.activitiesOfTypes('SHUTDOWNWRAP').length, 0);
   }
@@ -44,8 +46,11 @@ function onconnected() {
 
 function onserverClosed() {
   const as = hooks.activitiesOfTypes('SHUTDOWNWRAP');
-  checkInvocations(as[0], { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when server closed');
+  checkInvocations(
+    as[0],
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when server closed'
+  );
 }
 
 process.on('exit', onexit);
@@ -58,6 +63,9 @@ function onexit() {
   assert.strictEqual(a.type, 'SHUTDOWNWRAP');
   assert.strictEqual(typeof a.uid, 'number');
   assert.strictEqual(typeof a.triggerAsyncId, 'number');
-  checkInvocations(as[0], { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    as[0],
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-signalwrap.js b/test/async-hooks/test-signalwrap.js
index c94d763450ab24..43a96c2ad57c74 100644
--- a/test/async-hooks/test-signalwrap.js
+++ b/test/async-hooks/test-signalwrap.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (common.isWindows)
-  common.skip('no signals in Windows');
+if (common.isWindows) common.skip('no signals in Windows');
 if (!common.isMainThread)
   common.skip('No signal handling available in Workers');
 
@@ -39,16 +38,20 @@ function onsigusr2() {
   if (count === 1) {
     // first invocation
     checkInvocations(
-      signal1, { init: 1, before: 1 },
-      ' signal1: when first SIGUSR2 handler is called for the first time');
+      signal1,
+      { init: 1, before: 1 },
+      ' signal1: when first SIGUSR2 handler is called for the first time'
+    );
 
     // trigger same signal handler again
     exec(`kill -USR2 ${process.pid}`);
   } else {
     // second invocation
     checkInvocations(
-      signal1, { init: 1, before: 2, after: 1 },
-      'signal1: when first SIGUSR2 handler is called for the second time');
+      signal1,
+      { init: 1, before: 2, after: 1 },
+      'signal1: when first SIGUSR2 handler is called for the second time'
+    );
 
     // install another signal handler
     process.removeAllListeners('SIGUSR2');
@@ -62,11 +65,15 @@ function onsigusr2() {
     assert.strictEqual(typeof signal2.triggerAsyncId, 'number');
 
     checkInvocations(
-      signal1, { init: 1, before: 2, after: 1 },
-      'signal1: when second SIGUSR2 handler is set up');
+      signal1,
+      { init: 1, before: 2, after: 1 },
+      'signal1: when second SIGUSR2 handler is set up'
+    );
     checkInvocations(
-      signal2, { init: 1 },
-      'signal2: when second SIGUSR2 handler is setup');
+      signal2,
+      { init: 1 },
+      'signal2: when second SIGUSR2 handler is setup'
+    );
 
     exec(`kill -USR2 ${process.pid}`);
   }
@@ -76,11 +83,15 @@ function onsigusr2Again() {
   clearInterval(interval);
   setImmediate(() => {
     checkInvocations(
-      signal1, { init: 1, before: 2, after: 2, destroy: 1 },
-      'signal1: when second SIGUSR2 handler is called');
+      signal1,
+      { init: 1, before: 2, after: 2, destroy: 1 },
+      'signal1: when second SIGUSR2 handler is called'
+    );
     checkInvocations(
-      signal2, { init: 1, before: 1 },
-      'signal2: when second SIGUSR2 handler is called');
+      signal2,
+      { init: 1, before: 1 },
+      'signal2: when second SIGUSR2 handler is called'
+    );
   });
 }
 
@@ -90,10 +101,14 @@ function onexit() {
   hooks.disable();
   hooks.sanityCheck('SIGNALWRAP');
   checkInvocations(
-    signal1, { init: 1, before: 2, after: 2, destroy: 1 },
-    'signal1: when second SIGUSR2 process exits');
+    signal1,
+    { init: 1, before: 2, after: 2, destroy: 1 },
+    'signal1: when second SIGUSR2 process exits'
+  );
   // second signal not destroyed yet since its event listener is still active
   checkInvocations(
-    signal2, { init: 1, before: 1, after: 1 },
-    'signal2: when second SIGUSR2 process exits');
+    signal2,
+    { init: 1, before: 1, after: 1 },
+    'signal2: when second SIGUSR2 process exits'
+  );
 }
diff --git a/test/async-hooks/test-statwatcher.js b/test/async-hooks/test-statwatcher.js
index 92832a46803bd4..e0bbd793895555 100644
--- a/test/async-hooks/test-statwatcher.js
+++ b/test/async-hooks/test-statwatcher.js
@@ -32,8 +32,11 @@ const statwatcher1 = as[0];
 assert.strictEqual(statwatcher1.type, 'STATWATCHER');
 assert.strictEqual(typeof statwatcher1.uid, 'number');
 assert.strictEqual(statwatcher1.triggerAsyncId, 1);
-checkInvocations(statwatcher1, { init: 1 },
-                 'watcher1: when started to watch file');
+checkInvocations(
+  statwatcher1,
+  { init: 1 },
+  'watcher1: when started to watch file'
+);
 
 // install second file watcher
 const w2 = fs.watchFile(file2, { interval: 10 }, onchange);
@@ -44,42 +47,73 @@ const statwatcher2 = as[1];
 assert.strictEqual(statwatcher2.type, 'STATWATCHER');
 assert.strictEqual(typeof statwatcher2.uid, 'number');
 assert.strictEqual(statwatcher2.triggerAsyncId, 1);
-checkInvocations(statwatcher1, { init: 1 },
-                 'watcher1: when started to watch second file');
-checkInvocations(statwatcher2, { init: 1 },
-                 'watcher2: when started to watch second file');
+checkInvocations(
+  statwatcher1,
+  { init: 1 },
+  'watcher1: when started to watch second file'
+);
+checkInvocations(
+  statwatcher2,
+  { init: 1 },
+  'watcher2: when started to watch second file'
+);
 
-setTimeout(() => fs.writeFileSync(file1, 'foo++'),
-           common.platformTimeout(100));
-w1.once('change', common.mustCall(() => {
-  setImmediate(() => {
-    checkInvocations(statwatcher1, { init: 1, before: 1, after: 1 },
-                     'watcher1: when unwatched first file');
-    checkInvocations(statwatcher2, { init: 1 },
-                     'watcher2: when unwatched first file');
+setTimeout(() => fs.writeFileSync(file1, 'foo++'), common.platformTimeout(100));
+w1.once(
+  'change',
+  common.mustCall(() => {
+    setImmediate(() => {
+      checkInvocations(
+        statwatcher1,
+        { init: 1, before: 1, after: 1 },
+        'watcher1: when unwatched first file'
+      );
+      checkInvocations(
+        statwatcher2,
+        { init: 1 },
+        'watcher2: when unwatched first file'
+      );
 
-    setTimeout(() => fs.writeFileSync(file2, 'bar++'),
-               common.platformTimeout(100));
-    w2.once('change', common.mustCall(() => {
-      setImmediate(() => {
-        checkInvocations(statwatcher1, { init: 1, before: 1, after: 1 },
-                         'watcher1: when unwatched second file');
-        checkInvocations(statwatcher2, { init: 1, before: 1, after: 1 },
-                         'watcher2: when unwatched second file');
-        fs.unwatchFile(file1);
-        fs.unwatchFile(file2);
-      });
-    }));
-  });
-}));
+      setTimeout(
+        () => fs.writeFileSync(file2, 'bar++'),
+        common.platformTimeout(100)
+      );
+      w2.once(
+        'change',
+        common.mustCall(() => {
+          setImmediate(() => {
+            checkInvocations(
+              statwatcher1,
+              { init: 1, before: 1, after: 1 },
+              'watcher1: when unwatched second file'
+            );
+            checkInvocations(
+              statwatcher2,
+              { init: 1, before: 1, after: 1 },
+              'watcher2: when unwatched second file'
+            );
+            fs.unwatchFile(file1);
+            fs.unwatchFile(file2);
+          });
+        })
+      );
+    });
+  })
+);
 
 process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
   hooks.sanityCheck('STATWATCHER');
-  checkInvocations(statwatcher1, { init: 1, before: 1, after: 1 },
-                   'watcher1: when process exits');
-  checkInvocations(statwatcher2, { init: 1, before: 1, after: 1 },
-                   'watcher2: when process exits');
+  checkInvocations(
+    statwatcher1,
+    { init: 1, before: 1, after: 1 },
+    'watcher1: when process exits'
+  );
+  checkInvocations(
+    statwatcher2,
+    { init: 1, before: 1, after: 1 },
+    'watcher2: when process exits'
+  );
 }
diff --git a/test/async-hooks/test-tcpwrap.js b/test/async-hooks/test-tcpwrap.js
index a01a1fc4fe21d4..721aa89295ccf6 100644
--- a/test/async-hooks/test-tcpwrap.js
+++ b/test/async-hooks/test-tcpwrap.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasIPv6)
-  common.skip('IPv6 support required');
+if (!common.hasIPv6) common.skip('IPv6 support required');
 
 const assert = require('assert');
 const tick = require('../common/tick');
@@ -40,7 +39,8 @@ const server = net
 {
   net.connect(
     { port: server.address().port, host: '::1' },
-    common.mustCall(onconnected));
+    common.mustCall(onconnected)
+  );
   const tcps = hooks.activitiesOfTypes('TCPWRAP');
   assert.strictEqual(tcps.length, 1);
   process.nextTick(() => {
@@ -54,8 +54,11 @@ const server = net
   assert.strictEqual(typeof tcp1.uid, 'number');
   assert.strictEqual(typeof tcp1.triggerAsyncId, 'number');
 
-  checkInvocations(tcpserver, { init: 1 },
-                   'tcpserver when client is connecting');
+  checkInvocations(
+    tcpserver,
+    { init: 1 },
+    'tcpserver when client is connecting'
+  );
   checkInvocations(tcp1, { init: 1 }, 'tcp1 when client is connecting');
 }
 
@@ -70,12 +73,14 @@ function ontcpConnection(serverConnection) {
   if (tcpconnect != null) {
     // When client receives connection first ('onconnected') and the server
     // second then we see an 'after' here, otherwise not
-    const expected = serverConnection ?
-      { init: 1, before: 1, after: 1 } :
-      { init: 1, before: 1 };
+    const expected = serverConnection
+      ? { init: 1, before: 1, after: 1 }
+      : { init: 1, before: 1 };
     checkInvocations(
-      tcpconnect, expected,
-      'tcpconnect: when both client and server received connection');
+      tcpconnect,
+      expected,
+      'tcpconnect: when both client and server received connection'
+    );
     return;
   }
 
@@ -89,8 +94,11 @@ function ontcpConnection(serverConnection) {
   // When client receives connection first ('onconnected'), we 'before' has
   // been invoked at this point already, otherwise it only was 'init'ed
   const expected = serverConnection ? { init: 1 } : { init: 1, before: 1 };
-  checkInvocations(tcpconnect, expected,
-                   'tcpconnect: when tcp connection is established');
+  checkInvocations(
+    tcpconnect,
+    expected,
+    'tcpconnect: when tcp connection is established'
+  );
 }
 
 let serverConnected = false;
@@ -98,9 +106,9 @@ function onconnected() {
   ontcpConnection(false);
   // In the case that the client connects before the server TCPWRAP 'before'
   // and 'after' weren't invoked yet. Also @see ontcpConnection.
-  const expected = serverConnected ?
-    { init: 1, before: 1, after: 1 } :
-    { init: 1 };
+  const expected = serverConnected
+    ? { init: 1, before: 1, after: 1 }
+    : { init: 1 };
   checkInvocations(tcpserver, expected, 'tcpserver when client connects');
   checkInvocations(tcp1, { init: 1 }, 'tcp1 when client connects');
 }
@@ -109,7 +117,7 @@ function onconnection(c) {
   serverConnected = true;
   ontcpConnection(true);
 
-  const tcps = hooks.activitiesOfTypes([ 'TCPWRAP' ]);
+  const tcps = hooks.activitiesOfTypes(['TCPWRAP']);
   const tcpconnects = hooks.activitiesOfTypes('TCPCONNECTWRAP');
   assert.strictEqual(tcps.length, 2);
   assert.strictEqual(tcpconnects.length, 1);
@@ -118,8 +126,11 @@ function onconnection(c) {
   assert.strictEqual(typeof tcp2.uid, 'number');
   assert.strictEqual(typeof tcp2.triggerAsyncId, 'number');
 
-  checkInvocations(tcpserver, { init: 1, before: 1 },
-                   'tcpserver when server receives connection');
+  checkInvocations(
+    tcpserver,
+    { init: 1, before: 1 },
+    'tcpserver when server receives connection'
+  );
   checkInvocations(tcp1, { init: 1 }, 'tcp1 when server receives connection');
   checkInvocations(tcp2, { init: 1 }, 'tcp2 when server receives connection');
 
@@ -128,20 +139,35 @@ function onconnection(c) {
 }
 
 function onserverClosed() {
-  checkInvocations(tcpserver, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'tcpserver when server is closed');
+  checkInvocations(
+    tcpserver,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'tcpserver when server is closed'
+  );
   setImmediate(() => {
-    checkInvocations(tcp1, { init: 1, before: 2, after: 2, destroy: 1 },
-                     'tcp1 after server is closed');
+    checkInvocations(
+      tcp1,
+      { init: 1, before: 2, after: 2, destroy: 1 },
+      'tcp1 after server is closed'
+    );
   });
-  checkInvocations(tcp2, { init: 1, before: 1, after: 1 },
-                   'tcp2 synchronously when server is closed');
+  checkInvocations(
+    tcp2,
+    { init: 1, before: 1, after: 1 },
+    'tcp2 synchronously when server is closed'
+  );
 
   tick(2, () => {
-    checkInvocations(tcp2, { init: 1, before: 2, after: 2, destroy: 1 },
-                     'tcp2 when server is closed');
-    checkInvocations(tcpconnect, { init: 1, before: 1, after: 1, destroy: 1 },
-                     'tcpconnect when server is closed');
+    checkInvocations(
+      tcp2,
+      { init: 1, before: 2, after: 2, destroy: 1 },
+      'tcp2 when server is closed'
+    );
+    checkInvocations(
+      tcpconnect,
+      { init: 1, before: 1, after: 1, destroy: 1 },
+      'tcpconnect when server is closed'
+    );
   });
 }
 
@@ -149,17 +175,26 @@ process.on('exit', onexit);
 
 function onexit() {
   hooks.disable();
-  hooks.sanityCheck([ 'TCPWRAP', 'TCPSERVERWRAP', 'TCPCONNECTWRAP' ]);
+  hooks.sanityCheck(['TCPWRAP', 'TCPSERVERWRAP', 'TCPCONNECTWRAP']);
 
-  checkInvocations(tcpserver, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'tcpserver when process exits');
   checkInvocations(
-    tcp1, { init: 1, before: 2, after: 2, destroy: 1 },
-    'tcp1 when process exits');
+    tcpserver,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'tcpserver when process exits'
+  );
+  checkInvocations(
+    tcp1,
+    { init: 1, before: 2, after: 2, destroy: 1 },
+    'tcp1 when process exits'
+  );
   checkInvocations(
-    tcp2, { init: 1, before: 2, after: 2, destroy: 1 },
-    'tcp2 when process exits');
+    tcp2,
+    { init: 1, before: 2, after: 2, destroy: 1 },
+    'tcp2 when process exits'
+  );
   checkInvocations(
-    tcpconnect, { init: 1, before: 1, after: 1, destroy: 1 },
-    'tcpconnect when process exits');
+    tcpconnect,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'tcpconnect when process exits'
+  );
 }
diff --git a/test/async-hooks/test-timers.setInterval.js b/test/async-hooks/test-timers.setInterval.js
index 10b2bafb2a2598..3b05dbf9347459 100644
--- a/test/async-hooks/test-timers.setInterval.js
+++ b/test/async-hooks/test-timers.setInterval.js
@@ -23,8 +23,11 @@ function ontimeout() {
   if (iter === 0) {
     checkInvocations(t1, { init: 1, before: 1 }, 't1: when first timer fired');
   } else {
-    checkInvocations(t1, { init: 1, before: 2, after: 1 },
-                     't1: when first interval fired again');
+    checkInvocations(
+      t1,
+      { init: 1, before: 2, after: 1 },
+      't1: when first interval fired again'
+    );
     clearInterval(interval);
     return;
   }
@@ -33,14 +36,20 @@ function ontimeout() {
   throw new Error('setInterval Error');
 }
 
-process.once('uncaughtException', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'setInterval Error');
-}));
+process.once(
+  'uncaughtException',
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'setInterval Error');
+  })
+);
 
 process.on('exit', () => {
   hooks.disable();
   hooks.sanityCheck('Timeout');
 
-  checkInvocations(t1, { init: 1, before: 2, after: 2, destroy: 1 },
-                   't1: when process exits');
+  checkInvocations(
+    t1,
+    { init: 1, before: 2, after: 2, destroy: 1 },
+    't1: when process exits'
+  );
 });
diff --git a/test/async-hooks/test-timers.setTimeout.js b/test/async-hooks/test-timers.setTimeout.js
index 748fa5565eee64..69056f3307a10c 100644
--- a/test/async-hooks/test-timers.setTimeout.js
+++ b/test/async-hooks/test-timers.setTimeout.js
@@ -29,10 +29,12 @@ function ontimeout() {
   const as = hooks.activitiesOfTypes('Timeout');
   t2 = as[1];
   assert.strictEqual(as.length, 2);
-  checkInvocations(t1, { init: 1, before: 1 },
-                   't1: when second timer installed');
-  checkInvocations(t2, { init: 1 },
-                   't2: when second timer installed');
+  checkInvocations(
+    t1,
+    { init: 1, before: 1 },
+    't1: when second timer installed'
+  );
+  checkInvocations(t2, { init: 1 }, 't2: when second timer installed');
 
   timer = setTimeout(common.mustNotCall(), 2 ** 31 - 1);
 }
@@ -40,10 +42,12 @@ function ontimeout() {
 function onSecondTimeout() {
   const as = hooks.activitiesOfTypes('Timeout');
   assert.strictEqual(as.length, 3);
-  checkInvocations(t1, { init: 1, before: 1, after: 1 },
-                   't1: when second timer fired');
-  checkInvocations(t2, { init: 1, before: 1 },
-                   't2: when second timer fired');
+  checkInvocations(
+    t1,
+    { init: 1, before: 1, after: 1 },
+    't1: when second timer fired'
+  );
+  checkInvocations(t2, { init: 1, before: 1 }, 't2: when second timer fired');
   clearTimeout(timer);
   tick(2);
 }
@@ -54,8 +58,14 @@ function onexit() {
   hooks.disable();
   hooks.sanityCheck('Timeout');
 
-  checkInvocations(t1, { init: 1, before: 1, after: 1, destroy: 1 },
-                   't1: when process exits');
-  checkInvocations(t2, { init: 1, before: 1, after: 1, destroy: 1 },
-                   't2: when process exits');
+  checkInvocations(
+    t1,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    't1: when process exits'
+  );
+  checkInvocations(
+    t2,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    't2: when process exits'
+  );
 }
diff --git a/test/async-hooks/test-tlswrap.js b/test/async-hooks/test-tlswrap.js
index 354cd7ad0cd91d..6ca5f47a929393 100644
--- a/test/async-hooks/test-tlswrap.js
+++ b/test/async-hooks/test-tlswrap.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -33,7 +32,10 @@ function onlistening() {
   // Creating client and connecting it to server
   //
   tls
-    .connect(server.address().port, { rejectUnauthorized: false })
+    .connect(
+      server.address().port,
+      { rejectUnauthorized: false }
+    )
     .on('secureConnect', common.mustCall(onsecureConnect));
 
   const as = hooks.activitiesOfTypes('TLSWRAP');
@@ -59,35 +61,56 @@ function onsecureConnection() {
 
   // TODO(thlorenz) which callback did the server wrap execute that already
   // finished as well?
-  checkInvocations(svr, { init: 1, before: 1, after: 1 },
-                   'server: when server has secure connection');
-
-  checkInvocations(client, { init: 1, before: 2, after: 1 },
-                   'client: when server has secure connection');
+  checkInvocations(
+    svr,
+    { init: 1, before: 1, after: 1 },
+    'server: when server has secure connection'
+  );
+
+  checkInvocations(
+    client,
+    { init: 1, before: 2, after: 1 },
+    'client: when server has secure connection'
+  );
 }
 
 function onsecureConnect() {
   //
   // Client connected to server
   //
-  checkInvocations(svr, { init: 1, before: 2, after: 1 },
-                   'server: when client connected');
-  checkInvocations(client, { init: 1, before: 2, after: 2 },
-                   'client: when client connected');
+  checkInvocations(
+    svr,
+    { init: 1, before: 2, after: 1 },
+    'server: when client connected'
+  );
+  checkInvocations(
+    client,
+    { init: 1, before: 2, after: 2 },
+    'client: when client connected'
+  );
 
   //
   // Destroying client socket
   //
   this.destroy();
-  checkInvocations(svr, { init: 1, before: 2, after: 1 },
-                   'server: when destroying client');
-  checkInvocations(client, { init: 1, before: 2, after: 2 },
-                   'client: when destroying client');
+  checkInvocations(
+    svr,
+    { init: 1, before: 2, after: 1 },
+    'server: when destroying client'
+  );
+  checkInvocations(
+    client,
+    { init: 1, before: 2, after: 2 },
+    'client: when destroying client'
+  );
 
   tick(5, tick1);
   function tick1() {
-    checkInvocations(svr, { init: 1, before: 2, after: 2 },
-                     'server: when client destroyed');
+    checkInvocations(
+      svr,
+      { init: 1, before: 2, after: 2 },
+      'server: when client destroyed'
+    );
     // TODO: why is client not destroyed here even after 5 ticks?
     // or could it be that it isn't actually destroyed until
     // the server is closed?
@@ -95,17 +118,26 @@ function onsecureConnect() {
       tick(5, tick1);
       return;
     }
-    checkInvocations(client, { init: 1, before: 3, after: 3 },
-                     'client: when client destroyed');
+    checkInvocations(
+      client,
+      { init: 1, before: 3, after: 3 },
+      'client: when client destroyed'
+    );
     //
     // Closing server
     //
     server.close(common.mustCall(onserverClosed));
     // No changes to invocations until server actually closed below
-    checkInvocations(svr, { init: 1, before: 2, after: 2 },
-                     'server: when closing server');
-    checkInvocations(client, { init: 1, before: 3, after: 3 },
-                     'client: when closing server');
+    checkInvocations(
+      svr,
+      { init: 1, before: 2, after: 2 },
+      'server: when closing server'
+    );
+    checkInvocations(
+      client,
+      { init: 1, before: 3, after: 3 },
+      'client: when closing server'
+    );
   }
 }
 
@@ -113,12 +145,21 @@ function onserverClosed() {
   //
   // Server closed
   //
-  tick(1E4, common.mustCall(() => {
-    checkInvocations(svr, { init: 1, before: 2, after: 2 },
-                     'server: when server closed');
-    checkInvocations(client, { init: 1, before: 3, after: 3 },
-                     'client: when server closed');
-  }));
+  tick(
+    1e4,
+    common.mustCall(() => {
+      checkInvocations(
+        svr,
+        { init: 1, before: 2, after: 2 },
+        'server: when server closed'
+      );
+      checkInvocations(
+        client,
+        { init: 1, before: 3, after: 3 },
+        'client: when server closed'
+      );
+    })
+  );
 }
 
 process.on('exit', onexit);
@@ -127,8 +168,14 @@ function onexit() {
   hooks.disable();
   hooks.sanityCheck('TLSWRAP');
 
-  checkInvocations(svr, { init: 1, before: 2, after: 2 },
-                   'server: when process exits');
-  checkInvocations(client, { init: 1, before: 3, after: 3 },
-                   'client: when process exits');
+  checkInvocations(
+    svr,
+    { init: 1, before: 2, after: 2 },
+    'server: when process exits'
+  );
+  checkInvocations(
+    client,
+    { init: 1, before: 3, after: 3 },
+    'client: when process exits'
+  );
 }
diff --git a/test/async-hooks/test-ttywrap.readstream.js b/test/async-hooks/test-ttywrap.readstream.js
index bf81a3266c1fb6..d11ccac713ea65 100644
--- a/test/async-hooks/test-ttywrap.readstream.js
+++ b/test/async-hooks/test-ttywrap.readstream.js
@@ -11,8 +11,7 @@ const { checkInvocations } = require('./hook-checks');
 const hooks = initHooks();
 hooks.enable();
 
-if (!process.stdin.isTTY)
-  return common.skip('no valid readable TTY available');
+if (!process.stdin.isTTY) return common.skip('no valid readable TTY available');
 
 // test specific setup
 const checkInitOpts = { init: 1 };
@@ -34,9 +33,10 @@ const delayedOnCloseHandler = common.mustCall(() => {
   checkInvocations(tty, checkEndedOpts, 'when tty ended');
 });
 process.stdin.on('error', (err) => assert.fail(err));
-process.stdin.on('close', common.mustCall(() =>
-  tick(2, delayedOnCloseHandler)
-));
+process.stdin.on(
+  'close',
+  common.mustCall(() => tick(2, delayedOnCloseHandler))
+);
 process.stdin.destroy();
 checkInvocations(tty, checkInitOpts, 'when tty.end() was invoked');
 
diff --git a/test/async-hooks/test-ttywrap.writestream.js b/test/async-hooks/test-ttywrap.writestream.js
index 44f32e80f015c2..06215c7b649a06 100644
--- a/test/async-hooks/test-ttywrap.writestream.js
+++ b/test/async-hooks/test-ttywrap.writestream.js
@@ -34,9 +34,10 @@ const delayedOnCloseHandler = common.mustCall(() => {
   checkInvocations(tty, checkEndedOpts, 'when tty ended');
 });
 process.stdout.on('error', (err) => assert.fail(err));
-process.stdout.on('close', common.mustCall(() =>
-  tick(2, delayedOnCloseHandler)
-));
+process.stdout.on(
+  'close',
+  common.mustCall(() => tick(2, delayedOnCloseHandler))
+);
 process.stdout.destroy();
 checkInvocations(tty, checkInitOpts, 'when tty.end() was invoked');
 
diff --git a/test/async-hooks/test-udpsendwrap.js b/test/async-hooks/test-udpsendwrap.js
index d8ab77730f4921..6a46ed5f2e44a4 100644
--- a/test/async-hooks/test-udpsendwrap.js
+++ b/test/async-hooks/test-udpsendwrap.js
@@ -18,8 +18,13 @@ const sock = dgram
 
 function onlistening() {
   sock.send(
-    Buffer.alloc(2), 0, 2, sock.address().port,
-    undefined, common.mustCall(onsent));
+    Buffer.alloc(2),
+    0,
+    2,
+    sock.address().port,
+    undefined,
+    common.mustCall(onsent)
+  );
 
   // init not called synchronously because dns lookup always wraps
   // callback in a next tick even if no lookup is needed
@@ -50,6 +55,9 @@ process.on('exit', onexit);
 function onexit() {
   hooks.disable();
   hooks.sanityCheck('UDPSENDWRAP');
-  checkInvocations(send, { init: 1, before: 1, after: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(
+    send,
+    { init: 1, before: 1, after: 1, destroy: 1 },
+    'when process exits'
+  );
 }
diff --git a/test/async-hooks/test-udpwrap.js b/test/async-hooks/test-udpwrap.js
index 0a0e03c5d5148d..0a0d87ebd490b4 100644
--- a/test/async-hooks/test-udpwrap.js
+++ b/test/async-hooks/test-udpwrap.js
@@ -32,6 +32,5 @@ process.on('exit', onexit);
 function onexit() {
   hooks.disable();
   hooks.sanityCheck('UDPWRAP');
-  checkInvocations(udpwrap, { init: 1, destroy: 1 },
-                   'when process exits');
+  checkInvocations(udpwrap, { init: 1, destroy: 1 }, 'when process exits');
 }
diff --git a/test/async-hooks/test-writewrap.js b/test/async-hooks/test-writewrap.js
index 4f3455480ba849..69137c26dcc736 100644
--- a/test/async-hooks/test-writewrap.js
+++ b/test/async-hooks/test-writewrap.js
@@ -12,7 +12,8 @@ hooks.enable();
 //
 // Creating server and listening on port
 //
-const server = net.createServer()
+const server = net
+  .createServer()
   .on('listening', common.mustCall(onlistening))
   .on('connection', common.mustCall(onconnection))
   .listen(0);
@@ -24,17 +25,18 @@ function onlistening() {
   //
   // Creating client and connecting it to server
   //
-  net
-    .connect(server.address().port)
-    .on('connect', common.mustCall(onconnect));
+  net.connect(server.address().port).on('connect', common.mustCall(onconnect));
 
   assert.strictEqual(hooks.activitiesOfTypes('WRITEWRAP').length, 0);
 }
 
 function checkDestroyedWriteWraps(n, stage) {
   const as = hooks.activitiesOfTypes('WRITEWRAP');
-  assert.strictEqual(as.length, n,
-                     `${as.length} out of ${n} WRITEWRAPs when ${stage}`);
+  assert.strictEqual(
+    as.length,
+    n,
+    `${as.length} out of ${n} WRITEWRAPs when ${stage}`
+  );
 
   function checkValidWriteWrap(w) {
     assert.strictEqual(w.type, 'WRITEWRAP');
@@ -47,7 +49,7 @@ function checkDestroyedWriteWraps(n, stage) {
 }
 
 function onconnection(conn) {
-  conn.write('hi');  // Let the client know we're ready.
+  conn.write('hi'); // Let the client know we're ready.
   conn.resume();
   //
   // Server received client connection
diff --git a/test/async-hooks/test-zlib.zlib-binding.deflate.js b/test/async-hooks/test-zlib.zlib-binding.deflate.js
index 972052b2d570a5..48d39726186429 100644
--- a/test/async-hooks/test-zlib.zlib-binding.deflate.js
+++ b/test/async-hooks/test-zlib.zlib-binding.deflate.js
@@ -38,7 +38,9 @@ handle.init(
   constants.Z_DEFAULT_MEMLEVEL,
   constants.Z_DEFAULT_STRATEGY,
   buffers.writeResult,
-  function processCallback() { this.cb(); },
+  function processCallback() {
+    this.cb();
+  },
   buffers.dictionary
 );
 checkInvocations(hdl, { init: 1 }, 'when initialized handle');
@@ -51,13 +53,19 @@ checkInvocations(hdl, { init: 1 }, 'when invoked write() on handle');
 function onwritten() {
   if (--count) {
     // first write
-    checkInvocations(hdl, { init: 1, before: 1 },
-                     'when wrote to handle the first time');
+    checkInvocations(
+      hdl,
+      { init: 1, before: 1 },
+      'when wrote to handle the first time'
+    );
     handle.write(true, buffers.inBuf, 0, 1, buffers.outBuf, 0, 1);
   } else {
     // second write
-    checkInvocations(hdl, { init: 1, before: 2, after: 1 },
-                     'when wrote to handle the second time');
+    checkInvocations(
+      hdl,
+      { init: 1, before: 2, after: 1 },
+      'when wrote to handle the second time'
+    );
   }
 }
 
diff --git a/test/async-hooks/verify-graph.js b/test/async-hooks/verify-graph.js
index 95c55c15958b2c..ae148e6f21734d 100644
--- a/test/async-hooks/verify-graph.js
+++ b/test/async-hooks/verify-graph.js
@@ -82,7 +82,7 @@ module.exports = function verifyGraph(hooks, graph) {
     errors.forEach((x) =>
       console.error(
         `'${x.id}' expected to be triggered by '${x.expectedTid}', ` +
-        `but was triggered by '${x.actualTid}' instead.`
+          `but was triggered by '${x.actualTid}' instead.`
       )
     );
   }
diff --git a/test/benchmark/test-benchmark-assert.js b/test/benchmark/test-benchmark-assert.js
index 8a8ba0244489e5..dc2f9083957091 100644
--- a/test/benchmark/test-benchmark-assert.js
+++ b/test/benchmark/test-benchmark-assert.js
@@ -7,15 +7,12 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark(
-  'assert',
-  [
-    'strict=1',
-    'len=1',
-    'method=',
-    'n=1',
-    'primitive=null',
-    'size=1',
-    'type=Int8Array'
-  ]
-);
+runBenchmark('assert', [
+  'strict=1',
+  'len=1',
+  'method=',
+  'n=1',
+  'primitive=null',
+  'size=1',
+  'type=Int8Array'
+]);
diff --git a/test/benchmark/test-benchmark-async-hooks.js b/test/benchmark/test-benchmark-async-hooks.js
index 4cb6f89a8c70e3..4df5ace627a555 100644
--- a/test/benchmark/test-benchmark-async-hooks.js
+++ b/test/benchmark/test-benchmark-async-hooks.js
@@ -2,17 +2,11 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 if (!common.enoughTestMem)
   common.skip('Insufficient memory for async_hooks benchmark test');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('async_hooks',
-             [
-               'method=trackingDisabled',
-               'n=10'
-             ],
-             {});
+runBenchmark('async_hooks', ['method=trackingDisabled', 'n=10'], {});
diff --git a/test/benchmark/test-benchmark-buffer.js b/test/benchmark/test-benchmark-buffer.js
index 171f755647d21f..3171220aa9ec21 100644
--- a/test/benchmark/test-benchmark-buffer.js
+++ b/test/benchmark/test-benchmark-buffer.js
@@ -4,26 +4,28 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('buffers',
-             [
-               'aligned=true',
-               'args=1',
-               'buffer=fast',
-               'byteLength=1',
-               'charsPerLine=6',
-               'encoding=utf8',
-               'endian=BE',
-               'len=2',
-               'linesCount=1',
-               'method=',
-               'n=1',
-               'pieces=1',
-               'pieceSize=1',
-               'search=@',
-               'size=1',
-               'source=array',
-               'type=',
-               'value=0',
-               'withTotalLength=0'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'buffers',
+  [
+    'aligned=true',
+    'args=1',
+    'buffer=fast',
+    'byteLength=1',
+    'charsPerLine=6',
+    'encoding=utf8',
+    'endian=BE',
+    'len=2',
+    'linesCount=1',
+    'method=',
+    'n=1',
+    'pieces=1',
+    'pieceSize=1',
+    'search=@',
+    'size=1',
+    'source=array',
+    'type=',
+    'value=0',
+    'withTotalLength=0'
+  ],
+  { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-child-process.js b/test/benchmark/test-benchmark-child-process.js
index 365777069bc4cf..15ad023e38f1a9 100644
--- a/test/benchmark/test-benchmark-child-process.js
+++ b/test/benchmark/test-benchmark-child-process.js
@@ -4,12 +4,8 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('child_process',
-             [
-               'dur=0',
-               'n=1',
-               'len=1',
-               'params=1',
-               'methodName=execSync',
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'child_process',
+  ['dur=0', 'n=1', 'len=1', 'params=1', 'methodName=execSync'],
+  { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-crypto.js b/test/benchmark/test-benchmark-crypto.js
index f24edf675f92f0..91248d7bb87dbc 100644
--- a/test/benchmark/test-benchmark-crypto.js
+++ b/test/benchmark/test-benchmark-crypto.js
@@ -2,25 +2,25 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (common.hasFipsCrypto)
-  common.skip('some benchmarks are FIPS-incompatible');
+if (common.hasFipsCrypto) common.skip('some benchmarks are FIPS-incompatible');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('crypto',
-             [
-               'algo=sha256',
-               'api=stream',
-               'cipher=',
-               'keylen=1024',
-               'len=1',
-               'n=1',
-               'out=buffer',
-               'type=buf',
-               'v=crypto',
-               'writes=1',
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'crypto',
+  [
+    'algo=sha256',
+    'api=stream',
+    'cipher=',
+    'keylen=1024',
+    'len=1',
+    'n=1',
+    'out=buffer',
+    'type=buf',
+    'v=crypto',
+    'writes=1'
+  ],
+  { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-dgram.js b/test/benchmark/test-benchmark-dgram.js
index 8c93cd5a0c9239..b1731a0781b542 100644
--- a/test/benchmark/test-benchmark-dgram.js
+++ b/test/benchmark/test-benchmark-dgram.js
@@ -8,10 +8,12 @@ const runBenchmark = require('../common/benchmark');
 // sequential rather than parallel to make sure it does not conflict with
 // tests that choose random available ports.
 
-runBenchmark('dgram', ['address=true',
-                       'chunks=2',
-                       'dur=0.1',
-                       'len=1',
-                       'n=1',
-                       'num=1',
-                       'type=send']);
+runBenchmark('dgram', [
+  'address=true',
+  'chunks=2',
+  'dur=0.1',
+  'len=1',
+  'n=1',
+  'num=1',
+  'type=send'
+]);
diff --git a/test/benchmark/test-benchmark-dns.js b/test/benchmark/test-benchmark-dns.js
index 27c3271c74d86d..929cf7bcf104e4 100644
--- a/test/benchmark/test-benchmark-dns.js
+++ b/test/benchmark/test-benchmark-dns.js
@@ -4,7 +4,8 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-const env = Object.assign({}, process.env,
-                          { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+const env = Object.assign({}, process.env, {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
 
 runBenchmark('dns', ['n=1', 'all=false', 'name=127.0.0.1'], env);
diff --git a/test/benchmark/test-benchmark-es.js b/test/benchmark/test-benchmark-es.js
index 47fe4ab3f91a63..96e521659f32bf 100644
--- a/test/benchmark/test-benchmark-es.js
+++ b/test/benchmark/test-benchmark-es.js
@@ -4,15 +4,17 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('es',
-             [
-               'method=',
-               'count=1',
-               'context=null',
-               'rest=0',
-               'mode=',
-               'n=1',
-               'encoding=ascii',
-               'size=1e1'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'es',
+  [
+    'method=',
+    'count=1',
+    'context=null',
+    'rest=0',
+    'mode=',
+    'n=1',
+    'encoding=ascii',
+    'size=1e1'
+  ],
+  { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-events.js b/test/benchmark/test-benchmark-events.js
index 06be60a84abb5b..8d72419960b9f6 100644
--- a/test/benchmark/test-benchmark-events.js
+++ b/test/benchmark/test-benchmark-events.js
@@ -4,6 +4,6 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('events',
-             ['argc=0', 'listeners=1', 'n=1'],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('events', ['argc=0', 'listeners=1', 'n=1'], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-fs.js b/test/benchmark/test-benchmark-fs.js
index 7ae32fe617d58f..c28ddb2ec32005 100644
--- a/test/benchmark/test-benchmark-fs.js
+++ b/test/benchmark/test-benchmark-fs.js
@@ -6,17 +6,21 @@ const runBenchmark = require('../common/benchmark');
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-runBenchmark('fs', [
-  'n=1',
-  'size=1',
-  'dur=0.1',
-  'len=1024',
-  'concurrent=1',
-  'pathType=relative',
-  'statType=fstat',
-  'statSyncType=fstatSync',
-  'encodingType=buf',
-  'filesize=1024',
-  'dir=.github',
-  'withFileTypes=false'
-], { NODE_TMPDIR: tmpdir.path, NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'fs',
+  [
+    'n=1',
+    'size=1',
+    'dur=0.1',
+    'len=1024',
+    'concurrent=1',
+    'pathType=relative',
+    'statType=fstat',
+    'statSyncType=fstatSync',
+    'encodingType=buf',
+    'filesize=1024',
+    'dir=.github',
+    'withFileTypes=false'
+  ],
+  { NODE_TMPDIR: tmpdir.path, NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-http.js b/test/benchmark/test-benchmark-http.js
index 7255e655c094e6..e0558e600604f8 100644
--- a/test/benchmark/test-benchmark-http.js
+++ b/test/benchmark/test-benchmark-http.js
@@ -11,24 +11,26 @@ if (!common.enoughTestMem)
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('http',
-             [
-               'benchmarker=test-double-http',
-               'c=1',
-               'chunkedEnc=true',
-               'chunks=0',
-               'dur=0.1',
-               'duplicates=1',
-               'input=keep-alive',
-               'key=""',
-               'len=1',
-               'method=write',
-               'n=1',
-               'res=normal',
-               'type=asc',
-               'value=X-Powered-By'
-             ],
-             {
-               NODEJS_BENCHMARK_ZERO_ALLOWED: 1,
-               duration: 0
-             });
+runBenchmark(
+  'http',
+  [
+    'benchmarker=test-double-http',
+    'c=1',
+    'chunkedEnc=true',
+    'chunks=0',
+    'dur=0.1',
+    'duplicates=1',
+    'input=keep-alive',
+    'key=""',
+    'len=1',
+    'method=write',
+    'n=1',
+    'res=normal',
+    'type=asc',
+    'value=X-Powered-By'
+  ],
+  {
+    NODEJS_BENCHMARK_ZERO_ALLOWED: 1,
+    duration: 0
+  }
+);
diff --git a/test/benchmark/test-benchmark-http2.js b/test/benchmark/test-benchmark-http2.js
index 1668a7b87fe643..f7e26e6a6508db 100644
--- a/test/benchmark/test-benchmark-http2.js
+++ b/test/benchmark/test-benchmark-http2.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 if (!common.enoughTestMem)
   common.skip('Insufficient memory for HTTP/2 benchmark test');
@@ -13,17 +12,19 @@ if (!common.enoughTestMem)
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('http2',
-             [
-               'benchmarker=test-double-http2',
-               'clients=1',
-               'length=65536',
-               'n=1',
-               'nheaders=0',
-               'requests=1',
-               'streams=1'
-             ],
-             {
-               NODEJS_BENCHMARK_ZERO_ALLOWED: 1,
-               duration: 0
-             });
+runBenchmark(
+  'http2',
+  [
+    'benchmarker=test-double-http2',
+    'clients=1',
+    'length=65536',
+    'n=1',
+    'nheaders=0',
+    'requests=1',
+    'streams=1'
+  ],
+  {
+    NODEJS_BENCHMARK_ZERO_ALLOWED: 1,
+    duration: 0
+  }
+);
diff --git a/test/benchmark/test-benchmark-misc.js b/test/benchmark/test-benchmark-misc.js
index b88415280833bc..329c1ef65ac4be 100644
--- a/test/benchmark/test-benchmark-misc.js
+++ b/test/benchmark/test-benchmark-misc.js
@@ -4,13 +4,17 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('misc', [
-  'concat=0',
-  'dur=0.1',
-  'method=',
-  'n=1',
-  'type=',
-  'val=magyarország.icom.museum',
-  'script=test/fixtures/semicolon',
-  'mode=worker'
-], { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'misc',
+  [
+    'concat=0',
+    'dur=0.1',
+    'method=',
+    'n=1',
+    'type=',
+    'val=magyarország.icom.museum',
+    'script=test/fixtures/semicolon',
+    'mode=worker'
+  ],
+  { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-module.js b/test/benchmark/test-benchmark-module.js
index d81936210c00fe..6b35c5208931d0 100644
--- a/test/benchmark/test-benchmark-module.js
+++ b/test/benchmark/test-benchmark-module.js
@@ -4,8 +4,4 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('module', [
-  'n=1',
-  'useCache=true',
-  'fullPath=true'
-]);
+runBenchmark('module', ['n=1', 'useCache=true', 'fullPath=true']);
diff --git a/test/benchmark/test-benchmark-napi.js b/test/benchmark/test-benchmark-napi.js
index 1a1ff23d60c5c0..97a09535bb90c3 100644
--- a/test/benchmark/test-benchmark-napi.js
+++ b/test/benchmark/test-benchmark-napi.js
@@ -3,7 +3,7 @@
 const common = require('../common');
 
 if (common.isWindows) {
-  common.skip('vcbuild.bat doesn\'t build the n-api benchmarks yet');
+  common.skip("vcbuild.bat doesn't build the n-api benchmarks yet");
 }
 
 if (!common.isMainThread) {
@@ -15,10 +15,6 @@ if (process.features.debug) {
 }
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('napi',
-             [
-               'n=1',
-               'engine=v8',
-               'type=String'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('napi', ['n=1', 'engine=v8', 'type=String'], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-net.js b/test/benchmark/test-benchmark-net.js
index 5d3d283fc7903e..16a82b1596c08c 100644
--- a/test/benchmark/test-benchmark-net.js
+++ b/test/benchmark/test-benchmark-net.js
@@ -8,10 +8,6 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('net',
-             [
-               'dur=0',
-               'len=1024',
-               'type=buf'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('net', ['dur=0', 'len=1024', 'type=buf'], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-path.js b/test/benchmark/test-benchmark-path.js
index 890fd7ae41f548..762d4fc10f41a5 100644
--- a/test/benchmark/test-benchmark-path.js
+++ b/test/benchmark/test-benchmark-path.js
@@ -4,11 +4,6 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('path',
-             [
-               'n=1',
-               'path=',
-               'pathext=',
-               'paths=',
-               'props='
-             ], { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('path', ['n=1', 'path=', 'pathext=', 'paths=', 'props='], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-process.js b/test/benchmark/test-benchmark-process.js
index 15cb678017e7bb..eab32fa5e7b972 100644
--- a/test/benchmark/test-benchmark-process.js
+++ b/test/benchmark/test-benchmark-process.js
@@ -4,8 +4,6 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('process',
-             [
-               'n=1',
-               'type=raw'
-             ], { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('process', ['n=1', 'type=raw'], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-querystring.js b/test/benchmark/test-benchmark-querystring.js
index 77d0ac99ff97d8..3b6d4a116c8497 100644
--- a/test/benchmark/test-benchmark-querystring.js
+++ b/test/benchmark/test-benchmark-querystring.js
@@ -4,9 +4,8 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('querystring',
-             [ 'n=1',
-               'input="there is nothing to unescape here"',
-               'type=noencode'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'querystring',
+  ['n=1', 'input="there is nothing to unescape here"', 'type=noencode'],
+  { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-streams.js b/test/benchmark/test-benchmark-streams.js
index f90838794cdf2a..c1489d863374a1 100644
--- a/test/benchmark/test-benchmark-streams.js
+++ b/test/benchmark/test-benchmark-streams.js
@@ -4,10 +4,6 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('streams',
-             [
-               'kind=duplex',
-               'type=buffer',
-               'n=1'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('streams', ['kind=duplex', 'type=buffer', 'n=1'], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-string_decoder.js b/test/benchmark/test-benchmark-string_decoder.js
index f2fd6abe4b8f5f..4274746402fe87 100644
--- a/test/benchmark/test-benchmark-string_decoder.js
+++ b/test/benchmark/test-benchmark-string_decoder.js
@@ -4,7 +4,9 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('string_decoder', ['chunkLen=16',
-                                'encoding=utf8',
-                                'inLen=32',
-                                'n=1']);
+runBenchmark('string_decoder', [
+  'chunkLen=16',
+  'encoding=utf8',
+  'inLen=32',
+  'n=1'
+]);
diff --git a/test/benchmark/test-benchmark-timers.js b/test/benchmark/test-benchmark-timers.js
index af3c49bd714742..972d4f28c14f6a 100644
--- a/test/benchmark/test-benchmark-timers.js
+++ b/test/benchmark/test-benchmark-timers.js
@@ -4,10 +4,6 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('timers',
-             [
-               'direction=start',
-               'n=1',
-               'type=depth',
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('timers', ['direction=start', 'n=1', 'type=depth'], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-tls.js b/test/benchmark/test-benchmark-tls.js
index 40c14af8302bdb..0aa33332234374 100644
--- a/test/benchmark/test-benchmark-tls.js
+++ b/test/benchmark/test-benchmark-tls.js
@@ -2,8 +2,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 if (!common.enoughTestMem)
   common.skip('Insufficient memory for TLS benchmark test');
@@ -14,16 +13,18 @@ if (!common.enoughTestMem)
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('tls',
-             [
-               'concurrency=1',
-               'dur=0.1',
-               'n=1',
-               'size=2',
-               'securing=SecurePair',
-               'type=asc'
-             ],
-             {
-               NODEJS_BENCHMARK_ZERO_ALLOWED: 1,
-               duration: 0
-             });
+runBenchmark(
+  'tls',
+  [
+    'concurrency=1',
+    'dur=0.1',
+    'n=1',
+    'size=2',
+    'securing=SecurePair',
+    'type=asc'
+  ],
+  {
+    NODEJS_BENCHMARK_ZERO_ALLOWED: 1,
+    duration: 0
+  }
+);
diff --git a/test/benchmark/test-benchmark-url.js b/test/benchmark/test-benchmark-url.js
index 92bb34de278f80..9b3515264003c1 100644
--- a/test/benchmark/test-benchmark-url.js
+++ b/test/benchmark/test-benchmark-url.js
@@ -4,20 +4,22 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('url',
-             [
-               'method=legacy',
-               'loopMethod=forEach',
-               'accessMethod=get',
-               'type=short',
-               'searchParam=noencode',
-               'href=short',
-               'input=short',
-               'domain=empty',
-               'path=up',
-               'to=ascii',
-               'prop=href',
-               'n=1',
-               'param=one'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'url',
+  [
+    'method=legacy',
+    'loopMethod=forEach',
+    'accessMethod=get',
+    'type=short',
+    'searchParam=noencode',
+    'href=short',
+    'input=short',
+    'domain=empty',
+    'path=up',
+    'to=ascii',
+    'prop=href',
+    'n=1',
+    'param=one'
+  ],
+  { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-util.js b/test/benchmark/test-benchmark-util.js
index 97b02bbdeed5cd..e9583fdf1dfc29 100644
--- a/test/benchmark/test-benchmark-util.js
+++ b/test/benchmark/test-benchmark-util.js
@@ -4,15 +4,19 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('util',
-             ['argument=false',
-              'input=',
-              'method=Array',
-              'n=1',
-              'option=none',
-              'pos=start',
-              'size=1',
-              'type=',
-              'len=1',
-              'version=native'],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark(
+  'util',
+  [
+    'argument=false',
+    'input=',
+    'method=Array',
+    'n=1',
+    'option=none',
+    'pos=start',
+    'size=1',
+    'type=',
+    'len=1',
+    'version=native'
+  ],
+  { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 }
+);
diff --git a/test/benchmark/test-benchmark-v8.js b/test/benchmark/test-benchmark-v8.js
index 22861785db9c05..ddf230b1407761 100644
--- a/test/benchmark/test-benchmark-v8.js
+++ b/test/benchmark/test-benchmark-v8.js
@@ -4,9 +4,6 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('v8',
-             [
-               'method=getHeapStatistics',
-               'n=1'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('v8', ['method=getHeapStatistics', 'n=1'], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-vm.js b/test/benchmark/test-benchmark-vm.js
index 79ab6a03402522..6787f7afabeff4 100644
--- a/test/benchmark/test-benchmark-vm.js
+++ b/test/benchmark/test-benchmark-vm.js
@@ -4,10 +4,6 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('vm',
-             [
-               'breakOnSigint=0',
-               'withSigintListener=0',
-               'n=1'
-             ],
-             { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
+runBenchmark('vm', ['breakOnSigint=0', 'withSigintListener=0', 'n=1'], {
+  NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+});
diff --git a/test/benchmark/test-benchmark-worker.js b/test/benchmark/test-benchmark-worker.js
index ae9a8a6701ae4a..86f2653ad0a143 100644
--- a/test/benchmark/test-benchmark-worker.js
+++ b/test/benchmark/test-benchmark-worker.js
@@ -11,13 +11,10 @@ if (!common.enoughTestMem)
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('worker',
-             [
-               'n=1',
-               'sendsPerBroadcast=1',
-               'workers=1',
-               'payload=string'
-             ],
-             {
-               NODEJS_BENCHMARK_ZERO_ALLOWED: 1
-             });
+runBenchmark(
+  'worker',
+  ['n=1', 'sendsPerBroadcast=1', 'workers=1', 'payload=string'],
+  {
+    NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+  }
+);
diff --git a/test/benchmark/test-benchmark-zlib.js b/test/benchmark/test-benchmark-zlib.js
index 25b7d1a4d5f905..de4517541ef2bd 100644
--- a/test/benchmark/test-benchmark-zlib.js
+++ b/test/benchmark/test-benchmark-zlib.js
@@ -4,15 +4,17 @@ require('../common');
 
 const runBenchmark = require('../common/benchmark');
 
-runBenchmark('zlib',
-             [
-               'method=deflate',
-               'n=1',
-               'options=true',
-               'type=Deflate',
-               'inputLen=1024',
-               'duration=0.001'
-             ],
-             {
-               'NODEJS_BENCHMARK_ZERO_ALLOWED': 1
-             });
+runBenchmark(
+  'zlib',
+  [
+    'method=deflate',
+    'n=1',
+    'options=true',
+    'type=Deflate',
+    'inputLen=1024',
+    'duration=0.001'
+  ],
+  {
+    NODEJS_BENCHMARK_ZERO_ALLOWED: 1
+  }
+);
diff --git a/test/code-cache/test-code-cache-generator.js b/test/code-cache/test-code-cache-generator.js
index 972d89629c0a23..f60cef1f95cb2e 100644
--- a/test/code-cache/test-code-cache-generator.js
+++ b/test/code-cache/test-code-cache-generator.js
@@ -13,16 +13,21 @@ const fs = require('fs');
 const readline = require('readline');
 
 const generator = path.join(
-  __dirname, '..', '..', 'tools', 'generate_code_cache.js'
+  __dirname,
+  '..',
+  '..',
+  'tools',
+  'generate_code_cache.js'
 );
 tmpdir.refresh();
 const dest = path.join(tmpdir.path, 'cache.cc');
 
 // Run tools/generate_code_cache.js
-const child = spawnSync(
-  process.execPath,
-  ['--expose-internals', generator, dest]
-);
+const child = spawnSync(process.execPath, [
+  '--expose-internals',
+  generator,
+  dest
+]);
 assert.ifError(child.error);
 if (child.status !== 0) {
   console.log(child.stderr.toString());
@@ -43,16 +48,22 @@ const rl = readline.createInterface({
 let hasCacheDef = false;
 let hasHashDef = false;
 
-rl.on('line', common.mustCallAtLeast((line) => {
-  if (line.includes('DefineCodeCache(')) {
-    hasCacheDef = true;
-  }
-  if (line.includes('DefineCodeCacheHash(')) {
-    hasHashDef = true;
-  }
-}, 2));
-
-rl.on('close', common.mustCall(() => {
-  assert.ok(hasCacheDef);
-  assert.ok(hasHashDef);
-}));
+rl.on(
+  'line',
+  common.mustCallAtLeast((line) => {
+    if (line.includes('DefineCodeCache(')) {
+      hasCacheDef = true;
+    }
+    if (line.includes('DefineCodeCacheHash(')) {
+      hasHashDef = true;
+    }
+  }, 2)
+);
+
+rl.on(
+  'close',
+  common.mustCall(() => {
+    assert.ok(hasCacheDef);
+    assert.ok(hasHashDef);
+  })
+);
diff --git a/test/code-cache/test-code-cache.js b/test/code-cache/test-code-cache.js
index 994facff1996c2..81b69cd7abbb29 100644
--- a/test/code-cache/test-code-cache.js
+++ b/test/code-cache/test-code-cache.js
@@ -11,21 +11,16 @@ const {
   cachableBuiltins,
   cannotUseCache
 } = require('internal/bootstrap/cache');
-const {
-  isMainThread
-} = require('worker_threads');
+const { isMainThread } = require('worker_threads');
 
-const {
-  internalBinding
-} = require('internal/test/binding');
-const {
-  compiledWithoutCache,
-  compiledWithCache
-} = internalBinding('native_module');
+const { internalBinding } = require('internal/test/binding');
+const { compiledWithoutCache, compiledWithCache } = internalBinding(
+  'native_module'
+);
 
 for (const key of cachableBuiltins) {
   if (!isMainThread && key === 'trace_events') {
-    continue;  // Cannot load trace_events in workers
+    continue; // Cannot load trace_events in workers
   }
   require(key);
 }
@@ -49,11 +44,15 @@ if (process.config.variables.node_code_cache_path === undefined) {
 
   for (const key of loadedModules) {
     if (cannotUseCache.includes(key)) {
-      assert(compiledWithoutCache.has(key),
-             `"${key}" should've been compiled without code cache`);
+      assert(
+        compiledWithoutCache.has(key),
+        `"${key}" should've been compiled without code cache`
+      );
     } else {
-      assert(compiledWithCache.has(key),
-             `"${key}" should've been compiled with code cache`);
+      assert(
+        compiledWithCache.has(key),
+        `"${key}" should've been compiled with code cache`
+      );
     }
   }
 }
diff --git a/test/common/countdown.js b/test/common/countdown.js
index 67252657ec28b7..c5f6b47631dc6a 100644
--- a/test/common/countdown.js
+++ b/test/common/countdown.js
@@ -17,8 +17,7 @@ class Countdown {
 
   dec() {
     assert(this[kLimit] > 0, 'Countdown expired');
-    if (--this[kLimit] === 0)
-      this[kCallback]();
+    if (--this[kLimit] === 0) this[kCallback]();
     return this[kLimit];
   }
 
diff --git a/test/common/dns.js b/test/common/dns.js
index 01245c33d6997c..efb30ec7ae1618 100644
--- a/test/common/dns.js
+++ b/test/common/dns.js
@@ -27,7 +27,7 @@ function readDomainFromPacket(buffer, offset) {
   const length = buffer[offset];
   if (length === 0) {
     return { nread: 1, domain: '' };
-  } else if ((length & 0xC0) === 0) {
+  } else if ((length & 0xc0) === 0) {
     offset += 1;
     const chunk = buffer.toString('ascii', offset, offset + length);
     // Read the rest of the domain.
@@ -38,9 +38,9 @@ function readDomainFromPacket(buffer, offset) {
     };
   } else {
     // Pointer to another part of the packet.
-    assert.strictEqual(length & 0xC0, 0xC0);
+    assert.strictEqual(length & 0xc0, 0xc0);
     // eslint-disable-next-line space-infix-ops, space-unary-ops
-    const pointeeOffset = buffer.readUInt16BE(offset) &~ 0xC000;
+    const pointeeOffset = buffer.readUInt16BE(offset) & ~0xc000;
     return {
       nread: 2,
       domain: readDomainFromPacket(buffer, pointeeOffset)
@@ -53,7 +53,7 @@ function parseDNSPacket(buffer) {
 
   const parsed = {
     id: buffer.readUInt16BE(0),
-    flags: buffer.readUInt16BE(2),
+    flags: buffer.readUInt16BE(2)
   };
 
   const counts = [
@@ -64,7 +64,7 @@ function parseDNSPacket(buffer) {
   ];
 
   let offset = 12;
-  for (const [ sectionName, count ] of counts) {
+  for (const [sectionName, count] of counts) {
     parsed[sectionName] = [];
     for (let i = 0; i < count; ++i) {
       const { nread, domain } = readDomainFromPacket(buffer, offset);
@@ -74,13 +74,12 @@ function parseDNSPacket(buffer) {
 
       const rr = {
         domain,
-        cls: buffer.readUInt16BE(offset + 2),
+        cls: buffer.readUInt16BE(offset + 2)
       };
       offset += 4;
 
       for (const name in types) {
-        if (types[name] === type)
-          rr.type = name;
+        if (types[name] === type) rr.type = name;
       }
 
       if (sectionName !== 'questions') {
@@ -91,30 +90,30 @@ function parseDNSPacket(buffer) {
         switch (type) {
           case types.A:
             assert.strictEqual(dataLength, 4);
-            rr.address = `${buffer[offset + 0]}.${buffer[offset + 1]}.` +
-                         `${buffer[offset + 2]}.${buffer[offset + 3]}`;
+            rr.address =
+              `${buffer[offset + 0]}.${buffer[offset + 1]}.` +
+              `${buffer[offset + 2]}.${buffer[offset + 3]}`;
             break;
           case types.AAAA:
             assert.strictEqual(dataLength, 16);
-            rr.address = buffer.toString('hex', offset, offset + 16)
-                               .replace(/(.{4}(?!$))/g, '$1:');
+            rr.address = buffer
+              .toString('hex', offset, offset + 16)
+              .replace(/(.{4}(?!$))/g, '$1:');
             break;
-          case types.TXT:
-          {
+          case types.TXT: {
             let position = offset;
             rr.entries = [];
             while (position < offset + dataLength) {
               const txtLength = buffer[offset];
-              rr.entries.push(buffer.toString('utf8',
-                                              position + 1,
-                                              position + 1 + txtLength));
+              rr.entries.push(
+                buffer.toString('utf8', position + 1, position + 1 + txtLength)
+              );
               position += 1 + txtLength;
             }
             assert.strictEqual(position, offset + dataLength);
             break;
           }
-          case types.MX:
-          {
+          case types.MX: {
             rr.priority = buffer.readInt16BE(buffer, offset);
             offset += 2;
             const { nread, domain } = readDomainFromPacket(buffer, offset);
@@ -124,15 +123,13 @@ function parseDNSPacket(buffer) {
           }
           case types.NS:
           case types.CNAME:
-          case types.PTR:
-          {
+          case types.PTR: {
             const { nread, domain } = readDomainFromPacket(buffer, offset);
             rr.value = domain;
             assert.strictEqual(nread, dataLength);
             break;
           }
-          case types.SOA:
-          {
+          case types.SOA: {
             const mname = readDomainFromPacket(buffer, offset);
             const rname = readDomainFromPacket(buffer, offset + mname.nread);
             rr.nsname = mname.domain;
@@ -181,48 +178,58 @@ function writeIPv6(ip) {
 }
 
 function writeDomainName(domain) {
-  return Buffer.concat(domain.split('.').map((label) => {
-    assert(label.length < 64);
-    return Buffer.concat([
-      Buffer.from([label.length]),
-      Buffer.from(label, 'ascii')
-    ]);
-  }).concat([Buffer.alloc(1)]));
+  return Buffer.concat(
+    domain
+      .split('.')
+      .map((label) => {
+        assert(label.length < 64);
+        return Buffer.concat([
+          Buffer.from([label.length]),
+          Buffer.from(label, 'ascii')
+        ]);
+      })
+      .concat([Buffer.alloc(1)])
+  );
 }
 
 function writeDNSPacket(parsed) {
   const buffers = [];
   const kStandardResponseFlags = 0x8180;
 
-  buffers.push(new Uint16Array([
-    parsed.id,
-    parsed.flags === undefined ? kStandardResponseFlags : parsed.flags,
-    parsed.questions && parsed.questions.length,
-    parsed.answers && parsed.answers.length,
-    parsed.authorityAnswers && parsed.authorityAnswers.length,
-    parsed.additionalRecords && parsed.additionalRecords.length,
-  ]));
+  buffers.push(
+    new Uint16Array([
+      parsed.id,
+      parsed.flags === undefined ? kStandardResponseFlags : parsed.flags,
+      parsed.questions && parsed.questions.length,
+      parsed.answers && parsed.answers.length,
+      parsed.authorityAnswers && parsed.authorityAnswers.length,
+      parsed.additionalRecords && parsed.additionalRecords.length
+    ])
+  );
 
   for (const q of parsed.questions) {
     assert(types[q.type]);
     buffers.push(writeDomainName(q.domain));
-    buffers.push(new Uint16Array([
-      types[q.type],
-      q.cls === undefined ? classes.IN : q.cls
-    ]));
+    buffers.push(
+      new Uint16Array([types[q.type], q.cls === undefined ? classes.IN : q.cls])
+    );
   }
 
-  for (const rr of [].concat(parsed.answers,
-                             parsed.authorityAnswers,
-                             parsed.additionalRecords)) {
+  for (const rr of [].concat(
+    parsed.answers,
+    parsed.authorityAnswers,
+    parsed.additionalRecords
+  )) {
     if (!rr) continue;
 
     assert(types[rr.type]);
     buffers.push(writeDomainName(rr.domain));
-    buffers.push(new Uint16Array([
-      types[rr.type],
-      rr.cls === undefined ? classes.IN : rr.cls
-    ]));
+    buffers.push(
+      new Uint16Array([
+        types[rr.type],
+        rr.cls === undefined ? classes.IN : rr.cls
+      ])
+    );
     buffers.push(new Int32Array([rr.ttl]));
 
     const rdLengthBuf = new Uint16Array(1);
@@ -249,25 +256,29 @@ function writeDNSPacket(parsed) {
       case 'MX':
         rdLengthBuf[0] = 2;
         buffers.push(new Uint16Array([rr.priority]));
-        // fall through
+      // fall through
       case 'NS':
       case 'CNAME':
-      case 'PTR':
-      {
+      case 'PTR': {
         const domain = writeDomainName(rr.exchange || rr.value);
         rdLengthBuf[0] += domain.length;
         buffers.push(domain);
         break;
       }
-      case 'SOA':
-      {
+      case 'SOA': {
         const mname = writeDomainName(rr.nsname);
         const rname = writeDomainName(rr.hostmaster);
         rdLengthBuf[0] = mname.length + rname.length + 20;
         buffers.push(mname, rname);
-        buffers.push(new Uint32Array([
-          rr.serial, rr.refresh, rr.retry, rr.expire, rr.minttl
-        ]));
+        buffers.push(
+          new Uint32Array([
+            rr.serial,
+            rr.refresh,
+            rr.retry,
+            rr.expire,
+            rr.minttl
+          ])
+        );
         break;
       }
       default:
@@ -275,16 +286,20 @@ function writeDNSPacket(parsed) {
     }
   }
 
-  return Buffer.concat(buffers.map((typedArray) => {
-    const buf = Buffer.from(typedArray.buffer,
-                            typedArray.byteOffset,
-                            typedArray.byteLength);
-    if (os.endianness() === 'LE') {
-      if (typedArray.BYTES_PER_ELEMENT === 2) buf.swap16();
-      if (typedArray.BYTES_PER_ELEMENT === 4) buf.swap32();
-    }
-    return buf;
-  }));
+  return Buffer.concat(
+    buffers.map((typedArray) => {
+      const buf = Buffer.from(
+        typedArray.buffer,
+        typedArray.byteOffset,
+        typedArray.byteLength
+      );
+      if (os.endianness() === 'LE') {
+        if (typedArray.BYTES_PER_ELEMENT === 2) buf.swap16();
+        if (typedArray.BYTES_PER_ELEMENT === 4) buf.swap32();
+      }
+      return buf;
+    })
+  );
 }
 
 const mockedErrorCode = 'ENOTFOUND';
diff --git a/test/common/fixtures.js b/test/common/fixtures.js
index b45e5bc8091865..9505de9e0e882f 100644
--- a/test/common/fixtures.js
+++ b/test/common/fixtures.js
@@ -11,8 +11,7 @@ function fixturesPath(...args) {
 }
 
 function readFixtureSync(args, enc) {
-  if (Array.isArray(args))
-    return fs.readFileSync(fixturesPath(...args), enc);
+  if (Array.isArray(args)) return fs.readFileSync(fixturesPath(...args), enc);
   return fs.readFileSync(fixturesPath(args), enc);
 }
 
diff --git a/test/common/heap.js b/test/common/heap.js
index e23670b64c8a2d..51bd9f4f6659c2 100644
--- a/test/common/heap.js
+++ b/test/common/heap.js
@@ -40,25 +40,32 @@ class State {
   // Validate the v8 heap snapshot
   validateSnapshot(rootName, expected, { loose = false } = {}) {
     const rootNodes = this.snapshot.filter(
-      (node) => node.name === rootName && node.type !== 'string');
+      (node) => node.name === rootName && node.type !== 'string'
+    );
     if (loose) {
-      assert(rootNodes.length >= expected.length,
-             `Expect to find at least ${expected.length} '${rootName}', ` +
-             `found ${rootNodes.length}`);
+      assert(
+        rootNodes.length >= expected.length,
+        `Expect to find at least ${expected.length} '${rootName}', ` +
+          `found ${rootNodes.length}`
+      );
     } else {
       assert.strictEqual(
-        rootNodes.length, expected.length,
+        rootNodes.length,
+        expected.length,
         `Expect to find ${expected.length} '${rootName}', ` +
-        `found ${rootNodes.length}`);
+          `found ${rootNodes.length}`
+      );
     }
 
     for (const expectation of expected) {
       if (expectation.children) {
         for (const expectedEdge of expectation.children) {
-          const check = typeof expectedEdge === 'function' ? expectedEdge :
-            (edge) => (isEdge(edge, expectedEdge));
-          const hasChild = rootNodes.some(
-            (node) => node.outgoingEdges.some(check)
+          const check =
+            typeof expectedEdge === 'function'
+              ? expectedEdge
+              : (edge) => isEdge(edge, expectedEdge);
+          const hasChild = rootNodes.some((node) =>
+            node.outgoingEdges.some(check)
           );
           // Don't use assert with a custom message here. Otherwise the
           // inspection in the message is done eagerly and wastes a lot of CPU
@@ -66,7 +73,8 @@ class State {
           if (!hasChild) {
             throw new Error(
               'expected to find child ' +
-              `${util.inspect(expectedEdge)} in ${inspectNode(rootNodes)}`);
+                `${util.inspect(expectedEdge)} in ${inspectNode(rootNodes)}`
+            );
           }
         }
       }
@@ -79,30 +87,35 @@ class State {
       (node) => node.name === rootName
     );
     if (loose) {
-      assert(rootNodes.length >= expected.length,
-             `Expect to find at least ${expected.length} '${rootName}', ` +
-             `found ${rootNodes.length}`);
+      assert(
+        rootNodes.length >= expected.length,
+        `Expect to find at least ${expected.length} '${rootName}', ` +
+          `found ${rootNodes.length}`
+      );
     } else {
       assert.strictEqual(
-        rootNodes.length, expected.length,
+        rootNodes.length,
+        expected.length,
         `Expect to find ${expected.length} '${rootName}', ` +
-        `found ${rootNodes.length}`);
+          `found ${rootNodes.length}`
+      );
     }
     for (const expectation of expected) {
       if (expectation.children) {
         for (const expectedEdge of expectation.children) {
-          const check = typeof expectedEdge === 'function' ? expectedEdge :
-            (edge) => (isEdge(edge, expectedEdge));
+          const check =
+            typeof expectedEdge === 'function'
+              ? expectedEdge
+              : (edge) => isEdge(edge, expectedEdge);
           // Don't use assert with a custom message here. Otherwise the
           // inspection in the message is done eagerly and wastes a lot of CPU
           // time.
-          const hasChild = rootNodes.some(
-            (node) => node.edges.some(check)
-          );
+          const hasChild = rootNodes.some((node) => node.edges.some(check));
           if (!hasChild) {
             throw new Error(
               'expected to find child ' +
-              `${util.inspect(expectedEdge)} in ${inspectNode(rootNodes)}`);
+                `${util.inspect(expectedEdge)} in ${inspectNode(rootNodes)}`
+            );
           }
         }
       }
diff --git a/test/common/hijackstdio.js b/test/common/hijackstdio.js
index fcc98208f0ec8c..e2377e5da68735 100644
--- a/test/common/hijackstdio.js
+++ b/test/common/hijackstdio.js
@@ -5,14 +5,16 @@
 const stdWrite = {};
 function hijackStdWritable(name, listener) {
   const stream = process[name];
-  const _write = stdWrite[name] = stream.write;
+  const _write = (stdWrite[name] = stream.write);
 
   stream.writeTimes = 0;
   stream.write = function(data, callback) {
     try {
       listener(data);
     } catch (e) {
-      process.nextTick(() => { throw e; });
+      process.nextTick(() => {
+        throw e;
+      });
     }
 
     _write.call(stream, data, callback);
diff --git a/test/common/http2.js b/test/common/http2.js
index f84a66861755b9..d3f28a5ac51005 100644
--- a/test/common/http2.js
+++ b/test/common/http2.js
@@ -11,34 +11,39 @@ const FLAG_EOH = 0x4;
 const FLAG_PADDED = 0x8;
 const PADDING = Buffer.alloc(255);
 
-const kClientMagic = Buffer.from('505249202a20485454502f322' +
-                                 'e300d0a0d0a534d0d0a0d0a', 'hex');
-
-const kFakeRequestHeaders = Buffer.from('828684410f7777772e65' +
-                                        '78616d706c652e636f6d', 'hex');
-
-
-const kFakeResponseHeaders = Buffer.from('4803333032580770726976617465611d' +
-                                         '4d6f6e2c203231204f63742032303133' +
-                                         '2032303a31333a323120474d546e1768' +
-                                         '747470733a2f2f7777772e6578616d70' +
-                                         '6c652e636f6d', 'hex');
+const kClientMagic = Buffer.from(
+  '505249202a20485454502f322' + 'e300d0a0d0a534d0d0a0d0a',
+  'hex'
+);
+
+const kFakeRequestHeaders = Buffer.from(
+  '828684410f7777772e65' + '78616d706c652e636f6d',
+  'hex'
+);
+
+const kFakeResponseHeaders = Buffer.from(
+  '4803333032580770726976617465611d' +
+    '4d6f6e2c203231204f63742032303133' +
+    '2032303a31333a323120474d546e1768' +
+    '747470733a2f2f7777772e6578616d70' +
+    '6c652e636f6d',
+  'hex'
+);
 
 function isUint32(val) {
   return val >>> 0 === val;
 }
 
 function isUint24(val) {
-  return val >>> 0 === val && val <= 0xFFFFFF;
+  return val >>> 0 === val && val <= 0xffffff;
 }
 
 function isUint8(val) {
-  return val >>> 0 === val && val <= 0xFF;
+  return val >>> 0 === val && val <= 0xff;
 }
 
 function write32BE(array, pos, val) {
-  if (!isUint32(val))
-    throw new RangeError('val is not a 32-bit number');
+  if (!isUint32(val)) throw new RangeError('val is not a 32-bit number');
   array[pos++] = (val >> 24) & 0xff;
   array[pos++] = (val >> 16) & 0xff;
   array[pos++] = (val >> 8) & 0xff;
@@ -46,16 +51,14 @@ function write32BE(array, pos, val) {
 }
 
 function write24BE(array, pos, val) {
-  if (!isUint24(val))
-    throw new RangeError('val is not a 24-bit number');
+  if (!isUint24(val)) throw new RangeError('val is not a 24-bit number');
   array[pos++] = (val >> 16) & 0xff;
   array[pos++] = (val >> 8) & 0xff;
   array[pos++] = val & 0xff;
 }
 
 function write8(array, pos, val) {
-  if (!isUint8(val))
-    throw new RangeError('val is not an 8-bit number');
+  if (!isUint8(val)) throw new RangeError('val is not an 8-bit number');
   array[pos] = val;
 }
 
@@ -76,8 +79,7 @@ class Frame {
 class SettingsFrame extends Frame {
   constructor(ack = false) {
     let flags = 0;
-    if (ack)
-      flags |= FLAG_ACK;
+    if (ack) flags |= FLAG_ACK;
     super(0, 4, flags, 0);
   }
 }
diff --git a/test/common/index.js b/test/common/index.js
index 7b668e58c48ead..dbf2ee63d3e4ac 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -21,7 +21,7 @@
 
 /* eslint-disable node-core/required-modules, node-core/crypto-check */
 'use strict';
-const process = global.process;  // Some tests tamper with the process global.
+const process = global.process; // Some tests tamper with the process global.
 const path = require('path');
 const fs = require('fs');
 const assert = require('assert');
@@ -29,10 +29,7 @@ const os = require('os');
 const { exec, execSync, spawnSync } = require('child_process');
 const util = require('util');
 const tmpdir = require('./tmpdir');
-const {
-  bits,
-  hasIntl
-} = process.binding('config');
+const { bits, hasIntl } = process.binding('config');
 
 const noop = () => {};
 
@@ -47,21 +44,22 @@ const isMainThread = (() => {
 
 const isWindows = process.platform === 'win32';
 const isAIX = process.platform === 'aix';
-const isLinuxPPCBE = (process.platform === 'linux') &&
-                     (process.arch === 'ppc64') &&
-                     (os.endianness() === 'BE');
+const isLinuxPPCBE =
+  process.platform === 'linux' &&
+  process.arch === 'ppc64' &&
+  os.endianness() === 'BE';
 const isSunOS = process.platform === 'sunos';
 const isFreeBSD = process.platform === 'freebsd';
 const isOpenBSD = process.platform === 'openbsd';
 const isLinux = process.platform === 'linux';
 const isOSX = process.platform === 'darwin';
 
-const isOSXMojave = isOSX && (os.release().startsWith('18'));
+const isOSXMojave = isOSX && os.release().startsWith('18');
 
 const enoughTestMem = os.totalmem() > 0x70000000; /* 1.75 Gb */
 const cpus = os.cpus();
-const enoughTestCpu = Array.isArray(cpus) &&
-                      (cpus.length > 1 || cpus[0].speed > 999);
+const enoughTestCpu =
+  Array.isArray(cpus) && (cpus.length > 1 || cpus[0].speed > 999);
 
 const rootDir = isWindows ? 'c:\\' : '/';
 
@@ -79,8 +77,7 @@ if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) {
 
   process.on('exit', () => {
     // iterate through handles to make sure nothing crashes
-    for (const k in initHandles)
-      util.inspect(initHandles[k]);
+    for (const k in initHandles) util.inspect(initHandles[k]);
   });
 
   const _queueDestroyAsyncId = async_wrap.queueDestroyAsyncId;
@@ -94,46 +91,50 @@ if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) {
     _queueDestroyAsyncId(id);
   };
 
-  require('async_hooks').createHook({
-    init(id, ty, tr, r) {
-      if (initHandles[id]) {
-        process._rawDebug(
-          `Is same resource: ${r === initHandles[id].resource}`);
-        process._rawDebug(`Previous stack:\n${initHandles[id].stack}\n`);
-        throw new Error(`init called twice for same id (${id})`);
+  require('async_hooks')
+    .createHook({
+      init(id, ty, tr, r) {
+        if (initHandles[id]) {
+          process._rawDebug(
+            `Is same resource: ${r === initHandles[id].resource}`
+          );
+          process._rawDebug(`Previous stack:\n${initHandles[id].stack}\n`);
+          throw new Error(`init called twice for same id (${id})`);
+        }
+        initHandles[id] = { resource: r, stack: new Error().stack.substr(6) };
+      },
+      before() {},
+      after() {},
+      destroy(id) {
+        if (destroydIdsList[id] !== undefined) {
+          process._rawDebug(destroydIdsList[id]);
+          process._rawDebug();
+          throw new Error(`destroy called for same id (${id})`);
+        }
+        destroydIdsList[id] = new Error().stack;
       }
-      initHandles[id] = { resource: r, stack: new Error().stack.substr(6) };
-    },
-    before() { },
-    after() { },
-    destroy(id) {
-      if (destroydIdsList[id] !== undefined) {
-        process._rawDebug(destroydIdsList[id]);
-        process._rawDebug();
-        throw new Error(`destroy called for same id (${id})`);
-      }
-      destroydIdsList[id] = new Error().stack;
-    },
-  }).enable();
+    })
+    .enable();
 }
 
 let opensslCli = null;
 let inFreeBSDJail = null;
 let localhostIPv4 = null;
 
-const localIPv6Hosts =
-  isLinux ? [
-    // Debian/Ubuntu
-    'ip6-localhost',
-    'ip6-loopback',
+const localIPv6Hosts = isLinux
+  ? [
+      // Debian/Ubuntu
+      'ip6-localhost',
+      'ip6-loopback',
 
-    // SUSE
-    'ipv6-localhost',
-    'ipv6-loopback',
+      // SUSE
+      'ipv6-localhost',
+      'ipv6-loopback',
 
-    // Typically universal
-    'localhost',
-  ] : [ 'localhost' ];
+      // Typically universal
+      'localhost'
+    ]
+  : ['localhost'];
 
 const PIPE = (() => {
   const localRelative = path.relative(process.cwd(), `${tmpdir.path}/`);
@@ -146,8 +147,9 @@ const hasIPv6 = (() => {
   const iFaces = os.networkInterfaces();
   const re = isWindows ? /Loopback Pseudo-Interface/ : /lo/;
   return Object.keys(iFaces).some((name) => {
-    return re.test(name) &&
-           iFaces[name].some(({ family }) => family === 'IPv6');
+    return (
+      re.test(name) && iFaces[name].some(({ family }) => family === 'IPv6')
+    );
   });
 })();
 
@@ -167,9 +169,10 @@ function childShouldThrowAndAbort() {
   testCmd += `"${process.argv[1]}" child`;
   const child = exec(testCmd);
   child.on('exit', function onExit(exitCode, signal) {
-    const errMsg = 'Test should have aborted ' +
-                   `but instead exited with exit code ${exitCode}` +
-                   ` and signal ${signal}`;
+    const errMsg =
+      'Test should have aborted ' +
+      `but instead exited with exit code ${exitCode}` +
+      ` and signal ${signal}`;
     assert(nodeProcessAborted(exitCode, signal), errMsg);
   });
 }
@@ -180,38 +183,30 @@ function createZeroFilledFile(filename) {
   fs.closeSync(fd);
 }
 
-
-const pwdCommand = isWindows ?
-  ['cmd.exe', ['/d', '/c', 'cd']] :
-  ['pwd', []];
-
+const pwdCommand = isWindows ? ['cmd.exe', ['/d', '/c', 'cd']] : ['pwd', []];
 
 function platformTimeout(ms) {
   // ESLint will not support 'bigint' in valid-typeof until it reaches stage 4.
   // See https://github.com/eslint/eslint/pull/9636.
   // eslint-disable-next-line valid-typeof
-  const multipliers = typeof ms === 'bigint' ?
-    { two: 2n, four: 4n, seven: 7n } : { two: 2, four: 4, seven: 7 };
+  const multipliers =
+    typeof ms === 'bigint'
+      ? { two: 2n, four: 4n, seven: 7n }
+      : { two: 2, four: 4, seven: 7 };
 
-  if (process.features.debug)
-    ms = multipliers.two * ms;
+  if (process.features.debug) ms = multipliers.two * ms;
 
-  if (global.__coverage__)
-    ms = multipliers.four * ms;
+  if (global.__coverage__) ms = multipliers.four * ms;
 
-  if (isAIX)
-    return multipliers.two * ms; // default localhost speed is slower on AIX
+  if (isAIX) return multipliers.two * ms; // default localhost speed is slower on AIX
 
-  if (process.arch !== 'arm')
-    return ms;
+  if (process.arch !== 'arm') return ms;
 
   const armv = process.config.variables.arm_version;
 
-  if (armv === '6')
-    return multipliers.seven * ms;  // ARMv6
+  if (armv === '6') return multipliers.seven * ms; // ARMv6
 
-  if (armv === '7')
-    return multipliers.two * ms;  // ARMv7
+  if (armv === '7') return multipliers.two * ms; // ARMv7
 
   return ms; // ARMv8+
 }
@@ -298,11 +293,18 @@ function runCallChecks(exitCode) {
   });
 
   failed.forEach(function(context) {
-    console.log('Mismatched %s function calls. Expected %s, actual %d.',
-                context.name,
-                context.messageSegment,
-                context.actual);
-    console.log(context.stack.split('\n').slice(2).join('\n'));
+    console.log(
+      'Mismatched %s function calls. Expected %s, actual %d.',
+      context.name,
+      context.messageSegment,
+      context.actual
+    );
+    console.log(
+      context.stack
+        .split('\n')
+        .slice(2)
+        .join('\n')
+    );
   });
 
   if (failed.length) process.exit(1);
@@ -332,7 +334,7 @@ function _mustCallInner(fn, criteria = 1, field) {
   const context = {
     [field]: criteria,
     actual: 0,
-    stack: (new Error()).stack,
+    stack: new Error().stack,
     name: fn.name || '<anonymous>'
   };
 
@@ -357,9 +359,11 @@ function hasMultiLocalhost() {
 }
 
 function skipIfEslintMissing() {
-  if (!fs.existsSync(
-    path.join(__dirname, '..', '..', 'tools', 'node_modules', 'eslint')
-  )) {
+  if (
+    !fs.existsSync(
+      path.join(__dirname, '..', '..', 'tools', 'node_modules', 'eslint')
+    )
+  ) {
     skip('missing ESLint');
   }
 }
@@ -372,8 +376,11 @@ function canCreateSymLink() {
     // whoami.exe needs to be the one from System32
     // If unix tools are in the path, they can shadow the one we want,
     // so use the full path while executing whoami
-    const whoamiPath = path.join(process.env.SystemRoot,
-                                 'System32', 'whoami.exe');
+    const whoamiPath = path.join(
+      process.env.SystemRoot,
+      'System32',
+      'whoami.exe'
+    );
 
     try {
       const output = execSync(`${whoamiPath} /priv`, { timout: 1000 });
@@ -402,7 +409,8 @@ function mustNotCall(msg) {
   const callSite = getCallSite(mustNotCall);
   return function mustNotCall() {
     assert.fail(
-      `${msg || 'function should not have been called'} at ${callSite}`);
+      `${msg || 'function should not have been called'} at ${callSite}`
+    );
   };
 }
 
@@ -435,8 +443,7 @@ function nodeProcessAborted(exitCode, signal) {
   // which corresponds to exit code 3221225477 (0xC0000005)
   // (ii) Otherwise, _exit(134) which is called in place of abort() due to
   // raising SIGABRT exiting with ambiguous exit code '3' by default
-  if (isWindows)
-    expectedExitCodes = [0xC0000005, 134];
+  if (isWindows) expectedExitCodes = [0xc0000005, 134];
 
   // When using --abort-on-uncaught-exception, V8 will use
   // base::OS::Abort to terminate the process.
@@ -471,8 +478,10 @@ function _expectWarning(name, expected) {
   const map = new Map(expected);
   return mustCall((warning) => {
     assert.strictEqual(warning.name, name);
-    assert.ok(map.has(warning.message),
-              `unexpected error message: "${warning.message}"`);
+    assert.ok(
+      map.has(warning.message),
+      `unexpected error message: "${warning.message}"`
+    );
     const code = map.get(warning.message);
     assert.strictEqual(warning.code, code);
     // Remove a warning message after it is seen so that we guarantee that we
@@ -493,10 +502,12 @@ function expectWarningByMap(warningMap) {
   Object.keys(warningMap).forEach((name) => {
     let expected = warningMap[name];
     if (!Array.isArray(expected)) {
-      throw new Error('warningMap entries must be arrays consisting of two ' +
-      'entries: [message, warningCode]');
+      throw new Error(
+        'warningMap entries must be arrays consisting of two ' +
+          'entries: [message, warningCode]'
+      );
     }
-    if (!(Array.isArray(expected[0]))) {
+    if (!Array.isArray(expected[0])) {
       if (expected.length === 0) {
         return;
       }
@@ -521,8 +532,7 @@ function expectWarning(nameOrMap, expected, code) {
 class Comparison {
   constructor(obj, keys) {
     for (const key of keys) {
-      if (key in obj)
-        this[key] = obj[key];
+      if (key in obj) this[key] = obj[key];
     }
   }
 }
@@ -556,16 +566,19 @@ function expectsError(fn, settings, exact) {
         constructor = Object.getPrototypeOf(error.constructor);
       }
       // Add the `type` to the error to properly compare and visualize it.
-      if (!('type' in error))
-        error.type = constructor;
+      if (!('type' in error)) error.type = constructor;
     }
 
-    if ('message' in settings &&
-        typeof settings.message === 'object' &&
-        settings.message.test(error.message)) {
+    if (
+      'message' in settings &&
+      typeof settings.message === 'object' &&
+      settings.message.test(error.message)
+    ) {
       // Make a copy so we are able to modify the settings.
       innerSettings = Object.create(
-        settings, Object.getOwnPropertyDescriptors(settings));
+        settings,
+        Object.getOwnPropertyDescriptors(settings)
+      );
       // Visualize the message as identical in case of other errors.
       innerSettings.message = error.message;
     }
@@ -595,7 +608,6 @@ function expectsError(fn, settings, exact) {
           message: err.message
         });
       }
-
     }
     return true;
   }
@@ -656,7 +668,9 @@ function getBufferSources(buf) {
 }
 
 // Crash the process on unhandled rejections.
-const crashOnUnhandledRejection = (err) => { throw err; };
+const crashOnUnhandledRejection = (err) => {
+  throw err;
+};
 process.on('unhandledRejection', crashOnUnhandledRejection);
 function disableCrashOnUnhandledRejection() {
   process.removeListener('unhandledRejection', crashOnUnhandledRejection);
@@ -741,7 +755,9 @@ module.exports = {
   skipIfInspectorDisabled,
   skipIfWorker,
 
-  get localhostIPv6() { return '::1'; },
+  get localhostIPv6() {
+    return '::1';
+  },
 
   get hasFipsCrypto() {
     return hasCrypto && require('crypto').fips;
@@ -750,8 +766,10 @@ module.exports = {
   get inFreeBSDJail() {
     if (inFreeBSDJail !== null) return inFreeBSDJail;
 
-    if (exports.isFreeBSD &&
-        execSync('sysctl -n security.jail.jailed').toString() === '1\n') {
+    if (
+      exports.isFreeBSD &&
+      execSync('sysctl -n security.jail.jailed').toString() === '1\n'
+    ) {
       inFreeBSDJail = true;
     } else {
       inFreeBSDJail = false;
@@ -769,9 +787,11 @@ module.exports = {
       if (process.env.LOCALHOST) {
         localhostIPv4 = process.env.LOCALHOST;
       } else {
-        console.error('Looks like we\'re in a FreeBSD Jail. ' +
-                      'Please provide your default interface address ' +
-                      'as LOCALHOST or expect some tests to fail.');
+        console.error(
+          "Looks like we're in a FreeBSD Jail. " +
+            'Please provide your default interface address ' +
+            'as LOCALHOST or expect some tests to fail.'
+        );
       }
     }
 
@@ -808,5 +828,4 @@ module.exports = {
     }
     return +process.env.NODE_COMMON_PORT || 12346;
   }
-
 };
diff --git a/test/common/inspector-helper.js b/test/common/inspector-helper.js
index 7cac2b29f9c90c..97382dc49137cf 100644
--- a/test/common/inspector-helper.js
+++ b/test/common/inspector-helper.js
@@ -38,12 +38,9 @@ function makeBufferingDataCallback(dataCallback) {
     const newData = Buffer.concat([buffer, data]);
     const str = newData.toString('utf8');
     const lines = str.replace(/\r/g, '').split('\n');
-    if (str.endsWith('\n'))
-      buffer = Buffer.alloc(0);
-    else
-      buffer = Buffer.from(lines.pop(), 'utf8');
-    for (const line of lines)
-      dataCallback(line);
+    if (str.endsWith('\n')) buffer = Buffer.alloc(0);
+    else buffer = Buffer.from(lines.pop(), 'utf8');
+    for (const line of lines) dataCallback(line);
   };
 }
 
@@ -58,16 +55,14 @@ function tearDown(child, err) {
 function parseWSFrame(buffer) {
   // Protocol described in https://tools.ietf.org/html/rfc6455#section-5
   let message = null;
-  if (buffer.length < 2)
-    return { length: 0, message };
+  if (buffer.length < 2) return { length: 0, message };
   if (buffer[0] === 0x88 && buffer[1] === 0x00) {
     return { length: 2, message, closed: true };
   }
   assert.strictEqual(buffer[0], 0x81);
-  let dataLen = 0x7F & buffer[1];
+  let dataLen = 0x7f & buffer[1];
   let bodyOffset = 2;
-  if (buffer.length < bodyOffset + dataLen)
-    return 0;
+  if (buffer.length < bodyOffset + dataLen) return 0;
   if (dataLen === 126) {
     dataLen = buffer.readUInt16BE(2);
     bodyOffset = 4;
@@ -76,18 +71,17 @@ function parseWSFrame(buffer) {
     dataLen = buffer.readUIntBE(4, 6);
     bodyOffset = 10;
   }
-  if (buffer.length < bodyOffset + dataLen)
-    return { length: 0, message };
-  const jsonPayload =
-    buffer.slice(bodyOffset, bodyOffset + dataLen).toString('utf8');
+  if (buffer.length < bodyOffset + dataLen) return { length: 0, message };
+  const jsonPayload = buffer
+    .slice(bodyOffset, bodyOffset + dataLen)
+    .toString('utf8');
   try {
     message = JSON.parse(jsonPayload);
   } catch (e) {
     console.error(`JSON.parse() failed for: ${jsonPayload}`);
     throw e;
   }
-  if (DEBUG)
-    console.log('[received]', JSON.stringify(message));
+  if (DEBUG) console.log('[received]', JSON.stringify(message));
   return { length: bodyOffset + dataLen, message };
 }
 
@@ -103,11 +97,11 @@ function formatWSFrame(message) {
   if (bodyLen < 126) {
     byte2 = 0x80 + bodyLen;
   } else if (bodyLen < 65536) {
-    byte2 = 0xFE;
+    byte2 = 0xfe;
     wsHeaderBuf.writeUInt16BE(bodyLen, 2);
     maskOffset = 4;
   } else {
-    byte2 = 0xFF;
+    byte2 = 0xff;
     wsHeaderBuf.writeUInt32BE(bodyLen, 2);
     wsHeaderBuf.writeUInt32BE(0, 6);
     maskOffset = 10;
@@ -116,7 +110,7 @@ function formatWSFrame(message) {
   wsHeaderBuf.writeUInt32BE(0x01020408, maskOffset);
 
   for (let i = 0; i < messageBuf.length; i++)
-    messageBuf[i] = messageBuf[i] ^ (1 << (i % 4));
+    messageBuf[i] = messageBuf[i] ^ (1 << i % 4);
 
   return Buffer.concat([wsHeaderBuf.slice(0, maskOffset + 4), messageBuf]);
 }
@@ -136,15 +130,13 @@ class InspectorSession {
       buffer = Buffer.concat([buffer, data]);
       do {
         const { length, message, closed } = parseWSFrame(buffer);
-        if (!length)
-          break;
+        if (!length) break;
 
         if (closed) {
-          socket.write(Buffer.from([0x88, 0x00]));  // WS close frame
+          socket.write(Buffer.from([0x88, 0x00])); // WS close frame
         }
         buffer = buffer.slice(length);
-        if (message)
-          this._onMessage(message);
+        if (message) this._onMessage(message);
       } while (true);
     });
     this._terminationPromise = new Promise((resolve) => {
@@ -165,16 +157,15 @@ class InspectorSession {
     if (message.id) {
       const { resolve, reject } = this._commandResponsePromises.get(message.id);
       this._commandResponsePromises.delete(message.id);
-      if (message.result)
-        resolve(message.result);
-      else
-        reject(message.error);
+      if (message.result) resolve(message.result);
+      else reject(message.error);
     } else {
       if (message.method === 'Debugger.scriptParsed') {
         const { scriptId, url } = message.params;
         this._scriptsIdsByUrl.set(scriptId, url);
-        const fileUrl = url.startsWith('file:') ?
-          url : pathToFileURL(url).toString();
+        const fileUrl = url.startsWith('file:')
+          ? url
+          : pathToFileURL(url).toString();
         if (fileUrl === this.scriptURL().toString()) {
           this.mainScriptId = scriptId;
         }
@@ -194,25 +185,24 @@ class InspectorSession {
   _sendMessage(message) {
     const msg = JSON.parse(JSON.stringify(message)); // Clone!
     msg.id = this._nextId++;
-    if (DEBUG)
-      console.log('[sent]', JSON.stringify(msg));
+    if (DEBUG) console.log('[sent]', JSON.stringify(msg));
 
     const responsePromise = new Promise((resolve, reject) => {
       this._commandResponsePromises.set(msg.id, { resolve, reject });
     });
 
-    return new Promise(
-      (resolve) => this._socket.write(formatWSFrame(msg), resolve))
-      .then(() => responsePromise);
+    return new Promise((resolve) =>
+      this._socket.write(formatWSFrame(msg), resolve)
+    ).then(() => responsePromise);
   }
 
   send(commands) {
     if (Array.isArray(commands)) {
       // Multiple commands means the response does not matter. There might even
       // never be a response.
-      return Promise
-        .all(commands.map((command) => this._sendMessage(command)))
-        .then(() => {});
+      return Promise.all(
+        commands.map((command) => this._sendMessage(command))
+      ).then(() => {});
     } else {
       return this._sendMessage(commands);
     }
@@ -222,7 +212,10 @@ class InspectorSession {
     const desc = description || methodOrPredicate;
     const message = `Timed out waiting for matching notification (${desc}))`;
     return fires(
-      this._asyncWaitForNotification(methodOrPredicate), message, TIMEOUT);
+      this._asyncWaitForNotification(methodOrPredicate),
+      message,
+      TIMEOUT
+    );
   }
 
   async _asyncWaitForNotification(methodOrPredicate) {
@@ -230,14 +223,15 @@ class InspectorSession {
       return notification.method === methodOrPredicate;
     }
     const predicate =
-        typeof methodOrPredicate === 'string' ? matchMethod : methodOrPredicate;
+      typeof methodOrPredicate === 'string' ? matchMethod : methodOrPredicate;
     let notification = null;
     do {
       if (this._unprocessedNotifications.length) {
         notification = this._unprocessedNotifications.shift();
       } else {
         notification = await new Promise(
-          (resolve) => this._notificationCallback = resolve);
+          (resolve) => (this._notificationCallback = resolve)
+        );
       }
     } while (!predicate(notification));
     return notification;
@@ -248,32 +242,32 @@ class InspectorSession {
       const callFrame = message.params.callFrames[0];
       const location = callFrame.location;
       const scriptPath = this._scriptsIdsByUrl.get(location.scriptId);
-      assert.strictEqual(scriptPath.toString(),
-                         expectedScriptPath.toString(),
-                         `${scriptPath} !== ${expectedScriptPath}`);
+      assert.strictEqual(
+        scriptPath.toString(),
+        expectedScriptPath.toString(),
+        `${scriptPath} !== ${expectedScriptPath}`
+      );
       assert.strictEqual(location.lineNumber, line);
       return true;
     }
   }
 
   waitForBreakOnLine(line, url) {
-    return this
-      .waitForNotification(
-        (notification) =>
-          this._isBreakOnLineNotification(notification, line, url),
-        `break on ${url}:${line}`);
+    return this.waitForNotification(
+      (notification) =>
+        this._isBreakOnLineNotification(notification, line, url),
+      `break on ${url}:${line}`
+    );
   }
 
   _matchesConsoleOutputNotification(notification, type, values) {
-    if (!Array.isArray(values))
-      values = [ values ];
+    if (!Array.isArray(values)) values = [values];
     if (notification.method === 'Runtime.consoleAPICalled') {
       const params = notification.params;
       if (params.type === type) {
         let i = 0;
         for (const value of params.args) {
-          if (value.value !== values[i++])
-            return false;
+          if (value.value !== values[i++]) return false;
         }
         return i === values.length;
       }
@@ -283,20 +277,25 @@ class InspectorSession {
   waitForConsoleOutput(type, values) {
     const desc = `Console output matching ${JSON.stringify(values)}`;
     return this.waitForNotification(
-      (notification) => this._matchesConsoleOutputNotification(notification,
-                                                               type, values),
-      desc);
+      (notification) =>
+        this._matchesConsoleOutputNotification(notification, type, values),
+      desc
+    );
   }
 
   async runToCompletion() {
     console.log('[test]', 'Verify node waits for the frontend to disconnect');
-    await this.send({ 'method': 'Debugger.resume' });
+    await this.send({ method: 'Debugger.resume' });
     await this.waitForNotification((notification) => {
-      return notification.method === 'Runtime.executionContextDestroyed' &&
-        notification.params.executionContextId === 1;
+      return (
+        notification.method === 'Runtime.executionContextDestroyed' &&
+        notification.params.executionContextId === 1
+      );
     });
-    while ((await this._instance.nextStderrString()) !==
-              'Waiting for the debugger to disconnect...');
+    while (
+      (await this._instance.nextStderrString()) !==
+      'Waiting for the debugger to disconnect...'
+    );
     await this.disconnect();
   }
 
@@ -314,29 +313,38 @@ class InspectorSession {
 }
 
 class NodeInstance extends EventEmitter {
-  constructor(inspectorFlags = ['--inspect-brk=0'],
-              scriptContents = '',
-              scriptFile = _MAINSCRIPT) {
+  constructor(
+    inspectorFlags = ['--inspect-brk=0'],
+    scriptContents = '',
+    scriptFile = _MAINSCRIPT
+  ) {
     super();
 
     this._scriptPath = scriptFile;
     this._script = scriptFile ? null : scriptContents;
     this._portCallback = null;
-    this.portPromise = new Promise((resolve) => this._portCallback = resolve);
-    this._process = spawnChildProcess(inspectorFlags, scriptContents,
-                                      scriptFile);
+    this.portPromise = new Promise((resolve) => (this._portCallback = resolve));
+    this._process = spawnChildProcess(
+      inspectorFlags,
+      scriptContents,
+      scriptFile
+    );
     this._running = true;
     this._stderrLineCallback = null;
     this._unprocessedStderrLines = [];
 
-    this._process.stdout.on('data', makeBufferingDataCallback(
-      (line) => {
+    this._process.stdout.on(
+      'data',
+      makeBufferingDataCallback((line) => {
         this.emit('stdout', line);
         console.log('[out]', line);
-      }));
+      })
+    );
 
-    this._process.stderr.on('data', makeBufferingDataCallback(
-      (message) => this.onStderrLine(message)));
+    this._process.stderr.on(
+      'data',
+      makeBufferingDataCallback((message) => this.onStderrLine(message))
+    );
 
     this._shutdownPromise = new Promise((resolve) => {
       this._process.once('exit', (exitCode, signal) => {
@@ -348,10 +356,14 @@ class NodeInstance extends EventEmitter {
 
   static async startViaSignal(scriptContents) {
     const instance = new NodeInstance(
-      [], `${scriptContents}\nprocess._rawDebug('started');`, undefined);
+      [],
+      `${scriptContents}\nprocess._rawDebug('started');`,
+      undefined
+    );
     const msg = 'Timed out waiting for process to start';
-    while (await fires(instance.nextStderrString(), msg, TIMEOUT) !==
-             'started') {}
+    while (
+      (await fires(instance.nextStderrString(), msg, TIMEOUT)) !== 'started'
+    ) {}
     process._debugProcess(instance._process.pid);
     return instance;
   }
@@ -375,26 +387,31 @@ class NodeInstance extends EventEmitter {
 
   httpGet(host, path, hostHeaderValue) {
     console.log('[test]', `Testing ${path}`);
-    const headers = hostHeaderValue ? { 'Host': hostHeaderValue } : null;
-    return this.portPromise.then((port) => new Promise((resolve, reject) => {
-      const req = http.get({ host, port, path, headers }, (res) => {
-        let response = '';
-        res.setEncoding('utf8');
-        res
-          .on('data', (data) => response += data.toString())
-          .on('end', () => {
-            resolve(response);
-          });
+    const headers = hostHeaderValue ? { Host: hostHeaderValue } : null;
+    return this.portPromise
+      .then(
+        (port) =>
+          new Promise((resolve, reject) => {
+            const req = http.get({ host, port, path, headers }, (res) => {
+              let response = '';
+              res.setEncoding('utf8');
+              res
+                .on('data', (data) => (response += data.toString()))
+                .on('end', () => {
+                  resolve(response);
+                });
+            });
+            req.on('error', reject);
+          })
+      )
+      .then((response) => {
+        try {
+          return JSON.parse(response);
+        } catch (e) {
+          e.body = response;
+          throw e;
+        }
       });
-      req.on('error', reject);
-    })).then((response) => {
-      try {
-        return JSON.parse(response);
-      } catch (e) {
-        e.body = response;
-        throw e;
-      }
-    });
   }
 
   async sendUpgradeRequest() {
@@ -405,8 +422,8 @@ class NodeInstance extends EventEmitter {
       port,
       path: parseURL(devtoolsUrl).path,
       headers: {
-        'Connection': 'Upgrade',
-        'Upgrade': 'websocket',
+        Connection: 'Upgrade',
+        Upgrade: 'websocket',
         'Sec-WebSocket-Version': 13,
         'Sec-WebSocket-Key': 'key=='
       }
@@ -418,8 +435,9 @@ class NodeInstance extends EventEmitter {
     const upgradeRequest = await this.sendUpgradeRequest();
     return new Promise((resolve, reject) => {
       upgradeRequest
-        .on('upgrade',
-            (message, socket) => resolve(new InspectorSession(socket, this)))
+        .on('upgrade', (message, socket) =>
+          resolve(new InspectorSession(socket, this))
+        )
         .on('response', common.mustNotCall('Upgrade was not received'));
     });
   }
@@ -429,10 +447,12 @@ class NodeInstance extends EventEmitter {
     const upgradeRequest = await this.sendUpgradeRequest();
     return new Promise((resolve, reject) => {
       upgradeRequest
-          .on('upgrade', common.mustNotCall('Upgrade was received'))
-          .on('response', (response) =>
-            response.on('data', () => {})
-                    .on('end', () => resolve(response.statusCode)));
+        .on('upgrade', common.mustNotCall('Upgrade was received'))
+        .on('response', (response) =>
+          response
+            .on('data', () => {})
+            .on('end', () => resolve(response.statusCode))
+        );
     });
   }
 
@@ -443,7 +463,7 @@ class NodeInstance extends EventEmitter {
   nextStderrString() {
     if (this._unprocessedStderrLines.length)
       return Promise.resolve(this._unprocessedStderrLines.shift());
-    return new Promise((resolve) => this._stderrLineCallback = resolve);
+    return new Promise((resolve) => (this._stderrLineCallback = resolve));
   }
 
   write(message) {
@@ -467,27 +487,32 @@ class NodeInstance extends EventEmitter {
 }
 
 function onResolvedOrRejected(promise, callback) {
-  return promise.then((result) => {
-    callback();
-    return result;
-  }, (error) => {
-    callback();
-    throw error;
-  });
+  return promise.then(
+    (result) => {
+      callback();
+      return result;
+    },
+    (error) => {
+      callback();
+      throw error;
+    }
+  );
 }
 
 function timeoutPromise(error, timeoutMs) {
   let clearCallback = null;
   let done = false;
-  const promise = onResolvedOrRejected(new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => reject(error), timeoutMs);
-    clearCallback = () => {
-      if (done)
-        return;
-      clearTimeout(timeout);
-      resolve();
-    };
-  }), () => done = true);
+  const promise = onResolvedOrRejected(
+    new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(error), timeoutMs);
+      clearCallback = () => {
+        if (done) return;
+        clearTimeout(timeout);
+        resolve();
+      };
+    }),
+    () => (done = true)
+  );
   promise.clear = clearCallback;
   return promise;
 }
diff --git a/test/common/ongc.js b/test/common/ongc.js
index d8e27beb8f0a13..461634f8b64bcd 100644
--- a/test/common/ongc.js
+++ b/test/common/ongc.js
@@ -8,21 +8,23 @@ const gcTrackerTag = 'NODE_TEST_COMMON_GC_TRACKER';
 function onGC(obj, gcListener) {
   const async_hooks = require('async_hooks');
 
-  const onGcAsyncHook = async_hooks.createHook({
-    init: common.mustCallAtLeast(function(id, type) {
-      if (this.trackedId === undefined) {
-        assert.strictEqual(type, gcTrackerTag);
-        this.trackedId = id;
+  const onGcAsyncHook = 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();
+        }
       }
-    }),
-    destroy(id) {
-      assert.notStrictEqual(this.trackedId, -1);
-      if (id === this.trackedId) {
-        this.gcListener.ongc();
-        onGcAsyncHook.disable();
-      }
-    }
-  }).enable();
+    })
+    .enable();
   onGcAsyncHook.gcListener = gcListener;
 
   gcTrackerMap.set(obj, new async_hooks.AsyncResource(gcTrackerTag));
diff --git a/test/common/tls.js b/test/common/tls.js
index 3560af671bce25..a95c2a2c06dd07 100644
--- a/test/common/tls.js
+++ b/test/common/tls.js
@@ -14,8 +14,10 @@ class TestTLSSocket extends net.Socket {
     this.handshake_list = [];
     // AES128-GCM-SHA256
     this.ciphers = Buffer.from('000002009c0', 'hex');
-    this.pre_master_secret =
-      Buffer.concat([this.version, crypto.randomBytes(46)]);
+    this.pre_master_secret = Buffer.concat([
+      this.version,
+      crypto.randomBytes(46)
+    ]);
     this.master_secret = null;
     this.write_seq = 0;
     this.client_random = crypto.randomBytes(32);
@@ -25,16 +27,20 @@ class TestTLSSocket extends net.Socket {
     });
 
     this.on('server_random', (server_random) => {
-      this.master_secret = PRF12('sha256', this.pre_master_secret,
-                                 'master secret',
-                                 Buffer.concat([this.client_random,
-                                                server_random]),
-                                 48);
-      const key_block = PRF12('sha256', this.master_secret,
-                              'key expansion',
-                              Buffer.concat([server_random,
-                                             this.client_random]),
-                              40);
+      this.master_secret = PRF12(
+        'sha256',
+        this.pre_master_secret,
+        'master secret',
+        Buffer.concat([this.client_random, server_random]),
+        48
+      );
+      const key_block = PRF12(
+        'sha256',
+        this.master_secret,
+        'key expansion',
+        Buffer.concat([server_random, this.client_random]),
+        40
+      );
       this.client_writeKey = key_block.slice(0, 16);
       this.client_writeIV = key_block.slice(32, 36);
     });
@@ -42,22 +48,33 @@ class TestTLSSocket extends net.Socket {
 
   createClientHello() {
     const compressions = Buffer.from('0100', 'hex'); // null
-    const msg = addHandshakeHeader(0x01, Buffer.concat([
-      this.version, this.client_random, this.ciphers, compressions
-    ]));
+    const msg = addHandshakeHeader(
+      0x01,
+      Buffer.concat([
+        this.version,
+        this.client_random,
+        this.ciphers,
+        compressions
+      ])
+    );
     this.emit('handshake', msg);
     return addRecordHeader(0x16, msg);
   }
 
   createClientKeyExchange() {
-    const encrypted_pre_master_secret = crypto.publicEncrypt({
-      key: this.server_cert,
-      padding: crypto.constants.RSA_PKCS1_PADDING
-    }, this.pre_master_secret);
+    const encrypted_pre_master_secret = crypto.publicEncrypt(
+      {
+        key: this.server_cert,
+        padding: crypto.constants.RSA_PKCS1_PADDING
+      },
+      this.pre_master_secret
+    );
     const length = Buffer.alloc(2);
     length.writeUIntBE(encrypted_pre_master_secret.length, 0, 2);
-    const msg = addHandshakeHeader(0x10, Buffer.concat([
-      length, encrypted_pre_master_secret]));
+    const msg = addHandshakeHeader(
+      0x10,
+      Buffer.concat([length, encrypted_pre_master_secret])
+    );
     this.emit('handshake', msg);
     return addRecordHeader(0x16, msg);
   }
@@ -66,8 +83,13 @@ class TestTLSSocket extends net.Socket {
     const shasum = crypto.createHash('sha256');
     shasum.update(Buffer.concat(this.handshake_list));
     const message_hash = shasum.digest();
-    const r = PRF12('sha256', this.master_secret,
-                    'client finished', message_hash, 12);
+    const r = PRF12(
+      'sha256',
+      this.master_secret,
+      'client finished',
+      message_hash,
+      12
+    );
     const msg = addHandshakeHeader(0x14, r);
     this.emit('handshake', msg);
     return addRecordHeader(0x16, msg);
diff --git a/test/common/tmpdir.js b/test/common/tmpdir.js
index ca761b7f94a642..76090d3025f1ff 100644
--- a/test/common/tmpdir.js
+++ b/test/common/tmpdir.js
@@ -9,22 +9,16 @@ function rimrafSync(p) {
   try {
     st = fs.lstatSync(p);
   } catch (e) {
-    if (e.code === 'ENOENT')
-      return;
+    if (e.code === 'ENOENT') return;
   }
 
   try {
-    if (st && st.isDirectory())
-      rmdirSync(p, null);
-    else
-      fs.unlinkSync(p);
+    if (st && st.isDirectory()) rmdirSync(p, null);
+    else fs.unlinkSync(p);
   } catch (e) {
-    if (e.code === 'ENOENT')
-      return;
-    if (e.code === 'EPERM')
-      return rmdirSync(p, e);
-    if (e.code !== 'EISDIR')
-      throw e;
+    if (e.code === 'ENOENT') return;
+    if (e.code === 'EPERM') return rmdirSync(p, e);
+    if (e.code !== 'EISDIR') throw e;
     rmdirSync(p, e);
   }
 }
@@ -33,8 +27,7 @@ function rmdirSync(p, originalEr) {
   try {
     fs.rmdirSync(p);
   } catch (e) {
-    if (e.code === 'ENOTDIR')
-      throw originalEr;
+    if (e.code === 'ENOTDIR') throw originalEr;
     if (e.code === 'ENOTEMPTY' || e.code === 'EEXIST' || e.code === 'EPERM') {
       const enc = process.platform === 'linux' ? 'buffer' : 'utf8';
       fs.readdirSync(p, enc).forEach((f) => {
@@ -50,8 +43,9 @@ function rmdirSync(p, originalEr) {
   }
 }
 
-const testRoot = process.env.NODE_TEST_DIR ?
-  fs.realpathSync(process.env.NODE_TEST_DIR) : path.resolve(__dirname, '..');
+const testRoot = process.env.NODE_TEST_DIR
+  ? fs.realpathSync(process.env.NODE_TEST_DIR)
+  : path.resolve(__dirname, '..');
 
 // Using a `.` prefixed name, which is the convention for "hidden" on POSIX,
 // gets tools to ignore it by default or by simple rules, especially eslint.
diff --git a/test/common/wpt.js b/test/common/wpt.js
index 59dbe26d2abdcb..ec90cf6268c05d 100644
--- a/test/common/wpt.js
+++ b/test/common/wpt.js
@@ -25,11 +25,17 @@ const harnessMock = {
   assert_true: (value, message) => assert.strictEqual(value, true, message),
   assert_false: (value, message) => assert.strictEqual(value, false, message),
   assert_throws: (code, func, desc) => {
-    assert.throws(func, function(err) {
-      return typeof err === 'object' &&
-             'name' in err &&
-             err.name.startsWith(code.name);
-    }, desc);
+    assert.throws(
+      func,
+      function(err) {
+        return (
+          typeof err === 'object' &&
+          'name' in err &&
+          err.name.startsWith(code.name)
+        );
+      },
+      desc
+    );
   },
   assert_array_equals: assert.deepStrictEqual,
   assert_unreached(desc) {
@@ -48,18 +54,21 @@ class ResourceLoader {
       '/resources/WebIDLParser.js',
       '/resources/webidl2/lib/webidl2.js'
     );
-    const file = url.startsWith('/') ?
-      fixtures.path('wpt', url) :
-      fixtures.path('wpt', this.path, url);
+    const file = url.startsWith('/')
+      ? fixtures.path('wpt', url)
+      : fixtures.path('wpt', this.path, url);
     if (asPromise) {
-      return fsPromises.readFile(file)
-        .then((data) => {
-          return {
-            ok: true,
-            json() { return JSON.parse(data.toString()); },
-            text() { return data.toString(); }
-          };
-        });
+      return fsPromises.readFile(file).then((data) => {
+        return {
+          ok: true,
+          json() {
+            return JSON.parse(data.toString());
+          },
+          text() {
+            return data.toString();
+          }
+        };
+      });
     } else {
       return fs.readFileSync(file, 'utf8');
     }
@@ -76,7 +85,7 @@ class WPTTest {
    */
   constructor(mod, filename, requires, failReason, skipReason) {
     this.module = mod; // name of the WPT module, e.g. 'url'
-    this.filename = filename;  // name of the test file
+    this.filename = filename; // name of the test file
     this.requires = requires;
     this.failReason = failReason;
     this.skipReason = skipReason;
@@ -117,8 +126,7 @@ class StatusLoader {
       failReason = this.status[file].fail;
       skipReason = this.status[file].skip;
     }
-    return new WPTTest(this.path, file, requires,
-                       failReason, skipReason);
+    return new WPTTest(this.path, file, requires, failReason, skipReason);
   }
 
   load() {
@@ -212,7 +220,7 @@ class WPTRunner {
     for (const test of queue) {
       const filename = test.filename;
       const content = test.getContent();
-      const meta = test.title = this.getMeta(content);
+      const meta = (test.title = this.getMeta(content));
 
       const absolutePath = test.getAbsolutePath();
       const context = this.generateContext(test.filename);
@@ -222,11 +230,15 @@ class WPTRunner {
           filename: absolutePath
         });
       } catch (err) {
-        this.fail(filename, {
-          name: '',
-          message: err.message,
-          stack: err.stack
-        }, 'UNCAUGHT');
+        this.fail(
+          filename,
+          {
+            name: '',
+            message: err.message,
+            stack: err.stack
+          },
+          'UNCAUGHT'
+        );
         this.inProgress.delete(filename);
       }
     }
@@ -244,7 +256,9 @@ class WPTRunner {
       },
       location: {},
       GLOBAL: {
-        isWindow() { return false; }
+        isWindow() {
+          return false;
+        }
       },
       Object
     };
@@ -262,8 +276,8 @@ class WPTRunner {
   }
 
   generateContext(filename) {
-    const sandbox = this.sandbox = this.getSandbox();
-    const context = this.context = vm.createContext(sandbox);
+    const sandbox = (this.sandbox = this.getSandbox());
+    const context = (this.context = vm.createContext(sandbox));
 
     const harnessPath = fixtures.path('wpt', 'resources', 'testharness.js');
     const harness = fs.readFileSync(harnessPath, 'utf8');
@@ -271,16 +285,14 @@ class WPTRunner {
       filename: harnessPath
     });
 
-    sandbox.add_result_callback(
-      this.resultCallback.bind(this, filename)
-    );
+    sandbox.add_result_callback(this.resultCallback.bind(this, filename));
     sandbox.add_completion_callback(
       this.completionCallback.bind(this, filename)
     );
     sandbox.self = sandbox;
     // TODO(joyeecheung): we are not a window - work with the upstream to
     // add a new scope for us.
-    sandbox.document = {};  // Pretend we are Window
+    sandbox.document = {}; // Pretend we are Window
     return context;
   }
 
@@ -352,8 +364,9 @@ class WPTRunner {
         console.log(`[${item.reason}] ${item.test.name}`);
         console.log(item.test.message);
         console.log(item.test.stack);
-        const command = `${process.execPath} ${process.execArgv}` +
-                        ` ${require.main.filename} ${filename}`;
+        const command =
+          `${process.execPath} ${process.execArgv}` +
+          ` ${require.main.filename} ${filename}`;
         console.log(`Command: ${command}\n`);
       }
       assert.fail(`${unexpectedFailures.length} unexpected failures found`);
diff --git a/test/doctool/test-apilinks.js b/test/doctool/test-apilinks.js
index e53c81a08a7203..a5980e3bff5b15 100644
--- a/test/doctool/test-apilinks.js
+++ b/test/doctool/test-apilinks.js
@@ -16,24 +16,25 @@ fs.readdirSync(apilinks).forEach((fixture) => {
 
   const expectedContent = fs.readFileSync(file + 'on', 'utf8');
 
-  const output = execFileSync(
-    process.execPath,
-    [script, file],
-    { encoding: 'utf-8' }
-  );
+  const output = execFileSync(process.execPath, [script, file], {
+    encoding: 'utf-8'
+  });
 
   const expectedLinks = JSON.parse(expectedContent);
   const actualLinks = JSON.parse(output);
 
   for (const [k, v] of Object.entries(expectedLinks)) {
     assert.ok(k in actualLinks, `link not found: ${k}`);
-    assert.ok(actualLinks[k].endsWith('/' + v),
-              `link ${actualLinks[k]} expected to end with ${v}`);
+    assert.ok(
+      actualLinks[k].endsWith('/' + v),
+      `link ${actualLinks[k]} expected to end with ${v}`
+    );
     delete actualLinks[k];
   }
 
   assert.strictEqual(
-    Object.keys(actualLinks).length, 0,
+    Object.keys(actualLinks).length,
+    0,
     `unexpected links returned ${JSON.stringify(actualLinks)}`
   );
 });
diff --git a/test/doctool/test-doctool-html.js b/test/doctool/test-doctool-html.js
index 499034cd8a3684..a50ae87e409fb3 100644
--- a/test/doctool/test-doctool-html.js
+++ b/test/doctool/test-doctool-html.js
@@ -15,7 +15,8 @@ const html = require('../../tools/doc/html.js');
 const path = require('path');
 
 module.paths.unshift(
-  path.join(__dirname, '..', '..', 'tools', 'doc', 'node_modules'));
+  path.join(__dirname, '..', '..', 'tools', 'doc', 'node_modules')
+);
 const unified = require('unified');
 const markdown = require('remark-parse');
 const remark2rehype = require('remark-rehype');
@@ -34,10 +35,7 @@ function toHTML({ input, filename, nodeVersion }, cb) {
     .use(htmlStringify)
     .processSync(input);
 
-  html.toHTML(
-    { input, content, filename, nodeVersion },
-    cb
-  );
+  html.toHTML({ input, content, filename, nodeVersion }, cb);
 }
 
 // Test data is a list of objects with two properties.
@@ -48,12 +46,14 @@ function toHTML({ input, filename, nodeVersion }, cb) {
 const testData = [
   {
     file: fixtures.path('sample_document.md'),
-    html: '<ol><li>fish</li><li>fish</li></ol>' +
+    html:
+      '<ol><li>fish</li><li>fish</li></ol>' +
       '<ul><li>Redfish</li><li>Bluefish</li></ul>'
   },
   {
     file: fixtures.path('order_of_end_tags_5873.md'),
-    html: '<h3>ClassMethod: Buffer.from(array) <span> ' +
+    html:
+      '<h3>ClassMethod: Buffer.from(array) <span> ' +
       '<a class="mark" href="#foo_class_method_buffer_from_array" ' +
       'id="foo_class_method_buffer_from_array">#</a> </span> </h3>' +
       '<ul><li><code>array</code><a ' +
@@ -62,7 +62,8 @@ const testData = [
   },
   {
     file: fixtures.path('doc_with_yaml.md'),
-    html: '<h1>Sample Markdown with YAML info' +
+    html:
+      '<h1>Sample Markdown with YAML info' +
       '<span><a class="mark" href="#foo_sample_markdown_with_yaml_info" ' +
       ' id="foo_sample_markdown_with_yaml_info">#</a></span></h1>' +
       '<h2>Foobar<span><a class="mark" href="#foo_foobar" ' +
@@ -92,9 +93,10 @@ const testData = [
   },
   {
     file: fixtures.path('sample_document.md'),
-    html: '<ol><li>fish</li><li>fish</li></ol>' +
-      '<ul><li>Red fish</li><li>Blue fish</li></ul>',
-  },
+    html:
+      '<ol><li>fish</li><li>fish</li></ol>' +
+      '<ul><li>Red fish</li><li>Blue fish</li></ul>'
+  }
 ];
 
 const spaces = /\s/g;
@@ -103,22 +105,26 @@ testData.forEach(({ file, html }) => {
   // Normalize expected data by stripping whitespace.
   const expected = html.replace(spaces, '');
 
-  readFile(file, 'utf8', common.mustCall((err, input) => {
-    assert.ifError(err);
-    toHTML(
-      {
-        input: input,
-        filename: 'foo',
-        nodeVersion: process.version,
-      },
-      common.mustCall((err, output) => {
-        assert.ifError(err);
+  readFile(
+    file,
+    'utf8',
+    common.mustCall((err, input) => {
+      assert.ifError(err);
+      toHTML(
+        {
+          input: input,
+          filename: 'foo',
+          nodeVersion: process.version
+        },
+        common.mustCall((err, output) => {
+          assert.ifError(err);
 
-        const actual = output.replace(spaces, '');
-        // Assert that the input stripped of all whitespace contains the
-        // expected markup.
-        assert(actual.includes(expected));
-      })
-    );
-  }));
+          const actual = output.replace(spaces, '');
+          // Assert that the input stripped of all whitespace contains the
+          // expected markup.
+          assert(actual.includes(expected));
+        })
+      );
+    })
+  );
 });
diff --git a/test/doctool/test-doctool-json.js b/test/doctool/test-doctool-json.js
index 7471a2e1f0693d..f19c23032e637e 100644
--- a/test/doctool/test-doctool-json.js
+++ b/test/doctool/test-doctool-json.js
@@ -15,7 +15,8 @@ const fixtures = require('../common/fixtures');
 const json = require('../../tools/doc/json.js');
 
 module.paths.unshift(
-  path.join(__dirname, '..', '..', 'tools', 'doc', 'node_modules'));
+  path.join(__dirname, '..', '..', 'tools', 'doc', 'node_modules')
+);
 const unified = require('unified');
 const markdown = require('remark-parse');
 
@@ -41,20 +42,25 @@ const testData = [
     json: {
       type: 'module',
       source: 'foo',
-      modules: [{
-        textRaw: 'Sample Markdown',
-        name: 'sample_markdown',
-        modules: [{
-          textRaw: 'Seussian Rhymes',
-          name: 'seussian_rhymes',
-          desc: '<ol>\n<li>fish</li>\n<li>fish</li>\n</ol>\n' +
-                  '<ul>\n<li>Red fish</li>\n<li>Blue fish</li>\n</ul>',
+      modules: [
+        {
+          textRaw: 'Sample Markdown',
+          name: 'sample_markdown',
+          modules: [
+            {
+              textRaw: 'Seussian Rhymes',
+              name: 'seussian_rhymes',
+              desc:
+                '<ol>\n<li>fish</li>\n<li>fish</li>\n</ol>\n' +
+                '<ul>\n<li>Red fish</li>\n<li>Blue fish</li>\n</ul>',
+              type: 'module',
+              displayName: 'Seussian Rhymes'
+            }
+          ],
           type: 'module',
-          displayName: 'Seussian Rhymes'
-        }],
-        type: 'module',
-        displayName: 'Sample Markdown'
-      }]
+          displayName: 'Sample Markdown'
+        }
+      ]
     }
   },
   {
@@ -62,32 +68,40 @@ const testData = [
     json: {
       type: 'module',
       source: 'foo',
-      modules: [{
-        textRaw: 'Title',
-        name: 'title',
-        modules: [{
-          textRaw: 'Subsection',
-          name: 'subsection',
-          classMethods: [{
-            textRaw: 'Class Method: Buffer.from(array)',
-            type: 'classMethod',
-            name: 'from',
-            signatures: [
-              {
-                params: [{
-                  textRaw: '`array` {Array}',
-                  name: 'array',
-                  type: 'Array'
-                }]
-              }
-            ]
-          }],
+      modules: [
+        {
+          textRaw: 'Title',
+          name: 'title',
+          modules: [
+            {
+              textRaw: 'Subsection',
+              name: 'subsection',
+              classMethods: [
+                {
+                  textRaw: 'Class Method: Buffer.from(array)',
+                  type: 'classMethod',
+                  name: 'from',
+                  signatures: [
+                    {
+                      params: [
+                        {
+                          textRaw: '`array` {Array}',
+                          name: 'array',
+                          type: 'Array'
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ],
+              type: 'module',
+              displayName: 'Subsection'
+            }
+          ],
           type: 'module',
-          displayName: 'Subsection'
-        }],
-        type: 'module',
-        displayName: 'Title'
-      }]
+          displayName: 'Title'
+        }
+      ]
     }
   },
   {
@@ -107,8 +121,8 @@ const testData = [
                 added: ['v1.0.0'],
                 changes: []
               },
-              desc: '<p>Describe <code>Foobar</code> in more detail ' +
-                'here.</p>',
+              desc:
+                '<p>Describe <code>Foobar</code> in more detail ' + 'here.</p>',
               type: 'module',
               displayName: 'Foobar'
             },
@@ -118,14 +132,16 @@ const testData = [
               meta: {
                 added: ['v5.3.0', 'v4.2.0'],
                 changes: [
-                  { 'version': 'v4.2.0',
+                  {
+                    version: 'v4.2.0',
                     'pr-url': 'https://github.com/nodejs/node/pull/3276',
-                    'description': 'The `error` parameter can now be ' +
-                      'an arrow function.'
+                    description:
+                      'The `error` parameter can now be ' + 'an arrow function.'
                   }
                 ]
               },
-              desc: '<p>Describe <code>Foobar II</code> in more detail ' +
+              desc:
+                '<p>Describe <code>Foobar II</code> in more detail ' +
                 'here. fg(1)</p>',
               type: 'module',
               displayName: 'Foobar II'
@@ -138,7 +154,8 @@ const testData = [
                 deprecated: ['v2.0.0'],
                 changes: []
               },
-              desc: '<p>Describe <code>Deprecated thingy</code> in more ' +
+              desc:
+                '<p>Describe <code>Deprecated thingy</code> in more ' +
                 'detail here. fg(1p)</p>',
               type: 'module',
               displayName: 'Deprecated thingy'
@@ -146,7 +163,8 @@ const testData = [
             {
               textRaw: 'Something',
               name: 'something',
-              desc: '<!-- This is not a metadata comment -->\n<p>' +
+              desc:
+                '<!-- This is not a metadata comment -->\n<p>' +
                 'Describe <code>Something</code> in more detail here.</p>',
               type: 'module',
               displayName: 'Something'
@@ -161,11 +179,19 @@ const testData = [
 ];
 
 testData.forEach((item) => {
-  fs.readFile(item.file, 'utf8', common.mustCall((err, input) => {
-    assert.ifError(err);
-    toJSON(input, 'foo', common.mustCall((err, output) => {
+  fs.readFile(
+    item.file,
+    'utf8',
+    common.mustCall((err, input) => {
       assert.ifError(err);
-      assert.deepStrictEqual(output.json, item.json);
-    }));
-  }));
+      toJSON(
+        input,
+        'foo',
+        common.mustCall((err, output) => {
+          assert.ifError(err);
+          assert.deepStrictEqual(output.json, item.json);
+        })
+      );
+    })
+  );
 });
diff --git a/test/doctool/test-make-doc.js b/test/doctool/test-make-doc.js
index 7f4f3ae6fbfdfa..248a8a8b4c28fc 100644
--- a/test/doctool/test-make-doc.js
+++ b/test/doctool/test-make-doc.js
@@ -17,12 +17,10 @@ const allMD = fs.readdirSync(mdPath);
 const allDocs = fs.readdirSync(apiPath);
 assert.ok(allDocs.includes('index.html'));
 
-const actualDocs = allDocs.filter(
-  (name) => {
-    const extension = path.extname(name);
-    return extension === '.html' || extension === '.json';
-  }
-);
+const actualDocs = allDocs.filter((name) => {
+  const extension = path.extname(name);
+  return extension === '.html' || extension === '.json';
+});
 
 for (const name of actualDocs) {
   if (name.startsWith('all.')) continue;
@@ -41,8 +39,7 @@ assert.notStrictEqual(links, null);
 
 // Filter out duplicate links, leave just filenames, add expected JSON files.
 const linkedHtmls = [...new Set(links)].map((link) => link.match(re)[1]);
-const expectedJsons = linkedHtmls
-                       .map((name) => name.replace('.html', '.json'));
+const expectedJsons = linkedHtmls.map((name) => name.replace('.html', '.json'));
 const expectedDocs = linkedHtmls.concat(expectedJsons);
 
 // Test that all the relative links in the TOC match to the actual documents.
@@ -54,7 +51,9 @@ for (const expectedDoc of expectedDocs) {
 // and that they are not empty files.
 for (const actualDoc of actualDocs) {
   assert.ok(
-    expectedDocs.includes(actualDoc), `${actualDoc} does not match TOC`);
+    expectedDocs.includes(actualDoc),
+    `${actualDoc} does not match TOC`
+  );
 
   assert.ok(
     fs.statSync(path.join(apiPath, actualDoc)).size !== 0,
diff --git a/test/es-module/test-esm-cjs-main.js b/test/es-module/test-esm-cjs-main.js
index 8de923d37b1887..06c3b8aab3c921 100644
--- a/test/es-module/test-esm-cjs-main.js
+++ b/test/es-module/test-esm-cjs-main.js
@@ -21,7 +21,10 @@ child.stdout.on('data', (data) => {
   assert.strictEqual(data.toString(), 'executed\n');
   validatedExecution = true;
 });
-child.on('close', common.mustCall((code, stdout) => {
-  assert.strictEqual(validatedExecution, true);
-  assert.strictEqual(code, 0);
-}));
+child.on(
+  'close',
+  common.mustCall((code, stdout) => {
+    assert.strictEqual(validatedExecution, true);
+    assert.strictEqual(code, 0);
+  })
+);
diff --git a/test/es-module/test-esm-dynamic-import.js b/test/es-module/test-esm-dynamic-import.js
index 6cbbd0ac67dd66..5a0cfed50d98c3 100644
--- a/test/es-module/test-esm-dynamic-import.js
+++ b/test/es-module/test-esm-dynamic-import.js
@@ -11,10 +11,11 @@ const targetURL = new URL('file:///');
 targetURL.pathname = absolutePath;
 
 function expectErrorProperty(result, propertyKey, value) {
-  Promise.resolve(result)
-    .catch(common.mustCall(error => {
+  Promise.resolve(result).catch(
+    common.mustCall((error) => {
       assert.strictEqual(error[propertyKey], value);
-    }));
+    })
+  );
 }
 
 function expectMissingModuleError(result) {
@@ -34,24 +35,29 @@ function expectInvalidProtocolError(result) {
 }
 
 function expectInvalidContextError(result) {
-  expectErrorProperty(result,
-    'message', 'import() called outside of main context');
+  expectErrorProperty(
+    result,
+    'message',
+    'import() called outside of main context'
+  );
 }
 
 function expectOkNamespace(result) {
-  Promise.resolve(result)
-    .then(common.mustCall(ns => {
+  Promise.resolve(result).then(
+    common.mustCall((ns) => {
       // Can't deepStrictEqual because ns isn't a normal object
       assert.deepEqual(ns, { default: true });
-    }));
+    })
+  );
 }
 
 function expectFsNamespace(result) {
-  Promise.resolve(result)
-    .then(common.mustCall(ns => {
+  Promise.resolve(result).then(
+    common.mustCall((ns) => {
       assert.strictEqual(typeof ns.default.writeFile, 'function');
       assert.strictEqual(typeof ns.writeFile, 'function');
-    }));
+    })
+  );
 }
 
 // For direct use of import expressions inside of CJS or ES modules, including
@@ -64,14 +70,14 @@ function expectFsNamespace(result) {
   expectOkNamespace(eval.call(null, `import("${targetURL}")`));
 
   // Importing a built-in, both direct & via eval
-  expectFsNamespace(import("fs"));
+  expectFsNamespace(import('fs'));
   expectFsNamespace(eval('import("fs")'));
   expectFsNamespace(eval.call(null, 'import("fs")'));
 
-  expectMissingModuleError(import("./not-an-existing-module.mjs"));
+  expectMissingModuleError(import('./not-an-existing-module.mjs'));
   // TODO(jkrems): Right now this doesn't hit a protocol error because the
   // module resolution step already rejects it. These arguably should be
   // protocol errors.
-  expectMissingModuleError(import("node:fs"));
+  expectMissingModuleError(import('node:fs'));
   expectMissingModuleError(import('http://example.com/foo.js'));
 })();
diff --git a/test/es-module/test-esm-loader-modulemap.js b/test/es-module/test-esm-loader-modulemap.js
index 946d54ffaaa5aa..56c2312a97641a 100644
--- a/test/es-module/test-esm-loader-modulemap.js
+++ b/test/es-module/test-esm-loader-modulemap.js
@@ -10,49 +10,39 @@ const { URL } = require('url');
 const Loader = require('internal/modules/esm/loader');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
-const createDynamicModule = require(
-  'internal/modules/esm/create_dynamic_module');
+const createDynamicModule = require('internal/modules/esm/create_dynamic_module');
 
 const stubModuleUrl = new URL('file://tmp/test');
 const stubModule = createDynamicModule(['default'], stubModuleUrl);
 const loader = new Loader();
 const moduleMap = new ModuleMap();
-const moduleJob = new ModuleJob(loader, stubModule.module,
-                                () => new Promise(() => {}));
-
-common.expectsError(
-  () => moduleMap.get(1),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "url" argument must be of type string. Received type number'
-  }
+const moduleJob = new ModuleJob(
+  loader,
+  stubModule.module,
+  () => new Promise(() => {})
 );
 
-common.expectsError(
-  () => moduleMap.set(1, moduleJob),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "url" argument must be of type string. Received type number'
-  }
-);
-
-common.expectsError(
-  () => moduleMap.set('somestring', 'notamodulejob'),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "job" argument must be of type ModuleJob. ' +
-             'Received type string'
-  }
-);
-
-common.expectsError(
-  () => moduleMap.has(1),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "url" argument must be of type string. Received type number'
-  }
-);
+common.expectsError(() => moduleMap.get(1), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'The "url" argument must be of type string. Received type number'
+});
+
+common.expectsError(() => moduleMap.set(1, moduleJob), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'The "url" argument must be of type string. Received type number'
+});
+
+common.expectsError(() => moduleMap.set('somestring', 'notamodulejob'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "job" argument must be of type ModuleJob. ' + 'Received type string'
+});
+
+common.expectsError(() => moduleMap.has(1), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'The "url" argument must be of type string. Received type number'
+});
diff --git a/test/es-module/test-esm-loader-search.js b/test/es-module/test-esm-loader-search.js
index 0ca8990cb723ad..fbfd3949593fb9 100644
--- a/test/es-module/test-esm-loader-search.js
+++ b/test/es-module/test-esm-loader-search.js
@@ -7,11 +7,8 @@ const common = require('../common');
 
 const { search } = require('internal/modules/esm/default_resolve');
 
-common.expectsError(
-  () => search('target', undefined),
-  {
-    code: 'ERR_MISSING_MODULE',
-    type: Error,
-    message: 'Cannot find module target'
-  }
-);
+common.expectsError(() => search('target', undefined), {
+  code: 'ERR_MISSING_MODULE',
+  type: Error,
+  message: 'Cannot find module target'
+});
diff --git a/test/es-module/test-esm-preserve-symlinks-main.js b/test/es-module/test-esm-preserve-symlinks-main.js
index fbca5dce743674..744848406002f6 100644
--- a/test/es-module/test-esm-preserve-symlinks-main.js
+++ b/test/es-module/test-esm-preserve-symlinks-main.js
@@ -18,12 +18,15 @@ const entry_link_absolute_path = path.join(tmpDir, 'link.js');
 const submodule = path.join(tmpDir, 'nested2', 'submodule.js');
 const submodule_link_absolute_path = path.join(tmpDir, 'submodule_link.js');
 
-fs.writeFileSync(entry, `
+fs.writeFileSync(
+  entry,
+  `
 const assert = require('assert');
 
 // this import only resolves with --preserve-symlinks-main set
 require('./submodule_link.js');
-`);
+`
+);
 fs.writeFileSync(submodule, '');
 
 try {
@@ -39,12 +42,15 @@ function doTest(flags, done) {
   // dictates that it'll resolve relative imports in the main file relative to
   // the symlink, and not relative to the symlink target; the file structure set
   // up above requires this to not crash when loading ./submodule_link.js
-  spawn(process.execPath,
-        flags.concat([
-          '--preserve-symlinks',
-          '--preserve-symlinks-main', entry_link_absolute_path
-        ]),
-        { stdio: 'inherit' }).on('exit', (code) => {
+  spawn(
+    process.execPath,
+    flags.concat([
+      '--preserve-symlinks',
+      '--preserve-symlinks-main',
+      entry_link_absolute_path
+    ]),
+    { stdio: 'inherit' }
+  ).on('exit', (code) => {
     assert.strictEqual(code, 0);
     done();
   });
diff --git a/test/es-module/test-esm-preserve-symlinks.js b/test/es-module/test-esm-preserve-symlinks.js
index 28cba3e7022c1a..7695440bbce0b7 100644
--- a/test/es-module/test-esm-preserve-symlinks.js
+++ b/test/es-module/test-esm-preserve-symlinks.js
@@ -14,14 +14,17 @@ const entry = path.join(tmpDir, 'entry.js');
 const real = path.join(tmpDir, 'real.js');
 const link_absolute_path = path.join(tmpDir, 'link.js');
 
-fs.writeFileSync(entry, `
+fs.writeFileSync(
+  entry,
+  `
 const assert = require('assert');
 global.x = 0;
 require('./real.js');
 assert.strictEqual(x, 1);
 require('./link.js');
 assert.strictEqual(x, 2);
-`);
+`
+);
 fs.writeFileSync(real, 'x++;');
 
 try {
@@ -31,8 +34,10 @@ try {
   common.skip('insufficient privileges for symlinks');
 }
 
-spawn(process.execPath,
-      ['--experimental-modules', '--preserve-symlinks', entry],
-      { stdio: 'inherit' }).on('exit', (code) => {
+spawn(
+  process.execPath,
+  ['--experimental-modules', '--preserve-symlinks', entry],
+  { stdio: 'inherit' }
+).on('exit', (code) => {
   assert.strictEqual(code, 0);
 });
diff --git a/test/es-module/test-esm-symlink-main.js b/test/es-module/test-esm-symlink-main.js
index f7631ef2e5bdca..5e9fb8bbdb8095 100644
--- a/test/es-module/test-esm-symlink-main.js
+++ b/test/es-module/test-esm-symlink-main.js
@@ -18,8 +18,10 @@ try {
   common.skip('insufficient privileges for symlinks');
 }
 
-spawn(process.execPath,
-      ['--experimental-modules', '--preserve-symlinks', symlinkPath],
-      { stdio: 'inherit' }).on('exit', (code) => {
+spawn(
+  process.execPath,
+  ['--experimental-modules', '--preserve-symlinks', symlinkPath],
+  { stdio: 'inherit' }
+).on('exit', (code) => {
   assert.strictEqual(code, 0);
 });
diff --git a/test/es-module/test-esm-symlink.js b/test/es-module/test-esm-symlink.js
index 232925a52e3f64..7780fe427c8b7a 100644
--- a/test/es-module/test-esm-symlink.js
+++ b/test/es-module/test-esm-symlink.js
@@ -14,12 +14,13 @@ const entry = path.join(tmpDir, 'entry.mjs');
 const real = path.join(tmpDir, 'index.mjs');
 const link_absolute_path = path.join(tmpDir, 'absolute');
 const link_relative_path = path.join(tmpDir, 'relative');
-const link_ignore_extension = path.join(tmpDir,
-                                        'ignore_extension.json');
+const link_ignore_extension = path.join(tmpDir, 'ignore_extension.json');
 const link_directory = path.join(tmpDir, 'directory');
 
 fs.writeFileSync(real, 'export default [];');
-fs.writeFileSync(entry, `
+fs.writeFileSync(
+  entry,
+  `
 import assert from 'assert';
 import real from './index.mjs';
 import absolute from './absolute';
@@ -31,7 +32,8 @@ assert.strictEqual(absolute, real);
 assert.strictEqual(relative, real);
 assert.strictEqual(ignoreExtension, real);
 assert.strictEqual(directory, real);
-`);
+`
+);
 
 try {
   fs.symlinkSync(real, link_absolute_path);
@@ -43,7 +45,8 @@ try {
   common.skip('insufficient privileges for symlinks');
 }
 
-spawn(process.execPath, ['--experimental-modules', entry],
-      { stdio: 'inherit' }).on('exit', (code) => {
+spawn(process.execPath, ['--experimental-modules', entry], {
+  stdio: 'inherit'
+}).on('exit', (code) => {
   assert.strictEqual(code, 0);
 });
diff --git a/test/fixtures/0-dns/create-cert.js b/test/fixtures/0-dns/create-cert.js
index 9a72104887a9d2..c47e75cba45aea 100644
--- a/test/fixtures/0-dns/create-cert.js
+++ b/test/fixtures/0-dns/create-cert.js
@@ -5,7 +5,7 @@ const fs = require('fs');
 const rfc5280 = require('asn1.js-rfc5280');
 const BN = asn1.bignum;
 
-const id_at_commonName = [ 2, 5, 4, 3 ];
+const id_at_commonName = [2, 5, 4, 3];
 const rsaEncryption = [1, 2, 840, 113549, 1, 1, 1];
 const sha256WithRSAEncryption = [1, 2, 840, 113549, 1, 1, 11];
 const digest = 'SHA256';
@@ -33,19 +33,26 @@ const subject = PrintStr.encode('evil.example.com', 'der');
 const tbs = {
   version: 'v3',
   serialNumber: new BN('01', 16),
-  signature: { algorithm: sha256WithRSAEncryption, parameters: null_},
-  issuer: { type: 'rdnSequence',
-            value: [ [{type: id_at_commonName, value: issuer}] ] },
-  validity:
-  { notBefore: { type: 'utcTime', value: now },
-    notAfter: { type: 'utcTime', value: now + days * 86400000} },
-  subject: { type: 'rdnSequence',
-             value: [ [{type: id_at_commonName, value: subject}] ] },
-  subjectPublicKeyInfo:
-  { algorithm: { algorithm: rsaEncryption, parameters: null_},
-    subjectPublicKey: { unused: 0, data: public_key} },
-  extensions:
-  [ { extnID: 'subjectAlternativeName',
+  signature: { algorithm: sha256WithRSAEncryption, parameters: null_ },
+  issuer: {
+    type: 'rdnSequence',
+    value: [[{ type: id_at_commonName, value: issuer }]]
+  },
+  validity: {
+    notBefore: { type: 'utcTime', value: now },
+    notAfter: { type: 'utcTime', value: now + days * 86400000 }
+  },
+  subject: {
+    type: 'rdnSequence',
+    value: [[{ type: id_at_commonName, value: subject }]]
+  },
+  subjectPublicKeyInfo: {
+    algorithm: { algorithm: rsaEncryption, parameters: null_ },
+    subjectPublicKey: { unused: 0, data: public_key }
+  },
+  extensions: [
+    {
+      extnID: 'subjectAlternativeName',
       critical: false,
       // subjectAltName which contains '\0' character to check CVE-2009-2408
       extnValue: [
@@ -53,7 +60,9 @@ const tbs = {
         { type: 'dNSName', value: 'just-another.example.com' },
         { type: 'iPAddress', value: Buffer.from('08080808', 'hex') },
         { type: 'iPAddress', value: Buffer.from('08080404', 'hex') },
-        { type: 'dNSName', value: 'last.example.com' } ] }
+        { type: 'dNSName', value: 'last.example.com' }
+      ]
+    }
   ]
 };
 
@@ -66,10 +75,8 @@ const signature = sign.sign(private_key);
 const cert = {
   tbsCertificate: tbs,
   signatureAlgorithm: { algorithm: sha256WithRSAEncryption, parameters: null_ },
-  signature:
-  { unused: 0,
-    data: signature }
+  signature: { unused: 0, data: signature }
 };
-const pem = rfc5280.Certificate.encode(cert, 'pem', {label: 'CERTIFICATE'});
+const pem = rfc5280.Certificate.encode(cert, 'pem', { label: 'CERTIFICATE' });
 
 fs.writeFileSync('./0-dns-cert.pem', pem + '\n');
diff --git a/test/fixtures/GH-1899-output.js b/test/fixtures/GH-1899-output.js
index d6b513324a52f6..8081dc9baf328a 100644
--- a/test/fixtures/GH-1899-output.js
+++ b/test/fixtures/GH-1899-output.js
@@ -20,4 +20,3 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 console.log('hello, world!');
-
diff --git a/test/fixtures/GH-7131/a.js b/test/fixtures/GH-7131/a.js
index 8c386a4d6188eb..c7d4a2bd7841d1 100644
--- a/test/fixtures/GH-7131/a.js
+++ b/test/fixtures/GH-7131/a.js
@@ -1,5 +1,5 @@
 'use strict';
-require('sys');  // Builtin should not show up in module.children array.
-require('./b');  // This should.
-require('./b');  // This should not.
+require('sys'); // Builtin should not show up in module.children array.
+require('./b'); // This should.
+require('./b'); // This should not.
 module.exports = module.children.slice();
diff --git a/test/fixtures/aead-vectors.js b/test/fixtures/aead-vectors.js
index 6b1d169b2a7a9f..9857309db23abe 100644
--- a/test/fixtures/aead-vectors.js
+++ b/test/fixtures/aead-vectors.js
@@ -1,291 +1,397 @@
 module.exports = [
-  { algo: 'aes-128-gcm',
+  {
+    algo: 'aes-128-gcm',
     key: '6970787039613669314d623455536234',
-    iv: '583673497131313748307652', plain: 'Hello World!',
+    iv: '583673497131313748307652',
+    plain: 'Hello World!',
     ct: '4be13896f64dfa2c2d0f2c76',
-    tag: '272b422f62eb545eaa15b5ff84092447', tampered: false },
-  { algo: 'aes-128-gcm',
+    tag: '272b422f62eb545eaa15b5ff84092447',
+    tampered: false
+  },
+  {
+    algo: 'aes-128-gcm',
     key: '6970787039613669314d623455536234',
-    iv: '583673497131313748307652', plain: 'Hello World!',
-    ct: '4be13896f64dfa2c2d0f2c76', aad: '000000FF',
-    tag: 'ba2479f66275665a88cb7b15f43eb005', tampered: false },
-  { algo: 'aes-128-gcm',
+    iv: '583673497131313748307652',
+    plain: 'Hello World!',
+    ct: '4be13896f64dfa2c2d0f2c76',
+    aad: '000000FF',
+    tag: 'ba2479f66275665a88cb7b15f43eb005',
+    tampered: false
+  },
+  {
+    algo: 'aes-128-gcm',
     key: '6970787039613669314d623455536234',
-    iv: '583673497131313748307652', plain: 'Hello World!',
+    iv: '583673497131313748307652',
+    plain: 'Hello World!',
     ct: '4be13596f64dfa2c2d0fac76',
-    tag: '272b422f62eb545eaa15b5ff84092447', tampered: true },
-  { algo: 'aes-256-gcm',
+    tag: '272b422f62eb545eaa15b5ff84092447',
+    tampered: true
+  },
+  {
+    algo: 'aes-256-gcm',
     key: '337a54767a7233703637564336316a6d56353472495975313534357834546c59',
-    iv: '36306950306836764a6f4561', plain: 'Hello node.js world!',
+    iv: '36306950306836764a6f4561',
+    plain: 'Hello node.js world!',
     ct: '58e62cfe7b1d274111a82267ebb93866e72b6c2a',
-    tag: '9bb44f663badabacae9720881fb1ec7a', tampered: false },
-  { algo: 'aes-256-gcm',
+    tag: '9bb44f663badabacae9720881fb1ec7a',
+    tampered: false
+  },
+  {
+    algo: 'aes-256-gcm',
     key: '337a54767a7233703637564336316a6d56353472495975313534357834546c59',
-    iv: '36306950306836764a6f4561', plain: 'Hello node.js world!',
+    iv: '36306950306836764a6f4561',
+    plain: 'Hello node.js world!',
     ct: '58e62cff7b1d274011a82267ebb93866e72b6c2b',
-    tag: '9bb44f663badabacae9720881fb1ec7a', tampered: true },
-  { algo: 'aes-192-gcm',
+    tag: '9bb44f663badabacae9720881fb1ec7a',
+    tampered: true
+  },
+  {
+    algo: 'aes-192-gcm',
     key: '1ed2233fa2223ef5d7df08546049406c7305220bca40d4c9',
-    iv: '0e1791e9db3bd21a9122c416', plain: 'Hello node.js world!',
-    password: 'very bad password', aad: '63616c76696e',
+    iv: '0e1791e9db3bd21a9122c416',
+    plain: 'Hello node.js world!',
+    password: 'very bad password',
+    aad: '63616c76696e',
     ct: 'dda53a4059aa17b88756984995f7bba3c636cc44',
-    tag: 'd2a35e5c611e5e3d2258360241c5b045', tampered: false },
+    tag: 'd2a35e5c611e5e3d2258360241c5b045',
+    tampered: false
+  },
 
   // Following test cases are from "The Galois/Counter Mode of Operation (GCM)"
   // by D. McGrew and J. Viega, published by NIST.
 
   // Test case 1
-  { algo: 'aes-128-gcm',
+  {
+    algo: 'aes-128-gcm',
     key: '00000000000000000000000000000000',
     iv: '000000000000000000000000',
     plain: '',
     plainIsHex: false,
     ct: '',
-    tag: '58e2fccefa7e3061367f1d57a4e7455a', tampered: false },
+    tag: '58e2fccefa7e3061367f1d57a4e7455a',
+    tampered: false
+  },
 
   // Test case 2
-  { algo: 'aes-128-gcm',
+  {
+    algo: 'aes-128-gcm',
     key: '00000000000000000000000000000000',
     iv: '000000000000000000000000',
     plain: '00000000000000000000000000000000',
     plainIsHex: true,
     ct: '0388dace60b6a392f328c2b971b2fe78',
-    tag: 'ab6e47d42cec13bdf53a67b21257bddf', tampered: false },
+    tag: 'ab6e47d42cec13bdf53a67b21257bddf',
+    tampered: false
+  },
 
   // Test case 3
-  { algo: 'aes-128-gcm',
+  {
+    algo: 'aes-128-gcm',
     key: 'feffe9928665731c6d6a8f9467308308',
     iv: 'cafebabefacedbaddecaf888',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a721' +
-           'c3c0c95956809532fcf0e2449a6b525b1' +
-           '6aedf5aa0de657ba637b391aafd255',
-    plainIsHex: true,
-    ct: '42831ec2217774244b7221b784d0d49c' +
-        'e3aa212f2c02a4e035c17e2329aca12e2' +
-        '1d514b25466931c7d8f6a5aac84aa051b' +
-        'a30b396a0aac973d58e091473f5985',
-    tag: '4d5c2af327cd64a62cf35abd2ba6fab4', tampered: false },
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a721' +
+      'c3c0c95956809532fcf0e2449a6b525b1' +
+      '6aedf5aa0de657ba637b391aafd255',
+    plainIsHex: true,
+    ct:
+      '42831ec2217774244b7221b784d0d49c' +
+      'e3aa212f2c02a4e035c17e2329aca12e2' +
+      '1d514b25466931c7d8f6a5aac84aa051b' +
+      'a30b396a0aac973d58e091473f5985',
+    tag: '4d5c2af327cd64a62cf35abd2ba6fab4',
+    tampered: false
+  },
 
   // Test case 4
-  { algo: 'aes-128-gcm',
+  {
+    algo: 'aes-128-gcm',
     key: 'feffe9928665731c6d6a8f9467308308',
     iv: 'cafebabefacedbaddecaf888',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a721' +
-           'c3c0c95956809532fcf0e2449a6b525b16' +
-           'aedf5aa0de657ba637b39',
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a721' +
+      'c3c0c95956809532fcf0e2449a6b525b16' +
+      'aedf5aa0de657ba637b39',
     aad: 'feedfacedeadbeeffeedfacedeadbeefabaddad2',
     plainIsHex: true,
-    ct: '42831ec2217774244b7221b784d0d49c' +
-        'e3aa212f2c02a4e035c17e2329aca12e2' +
-        '1d514b25466931c7d8f6a5aac84aa051b' +
-        'a30b396a0aac973d58e091',
-    tag: '5bc94fbc3221a5db94fae95ae7121a47', tampered: false },
+    ct:
+      '42831ec2217774244b7221b784d0d49c' +
+      'e3aa212f2c02a4e035c17e2329aca12e2' +
+      '1d514b25466931c7d8f6a5aac84aa051b' +
+      'a30b396a0aac973d58e091',
+    tag: '5bc94fbc3221a5db94fae95ae7121a47',
+    tampered: false
+  },
 
   // Test case 5, 8 byte IV
-  { algo: 'aes-128-gcm',
+  {
+    algo: 'aes-128-gcm',
     key: 'feffe9928665731c6d6a8f9467308308',
     iv: 'cafebabefacedbad',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b39',
-    aad: 'feedfacedeadbeeffeedfacedeadbeef' +
-         'abaddad2',
-    plainIsHex: true,
-    ct: '61353b4c2806934a777ff51fa22a4755' +
-        '699b2a714fcdc6f83766e5f97b6c7423' +
-        '73806900e49f24b22b097544d4896b42' +
-        '4989b5e1ebac0f07c23f4598',
-    tag: '3612d2e79e3b0785561be14aaca2fccb', tampered: false },
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b39',
+    aad: 'feedfacedeadbeeffeedfacedeadbeef' + 'abaddad2',
+    plainIsHex: true,
+    ct:
+      '61353b4c2806934a777ff51fa22a4755' +
+      '699b2a714fcdc6f83766e5f97b6c7423' +
+      '73806900e49f24b22b097544d4896b42' +
+      '4989b5e1ebac0f07c23f4598',
+    tag: '3612d2e79e3b0785561be14aaca2fccb',
+    tampered: false
+  },
 
   // Test case 6, 60 byte IV
-  { algo: 'aes-128-gcm',
+  {
+    algo: 'aes-128-gcm',
     key: 'feffe9928665731c6d6a8f9467308308',
-    iv: '9313225DF88406E555909C5AFF5269AA' +
-        '6A7A9538534F7DA1E4C303D2A318A728' +
-        'C3C0C95156809539FCF0E2429A6B52541' +
-        '6AEDBF5A0DE6A57A637B39B',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b39',
+    iv:
+      '9313225DF88406E555909C5AFF5269AA' +
+      '6A7A9538534F7DA1E4C303D2A318A728' +
+      'C3C0C95156809539FCF0E2429A6B52541' +
+      '6AEDBF5A0DE6A57A637B39B',
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b39',
     aad: 'feedfacedeadbeeffeedfacedeadbeefabaddad2',
     plainIsHex: true,
-    ct: '8ce24998625615b603a033aca13fb894' +
-        'be9112a5c3a211a8ba262a3cca7e2ca7' +
-        '01e4a9a4fba43c90ccdcb281d48c7c6f' +
-        'd62875d2aca417034c34aee5',
-    tag: '619cc5aefffe0bfa462af43c1699d050', tampered: false },
+    ct:
+      '8ce24998625615b603a033aca13fb894' +
+      'be9112a5c3a211a8ba262a3cca7e2ca7' +
+      '01e4a9a4fba43c90ccdcb281d48c7c6f' +
+      'd62875d2aca417034c34aee5',
+    tag: '619cc5aefffe0bfa462af43c1699d050',
+    tampered: false
+  },
 
   // Test case 7
-  { algo: 'aes-192-gcm',
+  {
+    algo: 'aes-192-gcm',
     key: '000000000000000000000000000000000000000000000000',
     iv: '000000000000000000000000',
     plain: '',
     plainIsHex: false,
     ct: '',
-    tag: 'cd33b28ac773f74ba00ed1f312572435', tampered: false },
+    tag: 'cd33b28ac773f74ba00ed1f312572435',
+    tampered: false
+  },
 
   // Test case 8
-  { algo: 'aes-192-gcm',
+  {
+    algo: 'aes-192-gcm',
     key: '000000000000000000000000000000000000000000000000',
     iv: '000000000000000000000000',
     plain: '00000000000000000000000000000000',
     plainIsHex: true,
     ct: '98e7247c07f0fe411c267e4384b0f600',
-    tag: '2ff58d80033927ab8ef4d4587514f0fb', tampered: false },
+    tag: '2ff58d80033927ab8ef4d4587514f0fb',
+    tampered: false
+  },
 
   // Test case 9
-  { algo: 'aes-192-gcm',
+  {
+    algo: 'aes-192-gcm',
     key: 'feffe9928665731c6d6a8f9467308308feffe9928665731c',
     iv: 'cafebabefacedbaddecaf888',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b391aafd255',
-    plainIsHex: true,
-    ct: '3980ca0b3c00e841eb06fac4872a2757' +
-        '859e1ceaa6efd984628593b40ca1e19c' +
-        '7d773d00c144c525ac619d18c84a3f47' +
-        '18e2448b2fe324d9ccda2710acade256',
-    tag: '9924a7c8587336bfb118024db8674a14', tampered: false },
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b391aafd255',
+    plainIsHex: true,
+    ct:
+      '3980ca0b3c00e841eb06fac4872a2757' +
+      '859e1ceaa6efd984628593b40ca1e19c' +
+      '7d773d00c144c525ac619d18c84a3f47' +
+      '18e2448b2fe324d9ccda2710acade256',
+    tag: '9924a7c8587336bfb118024db8674a14',
+    tampered: false
+  },
 
   // Test case 10
-  { algo: 'aes-192-gcm',
+  {
+    algo: 'aes-192-gcm',
     key: 'feffe9928665731c6d6a8f9467308308feffe9928665731c',
     iv: 'cafebabefacedbaddecaf888',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b39',
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b39',
     aad: 'feedfacedeadbeeffeedfacedeadbeefabaddad2',
     plainIsHex: true,
-    ct: '3980ca0b3c00e841eb06fac4872a2757' +
-        '859e1ceaa6efd984628593b40ca1e19c' +
-        '7d773d00c144c525ac619d18c84a3f47' +
-        '18e2448b2fe324d9ccda2710',
-    tag: '2519498e80f1478f37ba55bd6d27618c', tampered: false },
+    ct:
+      '3980ca0b3c00e841eb06fac4872a2757' +
+      '859e1ceaa6efd984628593b40ca1e19c' +
+      '7d773d00c144c525ac619d18c84a3f47' +
+      '18e2448b2fe324d9ccda2710',
+    tag: '2519498e80f1478f37ba55bd6d27618c',
+    tampered: false
+  },
 
   // Test case 11
-  { algo: 'aes-192-gcm',
+  {
+    algo: 'aes-192-gcm',
     key: 'feffe9928665731c6d6a8f9467308308feffe9928665731c',
     iv: 'cafebabefacedbad',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b39',
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b39',
     aad: 'feedfacedeadbeeffeedfacedeadbeefabaddad2',
     plainIsHex: true,
-    ct: '0f10f599ae14a154ed24b36e25324db8' +
-        'c566632ef2bbb34f8347280fc4507057' +
-        'fddc29df9a471f75c66541d4d4dad1c9' +
-        'e93a19a58e8b473fa0f062f7',
-    tag: '65dcc57fcf623a24094fcca40d3533f8', tampered: false },
+    ct:
+      '0f10f599ae14a154ed24b36e25324db8' +
+      'c566632ef2bbb34f8347280fc4507057' +
+      'fddc29df9a471f75c66541d4d4dad1c9' +
+      'e93a19a58e8b473fa0f062f7',
+    tag: '65dcc57fcf623a24094fcca40d3533f8',
+    tampered: false
+  },
 
   // Test case 12, 60 byte IV
-  { algo: 'aes-192-gcm',
+  {
+    algo: 'aes-192-gcm',
     key: 'feffe9928665731c6d6a8f9467308308feffe9928665731c',
-    iv: '9313225df88406e555909c5aff5269aa' +
-        '6a7a9538534f7da1e4c303d2a318a728' +
-        'c3c0c95156809539fcf0e2429a6b5254' +
-        '16aedbf5a0de6a57a637b39b',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b39',
+    iv:
+      '9313225df88406e555909c5aff5269aa' +
+      '6a7a9538534f7da1e4c303d2a318a728' +
+      'c3c0c95156809539fcf0e2429a6b5254' +
+      '16aedbf5a0de6a57a637b39b',
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b39',
     aad: 'feedfacedeadbeeffeedfacedeadbeefabaddad2',
     plainIsHex: true,
-    ct: 'd27e88681ce3243c4830165a8fdcf9ff' +
-        '1de9a1d8e6b447ef6ef7b79828666e45' +
-        '81e79012af34ddd9e2f037589b292db3' +
-        'e67c036745fa22e7e9b7373b',
-    tag: 'dcf566ff291c25bbb8568fc3d376a6d9', tampered: false },
+    ct:
+      'd27e88681ce3243c4830165a8fdcf9ff' +
+      '1de9a1d8e6b447ef6ef7b79828666e45' +
+      '81e79012af34ddd9e2f037589b292db3' +
+      'e67c036745fa22e7e9b7373b',
+    tag: 'dcf566ff291c25bbb8568fc3d376a6d9',
+    tampered: false
+  },
 
   // Test case 13
-  { algo: 'aes-256-gcm',
+  {
+    algo: 'aes-256-gcm',
     key: '0000000000000000000000000000000000000000000000000000000000000000',
     iv: '000000000000000000000000',
     plain: '',
     plainIsHex: false,
     ct: '',
-    tag: '530f8afbc74536b9a963b4f1c4cb738b', tampered: false },
+    tag: '530f8afbc74536b9a963b4f1c4cb738b',
+    tampered: false
+  },
 
   // Test case 14
-  { algo: 'aes-256-gcm',
+  {
+    algo: 'aes-256-gcm',
     key: '0000000000000000000000000000000000000000000000000000000000000000',
     iv: '000000000000000000000000',
     plain: '00000000000000000000000000000000',
     plainIsHex: true,
     ct: 'cea7403d4d606b6e074ec5d3baf39d18',
-    tag: 'd0d1c8a799996bf0265b98b5d48ab919', tampered: false },
+    tag: 'd0d1c8a799996bf0265b98b5d48ab919',
+    tampered: false
+  },
 
   // Test case 15
-  { algo: 'aes-256-gcm',
+  {
+    algo: 'aes-256-gcm',
     key: 'feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308',
     iv: 'cafebabefacedbaddecaf888',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b391aafd255',
-    plainIsHex: true,
-    ct: '522dc1f099567d07f47f37a32a84427d' +
-        '643a8cdcbfe5c0c97598a2bd2555d1aa' +
-        '8cb08e48590dbb3da7b08b1056828838' +
-        'c5f61e6393ba7a0abcc9f662898015ad',
-    tag: 'b094dac5d93471bdec1a502270e3cc6c', tampered: false },
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b391aafd255',
+    plainIsHex: true,
+    ct:
+      '522dc1f099567d07f47f37a32a84427d' +
+      '643a8cdcbfe5c0c97598a2bd2555d1aa' +
+      '8cb08e48590dbb3da7b08b1056828838' +
+      'c5f61e6393ba7a0abcc9f662898015ad',
+    tag: 'b094dac5d93471bdec1a502270e3cc6c',
+    tampered: false
+  },
 
   // Test case 16
-  { algo: 'aes-256-gcm',
+  {
+    algo: 'aes-256-gcm',
     key: 'feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308',
     iv: 'cafebabefacedbaddecaf888',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b39',
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b39',
     aad: 'feedfacedeadbeeffeedfacedeadbeefabaddad2',
     plainIsHex: true,
-    ct: '522dc1f099567d07f47f37a32a84427d' +
-        '643a8cdcbfe5c0c97598a2bd2555d1aa' +
-        '8cb08e48590dbb3da7b08b1056828838' +
-        'c5f61e6393ba7a0abcc9f662',
-    tag: '76fc6ece0f4e1768cddf8853bb2d551b', tampered: false },
+    ct:
+      '522dc1f099567d07f47f37a32a84427d' +
+      '643a8cdcbfe5c0c97598a2bd2555d1aa' +
+      '8cb08e48590dbb3da7b08b1056828838' +
+      'c5f61e6393ba7a0abcc9f662',
+    tag: '76fc6ece0f4e1768cddf8853bb2d551b',
+    tampered: false
+  },
 
   // Test case 17, 8 byte IV
-  { algo: 'aes-256-gcm',
+  {
+    algo: 'aes-256-gcm',
     key: 'feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308',
     iv: 'cafebabefacedbad',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b39',
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b39',
     aad: 'feedfacedeadbeeffeedfacedeadbeefabaddad2',
     plainIsHex: true,
-    ct: 'c3762df1ca787d32ae47c13bf19844cb' +
-        'af1ae14d0b976afac52ff7d79bba9de0' +
-        'feb582d33934a4f0954cc2363bc73f78' +
-        '62ac430e64abe499f47c9b1f',
-    tag: '3a337dbf46a792c45e454913fe2ea8f2', tampered: false },
+    ct:
+      'c3762df1ca787d32ae47c13bf19844cb' +
+      'af1ae14d0b976afac52ff7d79bba9de0' +
+      'feb582d33934a4f0954cc2363bc73f78' +
+      '62ac430e64abe499f47c9b1f',
+    tag: '3a337dbf46a792c45e454913fe2ea8f2',
+    tampered: false
+  },
 
   // Test case 18, 60 byte IV
-  { algo: 'aes-256-gcm',
+  {
+    algo: 'aes-256-gcm',
     key: 'feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308',
-    iv: '9313225df88406e555909c5aff5269aa' +
-        '6a7a9538534f7da1e4c303d2a318a728' +
-        'c3c0c95156809539fcf0e2429a6b5254' +
-        '16aedbf5a0de6a57a637b39b',
-    plain: 'd9313225f88406e5a55909c5aff5269a' +
-           '86a7a9531534f7da2e4c303d8a318a72' +
-           '1c3c0c95956809532fcf0e2449a6b525' +
-           'b16aedf5aa0de657ba637b39',
+    iv:
+      '9313225df88406e555909c5aff5269aa' +
+      '6a7a9538534f7da1e4c303d2a318a728' +
+      'c3c0c95156809539fcf0e2429a6b5254' +
+      '16aedbf5a0de6a57a637b39b',
+    plain:
+      'd9313225f88406e5a55909c5aff5269a' +
+      '86a7a9531534f7da2e4c303d8a318a72' +
+      '1c3c0c95956809532fcf0e2449a6b525' +
+      'b16aedf5aa0de657ba637b39',
     aad: 'feedfacedeadbeeffeedfacedeadbeefabaddad2',
     plainIsHex: true,
-    ct: '5a8def2f0c9e53f1f75d7853659e2a20' +
-        'eeb2b22aafde6419a058ab4f6f746bf4' +
-        '0fc0c3b780f244452da3ebf1c5d82cde' +
-        'a2418997200ef82e44ae7e3f',
-    tag: 'a44a8266ee1c8eb0c8b5d4cf5ae9f19a', tampered: false },
+    ct:
+      '5a8def2f0c9e53f1f75d7853659e2a20' +
+      'eeb2b22aafde6419a058ab4f6f746bf4' +
+      '0fc0c3b780f244452da3ebf1c5d82cde' +
+      'a2418997200ef82e44ae7e3f',
+    tag: 'a44a8266ee1c8eb0c8b5d4cf5ae9f19a',
+    tampered: false
+  },
 
   // The following test cases for AES-CCM are from RFC3610
 
@@ -601,13 +707,16 @@ module.exports = [
     algo: 'aes-128-ocb',
     key: '000102030405060708090a0b0c0d0e0f',
     iv: 'bbaa9988776655443322110d',
-    plain: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' +
-           '2021222324252627',
-    plainIsHex: true,
-    aad: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20' +
-         '21222324252627',
-    ct: 'd5ca91748410c1751ff8a2f618255b68a0a12e093ff454606e59f9c1d0ddc54b65e8' +
-        '628e568bad7a',
+    plain:
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' +
+      '2021222324252627',
+    plainIsHex: true,
+    aad:
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20' +
+      '21222324252627',
+    ct:
+      'd5ca91748410c1751ff8a2f618255b68a0a12e093ff454606e59f9c1d0ddc54b65e8' +
+      '628e568bad7a',
     tag: 'ed07ba06a4a69483a7035490c5769e60'
   },
 
@@ -617,8 +726,9 @@ module.exports = [
     iv: 'bbaa9988776655443322110e',
     plain: '',
     plainIsHex: true,
-    aad: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20' +
-         '21222324252627',
+    aad:
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20' +
+      '21222324252627',
     ct: '',
     tag: 'c5cd9d1850c141e358649994ee701b68'
   },
@@ -627,11 +737,13 @@ module.exports = [
     algo: 'aes-128-ocb',
     key: '000102030405060708090a0b0c0d0e0f',
     iv: 'bbaa9988776655443322110f',
-    plain: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' +
-           '2021222324252627',
+    plain:
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' +
+      '2021222324252627',
     plainIsHex: true,
-    ct: '4412923493c57d5de0d700f753cce0d1d2d95060122e9f15a5ddbfc5787e50b5cc55' +
-        'ee507bcb084e',
+    ct:
+      '4412923493c57d5de0d700f753cce0d1d2d95060122e9f15a5ddbfc5787e50b5cc55' +
+      'ee507bcb084e',
     tag: '479ad363ac366b95a98ca5f3000b1479'
   },
 
@@ -639,13 +751,16 @@ module.exports = [
     algo: 'aes-128-ocb',
     key: '0f0e0d0c0b0a09080706050403020100',
     iv: 'bbaa9988776655443322110d',
-    plain: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' +
-           '2021222324252627',
-    plainIsHex: true,
-    aad: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20' +
-         '21222324252627',
-    ct: '1792a4e31e0755fb03e31b22116e6c2ddf9efd6e33d536f1a0124b0a55bae884ed93' +
-        '481529c76b6a',
+    plain:
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' +
+      '2021222324252627',
+    plainIsHex: true,
+    aad:
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20' +
+      '21222324252627',
+    ct:
+      '1792a4e31e0755fb03e31b22116e6c2ddf9efd6e33d536f1a0124b0a55bae884ed93' +
+      '481529c76b6a',
     tag: 'd0c515f4d1cdd4fdac4f02aa'
   },
 
@@ -653,50 +768,59 @@ module.exports = [
     algo: 'aes-128-ocb',
     key: '0f0e0d0c0b0a09080706050403020100',
     iv: 'bbaa9988776655443322110d',
-    plain: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' +
-           '2021222324252627',
-    plainIsHex: true,
-    aad: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20' +
-         '21222324252627',
-    ct: '1792a4e31e0755fb03e31b22116e6c2ddf9efd6e33d536f1a0124b0a55bae884ed93' +
-        '481529c76b6a',
+    plain:
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' +
+      '2021222324252627',
+    plainIsHex: true,
+    aad:
+      '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20' +
+      '21222324252627',
+    ct:
+      '1792a4e31e0755fb03e31b22116e6c2ddf9efd6e33d536f1a0124b0a55bae884ed93' +
+      '481529c76b6a',
     tag: 'd0c515f4d1cdd4fdac4f02ab',
     tampered: true
   },
 
   // Test case from rfc7539 section 2.8.2
-  { algo: 'chacha20-poly1305',
+  {
+    algo: 'chacha20-poly1305',
     key: '808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f',
     iv: '070000004041424344454647',
-    plain: '4c616469657320616e642047656e746c656d656e206f662074686520636c6173' +
-           '73206f66202739393a204966204920636f756c64206f6666657220796f75206f' +
-           '6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73' +
-           '637265656e20776f756c642062652069742e',
+    plain:
+      '4c616469657320616e642047656e746c656d656e206f662074686520636c6173' +
+      '73206f66202739393a204966204920636f756c64206f6666657220796f75206f' +
+      '6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73' +
+      '637265656e20776f756c642062652069742e',
     plainIsHex: true,
     aad: '50515253c0c1c2c3c4c5c6c7',
-    ct: 'd31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5' +
-        'a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e06' +
-        '0b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fa' +
-        'b324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d265' +
-        '86cec64b6116',
+    ct:
+      'd31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5' +
+      'a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e06' +
+      '0b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fa' +
+      'b324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d265' +
+      '86cec64b6116',
     tag: '1ae10b594f09e26a7e902ecbd0600691',
     tampered: false
   },
 
-  { algo: 'chacha20-poly1305',
+  {
+    algo: 'chacha20-poly1305',
     key: '808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f',
     iv: '070000004041424344454647',
-    plain: '4c616469657320616e642047656e746c656d656e206f662074686520636c6173' +
-           '73206f66202739393a204966204920636f756c64206f6666657220796f75206f' +
-           '6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73' +
-           '637265656e20776f756c642062652069742e',
+    plain:
+      '4c616469657320616e642047656e746c656d656e206f662074686520636c6173' +
+      '73206f66202739393a204966204920636f756c64206f6666657220796f75206f' +
+      '6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73' +
+      '637265656e20776f756c642062652069742e',
     plainIsHex: true,
     aad: '50515253c0c1c2c3c4c5c6c7',
-    ct: 'd31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5' +
-        'a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e06' +
-        '0b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fa' +
-        'b324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d265' +
-        '86cec64b6116',
+    ct:
+      'd31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5' +
+      'a736ee62d63dbea45e8ca9671282fafb69da92728b1a71de0a9e06' +
+      '0b2905d6a5b67ecd3b3692ddbd7f2d778b8c9803aee328091b58fa' +
+      'b324e4fad675945585808b4831d7bc3ff4def08e4b7a9de576d265' +
+      '86cec64b6116',
     tag: '1ae10b594f09e26a7e902ecbd0600692',
     tampered: true
   }
diff --git a/test/fixtures/apilinks/buffer.js b/test/fixtures/apilinks/buffer.js
index 8ee44123a5e8ca..359d6da858f925 100644
--- a/test/fixtures/apilinks/buffer.js
+++ b/test/fixtures/apilinks/buffer.js
@@ -2,10 +2,9 @@
 
 // Buffer instance methods are exported as 'buf'.
 
-function Buffer() {
-}
+function Buffer() {}
 
-Buffer.prototype.instanceMethod = function() {}
+Buffer.prototype.instanceMethod = function() {};
 
 module.exports = {
   Buffer
diff --git a/test/fixtures/apilinks/class.js b/test/fixtures/apilinks/class.js
index 7db5c008e623f1..96e1a6754fe50d 100644
--- a/test/fixtures/apilinks/class.js
+++ b/test/fixtures/apilinks/class.js
@@ -3,8 +3,8 @@
 // An exported class using ES2015 class syntax.
 
 class Class {
-  constructor() {};
-  method() {};
+  constructor() {}
+  method() {}
 }
 
 module.exports = {
diff --git a/test/fixtures/apilinks/exports.js b/test/fixtures/apilinks/exports.js
index 880fdf6c9dbe0d..922851025251ef 100644
--- a/test/fixtures/apilinks/exports.js
+++ b/test/fixtures/apilinks/exports.js
@@ -2,12 +2,12 @@
 
 // Support `exports` as an alternative to `module.exports`.
 
-function Buffer() {};
+function Buffer() {}
 
 exports.Buffer = Buffer;
 exports.fn1 = function fn1() {};
 
-var fn2 = exports.fn2 = function() {};
+var fn2 = (exports.fn2 = function() {});
 
-function fn3() {};
+function fn3() {}
 exports.fn3 = fn3;
diff --git a/test/fixtures/apilinks/mod.js b/test/fixtures/apilinks/mod.js
index 72606121f53fdb..4280b0c6e47d55 100644
--- a/test/fixtures/apilinks/mod.js
+++ b/test/fixtures/apilinks/mod.js
@@ -2,9 +2,7 @@
 
 // A module may export one or more methods.
 
-function foo() {
-}
-
+function foo() {}
 
 module.exports = {
   foo
diff --git a/test/fixtures/apilinks/prototype.js b/test/fixtures/apilinks/prototype.js
index 40218e844e68ad..5e0e8d3607468a 100644
--- a/test/fixtures/apilinks/prototype.js
+++ b/test/fixtures/apilinks/prototype.js
@@ -2,11 +2,10 @@
 
 // An exported class using classic prototype syntax.
 
-function Class() {
-}
+function Class() {}
 
-Class.classMethod = function() {}
-Class.prototype.instanceMethod = function() {}
+Class.classMethod = function() {};
+Class.prototype.instanceMethod = function() {};
 
 module.exports = {
   Class
diff --git a/test/fixtures/apilinks/reverse.js b/test/fixtures/apilinks/reverse.js
index 5a61e50dc27581..c95ab65bf2d7bc 100644
--- a/test/fixtures/apilinks/reverse.js
+++ b/test/fixtures/apilinks/reverse.js
@@ -2,12 +2,10 @@
 
 // Parallel assignment to the exported variable and module.exports.
 
-function ok() {
-}
+function ok() {}
 
-const asserts = module.exports = ok;
+const asserts = (module.exports = ok);
 
 asserts.ok = ok;
 
-asserts.strictEqual = function() {
-}
+asserts.strictEqual = function() {};
diff --git a/test/fixtures/assert-first-line.js b/test/fixtures/assert-first-line.js
index 8a65113559c981..9f8107c052ef1f 100644
--- a/test/fixtures/assert-first-line.js
+++ b/test/fixtures/assert-first-line.js
@@ -1,2 +1,6 @@
-'use strict'; const ässört = require('assert'); ässört(true); ässört.ok(''); ässört(null);
+'use strict';
+const ässört = require('assert');
+ässört(true);
+ässört.ok('');
+ässört(null);
 // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(false);
diff --git a/test/fixtures/assert-long-line.js b/test/fixtures/assert-long-line.js
index cab3507ac8d779..bdcb235558ddb9 100644
--- a/test/fixtures/assert-long-line.js
+++ b/test/fixtures/assert-long-line.js
@@ -1 +1,5 @@
-'use strict'; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */ const assert = require('assert'); assert(true); assert.ok(''); assert(null);
+'use strict';
+/* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */ const assert = require('assert');
+assert(true);
+assert.ok('');
+assert(null);
diff --git a/test/fixtures/b/c.js b/test/fixtures/b/c.js
index f82150b057e16e..b1f0ce47f48a7b 100644
--- a/test/fixtures/b/c.js
+++ b/test/fixtures/b/c.js
@@ -31,9 +31,7 @@ console.error('load fixtures/b/c.js');
 
 var string = 'C';
 
-exports.SomeClass = function() {
-
-};
+exports.SomeClass = function() {};
 
 exports.C = function() {
   return string;
diff --git a/test/fixtures/b/d.js b/test/fixtures/b/d.js
index 37fefc2d340a00..bb2e320617d587 100644
--- a/test/fixtures/b/d.js
+++ b/test/fixtures/b/d.js
@@ -30,4 +30,3 @@ exports.D = function() {
 process.on('exit', function() {
   string = 'D done';
 });
-
diff --git a/test/fixtures/child-process-message-and-exit.js b/test/fixtures/child-process-message-and-exit.js
index 56e83ce801aae6..469406c3654d7e 100644
--- a/test/fixtures/child-process-message-and-exit.js
+++ b/test/fixtures/child-process-message-and-exit.js
@@ -1,3 +1,2 @@
-
 process.send('hello');
 process.exit(0);
diff --git a/test/fixtures/cycles/root.js b/test/fixtures/cycles/root.js
index 3e29b5e39dcc0b..cf66ea15e793bd 100644
--- a/test/fixtures/cycles/root.js
+++ b/test/fixtures/cycles/root.js
@@ -19,7 +19,7 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-const foo = exports.foo = require('./folder/foo');
+const foo = (exports.foo = require('./folder/foo'));
 
 exports.hello = 'hello';
 exports.sayHello = function() {
diff --git a/test/fixtures/debugger-util-regression-fixture.js b/test/fixtures/debugger-util-regression-fixture.js
index d397f3d641ea62..a9ebff8dbfe6ef 100644
--- a/test/fixtures/debugger-util-regression-fixture.js
+++ b/test/fixtures/debugger-util-regression-fixture.js
@@ -1,4 +1,4 @@
 'use strict';
 const util = require('util');
-const payload = util.inspect({a: 'b'});
+const payload = util.inspect({ a: 'b' });
 console.log(payload);
diff --git a/test/fixtures/deprecated-userland-class.js b/test/fixtures/deprecated-userland-class.js
index 075426fd6bf16c..c06f58604bbe20 100644
--- a/test/fixtures/deprecated-userland-class.js
+++ b/test/fixtures/deprecated-userland-class.js
@@ -1,10 +1,12 @@
 const util = require('util');
 const assert = require('assert');
 
-class deprecatedClass {
-}
+class deprecatedClass {}
 
-const deprecated = util.deprecate(deprecatedClass, 'deprecatedClass is deprecated.');
+const deprecated = util.deprecate(
+  deprecatedClass,
+  'deprecatedClass is deprecated.'
+);
 
 const instance = new deprecated();
 const deprecatedInstance = new deprecatedClass();
diff --git a/test/fixtures/deprecated-userland-function.js b/test/fixtures/deprecated-userland-function.js
index d54565b4edeb4f..b554e8697b4326 100644
--- a/test/fixtures/deprecated-userland-function.js
+++ b/test/fixtures/deprecated-userland-function.js
@@ -1,6 +1,5 @@
 const util = require('util');
 
-function deprecatedFunction() {
-}
+function deprecatedFunction() {}
 
 util.deprecate(deprecatedFunction, 'deprecatedFunction is deprecated.')();
diff --git a/test/fixtures/deprecated-userland-subclass.js b/test/fixtures/deprecated-userland-subclass.js
index 2df374ad7d1b8d..d81941a74cb453 100644
--- a/test/fixtures/deprecated-userland-subclass.js
+++ b/test/fixtures/deprecated-userland-subclass.js
@@ -1,10 +1,12 @@
 const util = require('util');
 const assert = require('assert');
 
-class deprecatedClass {
-}
+class deprecatedClass {}
 
-const deprecated = util.deprecate(deprecatedClass, 'deprecatedClass is deprecated.');
+const deprecated = util.deprecate(
+  deprecatedClass,
+  'deprecatedClass is deprecated.'
+);
 
 class subclass extends deprecated {
   constructor() {
diff --git a/test/fixtures/es-module-require-cache/counter.js b/test/fixtures/es-module-require-cache/counter.js
index 2640d3e372dcd2..d30fcbec009863 100644
--- a/test/fixtures/es-module-require-cache/counter.js
+++ b/test/fixtures/es-module-require-cache/counter.js
@@ -1,2 +1,2 @@
 global.counter = global.counter || 0;
-global.counter++;
\ No newline at end of file
+global.counter++;
diff --git a/test/fixtures/es-module-require-cache/preload.js b/test/fixtures/es-module-require-cache/preload.js
index 6090dc0d5821eb..9dcf60c8df19ad 100644
--- a/test/fixtures/es-module-require-cache/preload.js
+++ b/test/fixtures/es-module-require-cache/preload.js
@@ -1 +1 @@
-require('./counter');
\ No newline at end of file
+require('./counter');
diff --git a/test/fixtures/exports-function-with-param.js b/test/fixtures/exports-function-with-param.js
index 263b9064422108..7caebfc1626f67 100644
--- a/test/fixtures/exports-function-with-param.js
+++ b/test/fixtures/exports-function-with-param.js
@@ -1 +1,3 @@
-module.exports = function foo(arg) { return arg; }
+module.exports = function foo(arg) {
+  return arg;
+};
diff --git a/test/fixtures/failmustcall1.js b/test/fixtures/failmustcall1.js
index a54740eb296267..a38f9e364b3c55 100644
--- a/test/fixtures/failmustcall1.js
+++ b/test/fixtures/failmustcall1.js
@@ -1,3 +1,3 @@
 const common = require('../common');
-const f = common.mustCall( () => {}, 2);
+const f = common.mustCall(() => {}, 2);
 f();
diff --git a/test/fixtures/global/plain.js b/test/fixtures/global/plain.js
index f983d7c68ba93f..e10aa39a1a6bca 100644
--- a/test/fixtures/global/plain.js
+++ b/test/fixtures/global/plain.js
@@ -22,4 +22,4 @@
 foo = 'foo';
 global.bar = 'bar';
 
-exports.fooBar = {foo: global.foo, bar: bar};
+exports.fooBar = { foo: global.foo, bar: bar };
diff --git a/test/fixtures/guess-hash-seed.js b/test/fixtures/guess-hash-seed.js
index ffcfd75aac54a3..cb6d1d0ae00a43 100644
--- a/test/fixtures/guess-hash-seed.js
+++ b/test/fixtures/guess-hash-seed.js
@@ -3,8 +3,7 @@ function min(arr) {
   let res = arr[0];
   for (let i = 1; i < arr.length; i++) {
     const val = arr[i];
-    if (val < res)
-      res = val;
+    if (val < res) res = val;
   }
   return res;
 }
@@ -18,14 +17,14 @@ const INT_MAX = 0x7fffffff;
 
 // from src/js/collection.js
 // key must be a signed 32-bit number!
-function ComputeIntegerHash(key/*, seed*/) {
+function ComputeIntegerHash(key /*, seed*/) {
   let hash = key;
-  hash = hash ^ 0/*seed*/;
-  hash = ~hash + (hash << 15);  // hash = (hash << 15) - hash - 1;
+  hash = hash ^ 0 /*seed*/;
+  hash = ~hash + (hash << 15); // hash = (hash << 15) - hash - 1;
   hash = hash ^ (hash >>> 12);
   hash = hash + (hash << 2);
   hash = hash ^ (hash >>> 4);
-  hash = (hash * 2057) | 0;  // hash = (hash + (hash << 3)) + (hash << 11);
+  hash = (hash * 2057) | 0; // hash = (hash + (hash << 3)) + (hash << 11);
   hash = hash ^ (hash >>> 16);
   return hash & 0x3fffffff;
 }
@@ -45,16 +44,22 @@ function string_to_array(str) {
 
 function gen_specialized_hasher(str) {
   const str_arr = string_to_array(str);
-  return Function('seed', `
+  return Function(
+    'seed',
+    `
     var running_hash = seed;
-    ${str_arr.map((c) => `
+    ${str_arr
+      .map(
+        (c) => `
       running_hash += ${c};
       running_hash &= 0xffffffff;
       running_hash += (running_hash << 10);
       running_hash &= 0xffffffff;
       running_hash ^= (running_hash >>> 6);
       running_hash &= 0xffffffff;
-    `).join('')}
+    `
+      )
+      .join('')}
     running_hash += (running_hash << 3);
     running_hash &= 0xffffffff;
     running_hash ^= (running_hash >>> 11);
@@ -65,12 +70,13 @@ function gen_specialized_hasher(str) {
       return ${kZeroHash};
     }
     return running_hash;
-  `);
+  `
+  );
 }
 
 // adapted from HashToEntry
 function hash_to_bucket(hash, numBuckets) {
-  return (hash & ((numBuckets) - 1));
+  return hash & (numBuckets - 1);
 }
 
 function time_set_lookup(set, value) {
@@ -117,12 +123,18 @@ let tester_set_treshold;
   }
 
   // calibrate Set access times for accessing the full bucket / an empty bucket
-  const pos_time =
-    min(run_repeated(10000, time_set_lookup.bind(null, tester_set,
-                                                 positive_test_value)));
-  const neg_time =
-    min(run_repeated(10000, time_set_lookup.bind(null, tester_set,
-                                                 negative_test_value)));
+  const pos_time = min(
+    run_repeated(
+      10000,
+      time_set_lookup.bind(null, tester_set, positive_test_value)
+    )
+  );
+  const neg_time = min(
+    run_repeated(
+      10000,
+      time_set_lookup.bind(null, tester_set, negative_test_value)
+    )
+  );
   tester_set_treshold = (pos_time + neg_time) / 2;
   // console.log(`pos_time: ${pos_time}, neg_time: ${neg_time},`,
   //             `threshold: ${tester_set_treshold}`);
@@ -131,8 +143,7 @@ let tester_set_treshold;
 // determine hash seed
 const slow_str_gen = (function*() {
   let strgen_i = 0;
-  outer:
-  while (1) {
+  outer: while (1) {
     const str = `#${strgen_i++}`;
     for (let i = 0; i < 1000; i++) {
       if (time_set_lookup(tester_set, str) < tester_set_treshold)
@@ -148,8 +159,12 @@ const first_slow_str_special_hasher = gen_specialized_hasher(first_slow_str);
 let seed_candidates = [];
 //var t_before_first_seed_brute = performance.now();
 for (let seed_candidate = 0; seed_candidate < 0x100000000; seed_candidate++) {
-  if (hash_to_bucket(first_slow_str_special_hasher(seed_candidate),
-                     tester_set_buckets) == 0) {
+  if (
+    hash_to_bucket(
+      first_slow_str_special_hasher(seed_candidate),
+      tester_set_buckets
+    ) == 0
+  ) {
     seed_candidates.push(seed_candidate);
   }
 }
@@ -160,15 +175,15 @@ while (seed_candidates.length > 1) {
   const special_hasher = gen_specialized_hasher(slow_str);
   const new_seed_candidates = [];
   for (const seed_candidate of seed_candidates) {
-    if (hash_to_bucket(special_hasher(seed_candidate), tester_set_buckets) ==
-        0) {
+    if (
+      hash_to_bucket(special_hasher(seed_candidate), tester_set_buckets) == 0
+    ) {
       new_seed_candidates.push(seed_candidate);
     }
   }
   seed_candidates = new_seed_candidates;
   // console.log(`reduced to ${seed_candidates.length} candidates`);
 }
-if (seed_candidates.length != 1)
-  throw new Error('no candidates remaining');
+if (seed_candidates.length != 1) throw new Error('no candidates remaining');
 const seed = seed_candidates[0];
 console.log(seed);
diff --git a/test/fixtures/json-with-directory-name-module/module-stub/index.js b/test/fixtures/json-with-directory-name-module/module-stub/index.js
index 5cbb00b63c1ad5..5eb96b6505227d 100644
--- a/test/fixtures/json-with-directory-name-module/module-stub/index.js
+++ b/test/fixtures/json-with-directory-name-module/module-stub/index.js
@@ -19,4 +19,4 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-module.exports = "hello from module-stub!"
+module.exports = 'hello from module-stub!';
diff --git a/test/fixtures/linux-perf.js b/test/fixtures/linux-perf.js
index 011ef19777bd37..6d18284f70c381 100644
--- a/test/fixtures/linux-perf.js
+++ b/test/fixtures/linux-perf.js
@@ -7,17 +7,26 @@ const crypto = require('crypto');
 // should also take some time to run, otherwise Linux perf might miss them
 // entirely even when sampling at a high frequency.
 function functionOne(i) {
-  for (let j=i; j > 0; j--) {
-    crypto.createHash('md5').update(functionTwo(i, j)).digest("hex");
+  for (let j = i; j > 0; j--) {
+    crypto
+      .createHash('md5')
+      .update(functionTwo(i, j))
+      .digest('hex');
   }
 }
 
 function functionTwo(x, y) {
-  let data = ((((x * y) + (x / y)) * y) ** (x + 1)).toString();
+  let data = (((x * y + x / y) * y) ** (x + 1)).toString();
   if (x % 2 == 0) {
-    return crypto.createHash('md5').update(data.repeat((x % 100) + 1)).digest("hex");
+    return crypto
+      .createHash('md5')
+      .update(data.repeat((x % 100) + 1))
+      .digest('hex');
   } else {
-    return crypto.createHash('md5').update(data.repeat((y % 100) + 1)).digest("hex");
+    return crypto
+      .createHash('md5')
+      .update(data.repeat((y % 100) + 1))
+      .digest('hex');
   }
 }
 
diff --git a/test/fixtures/module-require-depth/one.js b/test/fixtures/module-require-depth/one.js
index 02b451465bb76c..9e7c4adea51e11 100644
--- a/test/fixtures/module-require-depth/one.js
+++ b/test/fixtures/module-require-depth/one.js
@@ -1,9 +1,7 @@
 // Flags: --expose_internals
 'use strict';
 const assert = require('assert');
-const {
-  requireDepth
-} = require('internal/modules/cjs/helpers');
+const { requireDepth } = require('internal/modules/cjs/helpers');
 
 exports.requireDepth = requireDepth;
 assert.strictEqual(requireDepth, 1);
diff --git a/test/fixtures/module-require-depth/two.js b/test/fixtures/module-require-depth/two.js
index 5c94c4c89aa9ef..e806b00da7356f 100644
--- a/test/fixtures/module-require-depth/two.js
+++ b/test/fixtures/module-require-depth/two.js
@@ -1,9 +1,7 @@
 // Flags: --expose_internals
 'use strict';
 const assert = require('assert');
-const {
-  requireDepth
-} = require('internal/modules/cjs/helpers');
+const { requireDepth } = require('internal/modules/cjs/helpers');
 
 exports.requireDepth = requireDepth;
 assert.strictEqual(requireDepth, 2);
diff --git a/test/fixtures/nested-index/one/hello.js b/test/fixtures/nested-index/one/hello.js
index c0c8c4fb158368..59669356e67012 100644
--- a/test/fixtures/nested-index/one/hello.js
+++ b/test/fixtures/nested-index/one/hello.js
@@ -20,4 +20,3 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 exports.hello = 'hello from one!';
-
diff --git a/test/fixtures/nested-index/two/hello.js b/test/fixtures/nested-index/two/hello.js
index 339276cc7a3930..fd3d2dc961f9e0 100644
--- a/test/fixtures/nested-index/two/hello.js
+++ b/test/fixtures/nested-index/two/hello.js
@@ -20,4 +20,3 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 exports.hello = 'hello from two!';
-
diff --git a/test/fixtures/overwrite-config-preload-module.js b/test/fixtures/overwrite-config-preload-module.js
index 21cb966a54988b..ce0d0712f96814 100644
--- a/test/fixtures/overwrite-config-preload-module.js
+++ b/test/fixtures/overwrite-config-preload-module.js
@@ -1,4 +1,4 @@
-'use strict'
+'use strict';
 const common = require('../common');
 common.skipIfInspectorDisabled();
 
diff --git a/test/fixtures/parent-process-nonpersistent.js b/test/fixtures/parent-process-nonpersistent.js
index e55c7bf896d4d3..902f22d696bf64 100644
--- a/test/fixtures/parent-process-nonpersistent.js
+++ b/test/fixtures/parent-process-nonpersistent.js
@@ -1,9 +1,8 @@
-
 const spawn = require('child_process').spawn,
-    path = require('path'),
-    childPath = path.join(__dirname, 'child-process-persistent.js');
+  path = require('path'),
+  childPath = path.join(__dirname, 'child-process-persistent.js');
 
-var child = spawn(process.execPath, [ childPath ], {
+var child = spawn(process.execPath, [childPath], {
   detached: true,
   stdio: 'ignore'
 });
diff --git a/test/fixtures/printA.js b/test/fixtures/printA.js
index 30a56425de829c..52f6164a0f8f45 100644
--- a/test/fixtures/printA.js
+++ b/test/fixtures/printA.js
@@ -1 +1 @@
-console.log('A')
+console.log('A');
diff --git a/test/fixtures/printB.js b/test/fixtures/printB.js
index 241b6bdcf6f4d2..e299cf1604db23 100644
--- a/test/fixtures/printB.js
+++ b/test/fixtures/printB.js
@@ -1 +1 @@
-console.log('B')
+console.log('B');
diff --git a/test/fixtures/printC.js b/test/fixtures/printC.js
index 9a203c981ea11d..b90a8ec8d910d2 100644
--- a/test/fixtures/printC.js
+++ b/test/fixtures/printC.js
@@ -1 +1 @@
-console.log('C')
+console.log('C');
diff --git a/test/fixtures/process-exit-code-cases.js b/test/fixtures/process-exit-code-cases.js
index c8c4a2ebe6c7ff..e1a05a287dc1b7 100644
--- a/test/fixtures/process-exit-code-cases.js
+++ b/test/fixtures/process-exit-code-cases.js
@@ -49,7 +49,7 @@ function exitWithOneOnUncaught() {
 cases.push({
   func: exitWithOneOnUncaught,
   result: 1,
-  error: /^Error: ok$/,
+  error: /^Error: ok$/
 });
 
 function changeCodeInsideExit() {
@@ -95,7 +95,7 @@ function changeCodeInExitWithUncaught() {
 cases.push({
   func: changeCodeInExitWithUncaught,
   result: 98,
-  error: /^Error: ok$/,
+  error: /^Error: ok$/
 });
 
 function exitWithZeroInExitWithUncaught() {
@@ -109,5 +109,5 @@ function exitWithZeroInExitWithUncaught() {
 cases.push({
   func: exitWithZeroInExitWithUncaught,
   result: 0,
-  error: /^Error: ok$/,
+  error: /^Error: ok$/
 });
diff --git a/test/fixtures/recvfd.js b/test/fixtures/recvfd.js
index c27a312c652c63..fdd26b1a485029 100644
--- a/test/fixtures/recvfd.js
+++ b/test/fixtures/recvfd.js
@@ -67,9 +67,13 @@ s.on('fd', function(fd) {
   processData(s);
 });
 s.on('data', function(data) {
-  data.toString('utf8').trim().split('\n').forEach(function(d) {
-    receivedData.unshift(JSON.parse(d));
-  });
+  data
+    .toString('utf8')
+    .trim()
+    .split('\n')
+    .forEach(function(d) {
+      receivedData.unshift(JSON.parse(d));
+    });
   processData(s);
 });
 s.connect(process.argv[2]);
diff --git a/test/fixtures/repl-load-multiline.js b/test/fixtures/repl-load-multiline.js
index faedf4ee07d106..551b038ec16ef3 100644
--- a/test/fixtures/repl-load-multiline.js
+++ b/test/fixtures/repl-load-multiline.js
@@ -1,6 +1,4 @@
-const getLunch = () =>
-  placeOrder('tacos')
-    .then(eat);
+const getLunch = () => placeOrder('tacos').then(eat);
 
 const placeOrder = (order) => Promise.resolve(order);
 const eat = (food) => '<nom nom nom>';
diff --git a/test/fixtures/repl-pretty-stack.js b/test/fixtures/repl-pretty-stack.js
index 26e72beecaefdd..f8af202485f8f4 100644
--- a/test/fixtures/repl-pretty-stack.js
+++ b/test/fixtures/repl-pretty-stack.js
@@ -9,11 +9,13 @@ function b() {
 }
 
 function c() {
-  d(function() { throw new Error('Whoops!'); });
+  d(function() {
+    throw new Error('Whoops!');
+  });
 }
 
 function d(f) {
   f();
 }
 
-a();
\ No newline at end of file
+a();
diff --git a/test/fixtures/repl-tab-completion-nested-repls.js b/test/fixtures/repl-tab-completion-nested-repls.js
index 832734a22a5024..c4cce9b40c868c 100644
--- a/test/fixtures/repl-tab-completion-nested-repls.js
+++ b/test/fixtures/repl-tab-completion-nested-repls.js
@@ -47,4 +47,6 @@ putIn.run([
 ]);
 
 // In Node.js 10.11.0, this next line will terminate the repl silently...
-testMe.complete('inner.o', () => { throw new Error('fhqwhgads'); });
+testMe.complete('inner.o', () => {
+  throw new Error('fhqwhgads');
+});
diff --git a/test/fixtures/require-resolve.js b/test/fixtures/require-resolve.js
index 982b15c4979c8c..bf35e033fe1380 100644
--- a/test/fixtures/require-resolve.js
+++ b/test/fixtures/require-resolve.js
@@ -7,21 +7,18 @@ const nestedNodeModules = path.join(__dirname, 'node_modules', 'node_modules');
 const nestedIndex = path.join(__dirname, 'nested-index');
 
 // Test the default behavior.
-assert.strictEqual(
-  require.resolve('bar'),
-  path.join(nodeModules, 'bar.js')
-);
+assert.strictEqual(require.resolve('bar'), path.join(nodeModules, 'bar.js'));
 
 // Verify that existing paths are removed.
 assert.throws(() => {
-  require.resolve('bar', { paths: [] })
+  require.resolve('bar', { paths: [] });
 }, /^Error: Cannot find module 'bar'$/);
 
 // Verify that resolution path can be overwritten.
 {
   // three.js cannot be loaded from this file by default.
   assert.throws(() => {
-    require.resolve('three')
+    require.resolve('three');
   }, /^Error: Cannot find module 'three'$/);
 
   // However, it can be found if resolution contains the nested index directory.
diff --git a/test/fixtures/semicolon.js b/test/fixtures/semicolon.js
index 79a30844992a24..dd2472dfb2e0f9 100644
--- a/test/fixtures/semicolon.js
+++ b/test/fixtures/semicolon.js
@@ -18,5 +18,3 @@
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-;
diff --git a/test/fixtures/test-error-first-line-offset.js b/test/fixtures/test-error-first-line-offset.js
index 8276753746b12b..9ec9ea29104b20 100644
--- a/test/fixtures/test-error-first-line-offset.js
+++ b/test/fixtures/test-error-first-line-offset.js
@@ -1 +1 @@
-error
+error;
diff --git a/test/fixtures/test-fs-readfile-error.js b/test/fixtures/test-fs-readfile-error.js
index 9bac28f8efaabb..91b23db77a7529 100644
--- a/test/fixtures/test-fs-readfile-error.js
+++ b/test/fixtures/test-fs-readfile-error.js
@@ -19,4 +19,4 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require('fs').readFileSync('/');  // throws EISDIR
+require('fs').readFileSync('/'); // throws EISDIR
diff --git a/test/fixtures/test-init-index/index.js b/test/fixtures/test-init-index/index.js
index 31272c8995b29e..05a7898832b1d3 100644
--- a/test/fixtures/test-init-index/index.js
+++ b/test/fixtures/test-init-index/index.js
@@ -22,4 +22,3 @@
 (function() {
   require('util').print('Loaded successfully!');
 })();
-
diff --git a/test/fixtures/test-init-native/fs.js b/test/fixtures/test-init-native/fs.js
index b2246e5c658809..24c67550e4ae12 100644
--- a/test/fixtures/test-init-native/fs.js
+++ b/test/fixtures/test-init-native/fs.js
@@ -25,4 +25,3 @@
     require('util').print('fs loaded successfully');
   }
 })();
-
diff --git a/test/fixtures/throws_error2.js b/test/fixtures/throws_error2.js
index 835ad5aa44dced..829fe4b1146860 100644
--- a/test/fixtures/throws_error2.js
+++ b/test/fixtures/throws_error2.js
@@ -20,4 +20,3 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 JSON.parse(undefined);
-
diff --git a/test/fixtures/tls-connect.js b/test/fixtures/tls-connect.js
index 43c3e6f0fd9fa0..c5342baaf17881 100644
--- a/test/fixtures/tls-connect.js
+++ b/test/fixtures/tls-connect.js
@@ -6,8 +6,7 @@
 const common = require('../common');
 // Check if Node was compiled --without-ssl and if so exit early
 // as the require of tls will otherwise throw an Error.
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const tls = require('tls');
@@ -18,7 +17,7 @@ exports.debug = util.debuglog('test');
 exports.tls = tls;
 
 // Pre-load keys from common fixtures for ease of use by tests.
-const keys = exports.keys = {
+const keys = (exports.keys = {
   agent1: load('agent1', 'ca1'),
   agent2: load('agent2', 'agent2'),
   agent3: load('agent3', 'ca2'),
@@ -26,15 +25,15 @@ const keys = exports.keys = {
   agent5: load('agent5', 'ca2'),
   agent6: load('agent6', 'ca1'),
   agent7: load('agent7', 'fake-cnnic-root'),
-  ec: load('ec', 'ec'),
-};
+  ec: load('ec', 'ec')
+});
 
 function load(cert, issuer) {
   issuer = issuer || cert; // Assume self-signed if no issuer
   const id = {
     key: fixtures.readKey(cert + '-key.pem', 'binary'),
     cert: fixtures.readKey(cert + '-cert.pem', 'binary'),
-    ca: fixtures.readKey(issuer + '-cert.pem', 'binary'),
+    ca: fixtures.readKey(issuer + '-cert.pem', 'binary')
   };
   return id;
 }
@@ -46,43 +45,46 @@ exports.connect = function connect(options, callback) {
   const client = {};
   const pair = { server, client };
 
-  tls.createServer(options.server, function(conn) {
-    server.conn = conn;
-    conn.pipe(conn);
-    maybeCallback()
-  }).listen(0, function() {
-    server.server = this;
+  tls
+    .createServer(options.server, function(conn) {
+      server.conn = conn;
+      conn.pipe(conn);
+      maybeCallback();
+    })
+    .listen(0, function() {
+      server.server = this;
 
-    const optClient = util._extend({
-      port: this.address().port,
-    }, options.client);
+      const optClient = util._extend(
+        {
+          port: this.address().port
+        },
+        options.client
+      );
 
-    tls.connect(optClient)
-      .on('secureConnect', function() {
-        client.conn = this;
-        maybeCallback();
-      })
-      .on('error', function(err) {
-        client.err = err;
-        client.conn = this;
-        maybeCallback();
-      });
-  });
+      tls
+        .connect(optClient)
+        .on('secureConnect', function() {
+          client.conn = this;
+          maybeCallback();
+        })
+        .on('error', function(err) {
+          client.err = err;
+          client.conn = this;
+          maybeCallback();
+        });
+    });
 
   function maybeCallback() {
-    if (!callback)
-      return;
+    if (!callback) return;
     if (server.conn && (client.conn || client.err)) {
       const err = pair.client.err || pair.server.err;
       callback(err, pair, cleanup);
       callback = null;
 
       function cleanup() {
-        if (server.server)
-          server.server.close();
-        if (client.conn)
-          client.conn.end();
+        if (server.server) server.server.close();
+        if (client.conn) client.conn.end();
       }
     }
   }
-}
+};
diff --git a/test/fixtures/uncaught-exceptions/callbackify1.js b/test/fixtures/uncaught-exceptions/callbackify1.js
index 1fbe7c8ebfd7c5..b96e87cf44968a 100644
--- a/test/fixtures/uncaught-exceptions/callbackify1.js
+++ b/test/fixtures/uncaught-exceptions/callbackify1.js
@@ -5,7 +5,7 @@
 const { callbackify } = require('util');
 
 {
-  async function fn() { }
+  async function fn() {}
 
   const cbFn = callbackify(fn);
 
diff --git a/test/fixtures/url-idna.js b/test/fixtures/url-idna.js
index 4b8f5a48cc9646..a9976cfd5846c9 100644
--- a/test/fixtures/url-idna.js
+++ b/test/fixtures/url-idna.js
@@ -2,9 +2,7 @@
 
 // Credit for list: http://www.i18nguy.com/markup/idna-examples.html
 module.exports = [
-  { ascii: 'xn--mgbaal8b0b9b2b.icom.museum',
-    unicode: 'افغانستا.icom.museum'
-  },
+  { ascii: 'xn--mgbaal8b0b9b2b.icom.museum', unicode: 'افغانستا.icom.museum' },
   {
     ascii: 'xn--lgbbat1ad8j.icom.museum',
     unicode: 'الجزائر.icom.museum'
@@ -184,7 +182,7 @@ module.exports = [
   // long label
   {
     ascii: `${'a'.repeat(64)}.com`,
-    unicode: `${'a'.repeat(64)}.com`,
+    unicode: `${'a'.repeat(64)}.com`
   },
   // long URL
   {
diff --git a/test/fixtures/url-setter-tests-additional.js b/test/fixtures/url-setter-tests-additional.js
index b27ae336a28776..f8ff4e98fa2049 100644
--- a/test/fixtures/url-setter-tests-additional.js
+++ b/test/fixtures/url-setter-tests-additional.js
@@ -1,236 +1,236 @@
 module.exports = {
-  'username': [
+  username: [
     {
-      'comment': 'Surrogate pair',
-      'href': 'https://github.com/',
-      'new_value': '\uD83D\uDE00',
-      'expected': {
-        'href': 'https://%F0%9F%98%80@github.com/',
-        'username': '%F0%9F%98%80'
+      comment: 'Surrogate pair',
+      href: 'https://github.com/',
+      new_value: '\uD83D\uDE00',
+      expected: {
+        href: 'https://%F0%9F%98%80@github.com/',
+        username: '%F0%9F%98%80'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '\uD83D',
-      'expected': {
-        'href': 'https://%EF%BF%BD@github.com/',
-        'username': '%EF%BF%BD'
+      comment: 'Unpaired low surrogate 1',
+      href: 'https://github.com/',
+      new_value: '\uD83D',
+      expected: {
+        href: 'https://%EF%BF%BD@github.com/',
+        username: '%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '\uD83Dnode',
-      'expected': {
-        'href': 'https://%EF%BF%BDnode@github.com/',
-        'username': '%EF%BF%BDnode'
+      comment: 'Unpaired low surrogate 2',
+      href: 'https://github.com/',
+      new_value: '\uD83Dnode',
+      expected: {
+        href: 'https://%EF%BF%BDnode@github.com/',
+        username: '%EF%BF%BDnode'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '\uDE00',
-      'expected': {
-        'href': 'https://%EF%BF%BD@github.com/',
-        'username': '%EF%BF%BD'
+      comment: 'Unpaired high surrogate 1',
+      href: 'https://github.com/',
+      new_value: '\uDE00',
+      expected: {
+        href: 'https://%EF%BF%BD@github.com/',
+        username: '%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '\uDE00node',
-      'expected': {
-        'href': 'https://%EF%BF%BDnode@github.com/',
-        'username': '%EF%BF%BDnode'
+      comment: 'Unpaired high surrogate 2',
+      href: 'https://github.com/',
+      new_value: '\uDE00node',
+      expected: {
+        href: 'https://%EF%BF%BDnode@github.com/',
+        username: '%EF%BF%BDnode'
       }
     }
   ],
-  'password': [
+  password: [
     {
-      'comment': 'Surrogate pair',
-      'href': 'https://github.com/',
-      'new_value': '\uD83D\uDE00',
-      'expected': {
-        'href': 'https://:%F0%9F%98%80@github.com/',
-        'password': '%F0%9F%98%80'
+      comment: 'Surrogate pair',
+      href: 'https://github.com/',
+      new_value: '\uD83D\uDE00',
+      expected: {
+        href: 'https://:%F0%9F%98%80@github.com/',
+        password: '%F0%9F%98%80'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '\uD83D',
-      'expected': {
-        'href': 'https://:%EF%BF%BD@github.com/',
-        'password': '%EF%BF%BD'
+      comment: 'Unpaired low surrogate 1',
+      href: 'https://github.com/',
+      new_value: '\uD83D',
+      expected: {
+        href: 'https://:%EF%BF%BD@github.com/',
+        password: '%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '\uD83Dnode',
-      'expected': {
-        'href': 'https://:%EF%BF%BDnode@github.com/',
-        'password': '%EF%BF%BDnode'
+      comment: 'Unpaired low surrogate 2',
+      href: 'https://github.com/',
+      new_value: '\uD83Dnode',
+      expected: {
+        href: 'https://:%EF%BF%BDnode@github.com/',
+        password: '%EF%BF%BDnode'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '\uDE00',
-      'expected': {
-        'href': 'https://:%EF%BF%BD@github.com/',
-        'password': '%EF%BF%BD'
+      comment: 'Unpaired high surrogate 1',
+      href: 'https://github.com/',
+      new_value: '\uDE00',
+      expected: {
+        href: 'https://:%EF%BF%BD@github.com/',
+        password: '%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '\uDE00node',
-      'expected': {
-        'href': 'https://:%EF%BF%BDnode@github.com/',
-        'password': '%EF%BF%BDnode'
+      comment: 'Unpaired high surrogate 2',
+      href: 'https://github.com/',
+      new_value: '\uDE00node',
+      expected: {
+        href: 'https://:%EF%BF%BDnode@github.com/',
+        password: '%EF%BF%BDnode'
       }
     }
   ],
-  'pathname': [
+  pathname: [
     {
-      'comment': 'Surrogate pair',
-      'href': 'https://github.com/',
-      'new_value': '/\uD83D\uDE00',
-      'expected': {
-        'href': 'https://github.com/%F0%9F%98%80',
-        'pathname': '/%F0%9F%98%80'
+      comment: 'Surrogate pair',
+      href: 'https://github.com/',
+      new_value: '/\uD83D\uDE00',
+      expected: {
+        href: 'https://github.com/%F0%9F%98%80',
+        pathname: '/%F0%9F%98%80'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '/\uD83D',
-      'expected': {
-        'href': 'https://github.com/%EF%BF%BD',
-        'pathname': '/%EF%BF%BD'
+      comment: 'Unpaired low surrogate 1',
+      href: 'https://github.com/',
+      new_value: '/\uD83D',
+      expected: {
+        href: 'https://github.com/%EF%BF%BD',
+        pathname: '/%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '/\uD83Dnode',
-      'expected': {
-        'href': 'https://github.com/%EF%BF%BDnode',
-        'pathname': '/%EF%BF%BDnode'
+      comment: 'Unpaired low surrogate 2',
+      href: 'https://github.com/',
+      new_value: '/\uD83Dnode',
+      expected: {
+        href: 'https://github.com/%EF%BF%BDnode',
+        pathname: '/%EF%BF%BDnode'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '/\uDE00',
-      'expected': {
-        'href': 'https://github.com/%EF%BF%BD',
-        'pathname': '/%EF%BF%BD'
+      comment: 'Unpaired high surrogate 1',
+      href: 'https://github.com/',
+      new_value: '/\uDE00',
+      expected: {
+        href: 'https://github.com/%EF%BF%BD',
+        pathname: '/%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '/\uDE00node',
-      'expected': {
-        'href': 'https://github.com/%EF%BF%BDnode',
-        'pathname': '/%EF%BF%BDnode'
+      comment: 'Unpaired high surrogate 2',
+      href: 'https://github.com/',
+      new_value: '/\uDE00node',
+      expected: {
+        href: 'https://github.com/%EF%BF%BDnode',
+        pathname: '/%EF%BF%BDnode'
       }
     }
   ],
-  'search': [
+  search: [
     {
-      'comment': 'Surrogate pair',
-      'href': 'https://github.com/',
-      'new_value': '\uD83D\uDE00',
-      'expected': {
-        'href': 'https://github.com/?%F0%9F%98%80',
-        'search': '?%F0%9F%98%80'
+      comment: 'Surrogate pair',
+      href: 'https://github.com/',
+      new_value: '\uD83D\uDE00',
+      expected: {
+        href: 'https://github.com/?%F0%9F%98%80',
+        search: '?%F0%9F%98%80'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '\uD83D',
-      'expected': {
-        'href': 'https://github.com/?%EF%BF%BD',
-        'search': '?%EF%BF%BD'
+      comment: 'Unpaired low surrogate 1',
+      href: 'https://github.com/',
+      new_value: '\uD83D',
+      expected: {
+        href: 'https://github.com/?%EF%BF%BD',
+        search: '?%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '\uD83Dnode',
-      'expected': {
-        'href': 'https://github.com/?%EF%BF%BDnode',
-        'search': '?%EF%BF%BDnode'
+      comment: 'Unpaired low surrogate 2',
+      href: 'https://github.com/',
+      new_value: '\uD83Dnode',
+      expected: {
+        href: 'https://github.com/?%EF%BF%BDnode',
+        search: '?%EF%BF%BDnode'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '\uDE00',
-      'expected': {
-        'href': 'https://github.com/?%EF%BF%BD',
-        'search': '?%EF%BF%BD'
+      comment: 'Unpaired high surrogate 1',
+      href: 'https://github.com/',
+      new_value: '\uDE00',
+      expected: {
+        href: 'https://github.com/?%EF%BF%BD',
+        search: '?%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '\uDE00node',
-      'expected': {
-        'href': 'https://github.com/?%EF%BF%BDnode',
-        'search': '?%EF%BF%BDnode'
+      comment: 'Unpaired high surrogate 2',
+      href: 'https://github.com/',
+      new_value: '\uDE00node',
+      expected: {
+        href: 'https://github.com/?%EF%BF%BDnode',
+        search: '?%EF%BF%BDnode'
       }
     }
   ],
-  'hash': [
+  hash: [
     {
-      'comment': 'Surrogate pair',
-      'href': 'https://github.com/',
-      'new_value': '\uD83D\uDE00',
-      'expected': {
-        'href': 'https://github.com/#%F0%9F%98%80',
-        'hash': '#%F0%9F%98%80'
+      comment: 'Surrogate pair',
+      href: 'https://github.com/',
+      new_value: '\uD83D\uDE00',
+      expected: {
+        href: 'https://github.com/#%F0%9F%98%80',
+        hash: '#%F0%9F%98%80'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '\uD83D',
-      'expected': {
-        'href': 'https://github.com/#%EF%BF%BD',
-        'hash': '#%EF%BF%BD'
+      comment: 'Unpaired low surrogate 1',
+      href: 'https://github.com/',
+      new_value: '\uD83D',
+      expected: {
+        href: 'https://github.com/#%EF%BF%BD',
+        hash: '#%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired low surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '\uD83Dnode',
-      'expected': {
-        'href': 'https://github.com/#%EF%BF%BDnode',
-        'hash': '#%EF%BF%BDnode'
+      comment: 'Unpaired low surrogate 2',
+      href: 'https://github.com/',
+      new_value: '\uD83Dnode',
+      expected: {
+        href: 'https://github.com/#%EF%BF%BDnode',
+        hash: '#%EF%BF%BDnode'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 1',
-      'href': 'https://github.com/',
-      'new_value': '\uDE00',
-      'expected': {
-        'href': 'https://github.com/#%EF%BF%BD',
-        'hash': '#%EF%BF%BD'
+      comment: 'Unpaired high surrogate 1',
+      href: 'https://github.com/',
+      new_value: '\uDE00',
+      expected: {
+        href: 'https://github.com/#%EF%BF%BD',
+        hash: '#%EF%BF%BD'
       }
     },
     {
-      'comment': 'Unpaired high surrogate 2',
-      'href': 'https://github.com/',
-      'new_value': '\uDE00node',
-      'expected': {
-        'href': 'https://github.com/#%EF%BF%BDnode',
-        'hash': '#%EF%BF%BDnode'
+      comment: 'Unpaired high surrogate 2',
+      href: 'https://github.com/',
+      new_value: '\uDE00node',
+      expected: {
+        href: 'https://github.com/#%EF%BF%BDnode',
+        hash: '#%EF%BF%BDnode'
       }
     }
   ]
diff --git a/test/fixtures/url-tests-additional.js b/test/fixtures/url-tests-additional.js
index c1c640f4bb4b7d..36590e6d28aeb1 100644
--- a/test/fixtures/url-tests-additional.js
+++ b/test/fixtures/url-tests-additional.js
@@ -5,32 +5,32 @@
 module.exports = [
   {
     // surrogate pair
-    'url': 'https://github.com/nodejs/\uD83D\uDE00node',
-    'protocol': 'https:',
-    'pathname': '/nodejs/%F0%9F%98%80node'
+    url: 'https://github.com/nodejs/\uD83D\uDE00node',
+    protocol: 'https:',
+    pathname: '/nodejs/%F0%9F%98%80node'
   },
   {
     // unpaired low surrogate
-    'url': 'https://github.com/nodejs/\uD83D',
-    'protocol': 'https:',
-    'pathname': '/nodejs/%EF%BF%BD'
+    url: 'https://github.com/nodejs/\uD83D',
+    protocol: 'https:',
+    pathname: '/nodejs/%EF%BF%BD'
   },
   {
     // unpaired low surrogate
-    'url': 'https://github.com/nodejs/\uD83Dnode',
-    'protocol': 'https:',
-    'pathname': '/nodejs/%EF%BF%BDnode'
+    url: 'https://github.com/nodejs/\uD83Dnode',
+    protocol: 'https:',
+    pathname: '/nodejs/%EF%BF%BDnode'
   },
   {
     // unmatched high surrogate
-    'url': 'https://github.com/nodejs/\uDE00',
-    'protocol': 'https:',
-    'pathname': '/nodejs/%EF%BF%BD'
+    url: 'https://github.com/nodejs/\uDE00',
+    protocol: 'https:',
+    pathname: '/nodejs/%EF%BF%BD'
   },
   {
     // unmatched high surrogate
-    'url': 'https://github.com/nodejs/\uDE00node',
-    'protocol': 'https:',
-    'pathname': '/nodejs/%EF%BF%BDnode'
+    url: 'https://github.com/nodejs/\uDE00node',
+    protocol: 'https:',
+    pathname: '/nodejs/%EF%BF%BDnode'
   }
 ];
diff --git a/test/fixtures/v8-coverage/sigint.js b/test/fixtures/v8-coverage/sigint.js
index 78efc971925446..c52f5499375582 100644
--- a/test/fixtures/v8-coverage/sigint.js
+++ b/test/fixtures/v8-coverage/sigint.js
@@ -4,4 +4,4 @@ if (true) {
 } else {
   const c = 102;
 }
-process.kill(process.pid, "SIGINT");
+process.kill(process.pid, 'SIGINT');
diff --git a/test/fixtures/v8-coverage/spawn-subprocess.js b/test/fixtures/v8-coverage/spawn-subprocess.js
index 53ef7b995506f9..dcb8e12e328076 100644
--- a/test/fixtures/v8-coverage/spawn-subprocess.js
+++ b/test/fixtures/v8-coverage/spawn-subprocess.js
@@ -1,6 +1,6 @@
 const { spawnSync } = require('child_process');
 const env = Object.assign({}, process.env);
-delete env.NODE_V8_COVERAGE
+delete env.NODE_V8_COVERAGE;
 spawnSync(process.execPath, [require.resolve('./subprocess')], {
   env: env
 });
diff --git a/test/fixtures/wpt/console/console-is-a-namespace.any.js b/test/fixtures/wpt/console/console-is-a-namespace.any.js
index a4aae7ffce8ac8..46e2a2d5ba595d 100644
--- a/test/fixtures/wpt/console/console-is-a-namespace.any.js
+++ b/test/fixtures/wpt/console/console-is-a-namespace.any.js
@@ -1,27 +1,35 @@
-"use strict";
+'use strict';
 // https://heycam.github.io/webidl/#es-namespaces
 // https://console.spec.whatwg.org/#console-namespace
 
 test(() => {
-  assert_true(self.hasOwnProperty("console"));
-}, "console exists on the global object");
+  assert_true(self.hasOwnProperty('console'));
+}, 'console exists on the global object');
 
 test(() => {
-  const propDesc = Object.getOwnPropertyDescriptor(self, "console");
-  assert_equals(propDesc.writable, true, "must be writable");
-  assert_equals(propDesc.enumerable, false, "must not be enumerable");
-  assert_equals(propDesc.configurable, true, "must be configurable");
-  assert_equals(propDesc.value, console, "must have the right value");
-}, "console has the right property descriptors");
+  const propDesc = Object.getOwnPropertyDescriptor(self, 'console');
+  assert_equals(propDesc.writable, true, 'must be writable');
+  assert_equals(propDesc.enumerable, false, 'must not be enumerable');
+  assert_equals(propDesc.configurable, true, 'must be configurable');
+  assert_equals(propDesc.value, console, 'must have the right value');
+}, 'console has the right property descriptors');
 
 test(() => {
-  assert_false("Console" in self);
-}, "Console (uppercase, as if it were an interface) must not exist");
+  assert_false('Console' in self);
+}, 'Console (uppercase, as if it were an interface) must not exist');
 
 test(() => {
   const prototype1 = Object.getPrototypeOf(console);
   const prototype2 = Object.getPrototypeOf(prototype1);
 
-  assert_equals(Object.getOwnPropertyNames(prototype1).length, 0, "The [[Prototype]] must have no properties");
-  assert_equals(prototype2, Object.prototype, "The [[Prototype]]'s [[Prototype]] must be %ObjectPrototype%");
-}, "The prototype chain must be correct");
+  assert_equals(
+    Object.getOwnPropertyNames(prototype1).length,
+    0,
+    'The [[Prototype]] must have no properties'
+  );
+  assert_equals(
+    prototype2,
+    Object.prototype,
+    "The [[Prototype]]'s [[Prototype]] must be %ObjectPrototype%"
+  );
+}, 'The prototype chain must be correct');
diff --git a/test/fixtures/wpt/console/console-label-conversion.any.js b/test/fixtures/wpt/console/console-label-conversion.any.js
index 1fb269d4061c61..65550b05b96bd2 100644
--- a/test/fixtures/wpt/console/console-label-conversion.any.js
+++ b/test/fixtures/wpt/console/console-label-conversion.any.js
@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 // https://console.spec.whatwg/org/#counting
 // https://console.spec.whatwg/org/#timing
 
@@ -14,16 +14,23 @@ for (const method of methods) {
       }
     });
 
-    assert_true(labelToStringCalled, `${method}() must call toString() on label when label is an object`);
+    assert_true(
+      labelToStringCalled,
+      `${method}() must call toString() on label when label is an object`
+    );
   }, `console.${method}()'s label gets converted to string via label.toString() when label is an object`);
 
   test(() => {
-    assert_throws({name: 'Error'}, () => {
-      console[method]({
-        toString() {
-          throw new Error('conversion error');
-        }
-      });
-    }, `${method} must re-throw any exceptions thrown by label.toString() conversion`);
+    assert_throws(
+      { name: 'Error' },
+      () => {
+        console[method]({
+          toString() {
+            throw new Error('conversion error');
+          }
+        });
+      },
+      `${method} must re-throw any exceptions thrown by label.toString() conversion`
+    );
   }, `console.${method}() throws exceptions generated by erroneous label.toString() conversion`);
 }
diff --git a/test/fixtures/wpt/console/console-tests-historical.any.js b/test/fixtures/wpt/console/console-tests-historical.any.js
index 4c4d4c276d0cd4..0268316c5d29f7 100644
--- a/test/fixtures/wpt/console/console-tests-historical.any.js
+++ b/test/fixtures/wpt/console/console-tests-historical.any.js
@@ -4,16 +4,28 @@
  * the specification: http://console.spec.whatwg.org/
  */
 
-"use strict";
+'use strict';
 
 test(() => {
-  assert_equals(console.timeline, undefined, "console.timeline should be undefined");
+  assert_equals(
+    console.timeline,
+    undefined,
+    'console.timeline should be undefined'
+  );
 }, "'timeline' function should not exist on the console object");
 
 test(() => {
-  assert_equals(console.timelineEnd, undefined, "console.timelineEnd should be undefined");
+  assert_equals(
+    console.timelineEnd,
+    undefined,
+    'console.timelineEnd should be undefined'
+  );
 }, "'timelineEnd' function should not exist on the console object");
 
 test(() => {
-  assert_equals(console.markTimeline, undefined, "console.markTimeline should be undefined");
+  assert_equals(
+    console.markTimeline,
+    undefined,
+    'console.markTimeline should be undefined'
+  );
 }, "'markTimeline' function should not exist on the console object");
diff --git a/test/fixtures/wpt/resources/check-layout-th.js b/test/fixtures/wpt/resources/check-layout-th.js
index 928b0cf2a1041e..28a5a89e0ec24c 100644
--- a/test/fixtures/wpt/resources/check-layout-th.js
+++ b/test/fixtures/wpt/resources/check-layout-th.js
@@ -1,196 +1,300 @@
 (function() {
-// Test is initiated from body.onload, so explicit done() call is required.
-setup({ explicit_done: true });
+  // Test is initiated from body.onload, so explicit done() call is required.
+  setup({ explicit_done: true });
 
-function checkSubtreeExpectedValues(t, parent, prefix)
-{
+  function checkSubtreeExpectedValues(t, parent, prefix) {
     var checkedLayout = checkExpectedValues(t, parent, prefix);
     Array.prototype.forEach.call(parent.childNodes, function(node) {
-        checkedLayout |= checkSubtreeExpectedValues(t, node, prefix);
+      checkedLayout |= checkSubtreeExpectedValues(t, node, prefix);
     });
     return checkedLayout;
-}
+  }
 
-function checkAttribute(output, node, attribute)
-{
+  function checkAttribute(output, node, attribute) {
     var result = node.getAttribute && node.getAttribute(attribute);
     output.checked |= !!result;
     return result;
-}
+  }
 
-function assert_tolerance(actual, expected, message)
-{
+  function assert_tolerance(actual, expected, message) {
     if (isNaN(expected) || Math.abs(actual - expected) >= 1) {
-        assert_equals(actual, Number(expected), message);
+      assert_equals(actual, Number(expected), message);
     }
-}
+  }
 
-function checkExpectedValues(t, node, prefix)
-{
+  function checkExpectedValues(t, node, prefix) {
     var output = { checked: false };
 
-    var expectedWidth = checkAttribute(output, node, "data-expected-width");
+    var expectedWidth = checkAttribute(output, node, 'data-expected-width');
     if (expectedWidth) {
-        assert_tolerance(node.offsetWidth, expectedWidth, prefix + "width");
+      assert_tolerance(node.offsetWidth, expectedWidth, prefix + 'width');
     }
 
-    var expectedHeight = checkAttribute(output, node, "data-expected-height");
+    var expectedHeight = checkAttribute(output, node, 'data-expected-height');
     if (expectedHeight) {
-        assert_tolerance(node.offsetHeight, expectedHeight, prefix + "height");
+      assert_tolerance(node.offsetHeight, expectedHeight, prefix + 'height');
     }
 
-    var expectedOffset = checkAttribute(output, node, "data-offset-x");
+    var expectedOffset = checkAttribute(output, node, 'data-offset-x');
     if (expectedOffset) {
-        assert_tolerance(node.offsetLeft, expectedOffset, prefix + "offsetLeft");
+      assert_tolerance(node.offsetLeft, expectedOffset, prefix + 'offsetLeft');
     }
 
-    var expectedOffset = checkAttribute(output, node, "data-offset-y");
+    var expectedOffset = checkAttribute(output, node, 'data-offset-y');
     if (expectedOffset) {
-        assert_tolerance(node.offsetTop, expectedOffset, prefix + "offsetTop");
+      assert_tolerance(node.offsetTop, expectedOffset, prefix + 'offsetTop');
     }
 
-    var expectedWidth = checkAttribute(output, node, "data-expected-client-width");
+    var expectedWidth = checkAttribute(
+      output,
+      node,
+      'data-expected-client-width'
+    );
     if (expectedWidth) {
-        assert_tolerance(node.clientWidth, expectedWidth, prefix + "clientWidth");
+      assert_tolerance(node.clientWidth, expectedWidth, prefix + 'clientWidth');
     }
 
-    var expectedHeight = checkAttribute(output, node, "data-expected-client-height");
+    var expectedHeight = checkAttribute(
+      output,
+      node,
+      'data-expected-client-height'
+    );
     if (expectedHeight) {
-        assert_tolerance(node.clientHeight, expectedHeight, prefix + "clientHeight");
+      assert_tolerance(
+        node.clientHeight,
+        expectedHeight,
+        prefix + 'clientHeight'
+      );
     }
 
-    var expectedWidth = checkAttribute(output, node, "data-expected-scroll-width");
+    var expectedWidth = checkAttribute(
+      output,
+      node,
+      'data-expected-scroll-width'
+    );
     if (expectedWidth) {
-        assert_tolerance(node.scrollWidth, expectedWidth, prefix + "scrollWidth");
+      assert_tolerance(node.scrollWidth, expectedWidth, prefix + 'scrollWidth');
     }
 
-    var expectedHeight = checkAttribute(output, node, "data-expected-scroll-height");
+    var expectedHeight = checkAttribute(
+      output,
+      node,
+      'data-expected-scroll-height'
+    );
     if (expectedHeight) {
-        assert_tolerance(node.scrollHeight, expectedHeight, prefix + "scrollHeight");
+      assert_tolerance(
+        node.scrollHeight,
+        expectedHeight,
+        prefix + 'scrollHeight'
+      );
     }
 
-    var expectedWidth = checkAttribute(output, node, "data-expected-bounding-client-rect-width");
+    var expectedWidth = checkAttribute(
+      output,
+      node,
+      'data-expected-bounding-client-rect-width'
+    );
     if (expectedWidth) {
-        assert_tolerance(node.getBoundingClientRect().width, expectedWidth, prefix + "getBoundingClientRect().width");
+      assert_tolerance(
+        node.getBoundingClientRect().width,
+        expectedWidth,
+        prefix + 'getBoundingClientRect().width'
+      );
     }
 
-    var expectedOffset = checkAttribute(output, node, "data-total-x");
+    var expectedOffset = checkAttribute(output, node, 'data-total-x');
     if (expectedOffset) {
-        var totalLeft = node.clientLeft + node.offsetLeft;
-        assert_tolerance(totalLeft, expectedOffset, prefix +
-                         "clientLeft+offsetLeft (" + node.clientLeft + " + " + node.offsetLeft + ")");
+      var totalLeft = node.clientLeft + node.offsetLeft;
+      assert_tolerance(
+        totalLeft,
+        expectedOffset,
+        prefix +
+          'clientLeft+offsetLeft (' +
+          node.clientLeft +
+          ' + ' +
+          node.offsetLeft +
+          ')'
+      );
     }
 
-    var expectedOffset = checkAttribute(output, node, "data-total-y");
+    var expectedOffset = checkAttribute(output, node, 'data-total-y');
     if (expectedOffset) {
-        var totalTop = node.clientTop + node.offsetTop;
-        assert_tolerance(totalTop, expectedOffset, prefix +
-                         "clientTop+offsetTop (" + node.clientTop + " + " + node.offsetTop + ")");
+      var totalTop = node.clientTop + node.offsetTop;
+      assert_tolerance(
+        totalTop,
+        expectedOffset,
+        prefix +
+          'clientTop+offsetTop (' +
+          node.clientTop +
+          ' + ' +
+          node.offsetTop +
+          ')'
+      );
     }
 
-    var expectedDisplay = checkAttribute(output, node, "data-expected-display");
+    var expectedDisplay = checkAttribute(output, node, 'data-expected-display');
     if (expectedDisplay) {
-        var actualDisplay = getComputedStyle(node).display;
-        assert_equals(actualDisplay, expectedDisplay, prefix + "display");
+      var actualDisplay = getComputedStyle(node).display;
+      assert_equals(actualDisplay, expectedDisplay, prefix + 'display');
     }
 
-    var expectedPaddingTop = checkAttribute(output, node, "data-expected-padding-top");
+    var expectedPaddingTop = checkAttribute(
+      output,
+      node,
+      'data-expected-padding-top'
+    );
     if (expectedPaddingTop) {
-        var actualPaddingTop = getComputedStyle(node).paddingTop;
-        // Trim the unit "px" from the output.
-        actualPaddingTop = actualPaddingTop.slice(0, -2);
-        assert_equals(actualPaddingTop, expectedPaddingTop, prefix + "padding-top");
+      var actualPaddingTop = getComputedStyle(node).paddingTop;
+      // Trim the unit "px" from the output.
+      actualPaddingTop = actualPaddingTop.slice(0, -2);
+      assert_equals(
+        actualPaddingTop,
+        expectedPaddingTop,
+        prefix + 'padding-top'
+      );
     }
 
-    var expectedPaddingBottom = checkAttribute(output, node, "data-expected-padding-bottom");
+    var expectedPaddingBottom = checkAttribute(
+      output,
+      node,
+      'data-expected-padding-bottom'
+    );
     if (expectedPaddingBottom) {
-        var actualPaddingBottom = getComputedStyle(node).paddingBottom;
-        // Trim the unit "px" from the output.
-        actualPaddingBottom = actualPaddingBottom.slice(0, -2);
-        assert_equals(actualPaddingBottom, expectedPaddingBottom, prefix + "padding-bottom");
+      var actualPaddingBottom = getComputedStyle(node).paddingBottom;
+      // Trim the unit "px" from the output.
+      actualPaddingBottom = actualPaddingBottom.slice(0, -2);
+      assert_equals(
+        actualPaddingBottom,
+        expectedPaddingBottom,
+        prefix + 'padding-bottom'
+      );
     }
 
-    var expectedPaddingLeft = checkAttribute(output, node, "data-expected-padding-left");
+    var expectedPaddingLeft = checkAttribute(
+      output,
+      node,
+      'data-expected-padding-left'
+    );
     if (expectedPaddingLeft) {
-        var actualPaddingLeft = getComputedStyle(node).paddingLeft;
-        // Trim the unit "px" from the output.
-        actualPaddingLeft = actualPaddingLeft.slice(0, -2);
-        assert_equals(actualPaddingLeft, expectedPaddingLeft, prefix + "padding-left");
+      var actualPaddingLeft = getComputedStyle(node).paddingLeft;
+      // Trim the unit "px" from the output.
+      actualPaddingLeft = actualPaddingLeft.slice(0, -2);
+      assert_equals(
+        actualPaddingLeft,
+        expectedPaddingLeft,
+        prefix + 'padding-left'
+      );
     }
 
-    var expectedPaddingRight = checkAttribute(output, node, "data-expected-padding-right");
+    var expectedPaddingRight = checkAttribute(
+      output,
+      node,
+      'data-expected-padding-right'
+    );
     if (expectedPaddingRight) {
-        var actualPaddingRight = getComputedStyle(node).paddingRight;
-        // Trim the unit "px" from the output.
-        actualPaddingRight = actualPaddingRight.slice(0, -2);
-        assert_equals(actualPaddingRight, expectedPaddingRight, prefix + "padding-right");
+      var actualPaddingRight = getComputedStyle(node).paddingRight;
+      // Trim the unit "px" from the output.
+      actualPaddingRight = actualPaddingRight.slice(0, -2);
+      assert_equals(
+        actualPaddingRight,
+        expectedPaddingRight,
+        prefix + 'padding-right'
+      );
     }
 
-    var expectedMarginTop = checkAttribute(output, node, "data-expected-margin-top");
+    var expectedMarginTop = checkAttribute(
+      output,
+      node,
+      'data-expected-margin-top'
+    );
     if (expectedMarginTop) {
-        var actualMarginTop = getComputedStyle(node).marginTop;
-        // Trim the unit "px" from the output.
-        actualMarginTop = actualMarginTop.slice(0, -2);
-        assert_equals(actualMarginTop, expectedMarginTop, prefix + "margin-top");
+      var actualMarginTop = getComputedStyle(node).marginTop;
+      // Trim the unit "px" from the output.
+      actualMarginTop = actualMarginTop.slice(0, -2);
+      assert_equals(actualMarginTop, expectedMarginTop, prefix + 'margin-top');
     }
 
-    var expectedMarginBottom = checkAttribute(output, node, "data-expected-margin-bottom");
+    var expectedMarginBottom = checkAttribute(
+      output,
+      node,
+      'data-expected-margin-bottom'
+    );
     if (expectedMarginBottom) {
-        var actualMarginBottom = getComputedStyle(node).marginBottom;
-        // Trim the unit "px" from the output.
-        actualMarginBottom = actualMarginBottom.slice(0, -2);
-        assert_equals(actualMarginBottom, expectedMarginBottom, prefix + "margin-bottom");
+      var actualMarginBottom = getComputedStyle(node).marginBottom;
+      // Trim the unit "px" from the output.
+      actualMarginBottom = actualMarginBottom.slice(0, -2);
+      assert_equals(
+        actualMarginBottom,
+        expectedMarginBottom,
+        prefix + 'margin-bottom'
+      );
     }
 
-    var expectedMarginLeft = checkAttribute(output, node, "data-expected-margin-left");
+    var expectedMarginLeft = checkAttribute(
+      output,
+      node,
+      'data-expected-margin-left'
+    );
     if (expectedMarginLeft) {
-        var actualMarginLeft = getComputedStyle(node).marginLeft;
-        // Trim the unit "px" from the output.
-        actualMarginLeft = actualMarginLeft.slice(0, -2);
-        assert_equals(actualMarginLeft, expectedMarginLeft, prefix + "margin-left");
+      var actualMarginLeft = getComputedStyle(node).marginLeft;
+      // Trim the unit "px" from the output.
+      actualMarginLeft = actualMarginLeft.slice(0, -2);
+      assert_equals(
+        actualMarginLeft,
+        expectedMarginLeft,
+        prefix + 'margin-left'
+      );
     }
 
-    var expectedMarginRight = checkAttribute(output, node, "data-expected-margin-right");
+    var expectedMarginRight = checkAttribute(
+      output,
+      node,
+      'data-expected-margin-right'
+    );
     if (expectedMarginRight) {
-        var actualMarginRight = getComputedStyle(node).marginRight;
-        // Trim the unit "px" from the output.
-        actualMarginRight = actualMarginRight.slice(0, -2);
-        assert_equals(actualMarginRight, expectedMarginRight, prefix + "margin-right");
+      var actualMarginRight = getComputedStyle(node).marginRight;
+      // Trim the unit "px" from the output.
+      actualMarginRight = actualMarginRight.slice(0, -2);
+      assert_equals(
+        actualMarginRight,
+        expectedMarginRight,
+        prefix + 'margin-right'
+      );
     }
 
     return output.checked;
-}
+  }
 
-var testNumber = 0;
+  var testNumber = 0;
 
-window.checkLayout = function(selectorList, callDone = true)
-{
+  window.checkLayout = function(selectorList, callDone = true) {
     if (!selectorList) {
-        console.error("You must provide a CSS selector of nodes to check.");
-        return;
+      console.error('You must provide a CSS selector of nodes to check.');
+      return;
     }
     var nodes = document.querySelectorAll(selectorList);
     nodes = Array.prototype.slice.call(nodes);
     var checkedLayout = false;
     Array.prototype.forEach.call(nodes, function(node) {
-        test(function(t) {
-            var container = node.parentNode.className == 'container' ? node.parentNode : node;
-            var prefix = "\n" + container.outerHTML + "\n";
-            var passed = false;
-            try {
-                checkedLayout |= checkExpectedValues(t, node.parentNode, prefix);
-                checkedLayout |= checkSubtreeExpectedValues(t, node, prefix);
-                passed = true;
-            } finally {
-                checkedLayout |= !passed;
-            }
-        }, selectorList + ' ' + String(++testNumber));
+      test(function(t) {
+        var container =
+          node.parentNode.className == 'container' ? node.parentNode : node;
+        var prefix = '\n' + container.outerHTML + '\n';
+        var passed = false;
+        try {
+          checkedLayout |= checkExpectedValues(t, node.parentNode, prefix);
+          checkedLayout |= checkSubtreeExpectedValues(t, node, prefix);
+          passed = true;
+        } finally {
+          checkedLayout |= !passed;
+        }
+      }, selectorList + ' ' + String(++testNumber));
     });
     if (!checkedLayout) {
-        console.error("No valid data-* attributes found in selector list : " + selectorList);
+      console.error(
+        'No valid data-* attributes found in selector list : ' + selectorList
+      );
     }
-    if (callDone)
-        done();
-};
-
+    if (callDone) done();
+  };
 })();
diff --git a/test/fixtures/wpt/resources/idlharness.js b/test/fixtures/wpt/resources/idlharness.js
index 40a5fa59cd209d..5b89e4e7e93448 100644
--- a/test/fixtures/wpt/resources/idlharness.js
+++ b/test/fixtures/wpt/resources/idlharness.js
@@ -46,107 +46,112 @@ policies and contribution forms [3].
  * The members and methods of the classes defined by this file are all at least
  * briefly documented, hopefully.
  */
-(function(){
-"use strict";
-// Support subsetTestByKey from /common/subset-tests-by-key.js, but make it optional
-if (!('subsetTestByKey' in self)) {
+(function() {
+  'use strict';
+  // Support subsetTestByKey from /common/subset-tests-by-key.js, but make it optional
+  if (!('subsetTestByKey' in self)) {
     self.subsetTestByKey = function(key, callback, ...args) {
       return callback(...args);
-    }
+    };
     self.shouldRunSubTest = () => true;
-}
-/// Helpers ///
-function constValue (cnt)
-{
-    if (cnt.type === "null") return null;
-    if (cnt.type === "NaN") return NaN;
-    if (cnt.type === "Infinity") return cnt.negative ? -Infinity : Infinity;
-    if (cnt.type === "number") return +cnt.value;
+  }
+  /// Helpers ///
+  function constValue(cnt) {
+    if (cnt.type === 'null') return null;
+    if (cnt.type === 'NaN') return NaN;
+    if (cnt.type === 'Infinity') return cnt.negative ? -Infinity : Infinity;
+    if (cnt.type === 'number') return +cnt.value;
     return cnt.value;
-}
+  }
 
-function minOverloadLength(overloads)
-{
+  function minOverloadLength(overloads) {
     // "The value of the Function object’s “length” property is
     // a Number determined as follows:
     // ". . .
     // "Return the length of the shortest argument list of the
     // entries in S."
     if (!overloads.length) {
-        return 0;
+      return 0;
     }
 
-    return overloads.map(function(attr) {
-        return attr.arguments ? attr.arguments.filter(function(arg) {
-            return !arg.optional && !arg.variadic;
-        }).length : 0;
-    })
-    .reduce(function(m, n) { return Math.min(m, n); });
-}
-
-function throwOrReject(a_test, operation, fn, obj, args, message, cb)
-{
-    if (operation.idlType.generic !== "Promise") {
-        assert_throws(new TypeError(), function() {
-            fn.apply(obj, args);
-        }, message);
-        cb();
+    return overloads
+      .map(function(attr) {
+        return attr.arguments
+          ? attr.arguments.filter(function(arg) {
+              return !arg.optional && !arg.variadic;
+            }).length
+          : 0;
+      })
+      .reduce(function(m, n) {
+        return Math.min(m, n);
+      });
+  }
+
+  function throwOrReject(a_test, operation, fn, obj, args, message, cb) {
+    if (operation.idlType.generic !== 'Promise') {
+      assert_throws(
+        new TypeError(),
+        function() {
+          fn.apply(obj, args);
+        },
+        message
+      );
+      cb();
     } else {
-        try {
-            promise_rejects(a_test, new TypeError(), fn.apply(obj, args), message).then(cb, cb);
-        } catch (e){
-            a_test.step(function() {
-                assert_unreached("Throws \"" + e + "\" instead of rejecting promise");
-                cb();
-            });
-        }
+      try {
+        promise_rejects(
+          a_test,
+          new TypeError(),
+          fn.apply(obj, args),
+          message
+        ).then(cb, cb);
+      } catch (e) {
+        a_test.step(function() {
+          assert_unreached('Throws "' + e + '" instead of rejecting promise');
+          cb();
+        });
+      }
     }
-}
+  }
 
-function awaitNCallbacks(n, cb, ctx)
-{
+  function awaitNCallbacks(n, cb, ctx) {
     var counter = 0;
     return function() {
-        counter++;
-        if (counter >= n) {
-            cb();
-        }
+      counter++;
+      if (counter >= n) {
+        cb();
+      }
     };
-}
+  }
 
-var fround =
-(function(){
+  var fround = (function() {
     if (Math.fround) return Math.fround;
 
     var arr = new Float32Array(1);
     return function fround(n) {
-        arr[0] = n;
-        return arr[0];
+      arr[0] = n;
+      return arr[0];
     };
-})();
+  })();
 
-/// IdlHarnessError ///
-// Entry point
-self.IdlHarnessError = function(message)
-{
+  /// IdlHarnessError ///
+  // Entry point
+  self.IdlHarnessError = function(message) {
     /**
      * Message to be printed as the error's toString invocation.
      */
     this.message = message;
-};
+  };
 
-IdlHarnessError.prototype = Object.create(Error.prototype);
+  IdlHarnessError.prototype = Object.create(Error.prototype);
 
-IdlHarnessError.prototype.toString = function()
-{
+  IdlHarnessError.prototype.toString = function() {
     return this.message;
-};
-
+  };
 
-/// IdlArray ///
-// Entry point
-self.IdlArray = function()
-{
+  /// IdlArray ///
+  // Entry point
+  self.IdlArray = function() {
     /**
      * A map from strings to the corresponding named IdlObject, such as
      * IdlInterface or IdlException.  These are the things that test() will run
@@ -190,158 +195,164 @@ self.IdlArray = function()
      * results in this["inheritance"] = { A: "B", B: "C" }
      */
     this.partials = [];
-    this["implements"] = {};
-    this["includes"] = {};
-    this["inheritance"] = {};
-};
+    this['implements'] = {};
+    this['includes'] = {};
+    this['inheritance'] = {};
+  };
 
-IdlArray.prototype.add_idls = function(raw_idls, options)
-{
+  IdlArray.prototype.add_idls = function(raw_idls, options) {
     /** Entry point.  See documentation at beginning of file. */
     this.internal_add_idls(WebIDL2.parse(raw_idls), options);
-};
+  };
 
-IdlArray.prototype.add_untested_idls = function(raw_idls, options)
-{
+  IdlArray.prototype.add_untested_idls = function(raw_idls, options) {
     /** Entry point.  See documentation at beginning of file. */
     var parsed_idls = WebIDL2.parse(raw_idls);
     this.mark_as_untested(parsed_idls);
     this.internal_add_idls(parsed_idls, options);
-};
+  };
 
-IdlArray.prototype.mark_as_untested = function (parsed_idls)
-{
+  IdlArray.prototype.mark_as_untested = function(parsed_idls) {
     for (var i = 0; i < parsed_idls.length; i++) {
-        parsed_idls[i].untested = true;
-        if ("members" in parsed_idls[i]) {
-            for (var j = 0; j < parsed_idls[i].members.length; j++) {
-                parsed_idls[i].members[j].untested = true;
-            }
+      parsed_idls[i].untested = true;
+      if ('members' in parsed_idls[i]) {
+        for (var j = 0; j < parsed_idls[i].members.length; j++) {
+          parsed_idls[i].members[j].untested = true;
         }
+      }
     }
-};
+  };
 
-IdlArray.prototype.is_excluded_by_options = function (name, options)
-{
-    return options &&
-        (options.except && options.except.includes(name)
-         || options.only && !options.only.includes(name));
-};
+  IdlArray.prototype.is_excluded_by_options = function(name, options) {
+    return (
+      options &&
+      ((options.except && options.except.includes(name)) ||
+        (options.only && !options.only.includes(name)))
+    );
+  };
 
-IdlArray.prototype.add_dependency_idls = function(raw_idls, options)
-{
+  IdlArray.prototype.add_dependency_idls = function(raw_idls, options) {
     const parsed_idls = WebIDL2.parse(raw_idls);
-    const new_options = { only: [] }
+    const new_options = { only: [] };
 
     const all_deps = new Set();
-    Object.values(this.inheritance).forEach(v => all_deps.add(v));
+    Object.values(this.inheritance).forEach((v) => all_deps.add(v));
     Object.entries(this.implements).forEach(([k, v]) => {
-        all_deps.add(k);
-        all_deps.add(v);
+      all_deps.add(k);
+      all_deps.add(v);
     });
     // NOTE: If 'A includes B' for B that we care about, then A is also a dep.
-    Object.keys(this.includes).forEach(k => {
-        all_deps.add(k);
-        this.includes[k].forEach(v => all_deps.add(v));
+    Object.keys(this.includes).forEach((k) => {
+      all_deps.add(k);
+      this.includes[k].forEach((v) => all_deps.add(v));
     });
-    this.partials.map(p => p.name).forEach(v => all_deps.add(v));
+    this.partials.map((p) => p.name).forEach((v) => all_deps.add(v));
     // Add the attribute idlTypes of all the nested members of all tested idls.
     for (const obj of [this.members, this.partials]) {
-        const tested = Object.values(obj).filter(m => !m.untested && m.members);
-        for (const parsed of tested) {
-            for (const attr of Object.values(parsed.members).filter(m => !m.untested && m.type === 'attribute')) {
-                all_deps.add(attr.idlType.idlType);
-            }
+      const tested = Object.values(obj).filter((m) => !m.untested && m.members);
+      for (const parsed of tested) {
+        for (const attr of Object.values(parsed.members).filter(
+          (m) => !m.untested && m.type === 'attribute'
+        )) {
+          all_deps.add(attr.idlType.idlType);
         }
+      }
     }
 
     if (options && options.except && options.only) {
-        throw new IdlHarnessError("The only and except options can't be used together.");
+      throw new IdlHarnessError(
+        "The only and except options can't be used together."
+      );
     }
 
-    const should_skip = name => {
-        // NOTE: Deps are untested, so we're lenient, and skip re-encountered definitions.
-        // e.g. for 'idl' containing A:B, B:C, C:D
-        //      array.add_idls(idl, {only: ['A','B']}).
-        //      array.add_dependency_idls(idl);
-        // B would be encountered as tested, and encountered as a dep, so we ignore.
-        return name in this.members
-            || this.is_excluded_by_options(name, options);
-    }
+    const should_skip = (name) => {
+      // NOTE: Deps are untested, so we're lenient, and skip re-encountered definitions.
+      // e.g. for 'idl' containing A:B, B:C, C:D
+      //      array.add_idls(idl, {only: ['A','B']}).
+      //      array.add_dependency_idls(idl);
+      // B would be encountered as tested, and encountered as a dep, so we ignore.
+      return name in this.members || this.is_excluded_by_options(name, options);
+    };
     // Record of skipped items, in case we later determine they are a dependency.
     // Maps name -> [parsed_idl, ...]
     const skipped = new Map();
     const process = function(parsed) {
-        var deps = [];
-        if (parsed.name) {
-            deps.push(parsed.name);
-        } else if (parsed.type === "implements") {
-            deps.push(parsed.target);
-            deps.push(parsed.implements);
-        } else if (parsed.type === "includes") {
-            deps.push(parsed.target);
-            deps.push(parsed.includes);
-        }
-
-        deps = deps.filter(function(name) {
-            if (!name || should_skip(name) || !all_deps.has(name)) {
-                // Flag as skipped, if it's not already processed, so we can
-                // come back to it later if we retrospectively call it a dep.
-                if (name && !(name in this.members)) {
-                    skipped.has(name)
-                        ? skipped.get(name).push(parsed)
-                        : skipped.set(name, [parsed]);
-                }
-                return false;
+      var deps = [];
+      if (parsed.name) {
+        deps.push(parsed.name);
+      } else if (parsed.type === 'implements') {
+        deps.push(parsed.target);
+        deps.push(parsed.implements);
+      } else if (parsed.type === 'includes') {
+        deps.push(parsed.target);
+        deps.push(parsed.includes);
+      }
+
+      deps = deps.filter(
+        function(name) {
+          if (!name || should_skip(name) || !all_deps.has(name)) {
+            // Flag as skipped, if it's not already processed, so we can
+            // come back to it later if we retrospectively call it a dep.
+            if (name && !(name in this.members)) {
+              skipped.has(name)
+                ? skipped.get(name).push(parsed)
+                : skipped.set(name, [parsed]);
             }
-            return true;
-        }.bind(this));
-
-        deps.forEach(function(name) {
-            new_options.only.push(name);
-
-            const follow_up = new Set();
-            for (const dep_type of ["inheritance", "implements", "includes"]) {
-                if (parsed[dep_type]) {
-                    const inheriting = parsed[dep_type];
-                    const inheritor = parsed.name || parsed.target;
-                    const deps = [inheriting];
-                    // For A includes B, we can ignore A unless B is being tested.
-                    if (dep_type !== "includes"
-                        || (inheriting in this.members && !this.members[inheriting].untested)) {
-                        deps.push(inheritor);
-                    }
-                    for (const dep of deps) {
-                        new_options.only.push(dep);
-                        all_deps.add(dep);
-                        follow_up.add(dep);
-                    }
-                }
+            return false;
+          }
+          return true;
+        }.bind(this)
+      );
+
+      deps.forEach(
+        function(name) {
+          new_options.only.push(name);
+
+          const follow_up = new Set();
+          for (const dep_type of ['inheritance', 'implements', 'includes']) {
+            if (parsed[dep_type]) {
+              const inheriting = parsed[dep_type];
+              const inheritor = parsed.name || parsed.target;
+              const deps = [inheriting];
+              // For A includes B, we can ignore A unless B is being tested.
+              if (
+                dep_type !== 'includes' ||
+                (inheriting in this.members &&
+                  !this.members[inheriting].untested)
+              ) {
+                deps.push(inheritor);
+              }
+              for (const dep of deps) {
+                new_options.only.push(dep);
+                all_deps.add(dep);
+                follow_up.add(dep);
+              }
             }
+          }
 
-            for (const deferred of follow_up) {
-                if (skipped.has(deferred)) {
-                    const next = skipped.get(deferred);
-                    skipped.delete(deferred);
-                    next.forEach(process);
-                }
+          for (const deferred of follow_up) {
+            if (skipped.has(deferred)) {
+              const next = skipped.get(deferred);
+              skipped.delete(deferred);
+              next.forEach(process);
             }
-        }.bind(this));
+          }
+        }.bind(this)
+      );
     }.bind(this);
 
     for (let parsed of parsed_idls) {
-        process(parsed);
+      process(parsed);
     }
 
     this.mark_as_untested(parsed_idls);
 
     if (new_options.only.length) {
-        this.internal_add_idls(parsed_idls, new_options);
+      this.internal_add_idls(parsed_idls, new_options);
     }
-}
+  };
 
-IdlArray.prototype.internal_add_idls = function(parsed_idls, options)
-{
+  IdlArray.prototype.internal_add_idls = function(parsed_idls, options) {
     /**
      * Internal helper called by add_idls() and add_untested_idls().
      *
@@ -357,151 +368,150 @@ IdlArray.prototype.internal_add_idls = function(parsed_idls, options)
      * aren't listed will be added. Only one of only and except can be used.
      */
 
-    if (options && options.only && options.except)
-    {
-        throw new IdlHarnessError("The only and except options can't be used together.");
+    if (options && options.only && options.except) {
+      throw new IdlHarnessError(
+        "The only and except options can't be used together."
+      );
     }
 
-    var should_skip = name => {
-        return this.is_excluded_by_options(name, options);
-    }
+    var should_skip = (name) => {
+      return this.is_excluded_by_options(name, options);
+    };
 
-    parsed_idls.forEach(function(parsed_idl)
-    {
+    parsed_idls.forEach(
+      function(parsed_idl) {
         var partial_types = [
-            "interface",
-            "interface mixin",
-            "dictionary",
-            "namespace",
+          'interface',
+          'interface mixin',
+          'dictionary',
+          'namespace'
         ];
-        if (parsed_idl.partial && partial_types.includes(parsed_idl.type))
-        {
-            if (should_skip(parsed_idl.name))
-            {
-                return;
-            }
-            this.partials.push(parsed_idl);
+        if (parsed_idl.partial && partial_types.includes(parsed_idl.type)) {
+          if (should_skip(parsed_idl.name)) {
             return;
+          }
+          this.partials.push(parsed_idl);
+          return;
         }
 
-        if (parsed_idl.type == "implements")
-        {
-            if (should_skip(parsed_idl.target))
-            {
-                return;
-            }
-            if (!(parsed_idl.target in this["implements"]))
-            {
-                this["implements"][parsed_idl.target] = [];
-            }
-            this["implements"][parsed_idl.target].push(parsed_idl["implements"]);
+        if (parsed_idl.type == 'implements') {
+          if (should_skip(parsed_idl.target)) {
             return;
+          }
+          if (!(parsed_idl.target in this['implements'])) {
+            this['implements'][parsed_idl.target] = [];
+          }
+          this['implements'][parsed_idl.target].push(parsed_idl['implements']);
+          return;
         }
 
-        if (parsed_idl.type == "includes")
-        {
-            if (should_skip(parsed_idl.target))
-            {
-                return;
-            }
-            if (!(parsed_idl.target in this["includes"]))
-            {
-                this["includes"][parsed_idl.target] = [];
-            }
-            this["includes"][parsed_idl.target].push(parsed_idl["includes"]);
+        if (parsed_idl.type == 'includes') {
+          if (should_skip(parsed_idl.target)) {
             return;
+          }
+          if (!(parsed_idl.target in this['includes'])) {
+            this['includes'][parsed_idl.target] = [];
+          }
+          this['includes'][parsed_idl.target].push(parsed_idl['includes']);
+          return;
         }
 
         parsed_idl.array = this;
-        if (should_skip(parsed_idl.name))
-        {
-            return;
+        if (should_skip(parsed_idl.name)) {
+          return;
         }
-        if (parsed_idl.name in this.members)
-        {
-            throw new IdlHarnessError("Duplicate identifier " + parsed_idl.name);
+        if (parsed_idl.name in this.members) {
+          throw new IdlHarnessError('Duplicate identifier ' + parsed_idl.name);
         }
 
-        if (parsed_idl["inheritance"]) {
-            // NOTE: Clash should be impossible (would require redefinition of parsed_idl.name).
-            if (parsed_idl.name in this["inheritance"]
-                && parsed_idl["inheritance"] != this["inheritance"][parsed_idl.name]) {
-                throw new IdlHarnessError(
-                    `Inheritance for ${parsed_idl.name} was already defined`);
-            }
-            this["inheritance"][parsed_idl.name] = parsed_idl["inheritance"];
+        if (parsed_idl['inheritance']) {
+          // NOTE: Clash should be impossible (would require redefinition of parsed_idl.name).
+          if (
+            parsed_idl.name in this['inheritance'] &&
+            parsed_idl['inheritance'] != this['inheritance'][parsed_idl.name]
+          ) {
+            throw new IdlHarnessError(
+              `Inheritance for ${parsed_idl.name} was already defined`
+            );
+          }
+          this['inheritance'][parsed_idl.name] = parsed_idl['inheritance'];
         }
 
-        switch(parsed_idl.type)
-        {
-        case "interface":
-            this.members[parsed_idl.name] =
-                new IdlInterface(parsed_idl, /* is_callback = */ false, /* is_mixin = */ false);
+        switch (parsed_idl.type) {
+          case 'interface':
+            this.members[parsed_idl.name] = new IdlInterface(
+              parsed_idl,
+              /* is_callback = */ false,
+              /* is_mixin = */ false
+            );
             break;
 
-        case "interface mixin":
-            this.members[parsed_idl.name] =
-                new IdlInterface(parsed_idl, /* is_callback = */ false, /* is_mixin = */ true);
+          case 'interface mixin':
+            this.members[parsed_idl.name] = new IdlInterface(
+              parsed_idl,
+              /* is_callback = */ false,
+              /* is_mixin = */ true
+            );
             break;
 
-        case "dictionary":
+          case 'dictionary':
             // Nothing to test, but we need the dictionary info around for type
             // checks
             this.members[parsed_idl.name] = new IdlDictionary(parsed_idl);
             break;
 
-        case "typedef":
+          case 'typedef':
             this.members[parsed_idl.name] = new IdlTypedef(parsed_idl);
             break;
 
-        case "callback":
+          case 'callback':
             // TODO
-            console.log("callback not yet supported");
+            console.log('callback not yet supported');
             break;
 
-        case "enum":
+          case 'enum':
             this.members[parsed_idl.name] = new IdlEnum(parsed_idl);
             break;
 
-        case "callback interface":
-            this.members[parsed_idl.name] =
-                new IdlInterface(parsed_idl, /* is_callback = */ true, /* is_mixin = */ false);
+          case 'callback interface':
+            this.members[parsed_idl.name] = new IdlInterface(
+              parsed_idl,
+              /* is_callback = */ true,
+              /* is_mixin = */ false
+            );
             break;
 
-        case "namespace":
+          case 'namespace':
             this.members[parsed_idl.name] = new IdlNamespace(parsed_idl);
             break;
 
-        default:
-            throw parsed_idl.name + ": " + parsed_idl.type + " not yet supported";
+          default:
+            throw parsed_idl.name +
+              ': ' +
+              parsed_idl.type +
+              ' not yet supported';
         }
-    }.bind(this));
-};
+      }.bind(this)
+    );
+  };
 
-IdlArray.prototype.add_objects = function(dict)
-{
+  IdlArray.prototype.add_objects = function(dict) {
     /** Entry point.  See documentation at beginning of file. */
-    for (var k in dict)
-    {
-        if (k in this.objects)
-        {
-            this.objects[k] = this.objects[k].concat(dict[k]);
-        }
-        else
-        {
-            this.objects[k] = dict[k];
-        }
+    for (var k in dict) {
+      if (k in this.objects) {
+        this.objects[k] = this.objects[k].concat(dict[k]);
+      } else {
+        this.objects[k] = dict[k];
+      }
     }
-};
+  };
 
-IdlArray.prototype.prevent_multiple_testing = function(name)
-{
+  IdlArray.prototype.prevent_multiple_testing = function(name) {
     /** Entry point.  See documentation at beginning of file. */
     this.members[name].prevent_multiple_testing = true;
-};
+  };
 
-IdlArray.prototype.recursively_get_implements = function(interface_name)
-{
+  IdlArray.prototype.recursively_get_implements = function(interface_name) {
     /**
      * Helper function for test().  Returns an array of things that implement
      * interface_name, so if the IDL contains
@@ -512,24 +522,22 @@ IdlArray.prototype.recursively_get_implements = function(interface_name)
      *
      * then recursively_get_implements("A") should return ["B", "C", "D"].
      */
-    var ret = this["implements"][interface_name];
-    if (ret === undefined)
-    {
-        return [];
-    }
-    for (var i = 0; i < this["implements"][interface_name].length; i++)
-    {
-        ret = ret.concat(this.recursively_get_implements(ret[i]));
-        if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i]))
-        {
-            throw new IdlHarnessError("Circular implements statements involving " + ret[i]);
-        }
+    var ret = this['implements'][interface_name];
+    if (ret === undefined) {
+      return [];
+    }
+    for (var i = 0; i < this['implements'][interface_name].length; i++) {
+      ret = ret.concat(this.recursively_get_implements(ret[i]));
+      if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i])) {
+        throw new IdlHarnessError(
+          'Circular implements statements involving ' + ret[i]
+        );
+      }
     }
     return ret;
-};
+  };
 
-IdlArray.prototype.recursively_get_includes = function(interface_name)
-{
+  IdlArray.prototype.recursively_get_includes = function(interface_name) {
     /**
      * Helper function for test().  Returns an array of things that implement
      * interface_name, so if the IDL contains
@@ -540,24 +548,22 @@ IdlArray.prototype.recursively_get_includes = function(interface_name)
      *
      * then recursively_get_includes("A") should return ["B", "C", "D"].
      */
-    var ret = this["includes"][interface_name];
-    if (ret === undefined)
-    {
-        return [];
-    }
-    for (var i = 0; i < this["includes"][interface_name].length; i++)
-    {
-        ret = ret.concat(this.recursively_get_includes(ret[i]));
-        if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i]))
-        {
-            throw new IdlHarnessError("Circular includes statements involving " + ret[i]);
-        }
+    var ret = this['includes'][interface_name];
+    if (ret === undefined) {
+      return [];
+    }
+    for (var i = 0; i < this['includes'][interface_name].length; i++) {
+      ret = ret.concat(this.recursively_get_includes(ret[i]));
+      if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i])) {
+        throw new IdlHarnessError(
+          'Circular includes statements involving ' + ret[i]
+        );
+      }
     }
     return ret;
-};
+  };
 
-IdlArray.prototype.is_json_type = function(type)
-{
+  IdlArray.prototype.is_json_type = function(type) {
     /**
      * Checks whether type is a JSON type as per
      * https://heycam.github.io/webidl/#dfn-json-types
@@ -565,382 +571,482 @@ IdlArray.prototype.is_json_type = function(type)
 
     var idlType = type.idlType;
 
-    if (type.generic == "Promise") { return false; }
+    if (type.generic == 'Promise') {
+      return false;
+    }
 
     //  nullable and annotated types don't need to be handled separately,
     //  as webidl2 doesn't represent them wrapped-up (as they're described
     //  in WebIDL).
 
     // union and record types
-    if (type.union || type.generic == "record") {
-        return idlType.every(this.is_json_type, this);
+    if (type.union || type.generic == 'record') {
+      return idlType.every(this.is_json_type, this);
     }
 
     // sequence types
-    if (type.generic == "sequence" || type.generic == "FrozenArray") {
-        return this.is_json_type(idlType);
-    }
-
-    if (typeof idlType != "string") { throw new Error("Unexpected type " + JSON.stringify(idlType)); }
-
-    switch (idlType)
-    {
-       //  Numeric types
-       case "byte":
-       case "octet":
-       case "short":
-       case "unsigned short":
-       case "long":
-       case "unsigned long":
-       case "long long":
-       case "unsigned long long":
-       case "float":
-       case "double":
-       case "unrestricted float":
-       case "unrestricted double":
-       // boolean
-       case "boolean":
-       // string types
-       case "DOMString":
-       case "ByteString":
-       case "USVString":
-       // object type
-       case "object":
-           return true;
-       case "Error":
-       case "DOMException":
-       case "Int8Array":
-       case "Int16Array":
-       case "Int32Array":
-       case "Uint8Array":
-       case "Uint16Array":
-       case "Uint32Array":
-       case "Uint8ClampedArray":
-       case "Float32Array":
-       case "ArrayBuffer":
-       case "DataView":
-       case "any":
-           return false;
-       default:
-           var thing = this.members[idlType];
-           if (!thing) { throw new Error("Type " + idlType + " not found"); }
-           if (thing instanceof IdlEnum) { return true; }
-
-           if (thing instanceof IdlTypedef) {
-               return this.is_json_type(thing.idlType);
-           }
-
-           //  dictionaries where all of their members are JSON types
-           if (thing instanceof IdlDictionary) {
-               var stack = thing.get_inheritance_stack();
-               var map = new Map();
-               while (stack.length)
-               {
-                   stack.pop().members.forEach(function(m) {
-                       map.set(m.name, m.idlType)
-                   });
-               }
-               return Array.from(map.values()).every(this.is_json_type, this);
-           }
-
-           //  interface types that have a toJSON operation declared on themselves or
-           //  one of their inherited or consequential interfaces.
-           if (thing instanceof IdlInterface) {
-               var base;
-               while (thing)
-               {
-                   if (thing.has_to_json_regular_operation()) { return true; }
-                   var mixins = this.implements[thing.name] || this.includes[thing.name];
-                   if (mixins) {
-                       mixins = mixins.map(function(id) {
-                           var mixin = this.members[id];
-                           if (!mixin) {
-                               throw new Error("Interface " + id + " not found (implemented by " + thing.name + ")");
-                           }
-                           return mixin;
-                       }, this);
-                       if (mixins.some(function(m) { return m.has_to_json_regular_operation() } )) { return true; }
-                   }
-                   if (!thing.base) { return false; }
-                   base = this.members[thing.base];
-                   if (!base) {
-                       throw new Error("Interface " + thing.base + " not found (inherited by " + thing.name + ")");
-                   }
-                   thing = base;
-               }
-               return false;
-           }
-           return false;
-    }
-};
-
-function exposure_set(object, default_set) {
-    var exposed = object.extAttrs && object.extAttrs.filter(a => a.name === "Exposed");
+    if (type.generic == 'sequence' || type.generic == 'FrozenArray') {
+      return this.is_json_type(idlType);
+    }
+
+    if (typeof idlType != 'string') {
+      throw new Error('Unexpected type ' + JSON.stringify(idlType));
+    }
+
+    switch (idlType) {
+      //  Numeric types
+      case 'byte':
+      case 'octet':
+      case 'short':
+      case 'unsigned short':
+      case 'long':
+      case 'unsigned long':
+      case 'long long':
+      case 'unsigned long long':
+      case 'float':
+      case 'double':
+      case 'unrestricted float':
+      case 'unrestricted double':
+      // boolean
+      case 'boolean':
+      // string types
+      case 'DOMString':
+      case 'ByteString':
+      case 'USVString':
+      // object type
+      case 'object':
+        return true;
+      case 'Error':
+      case 'DOMException':
+      case 'Int8Array':
+      case 'Int16Array':
+      case 'Int32Array':
+      case 'Uint8Array':
+      case 'Uint16Array':
+      case 'Uint32Array':
+      case 'Uint8ClampedArray':
+      case 'Float32Array':
+      case 'ArrayBuffer':
+      case 'DataView':
+      case 'any':
+        return false;
+      default:
+        var thing = this.members[idlType];
+        if (!thing) {
+          throw new Error('Type ' + idlType + ' not found');
+        }
+        if (thing instanceof IdlEnum) {
+          return true;
+        }
+
+        if (thing instanceof IdlTypedef) {
+          return this.is_json_type(thing.idlType);
+        }
+
+        //  dictionaries where all of their members are JSON types
+        if (thing instanceof IdlDictionary) {
+          var stack = thing.get_inheritance_stack();
+          var map = new Map();
+          while (stack.length) {
+            stack.pop().members.forEach(function(m) {
+              map.set(m.name, m.idlType);
+            });
+          }
+          return Array.from(map.values()).every(this.is_json_type, this);
+        }
+
+        //  interface types that have a toJSON operation declared on themselves or
+        //  one of their inherited or consequential interfaces.
+        if (thing instanceof IdlInterface) {
+          var base;
+          while (thing) {
+            if (thing.has_to_json_regular_operation()) {
+              return true;
+            }
+            var mixins =
+              this.implements[thing.name] || this.includes[thing.name];
+            if (mixins) {
+              mixins = mixins.map(function(id) {
+                var mixin = this.members[id];
+                if (!mixin) {
+                  throw new Error(
+                    'Interface ' +
+                      id +
+                      ' not found (implemented by ' +
+                      thing.name +
+                      ')'
+                  );
+                }
+                return mixin;
+              }, this);
+              if (
+                mixins.some(function(m) {
+                  return m.has_to_json_regular_operation();
+                })
+              ) {
+                return true;
+              }
+            }
+            if (!thing.base) {
+              return false;
+            }
+            base = this.members[thing.base];
+            if (!base) {
+              throw new Error(
+                'Interface ' +
+                  thing.base +
+                  ' not found (inherited by ' +
+                  thing.name +
+                  ')'
+              );
+            }
+            thing = base;
+          }
+          return false;
+        }
+        return false;
+    }
+  };
+
+  function exposure_set(object, default_set) {
+    var exposed =
+      object.extAttrs && object.extAttrs.filter((a) => a.name === 'Exposed');
     if (exposed && exposed.length > 1) {
-        throw new IdlHarnessError(
-            `Multiple 'Exposed' extended attributes on ${object.name}`);
+      throw new IdlHarnessError(
+        `Multiple 'Exposed' extended attributes on ${object.name}`
+      );
     }
 
-    let result = default_set || ["Window"];
+    let result = default_set || ['Window'];
     if (result && !(result instanceof Set)) {
-        result = new Set(result);
+      result = new Set(result);
     }
     if (exposed && exposed.length) {
-        var set = exposed[0].rhs.value;
-        // Could be a list or a string.
-        if (typeof set == "string") {
-            set = [ set ];
-        }
-        result = new Set(set);
+      var set = exposed[0].rhs.value;
+      // Could be a list or a string.
+      if (typeof set == 'string') {
+        set = [set];
+      }
+      result = new Set(set);
     }
-    if (result && result.has("Worker")) {
-        result.delete("Worker");
-        result.add("DedicatedWorker");
-        result.add("ServiceWorker");
-        result.add("SharedWorker");
+    if (result && result.has('Worker')) {
+      result.delete('Worker');
+      result.add('DedicatedWorker');
+      result.add('ServiceWorker');
+      result.add('SharedWorker');
     }
     return result;
-}
+  }
 
-function exposed_in(globals) {
+  function exposed_in(globals) {
     if ('document' in self) {
-        return globals.has("Window");
+      return globals.has('Window');
     }
-    if ('DedicatedWorkerGlobalScope' in self &&
-        self instanceof DedicatedWorkerGlobalScope) {
-        return globals.has("DedicatedWorker");
+    if (
+      'DedicatedWorkerGlobalScope' in self &&
+      self instanceof DedicatedWorkerGlobalScope
+    ) {
+      return globals.has('DedicatedWorker');
     }
-    if ('SharedWorkerGlobalScope' in self &&
-        self instanceof SharedWorkerGlobalScope) {
-        return globals.has("SharedWorker");
+    if (
+      'SharedWorkerGlobalScope' in self &&
+      self instanceof SharedWorkerGlobalScope
+    ) {
+      return globals.has('SharedWorker');
     }
-    if ('ServiceWorkerGlobalScope' in self &&
-        self instanceof ServiceWorkerGlobalScope) {
-        return globals.has("ServiceWorker");
+    if (
+      'ServiceWorkerGlobalScope' in self &&
+      self instanceof ServiceWorkerGlobalScope
+    ) {
+      return globals.has('ServiceWorker');
     }
-    throw new IdlHarnessError("Unexpected global object");
-}
-
-/**
- * Asserts that the given error message is thrown for the given function.
- * @param {string|IdlHarnessError} error Expected Error message.
- * @param {Function} idlArrayFunc Function operating on an IdlArray that should throw.
- */
-IdlArray.prototype.assert_throws = function(error, idlArrayFunc)
-{
+    throw new IdlHarnessError('Unexpected global object');
+  }
+
+  /**
+   * Asserts that the given error message is thrown for the given function.
+   * @param {string|IdlHarnessError} error Expected Error message.
+   * @param {Function} idlArrayFunc Function operating on an IdlArray that should throw.
+   */
+  IdlArray.prototype.assert_throws = function(error, idlArrayFunc) {
     try {
-        idlArrayFunc.call(this, this);
+      idlArrayFunc.call(this, this);
     } catch (e) {
-        if (e instanceof AssertionError) {
-            throw e;
-        }
-        // Assertions for behaviour of the idlharness.js engine.
-        if (error instanceof IdlHarnessError) {
-            error = error.message;
-        }
-        if (e.message !== error) {
-            throw new IdlHarnessError(`${idlArrayFunc} threw "${e}", not the expected IdlHarnessError "${error}"`);
-        }
-        return;
+      if (e instanceof AssertionError) {
+        throw e;
+      }
+      // Assertions for behaviour of the idlharness.js engine.
+      if (error instanceof IdlHarnessError) {
+        error = error.message;
+      }
+      if (e.message !== error) {
+        throw new IdlHarnessError(
+          `${idlArrayFunc} threw "${e}", not the expected IdlHarnessError "${error}"`
+        );
+      }
+      return;
     }
-    throw new IdlHarnessError(`${idlArrayFunc} did not throw the expected IdlHarnessError`);
-}
+    throw new IdlHarnessError(
+      `${idlArrayFunc} did not throw the expected IdlHarnessError`
+    );
+  };
 
-IdlArray.prototype.test = function()
-{
+  IdlArray.prototype.test = function() {
     /** Entry point.  See documentation at beginning of file. */
 
     // First merge in all the partial interfaces and implements statements we
     // encountered.
     this.collapse_partials();
 
-    for (var lhs in this["implements"])
-    {
-        this.recursively_get_implements(lhs).forEach(function(rhs)
-        {
-            var errStr = lhs + " implements " + rhs + ", but ";
-            if (!(lhs in this.members)) throw errStr + lhs + " is undefined.";
-            if (!(this.members[lhs] instanceof IdlInterface)) throw errStr + lhs + " is not an interface.";
-            if (!(rhs in this.members)) throw errStr + rhs + " is undefined.";
-            if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface.";
-            this.members[rhs].members.forEach(function(member)
-            {
-                this.members[lhs].members.push(new IdlInterfaceMember(member));
-            }.bind(this));
-        }.bind(this));
-    }
-    this["implements"] = {};
-
-    for (var lhs in this["includes"])
-    {
-        this.recursively_get_includes(lhs).forEach(function(rhs)
-        {
-            var errStr = lhs + " includes " + rhs + ", but ";
-            if (!(lhs in this.members)) throw errStr + lhs + " is undefined.";
-            if (!(this.members[lhs] instanceof IdlInterface)) throw errStr + lhs + " is not an interface.";
-            if (!(rhs in this.members)) throw errStr + rhs + " is undefined.";
-            if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface.";
-            this.members[rhs].members.forEach(function(member)
-            {
-                this.members[lhs].members.push(new IdlInterfaceMember(member));
-            }.bind(this));
-        }.bind(this));
-    }
-    this["includes"] = {};
+    for (var lhs in this['implements']) {
+      this.recursively_get_implements(lhs).forEach(
+        function(rhs) {
+          var errStr = lhs + ' implements ' + rhs + ', but ';
+          if (!(lhs in this.members)) throw errStr + lhs + ' is undefined.';
+          if (!(this.members[lhs] instanceof IdlInterface))
+            throw errStr + lhs + ' is not an interface.';
+          if (!(rhs in this.members)) throw errStr + rhs + ' is undefined.';
+          if (!(this.members[rhs] instanceof IdlInterface))
+            throw errStr + rhs + ' is not an interface.';
+          this.members[rhs].members.forEach(
+            function(member) {
+              this.members[lhs].members.push(new IdlInterfaceMember(member));
+            }.bind(this)
+          );
+        }.bind(this)
+      );
+    }
+    this['implements'] = {};
+
+    for (var lhs in this['includes']) {
+      this.recursively_get_includes(lhs).forEach(
+        function(rhs) {
+          var errStr = lhs + ' includes ' + rhs + ', but ';
+          if (!(lhs in this.members)) throw errStr + lhs + ' is undefined.';
+          if (!(this.members[lhs] instanceof IdlInterface))
+            throw errStr + lhs + ' is not an interface.';
+          if (!(rhs in this.members)) throw errStr + rhs + ' is undefined.';
+          if (!(this.members[rhs] instanceof IdlInterface))
+            throw errStr + rhs + ' is not an interface.';
+          this.members[rhs].members.forEach(
+            function(member) {
+              this.members[lhs].members.push(new IdlInterfaceMember(member));
+            }.bind(this)
+          );
+        }.bind(this)
+      );
+    }
+    this['includes'] = {};
 
     // Assert B defined for A : B
-    for (const member of Object.values(this.members).filter(m => m.base)) {
-        const lhs = member.name;
-        const rhs = member.base;
-        if (!(rhs in this.members)) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${rhs} is undefined.`);
-        const lhs_is_interface = this.members[lhs] instanceof IdlInterface;
-        const rhs_is_interface = this.members[rhs] instanceof IdlInterface;
-        if (rhs_is_interface != lhs_is_interface) {
-            if (!lhs_is_interface) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${lhs} is not an interface.`);
-            if (!rhs_is_interface) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${rhs} is not an interface.`);
-        }
-        // Check for circular dependencies.
-        member.get_inheritance_stack();
+    for (const member of Object.values(this.members).filter((m) => m.base)) {
+      const lhs = member.name;
+      const rhs = member.base;
+      if (!(rhs in this.members))
+        throw new IdlHarnessError(
+          `${lhs} inherits ${rhs}, but ${rhs} is undefined.`
+        );
+      const lhs_is_interface = this.members[lhs] instanceof IdlInterface;
+      const rhs_is_interface = this.members[rhs] instanceof IdlInterface;
+      if (rhs_is_interface != lhs_is_interface) {
+        if (!lhs_is_interface)
+          throw new IdlHarnessError(
+            `${lhs} inherits ${rhs}, but ${lhs} is not an interface.`
+          );
+        if (!rhs_is_interface)
+          throw new IdlHarnessError(
+            `${lhs} inherits ${rhs}, but ${rhs} is not an interface.`
+          );
+      }
+      // Check for circular dependencies.
+      member.get_inheritance_stack();
     }
 
-    Object.getOwnPropertyNames(this.members).forEach(function(memberName) {
+    Object.getOwnPropertyNames(this.members).forEach(
+      function(memberName) {
         var member = this.members[memberName];
         if (!(member instanceof IdlInterface)) {
-            return;
+          return;
         }
 
         var globals = exposure_set(member);
         member.exposed = exposed_in(globals);
         member.exposureSet = globals;
-    }.bind(this));
+      }.bind(this)
+    );
 
     // Now run test() on every member, and test_object() for every object.
-    for (var name in this.members)
-    {
-        this.members[name].test();
-        if (name in this.objects)
-        {
-            const objects = this.objects[name];
-            if (!objects || !Array.isArray(objects)) {
-                throw new IdlHarnessError(`Invalid or empty objects for member ${name}`);
-            }
-            objects.forEach(function(str)
-            {
-                if (!this.members[name] || !(this.members[name] instanceof IdlInterface)) {
-                    throw new IdlHarnessError(`Invalid object member name ${name}`);
-                }
-                this.members[name].test_object(str);
-            }.bind(this));
+    for (var name in this.members) {
+      this.members[name].test();
+      if (name in this.objects) {
+        const objects = this.objects[name];
+        if (!objects || !Array.isArray(objects)) {
+          throw new IdlHarnessError(
+            `Invalid or empty objects for member ${name}`
+          );
         }
+        objects.forEach(
+          function(str) {
+            if (
+              !this.members[name] ||
+              !(this.members[name] instanceof IdlInterface)
+            ) {
+              throw new IdlHarnessError(`Invalid object member name ${name}`);
+            }
+            this.members[name].test_object(str);
+          }.bind(this)
+        );
+      }
     }
-};
+  };
 
-IdlArray.prototype.collapse_partials = function()
-{
+  IdlArray.prototype.collapse_partials = function() {
     const testedPartials = new Map();
-    this.partials.forEach(function(parsed_idl)
-    {
-        const originalExists = parsed_idl.name in this.members
-            && (this.members[parsed_idl.name] instanceof IdlInterface
-                || this.members[parsed_idl.name] instanceof IdlDictionary
-                || this.members[parsed_idl.name] instanceof IdlNamespace);
+    this.partials.forEach(
+      function(parsed_idl) {
+        const originalExists =
+          parsed_idl.name in this.members &&
+          (this.members[parsed_idl.name] instanceof IdlInterface ||
+            this.members[parsed_idl.name] instanceof IdlDictionary ||
+            this.members[parsed_idl.name] instanceof IdlNamespace);
 
         let partialTestName = parsed_idl.name;
         if (!parsed_idl.untested) {
-            // Ensure unique test name in case of multiple partials.
-            let partialTestCount = 1;
-            if (testedPartials.has(parsed_idl.name)) {
-                partialTestCount += testedPartials.get(parsed_idl.name);
-                partialTestName = `${partialTestName}[${partialTestCount}]`;
-            }
-            testedPartials.set(parsed_idl.name, partialTestCount);
-
-            test(function () {
-                assert_true(originalExists, `Original ${parsed_idl.type} should be defined`);
-
-                var expected = IdlInterface;
-                switch (parsed_idl.type) {
-                    case 'interface': expected = IdlInterface; break;
-                    case 'dictionary': expected = IdlDictionary; break;
-                    case 'namespace': expected = IdlNamespace; break;
-                }
-                assert_true(
-                    expected.prototype.isPrototypeOf(this.members[parsed_idl.name]),
-                    `Original ${parsed_idl.name} definition should have type ${parsed_idl.type}`);
-            }.bind(this), `Partial ${parsed_idl.type} ${partialTestName}: original ${parsed_idl.type} defined`);
+          // Ensure unique test name in case of multiple partials.
+          let partialTestCount = 1;
+          if (testedPartials.has(parsed_idl.name)) {
+            partialTestCount += testedPartials.get(parsed_idl.name);
+            partialTestName = `${partialTestName}[${partialTestCount}]`;
+          }
+          testedPartials.set(parsed_idl.name, partialTestCount);
+
+          test(
+            function() {
+              assert_true(
+                originalExists,
+                `Original ${parsed_idl.type} should be defined`
+              );
+
+              var expected = IdlInterface;
+              switch (parsed_idl.type) {
+                case 'interface':
+                  expected = IdlInterface;
+                  break;
+                case 'dictionary':
+                  expected = IdlDictionary;
+                  break;
+                case 'namespace':
+                  expected = IdlNamespace;
+                  break;
+              }
+              assert_true(
+                expected.prototype.isPrototypeOf(this.members[parsed_idl.name]),
+                `Original ${parsed_idl.name} definition should have type ${
+                  parsed_idl.type
+                }`
+              );
+            }.bind(this),
+            `Partial ${parsed_idl.type} ${partialTestName}: original ${
+              parsed_idl.type
+            } defined`
+          );
         }
         if (!originalExists) {
-            // Not good.. but keep calm and carry on.
-            return;
+          // Not good.. but keep calm and carry on.
+          return;
         }
 
-        if (parsed_idl.extAttrs)
-        {
-            // Special-case "Exposed". Must be a subset of original interface's exposure.
-            // Exposed on a partial is the equivalent of having the same Exposed on all nested members.
-            // See https://github.com/heycam/webidl/issues/154 for discrepency between Exposed and
-            // other extended attributes on partial interfaces.
-            const exposureAttr = parsed_idl.extAttrs.find(a => a.name === "Exposed");
-            if (exposureAttr) {
-                if (!parsed_idl.untested) {
-                    test(function () {
-                        const partialExposure = exposure_set(parsed_idl);
-                        const memberExposure = exposure_set(this.members[parsed_idl.name]);
-                        partialExposure.forEach(name => {
-                            if (!memberExposure || !memberExposure.has(name)) {
-                                throw new IdlHarnessError(
-                                    `Partial ${parsed_idl.name} ${parsed_idl.type} is exposed to '${name}', the original ${parsed_idl.type} is not.`);
-                            }
-                        });
-                    }.bind(this), `Partial ${parsed_idl.type} ${partialTestName}: valid exposure set`);
-                }
-                parsed_idl.members.forEach(function (member) {
-                    member.extAttrs.push(exposureAttr);
-                }.bind(this));
+        if (parsed_idl.extAttrs) {
+          // Special-case "Exposed". Must be a subset of original interface's exposure.
+          // Exposed on a partial is the equivalent of having the same Exposed on all nested members.
+          // See https://github.com/heycam/webidl/issues/154 for discrepency between Exposed and
+          // other extended attributes on partial interfaces.
+          const exposureAttr = parsed_idl.extAttrs.find(
+            (a) => a.name === 'Exposed'
+          );
+          if (exposureAttr) {
+            if (!parsed_idl.untested) {
+              test(
+                function() {
+                  const partialExposure = exposure_set(parsed_idl);
+                  const memberExposure = exposure_set(
+                    this.members[parsed_idl.name]
+                  );
+                  partialExposure.forEach((name) => {
+                    if (!memberExposure || !memberExposure.has(name)) {
+                      throw new IdlHarnessError(
+                        `Partial ${parsed_idl.name} ${
+                          parsed_idl.type
+                        } is exposed to '${name}', the original ${
+                          parsed_idl.type
+                        } is not.`
+                      );
+                    }
+                  });
+                }.bind(this),
+                `Partial ${
+                  parsed_idl.type
+                } ${partialTestName}: valid exposure set`
+              );
             }
+            parsed_idl.members.forEach(
+              function(member) {
+                member.extAttrs.push(exposureAttr);
+              }.bind(this)
+            );
+          }
 
-            parsed_idl.extAttrs.forEach(function(extAttr)
-            {
-                // "Exposed" already handled above.
-                if (extAttr.name === "Exposed") {
-                    return;
-                }
-                this.members[parsed_idl.name].extAttrs.push(extAttr);
-            }.bind(this));
+          parsed_idl.extAttrs.forEach(
+            function(extAttr) {
+              // "Exposed" already handled above.
+              if (extAttr.name === 'Exposed') {
+                return;
+              }
+              this.members[parsed_idl.name].extAttrs.push(extAttr);
+            }.bind(this)
+          );
         }
-        parsed_idl.members.forEach(function(member)
-        {
-            this.members[parsed_idl.name].members.push(new IdlInterfaceMember(member));
-        }.bind(this));
-    }.bind(this));
+        parsed_idl.members.forEach(
+          function(member) {
+            this.members[parsed_idl.name].members.push(
+              new IdlInterfaceMember(member)
+            );
+          }.bind(this)
+        );
+      }.bind(this)
+    );
     this.partials = [];
-}
-
-IdlArray.prototype.assert_type_is = function(value, type)
-{
-    if (type.idlType in this.members
-    && this.members[type.idlType] instanceof IdlTypedef) {
-        this.assert_type_is(value, this.members[type.idlType].idlType);
-        return;
+  };
+
+  IdlArray.prototype.assert_type_is = function(value, type) {
+    if (
+      type.idlType in this.members &&
+      this.members[type.idlType] instanceof IdlTypedef
+    ) {
+      this.assert_type_is(value, this.members[type.idlType].idlType);
+      return;
     }
     if (type.union) {
-        for (var i = 0; i < type.idlType.length; i++) {
-            try {
-                this.assert_type_is(value, type.idlType[i]);
-                // No AssertionError, so we match one type in the union
-                return;
-            } catch(e) {
-                if (e instanceof AssertionError) {
-                    // We didn't match this type, let's try some others
-                    continue;
-                }
-                throw e;
-            }
+      for (var i = 0; i < type.idlType.length; i++) {
+        try {
+          this.assert_type_is(value, type.idlType[i]);
+          // No AssertionError, so we match one type in the union
+          return;
+        } catch (e) {
+          if (e instanceof AssertionError) {
+            // We didn't match this type, let's try some others
+            continue;
+          }
+          throw e;
         }
-        // TODO: Is there a nice way to list the union's types in the message?
-        assert_true(false, "Attribute has value " + format_value(value)
-                    + " which doesn't match any of the types in the union");
-
+      }
+      // TODO: Is there a nice way to list the union's types in the message?
+      assert_true(
+        false,
+        'Attribute has value ' +
+          format_value(value) +
+          " which doesn't match any of the types in the union"
+      );
     }
 
     /**
@@ -950,219 +1056,242 @@ IdlArray.prototype.assert_type_is = function(value, type)
      * is fairly elaborate due to the complexity of WebIDL's types, so it's
      * best to look at the grammar to figure out what properties it might have.
      */
-    if (type.idlType == "any")
-    {
-        // No assertions to make
-        return;
+    if (type.idlType == 'any') {
+      // No assertions to make
+      return;
     }
 
-    if (type.nullable && value === null)
-    {
-        // This is fine
-        return;
+    if (type.nullable && value === null) {
+      // This is fine
+      return;
     }
 
-    if (type.array)
-    {
-        // TODO: not supported yet
-        return;
+    if (type.array) {
+      // TODO: not supported yet
+      return;
     }
 
-    if (type.generic === "sequence")
-    {
-        assert_true(Array.isArray(value), "should be an Array");
-        if (!value.length)
-        {
-            // Nothing we can do.
-            return;
-        }
-        this.assert_type_is(value[0], type.idlType);
+    if (type.generic === 'sequence') {
+      assert_true(Array.isArray(value), 'should be an Array');
+      if (!value.length) {
+        // Nothing we can do.
         return;
+      }
+      this.assert_type_is(value[0], type.idlType);
+      return;
     }
 
-    if (type.generic === "Promise") {
-        assert_true("then" in value, "Attribute with a Promise type should have a then property");
-        // TODO: Ideally, we would check on project fulfillment
-        // that we get the right type
-        // but that would require making the type check async
-        return;
+    if (type.generic === 'Promise') {
+      assert_true(
+        'then' in value,
+        'Attribute with a Promise type should have a then property'
+      );
+      // TODO: Ideally, we would check on project fulfillment
+      // that we get the right type
+      // but that would require making the type check async
+      return;
     }
 
-    if (type.generic === "FrozenArray") {
-        assert_true(Array.isArray(value), "Value should be array");
-        assert_true(Object.isFrozen(value), "Value should be frozen");
-        if (!value.length)
-        {
-            // Nothing we can do.
-            return;
-        }
-        this.assert_type_is(value[0], type.idlType);
+    if (type.generic === 'FrozenArray') {
+      assert_true(Array.isArray(value), 'Value should be array');
+      assert_true(Object.isFrozen(value), 'Value should be frozen');
+      if (!value.length) {
+        // Nothing we can do.
         return;
+      }
+      this.assert_type_is(value[0], type.idlType);
+      return;
     }
 
     type = type.idlType;
 
-    switch(type)
-    {
-        case "void":
-            assert_equals(value, undefined);
-            return;
+    switch (type) {
+      case 'void':
+        assert_equals(value, undefined);
+        return;
 
-        case "boolean":
-            assert_equals(typeof value, "boolean");
-            return;
+      case 'boolean':
+        assert_equals(typeof value, 'boolean');
+        return;
 
-        case "byte":
-            assert_equals(typeof value, "number");
-            assert_equals(value, Math.floor(value), "should be an integer");
-            assert_true(-128 <= value && value <= 127, "byte " + value + " should be in range [-128, 127]");
-            return;
+      case 'byte':
+        assert_equals(typeof value, 'number');
+        assert_equals(value, Math.floor(value), 'should be an integer');
+        assert_true(
+          -128 <= value && value <= 127,
+          'byte ' + value + ' should be in range [-128, 127]'
+        );
+        return;
 
-        case "octet":
-            assert_equals(typeof value, "number");
-            assert_equals(value, Math.floor(value), "should be an integer");
-            assert_true(0 <= value && value <= 255, "octet " + value + " should be in range [0, 255]");
-            return;
+      case 'octet':
+        assert_equals(typeof value, 'number');
+        assert_equals(value, Math.floor(value), 'should be an integer');
+        assert_true(
+          0 <= value && value <= 255,
+          'octet ' + value + ' should be in range [0, 255]'
+        );
+        return;
 
-        case "short":
-            assert_equals(typeof value, "number");
-            assert_equals(value, Math.floor(value), "should be an integer");
-            assert_true(-32768 <= value && value <= 32767, "short " + value + " should be in range [-32768, 32767]");
-            return;
+      case 'short':
+        assert_equals(typeof value, 'number');
+        assert_equals(value, Math.floor(value), 'should be an integer');
+        assert_true(
+          -32768 <= value && value <= 32767,
+          'short ' + value + ' should be in range [-32768, 32767]'
+        );
+        return;
 
-        case "unsigned short":
-            assert_equals(typeof value, "number");
-            assert_equals(value, Math.floor(value), "should be an integer");
-            assert_true(0 <= value && value <= 65535, "unsigned short " + value + " should be in range [0, 65535]");
-            return;
+      case 'unsigned short':
+        assert_equals(typeof value, 'number');
+        assert_equals(value, Math.floor(value), 'should be an integer');
+        assert_true(
+          0 <= value && value <= 65535,
+          'unsigned short ' + value + ' should be in range [0, 65535]'
+        );
+        return;
 
-        case "long":
-            assert_equals(typeof value, "number");
-            assert_equals(value, Math.floor(value), "should be an integer");
-            assert_true(-2147483648 <= value && value <= 2147483647, "long " + value + " should be in range [-2147483648, 2147483647]");
-            return;
+      case 'long':
+        assert_equals(typeof value, 'number');
+        assert_equals(value, Math.floor(value), 'should be an integer');
+        assert_true(
+          -2147483648 <= value && value <= 2147483647,
+          'long ' + value + ' should be in range [-2147483648, 2147483647]'
+        );
+        return;
 
-        case "unsigned long":
-            assert_equals(typeof value, "number");
-            assert_equals(value, Math.floor(value), "should be an integer");
-            assert_true(0 <= value && value <= 4294967295, "unsigned long " + value + " should be in range [0, 4294967295]");
-            return;
+      case 'unsigned long':
+        assert_equals(typeof value, 'number');
+        assert_equals(value, Math.floor(value), 'should be an integer');
+        assert_true(
+          0 <= value && value <= 4294967295,
+          'unsigned long ' + value + ' should be in range [0, 4294967295]'
+        );
+        return;
 
-        case "long long":
-            assert_equals(typeof value, "number");
-            return;
+      case 'long long':
+        assert_equals(typeof value, 'number');
+        return;
 
-        case "unsigned long long":
-        case "DOMTimeStamp":
-            assert_equals(typeof value, "number");
-            assert_true(0 <= value, "unsigned long long should be positive");
-            return;
+      case 'unsigned long long':
+      case 'DOMTimeStamp':
+        assert_equals(typeof value, 'number');
+        assert_true(0 <= value, 'unsigned long long should be positive');
+        return;
 
-        case "float":
-            assert_equals(typeof value, "number");
-            assert_equals(value, fround(value), "float rounded to 32-bit float should be itself");
-            assert_not_equals(value, Infinity);
-            assert_not_equals(value, -Infinity);
-            assert_not_equals(value, NaN);
-            return;
+      case 'float':
+        assert_equals(typeof value, 'number');
+        assert_equals(
+          value,
+          fround(value),
+          'float rounded to 32-bit float should be itself'
+        );
+        assert_not_equals(value, Infinity);
+        assert_not_equals(value, -Infinity);
+        assert_not_equals(value, NaN);
+        return;
 
-        case "DOMHighResTimeStamp":
-        case "double":
-            assert_equals(typeof value, "number");
-            assert_not_equals(value, Infinity);
-            assert_not_equals(value, -Infinity);
-            assert_not_equals(value, NaN);
-            return;
+      case 'DOMHighResTimeStamp':
+      case 'double':
+        assert_equals(typeof value, 'number');
+        assert_not_equals(value, Infinity);
+        assert_not_equals(value, -Infinity);
+        assert_not_equals(value, NaN);
+        return;
 
-        case "unrestricted float":
-            assert_equals(typeof value, "number");
-            assert_equals(value, fround(value), "unrestricted float rounded to 32-bit float should be itself");
-            return;
+      case 'unrestricted float':
+        assert_equals(typeof value, 'number');
+        assert_equals(
+          value,
+          fround(value),
+          'unrestricted float rounded to 32-bit float should be itself'
+        );
+        return;
 
-        case "unrestricted double":
-            assert_equals(typeof value, "number");
-            return;
+      case 'unrestricted double':
+        assert_equals(typeof value, 'number');
+        return;
 
-        case "DOMString":
-            assert_equals(typeof value, "string");
-            return;
+      case 'DOMString':
+        assert_equals(typeof value, 'string');
+        return;
 
-        case "ByteString":
-            assert_equals(typeof value, "string");
-            assert_regexp_match(value, /^[\x00-\x7F]*$/);
-            return;
+      case 'ByteString':
+        assert_equals(typeof value, 'string');
+        assert_regexp_match(value, /^[\x00-\x7F]*$/);
+        return;
 
-        case "USVString":
-            assert_equals(typeof value, "string");
-            assert_regexp_match(value, /^([\x00-\ud7ff\ue000-\uffff]|[\ud800-\udbff][\udc00-\udfff])*$/);
-            return;
+      case 'USVString':
+        assert_equals(typeof value, 'string');
+        assert_regexp_match(
+          value,
+          /^([\x00-\ud7ff\ue000-\uffff]|[\ud800-\udbff][\udc00-\udfff])*$/
+        );
+        return;
 
-        case "object":
-            assert_in_array(typeof value, ["object", "function"], "wrong type: not object or function");
-            return;
+      case 'object':
+        assert_in_array(
+          typeof value,
+          ['object', 'function'],
+          'wrong type: not object or function'
+        );
+        return;
     }
 
-    if (!(type in this.members))
-    {
-        throw new IdlHarnessError("Unrecognized type " + type);
-    }
-
-    if (this.members[type] instanceof IdlInterface)
-    {
-        // We don't want to run the full
-        // IdlInterface.prototype.test_instance_of, because that could result
-        // in an infinite loop.  TODO: This means we don't have tests for
-        // NoInterfaceObject interfaces, and we also can't test objects that
-        // come from another self.
-        assert_in_array(typeof value, ["object", "function"], "wrong type: not object or function");
-        if (value instanceof Object
-        && !this.members[type].has_extended_attribute("NoInterfaceObject")
-        && type in self)
-        {
-            assert_true(value instanceof self[type], "instanceof " + type);
-        }
+    if (!(type in this.members)) {
+      throw new IdlHarnessError('Unrecognized type ' + type);
     }
-    else if (this.members[type] instanceof IdlEnum)
-    {
-        assert_equals(typeof value, "string");
-    }
-    else if (this.members[type] instanceof IdlDictionary)
-    {
-        // TODO: Test when we actually have something to test this on
-    }
-    else
-    {
-        throw new IdlHarnessError("Type " + type + " isn't an interface or dictionary");
+
+    if (this.members[type] instanceof IdlInterface) {
+      // We don't want to run the full
+      // IdlInterface.prototype.test_instance_of, because that could result
+      // in an infinite loop.  TODO: This means we don't have tests for
+      // NoInterfaceObject interfaces, and we also can't test objects that
+      // come from another self.
+      assert_in_array(
+        typeof value,
+        ['object', 'function'],
+        'wrong type: not object or function'
+      );
+      if (
+        value instanceof Object &&
+        !this.members[type].has_extended_attribute('NoInterfaceObject') &&
+        type in self
+      ) {
+        assert_true(value instanceof self[type], 'instanceof ' + type);
+      }
+    } else if (this.members[type] instanceof IdlEnum) {
+      assert_equals(typeof value, 'string');
+    } else if (this.members[type] instanceof IdlDictionary) {
+      // TODO: Test when we actually have something to test this on
+    } else {
+      throw new IdlHarnessError(
+        'Type ' + type + " isn't an interface or dictionary"
+      );
     }
-};
+  };
 
-/// IdlObject ///
-function IdlObject() {}
-IdlObject.prototype.test = function()
-{
+  /// IdlObject ///
+  function IdlObject() {}
+  IdlObject.prototype.test = function() {
     /**
      * By default, this does nothing, so no actual tests are run for IdlObjects
      * that don't define any (e.g., IdlDictionary at the time of this writing).
      */
-};
+  };
 
-IdlObject.prototype.has_extended_attribute = function(name)
-{
+  IdlObject.prototype.has_extended_attribute = function(name) {
     /**
      * This is only meaningful for things that support extended attributes,
      * such as interfaces, exceptions, and members.
      */
-    return this.extAttrs.some(function(o)
-    {
-        return o.name == name;
+    return this.extAttrs.some(function(o) {
+      return o.name == name;
     });
-};
-
+  };
 
-/// IdlDictionary ///
-// Used for IdlArray.prototype.assert_type_is
-function IdlDictionary(obj)
-{
+  /// IdlDictionary ///
+  // Used for IdlArray.prototype.assert_type_is
+  function IdlDictionary(obj) {
     /**
      * obj is an object produced by the WebIDLParser.js "dictionary"
      * production.
@@ -1182,17 +1311,16 @@ function IdlDictionary(obj)
      * if there is none.
      */
     this.base = obj.inheritance;
-}
+  }
 
-IdlDictionary.prototype = Object.create(IdlObject.prototype);
+  IdlDictionary.prototype = Object.create(IdlObject.prototype);
 
-IdlDictionary.prototype.get_inheritance_stack = function() {
+  IdlDictionary.prototype.get_inheritance_stack = function() {
     return IdlInterface.prototype.get_inheritance_stack.call(this);
-};
+  };
 
-/// IdlInterface ///
-function IdlInterface(obj, is_callback, is_mixin)
-{
+  /// IdlInterface ///
+  function IdlInterface(obj, is_callback, is_mixin) {
     /**
      * obj is an object produced by the WebIDLParser.js "interface" production.
      */
@@ -1214,11 +1342,19 @@ function IdlInterface(obj, is_callback, is_mixin)
     this.extAttrs = obj.extAttrs;
 
     /** An array of IdlInterfaceMembers. */
-    this.members = obj.members.map(function(m){return new IdlInterfaceMember(m); });
-    if (this.has_extended_attribute("Unforgeable")) {
-        this.members
-            .filter(function(m) { return !m["static"] && (m.type == "attribute" || m.type == "operation"); })
-            .forEach(function(m) { return m.isUnforgeable = true; });
+    this.members = obj.members.map(function(m) {
+      return new IdlInterfaceMember(m);
+    });
+    if (this.has_extended_attribute('Unforgeable')) {
+      this.members
+        .filter(function(m) {
+          return (
+            !m['static'] && (m.type == 'attribute' || m.type == 'operation')
+          );
+        })
+        .forEach(function(m) {
+          return (m.isUnforgeable = true);
+        });
     }
 
     /**
@@ -1229,94 +1365,94 @@ function IdlInterface(obj, is_callback, is_mixin)
 
     this._is_callback = is_callback;
     this._is_mixin = is_mixin;
-}
-IdlInterface.prototype = Object.create(IdlObject.prototype);
-IdlInterface.prototype.is_callback = function()
-{
+  }
+  IdlInterface.prototype = Object.create(IdlObject.prototype);
+  IdlInterface.prototype.is_callback = function() {
     return this._is_callback;
-};
+  };
 
-IdlInterface.prototype.is_mixin = function()
-{
+  IdlInterface.prototype.is_mixin = function() {
     return this._is_mixin;
-};
+  };
 
-IdlInterface.prototype.has_constants = function()
-{
+  IdlInterface.prototype.has_constants = function() {
     return this.members.some(function(member) {
-        return member.type === "const";
+      return member.type === 'const';
     });
-};
+  };
 
-IdlInterface.prototype.get_unscopables = function()
-{
+  IdlInterface.prototype.get_unscopables = function() {
     return this.members.filter(function(member) {
-        return member.isUnscopable;
+      return member.isUnscopable;
     });
-};
+  };
 
-IdlInterface.prototype.is_global = function()
-{
+  IdlInterface.prototype.is_global = function() {
     return this.extAttrs.some(function(attribute) {
-        return attribute.name === "Global";
+      return attribute.name === 'Global';
     });
-};
-
-/**
- * Value of the LegacyNamespace extended attribute, if any.
- *
- * https://heycam.github.io/webidl/#LegacyNamespace
- */
-IdlInterface.prototype.get_legacy_namespace = function()
-{
+  };
+
+  /**
+   * Value of the LegacyNamespace extended attribute, if any.
+   *
+   * https://heycam.github.io/webidl/#LegacyNamespace
+   */
+  IdlInterface.prototype.get_legacy_namespace = function() {
     var legacyNamespace = this.extAttrs.find(function(attribute) {
-        return attribute.name === "LegacyNamespace";
+      return attribute.name === 'LegacyNamespace';
     });
     return legacyNamespace ? legacyNamespace.rhs.value : undefined;
-};
+  };
 
-IdlInterface.prototype.get_interface_object_owner = function()
-{
+  IdlInterface.prototype.get_interface_object_owner = function() {
     var legacyNamespace = this.get_legacy_namespace();
     return legacyNamespace ? self[legacyNamespace] : self;
-};
-
-IdlInterface.prototype.assert_interface_object_exists = function()
-{
-    var owner = this.get_legacy_namespace() || "self";
-    assert_own_property(self[owner], this.name, owner + " does not have own property " + format_value(this.name));
-};
-
-IdlInterface.prototype.get_interface_object = function() {
-    if (this.has_extended_attribute("NoInterfaceObject")) {
-        throw new IdlHarnessError(this.name + " has no interface object due to NoInterfaceObject");
+  };
+
+  IdlInterface.prototype.assert_interface_object_exists = function() {
+    var owner = this.get_legacy_namespace() || 'self';
+    assert_own_property(
+      self[owner],
+      this.name,
+      owner + ' does not have own property ' + format_value(this.name)
+    );
+  };
+
+  IdlInterface.prototype.get_interface_object = function() {
+    if (this.has_extended_attribute('NoInterfaceObject')) {
+      throw new IdlHarnessError(
+        this.name + ' has no interface object due to NoInterfaceObject'
+      );
     }
 
     return this.get_interface_object_owner()[this.name];
-};
+  };
 
-IdlInterface.prototype.get_qualified_name = function() {
+  IdlInterface.prototype.get_qualified_name = function() {
     // https://heycam.github.io/webidl/#qualified-name
     var legacyNamespace = this.get_legacy_namespace();
     if (legacyNamespace) {
-        return legacyNamespace + "." + this.name;
+      return legacyNamespace + '.' + this.name;
     }
     return this.name;
-};
+  };
 
-IdlInterface.prototype.has_to_json_regular_operation = function() {
+  IdlInterface.prototype.has_to_json_regular_operation = function() {
     return this.members.some(function(m) {
-        return m.is_to_json_regular_operation();
+      return m.is_to_json_regular_operation();
     });
-};
+  };
 
-IdlInterface.prototype.has_default_to_json_regular_operation = function() {
+  IdlInterface.prototype.has_default_to_json_regular_operation = function() {
     return this.members.some(function(m) {
-        return m.is_to_json_regular_operation() && m.has_extended_attribute("Default");
+      return (
+        m.is_to_json_regular_operation() && m.has_extended_attribute('Default')
+      );
     });
-};
+  };
 
-IdlInterface.prototype.get_inheritance_stack = function() {
+  IdlInterface.prototype.get_inheritance_stack = function() {
     /**
      * See https://heycam.github.io/webidl/#create-an-inheritance-stack
      *
@@ -1339,118 +1475,138 @@ IdlInterface.prototype.get_inheritance_stack = function() {
     var stack = [this];
     var idl_interface = this;
     while (idl_interface.base) {
-        var base = this.array.members[idl_interface.base];
-        if (!base) {
-            throw new Error(idl_interface.type + " " + idl_interface.base + " not found (inherited by " + idl_interface.name + ")");
-        } else if (stack.indexOf(base) > -1) {
-            stack.push(base);
-            let dep_chain = stack.map(i => i.name).join(',');
-            throw new IdlHarnessError(`${this.name} has a circular dependency: ${dep_chain}`);
-        }
-        idl_interface = base;
-        stack.push(idl_interface);
+      var base = this.array.members[idl_interface.base];
+      if (!base) {
+        throw new Error(
+          idl_interface.type +
+            ' ' +
+            idl_interface.base +
+            ' not found (inherited by ' +
+            idl_interface.name +
+            ')'
+        );
+      } else if (stack.indexOf(base) > -1) {
+        stack.push(base);
+        let dep_chain = stack.map((i) => i.name).join(',');
+        throw new IdlHarnessError(
+          `${this.name} has a circular dependency: ${dep_chain}`
+        );
+      }
+      idl_interface = base;
+      stack.push(idl_interface);
     }
     return stack;
-};
-
-/**
- * Implementation of
- * https://heycam.github.io/webidl/#default-tojson-operation
- * for testing purposes.
- *
- * Collects the IDL types of the attributes that meet the criteria
- * for inclusion in the default toJSON operation for easy
- * comparison with actual value
- */
-IdlInterface.prototype.default_to_json_operation = function(callback) {
-    var map = new Map(), isDefault = false;
+  };
+
+  /**
+   * Implementation of
+   * https://heycam.github.io/webidl/#default-tojson-operation
+   * for testing purposes.
+   *
+   * Collects the IDL types of the attributes that meet the criteria
+   * for inclusion in the default toJSON operation for easy
+   * comparison with actual value
+   */
+  IdlInterface.prototype.default_to_json_operation = function(callback) {
+    var map = new Map(),
+      isDefault = false;
     this.traverse_inherited_and_consequential_interfaces(function(I) {
-        if (I.has_default_to_json_regular_operation()) {
-            isDefault = true;
-            I.members.forEach(function(m) {
-                if (!m.static && m.type == "attribute" && I.array.is_json_type(m.idlType)) {
-                    map.set(m.name, m.idlType);
-                }
-            });
-        } else if (I.has_to_json_regular_operation()) {
-            isDefault = false;
-        }
+      if (I.has_default_to_json_regular_operation()) {
+        isDefault = true;
+        I.members.forEach(function(m) {
+          if (
+            !m.static &&
+            m.type == 'attribute' &&
+            I.array.is_json_type(m.idlType)
+          ) {
+            map.set(m.name, m.idlType);
+          }
+        });
+      } else if (I.has_to_json_regular_operation()) {
+        isDefault = false;
+      }
     });
     return isDefault ? map : null;
-};
-
-/**
- * Traverses inherited interfaces from the top down
- * and imeplemented interfaces inside out.
- * Invokes |callback| on each interface.
- *
- * This is an abstract implementation of the traversal
- * algorithm specified in:
- * https://heycam.github.io/webidl/#collect-attribute-values
- * Given the following inheritance tree:
- *
- *           F
- *           |
- *       C   E - I
- *       |   |
- *       B - D
- *       |
- *   G - A - H - J
- *
- * Invoking traverse_inherited_and_consequential_interfaces() on A
- * would traverse the tree in the following order:
- * C -> B -> F -> E -> I -> D -> A -> G -> H -> J
- */
-
-IdlInterface.prototype.traverse_inherited_and_consequential_interfaces = function(callback) {
-    if (typeof callback != "function") {
-        throw new TypeError();
+  };
+
+  /**
+   * Traverses inherited interfaces from the top down
+   * and imeplemented interfaces inside out.
+   * Invokes |callback| on each interface.
+   *
+   * This is an abstract implementation of the traversal
+   * algorithm specified in:
+   * https://heycam.github.io/webidl/#collect-attribute-values
+   * Given the following inheritance tree:
+   *
+   *           F
+   *           |
+   *       C   E - I
+   *       |   |
+   *       B - D
+   *       |
+   *   G - A - H - J
+   *
+   * Invoking traverse_inherited_and_consequential_interfaces() on A
+   * would traverse the tree in the following order:
+   * C -> B -> F -> E -> I -> D -> A -> G -> H -> J
+   */
+
+  IdlInterface.prototype.traverse_inherited_and_consequential_interfaces = function(
+    callback
+  ) {
+    if (typeof callback != 'function') {
+      throw new TypeError();
     }
     var stack = this.get_inheritance_stack();
     _traverse_inherited_and_consequential_interfaces(stack, callback);
-};
+  };
 
-function _traverse_inherited_and_consequential_interfaces(stack, callback) {
+  function _traverse_inherited_and_consequential_interfaces(stack, callback) {
     var I = stack.pop();
     callback(I);
-    var mixins = I.array["implements"][I.name] || I.array["includes"][I.name];
+    var mixins = I.array['implements'][I.name] || I.array['includes'][I.name];
     if (mixins) {
-        mixins.forEach(function(id) {
-            var mixin = I.array.members[id];
-            if (!mixin) {
-                throw new Error("Interface " + id + " not found (implemented by " + I.name + ")");
-            }
-            var interfaces = mixin.get_inheritance_stack();
-            _traverse_inherited_and_consequential_interfaces(interfaces, callback);
-        });
+      mixins.forEach(function(id) {
+        var mixin = I.array.members[id];
+        if (!mixin) {
+          throw new Error(
+            'Interface ' + id + ' not found (implemented by ' + I.name + ')'
+          );
+        }
+        var interfaces = mixin.get_inheritance_stack();
+        _traverse_inherited_and_consequential_interfaces(interfaces, callback);
+      });
     }
     if (stack.length > 0) {
-        _traverse_inherited_and_consequential_interfaces(stack, callback);
+      _traverse_inherited_and_consequential_interfaces(stack, callback);
     }
-}
-
-IdlInterface.prototype.test = function()
-{
-    if (this.has_extended_attribute("NoInterfaceObject") || this.is_mixin())
-    {
-        // No tests to do without an instance.  TODO: We should still be able
-        // to run tests on the prototype object, if we obtain one through some
-        // other means.
-        return;
+  }
+
+  IdlInterface.prototype.test = function() {
+    if (this.has_extended_attribute('NoInterfaceObject') || this.is_mixin()) {
+      // No tests to do without an instance.  TODO: We should still be able
+      // to run tests on the prototype object, if we obtain one through some
+      // other means.
+      return;
     }
 
     if (!this.exposed) {
-        subsetTestByKey(this.name, test, function() {
-            assert_false(this.name in self);
-        }.bind(this), this.name + " interface: existence and properties of interface object");
-        return;
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          assert_false(this.name in self);
+        }.bind(this),
+        this.name + ' interface: existence and properties of interface object'
+      );
+      return;
     }
 
-    if (!this.untested)
-    {
-        // First test things to do with the exception/interface object and
-        // exception/interface prototype object.
-        this.test_self();
+    if (!this.untested) {
+      // First test things to do with the exception/interface object and
+      // exception/interface prototype object.
+      this.test_self();
     }
     // Then test things to do with its members (constants, fields, attributes,
     // operations, . . .).  These are run even if .untested is true, because
@@ -1460,12 +1616,13 @@ IdlInterface.prototype.test = function()
     // members will be marked as untested, but the members added by the partial
     // interface are still tested.
     this.test_members();
-};
+  };
 
-IdlInterface.prototype.test_self = function()
-{
-    subsetTestByKey(this.name, test, function()
-    {
+  IdlInterface.prototype.test_self = function() {
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         // This function tests WebIDL as of 2015-01-13.
 
         // "For every interface that is exposed in a given ECMAScript global
@@ -1479,26 +1636,57 @@ IdlInterface.prototype.test_self = function()
         // The property has the attributes { [[Writable]]: true,
         // [[Enumerable]]: false, [[Configurable]]: true }."
         if (this.is_callback() && !this.has_constants()) {
-            return;
+          return;
         }
 
         // TODO: Should we test here that the property is actually writable
         // etc., or trust getOwnPropertyDescriptor?
         this.assert_interface_object_exists();
-        var desc = Object.getOwnPropertyDescriptor(this.get_interface_object_owner(), this.name);
-        assert_false("get" in desc, "self's property " + format_value(this.name) + " should not have a getter");
-        assert_false("set" in desc, "self's property " + format_value(this.name) + " should not have a setter");
-        assert_true(desc.writable, "self's property " + format_value(this.name) + " should be writable");
-        assert_false(desc.enumerable, "self's property " + format_value(this.name) + " should not be enumerable");
-        assert_true(desc.configurable, "self's property " + format_value(this.name) + " should be configurable");
+        var desc = Object.getOwnPropertyDescriptor(
+          this.get_interface_object_owner(),
+          this.name
+        );
+        assert_false(
+          'get' in desc,
+          "self's property " +
+            format_value(this.name) +
+            ' should not have a getter'
+        );
+        assert_false(
+          'set' in desc,
+          "self's property " +
+            format_value(this.name) +
+            ' should not have a setter'
+        );
+        assert_true(
+          desc.writable,
+          "self's property " + format_value(this.name) + ' should be writable'
+        );
+        assert_false(
+          desc.enumerable,
+          "self's property " +
+            format_value(this.name) +
+            ' should not be enumerable'
+        );
+        assert_true(
+          desc.configurable,
+          "self's property " +
+            format_value(this.name) +
+            ' should be configurable'
+        );
 
         if (this.is_callback()) {
-            // "The internal [[Prototype]] property of an interface object for
-            // a callback interface must be the Function.prototype object."
-            assert_equals(Object.getPrototypeOf(this.get_interface_object()), Function.prototype,
-                          "prototype of self's property " + format_value(this.name) + " is not Object.prototype");
-
-            return;
+          // "The internal [[Prototype]] property of an interface object for
+          // a callback interface must be the Function.prototype object."
+          assert_equals(
+            Object.getPrototypeOf(this.get_interface_object()),
+            Function.prototype,
+            "prototype of self's property " +
+              format_value(this.name) +
+              ' is not Object.prototype'
+          );
+
+          return;
         }
 
         // "The interface object for a given non-callback interface is a
@@ -1525,164 +1713,282 @@ IdlInterface.prototype.test_self = function()
         // ES6 (rev 30) 19.1.3.6:
         // "Else, if O has a [[Call]] internal method, then let builtinTag be
         // "Function"."
-        assert_class_string(this.get_interface_object(), "Function", "class string of " + this.name);
+        assert_class_string(
+          this.get_interface_object(),
+          'Function',
+          'class string of ' + this.name
+        );
 
         // "The [[Prototype]] internal property of an interface object for a
         // non-callback interface is determined as follows:"
         var prototype = Object.getPrototypeOf(this.get_interface_object());
         if (this.base) {
-            // "* If the interface inherits from some other interface, the
-            //    value of [[Prototype]] is the interface object for that other
-            //    interface."
-            var inherited_interface = this.array.members[this.base];
-            if (!inherited_interface.has_extended_attribute("NoInterfaceObject")) {
-                inherited_interface.assert_interface_object_exists();
-                assert_equals(prototype, inherited_interface.get_interface_object(),
-                              'prototype of ' + this.name + ' is not ' +
-                              this.base);
-            }
+          // "* If the interface inherits from some other interface, the
+          //    value of [[Prototype]] is the interface object for that other
+          //    interface."
+          var inherited_interface = this.array.members[this.base];
+          if (
+            !inherited_interface.has_extended_attribute('NoInterfaceObject')
+          ) {
+            inherited_interface.assert_interface_object_exists();
+            assert_equals(
+              prototype,
+              inherited_interface.get_interface_object(),
+              'prototype of ' + this.name + ' is not ' + this.base
+            );
+          }
         } else {
-            // "If the interface doesn't inherit from any other interface, the
-            // value of [[Prototype]] is %FunctionPrototype% ([ECMA-262],
-            // section 6.1.7.4)."
-            assert_equals(prototype, Function.prototype,
-                          "prototype of self's property " + format_value(this.name) + " is not Function.prototype");
+          // "If the interface doesn't inherit from any other interface, the
+          // value of [[Prototype]] is %FunctionPrototype% ([ECMA-262],
+          // section 6.1.7.4)."
+          assert_equals(
+            prototype,
+            Function.prototype,
+            "prototype of self's property " +
+              format_value(this.name) +
+              ' is not Function.prototype'
+          );
         }
 
-        if (!this.has_extended_attribute("Constructor")) {
-            // "The internal [[Call]] method of the interface object behaves as
-            // follows . . .
-            //
-            // "If I was not declared with a [Constructor] extended attribute,
-            // then throw a TypeError."
-            var interface_object = this.get_interface_object();
-            assert_throws(new TypeError(), function() {
-                interface_object();
-            }, "interface object didn't throw TypeError when called as a function");
-            assert_throws(new TypeError(), function() {
-                new interface_object();
-            }, "interface object didn't throw TypeError when called as a constructor");
+        if (!this.has_extended_attribute('Constructor')) {
+          // "The internal [[Call]] method of the interface object behaves as
+          // follows . . .
+          //
+          // "If I was not declared with a [Constructor] extended attribute,
+          // then throw a TypeError."
+          var interface_object = this.get_interface_object();
+          assert_throws(
+            new TypeError(),
+            function() {
+              interface_object();
+            },
+            "interface object didn't throw TypeError when called as a function"
+          );
+          assert_throws(
+            new TypeError(),
+            function() {
+              new interface_object();
+            },
+            "interface object didn't throw TypeError when called as a constructor"
+          );
         }
-    }.bind(this), this.name + " interface: existence and properties of interface object");
+      }.bind(this),
+      this.name + ' interface: existence and properties of interface object'
+    );
 
     if (!this.is_callback()) {
-        subsetTestByKey(this.name, test, function() {
-            // This function tests WebIDL as of 2014-10-25.
-            // https://heycam.github.io/webidl/#es-interface-call
-
-            this.assert_interface_object_exists();
-
-            // "Interface objects for non-callback interfaces MUST have a
-            // property named “length” with attributes { [[Writable]]: false,
-            // [[Enumerable]]: false, [[Configurable]]: true } whose value is
-            // a Number."
-            assert_own_property(this.get_interface_object(), "length");
-            var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "length");
-            assert_false("get" in desc, this.name + ".length should not have a getter");
-            assert_false("set" in desc, this.name + ".length should not have a setter");
-            assert_false(desc.writable, this.name + ".length should not be writable");
-            assert_false(desc.enumerable, this.name + ".length should not be enumerable");
-            assert_true(desc.configurable, this.name + ".length should be configurable");
-
-            var constructors = this.extAttrs
-                .filter(function(attr) { return attr.name == "Constructor"; });
-            var expected_length = minOverloadLength(constructors);
-            assert_equals(this.get_interface_object().length, expected_length, "wrong value for " + this.name + ".length");
-        }.bind(this), this.name + " interface object length");
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          // This function tests WebIDL as of 2014-10-25.
+          // https://heycam.github.io/webidl/#es-interface-call
+
+          this.assert_interface_object_exists();
+
+          // "Interface objects for non-callback interfaces MUST have a
+          // property named “length” with attributes { [[Writable]]: false,
+          // [[Enumerable]]: false, [[Configurable]]: true } whose value is
+          // a Number."
+          assert_own_property(this.get_interface_object(), 'length');
+          var desc = Object.getOwnPropertyDescriptor(
+            this.get_interface_object(),
+            'length'
+          );
+          assert_false(
+            'get' in desc,
+            this.name + '.length should not have a getter'
+          );
+          assert_false(
+            'set' in desc,
+            this.name + '.length should not have a setter'
+          );
+          assert_false(
+            desc.writable,
+            this.name + '.length should not be writable'
+          );
+          assert_false(
+            desc.enumerable,
+            this.name + '.length should not be enumerable'
+          );
+          assert_true(
+            desc.configurable,
+            this.name + '.length should be configurable'
+          );
+
+          var constructors = this.extAttrs.filter(function(attr) {
+            return attr.name == 'Constructor';
+          });
+          var expected_length = minOverloadLength(constructors);
+          assert_equals(
+            this.get_interface_object().length,
+            expected_length,
+            'wrong value for ' + this.name + '.length'
+          );
+        }.bind(this),
+        this.name + ' interface object length'
+      );
     }
 
     if (!this.is_callback() || this.has_constants()) {
-        subsetTestByKey(this.name, test, function() {
-            // This function tests WebIDL as of 2015-11-17.
-            // https://heycam.github.io/webidl/#interface-object
-
-            this.assert_interface_object_exists();
-
-            // "All interface objects must have a property named “name” with
-            // attributes { [[Writable]]: false, [[Enumerable]]: false,
-            // [[Configurable]]: true } whose value is the identifier of the
-            // corresponding interface."
-
-            assert_own_property(this.get_interface_object(), "name");
-            var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "name");
-            assert_false("get" in desc, this.name + ".name should not have a getter");
-            assert_false("set" in desc, this.name + ".name should not have a setter");
-            assert_false(desc.writable, this.name + ".name should not be writable");
-            assert_false(desc.enumerable, this.name + ".name should not be enumerable");
-            assert_true(desc.configurable, this.name + ".name should be configurable");
-            assert_equals(this.get_interface_object().name, this.name, "wrong value for " + this.name + ".name");
-        }.bind(this), this.name + " interface object name");
-    }
-
-
-    if (this.has_extended_attribute("LegacyWindowAlias")) {
-        subsetTestByKey(this.name, test, function()
-        {
-            var aliasAttrs = this.extAttrs.filter(function(o) { return o.name === "LegacyWindowAlias"; });
-            if (aliasAttrs.length > 1) {
-                throw new IdlHarnessError("Invalid IDL: multiple LegacyWindowAlias extended attributes on " + this.name);
-            }
-            if (this.is_callback()) {
-                throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on non-interface " + this.name);
-            }
-            if (!this.exposureSet.has("Window")) {
-                throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on " + this.name + " which is not exposed in Window");
-            }
-            // TODO: when testing of [NoInterfaceObject] interfaces is supported,
-            // check that it's not specified together with LegacyWindowAlias.
-
-            // TODO: maybe check that [LegacyWindowAlias] is not specified on a partial interface.
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          // This function tests WebIDL as of 2015-11-17.
+          // https://heycam.github.io/webidl/#interface-object
+
+          this.assert_interface_object_exists();
+
+          // "All interface objects must have a property named “name” with
+          // attributes { [[Writable]]: false, [[Enumerable]]: false,
+          // [[Configurable]]: true } whose value is the identifier of the
+          // corresponding interface."
+
+          assert_own_property(this.get_interface_object(), 'name');
+          var desc = Object.getOwnPropertyDescriptor(
+            this.get_interface_object(),
+            'name'
+          );
+          assert_false(
+            'get' in desc,
+            this.name + '.name should not have a getter'
+          );
+          assert_false(
+            'set' in desc,
+            this.name + '.name should not have a setter'
+          );
+          assert_false(
+            desc.writable,
+            this.name + '.name should not be writable'
+          );
+          assert_false(
+            desc.enumerable,
+            this.name + '.name should not be enumerable'
+          );
+          assert_true(
+            desc.configurable,
+            this.name + '.name should be configurable'
+          );
+          assert_equals(
+            this.get_interface_object().name,
+            this.name,
+            'wrong value for ' + this.name + '.name'
+          );
+        }.bind(this),
+        this.name + ' interface object name'
+      );
+    }
 
-            var rhs = aliasAttrs[0].rhs;
-            if (!rhs) {
-                throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on " + this.name + " without identifier");
-            }
-            var aliases;
-            if (rhs.type === "identifier-list") {
-                aliases = rhs.value;
-            } else { // rhs.type === identifier
-                aliases = [ rhs.value ];
+    if (this.has_extended_attribute('LegacyWindowAlias')) {
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          var aliasAttrs = this.extAttrs.filter(function(o) {
+            return o.name === 'LegacyWindowAlias';
+          });
+          if (aliasAttrs.length > 1) {
+            throw new IdlHarnessError(
+              'Invalid IDL: multiple LegacyWindowAlias extended attributes on ' +
+                this.name
+            );
+          }
+          if (this.is_callback()) {
+            throw new IdlHarnessError(
+              'Invalid IDL: LegacyWindowAlias extended attribute on non-interface ' +
+                this.name
+            );
+          }
+          if (!this.exposureSet.has('Window')) {
+            throw new IdlHarnessError(
+              'Invalid IDL: LegacyWindowAlias extended attribute on ' +
+                this.name +
+                ' which is not exposed in Window'
+            );
+          }
+          // TODO: when testing of [NoInterfaceObject] interfaces is supported,
+          // check that it's not specified together with LegacyWindowAlias.
+
+          // TODO: maybe check that [LegacyWindowAlias] is not specified on a partial interface.
+
+          var rhs = aliasAttrs[0].rhs;
+          if (!rhs) {
+            throw new IdlHarnessError(
+              'Invalid IDL: LegacyWindowAlias extended attribute on ' +
+                this.name +
+                ' without identifier'
+            );
+          }
+          var aliases;
+          if (rhs.type === 'identifier-list') {
+            aliases = rhs.value;
+          } else {
+            // rhs.type === identifier
+            aliases = [rhs.value];
+          }
+
+          // OK now actually check the aliases...
+          var alias;
+          if (
+            exposed_in(exposure_set(this, this.exposureSet)) &&
+            'document' in self
+          ) {
+            for (alias of aliases) {
+              assert_true(alias in self, alias + ' should exist');
+              assert_equals(
+                self[alias],
+                this.get_interface_object(),
+                'self.' +
+                  alias +
+                  ' should be the same value as self.' +
+                  this.get_qualified_name()
+              );
+              var desc = Object.getOwnPropertyDescriptor(self, alias);
+              assert_equals(
+                desc.value,
+                this.get_interface_object(),
+                'wrong value in ' + alias + ' property descriptor'
+              );
+              assert_true(desc.writable, alias + ' should be writable');
+              assert_false(
+                desc.enumerable,
+                alias + ' should not be enumerable'
+              );
+              assert_true(desc.configurable, alias + ' should be configurable');
+              assert_false('get' in desc, alias + ' should not have a getter');
+              assert_false('set' in desc, alias + ' should not have a setter');
             }
-
-            // OK now actually check the aliases...
-            var alias;
-            if (exposed_in(exposure_set(this, this.exposureSet)) && 'document' in self) {
-                for (alias of aliases) {
-                    assert_true(alias in self, alias + " should exist");
-                    assert_equals(self[alias], this.get_interface_object(), "self." + alias + " should be the same value as self." + this.get_qualified_name());
-                    var desc = Object.getOwnPropertyDescriptor(self, alias);
-                    assert_equals(desc.value, this.get_interface_object(), "wrong value in " + alias + " property descriptor");
-                    assert_true(desc.writable, alias + " should be writable");
-                    assert_false(desc.enumerable, alias + " should not be enumerable");
-                    assert_true(desc.configurable, alias + " should be configurable");
-                    assert_false('get' in desc, alias + " should not have a getter");
-                    assert_false('set' in desc, alias + " should not have a setter");
-                }
-            } else {
-                for (alias of aliases) {
-                    assert_false(alias in self, alias + " should not exist");
-                }
+          } else {
+            for (alias of aliases) {
+              assert_false(alias in self, alias + ' should not exist');
             }
-
-        }.bind(this), this.name + " interface: legacy window alias");
+          }
+        }.bind(this),
+        this.name + ' interface: legacy window alias'
+      );
     }
     // TODO: Test named constructors if I find any interfaces that have them.
 
-    subsetTestByKey(this.name, test, function()
-    {
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         // This function tests WebIDL as of 2015-01-21.
         // https://heycam.github.io/webidl/#interface-object
 
         if (this.is_callback() && !this.has_constants()) {
-            return;
+          return;
         }
 
         this.assert_interface_object_exists();
 
         if (this.is_callback()) {
-            assert_false("prototype" in this.get_interface_object(),
-                         this.name + ' should not have a "prototype" property');
-            return;
+          assert_false(
+            'prototype' in this.get_interface_object(),
+            this.name + ' should not have a "prototype" property'
+          );
+          return;
         }
 
         // "An interface object for a non-callback interface must have a
@@ -1692,14 +1998,35 @@ IdlInterface.prototype.test_self = function()
         // properties that correspond to the regular attributes and regular
         // operations defined on the interface, and is described in more detail
         // in section 4.5.4 below."
-        assert_own_property(this.get_interface_object(), "prototype",
-                            'interface "' + this.name + '" does not have own property "prototype"');
-        var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "prototype");
-        assert_false("get" in desc, this.name + ".prototype should not have a getter");
-        assert_false("set" in desc, this.name + ".prototype should not have a setter");
-        assert_false(desc.writable, this.name + ".prototype should not be writable");
-        assert_false(desc.enumerable, this.name + ".prototype should not be enumerable");
-        assert_false(desc.configurable, this.name + ".prototype should not be configurable");
+        assert_own_property(
+          this.get_interface_object(),
+          'prototype',
+          'interface "' + this.name + '" does not have own property "prototype"'
+        );
+        var desc = Object.getOwnPropertyDescriptor(
+          this.get_interface_object(),
+          'prototype'
+        );
+        assert_false(
+          'get' in desc,
+          this.name + '.prototype should not have a getter'
+        );
+        assert_false(
+          'set' in desc,
+          this.name + '.prototype should not have a setter'
+        );
+        assert_false(
+          desc.writable,
+          this.name + '.prototype should not be writable'
+        );
+        assert_false(
+          desc.enumerable,
+          this.name + '.prototype should not be enumerable'
+        );
+        assert_false(
+          desc.configurable,
+          this.name + '.prototype should not be configurable'
+        );
 
         // Next, test that the [[Prototype]] of the interface prototype object
         // is correct. (This is made somewhat difficult by the existence of
@@ -1726,44 +2053,67 @@ IdlInterface.prototype.test_self = function()
         //     for DOMException must have as its [[Prototype]] the intrinsic
         //     object %ErrorPrototype%."
         //
-        if (this.name === "Window") {
-            assert_class_string(Object.getPrototypeOf(this.get_interface_object().prototype),
-                                'WindowProperties',
-                                'Class name for prototype of Window' +
-                                '.prototype is not "WindowProperties"');
+        if (this.name === 'Window') {
+          assert_class_string(
+            Object.getPrototypeOf(this.get_interface_object().prototype),
+            'WindowProperties',
+            'Class name for prototype of Window' +
+              '.prototype is not "WindowProperties"'
+          );
         } else {
-            var inherit_interface, inherit_interface_interface_object;
-            if (this.base) {
-                inherit_interface = this.base;
-                var parent = this.array.members[inherit_interface];
-                if (!parent.has_extended_attribute("NoInterfaceObject")) {
-                    parent.assert_interface_object_exists();
-                    inherit_interface_interface_object = parent.get_interface_object();
-                }
-            } else if (this.name === "DOMException") {
-                inherit_interface = 'Error';
-                inherit_interface_interface_object = self.Error;
-            } else {
-                inherit_interface = 'Object';
-                inherit_interface_interface_object = self.Object;
-            }
-            if (inherit_interface_interface_object) {
-                assert_not_equals(inherit_interface_interface_object, undefined,
-                                  'should inherit from ' + inherit_interface + ', but there is no such property');
-                assert_own_property(inherit_interface_interface_object, 'prototype',
-                                    'should inherit from ' + inherit_interface + ', but that object has no "prototype" property');
-                assert_equals(Object.getPrototypeOf(this.get_interface_object().prototype),
-                              inherit_interface_interface_object.prototype,
-                              'prototype of ' + this.name + '.prototype is not ' + inherit_interface + '.prototype');
-            } else {
-                // We can't test that we get the correct object, because this is the
-                // only way to get our hands on it. We only test that its class
-                // string, at least, is correct.
-                assert_class_string(Object.getPrototypeOf(this.get_interface_object().prototype),
-                                    inherit_interface + 'Prototype',
-                                    'Class name for prototype of ' + this.name +
-                                    '.prototype is not "' + inherit_interface + 'Prototype"');
+          var inherit_interface, inherit_interface_interface_object;
+          if (this.base) {
+            inherit_interface = this.base;
+            var parent = this.array.members[inherit_interface];
+            if (!parent.has_extended_attribute('NoInterfaceObject')) {
+              parent.assert_interface_object_exists();
+              inherit_interface_interface_object = parent.get_interface_object();
             }
+          } else if (this.name === 'DOMException') {
+            inherit_interface = 'Error';
+            inherit_interface_interface_object = self.Error;
+          } else {
+            inherit_interface = 'Object';
+            inherit_interface_interface_object = self.Object;
+          }
+          if (inherit_interface_interface_object) {
+            assert_not_equals(
+              inherit_interface_interface_object,
+              undefined,
+              'should inherit from ' +
+                inherit_interface +
+                ', but there is no such property'
+            );
+            assert_own_property(
+              inherit_interface_interface_object,
+              'prototype',
+              'should inherit from ' +
+                inherit_interface +
+                ', but that object has no "prototype" property'
+            );
+            assert_equals(
+              Object.getPrototypeOf(this.get_interface_object().prototype),
+              inherit_interface_interface_object.prototype,
+              'prototype of ' +
+                this.name +
+                '.prototype is not ' +
+                inherit_interface +
+                '.prototype'
+            );
+          } else {
+            // We can't test that we get the correct object, because this is the
+            // only way to get our hands on it. We only test that its class
+            // string, at least, is correct.
+            assert_class_string(
+              Object.getPrototypeOf(this.get_interface_object().prototype),
+              inherit_interface + 'Prototype',
+              'Class name for prototype of ' +
+                this.name +
+                '.prototype is not "' +
+                inherit_interface +
+                'Prototype"'
+            );
+          }
         }
 
         // "The class string of an interface prototype object is the
@@ -1780,10 +2130,13 @@ IdlInterface.prototype.test_self = function()
         // String() should end up calling {}.toString if nothing defines a
         // stringifier.
         if (!this.has_stringifier()) {
-            // assert_equals(String(this.get_interface_object().prototype), "[object " + this.get_qualified_name() + "Prototype]",
-            //         "String(" + this.name + ".prototype)");
+          // assert_equals(String(this.get_interface_object().prototype), "[object " + this.get_qualified_name() + "Prototype]",
+          //         "String(" + this.name + ".prototype)");
         }
-    }.bind(this), this.name + " interface: existence and properties of interface prototype object");
+      }.bind(this),
+      this.name +
+        ' interface: existence and properties of interface prototype object'
+    );
 
     // "If the interface is declared with the [Global]
     // extended attribute, or the interface is in the set of inherited
@@ -1792,215 +2145,357 @@ IdlInterface.prototype.test_self = function()
     // prototype exotic object."
     // https://heycam.github.io/webidl/#interface-prototype-object
     if (this.is_global()) {
-        this.test_immutable_prototype("interface prototype object", this.get_interface_object().prototype);
+      this.test_immutable_prototype(
+        'interface prototype object',
+        this.get_interface_object().prototype
+      );
     }
 
-    subsetTestByKey(this.name, test, function()
-    {
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         if (this.is_callback() && !this.has_constants()) {
-            return;
+          return;
         }
 
         this.assert_interface_object_exists();
 
         if (this.is_callback()) {
-            assert_false("prototype" in this.get_interface_object(),
-                         this.name + ' should not have a "prototype" property');
-            return;
+          assert_false(
+            'prototype' in this.get_interface_object(),
+            this.name + ' should not have a "prototype" property'
+          );
+          return;
         }
 
-        assert_own_property(this.get_interface_object(), "prototype",
-                            'interface "' + this.name + '" does not have own property "prototype"');
+        assert_own_property(
+          this.get_interface_object(),
+          'prototype',
+          'interface "' + this.name + '" does not have own property "prototype"'
+        );
 
         // "If the [NoInterfaceObject] extended attribute was not specified on
         // the interface, then the interface prototype object must also have a
         // property named “constructor” with attributes { [[Writable]]: true,
         // [[Enumerable]]: false, [[Configurable]]: true } whose value is a
         // reference to the interface object for the interface."
-        assert_own_property(this.get_interface_object().prototype, "constructor",
-                            this.name + '.prototype does not have own property "constructor"');
-        var desc = Object.getOwnPropertyDescriptor(this.get_interface_object().prototype, "constructor");
-        assert_false("get" in desc, this.name + ".prototype.constructor should not have a getter");
-        assert_false("set" in desc, this.name + ".prototype.constructor should not have a setter");
-        assert_true(desc.writable, this.name + ".prototype.constructor should be writable");
-        assert_false(desc.enumerable, this.name + ".prototype.constructor should not be enumerable");
-        assert_true(desc.configurable, this.name + ".prototype.constructor should be configurable");
-        assert_equals(this.get_interface_object().prototype.constructor, this.get_interface_object(),
-                      this.name + '.prototype.constructor is not the same object as ' + this.name);
-    }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s "constructor" property');
-
-
-    subsetTestByKey(this.name, test, function()
-    {
+        assert_own_property(
+          this.get_interface_object().prototype,
+          'constructor',
+          this.name + '.prototype does not have own property "constructor"'
+        );
+        var desc = Object.getOwnPropertyDescriptor(
+          this.get_interface_object().prototype,
+          'constructor'
+        );
+        assert_false(
+          'get' in desc,
+          this.name + '.prototype.constructor should not have a getter'
+        );
+        assert_false(
+          'set' in desc,
+          this.name + '.prototype.constructor should not have a setter'
+        );
+        assert_true(
+          desc.writable,
+          this.name + '.prototype.constructor should be writable'
+        );
+        assert_false(
+          desc.enumerable,
+          this.name + '.prototype.constructor should not be enumerable'
+        );
+        assert_true(
+          desc.configurable,
+          this.name + '.prototype.constructor should be configurable'
+        );
+        assert_equals(
+          this.get_interface_object().prototype.constructor,
+          this.get_interface_object(),
+          this.name +
+            '.prototype.constructor is not the same object as ' +
+            this.name
+        );
+      }.bind(this),
+      this.name +
+        ' interface: existence and properties of interface prototype object\'s "constructor" property'
+    );
+
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         if (this.is_callback() && !this.has_constants()) {
-            return;
+          return;
         }
 
         this.assert_interface_object_exists();
 
         if (this.is_callback()) {
-            assert_false("prototype" in this.get_interface_object(),
-                         this.name + ' should not have a "prototype" property');
-            return;
+          assert_false(
+            'prototype' in this.get_interface_object(),
+            this.name + ' should not have a "prototype" property'
+          );
+          return;
         }
 
-        assert_own_property(this.get_interface_object(), "prototype",
-                            'interface "' + this.name + '" does not have own property "prototype"');
+        assert_own_property(
+          this.get_interface_object(),
+          'prototype',
+          'interface "' + this.name + '" does not have own property "prototype"'
+        );
 
         // If the interface has any member declared with the [Unscopable] extended
         // attribute, then there must be a property on the interface prototype object
         // whose name is the @@unscopables symbol, which has the attributes
         // { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true },
         // and whose value is an object created as follows...
-        var unscopables = this.get_unscopables().map(m => m.name);
+        var unscopables = this.get_unscopables().map((m) => m.name);
         var proto = this.get_interface_object().prototype;
         if (unscopables.length != 0) {
-            assert_own_property(
-                proto, Symbol.unscopables,
-                this.name + '.prototype should have an @@unscopables property');
-            var desc = Object.getOwnPropertyDescriptor(proto, Symbol.unscopables);
-            assert_false("get" in desc,
-                         this.name + ".prototype[Symbol.unscopables] should not have a getter");
-            assert_false("set" in desc, this.name + ".prototype[Symbol.unscopables] should not have a setter");
-            assert_false(desc.writable, this.name + ".prototype[Symbol.unscopables] should not be writable");
-            assert_false(desc.enumerable, this.name + ".prototype[Symbol.unscopables] should not be enumerable");
-            assert_true(desc.configurable, this.name + ".prototype[Symbol.unscopables] should be configurable");
-            assert_equals(desc.value, proto[Symbol.unscopables],
-                          this.name + '.prototype[Symbol.unscopables] should be in the descriptor');
-            assert_equals(typeof desc.value, "object",
-                          this.name + '.prototype[Symbol.unscopables] should be an object');
-            assert_equals(Object.getPrototypeOf(desc.value), null,
-                          this.name + '.prototype[Symbol.unscopables] should have a null prototype');
-            assert_equals(Object.getOwnPropertySymbols(desc.value).length,
-                          0,
-                          this.name + '.prototype[Symbol.unscopables] should have the right number of symbol-named properties');
-
-            // Check that we do not have _extra_ unscopables.  Checking that we
-            // have all the ones we should will happen in the per-member tests.
-            var observed = Object.getOwnPropertyNames(desc.value);
-            for (var prop of observed) {
-                assert_not_equals(unscopables.indexOf(prop),
-                                  -1,
-                                  this.name + '.prototype[Symbol.unscopables] has unexpected property "' + prop + '"');
-            }
+          assert_own_property(
+            proto,
+            Symbol.unscopables,
+            this.name + '.prototype should have an @@unscopables property'
+          );
+          var desc = Object.getOwnPropertyDescriptor(proto, Symbol.unscopables);
+          assert_false(
+            'get' in desc,
+            this.name +
+              '.prototype[Symbol.unscopables] should not have a getter'
+          );
+          assert_false(
+            'set' in desc,
+            this.name +
+              '.prototype[Symbol.unscopables] should not have a setter'
+          );
+          assert_false(
+            desc.writable,
+            this.name + '.prototype[Symbol.unscopables] should not be writable'
+          );
+          assert_false(
+            desc.enumerable,
+            this.name +
+              '.prototype[Symbol.unscopables] should not be enumerable'
+          );
+          assert_true(
+            desc.configurable,
+            this.name + '.prototype[Symbol.unscopables] should be configurable'
+          );
+          assert_equals(
+            desc.value,
+            proto[Symbol.unscopables],
+            this.name +
+              '.prototype[Symbol.unscopables] should be in the descriptor'
+          );
+          assert_equals(
+            typeof desc.value,
+            'object',
+            this.name + '.prototype[Symbol.unscopables] should be an object'
+          );
+          assert_equals(
+            Object.getPrototypeOf(desc.value),
+            null,
+            this.name +
+              '.prototype[Symbol.unscopables] should have a null prototype'
+          );
+          assert_equals(
+            Object.getOwnPropertySymbols(desc.value).length,
+            0,
+            this.name +
+              '.prototype[Symbol.unscopables] should have the right number of symbol-named properties'
+          );
+
+          // Check that we do not have _extra_ unscopables.  Checking that we
+          // have all the ones we should will happen in the per-member tests.
+          var observed = Object.getOwnPropertyNames(desc.value);
+          for (var prop of observed) {
+            assert_not_equals(
+              unscopables.indexOf(prop),
+              -1,
+              this.name +
+                '.prototype[Symbol.unscopables] has unexpected property "' +
+                prop +
+                '"'
+            );
+          }
         } else {
-            assert_equals(Object.getOwnPropertyDescriptor(this.get_interface_object().prototype, Symbol.unscopables),
-                          undefined,
-                          this.name + '.prototype should not have @@unscopables');
+          assert_equals(
+            Object.getOwnPropertyDescriptor(
+              this.get_interface_object().prototype,
+              Symbol.unscopables
+            ),
+            undefined,
+            this.name + '.prototype should not have @@unscopables'
+          );
         }
-    }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s @@unscopables property');
-};
-
-IdlInterface.prototype.test_immutable_prototype = function(type, obj)
-{
-    if (typeof Object.setPrototypeOf !== "function") {
-        return;
+      }.bind(this),
+      this.name +
+        " interface: existence and properties of interface prototype object's @@unscopables property"
+    );
+  };
+
+  IdlInterface.prototype.test_immutable_prototype = function(type, obj) {
+    if (typeof Object.setPrototypeOf !== 'function') {
+      return;
     }
 
-    subsetTestByKey(this.name, test, function(t) {
+    subsetTestByKey(
+      this.name,
+      test,
+      function(t) {
         var originalValue = Object.getPrototypeOf(obj);
         var newValue = Object.create(null);
 
         t.add_cleanup(function() {
-            try {
-                Object.setPrototypeOf(obj, originalValue);
-            } catch (err) {}
+          try {
+            Object.setPrototypeOf(obj, originalValue);
+          } catch (err) {}
         });
 
         assert_throws(new TypeError(), function() {
-            Object.setPrototypeOf(obj, newValue);
+          Object.setPrototypeOf(obj, newValue);
         });
 
         assert_equals(
-                Object.getPrototypeOf(obj),
-                originalValue,
-                "original value not modified"
-            );
-    }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +
-        "of " + type + " - setting to a new value via Object.setPrototypeOf " +
-        "should throw a TypeError");
-
-    subsetTestByKey(this.name, test, function(t) {
+          Object.getPrototypeOf(obj),
+          originalValue,
+          'original value not modified'
+        );
+      }.bind(this),
+      this.name +
+        ' interface: internal [[SetPrototypeOf]] method ' +
+        'of ' +
+        type +
+        ' - setting to a new value via Object.setPrototypeOf ' +
+        'should throw a TypeError'
+    );
+
+    subsetTestByKey(
+      this.name,
+      test,
+      function(t) {
         var originalValue = Object.getPrototypeOf(obj);
         var newValue = Object.create(null);
 
         t.add_cleanup(function() {
-            var setter = Object.getOwnPropertyDescriptor(
-                Object.prototype, '__proto__'
-            ).set;
-
-            try {
-                setter.call(obj, originalValue);
-            } catch (err) {}
+          var setter = Object.getOwnPropertyDescriptor(
+            Object.prototype,
+            '__proto__'
+          ).set;
+
+          try {
+            setter.call(obj, originalValue);
+          } catch (err) {}
         });
 
         assert_throws(new TypeError(), function() {
-            obj.__proto__ = newValue;
+          obj.__proto__ = newValue;
         });
 
         assert_equals(
-                Object.getPrototypeOf(obj),
-                originalValue,
-                "original value not modified"
-            );
-    }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +
-        "of " + type + " - setting to a new value via __proto__ " +
-        "should throw a TypeError");
-
-    subsetTestByKey(this.name, test, function(t) {
+          Object.getPrototypeOf(obj),
+          originalValue,
+          'original value not modified'
+        );
+      }.bind(this),
+      this.name +
+        ' interface: internal [[SetPrototypeOf]] method ' +
+        'of ' +
+        type +
+        ' - setting to a new value via __proto__ ' +
+        'should throw a TypeError'
+    );
+
+    subsetTestByKey(
+      this.name,
+      test,
+      function(t) {
         var originalValue = Object.getPrototypeOf(obj);
         var newValue = Object.create(null);
 
         t.add_cleanup(function() {
-            try {
-                Reflect.setPrototypeOf(obj, originalValue);
-            } catch (err) {}
+          try {
+            Reflect.setPrototypeOf(obj, originalValue);
+          } catch (err) {}
         });
 
         assert_false(Reflect.setPrototypeOf(obj, newValue));
 
         assert_equals(
-                Object.getPrototypeOf(obj),
-                originalValue,
-                "original value not modified"
-            );
-    }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +
-        "of " + type + " - setting to a new value via Reflect.setPrototypeOf " +
-        "should return false");
-
-    subsetTestByKey(this.name, test, function() {
+          Object.getPrototypeOf(obj),
+          originalValue,
+          'original value not modified'
+        );
+      }.bind(this),
+      this.name +
+        ' interface: internal [[SetPrototypeOf]] method ' +
+        'of ' +
+        type +
+        ' - setting to a new value via Reflect.setPrototypeOf ' +
+        'should return false'
+    );
+
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         var originalValue = Object.getPrototypeOf(obj);
 
         Object.setPrototypeOf(obj, originalValue);
-    }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +
-        "of " + type + " - setting to its original value via Object.setPrototypeOf " +
-        "should not throw");
-
-    subsetTestByKey(this.name, test, function() {
+      }.bind(this),
+      this.name +
+        ' interface: internal [[SetPrototypeOf]] method ' +
+        'of ' +
+        type +
+        ' - setting to its original value via Object.setPrototypeOf ' +
+        'should not throw'
+    );
+
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         var originalValue = Object.getPrototypeOf(obj);
 
         obj.__proto__ = originalValue;
-    }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +
-        "of " + type + " - setting to its original value via __proto__ " +
-        "should not throw");
-
-    subsetTestByKey(this.name, test, function() {
+      }.bind(this),
+      this.name +
+        ' interface: internal [[SetPrototypeOf]] method ' +
+        'of ' +
+        type +
+        ' - setting to its original value via __proto__ ' +
+        'should not throw'
+    );
+
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         var originalValue = Object.getPrototypeOf(obj);
 
         assert_true(Reflect.setPrototypeOf(obj, originalValue));
-    }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " +
-        "of " + type + " - setting to its original value via Reflect.setPrototypeOf " +
-        "should return true");
-};
-
-IdlInterface.prototype.test_member_const = function(member)
-{
+      }.bind(this),
+      this.name +
+        ' interface: internal [[SetPrototypeOf]] method ' +
+        'of ' +
+        type +
+        ' - setting to its original value via Reflect.setPrototypeOf ' +
+        'should return true'
+    );
+  };
+
+  IdlInterface.prototype.test_member_const = function(member) {
     if (!this.has_constants()) {
-        throw new IdlHarnessError("Internal error: test_member_const called without any constants");
+      throw new IdlHarnessError(
+        'Internal error: test_member_const called without any constants'
+      );
     }
 
-    subsetTestByKey(this.name, test, function()
-    {
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         this.assert_interface_object_exists();
 
         // "For each constant defined on an interface A, there must be
@@ -2010,168 +2505,252 @@ IdlInterface.prototype.test_member_const = function(member)
         // "The value of the property is that which is obtained by
         // converting the constant’s IDL value to an ECMAScript
         // value."
-        assert_equals(this.get_interface_object()[member.name], constValue(member.value),
-                      "property has wrong value");
+        assert_equals(
+          this.get_interface_object()[member.name],
+          constValue(member.value),
+          'property has wrong value'
+        );
         // "The property has attributes { [[Writable]]: false,
         // [[Enumerable]]: true, [[Configurable]]: false }."
-        var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), member.name);
-        assert_false("get" in desc, "property should not have a getter");
-        assert_false("set" in desc, "property should not have a setter");
-        assert_false(desc.writable, "property should not be writable");
-        assert_true(desc.enumerable, "property should be enumerable");
-        assert_false(desc.configurable, "property should not be configurable");
-    }.bind(this), this.name + " interface: constant " + member.name + " on interface object");
+        var desc = Object.getOwnPropertyDescriptor(
+          this.get_interface_object(),
+          member.name
+        );
+        assert_false('get' in desc, 'property should not have a getter');
+        assert_false('set' in desc, 'property should not have a setter');
+        assert_false(desc.writable, 'property should not be writable');
+        assert_true(desc.enumerable, 'property should be enumerable');
+        assert_false(desc.configurable, 'property should not be configurable');
+      }.bind(this),
+      this.name + ' interface: constant ' + member.name + ' on interface object'
+    );
 
     // "In addition, a property with the same characteristics must
     // exist on the interface prototype object."
-    subsetTestByKey(this.name, test, function()
-    {
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         this.assert_interface_object_exists();
 
         if (this.is_callback()) {
-            assert_false("prototype" in this.get_interface_object(),
-                         this.name + ' should not have a "prototype" property');
-            return;
+          assert_false(
+            'prototype' in this.get_interface_object(),
+            this.name + ' should not have a "prototype" property'
+          );
+          return;
         }
 
-        assert_own_property(this.get_interface_object(), "prototype",
-                            'interface "' + this.name + '" does not have own property "prototype"');
+        assert_own_property(
+          this.get_interface_object(),
+          'prototype',
+          'interface "' + this.name + '" does not have own property "prototype"'
+        );
 
         assert_own_property(this.get_interface_object().prototype, member.name);
-        assert_equals(this.get_interface_object().prototype[member.name], constValue(member.value),
-                      "property has wrong value");
-        var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), member.name);
-        assert_false("get" in desc, "property should not have a getter");
-        assert_false("set" in desc, "property should not have a setter");
-        assert_false(desc.writable, "property should not be writable");
-        assert_true(desc.enumerable, "property should be enumerable");
-        assert_false(desc.configurable, "property should not be configurable");
-    }.bind(this), this.name + " interface: constant " + member.name + " on interface prototype object");
-};
-
-
-IdlInterface.prototype.test_member_attribute = function(member)
-  {
+        assert_equals(
+          this.get_interface_object().prototype[member.name],
+          constValue(member.value),
+          'property has wrong value'
+        );
+        var desc = Object.getOwnPropertyDescriptor(
+          this.get_interface_object(),
+          member.name
+        );
+        assert_false('get' in desc, 'property should not have a getter');
+        assert_false('set' in desc, 'property should not have a setter');
+        assert_false(desc.writable, 'property should not be writable');
+        assert_true(desc.enumerable, 'property should be enumerable');
+        assert_false(desc.configurable, 'property should not be configurable');
+      }.bind(this),
+      this.name +
+        ' interface: constant ' +
+        member.name +
+        ' on interface prototype object'
+    );
+  };
+
+  IdlInterface.prototype.test_member_attribute = function(member) {
     if (!shouldRunSubTest(this.name)) {
-        return;
+      return;
     }
-    var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: attribute " + member.name);
-    a_test.step(function()
-    {
+    var a_test = subsetTestByKey(
+      this.name,
+      async_test,
+      this.name + ' interface: attribute ' + member.name
+    );
+    a_test.step(
+      function() {
         if (this.is_callback() && !this.has_constants()) {
-            a_test.done()
-            return;
+          a_test.done();
+          return;
         }
 
         this.assert_interface_object_exists();
-        assert_own_property(this.get_interface_object(), "prototype",
-                            'interface "' + this.name + '" does not have own property "prototype"');
-
-        if (member["static"]) {
-            assert_own_property(this.get_interface_object(), member.name,
-                "The interface object must have a property " +
-                format_value(member.name));
-            a_test.done();
-            return;
+        assert_own_property(
+          this.get_interface_object(),
+          'prototype',
+          'interface "' + this.name + '" does not have own property "prototype"'
+        );
+
+        if (member['static']) {
+          assert_own_property(
+            this.get_interface_object(),
+            member.name,
+            'The interface object must have a property ' +
+              format_value(member.name)
+          );
+          a_test.done();
+          return;
         }
 
         this.do_member_unscopable_asserts(member);
 
         if (this.is_global()) {
-            assert_own_property(self, member.name,
-                "The global object must have a property " +
-                format_value(member.name));
-            assert_false(member.name in this.get_interface_object().prototype,
-                "The prototype object should not have a property " +
-                format_value(member.name));
-
-            var getter = Object.getOwnPropertyDescriptor(self, member.name).get;
-            assert_equals(typeof(getter), "function",
-                          format_value(member.name) + " must have a getter");
-
-            // Try/catch around the get here, since it can legitimately throw.
-            // If it does, we obviously can't check for equality with direct
-            // invocation of the getter.
-            var gotValue;
-            var propVal;
-            try {
-                propVal = self[member.name];
-                gotValue = true;
-            } catch (e) {
-                gotValue = false;
-            }
-            if (gotValue) {
-                assert_equals(propVal, getter.call(undefined),
-                              "Gets on a global should not require an explicit this");
-            }
+          assert_own_property(
+            self,
+            member.name,
+            'The global object must have a property ' +
+              format_value(member.name)
+          );
+          assert_false(
+            member.name in this.get_interface_object().prototype,
+            'The prototype object should not have a property ' +
+              format_value(member.name)
+          );
+
+          var getter = Object.getOwnPropertyDescriptor(self, member.name).get;
+          assert_equals(
+            typeof getter,
+            'function',
+            format_value(member.name) + ' must have a getter'
+          );
+
+          // Try/catch around the get here, since it can legitimately throw.
+          // If it does, we obviously can't check for equality with direct
+          // invocation of the getter.
+          var gotValue;
+          var propVal;
+          try {
+            propVal = self[member.name];
+            gotValue = true;
+          } catch (e) {
+            gotValue = false;
+          }
+          if (gotValue) {
+            assert_equals(
+              propVal,
+              getter.call(undefined),
+              'Gets on a global should not require an explicit this'
+            );
+          }
 
-            // do_interface_attribute_asserts must be the last thing we do,
-            // since it will call done() on a_test.
-            this.do_interface_attribute_asserts(self, member, a_test);
+          // do_interface_attribute_asserts must be the last thing we do,
+          // since it will call done() on a_test.
+          this.do_interface_attribute_asserts(self, member, a_test);
         } else {
-            assert_true(member.name in this.get_interface_object().prototype,
-                "The prototype object must have a property " +
-                format_value(member.name));
-
-            if (!member.has_extended_attribute("LenientThis")) {
-                if (member.idlType.generic !== "Promise") {
-                    assert_throws(new TypeError(), function() {
-                        this.get_interface_object().prototype[member.name];
-                    }.bind(this), "getting property on prototype object must throw TypeError");
-                    // do_interface_attribute_asserts must be the last thing we
-                    // do, since it will call done() on a_test.
-                    this.do_interface_attribute_asserts(this.get_interface_object().prototype, member, a_test);
-                } else {
-                    promise_rejects(a_test, new TypeError(),
-                                    this.get_interface_object().prototype[member.name])
-                        .then(function() {
-                            // do_interface_attribute_asserts must be the last
-                            // thing we do, since it will call done() on a_test.
-                            this.do_interface_attribute_asserts(this.get_interface_object().prototype,
-                                                                member, a_test);
-                        }.bind(this));
-                }
+          assert_true(
+            member.name in this.get_interface_object().prototype,
+            'The prototype object must have a property ' +
+              format_value(member.name)
+          );
+
+          if (!member.has_extended_attribute('LenientThis')) {
+            if (member.idlType.generic !== 'Promise') {
+              assert_throws(
+                new TypeError(),
+                function() {
+                  this.get_interface_object().prototype[member.name];
+                }.bind(this),
+                'getting property on prototype object must throw TypeError'
+              );
+              // do_interface_attribute_asserts must be the last thing we
+              // do, since it will call done() on a_test.
+              this.do_interface_attribute_asserts(
+                this.get_interface_object().prototype,
+                member,
+                a_test
+              );
             } else {
-                assert_equals(this.get_interface_object().prototype[member.name], undefined,
-                              "getting property on prototype object must return undefined");
-              // do_interface_attribute_asserts must be the last thing we do,
-              // since it will call done() on a_test.
-              this.do_interface_attribute_asserts(this.get_interface_object().prototype, member, a_test);
+              promise_rejects(
+                a_test,
+                new TypeError(),
+                this.get_interface_object().prototype[member.name]
+              ).then(
+                function() {
+                  // do_interface_attribute_asserts must be the last
+                  // thing we do, since it will call done() on a_test.
+                  this.do_interface_attribute_asserts(
+                    this.get_interface_object().prototype,
+                    member,
+                    a_test
+                  );
+                }.bind(this)
+              );
             }
+          } else {
+            assert_equals(
+              this.get_interface_object().prototype[member.name],
+              undefined,
+              'getting property on prototype object must return undefined'
+            );
+            // do_interface_attribute_asserts must be the last thing we do,
+            // since it will call done() on a_test.
+            this.do_interface_attribute_asserts(
+              this.get_interface_object().prototype,
+              member,
+              a_test
+            );
+          }
         }
-    }.bind(this));
-};
+      }.bind(this)
+    );
+  };
 
-IdlInterface.prototype.test_member_operation = function(member)
-{
+  IdlInterface.prototype.test_member_operation = function(member) {
     if (!shouldRunSubTest(this.name)) {
-        return;
+      return;
     }
-    var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: operation " + member.name +
-                            "(" + member.arguments.map(
-                                function(m) {return m.idlType.idlType; } ).join(", ")
-                            +")");
-    a_test.step(function()
-    {
+    var a_test = subsetTestByKey(
+      this.name,
+      async_test,
+      this.name +
+        ' interface: operation ' +
+        member.name +
+        '(' +
+        member.arguments
+          .map(function(m) {
+            return m.idlType.idlType;
+          })
+          .join(', ') +
+        ')'
+    );
+    a_test.step(
+      function() {
         // This function tests WebIDL as of 2015-12-29.
         // https://heycam.github.io/webidl/#es-operations
 
         if (this.is_callback() && !this.has_constants()) {
-            a_test.done();
-            return;
+          a_test.done();
+          return;
         }
 
         this.assert_interface_object_exists();
 
         if (this.is_callback()) {
-            assert_false("prototype" in this.get_interface_object(),
-                         this.name + ' should not have a "prototype" property');
-            a_test.done();
-            return;
+          assert_false(
+            'prototype' in this.get_interface_object(),
+            this.name + ' should not have a "prototype" property'
+          );
+          a_test.done();
+          return;
         }
 
-        assert_own_property(this.get_interface_object(), "prototype",
-                            'interface "' + this.name + '" does not have own property "prototype"');
+        assert_own_property(
+          this.get_interface_object(),
+          'prototype',
+          'interface "' + this.name + '" does not have own property "prototype"'
+        );
 
         // "For each unique identifier of an exposed operation defined on the
         // interface, there must exist a corresponding property, unless the
@@ -2184,87 +2763,140 @@ IdlInterface.prototype.test_member_operation = function(member)
         var memberHolderObject;
         // "* If the operation is static, then the property exists on the
         //    interface object."
-        if (member["static"]) {
-            assert_own_property(this.get_interface_object(), member.name,
-                    "interface object missing static operation");
-            memberHolderObject = this.get_interface_object();
-        // "* Otherwise, [...] if the interface was declared with the [Global]
-        //    extended attribute, then the property exists
-        //    on every object that implements the interface."
+        if (member['static']) {
+          assert_own_property(
+            this.get_interface_object(),
+            member.name,
+            'interface object missing static operation'
+          );
+          memberHolderObject = this.get_interface_object();
+          // "* Otherwise, [...] if the interface was declared with the [Global]
+          //    extended attribute, then the property exists
+          //    on every object that implements the interface."
         } else if (this.is_global()) {
-            assert_own_property(self, member.name,
-                    "global object missing non-static operation");
-            memberHolderObject = self;
-        // "* Otherwise, the property exists solely on the interface’s
-        //    interface prototype object."
+          assert_own_property(
+            self,
+            member.name,
+            'global object missing non-static operation'
+          );
+          memberHolderObject = self;
+          // "* Otherwise, the property exists solely on the interface’s
+          //    interface prototype object."
         } else {
-            assert_own_property(this.get_interface_object().prototype, member.name,
-                    "interface prototype object missing non-static operation");
-            memberHolderObject = this.get_interface_object().prototype;
+          assert_own_property(
+            this.get_interface_object().prototype,
+            member.name,
+            'interface prototype object missing non-static operation'
+          );
+          memberHolderObject = this.get_interface_object().prototype;
         }
         this.do_member_unscopable_asserts(member);
         this.do_member_operation_asserts(memberHolderObject, member, a_test);
-    }.bind(this));
-};
+      }.bind(this)
+    );
+  };
 
-IdlInterface.prototype.do_member_unscopable_asserts = function(member)
-{
+  IdlInterface.prototype.do_member_unscopable_asserts = function(member) {
     // Check that if the member is unscopable then it's in the
     // @@unscopables object properly.
     if (!member.isUnscopable) {
-        return;
+      return;
     }
 
     var unscopables = this.get_interface_object().prototype[Symbol.unscopables];
     var prop = member.name;
     var propDesc = Object.getOwnPropertyDescriptor(unscopables, prop);
-    assert_equals(typeof propDesc, "object",
-                  this.name + '.prototype[Symbol.unscopables].' + prop + ' must exist')
-    assert_false("get" in propDesc,
-                 this.name + '.prototype[Symbol.unscopables].' + prop + ' must have no getter');
-    assert_false("set" in propDesc,
-                 this.name + '.prototype[Symbol.unscopables].' + prop + ' must have no setter');
-    assert_true(propDesc.writable,
-                this.name + '.prototype[Symbol.unscopables].' + prop + ' must be writable');
-    assert_true(propDesc.enumerable,
-                this.name + '.prototype[Symbol.unscopables].' + prop + ' must be enumerable');
-    assert_true(propDesc.configurable,
-                this.name + '.prototype[Symbol.unscopables].' + prop + ' must be configurable');
-    assert_equals(propDesc.value, true,
-                  this.name + '.prototype[Symbol.unscopables].' + prop + ' must have the value `true`');
-};
-
-IdlInterface.prototype.do_member_operation_asserts = function(memberHolderObject, member, a_test)
-{
+    assert_equals(
+      typeof propDesc,
+      'object',
+      this.name + '.prototype[Symbol.unscopables].' + prop + ' must exist'
+    );
+    assert_false(
+      'get' in propDesc,
+      this.name +
+        '.prototype[Symbol.unscopables].' +
+        prop +
+        ' must have no getter'
+    );
+    assert_false(
+      'set' in propDesc,
+      this.name +
+        '.prototype[Symbol.unscopables].' +
+        prop +
+        ' must have no setter'
+    );
+    assert_true(
+      propDesc.writable,
+      this.name + '.prototype[Symbol.unscopables].' + prop + ' must be writable'
+    );
+    assert_true(
+      propDesc.enumerable,
+      this.name +
+        '.prototype[Symbol.unscopables].' +
+        prop +
+        ' must be enumerable'
+    );
+    assert_true(
+      propDesc.configurable,
+      this.name +
+        '.prototype[Symbol.unscopables].' +
+        prop +
+        ' must be configurable'
+    );
+    assert_equals(
+      propDesc.value,
+      true,
+      this.name +
+        '.prototype[Symbol.unscopables].' +
+        prop +
+        ' must have the value `true`'
+    );
+  };
+
+  IdlInterface.prototype.do_member_operation_asserts = function(
+    memberHolderObject,
+    member,
+    a_test
+  ) {
     var done = a_test.done.bind(a_test);
     var operationUnforgeable = member.isUnforgeable;
     var desc = Object.getOwnPropertyDescriptor(memberHolderObject, member.name);
     // "The property has attributes { [[Writable]]: B,
     // [[Enumerable]]: true, [[Configurable]]: B }, where B is false if the
     // operation is unforgeable on the interface, and true otherwise".
-    assert_false("get" in desc, "property should not have a getter");
-    assert_false("set" in desc, "property should not have a setter");
-    assert_equals(desc.writable, !operationUnforgeable,
-                  "property should be writable if and only if not unforgeable");
-    assert_true(desc.enumerable, "property should be enumerable");
-    assert_equals(desc.configurable, !operationUnforgeable,
-                  "property should be configurable if and only if not unforgeable");
+    assert_false('get' in desc, 'property should not have a getter');
+    assert_false('set' in desc, 'property should not have a setter');
+    assert_equals(
+      desc.writable,
+      !operationUnforgeable,
+      'property should be writable if and only if not unforgeable'
+    );
+    assert_true(desc.enumerable, 'property should be enumerable');
+    assert_equals(
+      desc.configurable,
+      !operationUnforgeable,
+      'property should be configurable if and only if not unforgeable'
+    );
     // "The value of the property is a Function object whose
     // behavior is as follows . . ."
-    assert_equals(typeof memberHolderObject[member.name], "function",
-                  "property must be a function");
+    assert_equals(
+      typeof memberHolderObject[member.name],
+      'function',
+      'property must be a function'
+    );
 
     const ctors = this.members.filter(function(m) {
-        return m.type == "operation" && m.name == member.name;
+      return m.type == 'operation' && m.name == member.name;
     });
     assert_equals(
-        memberHolderObject[member.name].length,
-        minOverloadLength(ctors),
-        "property has wrong .length");
+      memberHolderObject[member.name].length,
+      minOverloadLength(ctors),
+      'property has wrong .length'
+    );
 
     // Make some suitable arguments
     var args = member.arguments.map(function(arg) {
-        return create_suitable_object(arg.idlType);
+      return create_suitable_object(arg.idlType);
     });
 
     // "Let O be a value determined as follows:
@@ -2277,275 +2909,434 @@ IdlInterface.prototype.do_member_operation_asserts = function(memberHolderObject
     // check for globals, since otherwise we'll invoke window.close().  And we
     // have to skip this test for anything that on the proto chain of "self",
     // since that does in fact have implicit-this behavior.
-    if (!member["static"]) {
-        var cb;
-        if (!this.is_global() &&
-            memberHolderObject[member.name] != self[member.name])
-        {
-            cb = awaitNCallbacks(2, done);
-            throwOrReject(a_test, member, memberHolderObject[member.name], null, args,
-                          "calling operation with this = null didn't throw TypeError", cb);
-        } else {
-            cb = awaitNCallbacks(1, done);
-        }
-
-        // ". . . If O is not null and is also not a platform object
-        // that implements interface I, throw a TypeError."
-        //
-        // TODO: Test a platform object that implements some other
-        // interface.  (Have to be sure to get inheritance right.)
-        throwOrReject(a_test, member, memberHolderObject[member.name], {}, args,
-                      "calling operation with this = {} didn't throw TypeError", cb);
+    if (!member['static']) {
+      var cb;
+      if (
+        !this.is_global() &&
+        memberHolderObject[member.name] != self[member.name]
+      ) {
+        cb = awaitNCallbacks(2, done);
+        throwOrReject(
+          a_test,
+          member,
+          memberHolderObject[member.name],
+          null,
+          args,
+          "calling operation with this = null didn't throw TypeError",
+          cb
+        );
+      } else {
+        cb = awaitNCallbacks(1, done);
+      }
+
+      // ". . . If O is not null and is also not a platform object
+      // that implements interface I, throw a TypeError."
+      //
+      // TODO: Test a platform object that implements some other
+      // interface.  (Have to be sure to get inheritance right.)
+      throwOrReject(
+        a_test,
+        member,
+        memberHolderObject[member.name],
+        {},
+        args,
+        "calling operation with this = {} didn't throw TypeError",
+        cb
+      );
     } else {
-        done();
+      done();
     }
-}
-
-IdlInterface.prototype.add_iterable_members = function(member)
-{
-    this.members.push(new IdlInterfaceMember(
-        { type: "operation", name: "entries", idlType: "iterator", arguments: []}));
-    this.members.push(new IdlInterfaceMember(
-        { type: "operation", name: "keys", idlType: "iterator", arguments: []}));
-    this.members.push(new IdlInterfaceMember(
-        { type: "operation", name: "values", idlType: "iterator", arguments: []}));
-    this.members.push(new IdlInterfaceMember(
-        { type: "operation", name: "forEach", idlType: "void",
-          arguments:
-          [{ name: "callback", idlType: {idlType: "function"}},
-           { name: "thisValue", idlType: {idlType: "any"}, optional: true}]}));
-};
-
-IdlInterface.prototype.test_to_json_operation = function(memberHolderObject, member) {
-    var instanceName = memberHolderObject && memberHolderObject.constructor.name
-        || member.name + " object";
-    if (member.has_extended_attribute("Default")) {
-        subsetTestByKey(this.name, test, function() {
-            var map = this.default_to_json_operation();
-            var json = memberHolderObject.toJSON();
-            map.forEach(function(type, k) {
-                assert_true(k in json, "property " + JSON.stringify(k) + " should be present in the output of " + this.name + ".prototype.toJSON()");
-                var descriptor = Object.getOwnPropertyDescriptor(json, k);
-                assert_true(descriptor.writable, "property " + k + " should be writable");
-                assert_true(descriptor.configurable, "property " + k + " should be configurable");
-                assert_true(descriptor.enumerable, "property " + k + " should be enumerable");
-                this.array.assert_type_is(json[k], type);
-                delete json[k];
-            }, this);
-        }.bind(this), "Test default toJSON operation of " + instanceName);
+  };
+
+  IdlInterface.prototype.add_iterable_members = function(member) {
+    this.members.push(
+      new IdlInterfaceMember({
+        type: 'operation',
+        name: 'entries',
+        idlType: 'iterator',
+        arguments: []
+      })
+    );
+    this.members.push(
+      new IdlInterfaceMember({
+        type: 'operation',
+        name: 'keys',
+        idlType: 'iterator',
+        arguments: []
+      })
+    );
+    this.members.push(
+      new IdlInterfaceMember({
+        type: 'operation',
+        name: 'values',
+        idlType: 'iterator',
+        arguments: []
+      })
+    );
+    this.members.push(
+      new IdlInterfaceMember({
+        type: 'operation',
+        name: 'forEach',
+        idlType: 'void',
+        arguments: [
+          { name: 'callback', idlType: { idlType: 'function' } },
+          { name: 'thisValue', idlType: { idlType: 'any' }, optional: true }
+        ]
+      })
+    );
+  };
+
+  IdlInterface.prototype.test_to_json_operation = function(
+    memberHolderObject,
+    member
+  ) {
+    var instanceName =
+      (memberHolderObject && memberHolderObject.constructor.name) ||
+      member.name + ' object';
+    if (member.has_extended_attribute('Default')) {
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          var map = this.default_to_json_operation();
+          var json = memberHolderObject.toJSON();
+          map.forEach(function(type, k) {
+            assert_true(
+              k in json,
+              'property ' +
+                JSON.stringify(k) +
+                ' should be present in the output of ' +
+                this.name +
+                '.prototype.toJSON()'
+            );
+            var descriptor = Object.getOwnPropertyDescriptor(json, k);
+            assert_true(
+              descriptor.writable,
+              'property ' + k + ' should be writable'
+            );
+            assert_true(
+              descriptor.configurable,
+              'property ' + k + ' should be configurable'
+            );
+            assert_true(
+              descriptor.enumerable,
+              'property ' + k + ' should be enumerable'
+            );
+            this.array.assert_type_is(json[k], type);
+            delete json[k];
+          }, this);
+        }.bind(this),
+        'Test default toJSON operation of ' + instanceName
+      );
     } else {
-        subsetTestByKey(this.name, test, function() {
-            assert_true(this.array.is_json_type(member.idlType), JSON.stringify(member.idlType) + " is not an appropriate return value for the toJSON operation of " + instanceName);
-            this.array.assert_type_is(memberHolderObject.toJSON(), member.idlType);
-        }.bind(this), "Test toJSON operation of " + instanceName);
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          assert_true(
+            this.array.is_json_type(member.idlType),
+            JSON.stringify(member.idlType) +
+              ' is not an appropriate return value for the toJSON operation of ' +
+              instanceName
+          );
+          this.array.assert_type_is(
+            memberHolderObject.toJSON(),
+            member.idlType
+          );
+        }.bind(this),
+        'Test toJSON operation of ' + instanceName
+      );
     }
-};
+  };
 
-IdlInterface.prototype.test_member_iterable = function(member)
-{
+  IdlInterface.prototype.test_member_iterable = function(member) {
     var isPairIterator = member.idlType.length === 2;
-    subsetTestByKey(this.name, test, function()
-    {
-        var descriptor = Object.getOwnPropertyDescriptor(this.get_interface_object().prototype, Symbol.iterator);
-        assert_true(descriptor.writable, "property should be writable");
-        assert_true(descriptor.configurable, "property should be configurable");
-        assert_false(descriptor.enumerable, "property should not be enumerable");
-        assert_equals(this.get_interface_object().prototype[Symbol.iterator].name, isPairIterator ? "entries" : "values", "@@iterator function does not have the right name");
-    }.bind(this), "Testing Symbol.iterator property of iterable interface " + this.name);
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
+        var descriptor = Object.getOwnPropertyDescriptor(
+          this.get_interface_object().prototype,
+          Symbol.iterator
+        );
+        assert_true(descriptor.writable, 'property should be writable');
+        assert_true(descriptor.configurable, 'property should be configurable');
+        assert_false(
+          descriptor.enumerable,
+          'property should not be enumerable'
+        );
+        assert_equals(
+          this.get_interface_object().prototype[Symbol.iterator].name,
+          isPairIterator ? 'entries' : 'values',
+          '@@iterator function does not have the right name'
+        );
+      }.bind(this),
+      'Testing Symbol.iterator property of iterable interface ' + this.name
+    );
 
     if (isPairIterator) {
-        subsetTestByKey(this.name, test, function() {
-            assert_equals(this.get_interface_object().prototype[Symbol.iterator], this.get_interface_object().prototype["entries"], "entries method is not the same as @@iterator");
-        }.bind(this), "Testing pair iterable interface " + this.name);
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          assert_equals(
+            this.get_interface_object().prototype[Symbol.iterator],
+            this.get_interface_object().prototype['entries'],
+            'entries method is not the same as @@iterator'
+          );
+        }.bind(this),
+        'Testing pair iterable interface ' + this.name
+      );
     } else {
-        subsetTestByKey(this.name, test, function() {
-            ["entries", "keys", "values", "forEach", Symbol.Iterator].forEach(function(property) {
-                assert_equals(this.get_interface_object().prototype[property], Array.prototype[property], property + " function is not the same as Array one");
-            }.bind(this));
-        }.bind(this), "Testing value iterable interface " + this.name);
-    }
-};
-
-IdlInterface.prototype.test_member_stringifier = function(member)
-{
-    subsetTestByKey(this.name, test, function()
-    {
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          ['entries', 'keys', 'values', 'forEach', Symbol.Iterator].forEach(
+            function(property) {
+              assert_equals(
+                this.get_interface_object().prototype[property],
+                Array.prototype[property],
+                property + ' function is not the same as Array one'
+              );
+            }.bind(this)
+          );
+        }.bind(this),
+        'Testing value iterable interface ' + this.name
+      );
+    }
+  };
+
+  IdlInterface.prototype.test_member_stringifier = function(member) {
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
         if (this.is_callback() && !this.has_constants()) {
-            return;
+          return;
         }
 
         this.assert_interface_object_exists();
 
         if (this.is_callback()) {
-            assert_false("prototype" in this.get_interface_object(),
-                         this.name + ' should not have a "prototype" property');
-            return;
+          assert_false(
+            'prototype' in this.get_interface_object(),
+            this.name + ' should not have a "prototype" property'
+          );
+          return;
         }
 
-        assert_own_property(this.get_interface_object(), "prototype",
-                            'interface "' + this.name + '" does not have own property "prototype"');
+        assert_own_property(
+          this.get_interface_object(),
+          'prototype',
+          'interface "' + this.name + '" does not have own property "prototype"'
+        );
 
         // ". . . the property exists on the interface prototype object."
         var interfacePrototypeObject = this.get_interface_object().prototype;
-        assert_own_property(interfacePrototypeObject, "toString",
-                "interface prototype object missing non-static operation");
+        assert_own_property(
+          interfacePrototypeObject,
+          'toString',
+          'interface prototype object missing non-static operation'
+        );
 
         var stringifierUnforgeable = member.isUnforgeable;
-        var desc = Object.getOwnPropertyDescriptor(interfacePrototypeObject, "toString");
+        var desc = Object.getOwnPropertyDescriptor(
+          interfacePrototypeObject,
+          'toString'
+        );
         // "The property has attributes { [[Writable]]: B,
         // [[Enumerable]]: true, [[Configurable]]: B }, where B is false if the
         // stringifier is unforgeable on the interface, and true otherwise."
-        assert_false("get" in desc, "property should not have a getter");
-        assert_false("set" in desc, "property should not have a setter");
-        assert_equals(desc.writable, !stringifierUnforgeable,
-                      "property should be writable if and only if not unforgeable");
-        assert_true(desc.enumerable, "property should be enumerable");
-        assert_equals(desc.configurable, !stringifierUnforgeable,
-                      "property should be configurable if and only if not unforgeable");
+        assert_false('get' in desc, 'property should not have a getter');
+        assert_false('set' in desc, 'property should not have a setter');
+        assert_equals(
+          desc.writable,
+          !stringifierUnforgeable,
+          'property should be writable if and only if not unforgeable'
+        );
+        assert_true(desc.enumerable, 'property should be enumerable');
+        assert_equals(
+          desc.configurable,
+          !stringifierUnforgeable,
+          'property should be configurable if and only if not unforgeable'
+        );
         // "The value of the property is a Function object, which behaves as
         // follows . . ."
-        assert_equals(typeof interfacePrototypeObject.toString, "function",
-                      "property must be a function");
+        assert_equals(
+          typeof interfacePrototypeObject.toString,
+          'function',
+          'property must be a function'
+        );
         // "The value of the Function object’s “length” property is the Number
         // value 0."
-        assert_equals(interfacePrototypeObject.toString.length, 0,
-            "property has wrong .length");
+        assert_equals(
+          interfacePrototypeObject.toString.length,
+          0,
+          'property has wrong .length'
+        );
 
         // "Let O be the result of calling ToObject on the this value."
-        assert_throws(new TypeError(), function() {
+        assert_throws(
+          new TypeError(),
+          function() {
             interfacePrototypeObject.toString.apply(null, []);
-        }, "calling stringifier with this = null didn't throw TypeError");
+          },
+          "calling stringifier with this = null didn't throw TypeError"
+        );
 
         // "If O is not an object that implements the interface on which the
         // stringifier was declared, then throw a TypeError."
         //
         // TODO: Test a platform object that implements some other
         // interface.  (Have to be sure to get inheritance right.)
-        assert_throws(new TypeError(), function() {
+        assert_throws(
+          new TypeError(),
+          function() {
             interfacePrototypeObject.toString.apply({}, []);
-        }, "calling stringifier with this = {} didn't throw TypeError");
-    }.bind(this), this.name + " interface: stringifier");
-};
-
-IdlInterface.prototype.test_members = function()
-{
-    for (var i = 0; i < this.members.length; i++)
-    {
-        var member = this.members[i];
-        switch (member.type) {
-        case "iterable":
-            this.add_iterable_members(member);
-            break;
+          },
+          "calling stringifier with this = {} didn't throw TypeError"
+        );
+      }.bind(this),
+      this.name + ' interface: stringifier'
+    );
+  };
+
+  IdlInterface.prototype.test_members = function() {
+    for (var i = 0; i < this.members.length; i++) {
+      var member = this.members[i];
+      switch (member.type) {
+        case 'iterable':
+          this.add_iterable_members(member);
+          break;
         // TODO: add setlike and maplike handling.
         default:
-            break;
-        }
+          break;
+      }
     }
 
-    for (var i = 0; i < this.members.length; i++)
-    {
-        var member = this.members[i];
-        if (member.untested) {
-            continue;
-        }
-
-        if (!exposed_in(exposure_set(member, this.exposureSet))) {
-            subsetTestByKey(this.name, test, function() {
-                // It's not exposed, so we shouldn't find it anywhere.
-                assert_false(member.name in this.get_interface_object(),
-                             "The interface object must not have a property " +
-                             format_value(member.name));
-                assert_false(member.name in this.get_interface_object().prototype,
-                             "The prototype object must not have a property " +
-                             format_value(member.name));
-            }.bind(this), this.name + " interface: member " + member.name);
-            continue;
-        }
+    for (var i = 0; i < this.members.length; i++) {
+      var member = this.members[i];
+      if (member.untested) {
+        continue;
+      }
+
+      if (!exposed_in(exposure_set(member, this.exposureSet))) {
+        subsetTestByKey(
+          this.name,
+          test,
+          function() {
+            // It's not exposed, so we shouldn't find it anywhere.
+            assert_false(
+              member.name in this.get_interface_object(),
+              'The interface object must not have a property ' +
+                format_value(member.name)
+            );
+            assert_false(
+              member.name in this.get_interface_object().prototype,
+              'The prototype object must not have a property ' +
+                format_value(member.name)
+            );
+          }.bind(this),
+          this.name + ' interface: member ' + member.name
+        );
+        continue;
+      }
 
-        switch (member.type) {
-        case "const":
-            this.test_member_const(member);
-            break;
+      switch (member.type) {
+        case 'const':
+          this.test_member_const(member);
+          break;
 
-        case "attribute":
-            // For unforgeable attributes, we do the checks in
-            // test_interface_of instead.
-            if (!member.isUnforgeable)
-            {
-                this.test_member_attribute(member);
-            }
-            if (member.stringifier) {
-                this.test_member_stringifier(member);
-            }
-            break;
+        case 'attribute':
+          // For unforgeable attributes, we do the checks in
+          // test_interface_of instead.
+          if (!member.isUnforgeable) {
+            this.test_member_attribute(member);
+          }
+          if (member.stringifier) {
+            this.test_member_stringifier(member);
+          }
+          break;
 
-        case "operation":
-            // TODO: Need to correctly handle multiple operations with the same
-            // identifier.
-            // For unforgeable operations, we do the checks in
-            // test_interface_of instead.
-            if (member.name) {
-                if (!member.isUnforgeable)
-                {
-                    this.test_member_operation(member);
-                }
-            } else if (member.stringifier) {
-                this.test_member_stringifier(member);
+        case 'operation':
+          // TODO: Need to correctly handle multiple operations with the same
+          // identifier.
+          // For unforgeable operations, we do the checks in
+          // test_interface_of instead.
+          if (member.name) {
+            if (!member.isUnforgeable) {
+              this.test_member_operation(member);
             }
-            break;
-
-        case "iterable":
-            this.test_member_iterable(member);
-            break;
+          } else if (member.stringifier) {
+            this.test_member_stringifier(member);
+          }
+          break;
+
+        case 'iterable':
+          this.test_member_iterable(member);
+          break;
         default:
-            // TODO: check more member types.
-            break;
-        }
+          // TODO: check more member types.
+          break;
+      }
     }
-};
+  };
 
-IdlInterface.prototype.test_object = function(desc)
-{
-    var obj, exception = null;
-    try
-    {
-        obj = eval(desc);
-    }
-    catch(e)
-    {
-        exception = e;
+  IdlInterface.prototype.test_object = function(desc) {
+    var obj,
+      exception = null;
+    try {
+      obj = eval(desc);
+    } catch (e) {
+      exception = e;
     }
 
-    var expected_typeof =
-        this.members.some(function(member) { return member.legacycaller; })
-        ? "function"
-        : "object";
+    var expected_typeof = this.members.some(function(member) {
+      return member.legacycaller;
+    })
+      ? 'function'
+      : 'object';
 
     this.test_primary_interface_of(desc, obj, exception, expected_typeof);
 
     var current_interface = this;
-    while (current_interface)
-    {
-        if (!(current_interface.name in this.array.members))
-        {
-            throw new IdlHarnessError("Interface " + current_interface.name + " not found (inherited by " + this.name + ")");
-        }
-        if (current_interface.prevent_multiple_testing && current_interface.already_tested)
-        {
-            return;
-        }
-        current_interface.test_interface_of(desc, obj, exception, expected_typeof);
-        current_interface = this.array.members[current_interface.base];
+    while (current_interface) {
+      if (!(current_interface.name in this.array.members)) {
+        throw new IdlHarnessError(
+          'Interface ' +
+            current_interface.name +
+            ' not found (inherited by ' +
+            this.name +
+            ')'
+        );
+      }
+      if (
+        current_interface.prevent_multiple_testing &&
+        current_interface.already_tested
+      ) {
+        return;
+      }
+      current_interface.test_interface_of(
+        desc,
+        obj,
+        exception,
+        expected_typeof
+      );
+      current_interface = this.array.members[current_interface.base];
     }
-};
-
-IdlInterface.prototype.test_primary_interface_of = function(desc, obj, exception, expected_typeof)
-{
+  };
+
+  IdlInterface.prototype.test_primary_interface_of = function(
+    desc,
+    obj,
+    exception,
+    expected_typeof
+  ) {
     // Only the object itself, not its members, are tested here, so if the
     // interface is untested, there is nothing to do.
-    if (this.untested)
-    {
-        return;
+    if (this.untested) {
+      return;
     }
 
     // "The internal [[SetPrototypeOf]] method of every platform object that
@@ -2554,216 +3345,340 @@ IdlInterface.prototype.test_primary_interface_of = function(desc, obj, exception
     // [[SetPrototypeOf]] internal method of an immutable prototype exotic
     // object."
     // https://heycam.github.io/webidl/#platform-object-setprototypeof
-    if (this.is_global())
-    {
-        this.test_immutable_prototype("global platform object", obj);
+    if (this.is_global()) {
+      this.test_immutable_prototype('global platform object', obj);
     }
 
-
     // We can't easily test that its prototype is correct if there's no
     // interface object, or the object is from a different global environment
     // (not instanceof Object).  TODO: test in this case that its prototype at
     // least looks correct, even if we can't test that it's actually correct.
-    if (!this.has_extended_attribute("NoInterfaceObject")
-    && (typeof obj != expected_typeof || obj instanceof Object))
-    {
-        subsetTestByKey(this.name, test, function()
-        {
-            assert_equals(exception, null, "Unexpected exception when evaluating object");
-            assert_equals(typeof obj, expected_typeof, "wrong typeof object");
-            this.assert_interface_object_exists();
-            assert_own_property(this.get_interface_object(), "prototype",
-                                'interface "' + this.name + '" does not have own property "prototype"');
-
-            // "The value of the internal [[Prototype]] property of the
-            // platform object is the interface prototype object of the primary
-            // interface from the platform object’s associated global
-            // environment."
-            assert_equals(Object.getPrototypeOf(obj),
-                          this.get_interface_object().prototype,
-                          desc + "'s prototype is not " + this.name + ".prototype");
-        }.bind(this), this.name + " must be primary interface of " + desc);
+    if (
+      !this.has_extended_attribute('NoInterfaceObject') &&
+      (typeof obj != expected_typeof || obj instanceof Object)
+    ) {
+      subsetTestByKey(
+        this.name,
+        test,
+        function() {
+          assert_equals(
+            exception,
+            null,
+            'Unexpected exception when evaluating object'
+          );
+          assert_equals(typeof obj, expected_typeof, 'wrong typeof object');
+          this.assert_interface_object_exists();
+          assert_own_property(
+            this.get_interface_object(),
+            'prototype',
+            'interface "' +
+              this.name +
+              '" does not have own property "prototype"'
+          );
+
+          // "The value of the internal [[Prototype]] property of the
+          // platform object is the interface prototype object of the primary
+          // interface from the platform object’s associated global
+          // environment."
+          assert_equals(
+            Object.getPrototypeOf(obj),
+            this.get_interface_object().prototype,
+            desc + "'s prototype is not " + this.name + '.prototype'
+          );
+        }.bind(this),
+        this.name + ' must be primary interface of ' + desc
+      );
     }
 
     // "The class string of a platform object that implements one or more
     // interfaces must be the qualified name of the primary interface of the
     // platform object."
-    subsetTestByKey(this.name, test, function()
-    {
-        assert_equals(exception, null, "Unexpected exception when evaluating object");
-        assert_equals(typeof obj, expected_typeof, "wrong typeof object");
-        assert_class_string(obj, this.get_qualified_name(), "class string of " + desc);
-        if (!this.has_stringifier())
-        {
-            assert_equals(String(obj), "[object " + this.get_qualified_name() + "]", "String(" + desc + ")");
+    subsetTestByKey(
+      this.name,
+      test,
+      function() {
+        assert_equals(
+          exception,
+          null,
+          'Unexpected exception when evaluating object'
+        );
+        assert_equals(typeof obj, expected_typeof, 'wrong typeof object');
+        assert_class_string(
+          obj,
+          this.get_qualified_name(),
+          'class string of ' + desc
+        );
+        if (!this.has_stringifier()) {
+          assert_equals(
+            String(obj),
+            '[object ' + this.get_qualified_name() + ']',
+            'String(' + desc + ')'
+          );
         }
-    }.bind(this), "Stringification of " + desc);
-};
-
-IdlInterface.prototype.test_interface_of = function(desc, obj, exception, expected_typeof)
-{
+      }.bind(this),
+      'Stringification of ' + desc
+    );
+  };
+
+  IdlInterface.prototype.test_interface_of = function(
+    desc,
+    obj,
+    exception,
+    expected_typeof
+  ) {
     // TODO: Indexed and named properties, more checks on interface members
     this.already_tested = true;
     if (!shouldRunSubTest(this.name)) {
-        return;
+      return;
     }
 
-    for (var i = 0; i < this.members.length; i++)
-    {
-        var member = this.members[i];
-        if (member.untested) {
-            continue;
-        }
-        if (!exposed_in(exposure_set(member, this.exposureSet))) {
-            subsetTestByKey(this.name, test, function() {
-                assert_equals(exception, null, "Unexpected exception when evaluating object");
-                assert_false(member.name in obj);
-            }.bind(this), this.name + " interface: " + desc + ' must not have property "' + member.name + '"');
-            continue;
-        }
-        if (member.type == "attribute" && member.isUnforgeable)
-        {
-            var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: " + desc + ' must have own property "' + member.name + '"');
-            a_test.step(function() {
-                assert_equals(exception, null, "Unexpected exception when evaluating object");
-                assert_equals(typeof obj, expected_typeof, "wrong typeof object");
-                // Call do_interface_attribute_asserts last, since it will call a_test.done()
-                this.do_interface_attribute_asserts(obj, member, a_test);
-            }.bind(this));
-        }
-        else if (member.type == "operation" &&
-                 member.name &&
-                 member.isUnforgeable)
-        {
-            var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: " + desc + ' must have own property "' + member.name + '"');
-            a_test.step(function()
-            {
-                assert_equals(exception, null, "Unexpected exception when evaluating object");
-                assert_equals(typeof obj, expected_typeof, "wrong typeof object");
-                assert_own_property(obj, member.name,
-                                    "Doesn't have the unforgeable operation property");
-                this.do_member_operation_asserts(obj, member, a_test);
-            }.bind(this));
-        }
-        else if ((member.type == "const"
-        || member.type == "attribute"
-        || member.type == "operation")
-        && member.name)
-        {
-            var described_name = member.name;
-            if (member.type == "operation")
-            {
-                described_name += "(" + member.arguments.map(arg => arg.idlType.idlType).join(", ") + ")";
-            }
-            subsetTestByKey(this.name, test, function()
-            {
-                assert_equals(exception, null, "Unexpected exception when evaluating object");
-                assert_equals(typeof obj, expected_typeof, "wrong typeof object");
-                if (!member["static"]) {
-                    if (!this.is_global()) {
-                        assert_inherits(obj, member.name);
-                    } else {
-                        assert_own_property(obj, member.name);
-                    }
-
-                    if (member.type == "const")
-                    {
-                        assert_equals(obj[member.name], constValue(member.value));
-                    }
-                    if (member.type == "attribute")
-                    {
-                        // Attributes are accessor properties, so they might
-                        // legitimately throw an exception rather than returning
-                        // anything.
-                        var property, thrown = false;
-                        try
-                        {
-                            property = obj[member.name];
-                        }
-                        catch (e)
-                        {
-                            thrown = true;
-                        }
-                        if (!thrown)
-                        {
-                            this.array.assert_type_is(property, member.idlType);
-                        }
-                    }
-                    if (member.type == "operation")
-                    {
-                        assert_equals(typeof obj[member.name], "function");
-                    }
-                }
-            }.bind(this), this.name + " interface: " + desc + ' must inherit property "' + described_name + '" with the proper type');
+    for (var i = 0; i < this.members.length; i++) {
+      var member = this.members[i];
+      if (member.untested) {
+        continue;
+      }
+      if (!exposed_in(exposure_set(member, this.exposureSet))) {
+        subsetTestByKey(
+          this.name,
+          test,
+          function() {
+            assert_equals(
+              exception,
+              null,
+              'Unexpected exception when evaluating object'
+            );
+            assert_false(member.name in obj);
+          }.bind(this),
+          this.name +
+            ' interface: ' +
+            desc +
+            ' must not have property "' +
+            member.name +
+            '"'
+        );
+        continue;
+      }
+      if (member.type == 'attribute' && member.isUnforgeable) {
+        var a_test = subsetTestByKey(
+          this.name,
+          async_test,
+          this.name +
+            ' interface: ' +
+            desc +
+            ' must have own property "' +
+            member.name +
+            '"'
+        );
+        a_test.step(
+          function() {
+            assert_equals(
+              exception,
+              null,
+              'Unexpected exception when evaluating object'
+            );
+            assert_equals(typeof obj, expected_typeof, 'wrong typeof object');
+            // Call do_interface_attribute_asserts last, since it will call a_test.done()
+            this.do_interface_attribute_asserts(obj, member, a_test);
+          }.bind(this)
+        );
+      } else if (
+        member.type == 'operation' &&
+        member.name &&
+        member.isUnforgeable
+      ) {
+        var a_test = subsetTestByKey(
+          this.name,
+          async_test,
+          this.name +
+            ' interface: ' +
+            desc +
+            ' must have own property "' +
+            member.name +
+            '"'
+        );
+        a_test.step(
+          function() {
+            assert_equals(
+              exception,
+              null,
+              'Unexpected exception when evaluating object'
+            );
+            assert_equals(typeof obj, expected_typeof, 'wrong typeof object');
+            assert_own_property(
+              obj,
+              member.name,
+              "Doesn't have the unforgeable operation property"
+            );
+            this.do_member_operation_asserts(obj, member, a_test);
+          }.bind(this)
+        );
+      } else if (
+        (member.type == 'const' ||
+          member.type == 'attribute' ||
+          member.type == 'operation') &&
+        member.name
+      ) {
+        var described_name = member.name;
+        if (member.type == 'operation') {
+          described_name +=
+            '(' +
+            member.arguments.map((arg) => arg.idlType.idlType).join(', ') +
+            ')';
         }
-        // TODO: This is wrong if there are multiple operations with the same
-        // identifier.
-        // TODO: Test passing arguments of the wrong type.
-        if (member.type == "operation" && member.name && member.arguments.length)
-        {
-            var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: calling " + member.name +
-            "(" + member.arguments.map(function(m) { return m.idlType.idlType; }).join(", ") +
-            ") on " + desc + " with too few arguments must throw TypeError");
-            a_test.step(function()
-            {
-                assert_equals(exception, null, "Unexpected exception when evaluating object");
-                assert_equals(typeof obj, expected_typeof, "wrong typeof object");
-                var fn;
-                if (!member["static"]) {
-                    if (!this.is_global() && !member.isUnforgeable) {
-                        assert_inherits(obj, member.name);
-                    } else {
-                        assert_own_property(obj, member.name);
-                    }
-                    fn = obj[member.name];
+        subsetTestByKey(
+          this.name,
+          test,
+          function() {
+            assert_equals(
+              exception,
+              null,
+              'Unexpected exception when evaluating object'
+            );
+            assert_equals(typeof obj, expected_typeof, 'wrong typeof object');
+            if (!member['static']) {
+              if (!this.is_global()) {
+                assert_inherits(obj, member.name);
+              } else {
+                assert_own_property(obj, member.name);
+              }
+
+              if (member.type == 'const') {
+                assert_equals(obj[member.name], constValue(member.value));
+              }
+              if (member.type == 'attribute') {
+                // Attributes are accessor properties, so they might
+                // legitimately throw an exception rather than returning
+                // anything.
+                var property,
+                  thrown = false;
+                try {
+                  property = obj[member.name];
+                } catch (e) {
+                  thrown = true;
                 }
-                else
-                {
-                    assert_own_property(obj.constructor, member.name, "interface object must have static operation as own property");
-                    fn = obj.constructor[member.name];
+                if (!thrown) {
+                  this.array.assert_type_is(property, member.idlType);
                 }
+              }
+              if (member.type == 'operation') {
+                assert_equals(typeof obj[member.name], 'function');
+              }
+            }
+          }.bind(this),
+          this.name +
+            ' interface: ' +
+            desc +
+            ' must inherit property "' +
+            described_name +
+            '" with the proper type'
+        );
+      }
+      // TODO: This is wrong if there are multiple operations with the same
+      // identifier.
+      // TODO: Test passing arguments of the wrong type.
+      if (
+        member.type == 'operation' &&
+        member.name &&
+        member.arguments.length
+      ) {
+        var a_test = subsetTestByKey(
+          this.name,
+          async_test,
+          this.name +
+            ' interface: calling ' +
+            member.name +
+            '(' +
+            member.arguments
+              .map(function(m) {
+                return m.idlType.idlType;
+              })
+              .join(', ') +
+            ') on ' +
+            desc +
+            ' with too few arguments must throw TypeError'
+        );
+        a_test.step(
+          function() {
+            assert_equals(
+              exception,
+              null,
+              'Unexpected exception when evaluating object'
+            );
+            assert_equals(typeof obj, expected_typeof, 'wrong typeof object');
+            var fn;
+            if (!member['static']) {
+              if (!this.is_global() && !member.isUnforgeable) {
+                assert_inherits(obj, member.name);
+              } else {
+                assert_own_property(obj, member.name);
+              }
+              fn = obj[member.name];
+            } else {
+              assert_own_property(
+                obj.constructor,
+                member.name,
+                'interface object must have static operation as own property'
+              );
+              fn = obj.constructor[member.name];
+            }
 
-                var minLength = minOverloadLength(this.members.filter(function(m) {
-                    return m.type == "operation" && m.name == member.name;
-                }));
-                var args = [];
-                var cb = awaitNCallbacks(minLength, a_test.done.bind(a_test));
-                for (var i = 0; i < minLength; i++) {
-                    throwOrReject(a_test, member, fn, obj, args, "Called with " + i + " arguments", cb);
-
-                    args.push(create_suitable_object(member.arguments[i].idlType));
-                }
-                if (minLength === 0) {
-                    cb();
-                }
-            }.bind(this));
-        }
+            var minLength = minOverloadLength(
+              this.members.filter(function(m) {
+                return m.type == 'operation' && m.name == member.name;
+              })
+            );
+            var args = [];
+            var cb = awaitNCallbacks(minLength, a_test.done.bind(a_test));
+            for (var i = 0; i < minLength; i++) {
+              throwOrReject(
+                a_test,
+                member,
+                fn,
+                obj,
+                args,
+                'Called with ' + i + ' arguments',
+                cb
+              );
+
+              args.push(create_suitable_object(member.arguments[i].idlType));
+            }
+            if (minLength === 0) {
+              cb();
+            }
+          }.bind(this)
+        );
+      }
 
-        if (member.is_to_json_regular_operation()) {
-            this.test_to_json_operation(obj, member);
-        }
+      if (member.is_to_json_regular_operation()) {
+        this.test_to_json_operation(obj, member);
+      }
     }
-};
+  };
 
-IdlInterface.prototype.has_stringifier = function()
-{
-    if (this.name === "DOMException") {
-        // toString is inherited from Error, so don't assume we have the
-        // default stringifer
-        return true;
+  IdlInterface.prototype.has_stringifier = function() {
+    if (this.name === 'DOMException') {
+      // toString is inherited from Error, so don't assume we have the
+      // default stringifer
+      return true;
     }
-    if (this.members.some(function(member) { return member.stringifier; })) {
-        return true;
+    if (
+      this.members.some(function(member) {
+        return member.stringifier;
+      })
+    ) {
+      return true;
     }
-    if (this.base &&
-        this.array.members[this.base].has_stringifier()) {
-        return true;
+    if (this.base && this.array.members[this.base].has_stringifier()) {
+      return true;
     }
     return false;
-};
+  };
 
-IdlInterface.prototype.do_interface_attribute_asserts = function(obj, member, a_test)
-{
+  IdlInterface.prototype.do_interface_attribute_asserts = function(
+    obj,
+    member,
+    a_test
+  ) {
     // This function tests WebIDL as of 2015-01-27.
     // TODO: Consider [Exposed].
 
@@ -2788,173 +3703,210 @@ IdlInterface.prototype.do_interface_attribute_asserts = function(obj, member, a_
     // "G is the attribute getter, defined below; and
     // "S is the attribute setter, also defined below."
     var desc = Object.getOwnPropertyDescriptor(obj, member.name);
-    assert_false("value" in desc, 'property descriptor should not have a "value" field');
-    assert_false("writable" in desc, 'property descriptor should not have a "writable" field');
-    assert_true(desc.enumerable, "property should be enumerable");
-    if (member.isUnforgeable)
-    {
-        assert_false(desc.configurable, "[Unforgeable] property must not be configurable");
-    }
-    else
-    {
-        assert_true(desc.configurable, "property must be configurable");
+    assert_false(
+      'value' in desc,
+      'property descriptor should not have a "value" field'
+    );
+    assert_false(
+      'writable' in desc,
+      'property descriptor should not have a "writable" field'
+    );
+    assert_true(desc.enumerable, 'property should be enumerable');
+    if (member.isUnforgeable) {
+      assert_false(
+        desc.configurable,
+        '[Unforgeable] property must not be configurable'
+      );
+    } else {
+      assert_true(desc.configurable, 'property must be configurable');
     }
 
-
     // "The attribute getter is a Function object whose behavior when invoked
     // is as follows:"
-    assert_equals(typeof desc.get, "function", "getter must be Function");
+    assert_equals(typeof desc.get, 'function', 'getter must be Function');
 
     // "If the attribute is a regular attribute, then:"
-    if (!member["static"]) {
-        // "If O is not a platform object that implements I, then:
-        // "If the attribute was specified with the [LenientThis] extended
-        // attribute, then return undefined.
-        // "Otherwise, throw a TypeError."
-        if (!member.has_extended_attribute("LenientThis")) {
-            if (member.idlType.generic !== "Promise") {
-                assert_throws(new TypeError(), function() {
-                    desc.get.call({});
-                }.bind(this), "calling getter on wrong object type must throw TypeError");
-            } else {
-                pendingPromises.push(
-                    promise_rejects(a_test, new TypeError(), desc.get.call({}),
-                                    "calling getter on wrong object type must reject the return promise with TypeError"));
-            }
+    if (!member['static']) {
+      // "If O is not a platform object that implements I, then:
+      // "If the attribute was specified with the [LenientThis] extended
+      // attribute, then return undefined.
+      // "Otherwise, throw a TypeError."
+      if (!member.has_extended_attribute('LenientThis')) {
+        if (member.idlType.generic !== 'Promise') {
+          assert_throws(
+            new TypeError(),
+            function() {
+              desc.get.call({});
+            }.bind(this),
+            'calling getter on wrong object type must throw TypeError'
+          );
         } else {
-            assert_equals(desc.get.call({}), undefined,
-                          "calling getter on wrong object type must return undefined");
+          pendingPromises.push(
+            promise_rejects(
+              a_test,
+              new TypeError(),
+              desc.get.call({}),
+              'calling getter on wrong object type must reject the return promise with TypeError'
+            )
+          );
         }
+      } else {
+        assert_equals(
+          desc.get.call({}),
+          undefined,
+          'calling getter on wrong object type must return undefined'
+        );
+      }
     }
 
     // "The value of the Function object’s “length” property is the Number
     // value 0."
-    assert_equals(desc.get.length, 0, "getter length must be 0");
+    assert_equals(desc.get.length, 0, 'getter length must be 0');
 
     // "Let name be the string "get " prepended to attribute’s identifier."
     // "Perform ! SetFunctionName(F, name)."
-    assert_equals(desc.get.name, "get " + member.name,
-        "getter must have the name 'get " + member.name + "'");
-
+    assert_equals(
+      desc.get.name,
+      'get ' + member.name,
+      "getter must have the name 'get " + member.name + "'"
+    );
 
     // TODO: Test calling setter on the interface prototype (should throw
     // TypeError in most cases).
-    if (member.readonly
-    && !member.has_extended_attribute("LenientSetter")
-    && !member.has_extended_attribute("PutForwards")
-    && !member.has_extended_attribute("Replaceable"))
-    {
-        // "The attribute setter is undefined if the attribute is declared
-        // readonly and has neither a [PutForwards] nor a [Replaceable]
-        // extended attribute declared on it."
-        assert_equals(desc.set, undefined, "setter must be undefined for readonly attributes");
-    }
-    else
-    {
-        // "Otherwise, it is a Function object whose behavior when
-        // invoked is as follows:"
-        assert_equals(typeof desc.set, "function", "setter must be function for PutForwards, Replaceable, or non-readonly attributes");
-
-        // "If the attribute is a regular attribute, then:"
-        if (!member["static"]) {
-            // "If /validThis/ is false and the attribute was not specified
-            // with the [LenientThis] extended attribute, then throw a
-            // TypeError."
-            // "If the attribute is declared with a [Replaceable] extended
-            // attribute, then: ..."
-            // "If validThis is false, then return."
-            if (!member.has_extended_attribute("LenientThis")) {
-                assert_throws(new TypeError(), function() {
-                    desc.set.call({});
-                }.bind(this), "calling setter on wrong object type must throw TypeError");
-            } else {
-                assert_equals(desc.set.call({}), undefined,
-                              "calling setter on wrong object type must return undefined");
-            }
+    if (
+      member.readonly &&
+      !member.has_extended_attribute('LenientSetter') &&
+      !member.has_extended_attribute('PutForwards') &&
+      !member.has_extended_attribute('Replaceable')
+    ) {
+      // "The attribute setter is undefined if the attribute is declared
+      // readonly and has neither a [PutForwards] nor a [Replaceable]
+      // extended attribute declared on it."
+      assert_equals(
+        desc.set,
+        undefined,
+        'setter must be undefined for readonly attributes'
+      );
+    } else {
+      // "Otherwise, it is a Function object whose behavior when
+      // invoked is as follows:"
+      assert_equals(
+        typeof desc.set,
+        'function',
+        'setter must be function for PutForwards, Replaceable, or non-readonly attributes'
+      );
+
+      // "If the attribute is a regular attribute, then:"
+      if (!member['static']) {
+        // "If /validThis/ is false and the attribute was not specified
+        // with the [LenientThis] extended attribute, then throw a
+        // TypeError."
+        // "If the attribute is declared with a [Replaceable] extended
+        // attribute, then: ..."
+        // "If validThis is false, then return."
+        if (!member.has_extended_attribute('LenientThis')) {
+          assert_throws(
+            new TypeError(),
+            function() {
+              desc.set.call({});
+            }.bind(this),
+            'calling setter on wrong object type must throw TypeError'
+          );
+        } else {
+          assert_equals(
+            desc.set.call({}),
+            undefined,
+            'calling setter on wrong object type must return undefined'
+          );
         }
-
-        // "The value of the Function object’s “length” property is the Number
-        // value 1."
-        assert_equals(desc.set.length, 1, "setter length must be 1");
-
-        // "Let name be the string "set " prepended to id."
-        // "Perform ! SetFunctionName(F, name)."
-        assert_equals(desc.set.name, "set " + member.name,
-            "The attribute setter must have the name 'set " + member.name + "'");
+      }
+
+      // "The value of the Function object’s “length” property is the Number
+      // value 1."
+      assert_equals(desc.set.length, 1, 'setter length must be 1');
+
+      // "Let name be the string "set " prepended to id."
+      // "Perform ! SetFunctionName(F, name)."
+      assert_equals(
+        desc.set.name,
+        'set ' + member.name,
+        "The attribute setter must have the name 'set " + member.name + "'"
+      );
     }
 
     Promise.all(pendingPromises).then(a_test.done.bind(a_test));
-}
+  };
 
-/// IdlInterfaceMember ///
-function IdlInterfaceMember(obj)
-{
+  /// IdlInterfaceMember ///
+  function IdlInterfaceMember(obj) {
     /**
      * obj is an object produced by the WebIDLParser.js "ifMember" production.
      * We just forward all properties to this object without modification,
      * except for special extAttrs handling.
      */
-    for (var k in obj)
-    {
-        this[k] = obj[k];
+    for (var k in obj) {
+      this[k] = obj[k];
     }
-    if (!("extAttrs" in this))
-    {
-        this.extAttrs = [];
+    if (!('extAttrs' in this)) {
+      this.extAttrs = [];
     }
 
-    this.isUnforgeable = this.has_extended_attribute("Unforgeable");
-    this.isUnscopable = this.has_extended_attribute("Unscopable");
-}
+    this.isUnforgeable = this.has_extended_attribute('Unforgeable');
+    this.isUnscopable = this.has_extended_attribute('Unscopable');
+  }
 
-IdlInterfaceMember.prototype = Object.create(IdlObject.prototype);
+  IdlInterfaceMember.prototype = Object.create(IdlObject.prototype);
 
-IdlInterfaceMember.prototype.is_to_json_regular_operation = function() {
-    return this.type == "operation" && !this.static && this.name == "toJSON";
-};
+  IdlInterfaceMember.prototype.is_to_json_regular_operation = function() {
+    return this.type == 'operation' && !this.static && this.name == 'toJSON';
+  };
 
-/// Internal helper functions ///
-function create_suitable_object(type)
-{
+  /// Internal helper functions ///
+  function create_suitable_object(type) {
     /**
      * type is an object produced by the WebIDLParser.js "type" production.  We
      * return a JavaScript value that matches the type, if we can figure out
      * how.
      */
-    if (type.nullable)
-    {
-        return null;
+    if (type.nullable) {
+      return null;
     }
-    switch (type.idlType)
-    {
-        case "any":
-        case "boolean":
-            return true;
-
-        case "byte": case "octet": case "short": case "unsigned short":
-        case "long": case "unsigned long": case "long long":
-        case "unsigned long long": case "float": case "double":
-        case "unrestricted float": case "unrestricted double":
-            return 7;
-
-        case "DOMString":
-        case "ByteString":
-        case "USVString":
-            return "foo";
-
-        case "object":
-            return {a: "b"};
+    switch (type.idlType) {
+      case 'any':
+      case 'boolean':
+        return true;
 
-        case "Node":
-            return document.createTextNode("abc");
+      case 'byte':
+      case 'octet':
+      case 'short':
+      case 'unsigned short':
+      case 'long':
+      case 'unsigned long':
+      case 'long long':
+      case 'unsigned long long':
+      case 'float':
+      case 'double':
+      case 'unrestricted float':
+      case 'unrestricted double':
+        return 7;
+
+      case 'DOMString':
+      case 'ByteString':
+      case 'USVString':
+        return 'foo';
+
+      case 'object':
+        return { a: 'b' };
+
+      case 'Node':
+        return document.createTextNode('abc');
     }
     return null;
-}
+  }
 
-/// IdlEnum ///
-// Used for IdlArray.prototype.assert_type_is
-function IdlEnum(obj)
-{
+  /// IdlEnum ///
+  // Used for IdlArray.prototype.assert_type_is
+  function IdlEnum(obj) {
     /**
      * obj is an object produced by the WebIDLParser.js "dictionary"
      * production.
@@ -2965,15 +3917,13 @@ function IdlEnum(obj)
 
     /** An array of values produced by the "enum" production. */
     this.values = obj.values;
+  }
 
-}
+  IdlEnum.prototype = Object.create(IdlObject.prototype);
 
-IdlEnum.prototype = Object.create(IdlObject.prototype);
-
-/// IdlTypedef ///
-// Used for IdlArray.prototype.assert_type_is
-function IdlTypedef(obj)
-{
+  /// IdlTypedef ///
+  // Used for IdlArray.prototype.assert_type_is
+  function IdlTypedef(obj) {
     /**
      * obj is an object produced by the WebIDLParser.js "typedef"
      * production.
@@ -2984,14 +3934,12 @@ function IdlTypedef(obj)
 
     /** The idlType that we are supposed to be typedeffing to. */
     this.idlType = obj.idlType;
+  }
 
-}
-
-IdlTypedef.prototype = Object.create(IdlObject.prototype);
+  IdlTypedef.prototype = Object.create(IdlObject.prototype);
 
-/// IdlNamespace ///
-function IdlNamespace(obj)
-{
+  /// IdlNamespace ///
+  function IdlNamespace(obj) {
     this.name = obj.name;
     this.extAttrs = obj.extAttrs;
     this.untested = obj.untested;
@@ -2999,91 +3947,113 @@ function IdlNamespace(obj)
     this.array = obj.array;
 
     /** An array of IdlInterfaceMembers. */
-    this.members = obj.members.map(m => new IdlInterfaceMember(m));
-}
+    this.members = obj.members.map((m) => new IdlInterfaceMember(m));
+  }
 
-IdlNamespace.prototype = Object.create(IdlObject.prototype);
+  IdlNamespace.prototype = Object.create(IdlObject.prototype);
 
-IdlNamespace.prototype.do_member_operation_asserts = function (memberHolderObject, member, a_test)
-{
+  IdlNamespace.prototype.do_member_operation_asserts = function(
+    memberHolderObject,
+    member,
+    a_test
+  ) {
     var desc = Object.getOwnPropertyDescriptor(memberHolderObject, member.name);
 
-    assert_false("get" in desc, "property should not have a getter");
-    assert_false("set" in desc, "property should not have a setter");
+    assert_false('get' in desc, 'property should not have a getter');
+    assert_false('set' in desc, 'property should not have a setter');
     assert_equals(
-        desc.writable,
-        !member.isUnforgeable,
-        "property should be writable if and only if not unforgeable");
-    assert_true(desc.enumerable, "property should be enumerable");
+      desc.writable,
+      !member.isUnforgeable,
+      'property should be writable if and only if not unforgeable'
+    );
+    assert_true(desc.enumerable, 'property should be enumerable');
     assert_equals(
-        desc.configurable,
-        !member.isUnforgeable,
-        "property should be configurable if and only if not unforgeable");
+      desc.configurable,
+      !member.isUnforgeable,
+      'property should be configurable if and only if not unforgeable'
+    );
 
     assert_equals(
-        typeof memberHolderObject[member.name],
-        "function",
-         "property must be a function");
+      typeof memberHolderObject[member.name],
+      'function',
+      'property must be a function'
+    );
 
     assert_equals(
-        memberHolderObject[member.name].length,
-        minOverloadLength(this.members.filter(function(m) {
-            return m.type == "operation" && m.name == member.name;
-        })),
-        "operation has wrong .length");
+      memberHolderObject[member.name].length,
+      minOverloadLength(
+        this.members.filter(function(m) {
+          return m.type == 'operation' && m.name == member.name;
+        })
+      ),
+      'operation has wrong .length'
+    );
     a_test.done();
-}
+  };
 
-IdlNamespace.prototype.test_member_operation = function(member)
-{
+  IdlNamespace.prototype.test_member_operation = function(member) {
     if (!shouldRunSubTest(this.name)) {
-        return;
+      return;
     }
-    var args = member.arguments.map(function(a) {
+    var args = member.arguments
+      .map(function(a) {
         var s = a.idlType.idlType;
         if (a.variadic) {
-            s += '...';
+          s += '...';
         }
         return s;
-    }).join(", ");
+      })
+      .join(', ');
     var a_test = subsetTestByKey(
-        this.name,
-        async_test,
-        this.name + ' namespace: operation ' + member.name + '(' + args + ')');
-    a_test.step(function() {
+      this.name,
+      async_test,
+      this.name + ' namespace: operation ' + member.name + '(' + args + ')'
+    );
+    a_test.step(
+      function() {
         assert_own_property(
-            self[this.name],
-            member.name,
-            'namespace object missing operation ' + format_value(member.name));
+          self[this.name],
+          member.name,
+          'namespace object missing operation ' + format_value(member.name)
+        );
 
         this.do_member_operation_asserts(self[this.name], member, a_test);
-    }.bind(this));
-};
+      }.bind(this)
+    );
+  };
 
-IdlNamespace.prototype.test_member_attribute = function (member)
-{
+  IdlNamespace.prototype.test_member_attribute = function(member) {
     if (!shouldRunSubTest(this.name)) {
-        return;
+      return;
     }
     var a_test = subsetTestByKey(
-        this.name,
-        async_test,
-        this.name + ' namespace: attribute ' + member.name);
-    a_test.step(function()
-    {
+      this.name,
+      async_test,
+      this.name + ' namespace: attribute ' + member.name
+    );
+    a_test.step(
+      function() {
         assert_own_property(
-            self[this.name],
-            member.name,
-            this.name + ' does not have property ' + format_value(member.name));
-
-        var desc = Object.getOwnPropertyDescriptor(self[this.name], member.name);
-        assert_equals(desc.set, undefined, "setter must be undefined for namespace members");
+          self[this.name],
+          member.name,
+          this.name + ' does not have property ' + format_value(member.name)
+        );
+
+        var desc = Object.getOwnPropertyDescriptor(
+          self[this.name],
+          member.name
+        );
+        assert_equals(
+          desc.set,
+          undefined,
+          'setter must be undefined for namespace members'
+        );
         a_test.done();
-    }.bind(this));
-};
+      }.bind(this)
+    );
+  };
 
-IdlNamespace.prototype.test = function ()
-{
+  IdlNamespace.prototype.test = function() {
     /**
      * TODO(lukebjerring): Assert:
      * - "Note that unlike interfaces or dictionaries, namespaces do not create types."
@@ -3093,23 +4063,25 @@ IdlNamespace.prototype.test = function ()
      */
 
     for (const v of Object.values(this.members)) {
-        switch (v.type) {
-
+      switch (v.type) {
         case 'operation':
-            this.test_member_operation(v);
-            break;
+          this.test_member_operation(v);
+          break;
 
         case 'attribute':
-            this.test_member_attribute(v);
-            break;
+          this.test_member_attribute(v);
+          break;
 
         default:
-            throw 'Invalid namespace member ' + v.name + ': ' + v.type + ' not supported';
-        }
-    };
-};
-
-}());
+          throw 'Invalid namespace member ' +
+            v.name +
+            ': ' +
+            v.type +
+            ' not supported';
+      }
+    }
+  };
+})();
 
 /**
  * idl_test is a promise_test wrapper that handles the fetching of the IDL,
@@ -3126,55 +4098,58 @@ IdlNamespace.prototype.test = function ()
  *      called by this function (idl_test).
  */
 function idl_test(srcs, deps, idl_setup_func) {
-    return promise_test(function (t) {
-        var idl_array = new IdlArray();
-        srcs = (srcs instanceof Array) ? srcs : [srcs] || [];
-        deps = (deps instanceof Array) ? deps : [deps] || [];
-        var setup_error = null;
-        return Promise.all(
-            srcs.concat(deps).map(function(spec) {
-                return fetch_spec(spec);
-            }))
-            .then(function(idls) {
-                for (var i = 0; i < srcs.length; i++) {
-                    idl_array.add_idls(idls[i]);
-                }
-                for (var i = srcs.length; i < srcs.length + deps.length; i++) {
-                    idl_array.add_dependency_idls(idls[i]);
-                }
-            })
-            .then(function() {
-                if (idl_setup_func) {
-                    return idl_setup_func(idl_array, t);
-                }
-            })
-            .catch(function(e) { setup_error = e || 'IDL setup failed.'; })
-            .then(function () {
-                var error = setup_error;
-                try {
-                    idl_array.test(); // Test what we can.
-                } catch (e) {
-                    // If testing fails hard here, the original setup error
-                    // is more likely to be the real cause.
-                    error = error || e;
-                }
-                if (error) {
-                    throw error;
-                }
-            });
-    }, 'idl_test setup');
+  return promise_test(function(t) {
+    var idl_array = new IdlArray();
+    srcs = srcs instanceof Array ? srcs : [srcs] || [];
+    deps = deps instanceof Array ? deps : [deps] || [];
+    var setup_error = null;
+    return Promise.all(
+      srcs.concat(deps).map(function(spec) {
+        return fetch_spec(spec);
+      })
+    )
+      .then(function(idls) {
+        for (var i = 0; i < srcs.length; i++) {
+          idl_array.add_idls(idls[i]);
+        }
+        for (var i = srcs.length; i < srcs.length + deps.length; i++) {
+          idl_array.add_dependency_idls(idls[i]);
+        }
+      })
+      .then(function() {
+        if (idl_setup_func) {
+          return idl_setup_func(idl_array, t);
+        }
+      })
+      .catch(function(e) {
+        setup_error = e || 'IDL setup failed.';
+      })
+      .then(function() {
+        var error = setup_error;
+        try {
+          idl_array.test(); // Test what we can.
+        } catch (e) {
+          // If testing fails hard here, the original setup error
+          // is more likely to be the real cause.
+          error = error || e;
+        }
+        if (error) {
+          throw error;
+        }
+      });
+  }, 'idl_test setup');
 }
 
 /**
  * fetch_spec is a shorthand for a Promise that fetches the spec's content.
  */
 function fetch_spec(spec) {
-    var url = '/interfaces/' + spec + '.idl';
-    return fetch(url).then(function (r) {
-        if (!r.ok) {
-            throw new IdlHarnessError("Error fetching " + url + ".");
-        }
-        return r.text();
-    });
+  var url = '/interfaces/' + spec + '.idl';
+  return fetch(url).then(function(r) {
+    if (!r.ok) {
+      throw new IdlHarnessError('Error fetching ' + url + '.');
+    }
+    return r.text();
+  });
 }
 // vim: set expandtab shiftwidth=4 tabstop=4 foldmarker=@{,@} foldmethod=marker:
diff --git a/test/fixtures/wpt/resources/sriharness.js b/test/fixtures/wpt/resources/sriharness.js
index b36d29223585ec..a32bb826a1089c 100644
--- a/test/fixtures/wpt/resources/sriharness.js
+++ b/test/fixtures/wpt/resources/sriharness.js
@@ -1,35 +1,50 @@
-var SRIScriptTest = function(pass, name, src, integrityValue, crossoriginValue, nonce) {
-    this.pass = pass;
-    this.name = "Script: " + name;
-    this.src = src;
-    this.integrityValue = integrityValue;
-    this.crossoriginValue = crossoriginValue;
-    this.nonce = nonce;
-}
+var SRIScriptTest = function(
+  pass,
+  name,
+  src,
+  integrityValue,
+  crossoriginValue,
+  nonce
+) {
+  this.pass = pass;
+  this.name = 'Script: ' + name;
+  this.src = src;
+  this.integrityValue = integrityValue;
+  this.crossoriginValue = crossoriginValue;
+  this.nonce = nonce;
+};
 
 SRIScriptTest.prototype.execute = function() {
-    var test = async_test(this.name);
-    var e = document.createElement("script");
-    e.src = this.src;
-    e.setAttribute("integrity", this.integrityValue);
-    if(this.crossoriginValue) {
-        e.setAttribute("crossorigin", this.crossoriginValue);
-    }
-    if(this.nonce) {
-      e.setAttribute("nonce", this.nonce);
-    }
-    if(this.pass) {
-        e.addEventListener("load", function() {test.done()});
-        e.addEventListener("error", function() {
-            test.step(function(){ assert_unreached("Good load fired error handler.") })
-        });
-    } else {
-       e.addEventListener("load", function() {
-            test.step(function() { assert_unreached("Bad load succeeded.") })
-        });
-       e.addEventListener("error", function() {test.done()});
-    }
-    document.body.appendChild(e);
+  var test = async_test(this.name);
+  var e = document.createElement('script');
+  e.src = this.src;
+  e.setAttribute('integrity', this.integrityValue);
+  if (this.crossoriginValue) {
+    e.setAttribute('crossorigin', this.crossoriginValue);
+  }
+  if (this.nonce) {
+    e.setAttribute('nonce', this.nonce);
+  }
+  if (this.pass) {
+    e.addEventListener('load', function() {
+      test.done();
+    });
+    e.addEventListener('error', function() {
+      test.step(function() {
+        assert_unreached('Good load fired error handler.');
+      });
+    });
+  } else {
+    e.addEventListener('load', function() {
+      test.step(function() {
+        assert_unreached('Bad load succeeded.');
+      });
+    });
+    e.addEventListener('error', function() {
+      test.done();
+    });
+  }
+  document.body.appendChild(e);
 };
 
 // <link> tests
@@ -38,62 +53,77 @@ SRIScriptTest.prototype.execute = function() {
 // of executing them one at a time, the style tests are implemented as a
 // queue that builds up a list of tests, and then executes them one at a
 // time.
-var SRIStyleTest = function(queue, pass, name, attrs, customCallback, altPassValue) {
-    this.pass = pass;
-    this.name = "Style: " + name;
-    this.customCallback = customCallback || function () {};
-    this.attrs = attrs || {};
-    this.passValue = altPassValue || "rgb(255, 255, 0)";
+var SRIStyleTest = function(
+  queue,
+  pass,
+  name,
+  attrs,
+  customCallback,
+  altPassValue
+) {
+  this.pass = pass;
+  this.name = 'Style: ' + name;
+  this.customCallback = customCallback || function() {};
+  this.attrs = attrs || {};
+  this.passValue = altPassValue || 'rgb(255, 255, 0)';
 
-    this.test = async_test(this.name);
+  this.test = async_test(this.name);
 
-    this.queue = queue;
-    this.queue.push(this);
-}
+  this.queue = queue;
+  this.queue.push(this);
+};
 
 SRIStyleTest.prototype.execute = function() {
   var that = this;
-    var container = document.getElementById("container");
-    while (container.hasChildNodes()) {
-      container.removeChild(container.firstChild);
-    }
+  var container = document.getElementById('container');
+  while (container.hasChildNodes()) {
+    container.removeChild(container.firstChild);
+  }
 
-    var test = this.test;
+  var test = this.test;
 
-    var div = document.createElement("div");
-    div.className = "testdiv";
-    var e = document.createElement("link");
-    this.attrs.rel = this.attrs.rel || "stylesheet";
-    for (var key in this.attrs) {
-        if (this.attrs.hasOwnProperty(key)) {
-            e.setAttribute(key, this.attrs[key]);
-        }
+  var div = document.createElement('div');
+  div.className = 'testdiv';
+  var e = document.createElement('link');
+  this.attrs.rel = this.attrs.rel || 'stylesheet';
+  for (var key in this.attrs) {
+    if (this.attrs.hasOwnProperty(key)) {
+      e.setAttribute(key, this.attrs[key]);
     }
+  }
 
-    if(this.pass) {
-        e.addEventListener("load", function() {
-            test.step(function() {
-                var background = window.getComputedStyle(div, null).getPropertyValue("background-color");
-                assert_equals(background, that.passValue);
-                test.done();
-            });
-        });
-        e.addEventListener("error", function() {
-            test.step(function(){ assert_unreached("Good load fired error handler.") })
-        });
-    } else {
-        e.addEventListener("load", function() {
-             test.step(function() { assert_unreached("Bad load succeeded.") })
-         });
-        e.addEventListener("error", function() {
-            test.step(function() {
-                var background = window.getComputedStyle(div, null).getPropertyValue("background-color");
-                assert_not_equals(background, that.passValue);
-                test.done();
-            });
-        });
-    }
-    container.appendChild(div);
-    container.appendChild(e);
-    this.customCallback(e, container);
+  if (this.pass) {
+    e.addEventListener('load', function() {
+      test.step(function() {
+        var background = window
+          .getComputedStyle(div, null)
+          .getPropertyValue('background-color');
+        assert_equals(background, that.passValue);
+        test.done();
+      });
+    });
+    e.addEventListener('error', function() {
+      test.step(function() {
+        assert_unreached('Good load fired error handler.');
+      });
+    });
+  } else {
+    e.addEventListener('load', function() {
+      test.step(function() {
+        assert_unreached('Bad load succeeded.');
+      });
+    });
+    e.addEventListener('error', function() {
+      test.step(function() {
+        var background = window
+          .getComputedStyle(div, null)
+          .getPropertyValue('background-color');
+        assert_not_equals(background, that.passValue);
+        test.done();
+      });
+    });
+  }
+  container.appendChild(div);
+  container.appendChild(e);
+  this.customCallback(e, container);
 };
diff --git a/test/fixtures/wpt/resources/testdriver-actions.js b/test/fixtures/wpt/resources/testdriver-actions.js
index 46c68858e45746..89686a212e19f7 100644
--- a/test/fixtures/wpt/resources/testdriver-actions.js
+++ b/test/fixtures/wpt/resources/testdriver-actions.js
@@ -5,9 +5,11 @@
    * Builder for creating a sequence of actions
    */
   function Actions() {
-    this.sourceTypes = new Map([["key", KeySource],
-                                ["pointer", PointerSource],
-                                ["general", GeneralSource]]);
+    this.sourceTypes = new Map([
+      ['key', KeySource],
+      ['pointer', PointerSource],
+      ['general', GeneralSource]
+    ]);
     this.sources = new Map();
     this.sourceOrder = [];
     for (let sourceType of this.sourceTypes.keys()) {
@@ -17,7 +19,7 @@
     for (let sourceType of this.sourceTypes.keys()) {
       this.currentSources.set(sourceType, null);
     }
-    this.createSource("general");
+    this.createSource('general');
     this.tickIdx = 0;
   }
 
@@ -51,7 +53,7 @@
       let actions;
       try {
         actions = this.serialize();
-      } catch(e) {
+      } catch (e) {
         return Promise.reject(e);
       }
       return test_driver.action_sequence(actions);
@@ -97,8 +99,8 @@
      * @param {Bool} set - Set source as the default key source
      * @returns {Actions}
      */
-    addKeyboard: function(name, set=true) {
-      this.createSource("key", name, true);
+    addKeyboard: function(name, set = true) {
+      this.createSource('key', name, true);
       if (set) {
         this.setKeyboard(name);
       }
@@ -112,7 +114,7 @@
      * @returns {Actions}
      */
     setKeyboard: function(name) {
-      this.setSource("key", name);
+      this.setSource('key', name);
       return this;
     },
 
@@ -124,8 +126,8 @@
      * @param {Bool} set - Set source as the default key source
      * @returns {Actions}
      */
-    addPointer: function(name, pointerType="mouse", set=true) {
-      this.createSource("pointer", name, true, {pointerType: pointerType});
+    addPointer: function(name, pointerType = 'mouse', set = true) {
+      this.createSource('pointer', name, true, { pointerType: pointerType });
       if (set) {
         this.setPointer(name);
       }
@@ -139,11 +141,11 @@
      * @returns {Actions}
      */
     setPointer: function(name) {
-      this.setSource("pointer", name);
+      this.setSource('pointer', name);
       return this;
     },
 
-    createSource: function(type, name, parameters={}) {
+    createSource: function(type, name, parameters = {}) {
       if (!this.sources.has(type)) {
         throw new Error(`${type} is not a valid action type`);
       }
@@ -153,14 +155,18 @@
       }
       if (!name) {
         do {
-          name = "" + sourceNameIdx++;
-        } while (sourceNames.has(name))
+          name = '' + sourceNameIdx++;
+        } while (sourceNames.has(name));
       } else {
         if (sourceNames.has(name)) {
-          throw new Error(`Alreay have a source of type ${type} named ${name}.`);
+          throw new Error(
+            `Alreay have a source of type ${type} named ${name}.`
+          );
         }
       }
-      this.sources.get(type).set(name, new (this.sourceTypes.get(type))(parameters));
+      this.sources
+        .get(type)
+        .set(name, new (this.sourceTypes.get(type))(parameters));
       this.currentSources.set(type, name);
       this.sourceOrder.push([type, name]);
       return this.sources.get(type).get(name);
@@ -187,7 +193,7 @@
      * @returns {Actions}
      */
     pause: function(duration) {
-      this.getSource("general").addPause(this, duration);
+      this.getSource('general').addPause(this, duration);
       return this;
     },
 
@@ -198,8 +204,8 @@
      * @param {String?} sourceName - Named key source to use or null for the default key source
      * @returns {Actions}
      */
-    keyDown: function(key, {sourceName=null}={}) {
-      let source = this.getSource("key", sourceName);
+    keyDown: function(key, { sourceName = null } = {}) {
+      let source = this.getSource('key', sourceName);
       source.keyDown(this, key);
       return this;
     },
@@ -211,8 +217,8 @@
      * @param {String?} sourceName - Named key source to use or null for the default key source
      * @returns {Actions}
      */
-    keyUp: function(key, {sourceName=null}={}) {
-      let source = this.getSource("key", sourceName);
+    keyUp: function(key, { sourceName = null } = {}) {
+      let source = this.getSource('key', sourceName);
       source.keyUp(this, key);
       return this;
     },
@@ -225,8 +231,8 @@
      *                               pointer source
      * @returns {Actions}
      */
-    pointerDown: function({button=0, sourceName=null}={}) {
-      let source = this.getSource("pointer", sourceName);
+    pointerDown: function({ button = 0, sourceName = null } = {}) {
+      let source = this.getSource('pointer', sourceName);
       source.pointerDown(this, button);
       return this;
     },
@@ -239,8 +245,8 @@
      *                               source
      * @returns {Actions}
      */
-    pointerUp: function({button=0, sourceName=null}={}) {
-      let source = this.getSource("pointer", sourceName);
+    pointerUp: function({ button = 0, sourceName = null } = {}) {
+      let source = this.getSource('pointer', sourceName);
       source.pointerUp(this, button);
       return this;
     },
@@ -257,12 +263,15 @@
      *                               source
      * @returns {Actions}
      */
-    pointerMove: function(x, y,
-                          {origin="viewport", duration, sourceName=null}={}) {
-      let source = this.getSource("pointer", sourceName);
+    pointerMove: function(
+      x,
+      y,
+      { origin = 'viewport', duration, sourceName = null } = {}
+    ) {
+      let source = this.getSource('pointer', sourceName);
       source.pointerMove(this, x, y, duration, origin);
       return this;
-    },
+    }
   };
 
   function GeneralSource() {
@@ -275,12 +284,12 @@
         return undefined;
       }
       let actions = [];
-      let data = {"type": "none", "actions": actions};
-      for (let i=0; i<tickCount; i++) {
+      let data = { type: 'none', actions: actions };
+      for (let i = 0; i < tickCount; i++) {
         if (this.actions.has(i)) {
           actions.push(this.actions.get(i));
         } else {
-          actions.push({"type": "pause"});
+          actions.push({ type: 'pause' });
         }
       }
       return data;
@@ -291,8 +300,8 @@
       if (this.actions.has(tick)) {
         throw new Error(`Already have a pause action for the current tick`);
       }
-      this.actions.set(tick, {type: "pause", duration: duration});
-    },
+      this.actions.set(tick, { type: 'pause', duration: duration });
+    }
   };
 
   function KeySource() {
@@ -305,12 +314,12 @@
         return undefined;
       }
       let actions = [];
-      let data = {"type": "key", "actions": actions};
-      for (let i=0; i<tickCount; i++) {
+      let data = { type: 'key', actions: actions };
+      for (let i = 0; i < tickCount; i++) {
         if (this.actions.has(i)) {
           actions.push(this.actions.get(i));
         } else {
-          actions.push({"type": "pause"});
+          actions.push({ type: 'pause' });
         }
       }
       return data;
@@ -321,7 +330,7 @@
       if (this.actions.has(tick)) {
         tick = actions.addTick().tickIdx;
       }
-      this.actions.set(tick, {type: "keyDown", value: key});
+      this.actions.set(tick, { type: 'keyDown', value: key });
     },
 
     keyUp: function(actions, key) {
@@ -329,13 +338,13 @@
       if (this.actions.has(tick)) {
         tick = actions.addTick().tickIdx;
       }
-      this.actions.set(tick, {type: "keyUp", value: key});
-    },
+      this.actions.set(tick, { type: 'keyUp', value: key });
+    }
   };
 
-  function PointerSource(parameters={pointerType: "mouse"}) {
-    let pointerType = parameters.pointerType || "mouse";
-    if (!["mouse", "pen", "touch"].includes(pointerType)) {
+  function PointerSource(parameters = { pointerType: 'mouse' }) {
+    let pointerType = parameters.pointerType || 'mouse';
+    if (!['mouse', 'pen', 'touch'].includes(pointerType)) {
       throw new Error(`Invalid pointerType ${pointerType}`);
     }
     this.type = pointerType;
@@ -348,12 +357,16 @@
         return undefined;
       }
       let actions = [];
-      let data = {"type": "pointer", "actions": actions, "parameters": {"pointerType": this.type}};
-      for (let i=0; i<tickCount; i++) {
+      let data = {
+        type: 'pointer',
+        actions: actions,
+        parameters: { pointerType: this.type }
+      };
+      for (let i = 0; i < tickCount; i++) {
         if (this.actions.has(i)) {
           actions.push(this.actions.get(i));
         } else {
-          actions.push({"type": "pause"});
+          actions.push({ type: 'pause' });
         }
       }
       return data;
@@ -364,7 +377,7 @@
       if (this.actions.has(tick)) {
         tick = actions.addTick().tickIdx;
       }
-      this.actions.set(tick, {type: "pointerDown", button});
+      this.actions.set(tick, { type: 'pointerDown', button });
     },
 
     pointerUp: function(actions, button) {
@@ -372,7 +385,7 @@
       if (this.actions.has(tick)) {
         tick = actions.addTick().tickIdx;
       }
-      this.actions.set(tick, {type: "pointerUp", button});
+      this.actions.set(tick, { type: 'pointerUp', button });
     },
 
     pointerMove: function(actions, x, y, duration, origin) {
@@ -380,11 +393,11 @@
       if (this.actions.has(tick)) {
         tick = actions.addTick().tickIdx;
       }
-      this.actions.set(tick, {type: "pointerMove", x, y, origin});
+      this.actions.set(tick, { type: 'pointerMove', x, y, origin });
       if (duration) {
         this.actions.get(tick).duration = duration;
       }
-    },
+    }
   };
 
   test_driver.Actions = Actions;
diff --git a/test/fixtures/wpt/resources/testdriver.js b/test/fixtures/wpt/resources/testdriver.js
index e0741e8d61d4d6..8f310b7b15c7a9 100644
--- a/test/fixtures/wpt/resources/testdriver.js
+++ b/test/fixtures/wpt/resources/testdriver.js
@@ -1,179 +1,200 @@
 (function() {
-    "use strict";
-    var idCounter = 0;
+  'use strict';
+  var idCounter = 0;
 
-    function getInViewCenterPoint(rect) {
-        var left = Math.max(0, rect.left);
-        var right = Math.min(window.innerWidth, rect.right);
-        var top = Math.max(0, rect.top);
-        var bottom = Math.min(window.innerHeight, rect.bottom);
+  function getInViewCenterPoint(rect) {
+    var left = Math.max(0, rect.left);
+    var right = Math.min(window.innerWidth, rect.right);
+    var top = Math.max(0, rect.top);
+    var bottom = Math.min(window.innerHeight, rect.bottom);
 
-        var x = 0.5 * (left + right);
-        var y = 0.5 * (top + bottom);
+    var x = 0.5 * (left + right);
+    var y = 0.5 * (top + bottom);
 
-        return [x, y];
+    return [x, y];
+  }
+
+  function getPointerInteractablePaintTree(element) {
+    if (!window.document.contains(element)) {
+      return [];
     }
 
-    function getPointerInteractablePaintTree(element) {
-        if (!window.document.contains(element)) {
-            return [];
-        }
+    var rectangles = element.getClientRects();
 
-        var rectangles = element.getClientRects();
+    if (rectangles.length === 0) {
+      return [];
+    }
 
-        if (rectangles.length === 0) {
-            return [];
-        }
+    var centerPoint = getInViewCenterPoint(rectangles[0]);
+
+    if ('elementsFromPoint' in document) {
+      return document.elementsFromPoint(centerPoint[0], centerPoint[1]);
+    } else if ('msElementsFromPoint' in document) {
+      var rv = document.msElementsFromPoint(centerPoint[0], centerPoint[1]);
+      return Array.prototype.slice.call(rv ? rv : []);
+    } else {
+      throw new Error('document.elementsFromPoint unsupported');
+    }
+  }
+
+  function inView(element) {
+    var pointerInteractablePaintTree = getPointerInteractablePaintTree(element);
+    return pointerInteractablePaintTree.indexOf(element) !== -1;
+  }
+
+  /**
+   * @namespace
+   */
+  window.test_driver = {
+    /**
+     * Trigger user interaction in order to grant additional privileges to
+     * a provided function.
+     *
+     * https://html.spec.whatwg.org/#triggered-by-user-activation
+     *
+     * @param {String} intent - a description of the action which much be
+     *                          triggered by user interaction
+     * @param {Function} action - code requiring escalated privileges
+     *
+     * @returns {Promise} fulfilled following user interaction and
+     *                    execution of the provided `action` function;
+     *                    rejected if interaction fails or the provided
+     *                    function throws an error
+     */
+    bless: function(intent, action) {
+      var button = document.createElement('button');
+      button.innerHTML =
+        'This test requires user interaction.<br />' +
+        'Please click here to allow ' +
+        intent +
+        '.';
+      button.id = 'wpt-test-driver-bless-' + (idCounter += 1);
+      const elem = document.body || document.documentElement;
+      elem.appendChild(button);
 
-        var centerPoint = getInViewCenterPoint(rectangles[0]);
+      return new Promise(function(resolve, reject) {
+        button.addEventListener('click', resolve);
 
-        if ("elementsFromPoint" in document) {
-            return document.elementsFromPoint(centerPoint[0], centerPoint[1]);
-        } else if ("msElementsFromPoint" in document) {
-            var rv = document.msElementsFromPoint(centerPoint[0], centerPoint[1]);
-            return Array.prototype.slice.call(rv ? rv : []);
-        } else {
-            throw new Error("document.elementsFromPoint unsupported");
+        test_driver.click(button).catch(reject);
+      }).then(function() {
+        button.remove();
+
+        if (typeof action === 'function') {
+          return action();
         }
-    }
+      });
+    },
 
-    function inView(element) {
-        var pointerInteractablePaintTree = getPointerInteractablePaintTree(element);
-        return pointerInteractablePaintTree.indexOf(element) !== -1;
-    }
+    /**
+     * Triggers a user-initiated click
+     *
+     * This matches the behaviour of the {@link
+     * https://w3c.github.io/webdriver/webdriver-spec.html#element-click|WebDriver
+     * Element Click command}.
+     *
+     * @param {Element} element - element to be clicked
+     * @returns {Promise} fulfilled after click occurs, or rejected in
+     *                    the cases the WebDriver command errors
+     */
+    click: function(element) {
+      if (window.top !== window) {
+        return Promise.reject(new Error('can only click in top-level window'));
+      }
+
+      if (!window.document.contains(element)) {
+        return Promise.reject(
+          new Error('element in different document or shadow tree')
+        );
+      }
 
+      if (!inView(element)) {
+        element.scrollIntoView({
+          behavior: 'instant',
+          block: 'end',
+          inline: 'nearest'
+        });
+      }
+
+      var pointerInteractablePaintTree = getPointerInteractablePaintTree(
+        element
+      );
+      if (
+        pointerInteractablePaintTree.length === 0 ||
+        !element.contains(pointerInteractablePaintTree[0])
+      ) {
+        return Promise.reject(new Error('element click intercepted error'));
+      }
+
+      var rect = element.getClientRects()[0];
+      var centerPoint = getInViewCenterPoint(rect);
+      return window.test_driver_internal.click(element, {
+        x: centerPoint[0],
+        y: centerPoint[1]
+      });
+    },
 
     /**
-     * @namespace
+     * Send keys to an element
+     *
+     * This matches the behaviour of the {@link
+     * https://w3c.github.io/webdriver/webdriver-spec.html#element-send-keys|WebDriver
+     * Send Keys command}.
+     *
+     * @param {Element} element - element to send keys to
+     * @param {String} keys - keys to send to the element
+     * @returns {Promise} fulfilled after keys are sent, or rejected in
+     *                    the cases the WebDriver command errors
      */
-    window.test_driver = {
-        /**
-         * Trigger user interaction in order to grant additional privileges to
-         * a provided function.
-         *
-         * https://html.spec.whatwg.org/#triggered-by-user-activation
-         *
-         * @param {String} intent - a description of the action which much be
-         *                          triggered by user interaction
-         * @param {Function} action - code requiring escalated privileges
-         *
-         * @returns {Promise} fulfilled following user interaction and
-         *                    execution of the provided `action` function;
-         *                    rejected if interaction fails or the provided
-         *                    function throws an error
-         */
-        bless: function(intent, action) {
-            var button = document.createElement("button");
-            button.innerHTML = "This test requires user interaction.<br />" +
-                "Please click here to allow " + intent + ".";
-            button.id = "wpt-test-driver-bless-" + (idCounter += 1);
-            const elem = document.body || document.documentElement;
-            elem.appendChild(button);
-
-            return new Promise(function(resolve, reject) {
-                    button.addEventListener("click", resolve);
-
-                    test_driver.click(button).catch(reject);
-                }).then(function() {
-                    button.remove();
-
-                    if (typeof action === "function") {
-                        return action();
-                    }
-                });
-        },
-
-        /**
-         * Triggers a user-initiated click
-         *
-         * This matches the behaviour of the {@link
-         * https://w3c.github.io/webdriver/webdriver-spec.html#element-click|WebDriver
-         * Element Click command}.
-         *
-         * @param {Element} element - element to be clicked
-         * @returns {Promise} fulfilled after click occurs, or rejected in
-         *                    the cases the WebDriver command errors
-         */
-        click: function(element) {
-            if (window.top !== window) {
-                return Promise.reject(new Error("can only click in top-level window"));
-            }
-
-            if (!window.document.contains(element)) {
-                return Promise.reject(new Error("element in different document or shadow tree"));
-            }
-
-            if (!inView(element)) {
-                element.scrollIntoView({behavior: "instant",
-                                        block: "end",
-                                        inline: "nearest"});
-            }
-
-            var pointerInteractablePaintTree = getPointerInteractablePaintTree(element);
-            if (pointerInteractablePaintTree.length === 0 ||
-                !element.contains(pointerInteractablePaintTree[0])) {
-                return Promise.reject(new Error("element click intercepted error"));
-            }
-
-            var rect = element.getClientRects()[0];
-            var centerPoint = getInViewCenterPoint(rect);
-            return window.test_driver_internal.click(element,
-                                                     {x: centerPoint[0],
-                                                      y: centerPoint[1]});
-        },
-
-        /**
-         * Send keys to an element
-         *
-         * This matches the behaviour of the {@link
-         * https://w3c.github.io/webdriver/webdriver-spec.html#element-send-keys|WebDriver
-         * Send Keys command}.
-         *
-         * @param {Element} element - element to send keys to
-         * @param {String} keys - keys to send to the element
-         * @returns {Promise} fulfilled after keys are sent, or rejected in
-         *                    the cases the WebDriver command errors
-         */
-        send_keys: function(element, keys) {
-            if (window.top !== window) {
-                return Promise.reject(new Error("can only send keys in top-level window"));
-            }
-
-            if (!window.document.contains(element)) {
-                return Promise.reject(new Error("element in different document or shadow tree"));
-            }
-
-            if (!inView(element)) {
-                element.scrollIntoView({behavior: "instant",
-                                        block: "end",
-                                        inline: "nearest"});
-            }
-
-            var pointerInteractablePaintTree = getPointerInteractablePaintTree(element);
-            if (pointerInteractablePaintTree.length === 0 ||
-                !element.contains(pointerInteractablePaintTree[0])) {
-                return Promise.reject(new Error("element send_keys intercepted error"));
-            }
-
-            return window.test_driver_internal.send_keys(element, keys);
-        },
-
-        /**
-         * Freeze the current page
-         *
-         * The freeze function transitions the page from the HIDDEN state to
-         * the FROZEN state as described in {@link
-         * https://github.com/WICG/page-lifecycle/blob/master/README.md|Lifecycle API
-         * for Web Pages}
-         *
-         * @returns {Promise} fulfilled after the freeze request is sent, or rejected
-         *                    in case the WebDriver command errors
-         */
-        freeze: function() {
-            return window.test_driver_internal.freeze();
-        },
+    send_keys: function(element, keys) {
+      if (window.top !== window) {
+        return Promise.reject(
+          new Error('can only send keys in top-level window')
+        );
+      }
+
+      if (!window.document.contains(element)) {
+        return Promise.reject(
+          new Error('element in different document or shadow tree')
+        );
+      }
+
+      if (!inView(element)) {
+        element.scrollIntoView({
+          behavior: 'instant',
+          block: 'end',
+          inline: 'nearest'
+        });
+      }
 
-        /**
+      var pointerInteractablePaintTree = getPointerInteractablePaintTree(
+        element
+      );
+      if (
+        pointerInteractablePaintTree.length === 0 ||
+        !element.contains(pointerInteractablePaintTree[0])
+      ) {
+        return Promise.reject(new Error('element send_keys intercepted error'));
+      }
+
+      return window.test_driver_internal.send_keys(element, keys);
+    },
+
+    /**
+     * Freeze the current page
+     *
+     * The freeze function transitions the page from the HIDDEN state to
+     * the FROZEN state as described in {@link
+     * https://github.com/WICG/page-lifecycle/blob/master/README.md|Lifecycle API
+     * for Web Pages}
+     *
+     * @returns {Promise} fulfilled after the freeze request is sent, or rejected
+     *                    in case the WebDriver command errors
+     */
+    freeze: function() {
+      return window.test_driver_internal.freeze();
+    },
+
+    /**
          * Send a sequence of actions
          *
          * This function sends a sequence of actions to the top level window
@@ -192,52 +213,52 @@
          * @returns {Promise} fufiled after the actions are performed, or rejected in
          *                    the cases the WebDriver command errors
          */
-        action_sequence(actions) {
-            return window.test_driver_internal.action_sequence(actions);
-        }
-    };
+    action_sequence(actions) {
+      return window.test_driver_internal.action_sequence(actions);
+    }
+  };
 
-    window.test_driver_internal = {
-        /**
-         * Triggers a user-initiated click
-         *
-         * @param {Element} element - element to be clicked
-         * @param {{x: number, y: number} coords - viewport coordinates to click at
-         * @returns {Promise} fulfilled after click occurs or rejected if click fails
-         */
-        click: function(element, coords) {
-            return Promise.reject(new Error("unimplemented"));
-        },
+  window.test_driver_internal = {
+    /**
+     * Triggers a user-initiated click
+     *
+     * @param {Element} element - element to be clicked
+     * @param {{x: number, y: number} coords - viewport coordinates to click at
+     * @returns {Promise} fulfilled after click occurs or rejected if click fails
+     */
+    click: function(element, coords) {
+      return Promise.reject(new Error('unimplemented'));
+    },
 
-        /**
-         * Triggers a user-initiated click
-         *
-         * @param {Element} element - element to be clicked
-         * @param {String} keys - keys to send to the element
-         * @returns {Promise} fulfilled after keys are sent or rejected if click fails
-         */
-        send_keys: function(element, keys) {
-            return Promise.reject(new Error("unimplemented"));
-        },
+    /**
+     * Triggers a user-initiated click
+     *
+     * @param {Element} element - element to be clicked
+     * @param {String} keys - keys to send to the element
+     * @returns {Promise} fulfilled after keys are sent or rejected if click fails
+     */
+    send_keys: function(element, keys) {
+      return Promise.reject(new Error('unimplemented'));
+    },
 
-        /**
-         * Freeze the current page
-         *
-         * @returns {Promise} fulfilled after freeze request is sent, otherwise
-         * it gets rejected
-         */
-        freeze: function() {
-            return Promise.reject(new Error("unimplemented"));
-        },
+    /**
+     * Freeze the current page
+     *
+     * @returns {Promise} fulfilled after freeze request is sent, otherwise
+     * it gets rejected
+     */
+    freeze: function() {
+      return Promise.reject(new Error('unimplemented'));
+    },
 
-        /**
-         * Send a sequence of pointer actions
-         *
-         * @returns {Promise} fufilled after actions are sent, rejected if any actions
-         *                    fail
-         */
-        action_sequence: function(actions) {
-            return Promise.reject(new Error("unimplemented"));
-        }
-    };
+    /**
+     * Send a sequence of pointer actions
+     *
+     * @returns {Promise} fufilled after actions are sent, rejected if any actions
+     *                    fail
+     */
+    action_sequence: function(actions) {
+      return Promise.reject(new Error('unimplemented'));
+    }
+  };
 })();
diff --git a/test/fixtures/wpt/resources/testharness.js b/test/fixtures/wpt/resources/testharness.js
index 18a6f70beab26b..677acb5defc9d6 100644
--- a/test/fixtures/wpt/resources/testharness.js
+++ b/test/fixtures/wpt/resources/testharness.js
@@ -13,3285 +13,3578 @@ policies and contribution forms [3].
 /* Documentation: https://web-platform-tests.org/writing-tests/testharness-api.html
  * (../docs/_writing-tests/testharness-api.md) */
 
-(function (global_scope)
-{
-    var debug = false;
-    // default timeout is 10 seconds, test can override if needed
-    var settings = {
-        output:true,
-        harness_timeout:{
-            "normal":10000,
-            "long":60000
-        },
-        test_timeout:null,
-        message_events: ["start", "test_state", "result", "completion"]
-    };
-
-    var xhtml_ns = "http://www.w3.org/1999/xhtml";
-
-    /*
-     * TestEnvironment is an abstraction for the environment in which the test
-     * harness is used. Each implementation of a test environment has to provide
-     * the following interface:
-     *
-     * interface TestEnvironment {
-     *   // Invoked after the global 'tests' object has been created and it's
-     *   // safe to call add_*_callback() to register event handlers.
-     *   void on_tests_ready();
-     *
-     *   // Invoked after setup() has been called to notify the test environment
-     *   // of changes to the test harness properties.
-     *   void on_new_harness_properties(object properties);
-     *
-     *   // Should return a new unique default test name.
-     *   DOMString next_default_test_name();
-     *
-     *   // Should return the test harness timeout duration in milliseconds.
-     *   float test_timeout();
-     * };
-     */
-
-    /*
-     * A test environment with a DOM. The global object is 'window'. By default
-     * test results are displayed in a table. Any parent windows receive
-     * callbacks or messages via postMessage() when test events occur. See
-     * apisample11.html and apisample12.html.
-     */
-    function WindowTestEnvironment() {
-        this.name_counter = 0;
-        this.window_cache = null;
-        this.output_handler = null;
-        this.all_loaded = false;
-        var this_obj = this;
-        this.message_events = [];
-        this.dispatched_messages = [];
-
-        this.message_functions = {
-            start: [add_start_callback, remove_start_callback,
-                    function (properties) {
-                        this_obj._dispatch("start_callback", [properties],
-                                           {type: "start", properties: properties});
-                    }],
-
-            test_state: [add_test_state_callback, remove_test_state_callback,
-                         function(test) {
-                             this_obj._dispatch("test_state_callback", [test],
-                                                {type: "test_state",
-                                                 test: test.structured_clone()});
-                         }],
-            result: [add_result_callback, remove_result_callback,
-                     function (test) {
-                         this_obj.output_handler.show_status();
-                         this_obj._dispatch("result_callback", [test],
-                                            {type: "result",
-                                             test: test.structured_clone()});
-                     }],
-            completion: [add_completion_callback, remove_completion_callback,
-                         function (tests, harness_status) {
-                             var cloned_tests = map(tests, function(test) {
-                                 return test.structured_clone();
-                             });
-                             this_obj._dispatch("completion_callback", [tests, harness_status],
-                                                {type: "complete",
-                                                 tests: cloned_tests,
-                                                 status: harness_status.structured_clone()});
-                         }]
-        }
-
-        on_event(window, 'load', function() {
-            this_obj.all_loaded = true;
-        });
-
-        on_event(window, 'message', function(event) {
-            if (event.data && event.data.type === "getmessages" && event.source) {
-                // A window can post "getmessages" to receive a duplicate of every
-                // message posted by this environment so far. This allows subscribers
-                // from fetch_tests_from_window to 'catch up' to the current state of
-                // this environment.
-                for (var i = 0; i < this_obj.dispatched_messages.length; ++i)
-                {
-                    event.source.postMessage(this_obj.dispatched_messages[i], "*");
-                }
-            }
-        });
-    }
-
-    WindowTestEnvironment.prototype._dispatch = function(selector, callback_args, message_arg) {
-        this.dispatched_messages.push(message_arg);
-        this._forEach_windows(
-                function(w, same_origin) {
-                    if (same_origin) {
-                        try {
-                            var has_selector = selector in w;
-                        } catch(e) {
-                            // If document.domain was set at some point same_origin can be
-                            // wrong and the above will fail.
-                            has_selector = false;
-                        }
-                        if (has_selector) {
-                            try {
-                                w[selector].apply(undefined, callback_args);
-                            } catch (e) {
-                                if (debug) {
-                                    throw e;
-                                }
-                            }
-                        }
-                    }
-                    if (supports_post_message(w) && w !== self) {
-                        w.postMessage(message_arg, "*");
-                    }
-                });
-    };
-
-    WindowTestEnvironment.prototype._forEach_windows = function(callback) {
-        // Iterate over the windows [self ... top, opener]. The callback is passed
-        // two objects, the first one is the window object itself, the second one
-        // is a boolean indicating whether or not it's on the same origin as the
-        // current window.
-        var cache = this.window_cache;
-        if (!cache) {
-            cache = [[self, true]];
-            var w = self;
-            var i = 0;
-            var so;
-            while (w != w.parent) {
-                w = w.parent;
-                so = is_same_origin(w);
-                cache.push([w, so]);
-                i++;
-            }
-            w = window.opener;
-            if (w) {
-                cache.push([w, is_same_origin(w)]);
-            }
-            this.window_cache = cache;
-        }
-
-        forEach(cache,
-                function(a) {
-                    callback.apply(null, a);
-                });
-    };
-
-    WindowTestEnvironment.prototype.on_tests_ready = function() {
-        var output = new Output();
-        this.output_handler = output;
-
-        var this_obj = this;
-
-        add_start_callback(function (properties) {
-            this_obj.output_handler.init(properties);
-        });
-
-        add_test_state_callback(function(test) {
-            this_obj.output_handler.show_status();
-        });
-
-        add_result_callback(function (test) {
-            this_obj.output_handler.show_status();
-        });
-
-        add_completion_callback(function (tests, harness_status) {
-            this_obj.output_handler.show_results(tests, harness_status);
-        });
-        this.setup_messages(settings.message_events);
-    };
-
-    WindowTestEnvironment.prototype.setup_messages = function(new_events) {
-        var this_obj = this;
-        forEach(settings.message_events, function(x) {
-            var current_dispatch = this_obj.message_events.indexOf(x) !== -1;
-            var new_dispatch = new_events.indexOf(x) !== -1;
-            if (!current_dispatch && new_dispatch) {
-                this_obj.message_functions[x][0](this_obj.message_functions[x][2]);
-            } else if (current_dispatch && !new_dispatch) {
-                this_obj.message_functions[x][1](this_obj.message_functions[x][2]);
-            }
-        });
-        this.message_events = new_events;
-    }
-
-    WindowTestEnvironment.prototype.next_default_test_name = function() {
-        var suffix = this.name_counter > 0 ? " " + this.name_counter : "";
-        this.name_counter++;
-        return get_title() + suffix;
-    };
-
-    WindowTestEnvironment.prototype.on_new_harness_properties = function(properties) {
-        this.output_handler.setup(properties);
-        if (properties.hasOwnProperty("message_events")) {
-            this.setup_messages(properties.message_events);
-        }
-    };
-
-    WindowTestEnvironment.prototype.add_on_loaded_callback = function(callback) {
-        on_event(window, 'load', callback);
-    };
-
-    WindowTestEnvironment.prototype.test_timeout = function() {
-        var metas = document.getElementsByTagName("meta");
-        for (var i = 0; i < metas.length; i++) {
-            if (metas[i].name == "timeout") {
-                if (metas[i].content == "long") {
-                    return settings.harness_timeout.long;
-                }
-                break;
-            }
-        }
-        return settings.harness_timeout.normal;
-    };
-
-    /*
-     * Base TestEnvironment implementation for a generic web worker.
-     *
-     * Workers accumulate test results. One or more clients can connect and
-     * retrieve results from a worker at any time.
-     *
-     * WorkerTestEnvironment supports communicating with a client via a
-     * MessagePort.  The mechanism for determining the appropriate MessagePort
-     * for communicating with a client depends on the type of worker and is
-     * implemented by the various specializations of WorkerTestEnvironment
-     * below.
-     *
-     * A client document using testharness can use fetch_tests_from_worker() to
-     * retrieve results from a worker. See apisample16.html.
-     */
-    function WorkerTestEnvironment() {
-        this.name_counter = 0;
-        this.all_loaded = true;
-        this.message_list = [];
-        this.message_ports = [];
-    }
-
-    WorkerTestEnvironment.prototype._dispatch = function(message) {
-        this.message_list.push(message);
-        for (var i = 0; i < this.message_ports.length; ++i)
-        {
-            this.message_ports[i].postMessage(message);
-        }
-    };
-
-    // The only requirement is that port has a postMessage() method. It doesn't
-    // have to be an instance of a MessagePort, and often isn't.
-    WorkerTestEnvironment.prototype._add_message_port = function(port) {
-        this.message_ports.push(port);
-        for (var i = 0; i < this.message_list.length; ++i)
-        {
-            port.postMessage(this.message_list[i]);
-        }
-    };
-
-    WorkerTestEnvironment.prototype.next_default_test_name = function() {
-        var suffix = this.name_counter > 0 ? " " + this.name_counter : "";
-        this.name_counter++;
-        return get_title() + suffix;
-    };
-
-    WorkerTestEnvironment.prototype.on_new_harness_properties = function() {};
-
-    WorkerTestEnvironment.prototype.on_tests_ready = function() {
-        var this_obj = this;
-        add_start_callback(
-                function(properties) {
-                    this_obj._dispatch({
-                        type: "start",
-                        properties: properties,
-                    });
-                });
-        add_test_state_callback(
-                function(test) {
-                    this_obj._dispatch({
-                        type: "test_state",
-                        test: test.structured_clone()
-                    });
-                });
-        add_result_callback(
-                function(test) {
-                    this_obj._dispatch({
-                        type: "result",
-                        test: test.structured_clone()
-                    });
-                });
-        add_completion_callback(
-                function(tests, harness_status) {
-                    this_obj._dispatch({
-                        type: "complete",
-                        tests: map(tests,
-                            function(test) {
-                                return test.structured_clone();
-                            }),
-                        status: harness_status.structured_clone()
-                    });
-                });
-    };
-
-    WorkerTestEnvironment.prototype.add_on_loaded_callback = function() {};
-
-    WorkerTestEnvironment.prototype.test_timeout = function() {
-        // Tests running in a worker don't have a default timeout. I.e. all
-        // worker tests behave as if settings.explicit_timeout is true.
-        return null;
-    };
-
-    /*
-     * Dedicated web workers.
-     * https://html.spec.whatwg.org/multipage/workers.html#dedicatedworkerglobalscope
-     *
-     * This class is used as the test_environment when testharness is running
-     * inside a dedicated worker.
-     */
-    function DedicatedWorkerTestEnvironment() {
-        WorkerTestEnvironment.call(this);
-        // self is an instance of DedicatedWorkerGlobalScope which exposes
-        // a postMessage() method for communicating via the message channel
-        // established when the worker is created.
-        this._add_message_port(self);
-    }
-    DedicatedWorkerTestEnvironment.prototype = Object.create(WorkerTestEnvironment.prototype);
-
-    DedicatedWorkerTestEnvironment.prototype.on_tests_ready = function() {
-        WorkerTestEnvironment.prototype.on_tests_ready.call(this);
-        // In the absence of an onload notification, we a require dedicated
-        // workers to explicitly signal when the tests are done.
-        tests.wait_for_finish = true;
-    };
-
-    /*
-     * Shared web workers.
-     * https://html.spec.whatwg.org/multipage/workers.html#sharedworkerglobalscope
-     *
-     * This class is used as the test_environment when testharness is running
-     * inside a shared web worker.
-     */
-    function SharedWorkerTestEnvironment() {
-        WorkerTestEnvironment.call(this);
-        var this_obj = this;
-        // Shared workers receive message ports via the 'onconnect' event for
-        // each connection.
-        self.addEventListener("connect",
-                function(message_event) {
-                    this_obj._add_message_port(message_event.source);
-                }, false);
-    }
-    SharedWorkerTestEnvironment.prototype = Object.create(WorkerTestEnvironment.prototype);
-
-    SharedWorkerTestEnvironment.prototype.on_tests_ready = function() {
-        WorkerTestEnvironment.prototype.on_tests_ready.call(this);
-        // In the absence of an onload notification, we a require shared
-        // workers to explicitly signal when the tests are done.
-        tests.wait_for_finish = true;
-    };
-
-    /*
-     * Service workers.
-     * http://www.w3.org/TR/service-workers/
-     *
-     * This class is used as the test_environment when testharness is running
-     * inside a service worker.
-     */
-    function ServiceWorkerTestEnvironment() {
-        WorkerTestEnvironment.call(this);
-        this.all_loaded = false;
-        this.on_loaded_callback = null;
-        var this_obj = this;
-        self.addEventListener("message",
-                function(event) {
-                    if (event.data && event.data.type && event.data.type === "connect") {
-                        if (event.ports && event.ports[0]) {
-                            // If a MessageChannel was passed, then use it to
-                            // send results back to the main window.  This
-                            // allows the tests to work even if the browser
-                            // does not fully support MessageEvent.source in
-                            // ServiceWorkers yet.
-                            this_obj._add_message_port(event.ports[0]);
-                            event.ports[0].start();
-                        } else {
-                            // If there is no MessageChannel, then attempt to
-                            // use the MessageEvent.source to send results
-                            // back to the main window.
-                            this_obj._add_message_port(event.source);
-                        }
-                    }
-                }, false);
-
-        // The oninstall event is received after the service worker script and
-        // all imported scripts have been fetched and executed. It's the
-        // equivalent of an onload event for a document. All tests should have
-        // been added by the time this event is received, thus it's not
-        // necessary to wait until the onactivate event. However, tests for
-        // installed service workers need another event which is equivalent to
-        // the onload event because oninstall is fired only on installation. The
-        // onmessage event is used for that purpose since tests using
-        // testharness.js should ask the result to its service worker by
-        // PostMessage. If the onmessage event is triggered on the service
-        // worker's context, that means the worker's script has been evaluated.
-        on_event(self, "install", on_all_loaded);
-        on_event(self, "message", on_all_loaded);
-        function on_all_loaded() {
-            if (this_obj.all_loaded)
-                return;
-            this_obj.all_loaded = true;
-            if (this_obj.on_loaded_callback) {
-              this_obj.on_loaded_callback();
-            }
-        }
-    }
-
-    ServiceWorkerTestEnvironment.prototype = Object.create(WorkerTestEnvironment.prototype);
-
-    ServiceWorkerTestEnvironment.prototype.add_on_loaded_callback = function(callback) {
-        if (this.all_loaded) {
-            callback();
-        } else {
-            this.on_loaded_callback = callback;
-        }
-    };
-
-    /*
-     * JavaScript shells.
-     *
-     * This class is used as the test_environment when testharness is running
-     * inside a JavaScript shell.
-     */
-    function ShellTestEnvironment() {
-        this.name_counter = 0;
-        this.all_loaded = false;
-        this.on_loaded_callback = null;
-        Promise.resolve().then(function() {
-            this.all_loaded = true
-            if (this.on_loaded_callback) {
-                this.on_loaded_callback();
-            }
-        }.bind(this));
-        this.message_list = [];
-        this.message_ports = [];
-    }
-
-    ShellTestEnvironment.prototype.next_default_test_name = function() {
-        var suffix = this.name_counter > 0 ? " " + this.name_counter : "";
-        this.name_counter++;
-        return "Untitled" + suffix;
-    };
-
-    ShellTestEnvironment.prototype.on_new_harness_properties = function() {};
-
-    ShellTestEnvironment.prototype.on_tests_ready = function() {};
-
-    ShellTestEnvironment.prototype.add_on_loaded_callback = function(callback) {
-        if (this.all_loaded) {
-            callback();
-        } else {
-            this.on_loaded_callback = callback;
-        }
-    };
-
-    ShellTestEnvironment.prototype.test_timeout = function() {
-        // Tests running in a shell don't have a default timeout, so behave as
-        // if settings.explicit_timeout is true.
-        return null;
-    };
-
-    function create_test_environment() {
-        if ('document' in global_scope) {
-            return new WindowTestEnvironment();
-        }
-        if ('DedicatedWorkerGlobalScope' in global_scope &&
-            global_scope instanceof DedicatedWorkerGlobalScope) {
-            return new DedicatedWorkerTestEnvironment();
-        }
-        if ('SharedWorkerGlobalScope' in global_scope &&
-            global_scope instanceof SharedWorkerGlobalScope) {
-            return new SharedWorkerTestEnvironment();
-        }
-        if ('ServiceWorkerGlobalScope' in global_scope &&
-            global_scope instanceof ServiceWorkerGlobalScope) {
-            return new ServiceWorkerTestEnvironment();
-        }
-        if ('WorkerGlobalScope' in global_scope &&
-            global_scope instanceof WorkerGlobalScope) {
-            return new DedicatedWorkerTestEnvironment();
-        }
-
-        if (!('self' in global_scope)) {
-            return new ShellTestEnvironment();
-        }
-
-        throw new Error("Unsupported test environment");
-    }
-
-    var test_environment = create_test_environment();
-
-    function is_shared_worker(worker) {
-        return 'SharedWorker' in global_scope && worker instanceof SharedWorker;
-    }
-
-    function is_service_worker(worker) {
-        // The worker object may be from another execution context,
-        // so do not use instanceof here.
-        return 'ServiceWorker' in global_scope &&
-            Object.prototype.toString.call(worker) == '[object ServiceWorker]';
-    }
-
-    /*
-     * API functions
-     */
-    function test(func, name, properties)
-    {
-        var test_name = name ? name : test_environment.next_default_test_name();
-        properties = properties ? properties : {};
-        var test_obj = new Test(test_name, properties);
-        var value = test_obj.step(func, test_obj, test_obj);
-
-        if (value !== undefined) {
-            var msg = "test named \"" + test_name +
-                "\" inappropriately returned a value";
-
-            try {
-                if (value && value.hasOwnProperty("then")) {
-                    msg += ", consider using `promise_test` instead";
-                }
-            } catch (err) {}
-
-            tests.status.status = tests.status.ERROR;
-            tests.status.message = msg;
-        }
-
-        if (test_obj.phase === test_obj.phases.STARTED) {
-            test_obj.done();
-        }
-    }
-
-    function async_test(func, name, properties)
-    {
-        if (typeof func !== "function") {
-            properties = name;
-            name = func;
-            func = null;
-        }
-        var test_name = name ? name : test_environment.next_default_test_name();
-        properties = properties ? properties : {};
-        var test_obj = new Test(test_name, properties);
-        if (func) {
-            test_obj.step(func, test_obj, test_obj);
-        }
-        return test_obj;
-    }
-
-    function promise_test(func, name, properties) {
-        var test = async_test(name, properties);
-        test._is_promise_test = true;
-
-        // If there is no promise tests queue make one.
-        if (!tests.promise_tests) {
-            tests.promise_tests = Promise.resolve();
-        }
-        tests.promise_tests = tests.promise_tests.then(function() {
-            return new Promise(function(resolve) {
-                var promise = test.step(func, test, test);
-
-                test.step(function() {
-                    assert(!!promise, "promise_test", null,
-                           "test body must return a 'thenable' object (received ${value})",
-                           {value:promise});
-                    assert(typeof promise.then === "function", "promise_test", null,
-                           "test body must return a 'thenable' object (received an object with no `then` method)",
-                           null);
-                });
-
-                // Test authors may use the `step` method within a
-                // `promise_test` even though this reflects a mixture of
-                // asynchronous control flow paradigms. The "done" callback
-                // should be registered prior to the resolution of the
-                // user-provided Promise to avoid timeouts in cases where the
-                // Promise does not settle but a `step` function has thrown an
-                // error.
-                add_test_done_callback(test, resolve);
-
-                Promise.resolve(promise)
-                    .catch(test.step_func(
-                        function(value) {
-                            if (value instanceof AssertionError) {
-                                throw value;
-                            }
-                            assert(false, "promise_test", null,
-                                   "Unhandled rejection with value: ${value}", {value:value});
-                        }))
-                    .then(function() {
-                        test.done();
-                    });
-                });
-        });
-    }
-
-    function promise_rejects(test, expected, promise, description) {
-        return promise.then(test.unreached_func("Should have rejected: " + description)).catch(function(e) {
-            assert_throws(expected, function() { throw e }, description);
-        });
-    }
-
-    /**
-     * This constructor helper allows DOM events to be handled using Promises,
-     * which can make it a lot easier to test a very specific series of events,
-     * including ensuring that unexpected events are not fired at any point.
-     */
-    function EventWatcher(test, watchedNode, eventTypes)
-    {
-        if (typeof eventTypes == 'string') {
-            eventTypes = [eventTypes];
-        }
-
-        var waitingFor = null;
-
-        // This is null unless we are recording all events, in which case it
-        // will be an Array object.
-        var recordedEvents = null;
-
-        var eventHandler = test.step_func(function(evt) {
-            assert_true(!!waitingFor,
-                        'Not expecting event, but got ' + evt.type + ' event');
-            assert_equals(evt.type, waitingFor.types[0],
-                          'Expected ' + waitingFor.types[0] + ' event, but got ' +
-                          evt.type + ' event instead');
-
-            if (Array.isArray(recordedEvents)) {
-                recordedEvents.push(evt);
-            }
-
-            if (waitingFor.types.length > 1) {
-                // Pop first event from array
-                waitingFor.types.shift();
-                return;
-            }
-            // We need to null out waitingFor before calling the resolve function
-            // since the Promise's resolve handlers may call wait_for() which will
-            // need to set waitingFor.
-            var resolveFunc = waitingFor.resolve;
-            waitingFor = null;
-            // Likewise, we should reset the state of recordedEvents.
-            var result = recordedEvents || evt;
-            recordedEvents = null;
-            resolveFunc(result);
-        });
-
-        for (var i = 0; i < eventTypes.length; i++) {
-            watchedNode.addEventListener(eventTypes[i], eventHandler, false);
-        }
-
-        /**
-         * Returns a Promise that will resolve after the specified event or
-         * series of events has occurred.
-         *
-         * @param options An optional options object. If the 'record' property
-         *                on this object has the value 'all', when the Promise
-         *                returned by this function is resolved,  *all* Event
-         *                objects that were waited for will be returned as an
-         *                array.
-         *
-         * For example,
-         *
-         * ```js
-         * const watcher = new EventWatcher(t, div, [ 'animationstart',
-         *                                            'animationiteration',
-         *                                            'animationend' ]);
-         * return watcher.wait_for([ 'animationstart', 'animationend' ],
-         *                         { record: 'all' }).then(evts => {
-         *   assert_equals(evts[0].elapsedTime, 0.0);
-         *   assert_equals(evts[1].elapsedTime, 2.0);
-         * });
-         * ```
-         */
-        this.wait_for = function(types, options) {
-            if (waitingFor) {
-                return Promise.reject('Already waiting for an event or events');
-            }
-            if (typeof types == 'string') {
-                types = [types];
-            }
-            if (options && options.record && options.record === 'all') {
-                recordedEvents = [];
-            }
-            return new Promise(function(resolve, reject) {
-                waitingFor = {
-                    types: types,
-                    resolve: resolve,
-                    reject: reject
-                };
-            });
-        };
-
-        function stop_watching() {
-            for (var i = 0; i < eventTypes.length; i++) {
-                watchedNode.removeEventListener(eventTypes[i], eventHandler, false);
-            }
-        };
-
-        test._add_cleanup(stop_watching);
-
-        return this;
-    }
-    expose(EventWatcher, 'EventWatcher');
-
-    function setup(func_or_properties, maybe_properties)
-    {
-        var func = null;
-        var properties = {};
-        if (arguments.length === 2) {
-            func = func_or_properties;
-            properties = maybe_properties;
-        } else if (func_or_properties instanceof Function) {
-            func = func_or_properties;
-        } else {
-            properties = func_or_properties;
-        }
-        tests.setup(func, properties);
-        test_environment.on_new_harness_properties(properties);
-    }
-
-    function done() {
-        if (tests.tests.length === 0) {
-            tests.set_file_is_test();
-        }
-        if (tests.file_is_test) {
-            // file is test files never have asynchronous cleanup logic,
-            // meaning the fully-synchronous `done` function can be used here.
-            tests.tests[0].done();
-        }
-        tests.end_wait();
-    }
-
-    function generate_tests(func, args, properties) {
-        forEach(args, function(x, i)
-                {
-                    var name = x[0];
-                    test(function()
-                         {
-                             func.apply(this, x.slice(1));
-                         },
-                         name,
-                         Array.isArray(properties) ? properties[i] : properties);
-                });
-    }
-
-    function on_event(object, event, callback)
-    {
-        object.addEventListener(event, callback, false);
-    }
-
-    function step_timeout(f, t) {
-        var outer_this = this;
-        var args = Array.prototype.slice.call(arguments, 2);
-        return setTimeout(function() {
-            f.apply(outer_this, args);
-        }, t * tests.timeout_multiplier);
-    }
-
-    expose(test, 'test');
-    expose(async_test, 'async_test');
-    expose(promise_test, 'promise_test');
-    expose(promise_rejects, 'promise_rejects');
-    expose(generate_tests, 'generate_tests');
-    expose(setup, 'setup');
-    expose(done, 'done');
-    expose(on_event, 'on_event');
-    expose(step_timeout, 'step_timeout');
-
-    /*
-     * Return a string truncated to the given length, with ... added at the end
-     * if it was longer.
-     */
-    function truncate(s, len)
-    {
-        if (s.length > len) {
-            return s.substring(0, len - 3) + "...";
-        }
-        return s;
-    }
-
-    /*
-     * Return true if object is probably a Node object.
-     */
-    function is_node(object)
-    {
-        // I use duck-typing instead of instanceof, because
-        // instanceof doesn't work if the node is from another window (like an
-        // iframe's contentWindow):
-        // http://www.w3.org/Bugs/Public/show_bug.cgi?id=12295
+(function(global_scope) {
+  var debug = false;
+  // default timeout is 10 seconds, test can override if needed
+  var settings = {
+    output: true,
+    harness_timeout: {
+      normal: 10000,
+      long: 60000
+    },
+    test_timeout: null,
+    message_events: ['start', 'test_state', 'result', 'completion']
+  };
+
+  var xhtml_ns = 'http://www.w3.org/1999/xhtml';
+
+  /*
+   * TestEnvironment is an abstraction for the environment in which the test
+   * harness is used. Each implementation of a test environment has to provide
+   * the following interface:
+   *
+   * interface TestEnvironment {
+   *   // Invoked after the global 'tests' object has been created and it's
+   *   // safe to call add_*_callback() to register event handlers.
+   *   void on_tests_ready();
+   *
+   *   // Invoked after setup() has been called to notify the test environment
+   *   // of changes to the test harness properties.
+   *   void on_new_harness_properties(object properties);
+   *
+   *   // Should return a new unique default test name.
+   *   DOMString next_default_test_name();
+   *
+   *   // Should return the test harness timeout duration in milliseconds.
+   *   float test_timeout();
+   * };
+   */
+
+  /*
+   * A test environment with a DOM. The global object is 'window'. By default
+   * test results are displayed in a table. Any parent windows receive
+   * callbacks or messages via postMessage() when test events occur. See
+   * apisample11.html and apisample12.html.
+   */
+  function WindowTestEnvironment() {
+    this.name_counter = 0;
+    this.window_cache = null;
+    this.output_handler = null;
+    this.all_loaded = false;
+    var this_obj = this;
+    this.message_events = [];
+    this.dispatched_messages = [];
+
+    this.message_functions = {
+      start: [
+        add_start_callback,
+        remove_start_callback,
+        function(properties) {
+          this_obj._dispatch('start_callback', [properties], {
+            type: 'start',
+            properties: properties
+          });
+        }
+      ],
+
+      test_state: [
+        add_test_state_callback,
+        remove_test_state_callback,
+        function(test) {
+          this_obj._dispatch('test_state_callback', [test], {
+            type: 'test_state',
+            test: test.structured_clone()
+          });
+        }
+      ],
+      result: [
+        add_result_callback,
+        remove_result_callback,
+        function(test) {
+          this_obj.output_handler.show_status();
+          this_obj._dispatch('result_callback', [test], {
+            type: 'result',
+            test: test.structured_clone()
+          });
+        }
+      ],
+      completion: [
+        add_completion_callback,
+        remove_completion_callback,
+        function(tests, harness_status) {
+          var cloned_tests = map(tests, function(test) {
+            return test.structured_clone();
+          });
+          this_obj._dispatch('completion_callback', [tests, harness_status], {
+            type: 'complete',
+            tests: cloned_tests,
+            status: harness_status.structured_clone()
+          });
+        }
+      ]
+    };
+
+    on_event(window, 'load', function() {
+      this_obj.all_loaded = true;
+    });
+
+    on_event(window, 'message', function(event) {
+      if (event.data && event.data.type === 'getmessages' && event.source) {
+        // A window can post "getmessages" to receive a duplicate of every
+        // message posted by this environment so far. This allows subscribers
+        // from fetch_tests_from_window to 'catch up' to the current state of
+        // this environment.
+        for (var i = 0; i < this_obj.dispatched_messages.length; ++i) {
+          event.source.postMessage(this_obj.dispatched_messages[i], '*');
+        }
+      }
+    });
+  }
+
+  WindowTestEnvironment.prototype._dispatch = function(
+    selector,
+    callback_args,
+    message_arg
+  ) {
+    this.dispatched_messages.push(message_arg);
+    this._forEach_windows(function(w, same_origin) {
+      if (same_origin) {
         try {
-            var has_node_properties = ("nodeType" in object &&
-                                       "nodeName" in object &&
-                                       "nodeValue" in object &&
-                                       "childNodes" in object);
+          var has_selector = selector in w;
         } catch (e) {
-            // We're probably cross-origin, which means we aren't a node
-            return false;
-        }
-
-        if (has_node_properties) {
-            try {
-                object.nodeType;
-            } catch (e) {
-                // The object is probably Node.prototype or another prototype
-                // object that inherits from it, and not a Node instance.
-                return false;
-            }
-            return true;
-        }
-        return false;
-    }
-
-    var replacements = {
-        "0": "0",
-        "1": "x01",
-        "2": "x02",
-        "3": "x03",
-        "4": "x04",
-        "5": "x05",
-        "6": "x06",
-        "7": "x07",
-        "8": "b",
-        "9": "t",
-        "10": "n",
-        "11": "v",
-        "12": "f",
-        "13": "r",
-        "14": "x0e",
-        "15": "x0f",
-        "16": "x10",
-        "17": "x11",
-        "18": "x12",
-        "19": "x13",
-        "20": "x14",
-        "21": "x15",
-        "22": "x16",
-        "23": "x17",
-        "24": "x18",
-        "25": "x19",
-        "26": "x1a",
-        "27": "x1b",
-        "28": "x1c",
-        "29": "x1d",
-        "30": "x1e",
-        "31": "x1f",
-        "0xfffd": "ufffd",
-        "0xfffe": "ufffe",
-        "0xffff": "uffff",
-    };
-
-    /*
-     * Convert a value to a nice, human-readable string
-     */
-    function format_value(val, seen)
-    {
-        if (!seen) {
-            seen = [];
-        }
-        if (typeof val === "object" && val !== null) {
-            if (seen.indexOf(val) >= 0) {
-                return "[...]";
-            }
-            seen.push(val);
-        }
-        if (Array.isArray(val)) {
-            return "[" + val.map(function(x) {return format_value(x, seen);}).join(", ") + "]";
-        }
-
-        switch (typeof val) {
-        case "string":
-            val = val.replace("\\", "\\\\");
-            for (var p in replacements) {
-                var replace = "\\" + replacements[p];
-                val = val.replace(RegExp(String.fromCharCode(p), "g"), replace);
-            }
-            return '"' + val.replace(/"/g, '\\"') + '"';
-        case "boolean":
-        case "undefined":
-            return String(val);
-        case "number":
-            // In JavaScript, -0 === 0 and String(-0) == "0", so we have to
-            // special-case.
-            if (val === -0 && 1/val === -Infinity) {
-                return "-0";
-            }
-            return String(val);
-        case "object":
-            if (val === null) {
-                return "null";
-            }
-
-            // Special-case Node objects, since those come up a lot in my tests.  I
-            // ignore namespaces.
-            if (is_node(val)) {
-                switch (val.nodeType) {
-                case Node.ELEMENT_NODE:
-                    var ret = "<" + val.localName;
-                    for (var i = 0; i < val.attributes.length; i++) {
-                        ret += " " + val.attributes[i].name + '="' + val.attributes[i].value + '"';
-                    }
-                    ret += ">" + val.innerHTML + "</" + val.localName + ">";
-                    return "Element node " + truncate(ret, 60);
-                case Node.TEXT_NODE:
-                    return 'Text node "' + truncate(val.data, 60) + '"';
-                case Node.PROCESSING_INSTRUCTION_NODE:
-                    return "ProcessingInstruction node with target " + format_value(truncate(val.target, 60)) + " and data " + format_value(truncate(val.data, 60));
-                case Node.COMMENT_NODE:
-                    return "Comment node <!--" + truncate(val.data, 60) + "-->";
-                case Node.DOCUMENT_NODE:
-                    return "Document node with " + val.childNodes.length + (val.childNodes.length == 1 ? " child" : " children");
-                case Node.DOCUMENT_TYPE_NODE:
-                    return "DocumentType node";
-                case Node.DOCUMENT_FRAGMENT_NODE:
-                    return "DocumentFragment node with " + val.childNodes.length + (val.childNodes.length == 1 ? " child" : " children");
-                default:
-                    return "Node object of unknown type";
-                }
-            }
-
-        /* falls through */
-        default:
-            try {
-                return typeof val + ' "' + truncate(String(val), 1000) + '"';
-            } catch(e) {
-                return ("[stringifying object threw " + String(e) +
-                        " with type " + String(typeof e) + "]");
-            }
-        }
-    }
-    expose(format_value, "format_value");
-
-    /*
-     * Assertions
-     */
-
-    function assert_true(actual, description)
-    {
-        assert(actual === true, "assert_true", description,
-                                "expected true got ${actual}", {actual:actual});
-    }
-    expose(assert_true, "assert_true");
-
-    function assert_false(actual, description)
-    {
-        assert(actual === false, "assert_false", description,
-                                 "expected false got ${actual}", {actual:actual});
-    }
-    expose(assert_false, "assert_false");
-
-    function same_value(x, y) {
-        if (y !== y) {
-            //NaN case
-            return x !== x;
-        }
-        if (x === 0 && y === 0) {
-            //Distinguish +0 and -0
-            return 1/x === 1/y;
-        }
-        return x === y;
-    }
-
-    function assert_equals(actual, expected, description)
-    {
-         /*
-          * Test if two primitives are equal or two objects
-          * are the same object
-          */
-        if (typeof actual != typeof expected) {
-            assert(false, "assert_equals", description,
-                          "expected (" + typeof expected + ") ${expected} but got (" + typeof actual + ") ${actual}",
-                          {expected:expected, actual:actual});
-            return;
-        }
-        assert(same_value(actual, expected), "assert_equals", description,
-                                             "expected ${expected} but got ${actual}",
-                                             {expected:expected, actual:actual});
-    }
-    expose(assert_equals, "assert_equals");
-
-    function assert_not_equals(actual, expected, description)
-    {
-         /*
-          * Test if two primitives are unequal or two objects
-          * are different objects
-          */
-        assert(!same_value(actual, expected), "assert_not_equals", description,
-                                              "got disallowed value ${actual}",
-                                              {actual:actual});
-    }
-    expose(assert_not_equals, "assert_not_equals");
-
-    function assert_in_array(actual, expected, description)
-    {
-        assert(expected.indexOf(actual) != -1, "assert_in_array", description,
-                                               "value ${actual} not in array ${expected}",
-                                               {actual:actual, expected:expected});
-    }
-    expose(assert_in_array, "assert_in_array");
-
-    function assert_object_equals(actual, expected, description)
-    {
-         assert(typeof actual === "object" && actual !== null, "assert_object_equals", description,
-                                                               "value is ${actual}, expected object",
-                                                               {actual: actual});
-         //This needs to be improved a great deal
-         function check_equal(actual, expected, stack)
-         {
-             stack.push(actual);
-
-             var p;
-             for (p in actual) {
-                 assert(expected.hasOwnProperty(p), "assert_object_equals", description,
-                                                    "unexpected property ${p}", {p:p});
-
-                 if (typeof actual[p] === "object" && actual[p] !== null) {
-                     if (stack.indexOf(actual[p]) === -1) {
-                         check_equal(actual[p], expected[p], stack);
-                     }
-                 } else {
-                     assert(same_value(actual[p], expected[p]), "assert_object_equals", description,
-                                                       "property ${p} expected ${expected} got ${actual}",
-                                                       {p:p, expected:expected, actual:actual});
-                 }
-             }
-             for (p in expected) {
-                 assert(actual.hasOwnProperty(p),
-                        "assert_object_equals", description,
-                        "expected property ${p} missing", {p:p});
-             }
-             stack.pop();
-         }
-         check_equal(actual, expected, []);
-    }
-    expose(assert_object_equals, "assert_object_equals");
-
-    function assert_array_equals(actual, expected, description)
-    {
-        assert(typeof actual === "object" && actual !== null && "length" in actual,
-               "assert_array_equals", description,
-               "value is ${actual}, expected array",
-               {actual:actual});
-        assert(actual.length === expected.length,
-               "assert_array_equals", description,
-               "lengths differ, expected ${expected} got ${actual}",
-               {expected:expected.length, actual:actual.length});
-
-        for (var i = 0; i < actual.length; i++) {
-            assert(actual.hasOwnProperty(i) === expected.hasOwnProperty(i),
-                   "assert_array_equals", description,
-                   "property ${i}, property expected to be ${expected} but was ${actual}",
-                   {i:i, expected:expected.hasOwnProperty(i) ? "present" : "missing",
-                   actual:actual.hasOwnProperty(i) ? "present" : "missing"});
-            assert(same_value(expected[i], actual[i]),
-                   "assert_array_equals", description,
-                   "property ${i}, expected ${expected} but got ${actual}",
-                   {i:i, expected:expected[i], actual:actual[i]});
-        }
-    }
-    expose(assert_array_equals, "assert_array_equals");
-
-    function assert_array_approx_equals(actual, expected, epsilon, description)
-    {
-        /*
-         * Test if two primitive arrays are equal within +/- epsilon
-         */
-        assert(actual.length === expected.length,
-               "assert_array_approx_equals", description,
-               "lengths differ, expected ${expected} got ${actual}",
-               {expected:expected.length, actual:actual.length});
-
-        for (var i = 0; i < actual.length; i++) {
-            assert(actual.hasOwnProperty(i) === expected.hasOwnProperty(i),
-                   "assert_array_approx_equals", description,
-                   "property ${i}, property expected to be ${expected} but was ${actual}",
-                   {i:i, expected:expected.hasOwnProperty(i) ? "present" : "missing",
-                   actual:actual.hasOwnProperty(i) ? "present" : "missing"});
-            assert(typeof actual[i] === "number",
-                   "assert_array_approx_equals", description,
-                   "property ${i}, expected a number but got a ${type_actual}",
-                   {i:i, type_actual:typeof actual[i]});
-            assert(Math.abs(actual[i] - expected[i]) <= epsilon,
-                   "assert_array_approx_equals", description,
-                   "property ${i}, expected ${expected} +/- ${epsilon}, expected ${expected} but got ${actual}",
-                   {i:i, expected:expected[i], actual:actual[i]});
-        }
-    }
-    expose(assert_array_approx_equals, "assert_array_approx_equals");
-
-    function assert_approx_equals(actual, expected, epsilon, description)
-    {
-        /*
-         * Test if two primitive numbers are equal within +/- epsilon
-         */
-        assert(typeof actual === "number",
-               "assert_approx_equals", description,
-               "expected a number but got a ${type_actual}",
-               {type_actual:typeof actual});
-
-        assert(Math.abs(actual - expected) <= epsilon,
-               "assert_approx_equals", description,
-               "expected ${expected} +/- ${epsilon} but got ${actual}",
-               {expected:expected, actual:actual, epsilon:epsilon});
-    }
-    expose(assert_approx_equals, "assert_approx_equals");
-
-    function assert_less_than(actual, expected, description)
-    {
-        /*
-         * Test if a primitive number is less than another
-         */
-        assert(typeof actual === "number",
-               "assert_less_than", description,
-               "expected a number but got a ${type_actual}",
-               {type_actual:typeof actual});
-
-        assert(actual < expected,
-               "assert_less_than", description,
-               "expected a number less than ${expected} but got ${actual}",
-               {expected:expected, actual:actual});
-    }
-    expose(assert_less_than, "assert_less_than");
-
-    function assert_greater_than(actual, expected, description)
-    {
-        /*
-         * Test if a primitive number is greater than another
-         */
-        assert(typeof actual === "number",
-               "assert_greater_than", description,
-               "expected a number but got a ${type_actual}",
-               {type_actual:typeof actual});
-
-        assert(actual > expected,
-               "assert_greater_than", description,
-               "expected a number greater than ${expected} but got ${actual}",
-               {expected:expected, actual:actual});
-    }
-    expose(assert_greater_than, "assert_greater_than");
-
-    function assert_between_exclusive(actual, lower, upper, description)
-    {
-        /*
-         * Test if a primitive number is between two others
-         */
-        assert(typeof actual === "number",
-               "assert_between_exclusive", description,
-               "expected a number but got a ${type_actual}",
-               {type_actual:typeof actual});
-
-        assert(actual > lower && actual < upper,
-               "assert_between_exclusive", description,
-               "expected a number greater than ${lower} " +
-               "and less than ${upper} but got ${actual}",
-               {lower:lower, upper:upper, actual:actual});
-    }
-    expose(assert_between_exclusive, "assert_between_exclusive");
-
-    function assert_less_than_equal(actual, expected, description)
-    {
-        /*
-         * Test if a primitive number is less than or equal to another
-         */
-        assert(typeof actual === "number",
-               "assert_less_than_equal", description,
-               "expected a number but got a ${type_actual}",
-               {type_actual:typeof actual});
-
-        assert(actual <= expected,
-               "assert_less_than_equal", description,
-               "expected a number less than or equal to ${expected} but got ${actual}",
-               {expected:expected, actual:actual});
-    }
-    expose(assert_less_than_equal, "assert_less_than_equal");
-
-    function assert_greater_than_equal(actual, expected, description)
-    {
-        /*
-         * Test if a primitive number is greater than or equal to another
-         */
-        assert(typeof actual === "number",
-               "assert_greater_than_equal", description,
-               "expected a number but got a ${type_actual}",
-               {type_actual:typeof actual});
-
-        assert(actual >= expected,
-               "assert_greater_than_equal", description,
-               "expected a number greater than or equal to ${expected} but got ${actual}",
-               {expected:expected, actual:actual});
-    }
-    expose(assert_greater_than_equal, "assert_greater_than_equal");
-
-    function assert_between_inclusive(actual, lower, upper, description)
-    {
-        /*
-         * Test if a primitive number is between to two others or equal to either of them
-         */
-        assert(typeof actual === "number",
-               "assert_between_inclusive", description,
-               "expected a number but got a ${type_actual}",
-               {type_actual:typeof actual});
-
-        assert(actual >= lower && actual <= upper,
-               "assert_between_inclusive", description,
-               "expected a number greater than or equal to ${lower} " +
-               "and less than or equal to ${upper} but got ${actual}",
-               {lower:lower, upper:upper, actual:actual});
-    }
-    expose(assert_between_inclusive, "assert_between_inclusive");
-
-    function assert_regexp_match(actual, expected, description) {
-        /*
-         * Test if a string (actual) matches a regexp (expected)
-         */
-        assert(expected.test(actual),
-               "assert_regexp_match", description,
-               "expected ${expected} but got ${actual}",
-               {expected:expected, actual:actual});
-    }
-    expose(assert_regexp_match, "assert_regexp_match");
-
-    function assert_class_string(object, class_string, description) {
-        assert_equals({}.toString.call(object), "[object " + class_string + "]",
-                      description);
-    }
-    expose(assert_class_string, "assert_class_string");
-
-
-    function assert_own_property(object, property_name, description) {
-        assert(object.hasOwnProperty(property_name),
-               "assert_own_property", description,
-               "expected property ${p} missing", {p:property_name});
-    }
-    expose(assert_own_property, "assert_own_property");
-
-    function assert_not_own_property(object, property_name, description) {
-        assert(!object.hasOwnProperty(property_name),
-               "assert_not_own_property", description,
-               "unexpected property ${p} is found on object", {p:property_name});
-    }
-    expose(assert_not_own_property, "assert_not_own_property");
-
-    function _assert_inherits(name) {
-        return function (object, property_name, description)
-        {
-            assert(typeof object === "object" || typeof object === "function",
-                   name, description,
-                   "provided value is not an object");
-
-            assert("hasOwnProperty" in object,
-                   name, description,
-                   "provided value is an object but has no hasOwnProperty method");
-
-            assert(!object.hasOwnProperty(property_name),
-                   name, description,
-                   "property ${p} found on object expected in prototype chain",
-                   {p:property_name});
-
-            assert(property_name in object,
-                   name, description,
-                   "property ${p} not found in prototype chain",
-                   {p:property_name});
-        };
-    }
-    expose(_assert_inherits("assert_inherits"), "assert_inherits");
-    expose(_assert_inherits("assert_idl_attribute"), "assert_idl_attribute");
-
-    function assert_readonly(object, property_name, description)
-    {
-         var initial_value = object[property_name];
-         try {
-             //Note that this can have side effects in the case where
-             //the property has PutForwards
-             object[property_name] = initial_value + "a"; //XXX use some other value here?
-             assert(same_value(object[property_name], initial_value),
-                    "assert_readonly", description,
-                    "changing property ${p} succeeded",
-                    {p:property_name});
-         } finally {
-             object[property_name] = initial_value;
-         }
-    }
-    expose(assert_readonly, "assert_readonly");
-
-    /**
-     * Assert an Exception with the expected code is thrown.
-     *
-     * @param {object|number|string} code The expected exception code.
-     * @param {Function} func Function which should throw.
-     * @param {string} description Error description for the case that the error is not thrown.
-     */
-    function assert_throws(code, func, description)
-    {
-        try {
-            func.call(this);
-            assert(false, "assert_throws", description,
-                   "${func} did not throw", {func:func});
-        } catch (e) {
-            if (e instanceof AssertionError) {
-                throw e;
-            }
-
-            assert(typeof e === "object",
-                   "assert_throws", description,
-                   "${func} threw ${e} with type ${type}, not an object",
-                   {func:func, e:e, type:typeof e});
-
-            assert(e !== null,
-                   "assert_throws", description,
-                   "${func} threw null, not an object",
-                   {func:func});
-
-            if (code === null) {
-                throw new AssertionError('Test bug: need to pass exception to assert_throws()');
-            }
-            if (typeof code === "object") {
-                assert("name" in e && e.name == code.name,
-                       "assert_throws", description,
-                       "${func} threw ${actual} (${actual_name}) expected ${expected} (${expected_name})",
-                                    {func:func, actual:e, actual_name:e.name,
-                                     expected:code,
-                                     expected_name:code.name});
-                return;
-            }
-
-            var code_name_map = {
-                INDEX_SIZE_ERR: 'IndexSizeError',
-                HIERARCHY_REQUEST_ERR: 'HierarchyRequestError',
-                WRONG_DOCUMENT_ERR: 'WrongDocumentError',
-                INVALID_CHARACTER_ERR: 'InvalidCharacterError',
-                NO_MODIFICATION_ALLOWED_ERR: 'NoModificationAllowedError',
-                NOT_FOUND_ERR: 'NotFoundError',
-                NOT_SUPPORTED_ERR: 'NotSupportedError',
-                INUSE_ATTRIBUTE_ERR: 'InUseAttributeError',
-                INVALID_STATE_ERR: 'InvalidStateError',
-                SYNTAX_ERR: 'SyntaxError',
-                INVALID_MODIFICATION_ERR: 'InvalidModificationError',
-                NAMESPACE_ERR: 'NamespaceError',
-                INVALID_ACCESS_ERR: 'InvalidAccessError',
-                TYPE_MISMATCH_ERR: 'TypeMismatchError',
-                SECURITY_ERR: 'SecurityError',
-                NETWORK_ERR: 'NetworkError',
-                ABORT_ERR: 'AbortError',
-                URL_MISMATCH_ERR: 'URLMismatchError',
-                QUOTA_EXCEEDED_ERR: 'QuotaExceededError',
-                TIMEOUT_ERR: 'TimeoutError',
-                INVALID_NODE_TYPE_ERR: 'InvalidNodeTypeError',
-                DATA_CLONE_ERR: 'DataCloneError'
-            };
-
-            var name = code in code_name_map ? code_name_map[code] : code;
-
-            var name_code_map = {
-                IndexSizeError: 1,
-                HierarchyRequestError: 3,
-                WrongDocumentError: 4,
-                InvalidCharacterError: 5,
-                NoModificationAllowedError: 7,
-                NotFoundError: 8,
-                NotSupportedError: 9,
-                InUseAttributeError: 10,
-                InvalidStateError: 11,
-                SyntaxError: 12,
-                InvalidModificationError: 13,
-                NamespaceError: 14,
-                InvalidAccessError: 15,
-                TypeMismatchError: 17,
-                SecurityError: 18,
-                NetworkError: 19,
-                AbortError: 20,
-                URLMismatchError: 21,
-                QuotaExceededError: 22,
-                TimeoutError: 23,
-                InvalidNodeTypeError: 24,
-                DataCloneError: 25,
-
-                EncodingError: 0,
-                NotReadableError: 0,
-                UnknownError: 0,
-                ConstraintError: 0,
-                DataError: 0,
-                TransactionInactiveError: 0,
-                ReadOnlyError: 0,
-                VersionError: 0,
-                OperationError: 0,
-                NotAllowedError: 0
-            };
-
-            if (!(name in name_code_map)) {
-                throw new AssertionError('Test bug: unrecognized DOMException code "' + code + '" passed to assert_throws()');
-            }
-
-            var required_props = { code: name_code_map[name] };
-
-            if (required_props.code === 0 ||
-               ("name" in e &&
-                e.name !== e.name.toUpperCase() &&
-                e.name !== "DOMException")) {
-                // New style exception: also test the name property.
-                required_props.name = name;
-            }
-
-            //We'd like to test that e instanceof the appropriate interface,
-            //but we can't, because we don't know what window it was created
-            //in.  It might be an instanceof the appropriate interface on some
-            //unknown other window.  TODO: Work around this somehow?
-
-            for (var prop in required_props) {
-                assert(prop in e && e[prop] == required_props[prop],
-                       "assert_throws", description,
-                       "${func} threw ${e} that is not a DOMException " + code + ": property ${prop} is equal to ${actual}, expected ${expected}",
-                       {func:func, e:e, prop:prop, actual:e[prop], expected:required_props[prop]});
-            }
-        }
-    }
-    expose(assert_throws, "assert_throws");
-
-    function assert_unreached(description) {
-         assert(false, "assert_unreached", description,
-                "Reached unreachable code");
-    }
-    expose(assert_unreached, "assert_unreached");
-
-    function assert_any(assert_func, actual, expected_array)
-    {
-        var args = [].slice.call(arguments, 3);
-        var errors = [];
-        var passed = false;
-        forEach(expected_array,
-                function(expected)
-                {
-                    try {
-                        assert_func.apply(this, [actual, expected].concat(args));
-                        passed = true;
-                    } catch (e) {
-                        errors.push(e.message);
-                    }
-                });
-        if (!passed) {
-            throw new AssertionError(errors.join("\n\n"));
-        }
-    }
-    expose(assert_any, "assert_any");
-
-    function Test(name, properties)
-    {
-        if (tests.file_is_test && tests.tests.length) {
-            throw new Error("Tried to create a test with file_is_test");
-        }
-        this.name = name;
-
-        this.phase = tests.is_aborted ?
-            this.phases.COMPLETE : this.phases.INITIAL;
-
-        this.status = this.NOTRUN;
-        this.timeout_id = null;
-        this.index = null;
-
-        this.properties = properties;
-        var timeout = properties.timeout ? properties.timeout : settings.test_timeout;
-        if (timeout !== null) {
-            this.timeout_length = timeout * tests.timeout_multiplier;
-        } else {
-            this.timeout_length = null;
-        }
-
-        this.message = null;
-        this.stack = null;
-
-        this.steps = [];
-        this._is_promise_test = false;
-
-        this.cleanup_callbacks = [];
-        this._user_defined_cleanup_count = 0;
-        this._done_callbacks = [];
-
-        tests.push(this);
-    }
-
-    Test.statuses = {
-        PASS:0,
-        FAIL:1,
-        TIMEOUT:2,
-        NOTRUN:3
-    };
-
-    Test.prototype = merge({}, Test.statuses);
-
-    Test.prototype.phases = {
-        INITIAL:0,
-        STARTED:1,
-        HAS_RESULT:2,
-        CLEANING:3,
-        COMPLETE:4
-    };
-
-    Test.prototype.structured_clone = function()
-    {
-        if (!this._structured_clone) {
-            var msg = this.message;
-            msg = msg ? String(msg) : msg;
-            this._structured_clone = merge({
-                name:String(this.name),
-                properties:merge({}, this.properties),
-                phases:merge({}, this.phases)
-            }, Test.statuses);
-        }
-        this._structured_clone.status = this.status;
-        this._structured_clone.message = this.message;
-        this._structured_clone.stack = this.stack;
-        this._structured_clone.index = this.index;
-        this._structured_clone.phase = this.phase;
-        return this._structured_clone;
-    };
-
-    Test.prototype.step = function(func, this_obj)
-    {
-        if (this.phase > this.phases.STARTED) {
-            return;
-        }
-        this.phase = this.phases.STARTED;
-        //If we don't get a result before the harness times out that will be a test timeout
-        this.set_status(this.TIMEOUT, "Test timed out");
-
-        tests.started = true;
-        tests.notify_test_state(this);
-
-        if (this.timeout_id === null) {
-            this.set_timeout();
-        }
-
-        this.steps.push(func);
-
-        if (arguments.length === 1) {
-            this_obj = this;
-        }
-
-        try {
-            return func.apply(this_obj, Array.prototype.slice.call(arguments, 2));
-        } catch (e) {
-            if (this.phase >= this.phases.HAS_RESULT) {
-                return;
-            }
-            var message = String((typeof e === "object" && e !== null) ? e.message : e);
-            var stack = e.stack ? e.stack : null;
-
-            this.set_status(this.FAIL, message, stack);
-            this.phase = this.phases.HAS_RESULT;
-            this.done();
-        }
-    };
-
-    Test.prototype.step_func = function(func, this_obj)
-    {
-        var test_this = this;
-
-        if (arguments.length === 1) {
-            this_obj = test_this;
-        }
-
-        return function()
-        {
-            return test_this.step.apply(test_this, [func, this_obj].concat(
-                Array.prototype.slice.call(arguments)));
-        };
-    };
-
-    Test.prototype.step_func_done = function(func, this_obj)
-    {
-        var test_this = this;
+          // If document.domain was set at some point same_origin can be
+          // wrong and the above will fail.
+          has_selector = false;
+        }
+        if (has_selector) {
+          try {
+            w[selector].apply(undefined, callback_args);
+          } catch (e) {
+            if (debug) {
+              throw e;
+            }
+          }
+        }
+      }
+      if (supports_post_message(w) && w !== self) {
+        w.postMessage(message_arg, '*');
+      }
+    });
+  };
+
+  WindowTestEnvironment.prototype._forEach_windows = function(callback) {
+    // Iterate over the windows [self ... top, opener]. The callback is passed
+    // two objects, the first one is the window object itself, the second one
+    // is a boolean indicating whether or not it's on the same origin as the
+    // current window.
+    var cache = this.window_cache;
+    if (!cache) {
+      cache = [[self, true]];
+      var w = self;
+      var i = 0;
+      var so;
+      while (w != w.parent) {
+        w = w.parent;
+        so = is_same_origin(w);
+        cache.push([w, so]);
+        i++;
+      }
+      w = window.opener;
+      if (w) {
+        cache.push([w, is_same_origin(w)]);
+      }
+      this.window_cache = cache;
+    }
+
+    forEach(cache, function(a) {
+      callback.apply(null, a);
+    });
+  };
+
+  WindowTestEnvironment.prototype.on_tests_ready = function() {
+    var output = new Output();
+    this.output_handler = output;
+
+    var this_obj = this;
+
+    add_start_callback(function(properties) {
+      this_obj.output_handler.init(properties);
+    });
+
+    add_test_state_callback(function(test) {
+      this_obj.output_handler.show_status();
+    });
+
+    add_result_callback(function(test) {
+      this_obj.output_handler.show_status();
+    });
+
+    add_completion_callback(function(tests, harness_status) {
+      this_obj.output_handler.show_results(tests, harness_status);
+    });
+    this.setup_messages(settings.message_events);
+  };
+
+  WindowTestEnvironment.prototype.setup_messages = function(new_events) {
+    var this_obj = this;
+    forEach(settings.message_events, function(x) {
+      var current_dispatch = this_obj.message_events.indexOf(x) !== -1;
+      var new_dispatch = new_events.indexOf(x) !== -1;
+      if (!current_dispatch && new_dispatch) {
+        this_obj.message_functions[x][0](this_obj.message_functions[x][2]);
+      } else if (current_dispatch && !new_dispatch) {
+        this_obj.message_functions[x][1](this_obj.message_functions[x][2]);
+      }
+    });
+    this.message_events = new_events;
+  };
+
+  WindowTestEnvironment.prototype.next_default_test_name = function() {
+    var suffix = this.name_counter > 0 ? ' ' + this.name_counter : '';
+    this.name_counter++;
+    return get_title() + suffix;
+  };
+
+  WindowTestEnvironment.prototype.on_new_harness_properties = function(
+    properties
+  ) {
+    this.output_handler.setup(properties);
+    if (properties.hasOwnProperty('message_events')) {
+      this.setup_messages(properties.message_events);
+    }
+  };
+
+  WindowTestEnvironment.prototype.add_on_loaded_callback = function(callback) {
+    on_event(window, 'load', callback);
+  };
+
+  WindowTestEnvironment.prototype.test_timeout = function() {
+    var metas = document.getElementsByTagName('meta');
+    for (var i = 0; i < metas.length; i++) {
+      if (metas[i].name == 'timeout') {
+        if (metas[i].content == 'long') {
+          return settings.harness_timeout.long;
+        }
+        break;
+      }
+    }
+    return settings.harness_timeout.normal;
+  };
+
+  /*
+   * Base TestEnvironment implementation for a generic web worker.
+   *
+   * Workers accumulate test results. One or more clients can connect and
+   * retrieve results from a worker at any time.
+   *
+   * WorkerTestEnvironment supports communicating with a client via a
+   * MessagePort.  The mechanism for determining the appropriate MessagePort
+   * for communicating with a client depends on the type of worker and is
+   * implemented by the various specializations of WorkerTestEnvironment
+   * below.
+   *
+   * A client document using testharness can use fetch_tests_from_worker() to
+   * retrieve results from a worker. See apisample16.html.
+   */
+  function WorkerTestEnvironment() {
+    this.name_counter = 0;
+    this.all_loaded = true;
+    this.message_list = [];
+    this.message_ports = [];
+  }
+
+  WorkerTestEnvironment.prototype._dispatch = function(message) {
+    this.message_list.push(message);
+    for (var i = 0; i < this.message_ports.length; ++i) {
+      this.message_ports[i].postMessage(message);
+    }
+  };
+
+  // The only requirement is that port has a postMessage() method. It doesn't
+  // have to be an instance of a MessagePort, and often isn't.
+  WorkerTestEnvironment.prototype._add_message_port = function(port) {
+    this.message_ports.push(port);
+    for (var i = 0; i < this.message_list.length; ++i) {
+      port.postMessage(this.message_list[i]);
+    }
+  };
+
+  WorkerTestEnvironment.prototype.next_default_test_name = function() {
+    var suffix = this.name_counter > 0 ? ' ' + this.name_counter : '';
+    this.name_counter++;
+    return get_title() + suffix;
+  };
+
+  WorkerTestEnvironment.prototype.on_new_harness_properties = function() {};
+
+  WorkerTestEnvironment.prototype.on_tests_ready = function() {
+    var this_obj = this;
+    add_start_callback(function(properties) {
+      this_obj._dispatch({
+        type: 'start',
+        properties: properties
+      });
+    });
+    add_test_state_callback(function(test) {
+      this_obj._dispatch({
+        type: 'test_state',
+        test: test.structured_clone()
+      });
+    });
+    add_result_callback(function(test) {
+      this_obj._dispatch({
+        type: 'result',
+        test: test.structured_clone()
+      });
+    });
+    add_completion_callback(function(tests, harness_status) {
+      this_obj._dispatch({
+        type: 'complete',
+        tests: map(tests, function(test) {
+          return test.structured_clone();
+        }),
+        status: harness_status.structured_clone()
+      });
+    });
+  };
+
+  WorkerTestEnvironment.prototype.add_on_loaded_callback = function() {};
+
+  WorkerTestEnvironment.prototype.test_timeout = function() {
+    // Tests running in a worker don't have a default timeout. I.e. all
+    // worker tests behave as if settings.explicit_timeout is true.
+    return null;
+  };
+
+  /*
+   * Dedicated web workers.
+   * https://html.spec.whatwg.org/multipage/workers.html#dedicatedworkerglobalscope
+   *
+   * This class is used as the test_environment when testharness is running
+   * inside a dedicated worker.
+   */
+  function DedicatedWorkerTestEnvironment() {
+    WorkerTestEnvironment.call(this);
+    // self is an instance of DedicatedWorkerGlobalScope which exposes
+    // a postMessage() method for communicating via the message channel
+    // established when the worker is created.
+    this._add_message_port(self);
+  }
+  DedicatedWorkerTestEnvironment.prototype = Object.create(
+    WorkerTestEnvironment.prototype
+  );
+
+  DedicatedWorkerTestEnvironment.prototype.on_tests_ready = function() {
+    WorkerTestEnvironment.prototype.on_tests_ready.call(this);
+    // In the absence of an onload notification, we a require dedicated
+    // workers to explicitly signal when the tests are done.
+    tests.wait_for_finish = true;
+  };
+
+  /*
+   * Shared web workers.
+   * https://html.spec.whatwg.org/multipage/workers.html#sharedworkerglobalscope
+   *
+   * This class is used as the test_environment when testharness is running
+   * inside a shared web worker.
+   */
+  function SharedWorkerTestEnvironment() {
+    WorkerTestEnvironment.call(this);
+    var this_obj = this;
+    // Shared workers receive message ports via the 'onconnect' event for
+    // each connection.
+    self.addEventListener(
+      'connect',
+      function(message_event) {
+        this_obj._add_message_port(message_event.source);
+      },
+      false
+    );
+  }
+  SharedWorkerTestEnvironment.prototype = Object.create(
+    WorkerTestEnvironment.prototype
+  );
+
+  SharedWorkerTestEnvironment.prototype.on_tests_ready = function() {
+    WorkerTestEnvironment.prototype.on_tests_ready.call(this);
+    // In the absence of an onload notification, we a require shared
+    // workers to explicitly signal when the tests are done.
+    tests.wait_for_finish = true;
+  };
+
+  /*
+   * Service workers.
+   * http://www.w3.org/TR/service-workers/
+   *
+   * This class is used as the test_environment when testharness is running
+   * inside a service worker.
+   */
+  function ServiceWorkerTestEnvironment() {
+    WorkerTestEnvironment.call(this);
+    this.all_loaded = false;
+    this.on_loaded_callback = null;
+    var this_obj = this;
+    self.addEventListener(
+      'message',
+      function(event) {
+        if (event.data && event.data.type && event.data.type === 'connect') {
+          if (event.ports && event.ports[0]) {
+            // If a MessageChannel was passed, then use it to
+            // send results back to the main window.  This
+            // allows the tests to work even if the browser
+            // does not fully support MessageEvent.source in
+            // ServiceWorkers yet.
+            this_obj._add_message_port(event.ports[0]);
+            event.ports[0].start();
+          } else {
+            // If there is no MessageChannel, then attempt to
+            // use the MessageEvent.source to send results
+            // back to the main window.
+            this_obj._add_message_port(event.source);
+          }
+        }
+      },
+      false
+    );
+
+    // The oninstall event is received after the service worker script and
+    // all imported scripts have been fetched and executed. It's the
+    // equivalent of an onload event for a document. All tests should have
+    // been added by the time this event is received, thus it's not
+    // necessary to wait until the onactivate event. However, tests for
+    // installed service workers need another event which is equivalent to
+    // the onload event because oninstall is fired only on installation. The
+    // onmessage event is used for that purpose since tests using
+    // testharness.js should ask the result to its service worker by
+    // PostMessage. If the onmessage event is triggered on the service
+    // worker's context, that means the worker's script has been evaluated.
+    on_event(self, 'install', on_all_loaded);
+    on_event(self, 'message', on_all_loaded);
+    function on_all_loaded() {
+      if (this_obj.all_loaded) return;
+      this_obj.all_loaded = true;
+      if (this_obj.on_loaded_callback) {
+        this_obj.on_loaded_callback();
+      }
+    }
+  }
+
+  ServiceWorkerTestEnvironment.prototype = Object.create(
+    WorkerTestEnvironment.prototype
+  );
+
+  ServiceWorkerTestEnvironment.prototype.add_on_loaded_callback = function(
+    callback
+  ) {
+    if (this.all_loaded) {
+      callback();
+    } else {
+      this.on_loaded_callback = callback;
+    }
+  };
+
+  /*
+   * JavaScript shells.
+   *
+   * This class is used as the test_environment when testharness is running
+   * inside a JavaScript shell.
+   */
+  function ShellTestEnvironment() {
+    this.name_counter = 0;
+    this.all_loaded = false;
+    this.on_loaded_callback = null;
+    Promise.resolve().then(
+      function() {
+        this.all_loaded = true;
+        if (this.on_loaded_callback) {
+          this.on_loaded_callback();
+        }
+      }.bind(this)
+    );
+    this.message_list = [];
+    this.message_ports = [];
+  }
+
+  ShellTestEnvironment.prototype.next_default_test_name = function() {
+    var suffix = this.name_counter > 0 ? ' ' + this.name_counter : '';
+    this.name_counter++;
+    return 'Untitled' + suffix;
+  };
 
-        if (arguments.length === 1) {
-            this_obj = test_this;
-        }
+  ShellTestEnvironment.prototype.on_new_harness_properties = function() {};
+
+  ShellTestEnvironment.prototype.on_tests_ready = function() {};
 
-        return function()
-        {
-            if (func) {
-                test_this.step.apply(test_this, [func, this_obj].concat(
-                    Array.prototype.slice.call(arguments)));
-            }
-            test_this.done();
-        };
-    };
+  ShellTestEnvironment.prototype.add_on_loaded_callback = function(callback) {
+    if (this.all_loaded) {
+      callback();
+    } else {
+      this.on_loaded_callback = callback;
+    }
+  };
 
-    Test.prototype.unreached_func = function(description)
-    {
-        return this.step_func(function() {
-            assert_unreached(description);
+  ShellTestEnvironment.prototype.test_timeout = function() {
+    // Tests running in a shell don't have a default timeout, so behave as
+    // if settings.explicit_timeout is true.
+    return null;
+  };
+
+  function create_test_environment() {
+    if ('document' in global_scope) {
+      return new WindowTestEnvironment();
+    }
+    if (
+      'DedicatedWorkerGlobalScope' in global_scope &&
+      global_scope instanceof DedicatedWorkerGlobalScope
+    ) {
+      return new DedicatedWorkerTestEnvironment();
+    }
+    if (
+      'SharedWorkerGlobalScope' in global_scope &&
+      global_scope instanceof SharedWorkerGlobalScope
+    ) {
+      return new SharedWorkerTestEnvironment();
+    }
+    if (
+      'ServiceWorkerGlobalScope' in global_scope &&
+      global_scope instanceof ServiceWorkerGlobalScope
+    ) {
+      return new ServiceWorkerTestEnvironment();
+    }
+    if (
+      'WorkerGlobalScope' in global_scope &&
+      global_scope instanceof WorkerGlobalScope
+    ) {
+      return new DedicatedWorkerTestEnvironment();
+    }
+
+    if (!('self' in global_scope)) {
+      return new ShellTestEnvironment();
+    }
+
+    throw new Error('Unsupported test environment');
+  }
+
+  var test_environment = create_test_environment();
+
+  function is_shared_worker(worker) {
+    return 'SharedWorker' in global_scope && worker instanceof SharedWorker;
+  }
+
+  function is_service_worker(worker) {
+    // The worker object may be from another execution context,
+    // so do not use instanceof here.
+    return (
+      'ServiceWorker' in global_scope &&
+      Object.prototype.toString.call(worker) == '[object ServiceWorker]'
+    );
+  }
+
+  /*
+   * API functions
+   */
+  function test(func, name, properties) {
+    var test_name = name ? name : test_environment.next_default_test_name();
+    properties = properties ? properties : {};
+    var test_obj = new Test(test_name, properties);
+    var value = test_obj.step(func, test_obj, test_obj);
+
+    if (value !== undefined) {
+      var msg =
+        'test named "' + test_name + '" inappropriately returned a value';
+
+      try {
+        if (value && value.hasOwnProperty('then')) {
+          msg += ', consider using `promise_test` instead';
+        }
+      } catch (err) {}
+
+      tests.status.status = tests.status.ERROR;
+      tests.status.message = msg;
+    }
+
+    if (test_obj.phase === test_obj.phases.STARTED) {
+      test_obj.done();
+    }
+  }
+
+  function async_test(func, name, properties) {
+    if (typeof func !== 'function') {
+      properties = name;
+      name = func;
+      func = null;
+    }
+    var test_name = name ? name : test_environment.next_default_test_name();
+    properties = properties ? properties : {};
+    var test_obj = new Test(test_name, properties);
+    if (func) {
+      test_obj.step(func, test_obj, test_obj);
+    }
+    return test_obj;
+  }
+
+  function promise_test(func, name, properties) {
+    var test = async_test(name, properties);
+    test._is_promise_test = true;
+
+    // If there is no promise tests queue make one.
+    if (!tests.promise_tests) {
+      tests.promise_tests = Promise.resolve();
+    }
+    tests.promise_tests = tests.promise_tests.then(function() {
+      return new Promise(function(resolve) {
+        var promise = test.step(func, test, test);
+
+        test.step(function() {
+          assert(
+            !!promise,
+            'promise_test',
+            null,
+            "test body must return a 'thenable' object (received ${value})",
+            { value: promise }
+          );
+          assert(
+            typeof promise.then === 'function',
+            'promise_test',
+            null,
+            "test body must return a 'thenable' object (received an object with no `then` method)",
+            null
+          );
         });
-    };
 
-    Test.prototype.step_timeout = function(f, timeout) {
-        var test_this = this;
-        var args = Array.prototype.slice.call(arguments, 2);
-        return setTimeout(this.step_func(function() {
-            return f.apply(test_this, args);
-        }), timeout * tests.timeout_multiplier);
-    }
-
-    /*
-     * Private method for registering cleanup functions. `testharness.js`
-     * internals should use this method instead of the public `add_cleanup`
-     * method in order to hide implementation details from the harness status
-     * message in the case errors.
-     */
-    Test.prototype._add_cleanup = function(callback) {
-        this.cleanup_callbacks.push(callback);
-    };
-
-    /*
-     * Schedule a function to be run after the test result is known, regardless
-     * of passing or failing state. The behavior of this function will not
-     * influence the result of the test, but if an exception is thrown, the
-     * test harness will report an error.
-     */
-    Test.prototype.add_cleanup = function(callback) {
-        this._user_defined_cleanup_count += 1;
-        this._add_cleanup(callback);
-    };
-
-    Test.prototype.set_timeout = function()
-    {
-        if (this.timeout_length !== null) {
-            var this_obj = this;
-            this.timeout_id = setTimeout(function()
-                                         {
-                                             this_obj.timeout();
-                                         }, this.timeout_length);
-        }
-    };
-
-    Test.prototype.set_status = function(status, message, stack)
-    {
-        this.status = status;
-        this.message = message;
-        this.stack = stack ? stack : null;
-    };
-
-    Test.prototype.timeout = function()
-    {
-        this.timeout_id = null;
-        this.set_status(this.TIMEOUT, "Test timed out");
-        this.phase = this.phases.HAS_RESULT;
-        this.done();
-    };
-
-    Test.prototype.force_timeout = Test.prototype.timeout;
-
-    /**
-     * Update the test status, initiate "cleanup" functions, and signal test
-     * completion.
-     */
-    Test.prototype.done = function()
-    {
-        if (this.phase >= this.phases.CLEANING) {
-            return;
-        }
-
-        if (this.phase <= this.phases.STARTED) {
-            this.set_status(this.PASS, null);
-        }
-
-        if (global_scope.clearTimeout) {
-            clearTimeout(this.timeout_id);
-        }
-
-        this.cleanup();
-    };
-
-    function add_test_done_callback(test, callback)
-    {
-        if (test.phase === test.phases.COMPLETE) {
-            callback();
-            return;
-        }
-
-        test._done_callbacks.push(callback);
-    }
-
-    /*
-     * Invoke all specified cleanup functions. If one or more produce an error,
-     * the context is in an unpredictable state, so all further testing should
-     * be cancelled.
-     */
-    Test.prototype.cleanup = function() {
-        var error_count = 0;
-        var bad_value_count = 0;
-        function on_error() {
-            error_count += 1;
-            // Abort tests immediately so that tests declared within subsequent
-            // cleanup functions are not run.
-            tests.abort();
-        }
-        var this_obj = this;
-        var results = [];
-
-        this.phase = this.phases.CLEANING;
-
-        forEach(this.cleanup_callbacks,
-                function(cleanup_callback) {
-                    var result;
-
-                    try {
-                        result = cleanup_callback();
-                    } catch (e) {
-                        on_error();
-                        return;
-                    }
-
-                    if (!is_valid_cleanup_result(this_obj, result)) {
-                        bad_value_count += 1;
-                        // Abort tests immediately so that tests declared
-                        // within subsequent cleanup functions are not run.
-                        tests.abort();
-                    }
-
-                    results.push(result);
-                });
-
-        if (!this._is_promise_test) {
-            cleanup_done(this_obj, error_count, bad_value_count);
-        } else {
-            all_async(results,
-                      function(result, done) {
-                          if (result && typeof result.then === "function") {
-                              result
-                                  .then(null, on_error)
-                                  .then(done);
-                          } else {
-                              done();
-                          }
-                      },
-                      function() {
-                          cleanup_done(this_obj, error_count, bad_value_count);
-                      });
-        }
-    };
-
-    /**
-     * Determine if the return value of a cleanup function is valid for a given
-     * test. Any test may return the value `undefined`. Tests created with
-     * `promise_test` may alternatively return "thenable" object values.
-     */
-    function is_valid_cleanup_result(test, result) {
-        if (result === undefined) {
-            return true;
-        }
-
-        if (test._is_promise_test) {
-            return result && typeof result.then === "function";
-        }
-
-        return false;
-    }
-
-    function cleanup_done(test, error_count, bad_value_count) {
-        if (error_count || bad_value_count) {
-            var total = test._user_defined_cleanup_count;
-
-            tests.status.status = tests.status.ERROR;
-            tests.status.message = "Test named '" + test.name +
-                "' specified " + total +
-                " 'cleanup' function" + (total > 1 ? "s" : "");
-
-            if (error_count) {
-                tests.status.message += ", and " + error_count + " failed";
-            }
-
-            if (bad_value_count) {
-                var type = test._is_promise_test ?
-                   "non-thenable" : "non-undefined";
-                tests.status.message += ", and " + bad_value_count +
-                    " returned a " + type + " value";
-            }
-
-            tests.status.message += ".";
-
-            tests.status.stack = null;
-        }
-
-        test.phase = test.phases.COMPLETE;
-        tests.result(test);
-        forEach(test._done_callbacks,
-                function(callback) {
-                    callback();
-                });
-        test._done_callbacks.length = 0;
+        // Test authors may use the `step` method within a
+        // `promise_test` even though this reflects a mixture of
+        // asynchronous control flow paradigms. The "done" callback
+        // should be registered prior to the resolution of the
+        // user-provided Promise to avoid timeouts in cases where the
+        // Promise does not settle but a `step` function has thrown an
+        // error.
+        add_test_done_callback(test, resolve);
+
+        Promise.resolve(promise)
+          .catch(
+            test.step_func(function(value) {
+              if (value instanceof AssertionError) {
+                throw value;
+              }
+              assert(
+                false,
+                'promise_test',
+                null,
+                'Unhandled rejection with value: ${value}',
+                { value: value }
+              );
+            })
+          )
+          .then(function() {
+            test.done();
+          });
+      });
+    });
+  }
+
+  function promise_rejects(test, expected, promise, description) {
+    return promise
+      .then(test.unreached_func('Should have rejected: ' + description))
+      .catch(function(e) {
+        assert_throws(
+          expected,
+          function() {
+            throw e;
+          },
+          description
+        );
+      });
+  }
+
+  /**
+   * This constructor helper allows DOM events to be handled using Promises,
+   * which can make it a lot easier to test a very specific series of events,
+   * including ensuring that unexpected events are not fired at any point.
+   */
+  function EventWatcher(test, watchedNode, eventTypes) {
+    if (typeof eventTypes == 'string') {
+      eventTypes = [eventTypes];
+    }
+
+    var waitingFor = null;
+
+    // This is null unless we are recording all events, in which case it
+    // will be an Array object.
+    var recordedEvents = null;
+
+    var eventHandler = test.step_func(function(evt) {
+      assert_true(
+        !!waitingFor,
+        'Not expecting event, but got ' + evt.type + ' event'
+      );
+      assert_equals(
+        evt.type,
+        waitingFor.types[0],
+        'Expected ' +
+          waitingFor.types[0] +
+          ' event, but got ' +
+          evt.type +
+          ' event instead'
+      );
+
+      if (Array.isArray(recordedEvents)) {
+        recordedEvents.push(evt);
+      }
+
+      if (waitingFor.types.length > 1) {
+        // Pop first event from array
+        waitingFor.types.shift();
+        return;
+      }
+      // We need to null out waitingFor before calling the resolve function
+      // since the Promise's resolve handlers may call wait_for() which will
+      // need to set waitingFor.
+      var resolveFunc = waitingFor.resolve;
+      waitingFor = null;
+      // Likewise, we should reset the state of recordedEvents.
+      var result = recordedEvents || evt;
+      recordedEvents = null;
+      resolveFunc(result);
+    });
+
+    for (var i = 0; i < eventTypes.length; i++) {
+      watchedNode.addEventListener(eventTypes[i], eventHandler, false);
     }
 
-    /*
-     * A RemoteTest object mirrors a Test object on a remote worker. The
-     * associated RemoteWorker updates the RemoteTest object in response to
-     * received events. In turn, the RemoteTest object replicates these events
-     * on the local document. This allows listeners (test result reporting
-     * etc..) to transparently handle local and remote events.
-     */
-    function RemoteTest(clone) {
-        var this_obj = this;
-        Object.keys(clone).forEach(
-                function(key) {
-                    this_obj[key] = clone[key];
-                });
-        this.index = null;
-        this.phase = this.phases.INITIAL;
-        this.update_state_from(clone);
-        this._done_callbacks = [];
-        tests.push(this);
-    }
-
-    RemoteTest.prototype.structured_clone = function() {
-        var clone = {};
-        Object.keys(this).forEach(
-                (function(key) {
-                    var value = this[key];
-                    // `RemoteTest` instances are responsible for managing
-                    // their own "done" callback functions, so those functions
-                    // are not relevant in other execution contexts. Because of
-                    // this (and because Function values cannot be serialized
-                    // for cross-realm transmittance), the property should not
-                    // be considered when cloning instances.
-                    if (key === '_done_callbacks' ) {
-                        return;
-                    }
-
-                    if (typeof value === "object" && value !== null) {
-                        clone[key] = merge({}, value);
-                    } else {
-                        clone[key] = value;
-                    }
-                }).bind(this));
-        clone.phases = merge({}, this.phases);
-        return clone;
-    };
-
     /**
-     * `RemoteTest` instances are objects which represent tests running in
-     * another realm. They do not define "cleanup" functions (if necessary,
-     * such functions are defined on the associated `Test` instance within the
-     * external realm). However, `RemoteTests` may have "done" callbacks (e.g.
-     * as attached by the `Tests` instance responsible for tracking the overall
-     * test status in the parent realm). The `cleanup` method delegates to
-     * `done` in order to ensure that such callbacks are invoked following the
-     * completion of the `RemoteTest`.
-     */
-    RemoteTest.prototype.cleanup = function() {
-        this.done();
-    };
-    RemoteTest.prototype.phases = Test.prototype.phases;
-    RemoteTest.prototype.update_state_from = function(clone) {
-        this.status = clone.status;
-        this.message = clone.message;
-        this.stack = clone.stack;
-        if (this.phase === this.phases.INITIAL) {
-            this.phase = this.phases.STARTED;
-        }
-    };
-    RemoteTest.prototype.done = function() {
-        this.phase = this.phases.COMPLETE;
-
-        forEach(this._done_callbacks,
-                function(callback) {
-                    callback();
-                });
-    }
-
-    /*
-     * A RemoteContext listens for test events from a remote test context, such
-     * as another window or a worker. These events are then used to construct
-     * and maintain RemoteTest objects that mirror the tests running in the
-     * remote context.
+     * Returns a Promise that will resolve after the specified event or
+     * series of events has occurred.
      *
-     * An optional third parameter can be used as a predicate to filter incoming
-     * MessageEvents.
-     */
-    function RemoteContext(remote, message_target, message_filter) {
-        this.running = true;
-        this.tests = new Array();
-
-        var this_obj = this;
-        // If remote context is cross origin assigning to onerror is not
-        // possible, so silently catch those errors.
-        try {
-          remote.onerror = function(error) { this_obj.remote_error(error); };
-        } catch (e) {
-          // Ignore.
-        }
-
-        // Keeping a reference to the remote object and the message handler until
-        // remote_done() is seen prevents the remote object and its message channel
-        // from going away before all the messages are dispatched.
-        this.remote = remote;
-        this.message_target = message_target;
-        this.message_handler = function(message) {
-            var passesFilter = !message_filter || message_filter(message);
-            // The reference to the `running` property in the following
-            // condition is unnecessary because that value is only set to
-            // `false` after the `message_handler` function has been
-            // unsubscribed.
-            // TODO: Simplify the condition by removing the reference.
-            if (this_obj.running && message.data && passesFilter &&
-                (message.data.type in this_obj.message_handlers)) {
-                this_obj.message_handlers[message.data.type].call(this_obj, message.data);
-            }
-        };
-
-        if (self.Promise) {
-            this.done = new Promise(function(resolve) {
-                this_obj.doneResolve = resolve;
-            });
-        }
-
-        this.message_target.addEventListener("message", this.message_handler);
-    }
-
-    RemoteContext.prototype.remote_error = function(error) {
-        var message = error.message || String(error);
-        var filename = (error.filename ? " " + error.filename: "");
-        // FIXME: Display remote error states separately from main document
-        // error state.
-        tests.set_status(tests.status.ERROR,
-                         "Error in remote" + filename + ": " + message,
-                         error.stack);
-
-        if (error.preventDefault) {
-            error.preventDefault();
-        }
-    };
-
-    RemoteContext.prototype.test_state = function(data) {
-        var remote_test = this.tests[data.test.index];
-        if (!remote_test) {
-            remote_test = new RemoteTest(data.test);
-            this.tests[data.test.index] = remote_test;
-        }
-        remote_test.update_state_from(data.test);
-        tests.notify_test_state(remote_test);
-    };
-
-    RemoteContext.prototype.test_done = function(data) {
-        var remote_test = this.tests[data.test.index];
-        remote_test.update_state_from(data.test);
-        remote_test.done();
-        tests.result(remote_test);
-    };
-
-    RemoteContext.prototype.remote_done = function(data) {
-        if (tests.status.status === null &&
-            data.status.status !== data.status.OK) {
-            tests.set_status(data.status.status, data.status.message, data.status.sack);
-        }
-
-        this.message_target.removeEventListener("message", this.message_handler);
-        this.running = false;
-
-        // If remote context is cross origin assigning to onerror is not
-        // possible, so silently catch those errors.
-        try {
-          this.remote.onerror = null;
-        } catch (e) {
-          // Ignore.
-        }
-
-        this.remote = null;
-        this.message_target = null;
-        if (this.doneResolve) {
-            this.doneResolve();
-        }
-
-        if (tests.all_done()) {
-            tests.complete();
-        }
-    };
-
-    RemoteContext.prototype.message_handlers = {
-        test_state: RemoteContext.prototype.test_state,
-        result: RemoteContext.prototype.test_done,
-        complete: RemoteContext.prototype.remote_done
-    };
-
-    /*
-     * Harness
+     * @param options An optional options object. If the 'record' property
+     *                on this object has the value 'all', when the Promise
+     *                returned by this function is resolved,  *all* Event
+     *                objects that were waited for will be returned as an
+     *                array.
+     *
+     * For example,
+     *
+     * ```js
+     * const watcher = new EventWatcher(t, div, [ 'animationstart',
+     *                                            'animationiteration',
+     *                                            'animationend' ]);
+     * return watcher.wait_for([ 'animationstart', 'animationend' ],
+     *                         { record: 'all' }).then(evts => {
+     *   assert_equals(evts[0].elapsedTime, 0.0);
+     *   assert_equals(evts[1].elapsedTime, 2.0);
+     * });
+     * ```
      */
-
-    function TestsStatus()
-    {
-        this.status = null;
-        this.message = null;
-        this.stack = null;
-    }
-
-    TestsStatus.statuses = {
-        OK:0,
-        ERROR:1,
-        TIMEOUT:2
-    };
-
-    TestsStatus.prototype = merge({}, TestsStatus.statuses);
-
-    TestsStatus.prototype.structured_clone = function()
-    {
-        if (!this._structured_clone) {
-            var msg = this.message;
-            msg = msg ? String(msg) : msg;
-            this._structured_clone = merge({
-                status:this.status,
-                message:msg,
-                stack:this.stack
-            }, TestsStatus.statuses);
-        }
-        return this._structured_clone;
-    };
-
-    function Tests()
-    {
-        this.tests = [];
-        this.num_pending = 0;
-
-        this.phases = {
-            INITIAL:0,
-            SETUP:1,
-            HAVE_TESTS:2,
-            HAVE_RESULTS:3,
-            COMPLETE:4
-        };
-        this.phase = this.phases.INITIAL;
-
-        this.properties = {};
-
-        this.wait_for_finish = false;
-        this.processing_callbacks = false;
-
-        this.allow_uncaught_exception = false;
-
-        this.file_is_test = false;
-
-        this.timeout_multiplier = 1;
-        this.timeout_length = test_environment.test_timeout();
-        this.timeout_id = null;
-
-        this.start_callbacks = [];
-        this.test_state_callbacks = [];
-        this.test_done_callbacks = [];
-        this.all_done_callbacks = [];
-
-        this.pending_remotes = [];
-
-        this.status = new TestsStatus();
-
-        var this_obj = this;
-
-        test_environment.add_on_loaded_callback(function() {
-            if (this_obj.all_done()) {
-                this_obj.complete();
-            }
-        });
-
-        this.set_timeout();
-    }
-
-    Tests.prototype.setup = function(func, properties)
-    {
-        if (this.phase >= this.phases.HAVE_RESULTS) {
-            return;
-        }
-
-        if (this.phase < this.phases.SETUP) {
-            this.phase = this.phases.SETUP;
-        }
-
-        this.properties = properties;
-
-        for (var p in properties) {
-            if (properties.hasOwnProperty(p)) {
-                var value = properties[p];
-                if (p == "allow_uncaught_exception") {
-                    this.allow_uncaught_exception = value;
-                } else if (p == "explicit_done" && value) {
-                    this.wait_for_finish = true;
-                } else if (p == "explicit_timeout" && value) {
-                    this.timeout_length = null;
-                    if (this.timeout_id)
-                    {
-                        clearTimeout(this.timeout_id);
-                    }
-                } else if (p == "timeout_multiplier") {
-                    this.timeout_multiplier = value;
-                }
-            }
-        }
-
-        if (func) {
-            try {
-                func();
-            } catch (e) {
-                this.status.status = this.status.ERROR;
-                this.status.message = String(e);
-                this.status.stack = e.stack ? e.stack : null;
-            }
-        }
-        this.set_timeout();
-    };
-
-    Tests.prototype.set_file_is_test = function() {
-        if (this.tests.length > 0) {
-            throw new Error("Tried to set file as test after creating a test");
-        }
-        this.wait_for_finish = true;
-        this.file_is_test = true;
-        // Create the test, which will add it to the list of tests
-        async_test();
-    };
-
-    Tests.prototype.set_status = function(status, message, stack)
-    {
-        this.status.status = status;
-        this.status.message = message;
-        this.status.stack = stack ? stack : null;
-    };
-
-    Tests.prototype.set_timeout = function() {
-        if (global_scope.clearTimeout) {
-            var this_obj = this;
-            clearTimeout(this.timeout_id);
-            if (this.timeout_length !== null) {
-                this.timeout_id = setTimeout(function() {
-                                                 this_obj.timeout();
-                                             }, this.timeout_length);
-            }
-        }
-    };
-
-    Tests.prototype.timeout = function() {
-        var test_in_cleanup = null;
-
-        if (this.status.status === null) {
-            forEach(this.tests,
-                    function(test) {
-                        // No more than one test is expected to be in the
-                        // "CLEANUP" phase at any time
-                        if (test.phase === test.phases.CLEANING) {
-                            test_in_cleanup = test;
-                        }
-
-                        test.phase = test.phases.COMPLETE;
-                    });
-
-            // Timeouts that occur while a test is in the "cleanup" phase
-            // indicate that some global state was not properly reverted. This
-            // invalidates the overall test execution, so the timeout should be
-            // reported as an error and cancel the execution of any remaining
-            // tests.
-            if (test_in_cleanup) {
-                this.status.status = this.status.ERROR;
-                this.status.message = "Timeout while running cleanup for " +
-                    "test named \"" + test_in_cleanup.name + "\".";
-                tests.status.stack = null;
-            } else {
-                this.status.status = this.status.TIMEOUT;
-            }
-        }
-
-        this.complete();
-    };
-
-    Tests.prototype.end_wait = function()
-    {
-        this.wait_for_finish = false;
-        if (this.all_done()) {
-            this.complete();
-        }
-    };
-
-    Tests.prototype.push = function(test)
-    {
-        if (this.phase < this.phases.HAVE_TESTS) {
-            this.start();
-        }
-        this.num_pending++;
-        test.index = this.tests.push(test);
-        this.notify_test_state(test);
-    };
-
-    Tests.prototype.notify_test_state = function(test) {
-        var this_obj = this;
-        forEach(this.test_state_callbacks,
-                function(callback) {
-                    callback(test, this_obj);
-                });
-    };
-
-    Tests.prototype.all_done = function() {
-        return this.tests.length > 0 && test_environment.all_loaded &&
-                (this.num_pending === 0 || this.is_aborted) && !this.wait_for_finish &&
-                !this.processing_callbacks &&
-                !this.pending_remotes.some(function(w) { return w.running; });
-    };
-
-    Tests.prototype.start = function() {
-        this.phase = this.phases.HAVE_TESTS;
-        this.notify_start();
-    };
-
-    Tests.prototype.notify_start = function() {
-        var this_obj = this;
-        forEach (this.start_callbacks,
-                 function(callback)
-                 {
-                     callback(this_obj.properties);
-                 });
-    };
-
-    Tests.prototype.result = function(test)
-    {
-        // If the harness has already transitioned beyond the `HAVE_RESULTS`
-        // phase, subsequent tests should not cause it to revert.
-        if (this.phase <= this.phases.HAVE_RESULTS) {
-            this.phase = this.phases.HAVE_RESULTS;
-        }
-        this.num_pending--;
-        this.notify_result(test);
-    };
-
-    Tests.prototype.notify_result = function(test) {
-        var this_obj = this;
-        this.processing_callbacks = true;
-        forEach(this.test_done_callbacks,
-                function(callback)
-                {
-                    callback(test, this_obj);
-                });
-        this.processing_callbacks = false;
-        if (this_obj.all_done()) {
-            this_obj.complete();
-        }
-    };
-
-    Tests.prototype.complete = function() {
-        if (this.phase === this.phases.COMPLETE) {
-            return;
-        }
-        var this_obj = this;
-        var all_complete = function() {
-            this_obj.phase = this_obj.phases.COMPLETE;
-            this_obj.notify_complete();
+    this.wait_for = function(types, options) {
+      if (waitingFor) {
+        return Promise.reject('Already waiting for an event or events');
+      }
+      if (typeof types == 'string') {
+        types = [types];
+      }
+      if (options && options.record && options.record === 'all') {
+        recordedEvents = [];
+      }
+      return new Promise(function(resolve, reject) {
+        waitingFor = {
+          types: types,
+          resolve: resolve,
+          reject: reject
         };
-        var incomplete = filter(this.tests,
-                                function(test) {
-                                    return test.phase < test.phases.COMPLETE;
-                                });
-
-        /**
-         * To preserve legacy behavior, overall test completion must be
-         * signaled synchronously.
-         */
-        if (incomplete.length === 0) {
-            all_complete();
-            return;
-        }
-
-        all_async(incomplete,
-                  function(test, testDone)
-                  {
-                      if (test.phase === test.phases.INITIAL) {
-                          test.phase = test.phases.COMPLETE;
-                          testDone();
-                      } else {
-                          add_test_done_callback(test, testDone);
-                          test.cleanup();
-                      }
-                  },
-                  all_complete);
-    };
-
-    /**
-     * Update the harness status to reflect an unrecoverable harness error that
-     * should cancel all further testing. Update all previously-defined tests
-     * which have not yet started to indicate that they will not be executed.
+      });
+    };
+
+    function stop_watching() {
+      for (var i = 0; i < eventTypes.length; i++) {
+        watchedNode.removeEventListener(eventTypes[i], eventHandler, false);
+      }
+    }
+
+    test._add_cleanup(stop_watching);
+
+    return this;
+  }
+  expose(EventWatcher, 'EventWatcher');
+
+  function setup(func_or_properties, maybe_properties) {
+    var func = null;
+    var properties = {};
+    if (arguments.length === 2) {
+      func = func_or_properties;
+      properties = maybe_properties;
+    } else if (func_or_properties instanceof Function) {
+      func = func_or_properties;
+    } else {
+      properties = func_or_properties;
+    }
+    tests.setup(func, properties);
+    test_environment.on_new_harness_properties(properties);
+  }
+
+  function done() {
+    if (tests.tests.length === 0) {
+      tests.set_file_is_test();
+    }
+    if (tests.file_is_test) {
+      // file is test files never have asynchronous cleanup logic,
+      // meaning the fully-synchronous `done` function can be used here.
+      tests.tests[0].done();
+    }
+    tests.end_wait();
+  }
+
+  function generate_tests(func, args, properties) {
+    forEach(args, function(x, i) {
+      var name = x[0];
+      test(
+        function() {
+          func.apply(this, x.slice(1));
+        },
+        name,
+        Array.isArray(properties) ? properties[i] : properties
+      );
+    });
+  }
+
+  function on_event(object, event, callback) {
+    object.addEventListener(event, callback, false);
+  }
+
+  function step_timeout(f, t) {
+    var outer_this = this;
+    var args = Array.prototype.slice.call(arguments, 2);
+    return setTimeout(function() {
+      f.apply(outer_this, args);
+    }, t * tests.timeout_multiplier);
+  }
+
+  expose(test, 'test');
+  expose(async_test, 'async_test');
+  expose(promise_test, 'promise_test');
+  expose(promise_rejects, 'promise_rejects');
+  expose(generate_tests, 'generate_tests');
+  expose(setup, 'setup');
+  expose(done, 'done');
+  expose(on_event, 'on_event');
+  expose(step_timeout, 'step_timeout');
+
+  /*
+   * Return a string truncated to the given length, with ... added at the end
+   * if it was longer.
+   */
+  function truncate(s, len) {
+    if (s.length > len) {
+      return s.substring(0, len - 3) + '...';
+    }
+    return s;
+  }
+
+  /*
+   * Return true if object is probably a Node object.
+   */
+  function is_node(object) {
+    // I use duck-typing instead of instanceof, because
+    // instanceof doesn't work if the node is from another window (like an
+    // iframe's contentWindow):
+    // http://www.w3.org/Bugs/Public/show_bug.cgi?id=12295
+    try {
+      var has_node_properties =
+        'nodeType' in object &&
+        'nodeName' in object &&
+        'nodeValue' in object &&
+        'childNodes' in object;
+    } catch (e) {
+      // We're probably cross-origin, which means we aren't a node
+      return false;
+    }
+
+    if (has_node_properties) {
+      try {
+        object.nodeType;
+      } catch (e) {
+        // The object is probably Node.prototype or another prototype
+        // object that inherits from it, and not a Node instance.
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  var replacements = {
+    '0': '0',
+    '1': 'x01',
+    '2': 'x02',
+    '3': 'x03',
+    '4': 'x04',
+    '5': 'x05',
+    '6': 'x06',
+    '7': 'x07',
+    '8': 'b',
+    '9': 't',
+    '10': 'n',
+    '11': 'v',
+    '12': 'f',
+    '13': 'r',
+    '14': 'x0e',
+    '15': 'x0f',
+    '16': 'x10',
+    '17': 'x11',
+    '18': 'x12',
+    '19': 'x13',
+    '20': 'x14',
+    '21': 'x15',
+    '22': 'x16',
+    '23': 'x17',
+    '24': 'x18',
+    '25': 'x19',
+    '26': 'x1a',
+    '27': 'x1b',
+    '28': 'x1c',
+    '29': 'x1d',
+    '30': 'x1e',
+    '31': 'x1f',
+    '0xfffd': 'ufffd',
+    '0xfffe': 'ufffe',
+    '0xffff': 'uffff'
+  };
+
+  /*
+   * Convert a value to a nice, human-readable string
+   */
+  function format_value(val, seen) {
+    if (!seen) {
+      seen = [];
+    }
+    if (typeof val === 'object' && val !== null) {
+      if (seen.indexOf(val) >= 0) {
+        return '[...]';
+      }
+      seen.push(val);
+    }
+    if (Array.isArray(val)) {
+      return (
+        '[' +
+        val
+          .map(function(x) {
+            return format_value(x, seen);
+          })
+          .join(', ') +
+        ']'
+      );
+    }
+
+    switch (typeof val) {
+      case 'string':
+        val = val.replace('\\', '\\\\');
+        for (var p in replacements) {
+          var replace = '\\' + replacements[p];
+          val = val.replace(RegExp(String.fromCharCode(p), 'g'), replace);
+        }
+        return '"' + val.replace(/"/g, '\\"') + '"';
+      case 'boolean':
+      case 'undefined':
+        return String(val);
+      case 'number':
+        // In JavaScript, -0 === 0 and String(-0) == "0", so we have to
+        // special-case.
+        if (val === -0 && 1 / val === -Infinity) {
+          return '-0';
+        }
+        return String(val);
+      case 'object':
+        if (val === null) {
+          return 'null';
+        }
+
+        // Special-case Node objects, since those come up a lot in my tests.  I
+        // ignore namespaces.
+        if (is_node(val)) {
+          switch (val.nodeType) {
+            case Node.ELEMENT_NODE:
+              var ret = '<' + val.localName;
+              for (var i = 0; i < val.attributes.length; i++) {
+                ret +=
+                  ' ' +
+                  val.attributes[i].name +
+                  '="' +
+                  val.attributes[i].value +
+                  '"';
+              }
+              ret += '>' + val.innerHTML + '</' + val.localName + '>';
+              return 'Element node ' + truncate(ret, 60);
+            case Node.TEXT_NODE:
+              return 'Text node "' + truncate(val.data, 60) + '"';
+            case Node.PROCESSING_INSTRUCTION_NODE:
+              return (
+                'ProcessingInstruction node with target ' +
+                format_value(truncate(val.target, 60)) +
+                ' and data ' +
+                format_value(truncate(val.data, 60))
+              );
+            case Node.COMMENT_NODE:
+              return 'Comment node <!--' + truncate(val.data, 60) + '-->';
+            case Node.DOCUMENT_NODE:
+              return (
+                'Document node with ' +
+                val.childNodes.length +
+                (val.childNodes.length == 1 ? ' child' : ' children')
+              );
+            case Node.DOCUMENT_TYPE_NODE:
+              return 'DocumentType node';
+            case Node.DOCUMENT_FRAGMENT_NODE:
+              return (
+                'DocumentFragment node with ' +
+                val.childNodes.length +
+                (val.childNodes.length == 1 ? ' child' : ' children')
+              );
+            default:
+              return 'Node object of unknown type';
+          }
+        }
+
+      /* falls through */
+      default:
+        try {
+          return typeof val + ' "' + truncate(String(val), 1000) + '"';
+        } catch (e) {
+          return (
+            '[stringifying object threw ' +
+            String(e) +
+            ' with type ' +
+            String(typeof e) +
+            ']'
+          );
+        }
+    }
+  }
+  expose(format_value, 'format_value');
+
+  /*
+   * Assertions
+   */
+
+  function assert_true(actual, description) {
+    assert(
+      actual === true,
+      'assert_true',
+      description,
+      'expected true got ${actual}',
+      { actual: actual }
+    );
+  }
+  expose(assert_true, 'assert_true');
+
+  function assert_false(actual, description) {
+    assert(
+      actual === false,
+      'assert_false',
+      description,
+      'expected false got ${actual}',
+      { actual: actual }
+    );
+  }
+  expose(assert_false, 'assert_false');
+
+  function same_value(x, y) {
+    if (y !== y) {
+      //NaN case
+      return x !== x;
+    }
+    if (x === 0 && y === 0) {
+      //Distinguish +0 and -0
+      return 1 / x === 1 / y;
+    }
+    return x === y;
+  }
+
+  function assert_equals(actual, expected, description) {
+    /*
+     * Test if two primitives are equal or two objects
+     * are the same object
      */
-    Tests.prototype.abort = function() {
-        this.status.status = this.status.ERROR;
-        this.is_aborted = true;
-
-        forEach(this.tests,
-                function(test) {
-                    if (test.phase === test.phases.INITIAL) {
-                        test.phase = test.phases.COMPLETE;
-                    }
-                });
-    };
-
+    if (typeof actual != typeof expected) {
+      assert(
+        false,
+        'assert_equals',
+        description,
+        'expected (' +
+          typeof expected +
+          ') ${expected} but got (' +
+          typeof actual +
+          ') ${actual}',
+        { expected: expected, actual: actual }
+      );
+      return;
+    }
+    assert(
+      same_value(actual, expected),
+      'assert_equals',
+      description,
+      'expected ${expected} but got ${actual}',
+      { expected: expected, actual: actual }
+    );
+  }
+  expose(assert_equals, 'assert_equals');
+
+  function assert_not_equals(actual, expected, description) {
     /*
-     * Determine if any tests share the same `name` property. Return an array
-     * containing the names of any such duplicates.
+     * Test if two primitives are unequal or two objects
+     * are different objects
      */
-    Tests.prototype.find_duplicates = function() {
-        var names = Object.create(null);
-        var duplicates = [];
-
-        forEach (this.tests,
-                 function(test)
-                 {
-                     if (test.name in names && duplicates.indexOf(test.name) === -1) {
-                        duplicates.push(test.name);
-                     }
-                     names[test.name] = true;
-                 });
-
-        return duplicates;
-    };
-
-    Tests.prototype.notify_complete = function() {
-        var this_obj = this;
-        var duplicates;
-
-        if (this.status.status === null) {
-            duplicates = this.find_duplicates();
-
-            // Test names are presumed to be unique within test files--this
-            // allows consumers to use them for identification purposes.
-            // Duplicated names violate this expectation and should therefore
-            // be reported as an error.
-            if (duplicates.length) {
-                this.status.status = this.status.ERROR;
-                this.status.message =
-                   duplicates.length + ' duplicate test name' +
-                   (duplicates.length > 1 ? 's' : '') + ': "' +
-                   duplicates.join('", "') + '"';
-            } else {
-                this.status.status = this.status.OK;
-            }
-        }
-
-        forEach (this.all_done_callbacks,
-                 function(callback)
-                 {
-                     callback(this_obj.tests, this_obj.status);
-                 });
-    };
+    assert(
+      !same_value(actual, expected),
+      'assert_not_equals',
+      description,
+      'got disallowed value ${actual}',
+      { actual: actual }
+    );
+  }
+  expose(assert_not_equals, 'assert_not_equals');
+
+  function assert_in_array(actual, expected, description) {
+    assert(
+      expected.indexOf(actual) != -1,
+      'assert_in_array',
+      description,
+      'value ${actual} not in array ${expected}',
+      { actual: actual, expected: expected }
+    );
+  }
+  expose(assert_in_array, 'assert_in_array');
+
+  function assert_object_equals(actual, expected, description) {
+    assert(
+      typeof actual === 'object' && actual !== null,
+      'assert_object_equals',
+      description,
+      'value is ${actual}, expected object',
+      { actual: actual }
+    );
+    //This needs to be improved a great deal
+    function check_equal(actual, expected, stack) {
+      stack.push(actual);
+
+      var p;
+      for (p in actual) {
+        assert(
+          expected.hasOwnProperty(p),
+          'assert_object_equals',
+          description,
+          'unexpected property ${p}',
+          { p: p }
+        );
 
+        if (typeof actual[p] === 'object' && actual[p] !== null) {
+          if (stack.indexOf(actual[p]) === -1) {
+            check_equal(actual[p], expected[p], stack);
+          }
+        } else {
+          assert(
+            same_value(actual[p], expected[p]),
+            'assert_object_equals',
+            description,
+            'property ${p} expected ${expected} got ${actual}',
+            { p: p, expected: expected, actual: actual }
+          );
+        }
+      }
+      for (p in expected) {
+        assert(
+          actual.hasOwnProperty(p),
+          'assert_object_equals',
+          description,
+          'expected property ${p} missing',
+          { p: p }
+        );
+      }
+      stack.pop();
+    }
+    check_equal(actual, expected, []);
+  }
+  expose(assert_object_equals, 'assert_object_equals');
+
+  function assert_array_equals(actual, expected, description) {
+    assert(
+      typeof actual === 'object' && actual !== null && 'length' in actual,
+      'assert_array_equals',
+      description,
+      'value is ${actual}, expected array',
+      { actual: actual }
+    );
+    assert(
+      actual.length === expected.length,
+      'assert_array_equals',
+      description,
+      'lengths differ, expected ${expected} got ${actual}',
+      { expected: expected.length, actual: actual.length }
+    );
+
+    for (var i = 0; i < actual.length; i++) {
+      assert(
+        actual.hasOwnProperty(i) === expected.hasOwnProperty(i),
+        'assert_array_equals',
+        description,
+        'property ${i}, property expected to be ${expected} but was ${actual}',
+        {
+          i: i,
+          expected: expected.hasOwnProperty(i) ? 'present' : 'missing',
+          actual: actual.hasOwnProperty(i) ? 'present' : 'missing'
+        }
+      );
+      assert(
+        same_value(expected[i], actual[i]),
+        'assert_array_equals',
+        description,
+        'property ${i}, expected ${expected} but got ${actual}',
+        { i: i, expected: expected[i], actual: actual[i] }
+      );
+    }
+  }
+  expose(assert_array_equals, 'assert_array_equals');
+
+  function assert_array_approx_equals(actual, expected, epsilon, description) {
     /*
-     * Constructs a RemoteContext that tracks tests from a specific worker.
+     * Test if two primitive arrays are equal within +/- epsilon
      */
-    Tests.prototype.create_remote_worker = function(worker) {
-        var message_port;
-
-        if (is_service_worker(worker)) {
-            if (window.MessageChannel) {
-                // The ServiceWorker's implicit MessagePort is currently not
-                // reliably accessible from the ServiceWorkerGlobalScope due to
-                // Blink setting MessageEvent.source to null for messages sent
-                // via ServiceWorker.postMessage(). Until that's resolved,
-                // create an explicit MessageChannel and pass one end to the
-                // worker.
-                var message_channel = new MessageChannel();
-                message_port = message_channel.port1;
-                message_port.start();
-                worker.postMessage({type: "connect"}, [message_channel.port2]);
-            } else {
-                // If MessageChannel is not available, then try the
-                // ServiceWorker.postMessage() approach using MessageEvent.source
-                // on the other end.
-                message_port = navigator.serviceWorker;
-                worker.postMessage({type: "connect"});
-            }
-        } else if (is_shared_worker(worker)) {
-            message_port = worker.port;
-            message_port.start();
-        } else {
-            message_port = worker;
-        }
-
-        return new RemoteContext(worker, message_port);
-    };
-
+    assert(
+      actual.length === expected.length,
+      'assert_array_approx_equals',
+      description,
+      'lengths differ, expected ${expected} got ${actual}',
+      { expected: expected.length, actual: actual.length }
+    );
+
+    for (var i = 0; i < actual.length; i++) {
+      assert(
+        actual.hasOwnProperty(i) === expected.hasOwnProperty(i),
+        'assert_array_approx_equals',
+        description,
+        'property ${i}, property expected to be ${expected} but was ${actual}',
+        {
+          i: i,
+          expected: expected.hasOwnProperty(i) ? 'present' : 'missing',
+          actual: actual.hasOwnProperty(i) ? 'present' : 'missing'
+        }
+      );
+      assert(
+        typeof actual[i] === 'number',
+        'assert_array_approx_equals',
+        description,
+        'property ${i}, expected a number but got a ${type_actual}',
+        { i: i, type_actual: typeof actual[i] }
+      );
+      assert(
+        Math.abs(actual[i] - expected[i]) <= epsilon,
+        'assert_array_approx_equals',
+        description,
+        'property ${i}, expected ${expected} +/- ${epsilon}, expected ${expected} but got ${actual}',
+        { i: i, expected: expected[i], actual: actual[i] }
+      );
+    }
+  }
+  expose(assert_array_approx_equals, 'assert_array_approx_equals');
+
+  function assert_approx_equals(actual, expected, epsilon, description) {
     /*
-     * Constructs a RemoteContext that tracks tests from a specific window.
+     * Test if two primitive numbers are equal within +/- epsilon
      */
-    Tests.prototype.create_remote_window = function(remote) {
-        remote.postMessage({type: "getmessages"}, "*");
-        return new RemoteContext(
-            remote,
-            window,
-            function(msg) {
-                return msg.source === remote;
-            }
+    assert(
+      typeof actual === 'number',
+      'assert_approx_equals',
+      description,
+      'expected a number but got a ${type_actual}',
+      { type_actual: typeof actual }
+    );
+
+    assert(
+      Math.abs(actual - expected) <= epsilon,
+      'assert_approx_equals',
+      description,
+      'expected ${expected} +/- ${epsilon} but got ${actual}',
+      { expected: expected, actual: actual, epsilon: epsilon }
+    );
+  }
+  expose(assert_approx_equals, 'assert_approx_equals');
+
+  function assert_less_than(actual, expected, description) {
+    /*
+     * Test if a primitive number is less than another
+     */
+    assert(
+      typeof actual === 'number',
+      'assert_less_than',
+      description,
+      'expected a number but got a ${type_actual}',
+      { type_actual: typeof actual }
+    );
+
+    assert(
+      actual < expected,
+      'assert_less_than',
+      description,
+      'expected a number less than ${expected} but got ${actual}',
+      { expected: expected, actual: actual }
+    );
+  }
+  expose(assert_less_than, 'assert_less_than');
+
+  function assert_greater_than(actual, expected, description) {
+    /*
+     * Test if a primitive number is greater than another
+     */
+    assert(
+      typeof actual === 'number',
+      'assert_greater_than',
+      description,
+      'expected a number but got a ${type_actual}',
+      { type_actual: typeof actual }
+    );
+
+    assert(
+      actual > expected,
+      'assert_greater_than',
+      description,
+      'expected a number greater than ${expected} but got ${actual}',
+      { expected: expected, actual: actual }
+    );
+  }
+  expose(assert_greater_than, 'assert_greater_than');
+
+  function assert_between_exclusive(actual, lower, upper, description) {
+    /*
+     * Test if a primitive number is between two others
+     */
+    assert(
+      typeof actual === 'number',
+      'assert_between_exclusive',
+      description,
+      'expected a number but got a ${type_actual}',
+      { type_actual: typeof actual }
+    );
+
+    assert(
+      actual > lower && actual < upper,
+      'assert_between_exclusive',
+      description,
+      'expected a number greater than ${lower} ' +
+        'and less than ${upper} but got ${actual}',
+      { lower: lower, upper: upper, actual: actual }
+    );
+  }
+  expose(assert_between_exclusive, 'assert_between_exclusive');
+
+  function assert_less_than_equal(actual, expected, description) {
+    /*
+     * Test if a primitive number is less than or equal to another
+     */
+    assert(
+      typeof actual === 'number',
+      'assert_less_than_equal',
+      description,
+      'expected a number but got a ${type_actual}',
+      { type_actual: typeof actual }
+    );
+
+    assert(
+      actual <= expected,
+      'assert_less_than_equal',
+      description,
+      'expected a number less than or equal to ${expected} but got ${actual}',
+      { expected: expected, actual: actual }
+    );
+  }
+  expose(assert_less_than_equal, 'assert_less_than_equal');
+
+  function assert_greater_than_equal(actual, expected, description) {
+    /*
+     * Test if a primitive number is greater than or equal to another
+     */
+    assert(
+      typeof actual === 'number',
+      'assert_greater_than_equal',
+      description,
+      'expected a number but got a ${type_actual}',
+      { type_actual: typeof actual }
+    );
+
+    assert(
+      actual >= expected,
+      'assert_greater_than_equal',
+      description,
+      'expected a number greater than or equal to ${expected} but got ${actual}',
+      { expected: expected, actual: actual }
+    );
+  }
+  expose(assert_greater_than_equal, 'assert_greater_than_equal');
+
+  function assert_between_inclusive(actual, lower, upper, description) {
+    /*
+     * Test if a primitive number is between to two others or equal to either of them
+     */
+    assert(
+      typeof actual === 'number',
+      'assert_between_inclusive',
+      description,
+      'expected a number but got a ${type_actual}',
+      { type_actual: typeof actual }
+    );
+
+    assert(
+      actual >= lower && actual <= upper,
+      'assert_between_inclusive',
+      description,
+      'expected a number greater than or equal to ${lower} ' +
+        'and less than or equal to ${upper} but got ${actual}',
+      { lower: lower, upper: upper, actual: actual }
+    );
+  }
+  expose(assert_between_inclusive, 'assert_between_inclusive');
+
+  function assert_regexp_match(actual, expected, description) {
+    /*
+     * Test if a string (actual) matches a regexp (expected)
+     */
+    assert(
+      expected.test(actual),
+      'assert_regexp_match',
+      description,
+      'expected ${expected} but got ${actual}',
+      { expected: expected, actual: actual }
+    );
+  }
+  expose(assert_regexp_match, 'assert_regexp_match');
+
+  function assert_class_string(object, class_string, description) {
+    assert_equals(
+      {}.toString.call(object),
+      '[object ' + class_string + ']',
+      description
+    );
+  }
+  expose(assert_class_string, 'assert_class_string');
+
+  function assert_own_property(object, property_name, description) {
+    assert(
+      object.hasOwnProperty(property_name),
+      'assert_own_property',
+      description,
+      'expected property ${p} missing',
+      { p: property_name }
+    );
+  }
+  expose(assert_own_property, 'assert_own_property');
+
+  function assert_not_own_property(object, property_name, description) {
+    assert(
+      !object.hasOwnProperty(property_name),
+      'assert_not_own_property',
+      description,
+      'unexpected property ${p} is found on object',
+      { p: property_name }
+    );
+  }
+  expose(assert_not_own_property, 'assert_not_own_property');
+
+  function _assert_inherits(name) {
+    return function(object, property_name, description) {
+      assert(
+        typeof object === 'object' || typeof object === 'function',
+        name,
+        description,
+        'provided value is not an object'
+      );
+
+      assert(
+        'hasOwnProperty' in object,
+        name,
+        description,
+        'provided value is an object but has no hasOwnProperty method'
+      );
+
+      assert(
+        !object.hasOwnProperty(property_name),
+        name,
+        description,
+        'property ${p} found on object expected in prototype chain',
+        { p: property_name }
+      );
+
+      assert(
+        property_name in object,
+        name,
+        description,
+        'property ${p} not found in prototype chain',
+        { p: property_name }
+      );
+    };
+  }
+  expose(_assert_inherits('assert_inherits'), 'assert_inherits');
+  expose(_assert_inherits('assert_idl_attribute'), 'assert_idl_attribute');
+
+  function assert_readonly(object, property_name, description) {
+    var initial_value = object[property_name];
+    try {
+      //Note that this can have side effects in the case where
+      //the property has PutForwards
+      object[property_name] = initial_value + 'a'; //XXX use some other value here?
+      assert(
+        same_value(object[property_name], initial_value),
+        'assert_readonly',
+        description,
+        'changing property ${p} succeeded',
+        { p: property_name }
+      );
+    } finally {
+      object[property_name] = initial_value;
+    }
+  }
+  expose(assert_readonly, 'assert_readonly');
+
+  /**
+   * Assert an Exception with the expected code is thrown.
+   *
+   * @param {object|number|string} code The expected exception code.
+   * @param {Function} func Function which should throw.
+   * @param {string} description Error description for the case that the error is not thrown.
+   */
+  function assert_throws(code, func, description) {
+    try {
+      func.call(this);
+      assert(false, 'assert_throws', description, '${func} did not throw', {
+        func: func
+      });
+    } catch (e) {
+      if (e instanceof AssertionError) {
+        throw e;
+      }
+
+      assert(
+        typeof e === 'object',
+        'assert_throws',
+        description,
+        '${func} threw ${e} with type ${type}, not an object',
+        { func: func, e: e, type: typeof e }
+      );
+
+      assert(
+        e !== null,
+        'assert_throws',
+        description,
+        '${func} threw null, not an object',
+        { func: func }
+      );
+
+      if (code === null) {
+        throw new AssertionError(
+          'Test bug: need to pass exception to assert_throws()'
         );
-    };
-
-    Tests.prototype.fetch_tests_from_worker = function(worker) {
-        if (this.phase >= this.phases.COMPLETE) {
-            return;
-        }
-
-        var remoteContext = this.create_remote_worker(worker);
-        this.pending_remotes.push(remoteContext);
-        return remoteContext.done;
-    };
-
-    function fetch_tests_from_worker(port) {
-        return tests.fetch_tests_from_worker(port);
-    }
-    expose(fetch_tests_from_worker, 'fetch_tests_from_worker');
-
-    Tests.prototype.fetch_tests_from_window = function(remote) {
-        if (this.phase >= this.phases.COMPLETE) {
-            return;
-        }
-
-        this.pending_remotes.push(this.create_remote_window(remote));
-    };
-
-    function fetch_tests_from_window(window) {
-        tests.fetch_tests_from_window(window);
+      }
+      if (typeof code === 'object') {
+        assert(
+          'name' in e && e.name == code.name,
+          'assert_throws',
+          description,
+          '${func} threw ${actual} (${actual_name}) expected ${expected} (${expected_name})',
+          {
+            func: func,
+            actual: e,
+            actual_name: e.name,
+            expected: code,
+            expected_name: code.name
+          }
+        );
+        return;
+      }
+
+      var code_name_map = {
+        INDEX_SIZE_ERR: 'IndexSizeError',
+        HIERARCHY_REQUEST_ERR: 'HierarchyRequestError',
+        WRONG_DOCUMENT_ERR: 'WrongDocumentError',
+        INVALID_CHARACTER_ERR: 'InvalidCharacterError',
+        NO_MODIFICATION_ALLOWED_ERR: 'NoModificationAllowedError',
+        NOT_FOUND_ERR: 'NotFoundError',
+        NOT_SUPPORTED_ERR: 'NotSupportedError',
+        INUSE_ATTRIBUTE_ERR: 'InUseAttributeError',
+        INVALID_STATE_ERR: 'InvalidStateError',
+        SYNTAX_ERR: 'SyntaxError',
+        INVALID_MODIFICATION_ERR: 'InvalidModificationError',
+        NAMESPACE_ERR: 'NamespaceError',
+        INVALID_ACCESS_ERR: 'InvalidAccessError',
+        TYPE_MISMATCH_ERR: 'TypeMismatchError',
+        SECURITY_ERR: 'SecurityError',
+        NETWORK_ERR: 'NetworkError',
+        ABORT_ERR: 'AbortError',
+        URL_MISMATCH_ERR: 'URLMismatchError',
+        QUOTA_EXCEEDED_ERR: 'QuotaExceededError',
+        TIMEOUT_ERR: 'TimeoutError',
+        INVALID_NODE_TYPE_ERR: 'InvalidNodeTypeError',
+        DATA_CLONE_ERR: 'DataCloneError'
+      };
+
+      var name = code in code_name_map ? code_name_map[code] : code;
+
+      var name_code_map = {
+        IndexSizeError: 1,
+        HierarchyRequestError: 3,
+        WrongDocumentError: 4,
+        InvalidCharacterError: 5,
+        NoModificationAllowedError: 7,
+        NotFoundError: 8,
+        NotSupportedError: 9,
+        InUseAttributeError: 10,
+        InvalidStateError: 11,
+        SyntaxError: 12,
+        InvalidModificationError: 13,
+        NamespaceError: 14,
+        InvalidAccessError: 15,
+        TypeMismatchError: 17,
+        SecurityError: 18,
+        NetworkError: 19,
+        AbortError: 20,
+        URLMismatchError: 21,
+        QuotaExceededError: 22,
+        TimeoutError: 23,
+        InvalidNodeTypeError: 24,
+        DataCloneError: 25,
+
+        EncodingError: 0,
+        NotReadableError: 0,
+        UnknownError: 0,
+        ConstraintError: 0,
+        DataError: 0,
+        TransactionInactiveError: 0,
+        ReadOnlyError: 0,
+        VersionError: 0,
+        OperationError: 0,
+        NotAllowedError: 0
+      };
+
+      if (!(name in name_code_map)) {
+        throw new AssertionError(
+          'Test bug: unrecognized DOMException code "' +
+            code +
+            '" passed to assert_throws()'
+        );
+      }
+
+      var required_props = { code: name_code_map[name] };
+
+      if (
+        required_props.code === 0 ||
+        ('name' in e &&
+          e.name !== e.name.toUpperCase() &&
+          e.name !== 'DOMException')
+      ) {
+        // New style exception: also test the name property.
+        required_props.name = name;
+      }
+
+      //We'd like to test that e instanceof the appropriate interface,
+      //but we can't, because we don't know what window it was created
+      //in.  It might be an instanceof the appropriate interface on some
+      //unknown other window.  TODO: Work around this somehow?
+
+      for (var prop in required_props) {
+        assert(
+          prop in e && e[prop] == required_props[prop],
+          'assert_throws',
+          description,
+          '${func} threw ${e} that is not a DOMException ' +
+            code +
+            ': property ${prop} is equal to ${actual}, expected ${expected}',
+          {
+            func: func,
+            e: e,
+            prop: prop,
+            actual: e[prop],
+            expected: required_props[prop]
+          }
+        );
+      }
+    }
+  }
+  expose(assert_throws, 'assert_throws');
+
+  function assert_unreached(description) {
+    assert(false, 'assert_unreached', description, 'Reached unreachable code');
+  }
+  expose(assert_unreached, 'assert_unreached');
+
+  function assert_any(assert_func, actual, expected_array) {
+    var args = [].slice.call(arguments, 3);
+    var errors = [];
+    var passed = false;
+    forEach(expected_array, function(expected) {
+      try {
+        assert_func.apply(this, [actual, expected].concat(args));
+        passed = true;
+      } catch (e) {
+        errors.push(e.message);
+      }
+    });
+    if (!passed) {
+      throw new AssertionError(errors.join('\n\n'));
+    }
+  }
+  expose(assert_any, 'assert_any');
+
+  function Test(name, properties) {
+    if (tests.file_is_test && tests.tests.length) {
+      throw new Error('Tried to create a test with file_is_test');
+    }
+    this.name = name;
+
+    this.phase = tests.is_aborted ? this.phases.COMPLETE : this.phases.INITIAL;
+
+    this.status = this.NOTRUN;
+    this.timeout_id = null;
+    this.index = null;
+
+    this.properties = properties;
+    var timeout = properties.timeout
+      ? properties.timeout
+      : settings.test_timeout;
+    if (timeout !== null) {
+      this.timeout_length = timeout * tests.timeout_multiplier;
+    } else {
+      this.timeout_length = null;
+    }
+
+    this.message = null;
+    this.stack = null;
+
+    this.steps = [];
+    this._is_promise_test = false;
+
+    this.cleanup_callbacks = [];
+    this._user_defined_cleanup_count = 0;
+    this._done_callbacks = [];
+
+    tests.push(this);
+  }
+
+  Test.statuses = {
+    PASS: 0,
+    FAIL: 1,
+    TIMEOUT: 2,
+    NOTRUN: 3
+  };
+
+  Test.prototype = merge({}, Test.statuses);
+
+  Test.prototype.phases = {
+    INITIAL: 0,
+    STARTED: 1,
+    HAS_RESULT: 2,
+    CLEANING: 3,
+    COMPLETE: 4
+  };
+
+  Test.prototype.structured_clone = function() {
+    if (!this._structured_clone) {
+      var msg = this.message;
+      msg = msg ? String(msg) : msg;
+      this._structured_clone = merge(
+        {
+          name: String(this.name),
+          properties: merge({}, this.properties),
+          phases: merge({}, this.phases)
+        },
+        Test.statuses
+      );
     }
-    expose(fetch_tests_from_window, 'fetch_tests_from_window');
+    this._structured_clone.status = this.status;
+    this._structured_clone.message = this.message;
+    this._structured_clone.stack = this.stack;
+    this._structured_clone.index = this.index;
+    this._structured_clone.phase = this.phase;
+    return this._structured_clone;
+  };
 
-    function timeout() {
-        if (tests.timeout_length === null) {
-            tests.timeout();
-        }
+  Test.prototype.step = function(func, this_obj) {
+    if (this.phase > this.phases.STARTED) {
+      return;
     }
-    expose(timeout, 'timeout');
+    this.phase = this.phases.STARTED;
+    //If we don't get a result before the harness times out that will be a test timeout
+    this.set_status(this.TIMEOUT, 'Test timed out');
 
-    function add_start_callback(callback) {
-        tests.start_callbacks.push(callback);
-    }
+    tests.started = true;
+    tests.notify_test_state(this);
 
-    function add_test_state_callback(callback) {
-        tests.test_state_callbacks.push(callback);
+    if (this.timeout_id === null) {
+      this.set_timeout();
     }
 
-    function add_result_callback(callback) {
-        tests.test_done_callbacks.push(callback);
-    }
+    this.steps.push(func);
 
-    function add_completion_callback(callback) {
-        tests.all_done_callbacks.push(callback);
+    if (arguments.length === 1) {
+      this_obj = this;
     }
 
-    expose(add_start_callback, 'add_start_callback');
-    expose(add_test_state_callback, 'add_test_state_callback');
-    expose(add_result_callback, 'add_result_callback');
-    expose(add_completion_callback, 'add_completion_callback');
-
-    function remove(array, item) {
-        var index = array.indexOf(item);
-        if (index > -1) {
-            array.splice(index, 1);
-        }
-    }
+    try {
+      return func.apply(this_obj, Array.prototype.slice.call(arguments, 2));
+    } catch (e) {
+      if (this.phase >= this.phases.HAS_RESULT) {
+        return;
+      }
+      var message = String(typeof e === 'object' && e !== null ? e.message : e);
+      var stack = e.stack ? e.stack : null;
 
-    function remove_start_callback(callback) {
-        remove(tests.start_callbacks, callback);
+      this.set_status(this.FAIL, message, stack);
+      this.phase = this.phases.HAS_RESULT;
+      this.done();
     }
+  };
 
-    function remove_test_state_callback(callback) {
-        remove(tests.test_state_callbacks, callback);
-    }
+  Test.prototype.step_func = function(func, this_obj) {
+    var test_this = this;
 
-    function remove_result_callback(callback) {
-        remove(tests.test_done_callbacks, callback);
+    if (arguments.length === 1) {
+      this_obj = test_this;
     }
 
-    function remove_completion_callback(callback) {
-       remove(tests.all_done_callbacks, callback);
-    }
+    return function() {
+      return test_this.step.apply(
+        test_this,
+        [func, this_obj].concat(Array.prototype.slice.call(arguments))
+      );
+    };
+  };
 
-    /*
-     * Output listener
-    */
+  Test.prototype.step_func_done = function(func, this_obj) {
+    var test_this = this;
 
-    function Output() {
-        this.output_document = document;
-        this.output_node = null;
-        this.enabled = settings.output;
-        this.phase = this.INITIAL;
+    if (arguments.length === 1) {
+      this_obj = test_this;
     }
 
-    Output.prototype.INITIAL = 0;
-    Output.prototype.STARTED = 1;
-    Output.prototype.HAVE_RESULTS = 2;
-    Output.prototype.COMPLETE = 3;
-
-    Output.prototype.setup = function(properties) {
-        if (this.phase > this.INITIAL) {
-            return;
-        }
-
-        //If output is disabled in testharnessreport.js the test shouldn't be
-        //able to override that
-        this.enabled = this.enabled && (properties.hasOwnProperty("output") ?
-                                        properties.output : settings.output);
-    };
-
-    Output.prototype.init = function(properties) {
-        if (this.phase >= this.STARTED) {
-            return;
-        }
-        if (properties.output_document) {
-            this.output_document = properties.output_document;
-        } else {
-            this.output_document = document;
-        }
-        this.phase = this.STARTED;
-    };
-
-    Output.prototype.resolve_log = function() {
-        var output_document;
-        if (typeof this.output_document === "function") {
-            output_document = this.output_document.apply(undefined);
+    return function() {
+      if (func) {
+        test_this.step.apply(
+          test_this,
+          [func, this_obj].concat(Array.prototype.slice.call(arguments))
+        );
+      }
+      test_this.done();
+    };
+  };
+
+  Test.prototype.unreached_func = function(description) {
+    return this.step_func(function() {
+      assert_unreached(description);
+    });
+  };
+
+  Test.prototype.step_timeout = function(f, timeout) {
+    var test_this = this;
+    var args = Array.prototype.slice.call(arguments, 2);
+    return setTimeout(
+      this.step_func(function() {
+        return f.apply(test_this, args);
+      }),
+      timeout * tests.timeout_multiplier
+    );
+  };
+
+  /*
+   * Private method for registering cleanup functions. `testharness.js`
+   * internals should use this method instead of the public `add_cleanup`
+   * method in order to hide implementation details from the harness status
+   * message in the case errors.
+   */
+  Test.prototype._add_cleanup = function(callback) {
+    this.cleanup_callbacks.push(callback);
+  };
+
+  /*
+   * Schedule a function to be run after the test result is known, regardless
+   * of passing or failing state. The behavior of this function will not
+   * influence the result of the test, but if an exception is thrown, the
+   * test harness will report an error.
+   */
+  Test.prototype.add_cleanup = function(callback) {
+    this._user_defined_cleanup_count += 1;
+    this._add_cleanup(callback);
+  };
+
+  Test.prototype.set_timeout = function() {
+    if (this.timeout_length !== null) {
+      var this_obj = this;
+      this.timeout_id = setTimeout(function() {
+        this_obj.timeout();
+      }, this.timeout_length);
+    }
+  };
+
+  Test.prototype.set_status = function(status, message, stack) {
+    this.status = status;
+    this.message = message;
+    this.stack = stack ? stack : null;
+  };
+
+  Test.prototype.timeout = function() {
+    this.timeout_id = null;
+    this.set_status(this.TIMEOUT, 'Test timed out');
+    this.phase = this.phases.HAS_RESULT;
+    this.done();
+  };
+
+  Test.prototype.force_timeout = Test.prototype.timeout;
+
+  /**
+   * Update the test status, initiate "cleanup" functions, and signal test
+   * completion.
+   */
+  Test.prototype.done = function() {
+    if (this.phase >= this.phases.CLEANING) {
+      return;
+    }
+
+    if (this.phase <= this.phases.STARTED) {
+      this.set_status(this.PASS, null);
+    }
+
+    if (global_scope.clearTimeout) {
+      clearTimeout(this.timeout_id);
+    }
+
+    this.cleanup();
+  };
+
+  function add_test_done_callback(test, callback) {
+    if (test.phase === test.phases.COMPLETE) {
+      callback();
+      return;
+    }
+
+    test._done_callbacks.push(callback);
+  }
+
+  /*
+   * Invoke all specified cleanup functions. If one or more produce an error,
+   * the context is in an unpredictable state, so all further testing should
+   * be cancelled.
+   */
+  Test.prototype.cleanup = function() {
+    var error_count = 0;
+    var bad_value_count = 0;
+    function on_error() {
+      error_count += 1;
+      // Abort tests immediately so that tests declared within subsequent
+      // cleanup functions are not run.
+      tests.abort();
+    }
+    var this_obj = this;
+    var results = [];
+
+    this.phase = this.phases.CLEANING;
+
+    forEach(this.cleanup_callbacks, function(cleanup_callback) {
+      var result;
+
+      try {
+        result = cleanup_callback();
+      } catch (e) {
+        on_error();
+        return;
+      }
+
+      if (!is_valid_cleanup_result(this_obj, result)) {
+        bad_value_count += 1;
+        // Abort tests immediately so that tests declared
+        // within subsequent cleanup functions are not run.
+        tests.abort();
+      }
+
+      results.push(result);
+    });
+
+    if (!this._is_promise_test) {
+      cleanup_done(this_obj, error_count, bad_value_count);
+    } else {
+      all_async(
+        results,
+        function(result, done) {
+          if (result && typeof result.then === 'function') {
+            result.then(null, on_error).then(done);
+          } else {
+            done();
+          }
+        },
+        function() {
+          cleanup_done(this_obj, error_count, bad_value_count);
+        }
+      );
+    }
+  };
+
+  /**
+   * Determine if the return value of a cleanup function is valid for a given
+   * test. Any test may return the value `undefined`. Tests created with
+   * `promise_test` may alternatively return "thenable" object values.
+   */
+  function is_valid_cleanup_result(test, result) {
+    if (result === undefined) {
+      return true;
+    }
+
+    if (test._is_promise_test) {
+      return result && typeof result.then === 'function';
+    }
+
+    return false;
+  }
+
+  function cleanup_done(test, error_count, bad_value_count) {
+    if (error_count || bad_value_count) {
+      var total = test._user_defined_cleanup_count;
+
+      tests.status.status = tests.status.ERROR;
+      tests.status.message =
+        "Test named '" +
+        test.name +
+        "' specified " +
+        total +
+        " 'cleanup' function" +
+        (total > 1 ? 's' : '');
+
+      if (error_count) {
+        tests.status.message += ', and ' + error_count + ' failed';
+      }
+
+      if (bad_value_count) {
+        var type = test._is_promise_test ? 'non-thenable' : 'non-undefined';
+        tests.status.message +=
+          ', and ' + bad_value_count + ' returned a ' + type + ' value';
+      }
+
+      tests.status.message += '.';
+
+      tests.status.stack = null;
+    }
+
+    test.phase = test.phases.COMPLETE;
+    tests.result(test);
+    forEach(test._done_callbacks, function(callback) {
+      callback();
+    });
+    test._done_callbacks.length = 0;
+  }
+
+  /*
+   * A RemoteTest object mirrors a Test object on a remote worker. The
+   * associated RemoteWorker updates the RemoteTest object in response to
+   * received events. In turn, the RemoteTest object replicates these events
+   * on the local document. This allows listeners (test result reporting
+   * etc..) to transparently handle local and remote events.
+   */
+  function RemoteTest(clone) {
+    var this_obj = this;
+    Object.keys(clone).forEach(function(key) {
+      this_obj[key] = clone[key];
+    });
+    this.index = null;
+    this.phase = this.phases.INITIAL;
+    this.update_state_from(clone);
+    this._done_callbacks = [];
+    tests.push(this);
+  }
+
+  RemoteTest.prototype.structured_clone = function() {
+    var clone = {};
+    Object.keys(this).forEach(
+      function(key) {
+        var value = this[key];
+        // `RemoteTest` instances are responsible for managing
+        // their own "done" callback functions, so those functions
+        // are not relevant in other execution contexts. Because of
+        // this (and because Function values cannot be serialized
+        // for cross-realm transmittance), the property should not
+        // be considered when cloning instances.
+        if (key === '_done_callbacks') {
+          return;
+        }
+
+        if (typeof value === 'object' && value !== null) {
+          clone[key] = merge({}, value);
         } else {
-            output_document = this.output_document;
-        }
-        if (!output_document) {
-            return;
-        }
-        var node = output_document.getElementById("log");
-        if (!node) {
-            if (!document.readyState == "loading") {
-                return;
-            }
-            node = output_document.createElementNS("http://www.w3.org/1999/xhtml", "div");
-            node.id = "log";
-            if (output_document.body) {
-                output_document.body.appendChild(node);
-            } else {
-                var root = output_document.documentElement;
-                var is_html = (root &&
-                               root.namespaceURI == "http://www.w3.org/1999/xhtml" &&
-                               root.localName == "html");
-                var is_svg = (output_document.defaultView &&
-                              "SVGSVGElement" in output_document.defaultView &&
-                              root instanceof output_document.defaultView.SVGSVGElement);
-                if (is_svg) {
-                    var foreignObject = output_document.createElementNS("http://www.w3.org/2000/svg", "foreignObject");
-                    foreignObject.setAttribute("width", "100%");
-                    foreignObject.setAttribute("height", "100%");
-                    root.appendChild(foreignObject);
-                    foreignObject.appendChild(node);
-                } else if (is_html) {
-                    root.appendChild(output_document.createElementNS("http://www.w3.org/1999/xhtml", "body"))
-                        .appendChild(node);
-                } else {
-                    root.appendChild(node);
-                }
-            }
-        }
-        this.output_document = output_document;
-        this.output_node = node;
-    };
-
-    Output.prototype.show_status = function() {
-        if (this.phase < this.STARTED) {
-            this.init();
-        }
-        if (!this.enabled) {
-            return;
-        }
-        if (this.phase < this.HAVE_RESULTS) {
-            this.resolve_log();
-            this.phase = this.HAVE_RESULTS;
-        }
-        var done_count = tests.tests.length - tests.num_pending;
-        if (this.output_node) {
-            if (done_count < 100 ||
-                (done_count < 1000 && done_count % 100 === 0) ||
-                done_count % 1000 === 0) {
-                this.output_node.textContent = "Running, " +
-                    done_count + " complete, " +
-                    tests.num_pending + " remain";
-            }
-        }
+          clone[key] = value;
+        }
+      }.bind(this)
+    );
+    clone.phases = merge({}, this.phases);
+    return clone;
+  };
+
+  /**
+   * `RemoteTest` instances are objects which represent tests running in
+   * another realm. They do not define "cleanup" functions (if necessary,
+   * such functions are defined on the associated `Test` instance within the
+   * external realm). However, `RemoteTests` may have "done" callbacks (e.g.
+   * as attached by the `Tests` instance responsible for tracking the overall
+   * test status in the parent realm). The `cleanup` method delegates to
+   * `done` in order to ensure that such callbacks are invoked following the
+   * completion of the `RemoteTest`.
+   */
+  RemoteTest.prototype.cleanup = function() {
+    this.done();
+  };
+  RemoteTest.prototype.phases = Test.prototype.phases;
+  RemoteTest.prototype.update_state_from = function(clone) {
+    this.status = clone.status;
+    this.message = clone.message;
+    this.stack = clone.stack;
+    if (this.phase === this.phases.INITIAL) {
+      this.phase = this.phases.STARTED;
+    }
+  };
+  RemoteTest.prototype.done = function() {
+    this.phase = this.phases.COMPLETE;
+
+    forEach(this._done_callbacks, function(callback) {
+      callback();
+    });
+  };
+
+  /*
+   * A RemoteContext listens for test events from a remote test context, such
+   * as another window or a worker. These events are then used to construct
+   * and maintain RemoteTest objects that mirror the tests running in the
+   * remote context.
+   *
+   * An optional third parameter can be used as a predicate to filter incoming
+   * MessageEvents.
+   */
+  function RemoteContext(remote, message_target, message_filter) {
+    this.running = true;
+    this.tests = new Array();
+
+    var this_obj = this;
+    // If remote context is cross origin assigning to onerror is not
+    // possible, so silently catch those errors.
+    try {
+      remote.onerror = function(error) {
+        this_obj.remote_error(error);
+      };
+    } catch (e) {
+      // Ignore.
+    }
+
+    // Keeping a reference to the remote object and the message handler until
+    // remote_done() is seen prevents the remote object and its message channel
+    // from going away before all the messages are dispatched.
+    this.remote = remote;
+    this.message_target = message_target;
+    this.message_handler = function(message) {
+      var passesFilter = !message_filter || message_filter(message);
+      // The reference to the `running` property in the following
+      // condition is unnecessary because that value is only set to
+      // `false` after the `message_handler` function has been
+      // unsubscribed.
+      // TODO: Simplify the condition by removing the reference.
+      if (
+        this_obj.running &&
+        message.data &&
+        passesFilter &&
+        message.data.type in this_obj.message_handlers
+      ) {
+        this_obj.message_handlers[message.data.type].call(
+          this_obj,
+          message.data
+        );
+      }
     };
 
-    Output.prototype.show_results = function (tests, harness_status) {
-        if (this.phase >= this.COMPLETE) {
-            return;
-        }
-        if (!this.enabled) {
-            return;
-        }
-        if (!this.output_node) {
-            this.resolve_log();
-        }
-        this.phase = this.COMPLETE;
-
-        var log = this.output_node;
-        if (!log) {
-            return;
-        }
-        var output_document = this.output_document;
-
-        while (log.lastChild) {
-            log.removeChild(log.lastChild);
-        }
-
-        var stylesheet = output_document.createElementNS(xhtml_ns, "style");
-        stylesheet.textContent = stylesheetContent;
-        var heads = output_document.getElementsByTagName("head");
-        if (heads.length) {
-            heads[0].appendChild(stylesheet);
-        }
-
-        var status_text_harness = {};
-        status_text_harness[harness_status.OK] = "OK";
-        status_text_harness[harness_status.ERROR] = "Error";
-        status_text_harness[harness_status.TIMEOUT] = "Timeout";
-
-        var status_text = {};
-        status_text[Test.prototype.PASS] = "Pass";
-        status_text[Test.prototype.FAIL] = "Fail";
-        status_text[Test.prototype.TIMEOUT] = "Timeout";
-        status_text[Test.prototype.NOTRUN] = "Not Run";
-
-        var status_number = {};
-        forEach(tests,
-                function(test) {
-                    var status = status_text[test.status];
-                    if (status_number.hasOwnProperty(status)) {
-                        status_number[status] += 1;
-                    } else {
-                        status_number[status] = 1;
-                    }
-                });
-
-        function status_class(status)
-        {
-            return status.replace(/\s/g, '').toLowerCase();
-        }
-
-        var summary_template = ["section", {"id":"summary"},
-                                ["h2", {}, "Summary"],
-                                function()
-                                {
-
-                                    var status = status_text_harness[harness_status.status];
-                                    var rv = [["section", {},
-                                               ["p", {},
-                                                "Harness status: ",
-                                                ["span", {"class":status_class(status)},
-                                                 status
-                                                ],
-                                               ]
-                                              ]];
-
-                                    if (harness_status.status === harness_status.ERROR) {
-                                        rv[0].push(["pre", {}, harness_status.message]);
-                                        if (harness_status.stack) {
-                                            rv[0].push(["pre", {}, harness_status.stack]);
-                                        }
-                                    }
-                                    return rv;
-                                },
-                                ["p", {}, "Found ${num_tests} tests"],
-                                function() {
-                                    var rv = [["div", {}]];
-                                    var i = 0;
-                                    while (status_text.hasOwnProperty(i)) {
-                                        if (status_number.hasOwnProperty(status_text[i])) {
-                                            var status = status_text[i];
-                                            rv[0].push(["div", {"class":status_class(status)},
-                                                        ["label", {},
-                                                         ["input", {type:"checkbox", checked:"checked"}],
-                                                         status_number[status] + " " + status]]);
-                                        }
-                                        i++;
-                                    }
-                                    return rv;
-                                },
-                               ];
-
-        log.appendChild(render(summary_template, {num_tests:tests.length}, output_document));
-
-        forEach(output_document.querySelectorAll("section#summary label"),
-                function(element)
-                {
-                    on_event(element, "click",
-                             function(e)
-                             {
-                                 if (output_document.getElementById("results") === null) {
-                                     e.preventDefault();
-                                     return;
-                                 }
-                                 var result_class = element.parentNode.getAttribute("class");
-                                 var style_element = output_document.querySelector("style#hide-" + result_class);
-                                 var input_element = element.querySelector("input");
-                                 if (!style_element && !input_element.checked) {
-                                     style_element = output_document.createElementNS(xhtml_ns, "style");
-                                     style_element.id = "hide-" + result_class;
-                                     style_element.textContent = "table#results > tbody > tr."+result_class+"{display:none}";
-                                     output_document.body.appendChild(style_element);
-                                 } else if (style_element && input_element.checked) {
-                                     style_element.parentNode.removeChild(style_element);
-                                 }
-                             });
-                });
-
-        // This use of innerHTML plus manual escaping is not recommended in
-        // general, but is necessary here for performance.  Using textContent
-        // on each individual <td> adds tens of seconds of execution time for
-        // large test suites (tens of thousands of tests).
-        function escape_html(s)
+    if (self.Promise) {
+      this.done = new Promise(function(resolve) {
+        this_obj.doneResolve = resolve;
+      });
+    }
+
+    this.message_target.addEventListener('message', this.message_handler);
+  }
+
+  RemoteContext.prototype.remote_error = function(error) {
+    var message = error.message || String(error);
+    var filename = error.filename ? ' ' + error.filename : '';
+    // FIXME: Display remote error states separately from main document
+    // error state.
+    tests.set_status(
+      tests.status.ERROR,
+      'Error in remote' + filename + ': ' + message,
+      error.stack
+    );
+
+    if (error.preventDefault) {
+      error.preventDefault();
+    }
+  };
+
+  RemoteContext.prototype.test_state = function(data) {
+    var remote_test = this.tests[data.test.index];
+    if (!remote_test) {
+      remote_test = new RemoteTest(data.test);
+      this.tests[data.test.index] = remote_test;
+    }
+    remote_test.update_state_from(data.test);
+    tests.notify_test_state(remote_test);
+  };
+
+  RemoteContext.prototype.test_done = function(data) {
+    var remote_test = this.tests[data.test.index];
+    remote_test.update_state_from(data.test);
+    remote_test.done();
+    tests.result(remote_test);
+  };
+
+  RemoteContext.prototype.remote_done = function(data) {
+    if (tests.status.status === null && data.status.status !== data.status.OK) {
+      tests.set_status(
+        data.status.status,
+        data.status.message,
+        data.status.sack
+      );
+    }
+
+    this.message_target.removeEventListener('message', this.message_handler);
+    this.running = false;
+
+    // If remote context is cross origin assigning to onerror is not
+    // possible, so silently catch those errors.
+    try {
+      this.remote.onerror = null;
+    } catch (e) {
+      // Ignore.
+    }
+
+    this.remote = null;
+    this.message_target = null;
+    if (this.doneResolve) {
+      this.doneResolve();
+    }
+
+    if (tests.all_done()) {
+      tests.complete();
+    }
+  };
+
+  RemoteContext.prototype.message_handlers = {
+    test_state: RemoteContext.prototype.test_state,
+    result: RemoteContext.prototype.test_done,
+    complete: RemoteContext.prototype.remote_done
+  };
+
+  /*
+   * Harness
+   */
+
+  function TestsStatus() {
+    this.status = null;
+    this.message = null;
+    this.stack = null;
+  }
+
+  TestsStatus.statuses = {
+    OK: 0,
+    ERROR: 1,
+    TIMEOUT: 2
+  };
+
+  TestsStatus.prototype = merge({}, TestsStatus.statuses);
+
+  TestsStatus.prototype.structured_clone = function() {
+    if (!this._structured_clone) {
+      var msg = this.message;
+      msg = msg ? String(msg) : msg;
+      this._structured_clone = merge(
         {
-            return s.replace(/\&/g, "&amp;")
-                .replace(/</g, "&lt;")
-                .replace(/"/g, "&quot;")
-                .replace(/'/g, "&#39;");
-        }
-
-        function has_assertions()
-        {
-            for (var i = 0; i < tests.length; i++) {
-                if (tests[i].properties.hasOwnProperty("assert")) {
-                    return true;
-                }
-            }
-            return false;
-        }
+          status: this.status,
+          message: msg,
+          stack: this.stack
+        },
+        TestsStatus.statuses
+      );
+    }
+    return this._structured_clone;
+  };
 
-        function get_assertion(test)
-        {
-            if (test.properties.hasOwnProperty("assert")) {
-                if (Array.isArray(test.properties.assert)) {
-                    return test.properties.assert.join(' ');
-                }
-                return test.properties.assert;
-            }
-            return '';
-        }
+  function Tests() {
+    this.tests = [];
+    this.num_pending = 0;
 
-        log.appendChild(document.createElementNS(xhtml_ns, "section"));
-        var assertions = has_assertions();
-        var html = "<h2>Details</h2><table id='results' " + (assertions ? "class='assertions'" : "" ) + ">" +
-            "<thead><tr><th>Result</th><th>Test Name</th>" +
-            (assertions ? "<th>Assertion</th>" : "") +
-            "<th>Message</th></tr></thead>" +
-            "<tbody>";
-        for (var i = 0; i < tests.length; i++) {
-            html += '<tr class="' +
-                escape_html(status_class(status_text[tests[i].status])) +
-                '"><td>' +
-                escape_html(status_text[tests[i].status]) +
-                "</td><td>" +
-                escape_html(tests[i].name) +
-                "</td><td>" +
-                (assertions ? escape_html(get_assertion(tests[i])) + "</td><td>" : "") +
-                escape_html(tests[i].message ? tests[i].message : " ") +
-                (tests[i].stack ? "<pre>" +
-                 escape_html(tests[i].stack) +
-                 "</pre>": "") +
-                "</td></tr>";
-        }
-        html += "</tbody></table>";
-        try {
-            log.lastChild.innerHTML = html;
-        } catch (e) {
-            log.appendChild(document.createElementNS(xhtml_ns, "p"))
-               .textContent = "Setting innerHTML for the log threw an exception.";
-            log.appendChild(document.createElementNS(xhtml_ns, "pre"))
-               .textContent = html;
-        }
+    this.phases = {
+      INITIAL: 0,
+      SETUP: 1,
+      HAVE_TESTS: 2,
+      HAVE_RESULTS: 3,
+      COMPLETE: 4
     };
+    this.phase = this.phases.INITIAL;
 
-    /*
-     * Template code
-     *
-     * A template is just a JavaScript structure. An element is represented as:
-     *
-     * [tag_name, {attr_name:attr_value}, child1, child2]
-     *
-     * the children can either be strings (which act like text nodes), other templates or
-     * functions (see below)
-     *
-     * A text node is represented as
-     *
-     * ["{text}", value]
-     *
-     * String values have a simple substitution syntax; ${foo} represents a variable foo.
-     *
-     * It is possible to embed logic in templates by using a function in a place where a
-     * node would usually go. The function must either return part of a template or null.
-     *
-     * In cases where a set of nodes are required as output rather than a single node
-     * with children it is possible to just use a list
-     * [node1, node2, node3]
-     *
-     * Usage:
-     *
-     * render(template, substitutions) - take a template and an object mapping
-     * variable names to parameters and return either a DOM node or a list of DOM nodes
-     *
-     * substitute(template, substitutions) - take a template and variable mapping object,
-     * make the variable substitutions and return the substituted template
-     *
-     */
-
-    function is_single_node(template)
-    {
-        return typeof template[0] === "string";
-    }
-
-    function substitute(template, substitutions)
-    {
-        if (typeof template === "function") {
-            var replacement = template(substitutions);
-            if (!replacement) {
-                return null;
-            }
-
-            return substitute(replacement, substitutions);
-        }
+    this.properties = {};
 
-        if (is_single_node(template)) {
-            return substitute_single(template, substitutions);
-        }
+    this.wait_for_finish = false;
+    this.processing_callbacks = false;
 
-        return filter(map(template, function(x) {
-                              return substitute(x, substitutions);
-                          }), function(x) {return x !== null;});
-    }
+    this.allow_uncaught_exception = false;
 
-    function substitute_single(template, substitutions)
-    {
-        var substitution_re = /\$\{([^ }]*)\}/g;
+    this.file_is_test = false;
 
-        function do_substitution(input) {
-            var components = input.split(substitution_re);
-            var rv = [];
-            for (var i = 0; i < components.length; i += 2) {
-                rv.push(components[i]);
-                if (components[i + 1]) {
-                    rv.push(String(substitutions[components[i + 1]]));
-                }
-            }
-            return rv;
-        }
+    this.timeout_multiplier = 1;
+    this.timeout_length = test_environment.test_timeout();
+    this.timeout_id = null;
 
-        function substitute_attrs(attrs, rv)
-        {
-            rv[1] = {};
-            for (var name in template[1]) {
-                if (attrs.hasOwnProperty(name)) {
-                    var new_name = do_substitution(name).join("");
-                    var new_value = do_substitution(attrs[name]).join("");
-                    rv[1][new_name] = new_value;
-                }
-            }
-        }
+    this.start_callbacks = [];
+    this.test_state_callbacks = [];
+    this.test_done_callbacks = [];
+    this.all_done_callbacks = [];
 
-        function substitute_children(children, rv)
-        {
-            for (var i = 0; i < children.length; i++) {
-                if (children[i] instanceof Object) {
-                    var replacement = substitute(children[i], substitutions);
-                    if (replacement !== null) {
-                        if (is_single_node(replacement)) {
-                            rv.push(replacement);
-                        } else {
-                            extend(rv, replacement);
-                        }
-                    }
-                } else {
-                    extend(rv, do_substitution(String(children[i])));
-                }
-            }
-            return rv;
-        }
+    this.pending_remotes = [];
 
-        var rv = [];
-        rv.push(do_substitution(String(template[0])).join(""));
+    this.status = new TestsStatus();
 
-        if (template[0] === "{text}") {
-            substitute_children(template.slice(1), rv);
-        } else {
-            substitute_attrs(template[1], rv);
-            substitute_children(template.slice(2), rv);
-        }
+    var this_obj = this;
 
-        return rv;
-    }
+    test_environment.add_on_loaded_callback(function() {
+      if (this_obj.all_done()) {
+        this_obj.complete();
+      }
+    });
 
-    function make_dom_single(template, doc)
-    {
-        var output_document = doc || document;
-        var element;
-        if (template[0] === "{text}") {
-            element = output_document.createTextNode("");
-            for (var i = 1; i < template.length; i++) {
-                element.data += template[i];
-            }
-        } else {
-            element = output_document.createElementNS(xhtml_ns, template[0]);
-            for (var name in template[1]) {
-                if (template[1].hasOwnProperty(name)) {
-                    element.setAttribute(name, template[1][name]);
-                }
-            }
-            for (var i = 2; i < template.length; i++) {
-                if (template[i] instanceof Object) {
-                    var sub_element = make_dom(template[i]);
-                    element.appendChild(sub_element);
-                } else {
-                    var text_node = output_document.createTextNode(template[i]);
-                    element.appendChild(text_node);
-                }
-            }
-        }
+    this.set_timeout();
+  }
 
-        return element;
+  Tests.prototype.setup = function(func, properties) {
+    if (this.phase >= this.phases.HAVE_RESULTS) {
+      return;
     }
 
-    function make_dom(template, substitutions, output_document)
-    {
-        if (is_single_node(template)) {
-            return make_dom_single(template, output_document);
-        }
-
-        return map(template, function(x) {
-                       return make_dom_single(x, output_document);
-                   });
+    if (this.phase < this.phases.SETUP) {
+      this.phase = this.phases.SETUP;
     }
 
-    function render(template, substitutions, output_document)
-    {
-        return make_dom(substitute(template, substitutions), output_document);
-    }
+    this.properties = properties;
 
-    /*
-     * Utility functions
-     */
-    function assert(expected_true, function_name, description, error, substitutions)
-    {
-        if (tests.tests.length === 0) {
-            tests.set_file_is_test();
-        }
-        if (expected_true !== true) {
-            var msg = make_message(function_name, description,
-                                   error, substitutions);
-            throw new AssertionError(msg);
+    for (var p in properties) {
+      if (properties.hasOwnProperty(p)) {
+        var value = properties[p];
+        if (p == 'allow_uncaught_exception') {
+          this.allow_uncaught_exception = value;
+        } else if (p == 'explicit_done' && value) {
+          this.wait_for_finish = true;
+        } else if (p == 'explicit_timeout' && value) {
+          this.timeout_length = null;
+          if (this.timeout_id) {
+            clearTimeout(this.timeout_id);
+          }
+        } else if (p == 'timeout_multiplier') {
+          this.timeout_multiplier = value;
         }
+      }
     }
 
-    function AssertionError(message)
-    {
-        this.message = message;
-        this.stack = this.get_stack();
-    }
-    expose(AssertionError, "AssertionError");
-
-    AssertionError.prototype = Object.create(Error.prototype);
-
-    AssertionError.prototype.get_stack = function() {
-        var stack = new Error().stack;
-        // IE11 does not initialize 'Error.stack' until the object is thrown.
-        if (!stack) {
-            try {
-                throw new Error();
-            } catch (e) {
-                stack = e.stack;
-            }
-        }
-
-        // 'Error.stack' is not supported in all browsers/versions
-        if (!stack) {
-            return "(Stack trace unavailable)";
-        }
-
-        var lines = stack.split("\n");
-
-        // Create a pattern to match stack frames originating within testharness.js.  These include the
-        // script URL, followed by the line/col (e.g., '/resources/testharness.js:120:21').
-        // Escape the URL per http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
-        // in case it contains RegExp characters.
-        var script_url = get_script_url();
-        var re_text = script_url ? script_url.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') : "\\btestharness.js";
-        var re = new RegExp(re_text + ":\\d+:\\d+");
-
-        // Some browsers include a preamble that specifies the type of the error object.  Skip this by
-        // advancing until we find the first stack frame originating from testharness.js.
-        var i = 0;
-        while (!re.test(lines[i]) && i < lines.length) {
-            i++;
-        }
-
-        // Then skip the top frames originating from testharness.js to begin the stack at the test code.
-        while (re.test(lines[i]) && i < lines.length) {
-            i++;
+    if (func) {
+      try {
+        func();
+      } catch (e) {
+        this.status.status = this.status.ERROR;
+        this.status.message = String(e);
+        this.status.stack = e.stack ? e.stack : null;
+      }
+    }
+    this.set_timeout();
+  };
+
+  Tests.prototype.set_file_is_test = function() {
+    if (this.tests.length > 0) {
+      throw new Error('Tried to set file as test after creating a test');
+    }
+    this.wait_for_finish = true;
+    this.file_is_test = true;
+    // Create the test, which will add it to the list of tests
+    async_test();
+  };
+
+  Tests.prototype.set_status = function(status, message, stack) {
+    this.status.status = status;
+    this.status.message = message;
+    this.status.stack = stack ? stack : null;
+  };
+
+  Tests.prototype.set_timeout = function() {
+    if (global_scope.clearTimeout) {
+      var this_obj = this;
+      clearTimeout(this.timeout_id);
+      if (this.timeout_length !== null) {
+        this.timeout_id = setTimeout(function() {
+          this_obj.timeout();
+        }, this.timeout_length);
+      }
+    }
+  };
+
+  Tests.prototype.timeout = function() {
+    var test_in_cleanup = null;
+
+    if (this.status.status === null) {
+      forEach(this.tests, function(test) {
+        // No more than one test is expected to be in the
+        // "CLEANUP" phase at any time
+        if (test.phase === test.phases.CLEANING) {
+          test_in_cleanup = test;
         }
 
-        // Paranoid check that we didn't skip all frames.  If so, return the original stack unmodified.
-        if (i >= lines.length) {
-            return stack;
-        }
+        test.phase = test.phases.COMPLETE;
+      });
+
+      // Timeouts that occur while a test is in the "cleanup" phase
+      // indicate that some global state was not properly reverted. This
+      // invalidates the overall test execution, so the timeout should be
+      // reported as an error and cancel the execution of any remaining
+      // tests.
+      if (test_in_cleanup) {
+        this.status.status = this.status.ERROR;
+        this.status.message =
+          'Timeout while running cleanup for ' +
+          'test named "' +
+          test_in_cleanup.name +
+          '".';
+        tests.status.stack = null;
+      } else {
+        this.status.status = this.status.TIMEOUT;
+      }
+    }
+
+    this.complete();
+  };
+
+  Tests.prototype.end_wait = function() {
+    this.wait_for_finish = false;
+    if (this.all_done()) {
+      this.complete();
+    }
+  };
+
+  Tests.prototype.push = function(test) {
+    if (this.phase < this.phases.HAVE_TESTS) {
+      this.start();
+    }
+    this.num_pending++;
+    test.index = this.tests.push(test);
+    this.notify_test_state(test);
+  };
+
+  Tests.prototype.notify_test_state = function(test) {
+    var this_obj = this;
+    forEach(this.test_state_callbacks, function(callback) {
+      callback(test, this_obj);
+    });
+  };
+
+  Tests.prototype.all_done = function() {
+    return (
+      this.tests.length > 0 &&
+      test_environment.all_loaded &&
+      (this.num_pending === 0 || this.is_aborted) &&
+      !this.wait_for_finish &&
+      !this.processing_callbacks &&
+      !this.pending_remotes.some(function(w) {
+        return w.running;
+      })
+    );
+  };
+
+  Tests.prototype.start = function() {
+    this.phase = this.phases.HAVE_TESTS;
+    this.notify_start();
+  };
+
+  Tests.prototype.notify_start = function() {
+    var this_obj = this;
+    forEach(this.start_callbacks, function(callback) {
+      callback(this_obj.properties);
+    });
+  };
+
+  Tests.prototype.result = function(test) {
+    // If the harness has already transitioned beyond the `HAVE_RESULTS`
+    // phase, subsequent tests should not cause it to revert.
+    if (this.phase <= this.phases.HAVE_RESULTS) {
+      this.phase = this.phases.HAVE_RESULTS;
+    }
+    this.num_pending--;
+    this.notify_result(test);
+  };
+
+  Tests.prototype.notify_result = function(test) {
+    var this_obj = this;
+    this.processing_callbacks = true;
+    forEach(this.test_done_callbacks, function(callback) {
+      callback(test, this_obj);
+    });
+    this.processing_callbacks = false;
+    if (this_obj.all_done()) {
+      this_obj.complete();
+    }
+  };
+
+  Tests.prototype.complete = function() {
+    if (this.phase === this.phases.COMPLETE) {
+      return;
+    }
+    var this_obj = this;
+    var all_complete = function() {
+      this_obj.phase = this_obj.phases.COMPLETE;
+      this_obj.notify_complete();
+    };
+    var incomplete = filter(this.tests, function(test) {
+      return test.phase < test.phases.COMPLETE;
+    });
 
-        return lines.slice(i).join("\n");
+    /**
+     * To preserve legacy behavior, overall test completion must be
+     * signaled synchronously.
+     */
+    if (incomplete.length === 0) {
+      all_complete();
+      return;
     }
 
-    function make_message(function_name, description, error, substitutions)
-    {
-        for (var p in substitutions) {
-            if (substitutions.hasOwnProperty(p)) {
-                substitutions[p] = format_value(substitutions[p]);
-            }
-        }
-        var node_form = substitute(["{text}", "${function_name}: ${description}" + error],
-                                   merge({function_name:function_name,
-                                          description:(description?description + " ":"")},
-                                          substitutions));
-        return node_form.slice(1).join("");
-    }
-
-    function filter(array, callable, thisObj) {
-        var rv = [];
-        for (var i = 0; i < array.length; i++) {
-            if (array.hasOwnProperty(i)) {
-                var pass = callable.call(thisObj, array[i], i, array);
-                if (pass) {
-                    rv.push(array[i]);
-                }
-            }
+    all_async(
+      incomplete,
+      function(test, testDone) {
+        if (test.phase === test.phases.INITIAL) {
+          test.phase = test.phases.COMPLETE;
+          testDone();
+        } else {
+          add_test_done_callback(test, testDone);
+          test.cleanup();
+        }
+      },
+      all_complete
+    );
+  };
+
+  /**
+   * Update the harness status to reflect an unrecoverable harness error that
+   * should cancel all further testing. Update all previously-defined tests
+   * which have not yet started to indicate that they will not be executed.
+   */
+  Tests.prototype.abort = function() {
+    this.status.status = this.status.ERROR;
+    this.is_aborted = true;
+
+    forEach(this.tests, function(test) {
+      if (test.phase === test.phases.INITIAL) {
+        test.phase = test.phases.COMPLETE;
+      }
+    });
+  };
+
+  /*
+   * Determine if any tests share the same `name` property. Return an array
+   * containing the names of any such duplicates.
+   */
+  Tests.prototype.find_duplicates = function() {
+    var names = Object.create(null);
+    var duplicates = [];
+
+    forEach(this.tests, function(test) {
+      if (test.name in names && duplicates.indexOf(test.name) === -1) {
+        duplicates.push(test.name);
+      }
+      names[test.name] = true;
+    });
+
+    return duplicates;
+  };
+
+  Tests.prototype.notify_complete = function() {
+    var this_obj = this;
+    var duplicates;
+
+    if (this.status.status === null) {
+      duplicates = this.find_duplicates();
+
+      // Test names are presumed to be unique within test files--this
+      // allows consumers to use them for identification purposes.
+      // Duplicated names violate this expectation and should therefore
+      // be reported as an error.
+      if (duplicates.length) {
+        this.status.status = this.status.ERROR;
+        this.status.message =
+          duplicates.length +
+          ' duplicate test name' +
+          (duplicates.length > 1 ? 's' : '') +
+          ': "' +
+          duplicates.join('", "') +
+          '"';
+      } else {
+        this.status.status = this.status.OK;
+      }
+    }
+
+    forEach(this.all_done_callbacks, function(callback) {
+      callback(this_obj.tests, this_obj.status);
+    });
+  };
+
+  /*
+   * Constructs a RemoteContext that tracks tests from a specific worker.
+   */
+  Tests.prototype.create_remote_worker = function(worker) {
+    var message_port;
+
+    if (is_service_worker(worker)) {
+      if (window.MessageChannel) {
+        // The ServiceWorker's implicit MessagePort is currently not
+        // reliably accessible from the ServiceWorkerGlobalScope due to
+        // Blink setting MessageEvent.source to null for messages sent
+        // via ServiceWorker.postMessage(). Until that's resolved,
+        // create an explicit MessageChannel and pass one end to the
+        // worker.
+        var message_channel = new MessageChannel();
+        message_port = message_channel.port1;
+        message_port.start();
+        worker.postMessage({ type: 'connect' }, [message_channel.port2]);
+      } else {
+        // If MessageChannel is not available, then try the
+        // ServiceWorker.postMessage() approach using MessageEvent.source
+        // on the other end.
+        message_port = navigator.serviceWorker;
+        worker.postMessage({ type: 'connect' });
+      }
+    } else if (is_shared_worker(worker)) {
+      message_port = worker.port;
+      message_port.start();
+    } else {
+      message_port = worker;
+    }
+
+    return new RemoteContext(worker, message_port);
+  };
+
+  /*
+   * Constructs a RemoteContext that tracks tests from a specific window.
+   */
+  Tests.prototype.create_remote_window = function(remote) {
+    remote.postMessage({ type: 'getmessages' }, '*');
+    return new RemoteContext(remote, window, function(msg) {
+      return msg.source === remote;
+    });
+  };
+
+  Tests.prototype.fetch_tests_from_worker = function(worker) {
+    if (this.phase >= this.phases.COMPLETE) {
+      return;
+    }
+
+    var remoteContext = this.create_remote_worker(worker);
+    this.pending_remotes.push(remoteContext);
+    return remoteContext.done;
+  };
+
+  function fetch_tests_from_worker(port) {
+    return tests.fetch_tests_from_worker(port);
+  }
+  expose(fetch_tests_from_worker, 'fetch_tests_from_worker');
+
+  Tests.prototype.fetch_tests_from_window = function(remote) {
+    if (this.phase >= this.phases.COMPLETE) {
+      return;
+    }
+
+    this.pending_remotes.push(this.create_remote_window(remote));
+  };
+
+  function fetch_tests_from_window(window) {
+    tests.fetch_tests_from_window(window);
+  }
+  expose(fetch_tests_from_window, 'fetch_tests_from_window');
+
+  function timeout() {
+    if (tests.timeout_length === null) {
+      tests.timeout();
+    }
+  }
+  expose(timeout, 'timeout');
+
+  function add_start_callback(callback) {
+    tests.start_callbacks.push(callback);
+  }
+
+  function add_test_state_callback(callback) {
+    tests.test_state_callbacks.push(callback);
+  }
+
+  function add_result_callback(callback) {
+    tests.test_done_callbacks.push(callback);
+  }
+
+  function add_completion_callback(callback) {
+    tests.all_done_callbacks.push(callback);
+  }
+
+  expose(add_start_callback, 'add_start_callback');
+  expose(add_test_state_callback, 'add_test_state_callback');
+  expose(add_result_callback, 'add_result_callback');
+  expose(add_completion_callback, 'add_completion_callback');
+
+  function remove(array, item) {
+    var index = array.indexOf(item);
+    if (index > -1) {
+      array.splice(index, 1);
+    }
+  }
+
+  function remove_start_callback(callback) {
+    remove(tests.start_callbacks, callback);
+  }
+
+  function remove_test_state_callback(callback) {
+    remove(tests.test_state_callbacks, callback);
+  }
+
+  function remove_result_callback(callback) {
+    remove(tests.test_done_callbacks, callback);
+  }
+
+  function remove_completion_callback(callback) {
+    remove(tests.all_done_callbacks, callback);
+  }
+
+  /*
+   * Output listener
+   */
+
+  function Output() {
+    this.output_document = document;
+    this.output_node = null;
+    this.enabled = settings.output;
+    this.phase = this.INITIAL;
+  }
+
+  Output.prototype.INITIAL = 0;
+  Output.prototype.STARTED = 1;
+  Output.prototype.HAVE_RESULTS = 2;
+  Output.prototype.COMPLETE = 3;
+
+  Output.prototype.setup = function(properties) {
+    if (this.phase > this.INITIAL) {
+      return;
+    }
+
+    //If output is disabled in testharnessreport.js the test shouldn't be
+    //able to override that
+    this.enabled =
+      this.enabled &&
+      (properties.hasOwnProperty('output')
+        ? properties.output
+        : settings.output);
+  };
+
+  Output.prototype.init = function(properties) {
+    if (this.phase >= this.STARTED) {
+      return;
+    }
+    if (properties.output_document) {
+      this.output_document = properties.output_document;
+    } else {
+      this.output_document = document;
+    }
+    this.phase = this.STARTED;
+  };
+
+  Output.prototype.resolve_log = function() {
+    var output_document;
+    if (typeof this.output_document === 'function') {
+      output_document = this.output_document.apply(undefined);
+    } else {
+      output_document = this.output_document;
+    }
+    if (!output_document) {
+      return;
+    }
+    var node = output_document.getElementById('log');
+    if (!node) {
+      if (!document.readyState == 'loading') {
+        return;
+      }
+      node = output_document.createElementNS(
+        'http://www.w3.org/1999/xhtml',
+        'div'
+      );
+      node.id = 'log';
+      if (output_document.body) {
+        output_document.body.appendChild(node);
+      } else {
+        var root = output_document.documentElement;
+        var is_html =
+          root &&
+          root.namespaceURI == 'http://www.w3.org/1999/xhtml' &&
+          root.localName == 'html';
+        var is_svg =
+          output_document.defaultView &&
+          'SVGSVGElement' in output_document.defaultView &&
+          root instanceof output_document.defaultView.SVGSVGElement;
+        if (is_svg) {
+          var foreignObject = output_document.createElementNS(
+            'http://www.w3.org/2000/svg',
+            'foreignObject'
+          );
+          foreignObject.setAttribute('width', '100%');
+          foreignObject.setAttribute('height', '100%');
+          root.appendChild(foreignObject);
+          foreignObject.appendChild(node);
+        } else if (is_html) {
+          root
+            .appendChild(
+              output_document.createElementNS(
+                'http://www.w3.org/1999/xhtml',
+                'body'
+              )
+            )
+            .appendChild(node);
+        } else {
+          root.appendChild(node);
+        }
+      }
+    }
+    this.output_document = output_document;
+    this.output_node = node;
+  };
+
+  Output.prototype.show_status = function() {
+    if (this.phase < this.STARTED) {
+      this.init();
+    }
+    if (!this.enabled) {
+      return;
+    }
+    if (this.phase < this.HAVE_RESULTS) {
+      this.resolve_log();
+      this.phase = this.HAVE_RESULTS;
+    }
+    var done_count = tests.tests.length - tests.num_pending;
+    if (this.output_node) {
+      if (
+        done_count < 100 ||
+        (done_count < 1000 && done_count % 100 === 0) ||
+        done_count % 1000 === 0
+      ) {
+        this.output_node.textContent =
+          'Running, ' +
+          done_count +
+          ' complete, ' +
+          tests.num_pending +
+          ' remain';
+      }
+    }
+  };
+
+  Output.prototype.show_results = function(tests, harness_status) {
+    if (this.phase >= this.COMPLETE) {
+      return;
+    }
+    if (!this.enabled) {
+      return;
+    }
+    if (!this.output_node) {
+      this.resolve_log();
+    }
+    this.phase = this.COMPLETE;
+
+    var log = this.output_node;
+    if (!log) {
+      return;
+    }
+    var output_document = this.output_document;
+
+    while (log.lastChild) {
+      log.removeChild(log.lastChild);
+    }
+
+    var stylesheet = output_document.createElementNS(xhtml_ns, 'style');
+    stylesheet.textContent = stylesheetContent;
+    var heads = output_document.getElementsByTagName('head');
+    if (heads.length) {
+      heads[0].appendChild(stylesheet);
+    }
+
+    var status_text_harness = {};
+    status_text_harness[harness_status.OK] = 'OK';
+    status_text_harness[harness_status.ERROR] = 'Error';
+    status_text_harness[harness_status.TIMEOUT] = 'Timeout';
+
+    var status_text = {};
+    status_text[Test.prototype.PASS] = 'Pass';
+    status_text[Test.prototype.FAIL] = 'Fail';
+    status_text[Test.prototype.TIMEOUT] = 'Timeout';
+    status_text[Test.prototype.NOTRUN] = 'Not Run';
+
+    var status_number = {};
+    forEach(tests, function(test) {
+      var status = status_text[test.status];
+      if (status_number.hasOwnProperty(status)) {
+        status_number[status] += 1;
+      } else {
+        status_number[status] = 1;
+      }
+    });
+
+    function status_class(status) {
+      return status.replace(/\s/g, '').toLowerCase();
+    }
+
+    var summary_template = [
+      'section',
+      { id: 'summary' },
+      ['h2', {}, 'Summary'],
+      function() {
+        var status = status_text_harness[harness_status.status];
+        var rv = [
+          [
+            'section',
+            {},
+            [
+              'p',
+              {},
+              'Harness status: ',
+              ['span', { class: status_class(status) }, status]
+            ]
+          ]
+        ];
+
+        if (harness_status.status === harness_status.ERROR) {
+          rv[0].push(['pre', {}, harness_status.message]);
+          if (harness_status.stack) {
+            rv[0].push(['pre', {}, harness_status.stack]);
+          }
         }
         return rv;
-    }
-
-    function map(array, callable, thisObj)
-    {
-        var rv = [];
-        rv.length = array.length;
-        for (var i = 0; i < array.length; i++) {
-            if (array.hasOwnProperty(i)) {
-                rv[i] = callable.call(thisObj, array[i], i, array);
-            }
+      },
+      ['p', {}, 'Found ${num_tests} tests'],
+      function() {
+        var rv = [['div', {}]];
+        var i = 0;
+        while (status_text.hasOwnProperty(i)) {
+          if (status_number.hasOwnProperty(status_text[i])) {
+            var status = status_text[i];
+            rv[0].push([
+              'div',
+              { class: status_class(status) },
+              [
+                'label',
+                {},
+                ['input', { type: 'checkbox', checked: 'checked' }],
+                status_number[status] + ' ' + status
+              ]
+            ]);
+          }
+          i++;
         }
         return rv;
-    }
+      }
+    ];
+
+    log.appendChild(
+      render(summary_template, { num_tests: tests.length }, output_document)
+    );
+
+    forEach(output_document.querySelectorAll('section#summary label'), function(
+      element
+    ) {
+      on_event(element, 'click', function(e) {
+        if (output_document.getElementById('results') === null) {
+          e.preventDefault();
+          return;
+        }
+        var result_class = element.parentNode.getAttribute('class');
+        var style_element = output_document.querySelector(
+          'style#hide-' + result_class
+        );
+        var input_element = element.querySelector('input');
+        if (!style_element && !input_element.checked) {
+          style_element = output_document.createElementNS(xhtml_ns, 'style');
+          style_element.id = 'hide-' + result_class;
+          style_element.textContent =
+            'table#results > tbody > tr.' + result_class + '{display:none}';
+          output_document.body.appendChild(style_element);
+        } else if (style_element && input_element.checked) {
+          style_element.parentNode.removeChild(style_element);
+        }
+      });
+    });
+
+    // This use of innerHTML plus manual escaping is not recommended in
+    // general, but is necessary here for performance.  Using textContent
+    // on each individual <td> adds tens of seconds of execution time for
+    // large test suites (tens of thousands of tests).
+    function escape_html(s) {
+      return s
+        .replace(/\&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+    }
+
+    function has_assertions() {
+      for (var i = 0; i < tests.length; i++) {
+        if (tests[i].properties.hasOwnProperty('assert')) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    function get_assertion(test) {
+      if (test.properties.hasOwnProperty('assert')) {
+        if (Array.isArray(test.properties.assert)) {
+          return test.properties.assert.join(' ');
+        }
+        return test.properties.assert;
+      }
+      return '';
+    }
+
+    log.appendChild(document.createElementNS(xhtml_ns, 'section'));
+    var assertions = has_assertions();
+    var html =
+      "<h2>Details</h2><table id='results' " +
+      (assertions ? "class='assertions'" : '') +
+      '>' +
+      '<thead><tr><th>Result</th><th>Test Name</th>' +
+      (assertions ? '<th>Assertion</th>' : '') +
+      '<th>Message</th></tr></thead>' +
+      '<tbody>';
+    for (var i = 0; i < tests.length; i++) {
+      html +=
+        '<tr class="' +
+        escape_html(status_class(status_text[tests[i].status])) +
+        '"><td>' +
+        escape_html(status_text[tests[i].status]) +
+        '</td><td>' +
+        escape_html(tests[i].name) +
+        '</td><td>' +
+        (assertions ? escape_html(get_assertion(tests[i])) + '</td><td>' : '') +
+        escape_html(tests[i].message ? tests[i].message : ' ') +
+        (tests[i].stack
+          ? '<pre>' + escape_html(tests[i].stack) + '</pre>'
+          : '') +
+        '</td></tr>';
+    }
+    html += '</tbody></table>';
+    try {
+      log.lastChild.innerHTML = html;
+    } catch (e) {
+      log.appendChild(document.createElementNS(xhtml_ns, 'p')).textContent =
+        'Setting innerHTML for the log threw an exception.';
+      log.appendChild(
+        document.createElementNS(xhtml_ns, 'pre')
+      ).textContent = html;
+    }
+  };
+
+  /*
+   * Template code
+   *
+   * A template is just a JavaScript structure. An element is represented as:
+   *
+   * [tag_name, {attr_name:attr_value}, child1, child2]
+   *
+   * the children can either be strings (which act like text nodes), other templates or
+   * functions (see below)
+   *
+   * A text node is represented as
+   *
+   * ["{text}", value]
+   *
+   * String values have a simple substitution syntax; ${foo} represents a variable foo.
+   *
+   * It is possible to embed logic in templates by using a function in a place where a
+   * node would usually go. The function must either return part of a template or null.
+   *
+   * In cases where a set of nodes are required as output rather than a single node
+   * with children it is possible to just use a list
+   * [node1, node2, node3]
+   *
+   * Usage:
+   *
+   * render(template, substitutions) - take a template and an object mapping
+   * variable names to parameters and return either a DOM node or a list of DOM nodes
+   *
+   * substitute(template, substitutions) - take a template and variable mapping object,
+   * make the variable substitutions and return the substituted template
+   *
+   */
+
+  function is_single_node(template) {
+    return typeof template[0] === 'string';
+  }
+
+  function substitute(template, substitutions) {
+    if (typeof template === 'function') {
+      var replacement = template(substitutions);
+      if (!replacement) {
+        return null;
+      }
 
-    function extend(array, items)
-    {
-        Array.prototype.push.apply(array, items);
+      return substitute(replacement, substitutions);
     }
 
-    function forEach(array, callback, thisObj)
-    {
-        for (var i = 0; i < array.length; i++) {
-            if (array.hasOwnProperty(i)) {
-                callback.call(thisObj, array[i], i, array);
-            }
-        }
+    if (is_single_node(template)) {
+      return substitute_single(template, substitutions);
     }
 
-    /**
-     * Immediately invoke a "iteratee" function with a series of values in
-     * parallel and invoke a final "done" function when all of the "iteratee"
-     * invocations have signaled completion.
-     *
-     * If all callbacks complete synchronously (or if no callbacks are
-     * specified), the `done_callback` will be invoked synchronously. It is the
-     * responsibility of the caller to ensure asynchronicity in cases where
-     * that is desired.
-     *
-     * @param {array} value Zero or more values to use in the invocation of
-     *                      `iter_callback`
-     * @param {function} iter_callback A function that will be invoked once for
-     *                                 each of the provided `values`. Two
-     *                                 arguments will be available in each
-     *                                 invocation: the value from `values` and
-     *                                 a function that must be invoked to
-     *                                 signal completion
-     * @param {function} done_callback A function that will be invoked after
-     *                                 all operations initiated by the
-     *                                 `iter_callback` function have signaled
-     *                                 completion
-     */
-    function all_async(values, iter_callback, done_callback)
-    {
-        var remaining = values.length;
-
-        if (remaining === 0) {
-            done_callback();
-        }
-
-        forEach(values,
-                function(element) {
-                    var invoked = false;
-                    var elDone = function() {
-                        if (invoked) {
-                            return;
-                        }
-
-                        invoked = true;
-                        remaining -= 1;
+    return filter(
+      map(template, function(x) {
+        return substitute(x, substitutions);
+      }),
+      function(x) {
+        return x !== null;
+      }
+    );
+  }
 
-                        if (remaining === 0) {
-                            done_callback();
-                        }
-                    };
+  function substitute_single(template, substitutions) {
+    var substitution_re = /\$\{([^ }]*)\}/g;
 
-                    iter_callback(element, elDone);
-                });
+    function do_substitution(input) {
+      var components = input.split(substitution_re);
+      var rv = [];
+      for (var i = 0; i < components.length; i += 2) {
+        rv.push(components[i]);
+        if (components[i + 1]) {
+          rv.push(String(substitutions[components[i + 1]]));
+        }
+      }
+      return rv;
     }
 
-    function merge(a,b)
-    {
-        var rv = {};
-        var p;
-        for (p in a) {
-            rv[p] = a[p];
-        }
-        for (p in b) {
-            rv[p] = b[p];
+    function substitute_attrs(attrs, rv) {
+      rv[1] = {};
+      for (var name in template[1]) {
+        if (attrs.hasOwnProperty(name)) {
+          var new_name = do_substitution(name).join('');
+          var new_value = do_substitution(attrs[name]).join('');
+          rv[1][new_name] = new_value;
         }
-        return rv;
+      }
     }
 
-    function expose(object, name)
-    {
-        var components = name.split(".");
-        var target = global_scope;
-        for (var i = 0; i < components.length - 1; i++) {
-            if (!(components[i] in target)) {
-                target[components[i]] = {};
+    function substitute_children(children, rv) {
+      for (var i = 0; i < children.length; i++) {
+        if (children[i] instanceof Object) {
+          var replacement = substitute(children[i], substitutions);
+          if (replacement !== null) {
+            if (is_single_node(replacement)) {
+              rv.push(replacement);
+            } else {
+              extend(rv, replacement);
             }
-            target = target[components[i]];
+          }
+        } else {
+          extend(rv, do_substitution(String(children[i])));
+        }
+      }
+      return rv;
+    }
+
+    var rv = [];
+    rv.push(do_substitution(String(template[0])).join(''));
+
+    if (template[0] === '{text}') {
+      substitute_children(template.slice(1), rv);
+    } else {
+      substitute_attrs(template[1], rv);
+      substitute_children(template.slice(2), rv);
+    }
+
+    return rv;
+  }
+
+  function make_dom_single(template, doc) {
+    var output_document = doc || document;
+    var element;
+    if (template[0] === '{text}') {
+      element = output_document.createTextNode('');
+      for (var i = 1; i < template.length; i++) {
+        element.data += template[i];
+      }
+    } else {
+      element = output_document.createElementNS(xhtml_ns, template[0]);
+      for (var name in template[1]) {
+        if (template[1].hasOwnProperty(name)) {
+          element.setAttribute(name, template[1][name]);
+        }
+      }
+      for (var i = 2; i < template.length; i++) {
+        if (template[i] instanceof Object) {
+          var sub_element = make_dom(template[i]);
+          element.appendChild(sub_element);
+        } else {
+          var text_node = output_document.createTextNode(template[i]);
+          element.appendChild(text_node);
         }
-        target[components[components.length - 1]] = object;
+      }
     }
 
-    function is_same_origin(w) {
-        try {
-            'random_prop' in w;
-            return true;
-        } catch (e) {
-            return false;
-        }
+    return element;
+  }
+
+  function make_dom(template, substitutions, output_document) {
+    if (is_single_node(template)) {
+      return make_dom_single(template, output_document);
     }
 
-    /** Returns the 'src' URL of the first <script> tag in the page to include the file 'testharness.js'. */
-    function get_script_url()
-    {
-        if (!('document' in global_scope)) {
-            return undefined;
-        }
+    return map(template, function(x) {
+      return make_dom_single(x, output_document);
+    });
+  }
 
-        var scripts = document.getElementsByTagName("script");
-        for (var i = 0; i < scripts.length; i++) {
-            var src;
-            if (scripts[i].src) {
-                src = scripts[i].src;
-            } else if (scripts[i].href) {
-                //SVG case
-                src = scripts[i].href.baseVal;
-            }
+  function render(template, substitutions, output_document) {
+    return make_dom(substitute(template, substitutions), output_document);
+  }
 
-            var matches = src && src.match(/^(.*\/|)testharness\.js$/);
-            if (matches) {
-                return src;
-            }
-        }
-        return undefined;
+  /*
+   * Utility functions
+   */
+  function assert(
+    expected_true,
+    function_name,
+    description,
+    error,
+    substitutions
+  ) {
+    if (tests.tests.length === 0) {
+      tests.set_file_is_test();
     }
+    if (expected_true !== true) {
+      var msg = make_message(function_name, description, error, substitutions);
+      throw new AssertionError(msg);
+    }
+  }
 
-    /** Returns the <title> or filename or "Untitled" */
-    function get_title()
-    {
-        if ('document' in global_scope) {
-            //Don't use document.title to work around an Opera bug in XHTML documents
-            var title = document.getElementsByTagName("title")[0];
-            if (title && title.firstChild && title.firstChild.data) {
-                return title.firstChild.data;
-            }
-        }
-        if ('META_TITLE' in global_scope && META_TITLE) {
-            return META_TITLE;
-        }
-        if ('location' in global_scope) {
-            return location.pathname.substring(location.pathname.lastIndexOf('/') + 1, location.pathname.indexOf('.'));
-        }
-        return "Untitled";
-    }
-
-    function supports_post_message(w)
-    {
-        var supports;
-        var type;
-        // Given IE implements postMessage across nested iframes but not across
-        // windows or tabs, you can't infer cross-origin communication from the presence
-        // of postMessage on the current window object only.
-        //
-        // Touching the postMessage prop on a window can throw if the window is
-        // not from the same origin AND post message is not supported in that
-        // browser. So just doing an existence test here won't do, you also need
-        // to wrap it in a try..catch block.
-        try {
-            type = typeof w.postMessage;
-            if (type === "function") {
-                supports = true;
-            }
+  function AssertionError(message) {
+    this.message = message;
+    this.stack = this.get_stack();
+  }
+  expose(AssertionError, 'AssertionError');
 
-            // IE8 supports postMessage, but implements it as a host object which
-            // returns "object" as its `typeof`.
-            else if (type === "object") {
-                supports = true;
-            }
+  AssertionError.prototype = Object.create(Error.prototype);
 
-            // This is the case where postMessage isn't supported AND accessing a
-            // window property across origins does NOT throw (e.g. old Safari browser).
-            else {
-                supports = false;
-            }
-        } catch (e) {
-            // This is the case where postMessage isn't supported AND accessing a
-            // window property across origins throws (e.g. old Firefox browser).
-            supports = false;
-        }
-        return supports;
+  AssertionError.prototype.get_stack = function() {
+    var stack = new Error().stack;
+    // IE11 does not initialize 'Error.stack' until the object is thrown.
+    if (!stack) {
+      try {
+        throw new Error();
+      } catch (e) {
+        stack = e.stack;
+      }
     }
 
-    /**
-     * Setup globals
-     */
+    // 'Error.stack' is not supported in all browsers/versions
+    if (!stack) {
+      return '(Stack trace unavailable)';
+    }
 
-    var tests = new Tests();
+    var lines = stack.split('\n');
 
-    if (global_scope.addEventListener) {
-        var error_handler = function(e) {
-            if (tests.tests.length === 0 && !tests.allow_uncaught_exception) {
-                tests.set_file_is_test();
-            }
+    // Create a pattern to match stack frames originating within testharness.js.  These include the
+    // script URL, followed by the line/col (e.g., '/resources/testharness.js:120:21').
+    // Escape the URL per http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+    // in case it contains RegExp characters.
+    var script_url = get_script_url();
+    var re_text = script_url
+      ? script_url.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')
+      : '\\btestharness.js';
+    var re = new RegExp(re_text + ':\\d+:\\d+');
 
-            var stack;
-            if (e.error && e.error.stack) {
-                stack = e.error.stack;
-            } else {
-                stack = e.filename + ":" + e.lineno + ":" + e.colno;
-            }
+    // Some browsers include a preamble that specifies the type of the error object.  Skip this by
+    // advancing until we find the first stack frame originating from testharness.js.
+    var i = 0;
+    while (!re.test(lines[i]) && i < lines.length) {
+      i++;
+    }
 
-            if (tests.file_is_test) {
-                var test = tests.tests[0];
-                if (test.phase >= test.phases.HAS_RESULT) {
-                    return;
-                }
-                test.set_status(test.FAIL, e.message, stack);
-                test.phase = test.phases.HAS_RESULT;
-                // The following function invocation is superfluous.
-                // TODO: Remove.
-                test.done();
-            } else if (!tests.allow_uncaught_exception) {
-                tests.status.status = tests.status.ERROR;
-                tests.status.message = e.message;
-                tests.status.stack = stack;
-            }
-            done();
-        };
+    // Then skip the top frames originating from testharness.js to begin the stack at the test code.
+    while (re.test(lines[i]) && i < lines.length) {
+      i++;
+    }
 
-        addEventListener("error", error_handler, false);
-        addEventListener("unhandledrejection", function(e){ error_handler(e.reason); }, false);
+    // Paranoid check that we didn't skip all frames.  If so, return the original stack unmodified.
+    if (i >= lines.length) {
+      return stack;
     }
 
-    test_environment.on_tests_ready();
+    return lines.slice(i).join('\n');
+  };
 
-    /**
-     * Stylesheet
-     */
-     var stylesheetContent = "\
+  function make_message(function_name, description, error, substitutions) {
+    for (var p in substitutions) {
+      if (substitutions.hasOwnProperty(p)) {
+        substitutions[p] = format_value(substitutions[p]);
+      }
+    }
+    var node_form = substitute(
+      ['{text}', '${function_name}: ${description}' + error],
+      merge(
+        {
+          function_name: function_name,
+          description: description ? description + ' ' : ''
+        },
+        substitutions
+      )
+    );
+    return node_form.slice(1).join('');
+  }
+
+  function filter(array, callable, thisObj) {
+    var rv = [];
+    for (var i = 0; i < array.length; i++) {
+      if (array.hasOwnProperty(i)) {
+        var pass = callable.call(thisObj, array[i], i, array);
+        if (pass) {
+          rv.push(array[i]);
+        }
+      }
+    }
+    return rv;
+  }
+
+  function map(array, callable, thisObj) {
+    var rv = [];
+    rv.length = array.length;
+    for (var i = 0; i < array.length; i++) {
+      if (array.hasOwnProperty(i)) {
+        rv[i] = callable.call(thisObj, array[i], i, array);
+      }
+    }
+    return rv;
+  }
+
+  function extend(array, items) {
+    Array.prototype.push.apply(array, items);
+  }
+
+  function forEach(array, callback, thisObj) {
+    for (var i = 0; i < array.length; i++) {
+      if (array.hasOwnProperty(i)) {
+        callback.call(thisObj, array[i], i, array);
+      }
+    }
+  }
+
+  /**
+   * Immediately invoke a "iteratee" function with a series of values in
+   * parallel and invoke a final "done" function when all of the "iteratee"
+   * invocations have signaled completion.
+   *
+   * If all callbacks complete synchronously (or if no callbacks are
+   * specified), the `done_callback` will be invoked synchronously. It is the
+   * responsibility of the caller to ensure asynchronicity in cases where
+   * that is desired.
+   *
+   * @param {array} value Zero or more values to use in the invocation of
+   *                      `iter_callback`
+   * @param {function} iter_callback A function that will be invoked once for
+   *                                 each of the provided `values`. Two
+   *                                 arguments will be available in each
+   *                                 invocation: the value from `values` and
+   *                                 a function that must be invoked to
+   *                                 signal completion
+   * @param {function} done_callback A function that will be invoked after
+   *                                 all operations initiated by the
+   *                                 `iter_callback` function have signaled
+   *                                 completion
+   */
+  function all_async(values, iter_callback, done_callback) {
+    var remaining = values.length;
+
+    if (remaining === 0) {
+      done_callback();
+    }
+
+    forEach(values, function(element) {
+      var invoked = false;
+      var elDone = function() {
+        if (invoked) {
+          return;
+        }
+
+        invoked = true;
+        remaining -= 1;
+
+        if (remaining === 0) {
+          done_callback();
+        }
+      };
+
+      iter_callback(element, elDone);
+    });
+  }
+
+  function merge(a, b) {
+    var rv = {};
+    var p;
+    for (p in a) {
+      rv[p] = a[p];
+    }
+    for (p in b) {
+      rv[p] = b[p];
+    }
+    return rv;
+  }
+
+  function expose(object, name) {
+    var components = name.split('.');
+    var target = global_scope;
+    for (var i = 0; i < components.length - 1; i++) {
+      if (!(components[i] in target)) {
+        target[components[i]] = {};
+      }
+      target = target[components[i]];
+    }
+    target[components[components.length - 1]] = object;
+  }
+
+  function is_same_origin(w) {
+    try {
+      'random_prop' in w;
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /** Returns the 'src' URL of the first <script> tag in the page to include the file 'testharness.js'. */
+  function get_script_url() {
+    if (!('document' in global_scope)) {
+      return undefined;
+    }
+
+    var scripts = document.getElementsByTagName('script');
+    for (var i = 0; i < scripts.length; i++) {
+      var src;
+      if (scripts[i].src) {
+        src = scripts[i].src;
+      } else if (scripts[i].href) {
+        //SVG case
+        src = scripts[i].href.baseVal;
+      }
+
+      var matches = src && src.match(/^(.*\/|)testharness\.js$/);
+      if (matches) {
+        return src;
+      }
+    }
+    return undefined;
+  }
+
+  /** Returns the <title> or filename or "Untitled" */
+  function get_title() {
+    if ('document' in global_scope) {
+      //Don't use document.title to work around an Opera bug in XHTML documents
+      var title = document.getElementsByTagName('title')[0];
+      if (title && title.firstChild && title.firstChild.data) {
+        return title.firstChild.data;
+      }
+    }
+    if ('META_TITLE' in global_scope && META_TITLE) {
+      return META_TITLE;
+    }
+    if ('location' in global_scope) {
+      return location.pathname.substring(
+        location.pathname.lastIndexOf('/') + 1,
+        location.pathname.indexOf('.')
+      );
+    }
+    return 'Untitled';
+  }
+
+  function supports_post_message(w) {
+    var supports;
+    var type;
+    // Given IE implements postMessage across nested iframes but not across
+    // windows or tabs, you can't infer cross-origin communication from the presence
+    // of postMessage on the current window object only.
+    //
+    // Touching the postMessage prop on a window can throw if the window is
+    // not from the same origin AND post message is not supported in that
+    // browser. So just doing an existence test here won't do, you also need
+    // to wrap it in a try..catch block.
+    try {
+      type = typeof w.postMessage;
+      if (type === 'function') {
+        supports = true;
+      }
+
+      // IE8 supports postMessage, but implements it as a host object which
+      // returns "object" as its `typeof`.
+      else if (type === 'object') {
+        supports = true;
+      }
+
+      // This is the case where postMessage isn't supported AND accessing a
+      // window property across origins does NOT throw (e.g. old Safari browser).
+      else {
+        supports = false;
+      }
+    } catch (e) {
+      // This is the case where postMessage isn't supported AND accessing a
+      // window property across origins throws (e.g. old Firefox browser).
+      supports = false;
+    }
+    return supports;
+  }
+
+  /**
+   * Setup globals
+   */
+
+  var tests = new Tests();
+
+  if (global_scope.addEventListener) {
+    var error_handler = function(e) {
+      if (tests.tests.length === 0 && !tests.allow_uncaught_exception) {
+        tests.set_file_is_test();
+      }
+
+      var stack;
+      if (e.error && e.error.stack) {
+        stack = e.error.stack;
+      } else {
+        stack = e.filename + ':' + e.lineno + ':' + e.colno;
+      }
+
+      if (tests.file_is_test) {
+        var test = tests.tests[0];
+        if (test.phase >= test.phases.HAS_RESULT) {
+          return;
+        }
+        test.set_status(test.FAIL, e.message, stack);
+        test.phase = test.phases.HAS_RESULT;
+        // The following function invocation is superfluous.
+        // TODO: Remove.
+        test.done();
+      } else if (!tests.allow_uncaught_exception) {
+        tests.status.status = tests.status.ERROR;
+        tests.status.message = e.message;
+        tests.status.stack = stack;
+      }
+      done();
+    };
+
+    addEventListener('error', error_handler, false);
+    addEventListener(
+      'unhandledrejection',
+      function(e) {
+        error_handler(e.reason);
+      },
+      false
+    );
+  }
+
+  test_environment.on_tests_ready();
+
+  /**
+   * Stylesheet
+   */
+  var stylesheetContent =
+    '\
 html {\
     font-family:DejaVu Sans, Bitstream Vera Sans, Arial, Sans;\
 }\
@@ -3394,7 +3687,6 @@ span.timeout {\
 span.ok, span.timeout, span.error {\
     font-variant:small-caps;\
 }\
-";
-
+';
 })(this);
 // vim: set expandtab shiftwidth=4 tabstop=4:
diff --git a/test/fixtures/wpt/resources/testharnessreport.js b/test/fixtures/wpt/resources/testharnessreport.js
index e5cb40fe0ef652..cb9381ffbe3944 100644
--- a/test/fixtures/wpt/resources/testharnessreport.js
+++ b/test/fixtures/wpt/resources/testharnessreport.js
@@ -15,26 +15,33 @@
  */
 
 function dump_test_results(tests, status) {
-    var results_element = document.createElement("script");
-    results_element.type = "text/json";
-    results_element.id = "__testharness__results__";
-    var test_results = tests.map(function(x) {
-        return {name:x.name, status:x.status, message:x.message, stack:x.stack}
-    });
-    var data = {test:window.location.href,
-                tests:test_results,
-                status: status.status,
-                message: status.message,
-                stack: status.stack};
-    results_element.textContent = JSON.stringify(data);
+  var results_element = document.createElement('script');
+  results_element.type = 'text/json';
+  results_element.id = '__testharness__results__';
+  var test_results = tests.map(function(x) {
+    return {
+      name: x.name,
+      status: x.status,
+      message: x.message,
+      stack: x.stack
+    };
+  });
+  var data = {
+    test: window.location.href,
+    tests: test_results,
+    status: status.status,
+    message: status.message,
+    stack: status.stack
+  };
+  results_element.textContent = JSON.stringify(data);
 
-    // To avoid a HierarchyRequestError with XML documents, ensure that 'results_element'
-    // is inserted at a location that results in a valid document.
-    var parent = document.body
-        ? document.body                 // <body> is required in XHTML documents
-        : document.documentElement;     // fallback for optional <body> in HTML5, SVG, etc.
+  // To avoid a HierarchyRequestError with XML documents, ensure that 'results_element'
+  // is inserted at a location that results in a valid document.
+  var parent = document.body
+    ? document.body // <body> is required in XHTML documents
+    : document.documentElement; // fallback for optional <body> in HTML5, SVG, etc.
 
-    parent.appendChild(results_element);
+  parent.appendChild(results_element);
 }
 
 add_completion_callback(dump_test_results);
@@ -45,13 +52,12 @@ add_completion_callback(dump_test_results);
  * rendering of results
  */
 try {
-    if (window.opener && "testharness_properties" in window.opener) {
-        /* If we pass the testharness_properties object as-is here without
-         * JSON stringifying and reparsing it, IE fails & emits the message
-         * "Could not complete the operation due to error 80700019".
-         */
-        setup(JSON.parse(JSON.stringify(window.opener.testharness_properties)));
-    }
-} catch (e) {
-}
+  if (window.opener && 'testharness_properties' in window.opener) {
+    /* If we pass the testharness_properties object as-is here without
+     * JSON stringifying and reparsing it, IE fails & emits the message
+     * "Could not complete the operation due to error 80700019".
+     */
+    setup(JSON.parse(JSON.stringify(window.opener.testharness_properties)));
+  }
+} catch (e) {}
 // vim: set expandtab shiftwidth=4 tabstop=4:
diff --git a/test/fixtures/wpt/resources/webidl2/index.js b/test/fixtures/wpt/resources/webidl2/index.js
index 09f9eb46aa78f4..87fc751bce1394 100644
--- a/test/fixtures/wpt/resources/webidl2/index.js
+++ b/test/fixtures/wpt/resources/webidl2/index.js
@@ -1 +1 @@
-module.exports = require("./lib/webidl2.js");
+module.exports = require('./lib/webidl2.js');
diff --git a/test/fixtures/wpt/resources/webidl2/lib/webidl2.js b/test/fixtures/wpt/resources/webidl2/lib/webidl2.js
index ef519c09df6d6d..5c81b73f7edf19 100644
--- a/test/fixtures/wpt/resources/webidl2/lib/webidl2.js
+++ b/test/fixtures/wpt/resources/webidl2/lib/webidl2.js
@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 (() => {
   // These regular expressions use the sticky flag so they will only match at
@@ -6,125 +6,121 @@
   const tokenRe = {
     // This expression uses a lookahead assertion to catch false matches
     // against integers early.
-    "float": /-?(?=[0-9]*\.|[0-9]+[eE])(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/y,
-    "integer": /-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/y,
-    "identifier": /_?[A-Za-z][0-9A-Z_a-z-]*/y,
-    "string": /"[^"]*"/y,
-    "whitespace": /[\t\n\r ]+/y,
-    "comment": /((\/(\/.*|\*([^*]|\*[^\/])*\*\/)[\t\n\r ]*)+)/y,
-    "other": /[^\t\n\r 0-9A-Za-z]/y
+    float: /-?(?=[0-9]*\.|[0-9]+[eE])(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/y,
+    integer: /-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/y,
+    identifier: /_?[A-Za-z][0-9A-Z_a-z-]*/y,
+    string: /"[^"]*"/y,
+    whitespace: /[\t\n\r ]+/y,
+    comment: /((\/(\/.*|\*([^*]|\*[^\/])*\*\/)[\t\n\r ]*)+)/y,
+    other: /[^\t\n\r 0-9A-Za-z]/y
   };
 
-  const stringTypes = [
-    "ByteString",
-    "DOMString",
-    "USVString"
-  ];
+  const stringTypes = ['ByteString', 'DOMString', 'USVString'];
 
   const argumentNameKeywords = [
-    "attribute",
-    "callback",
-    "const",
-    "deleter",
-    "dictionary",
-    "enum",
-    "getter",
-    "includes",
-    "inherit",
-    "interface",
-    "iterable",
-    "maplike",
-    "namespace",
-    "partial",
-    "required",
-    "setlike",
-    "setter",
-    "static",
-    "stringifier",
-    "typedef",
-    "unrestricted"
+    'attribute',
+    'callback',
+    'const',
+    'deleter',
+    'dictionary',
+    'enum',
+    'getter',
+    'includes',
+    'inherit',
+    'interface',
+    'iterable',
+    'maplike',
+    'namespace',
+    'partial',
+    'required',
+    'setlike',
+    'setter',
+    'static',
+    'stringifier',
+    'typedef',
+    'unrestricted'
   ];
 
   const nonRegexTerminals = [
-    "FrozenArray",
-    "Infinity",
-    "NaN",
-    "Promise",
-    "boolean",
-    "byte",
-    "double",
-    "false",
-    "float",
-    "implements",
-    "legacyiterable",
-    "long",
-    "mixin",
-    "null",
-    "octet",
-    "optional",
-    "or",
-    "readonly",
-    "record",
-    "sequence",
-    "short",
-    "true",
-    "unsigned",
-    "void"
+    'FrozenArray',
+    'Infinity',
+    'NaN',
+    'Promise',
+    'boolean',
+    'byte',
+    'double',
+    'false',
+    'float',
+    'implements',
+    'legacyiterable',
+    'long',
+    'mixin',
+    'null',
+    'octet',
+    'optional',
+    'or',
+    'readonly',
+    'record',
+    'sequence',
+    'short',
+    'true',
+    'unsigned',
+    'void'
   ].concat(argumentNameKeywords, stringTypes);
 
   const punctuations = [
-    "(",
-    ")",
-    ",",
-    "-Infinity",
-    "...",
-    ":",
-    ";",
-    "<",
-    "=",
-    ">",
-    "?",
-    "[",
-    "]",
-    "{",
-    "}"
+    '(',
+    ')',
+    ',',
+    '-Infinity',
+    '...',
+    ':',
+    ';',
+    '<',
+    '=',
+    '>',
+    '?',
+    '[',
+    ']',
+    '{',
+    '}'
   ];
 
   function tokenise(str) {
     const tokens = [];
     let lastIndex = 0;
-    let trivia = "";
+    let trivia = '';
     while (lastIndex < str.length) {
       const nextChar = str.charAt(lastIndex);
       let result = -1;
 
       if (/[\t\n\r ]/.test(nextChar)) {
-        result = attemptTokenMatch("whitespace", { noFlushTrivia: true });
+        result = attemptTokenMatch('whitespace', { noFlushTrivia: true });
       } else if (nextChar === '/') {
-        result = attemptTokenMatch("comment", { noFlushTrivia: true });
+        result = attemptTokenMatch('comment', { noFlushTrivia: true });
       }
 
       if (result !== -1) {
         trivia += tokens.pop().value;
       } else if (/[-0-9.]/.test(nextChar)) {
-        result = attemptTokenMatch("float");
+        result = attemptTokenMatch('float');
         if (result === -1) {
-          result = attemptTokenMatch("integer");
+          result = attemptTokenMatch('integer');
         }
       } else if (/[A-Z_a-z]/.test(nextChar)) {
-        result = attemptTokenMatch("identifier");
+        result = attemptTokenMatch('identifier');
         const token = tokens[tokens.length - 1];
         if (result !== -1 && nonRegexTerminals.includes(token.value)) {
           token.type = token.value;
         }
       } else if (nextChar === '"') {
-        result = attemptTokenMatch("string");
+        result = attemptTokenMatch('string');
       }
 
       for (const punctuation of punctuations) {
         if (str.startsWith(punctuation, lastIndex)) {
           tokens.push({ type: punctuation, value: punctuation, trivia });
-          trivia = "";
+          trivia = '';
           lastIndex += punctuation.length;
           result = lastIndex;
           break;
@@ -133,10 +129,10 @@
 
       // other as the last try
       if (result === -1) {
-        result = attemptTokenMatch("other");
+        result = attemptTokenMatch('other');
       }
       if (result === -1) {
-        throw new Error("Token stream not progressing");
+        throw new Error('Token stream not progressing');
       }
       lastIndex = result;
     }
@@ -149,7 +145,7 @@
       if (result) {
         tokens.push({ type, value: result[0], trivia });
         if (!noFlushTrivia) {
-          trivia = "";
+          trivia = '';
         }
         return re.lastIndex;
       }
@@ -168,7 +164,9 @@
     toString() {
       const escapedInput = JSON.stringify(this.input);
       const tokens = JSON.stringify(this.tokens, null, 4);
-      return `${this.message}, line ${this.line} (tokens: ${escapedInput})\n${tokens}`;
+      return `${this.message}, line ${
+        this.line
+      } (tokens: ${escapedInput})\n${tokens}`;
     }
   }
 
@@ -178,14 +176,14 @@
     const names = new Map();
     let current = null;
 
-    const FLOAT = "float";
-    const INT = "integer";
-    const ID = "identifier";
-    const STR = "string";
-    const OTHER = "other";
+    const FLOAT = 'float';
+    const INT = 'integer';
+    const ID = 'identifier';
+    const STR = 'string';
+    const OTHER = 'other';
 
     const EMPTY_OPERATION = Object.freeze({
-      type: "operation",
+      type: 'operation',
       getter: false,
       setter: false,
       deleter: false,
@@ -205,27 +203,36 @@
       const maxTokens = 5;
       const tok = tokens
         .slice(consume_position, consume_position + maxTokens)
-        .map(t => t.trivia + t.value).join("");
+        .map((t) => t.trivia + t.value)
+        .join('');
       // Count newlines preceding the actual erroneous token
       if (tokens.length) {
-        line += count(tokens[consume_position].trivia, "\n");
+        line += count(tokens[consume_position].trivia, '\n');
       }
 
       let message;
       if (current) {
-        message = `Got an error during or right after parsing \`${current.partial ? "partial " : ""}${current.type} ${current.name}\`: ${str}`
-      }
-      else {
+        message = `Got an error during or right after parsing \`${
+          current.partial ? 'partial ' : ''
+        }${current.type} ${current.name}\`: ${str}`;
+      } else {
         // throwing before any valid definition
         message = `Got an error before parsing any named definition: ${str}`;
       }
 
-      throw new WebIDLParseError(message, line, tok, tokens.slice(0, maxTokens));
+      throw new WebIDLParseError(
+        message,
+        line,
+        tok,
+        tokens.slice(0, maxTokens)
+      );
     }
 
     function sanitize_name(name, type) {
       if (names.has(name)) {
-        error(`The name "${name}" of type "${names.get(name)}" is already seen`);
+        error(
+          `The name "${name}" of type "${names.get(name)}" is already seen`
+        );
       }
       names.set(name, type);
       return name;
@@ -234,7 +241,10 @@
     let consume_position = 0;
 
     function probe(type) {
-      return tokens.length > consume_position && tokens[consume_position].type === type;
+      return (
+        tokens.length > consume_position &&
+        tokens[consume_position].type === type
+      );
     }
 
     function consume(...candidates) {
@@ -243,7 +253,7 @@
         if (!probe(type)) continue;
         const token = tokens[consume_position];
         consume_position++;
-        line += count(token.trivia, "\n");
+        line += count(token.trivia, '\n');
         return token;
       }
     }
@@ -255,7 +265,7 @@
     function unconsume(position) {
       while (consume_position > position) {
         consume_position--;
-        line -= count(tokens[consume_position].trivia, "\n");
+        line -= count(tokens[consume_position].trivia, '\n');
       }
     }
 
@@ -268,80 +278,86 @@
     }
 
     function integer_type() {
-      let ret = "";
-      if (consume("unsigned")) ret = "unsigned ";
-      if (consume("short")) return ret + "short";
-      if (consume("long")) {
-        ret += "long";
-        if (consume("long")) return ret + " long";
+      let ret = '';
+      if (consume('unsigned')) ret = 'unsigned ';
+      if (consume('short')) return ret + 'short';
+      if (consume('long')) {
+        ret += 'long';
+        if (consume('long')) return ret + ' long';
         return ret;
       }
-      if (ret) error("Failed to parse integer type");
+      if (ret) error('Failed to parse integer type');
     }
 
     function float_type() {
-      let ret = "";
-      if (consume("unrestricted")) ret = "unrestricted ";
-      if (consume("float")) return ret + "float";
-      if (consume("double")) return ret + "double";
-      if (ret) error("Failed to parse float type");
+      let ret = '';
+      if (consume('unrestricted')) ret = 'unrestricted ';
+      if (consume('float')) return ret + 'float';
+      if (consume('double')) return ret + 'double';
+      if (ret) error('Failed to parse float type');
     }
 
     function primitive_type() {
       const num_type = integer_type() || float_type();
       if (num_type) return num_type;
-      if (consume("boolean")) return "boolean";
-      if (consume("byte")) return "byte";
-      if (consume("octet")) return "octet";
+      if (consume('boolean')) return 'boolean';
+      if (consume('byte')) return 'byte';
+      if (consume('octet')) return 'octet';
     }
 
     function const_value() {
-      if (consume("true")) return { type: "boolean", value: true };
-      if (consume("false")) return { type: "boolean", value: false };
-      if (consume("null")) return { type: "null" };
-      if (consume("Infinity")) return { type: "Infinity", negative: false };
-      if (consume("-Infinity")) return { type: "Infinity", negative: true };
-      if (consume("NaN")) return { type: "NaN" };
+      if (consume('true')) return { type: 'boolean', value: true };
+      if (consume('false')) return { type: 'boolean', value: false };
+      if (consume('null')) return { type: 'null' };
+      if (consume('Infinity')) return { type: 'Infinity', negative: false };
+      if (consume('-Infinity')) return { type: 'Infinity', negative: true };
+      if (consume('NaN')) return { type: 'NaN' };
       const ret = consume(FLOAT, INT);
-      if (ret) return { type: "number", value: ret.value };
+      if (ret) return { type: 'number', value: ret.value };
     }
 
     function type_suffix(obj) {
-      obj.nullable = !!consume("?");
-      if (probe("?")) error("Can't nullable more than once");
+      obj.nullable = !!consume('?');
+      if (probe('?')) error("Can't nullable more than once");
     }
 
     function generic_type(typeName) {
-      const name = consume("FrozenArray", "Promise", "sequence", "record");
+      const name = consume('FrozenArray', 'Promise', 'sequence', 'record');
       if (!name) {
         return;
       }
       const ret = { generic: name.type };
-      consume("<") || error(`No opening bracket after ${name.type}`);
+      consume('<') || error(`No opening bracket after ${name.type}`);
       switch (name.type) {
-        case "Promise":
-          if (probe("[")) error("Promise type cannot have extended attribute");
+        case 'Promise':
+          if (probe('[')) error('Promise type cannot have extended attribute');
           ret.idlType = return_type(typeName);
           break;
-        case "sequence":
-        case "FrozenArray":
+        case 'sequence':
+        case 'FrozenArray':
           ret.idlType = type_with_extended_attributes(typeName);
           break;
-        case "record":
-          if (probe("[")) error("Record key cannot have extended attribute");
+        case 'record':
+          if (probe('[')) error('Record key cannot have extended attribute');
           ret.idlType = [];
           const keyType = consume(...stringTypes);
           if (!keyType) error(`Record key must be a string type`);
-          ret.idlType.push(Object.assign({ type: typeName }, EMPTY_IDLTYPE, { idlType: keyType.value }));
-          consume(",") || error("Missing comma after record key type");
-          const valueType = type_with_extended_attributes(typeName) || error("Error parsing generic type record");
+          ret.idlType.push(
+            Object.assign({ type: typeName }, EMPTY_IDLTYPE, {
+              idlType: keyType.value
+            })
+          );
+          consume(',') || error('Missing comma after record key type');
+          const valueType =
+            type_with_extended_attributes(typeName) ||
+            error('Error parsing generic type record');
           ret.idlType.push(valueType);
           break;
       }
       if (!ret.idlType) error(`Error parsing generic type ${name.type}`);
-      consume(">") || error(`Missing closing bracket after ${name.type}`);
-      if (name.type === "Promise" && probe("?")) {
-        error("Promise type cannot be nullable");
+      consume('>') || error(`Missing closing bracket after ${name.type}`);
+      if (name.type === 'Promise' && probe('?')) {
+        error('Promise type cannot be nullable');
       }
       type_suffix(ret);
       return ret;
@@ -357,28 +373,34 @@
       let name;
       if (prim) {
         ret.idlType = prim;
-      } else if (name = consume(ID, ...stringTypes)) {
+      } else if ((name = consume(ID, ...stringTypes))) {
         ret.idlType = name.value;
-        if (probe("<")) error(`Unsupported generic type ${name.value}`);
+        if (probe('<')) error(`Unsupported generic type ${name.value}`);
       } else {
         return;
       }
       type_suffix(ret);
-      if (ret.nullable && ret.idlType === "any") error("Type any cannot be made nullable");
+      if (ret.nullable && ret.idlType === 'any')
+        error('Type any cannot be made nullable');
       return ret;
     }
 
     function union_type(typeName) {
-      if (!consume("(")) return;
-      const ret = Object.assign({ type: typeName || null }, EMPTY_IDLTYPE, { union: true, idlType: [] });
+      if (!consume('(')) return;
+      const ret = Object.assign({ type: typeName || null }, EMPTY_IDLTYPE, {
+        union: true,
+        idlType: []
+      });
       do {
-        const typ = type_with_extended_attributes() || error("No type after open parenthesis or 'or' in union type");
+        const typ =
+          type_with_extended_attributes() ||
+          error("No type after open parenthesis or 'or' in union type");
         ret.idlType.push(typ);
-      } while (consume("or"));
+      } while (consume('or'));
       if (ret.idlType.length < 2) {
-        error("At least two types are expected in a union type but found less");
+        error('At least two types are expected in a union type but found less');
       }
-      if (!consume(")")) error("Unterminated union type");
+      if (!consume(')')) error('Unterminated union type');
       type_suffix(ret);
       return ret;
     }
@@ -398,16 +420,16 @@
       const start_position = consume_position;
       const ret = { optional: false, variadic: false, default: null };
       ret.extAttrs = extended_attrs();
-      const opt_token = consume("optional");
+      const opt_token = consume('optional');
       if (opt_token) {
         ret.optional = true;
       }
-      ret.idlType = type_with_extended_attributes("argument-type");
+      ret.idlType = type_with_extended_attributes('argument-type');
       if (!ret.idlType) {
         unconsume(start_position);
         return;
       }
-      if (!ret.optional && consume("...")) {
+      if (!ret.optional && consume('...')) {
         ret.variadic = true;
       }
       const name = consume(ID, ...argumentNameKeywords);
@@ -429,8 +451,8 @@
       if (!arg) return ret;
       ret.push(arg);
       while (true) {
-        if (!consume(",")) return ret;
-        const nxt = argument() || error("Trailing comma in arguments list");
+        if (!consume(',')) return ret;
+        const nxt = argument() || error('Trailing comma in arguments list');
         ret.push(nxt);
       }
     }
@@ -441,10 +463,10 @@
       const ret = {
         name: name.value,
         arguments: null,
-        type: "extended-attribute",
+        type: 'extended-attribute',
         rhs: null
       };
-      const eq = consume("=");
+      const eq = consume('=');
       if (eq) {
         ret.rhs = consume(ID, FLOAT, INT, STR);
         if (ret.rhs) {
@@ -452,21 +474,22 @@
           ret.rhs.trivia = undefined;
         }
       }
-      if (consume("(")) {
+      if (consume('(')) {
         if (eq && !ret.rhs) {
           // [Exposed=(Window,Worker)]
           ret.rhs = {
-            type: "identifier-list",
+            type: 'identifier-list',
             value: identifiers()
           };
-        }
-        else {
+        } else {
           // [NamedConstructor=Audio(DOMString src)] or [Constructor(DOMString str)]
           ret.arguments = argument_list();
         }
-        consume(")") || error("Unexpected token in extended attribute argument list");
+        consume(')') ||
+          error('Unexpected token in extended attribute argument list');
       }
-      if (eq && !ret.rhs) error("No right hand side to extended attribute assignment");
+      if (eq && !ret.rhs)
+        error('No right hand side to extended attribute assignment');
       return ret;
     }
 
@@ -474,25 +497,29 @@
     // seems to be used
     function extended_attrs() {
       const eas = [];
-      if (!consume("[")) return eas;
-      eas[0] = simple_extended_attr() || error("Extended attribute with not content");
-      while (consume(",")) {
-        eas.push(simple_extended_attr() || error("Trailing comma in extended attribute"));
+      if (!consume('[')) return eas;
+      eas[0] =
+        simple_extended_attr() || error('Extended attribute with not content');
+      while (consume(',')) {
+        eas.push(
+          simple_extended_attr() ||
+            error('Trailing comma in extended attribute')
+        );
       }
-      consume("]") || error("No end of extended attribute");
+      consume(']') || error('No end of extended attribute');
       return eas;
     }
 
     function default_() {
-      if (consume("=")) {
+      if (consume('=')) {
         const def = const_value();
         if (def) {
           return def;
-        } else if (consume("[")) {
-          if (!consume("]")) error("Default sequence value must be empty");
-          return { type: "sequence", value: [] };
+        } else if (consume('[')) {
+          if (!consume(']')) error('Default sequence value must be empty');
+          return { type: 'sequence', value: [] };
         } else {
-          const str = consume(STR) || error("No value for default");
+          const str = consume(STR) || error('No value for default');
           str.value = str.value.slice(1, -1);
           // No trivia exposure yet
           str.trivia = undefined;
@@ -502,28 +529,30 @@
     }
 
     function const_() {
-      if (!consume("const")) return;
-      const ret = { type: "const", nullable: false };
+      if (!consume('const')) return;
+      const ret = { type: 'const', nullable: false };
       let typ = primitive_type();
       if (!typ) {
-        typ = consume(ID) || error("No type for const");
+        typ = consume(ID) || error('No type for const');
         typ = typ.value;
       }
-      ret.idlType = Object.assign({ type: "const-type" }, EMPTY_IDLTYPE, { idlType: typ });
+      ret.idlType = Object.assign({ type: 'const-type' }, EMPTY_IDLTYPE, {
+        idlType: typ
+      });
       type_suffix(ret);
-      const name = consume(ID) || error("No name for const");
+      const name = consume(ID) || error('No name for const');
       ret.name = name.value;
-      consume("=") || error("No value assignment for const");
+      consume('=') || error('No value assignment for const');
       const cnt = const_value();
       if (cnt) ret.value = cnt;
-      else error("No value for const");
-      consume(";") || error("Unterminated const");
+      else error('No value for const');
+      consume(';') || error('Unterminated const');
       return ret;
     }
 
     function inheritance() {
-      if (consume(":")) {
-        const inh = consume(ID) || error("No type in inheritance");
+      if (consume(':')) {
+        const inh = consume(ID) || error('No type in inheritance');
         return inh.value;
       }
     }
@@ -533,48 +562,51 @@
       const name = consume(ID);
       ret.name = name ? unescape(name.value) : null;
       ret.escapedName = name ? name.value : null;
-      consume("(") || error("Invalid operation");
+      consume('(') || error('Invalid operation');
       ret.arguments = argument_list();
-      consume(")") || error("Unterminated operation");
-      consume(";") || error("Unterminated operation");
+      consume(')') || error('Unterminated operation');
+      consume(';') || error('Unterminated operation');
       return ret;
     }
 
     function callback() {
       let ret;
-      if (!consume("callback")) return;
-      const tok = consume("interface");
+      if (!consume('callback')) return;
+      const tok = consume('interface');
       if (tok) {
-        ret = interface_rest(false, "callback interface");
+        ret = interface_rest(false, 'callback interface');
         return ret;
       }
-      const name = consume(ID) || error("No name for callback");
-      ret = current = { type: "callback", name: sanitize_name(name.value, "callback") };
-      consume("=") || error("No assignment in callback");
-      ret.idlType = return_type() || error("Missing return type");
-      consume("(") || error("No arguments in callback");
+      const name = consume(ID) || error('No name for callback');
+      ret = current = {
+        type: 'callback',
+        name: sanitize_name(name.value, 'callback')
+      };
+      consume('=') || error('No assignment in callback');
+      ret.idlType = return_type() || error('Missing return type');
+      consume('(') || error('No arguments in callback');
       ret.arguments = argument_list();
-      consume(")") || error("Unterminated callback");
-      consume(";") || error("Unterminated callback");
+      consume(')') || error('Unterminated callback');
+      consume(';') || error('Unterminated callback');
       return ret;
     }
 
     function attribute({ noInherit = false, readonly = false } = {}) {
       const start_position = consume_position;
       const ret = {
-        type: "attribute",
+        type: 'attribute',
         static: false,
         stringifier: false,
         inherit: false,
         readonly: false
       };
-      if (!noInherit && consume("inherit")) {
+      if (!noInherit && consume('inherit')) {
         ret.inherit = true;
       }
-      if (consume("readonly")) {
+      if (consume('readonly')) {
         ret.readonly = true;
-      } else if (readonly && probe("attribute")) {
-        error("Attributes must be readonly in this context");
+      } else if (readonly && probe('attribute')) {
+        error('Attributes must be readonly in this context');
       }
       const rest = attribute_rest(ret);
       if (!rest) {
@@ -584,59 +616,67 @@
     }
 
     function attribute_rest(ret) {
-      if (!consume("attribute")) {
+      if (!consume('attribute')) {
         return;
       }
-      ret.idlType = type_with_extended_attributes("attribute-type") || error("No type in attribute");
-      if (ret.idlType.generic === "sequence") error("Attributes cannot accept sequence types");
-      if (ret.idlType.generic === "record") error("Attributes cannot accept record types");
-      const name = consume(ID, "required") || error("No name in attribute");
+      ret.idlType =
+        type_with_extended_attributes('attribute-type') ||
+        error('No type in attribute');
+      if (ret.idlType.generic === 'sequence')
+        error('Attributes cannot accept sequence types');
+      if (ret.idlType.generic === 'record')
+        error('Attributes cannot accept record types');
+      const name = consume(ID, 'required') || error('No name in attribute');
       ret.name = unescape(name.value);
       ret.escapedName = name.value;
-      consume(";") || error("Unterminated attribute");
+      consume(';') || error('Unterminated attribute');
       return ret;
     }
 
     function return_type(typeName) {
-      const typ = type(typeName || "return-type");
+      const typ = type(typeName || 'return-type');
       if (typ) {
         return typ;
       }
-      if (consume("void")) {
-        return Object.assign({ type: "return-type" }, EMPTY_IDLTYPE, { idlType: "void" });
+      if (consume('void')) {
+        return Object.assign({ type: 'return-type' }, EMPTY_IDLTYPE, {
+          idlType: 'void'
+        });
       }
     }
 
     function operation({ regular = false } = {}) {
       const ret = Object.assign({}, EMPTY_OPERATION);
       while (!regular) {
-        if (consume("getter")) ret.getter = true;
-        else if (consume("setter")) ret.setter = true;
-        else if (consume("deleter")) ret.deleter = true;
+        if (consume('getter')) ret.getter = true;
+        else if (consume('setter')) ret.setter = true;
+        else if (consume('deleter')) ret.deleter = true;
         else break;
       }
-      ret.idlType = return_type() || error("Missing return type");
+      ret.idlType = return_type() || error('Missing return type');
       operation_rest(ret);
       return ret;
     }
 
     function static_member() {
-      if (!consume("static")) return;
-      const member = attribute({ noInherit: true }) ||
+      if (!consume('static')) return;
+      const member =
+        attribute({ noInherit: true }) ||
         operation({ regular: true }) ||
-        error("No body in static member");
+        error('No body in static member');
       member.static = true;
       return member;
     }
 
     function stringifier() {
-      if (!consume("stringifier")) return;
-      if (consume(";")) {
+      if (!consume('stringifier')) return;
+      if (consume(';')) {
         return Object.assign({}, EMPTY_OPERATION, { stringifier: true });
       }
-      const member = attribute({ noInherit: true }) ||
+      const member =
+        attribute({ noInherit: true }) ||
         operation({ regular: true }) ||
-        error("Unterminated stringifier");
+        error('Unterminated stringifier');
       member.stringifier = true;
       return member;
     }
@@ -646,11 +686,11 @@
       const id = consume(ID);
       if (id) {
         arr.push(id.value);
-      }
-      else error("Expected identifiers but not found");
+      } else error('Expected identifiers but not found');
       while (true) {
-        if (consume(",")) {
-          const name = consume(ID) || error("Trailing comma in identifiers list");
+        if (consume(',')) {
+          const name =
+            consume(ID) || error('Trailing comma in identifiers list');
           arr.push(name.value);
         } else break;
       }
@@ -658,26 +698,28 @@
     }
 
     function iterable_type() {
-      if (consume("iterable")) return "iterable";
-      else if (consume("legacyiterable")) return "legacyiterable";
-      else if (consume("maplike")) return "maplike";
-      else if (consume("setlike")) return "setlike";
+      if (consume('iterable')) return 'iterable';
+      else if (consume('legacyiterable')) return 'legacyiterable';
+      else if (consume('maplike')) return 'maplike';
+      else if (consume('setlike')) return 'setlike';
       else return;
     }
 
     function readonly_iterable_type() {
-      if (consume("maplike")) return "maplike";
-      else if (consume("setlike")) return "setlike";
+      if (consume('maplike')) return 'maplike';
+      else if (consume('setlike')) return 'setlike';
       else return;
     }
 
     function iterable() {
       const start_position = consume_position;
       const ret = { type: null, idlType: null, readonly: false };
-      if (consume("readonly")) {
+      if (consume('readonly')) {
         ret.readonly = true;
       }
-      const consumeItType = ret.readonly ? readonly_iterable_type : iterable_type;
+      const consumeItType = ret.readonly
+        ? readonly_iterable_type
+        : iterable_type;
 
       const ittype = consumeItType();
       if (!ittype) {
@@ -685,119 +727,127 @@
         return;
       }
 
-      const secondTypeRequired = ittype === "maplike";
-      const secondTypeAllowed = secondTypeRequired || ittype === "iterable";
+      const secondTypeRequired = ittype === 'maplike';
+      const secondTypeAllowed = secondTypeRequired || ittype === 'iterable';
       ret.type = ittype;
-      if (ret.type !== 'maplike' && ret.type !== 'setlike')
-        delete ret.readonly;
-      if (consume("<")) {
-        ret.idlType = [type_with_extended_attributes()] || error(`Error parsing ${ittype} declaration`);
+      if (ret.type !== 'maplike' && ret.type !== 'setlike') delete ret.readonly;
+      if (consume('<')) {
+        ret.idlType =
+          [type_with_extended_attributes()] ||
+          error(`Error parsing ${ittype} declaration`);
         if (secondTypeAllowed) {
-          if (consume(",")) {
+          if (consume(',')) {
             ret.idlType.push(type_with_extended_attributes());
-          }
-          else if (secondTypeRequired)
+          } else if (secondTypeRequired)
             error(`Missing second type argument in ${ittype} declaration`);
         }
-        if (!consume(">")) error(`Unterminated ${ittype} declaration`);
-        if (!consume(";")) error(`Missing semicolon after ${ittype} declaration`);
-      } else
-        error(`Error parsing ${ittype} declaration`);
+        if (!consume('>')) error(`Unterminated ${ittype} declaration`);
+        if (!consume(';'))
+          error(`Missing semicolon after ${ittype} declaration`);
+      } else error(`Error parsing ${ittype} declaration`);
 
       return ret;
     }
 
-    function interface_rest(isPartial, typeName = "interface") {
-      const name = consume(ID) || error("No name for interface");
+    function interface_rest(isPartial, typeName = 'interface') {
+      const name = consume(ID) || error('No name for interface');
       const mems = [];
-      const ret = current = {
+      const ret = (current = {
         type: typeName,
-        name: isPartial ? name.value : sanitize_name(name.value, "interface"),
+        name: isPartial ? name.value : sanitize_name(name.value, 'interface'),
         partial: isPartial,
         members: mems
-      };
+      });
       if (!isPartial) ret.inheritance = inheritance() || null;
-      consume("{") || error("Bodyless interface");
+      consume('{') || error('Bodyless interface');
       while (true) {
-        if (consume("}")) {
-          consume(";") || error("Missing semicolon after interface");
+        if (consume('}')) {
+          consume(';') || error('Missing semicolon after interface');
           return ret;
         }
         const ea = extended_attrs();
-        const mem = const_() ||
+        const mem =
+          const_() ||
           static_member() ||
           stringifier() ||
           iterable() ||
           attribute() ||
           operation() ||
-          error("Unknown member");
+          error('Unknown member');
         mem.extAttrs = ea;
         ret.members.push(mem);
       }
     }
 
     function mixin_rest(isPartial) {
-      if (!consume("mixin")) return;
-      const name = consume(ID) || error("No name for interface mixin");
+      if (!consume('mixin')) return;
+      const name = consume(ID) || error('No name for interface mixin');
       const mems = [];
-      const ret = current = {
-        type: "interface mixin",
-        name: isPartial ? name.value : sanitize_name(name.value, "interface mixin"),
+      const ret = (current = {
+        type: 'interface mixin',
+        name: isPartial
+          ? name.value
+          : sanitize_name(name.value, 'interface mixin'),
         partial: isPartial,
         members: mems
-      };
-      consume("{") || error("Bodyless interface mixin");
+      });
+      consume('{') || error('Bodyless interface mixin');
       while (true) {
-        if (consume("}")) {
-          consume(";") || error("Missing semicolon after interface mixin");
+        if (consume('}')) {
+          consume(';') || error('Missing semicolon after interface mixin');
           return ret;
         }
         const ea = extended_attrs();
-        const mem = const_() ||
+        const mem =
+          const_() ||
           stringifier() ||
           attribute({ noInherit: true }) ||
           operation({ regular: true }) ||
-          error("Unknown member");
+          error('Unknown member');
         mem.extAttrs = ea;
         ret.members.push(mem);
       }
     }
 
     function interface_(isPartial) {
-      if (!consume("interface")) return;
-      return mixin_rest(isPartial) ||
+      if (!consume('interface')) return;
+      return (
+        mixin_rest(isPartial) ||
         interface_rest(isPartial) ||
-        error("Interface has no proper body");
+        error('Interface has no proper body')
+      );
     }
 
     function namespace(isPartial) {
-      if (!consume("namespace")) return;
-      const name = consume(ID) || error("No name for namespace");
+      if (!consume('namespace')) return;
+      const name = consume(ID) || error('No name for namespace');
       const mems = [];
-      const ret = current = {
-        type: "namespace",
-        name: isPartial ? name.value : sanitize_name(name.value, "namespace"),
+      const ret = (current = {
+        type: 'namespace',
+        name: isPartial ? name.value : sanitize_name(name.value, 'namespace'),
         partial: isPartial,
         members: mems
-      };
-      consume("{") || error("Bodyless namespace");
+      });
+      consume('{') || error('Bodyless namespace');
       while (true) {
-        if (consume("}")) {
-          consume(";") || error("Missing semicolon after namespace");
+        if (consume('}')) {
+          consume(';') || error('Missing semicolon after namespace');
           return ret;
         }
         const ea = extended_attrs();
-        const mem = attribute({ noInherit: true, readonly: true }) ||
+        const mem =
+          attribute({ noInherit: true, readonly: true }) ||
           operation({ regular: true }) ||
-          error("Unknown member");
+          error('Unknown member');
         mem.extAttrs = ea;
         ret.members.push(mem);
       }
     }
 
     function partial() {
-      if (!consume("partial")) return;
-      const thing = dictionary(true) ||
+      if (!consume('partial')) return;
+      const thing =
+        dictionary(true) ||
         interface_(true) ||
         namespace(true) ||
         error("Partial doesn't apply to anything");
@@ -805,30 +855,32 @@
     }
 
     function dictionary(isPartial) {
-      if (!consume("dictionary")) return;
-      const name = consume(ID) || error("No name for dictionary");
+      if (!consume('dictionary')) return;
+      const name = consume(ID) || error('No name for dictionary');
       const mems = [];
-      const ret = current = {
-        type: "dictionary",
-        name: isPartial ? name.value : sanitize_name(name.value, "dictionary"),
+      const ret = (current = {
+        type: 'dictionary',
+        name: isPartial ? name.value : sanitize_name(name.value, 'dictionary'),
         partial: isPartial,
         members: mems
-      };
+      });
       if (!isPartial) ret.inheritance = inheritance() || null;
-      consume("{") || error("Bodyless dictionary");
+      consume('{') || error('Bodyless dictionary');
       while (true) {
-        if (consume("}")) {
-          consume(";") || error("Missing semicolon after dictionary");
+        if (consume('}')) {
+          consume(';') || error('Missing semicolon after dictionary');
           return ret;
         }
         const ea = extended_attrs();
-        const required = consume("required");
-        const typ = type_with_extended_attributes("dictionary-type") || error("No type for dictionary member");
-        const name = consume(ID) || error("No name for dictionary member");
+        const required = consume('required');
+        const typ =
+          type_with_extended_attributes('dictionary-type') ||
+          error('No type for dictionary member');
+        const name = consume(ID) || error('No name for dictionary member');
         const dflt = default_() || null;
-        if (required && dflt) error("Required member must not have a default");
+        if (required && dflt) error('Required member must not have a default');
         const member = {
-          type: "field",
+          type: 'field',
           name: unescape(name.value),
           escapedName: name.value,
           required: !!required,
@@ -837,49 +889,50 @@
           default: dflt
         };
         ret.members.push(member);
-        consume(";") || error("Unterminated dictionary member");
+        consume(';') || error('Unterminated dictionary member');
       }
     }
 
     function enum_() {
-      if (!consume("enum")) return;
-      const name = consume(ID) || error("No name for enum");
+      if (!consume('enum')) return;
+      const name = consume(ID) || error('No name for enum');
       const vals = [];
-      const ret = current = {
-        type: "enum",
-        name: sanitize_name(name.value, "enum"),
+      const ret = (current = {
+        type: 'enum',
+        name: sanitize_name(name.value, 'enum'),
         values: vals
-      };
-      consume("{") || error("No curly for enum");
+      });
+      consume('{') || error('No curly for enum');
       let value_expected = true;
       while (true) {
-        if (consume("}")) {
-          if (!ret.values.length) error("No value in enum");
-          consume(";") || error("No semicolon after enum");
+        if (consume('}')) {
+          if (!ret.values.length) error('No value in enum');
+          consume(';') || error('No semicolon after enum');
           return ret;
+        } else if (!value_expected) {
+          error('No comma between enum values');
         }
-        else if (!value_expected) {
-          error("No comma between enum values");
-        }
-        const val = consume(STR) || error("Unexpected value in enum");
+        const val = consume(STR) || error('Unexpected value in enum');
         val.value = val.value.slice(1, -1);
         // No trivia exposure yet
         val.trivia = undefined;
         ret.values.push(val);
-        value_expected = !!consume(",");
+        value_expected = !!consume(',');
       }
     }
 
     function typedef() {
-      if (!consume("typedef")) return;
+      if (!consume('typedef')) return;
       const ret = {
-        type: "typedef"
+        type: 'typedef'
       };
-      ret.idlType = type_with_extended_attributes("typedef-type") || error("No type in typedef");
-      const name = consume(ID) || error("No name in typedef");
-      ret.name = sanitize_name(name.value, "typedef");
+      ret.idlType =
+        type_with_extended_attributes('typedef-type') ||
+        error('No type in typedef');
+      const name = consume(ID) || error('No name in typedef');
+      ret.name = sanitize_name(name.value, 'typedef');
       current = ret;
-      consume(";") || error("Unterminated typedef");
+      consume(';') || error('Unterminated typedef');
       return ret;
     }
 
@@ -887,14 +940,14 @@
       const start_position = consume_position;
       const target = consume(ID);
       if (!target) return;
-      if (consume("implements")) {
+      if (consume('implements')) {
         const ret = {
-          type: "implements",
+          type: 'implements',
           target: target.value
         };
-        const imp = consume(ID) || error("Incomplete implements statement");
+        const imp = consume(ID) || error('Incomplete implements statement');
         ret.implements = imp.value;
-        consume(";") || error("No terminating ; for implements statement");
+        consume(';') || error('No terminating ; for implements statement');
         return ret;
       } else {
         // rollback
@@ -906,14 +959,14 @@
       const start_position = consume_position;
       const target = consume(ID);
       if (!target) return;
-      if (consume("includes")) {
+      if (consume('includes')) {
         const ret = {
-          type: "includes",
+          type: 'includes',
           target: target.value
         };
-        const imp = consume(ID) || error("Incomplete includes statement");
+        const imp = consume(ID) || error('Incomplete includes statement');
         ret.includes = imp.value;
-        consume(";") || error("No terminating ; for includes statement");
+        consume(';') || error('No terminating ; for includes statement');
         return ret;
       } else {
         // rollback
@@ -922,7 +975,8 @@
     }
 
     function definition() {
-      return callback() ||
+      return (
+        callback() ||
         interface_(false) ||
         partial() ||
         dictionary(false) ||
@@ -930,7 +984,8 @@
         typedef() ||
         implements_() ||
         includes() ||
-        namespace(false);
+        namespace(false)
+      );
     }
 
     function definitions() {
@@ -940,7 +995,7 @@
         const ea = extended_attrs();
         const def = definition();
         if (!def) {
-          if (ea.length) error("Stray extended attributes");
+          if (ea.length) error('Stray extended attributes');
           break;
         }
         def.extAttrs = ea;
@@ -949,7 +1004,7 @@
       return defs;
     }
     const res = definitions();
-    if (consume_position < tokens.length) error("Unrecognised tokens");
+    if (consume_position < tokens.length) error('Unrecognised tokens');
     return res;
   }
 
diff --git a/test/fixtures/wpt/resources/webidl2/lib/writer.js b/test/fixtures/wpt/resources/webidl2/lib/writer.js
index b3097a6f8a74e4..ae8b4fbcfb77b5 100644
--- a/test/fixtures/wpt/resources/webidl2/lib/writer.js
+++ b/test/fixtures/wpt/resources/webidl2/lib/writer.js
@@ -1,9 +1,9 @@
-"use strict";
+'use strict';
 
 (() => {
   function write(ast, opt = {}) {
-    const noop = str => str;
-    const optNames = "type".split(" ");
+    const noop = (str) => str;
+    const optNames = 'type'.split(' ');
     const context = [];
     for (const o of optNames) {
       if (!opt[o]) opt[o] = noop;
@@ -11,91 +11,95 @@
 
     function literal(it) {
       return it.value;
-    };
+    }
     function type(it) {
-      if (typeof it === "string") return opt.type(it); // XXX should maintain some context
+      if (typeof it === 'string') return opt.type(it); // XXX should maintain some context
       let ret = extended_attributes(it.extAttrs);
-      if (it.union) ret += `(${it.idlType.map(type).join(" or ")})`;
+      if (it.union) ret += `(${it.idlType.map(type).join(' or ')})`;
       else {
         if (it.generic) ret += `${it.generic}<`;
-        if (Array.isArray(it.idlType)) ret += it.idlType.map(type).join(", ");
+        if (Array.isArray(it.idlType)) ret += it.idlType.map(type).join(', ');
         else ret += type(it.idlType);
-        if (it.generic) ret += ">";
+        if (it.generic) ret += '>';
       }
-      if (it.nullable) ret += "?";
+      if (it.nullable) ret += '?';
 
       return ret;
-    };
+    }
     function const_value(it) {
       const tp = it.type;
-      if (tp === "boolean") return it.value ? "true" : "false";
-      else if (tp === "null") return "null";
-      else if (tp === "Infinity") return (it.negative ? "-" : "") + "Infinity";
-      else if (tp === "NaN") return "NaN";
-      else if (tp === "number") return it.value;
-      else if (tp === "sequence") return "[]";
+      if (tp === 'boolean') return it.value ? 'true' : 'false';
+      else if (tp === 'null') return 'null';
+      else if (tp === 'Infinity') return (it.negative ? '-' : '') + 'Infinity';
+      else if (tp === 'NaN') return 'NaN';
+      else if (tp === 'number') return it.value;
+      else if (tp === 'sequence') return '[]';
       else return `"${it.value}"`;
-    };
+    }
     function argument(arg) {
       let ret = extended_attributes(arg.extAttrs);
-      if (arg.optional) ret += "optional ";
+      if (arg.optional) ret += 'optional ';
       ret += type(arg.idlType);
-      if (arg.variadic) ret += "...";
+      if (arg.variadic) ret += '...';
       ret += ` ${arg.escapedName}`;
       if (arg.default) ret += ` = ${const_value(arg.default)}`;
       return ret;
-    };
+    }
     function make_ext_at(it) {
       context.unshift(it);
       let ret = it.name;
       if (it.rhs) {
-        if (it.rhs.type === "identifier-list") ret += `=(${it.rhs.value.join(",")})`;
+        if (it.rhs.type === 'identifier-list')
+          ret += `=(${it.rhs.value.join(',')})`;
         else ret += `=${it.rhs.value}`;
       }
-      if (it.arguments) ret += `(${it.arguments.length ? it.arguments.map(argument).join(",") : ""})`;
+      if (it.arguments)
+        ret += `(${
+          it.arguments.length ? it.arguments.map(argument).join(',') : ''
+        })`;
       context.shift(); // XXX need to add more contexts, but not more than needed for ReSpec
       return ret;
-    };
+    }
     function extended_attributes(eats) {
-      if (!eats || !eats.length) return "";
-      return `[${eats.map(make_ext_at).join(", ")}]`;
-    };
+      if (!eats || !eats.length) return '';
+      return `[${eats.map(make_ext_at).join(', ')}]`;
+    }
 
-    const modifiers = "getter setter deleter stringifier static".split(" ");
+    const modifiers = 'getter setter deleter stringifier static'.split(' ');
     function operation(it) {
       let ret = extended_attributes(it.extAttrs);
-      if (it.stringifier && !it.idlType) return "stringifier;";
+      if (it.stringifier && !it.idlType) return 'stringifier;';
       for (const mod of modifiers) {
-        if (it[mod]) ret += mod + " ";
+        if (it[mod]) ret += mod + ' ';
       }
-      ret += type(it.idlType) + " ";
+      ret += type(it.idlType) + ' ';
       if (it.name) ret += it.escapedName;
-      ret += `(${it.arguments.map(argument).join(",")});`;
+      ret += `(${it.arguments.map(argument).join(',')});`;
       return ret;
-    };
+    }
 
     function attribute(it) {
       let ret = extended_attributes(it.extAttrs);
-      if (it.static) ret += "static ";
-      if (it.stringifier) ret += "stringifier ";
-      if (it.inherit) ret += "inherit ";
-      if (it.readonly) ret += "readonly ";
+      if (it.static) ret += 'static ';
+      if (it.stringifier) ret += 'stringifier ';
+      if (it.inherit) ret += 'inherit ';
+      if (it.readonly) ret += 'readonly ';
       ret += `attribute ${type(it.idlType)} ${it.escapedName};`;
       return ret;
-    };
+    }
 
     function interface_(it) {
       let ret = extended_attributes(it.extAttrs);
-      if (it.partial) ret += "partial ";
+      if (it.partial) ret += 'partial ';
       ret += `interface ${it.name} `;
       if (it.inheritance) ret += `: ${it.inheritance} `;
       ret += `{${iterate(it.members)}};`;
       return ret;
-    };
+    }
 
     function interface_mixin(it) {
       let ret = extended_attributes(it.extAttrs);
-      if (it.partial) ret += "partial ";
+      if (it.partial) ret += 'partial ';
       ret += `interface mixin ${it.name} `;
       ret += `{${iterate(it.members)}};`;
       return ret;
@@ -103,7 +107,7 @@
 
     function namespace(it) {
       let ret = extended_attributes(it.extAttrs);
-      if (it.partial) ret += "partial ";
+      if (it.partial) ret += 'partial ';
       ret += `namespace ${it.name} `;
       ret += `{${iterate(it.members)}};`;
       return ret;
@@ -111,68 +115,84 @@
 
     function dictionary(it) {
       let ret = extended_attributes(it.extAttrs);
-      if (it.partial) ret += "partial ";
+      if (it.partial) ret += 'partial ';
       ret += `dictionary ${it.name} `;
       if (it.inheritance) ret += `: ${it.inheritance} `;
       ret += `{${iterate(it.members)}};`;
       return ret;
-    };
+    }
     function field(it) {
       let ret = extended_attributes(it.extAttrs);
-      if (it.required) ret += "required ";
+      if (it.required) ret += 'required ';
       ret += `${type(it.idlType)} ${it.escapedName}`;
       if (it.default) ret += ` = ${const_value(it.default)}`;
-      ret += ";";
+      ret += ';';
       return ret;
-    };
+    }
     function const_(it) {
       const ret = extended_attributes(it.extAttrs);
-      return `${ret}const ${type(it.idlType)}${it.nullable ? "?" : ""} ${it.name} = ${const_value(it.value)};`;
-    };
+      return `${ret}const ${type(it.idlType)}${it.nullable ? '?' : ''} ${
+        it.name
+      } = ${const_value(it.value)};`;
+    }
     function typedef(it) {
       let ret = extended_attributes(it.extAttrs);
       ret += `typedef ${extended_attributes(it.typeExtAttrs)}`;
       return `${ret}${type(it.idlType)} ${it.name};`;
-    };
+    }
     function implements_(it) {
       const ret = extended_attributes(it.extAttrs);
       return `${ret}${it.target} implements ${it.implements};`;
-    };
+    }
     function includes(it) {
       const ret = extended_attributes(it.extAttrs);
       return `${ret}${it.target} includes ${it.includes};`;
-    };
+    }
     function callback(it) {
       const ret = extended_attributes(it.extAttrs);
-      return `${ret}callback ${it.name} = ${type(it.idlType)}(${it.arguments.map(argument).join(",")});`;
-    };
+      return `${ret}callback ${it.name} = ${type(
+        it.idlType
+      )}(${it.arguments.map(argument).join(',')});`;
+    }
     function enum_(it) {
       let ret = extended_attributes(it.extAttrs);
       ret += `enum ${it.name} {`;
       for (const v of it.values) {
         ret += `"${v.value}",`;
       }
-      return ret + "};";
-    };
+      return ret + '};';
+    }
     function iterable(it) {
-      return `iterable<${Array.isArray(it.idlType) ? it.idlType.map(type).join(", ") : type(it.idlType)}>;`;
-    };
+      return `iterable<${
+        Array.isArray(it.idlType)
+          ? it.idlType.map(type).join(', ')
+          : type(it.idlType)
+      }>;`;
+    }
     function legacyiterable(it) {
-      return `legacyiterable<${Array.isArray(it.idlType) ? it.idlType.map(type).join(", ") : type(it.idlType)}>;`;
-    };
+      return `legacyiterable<${
+        Array.isArray(it.idlType)
+          ? it.idlType.map(type).join(', ')
+          : type(it.idlType)
+      }>;`;
+    }
     function maplike(it) {
-      return `${it.readonly ? "readonly " : ""}maplike<${it.idlType.map(type).join(", ")}>;`;
-    };
+      return `${it.readonly ? 'readonly ' : ''}maplike<${it.idlType
+        .map(type)
+        .join(', ')}>;`;
+    }
     function setlike(it) {
-      return `${it.readonly ? "readonly " : ""}setlike<${type(it.idlType[0])}>;`;
-    };
+      return `${it.readonly ? 'readonly ' : ''}setlike<${type(
+        it.idlType[0]
+      )}>;`;
+    }
     function callbackInterface(it) {
       return `callback ${interface_(it)}`;
-    };
+    }
 
     const table = {
       interface: interface_,
-      "interface mixin": interface_mixin,
+      'interface mixin': interface_mixin,
       namespace,
       operation,
       attribute,
@@ -188,24 +208,23 @@
       legacyiterable,
       maplike,
       setlike,
-      "callback interface": callbackInterface
+      'callback interface': callbackInterface
     };
     function dispatch(it) {
       const dispatcher = table[it.type];
       if (!dispatcher) {
-        throw new Error(`Type "${it.type}" is unsupported`)
+        throw new Error(`Type "${it.type}" is unsupported`);
       }
       return table[it.type](it);
-    };
+    }
     function iterate(things) {
       if (!things) return;
-      let ret = "";
+      let ret = '';
       for (const thing of things) ret += dispatch(thing);
       return ret;
-    };
+    }
     return iterate(ast);
-  };
-
+  }
 
   const obj = {
     write
diff --git a/test/fixtures/wpt/url/historical.any.js b/test/fixtures/wpt/url/historical.any.js
index c3797ad263850c..bf2ef21520e295 100644
--- a/test/fixtures/wpt/url/historical.any.js
+++ b/test/fixtures/wpt/url/historical.any.js
@@ -1,29 +1,31 @@
 test(function() {
-  assert_false("searchParams" in self.location,
-               "location object should not have a searchParams attribute");
-}, "searchParams on location object");
+  assert_false(
+    'searchParams' in self.location,
+    'location object should not have a searchParams attribute'
+  );
+}, 'searchParams on location object');
 
-if(self.GLOBAL.isWindow()) {
+if (self.GLOBAL.isWindow()) {
   test(() => {
-    assert_false("searchParams" in document.createElement("a"))
-    assert_false("searchParams" in document.createElement("area"))
-  }, "<a> and <area>.searchParams should be undefined");
+    assert_false('searchParams' in document.createElement('a'));
+    assert_false('searchParams' in document.createElement('area'));
+  }, '<a> and <area>.searchParams should be undefined');
 }
 
 test(function() {
-  var url = new URL("./foo", "http://www.example.org");
-  assert_equals(url.href, "http://www.example.org/foo");
+  var url = new URL('./foo', 'http://www.example.org');
+  assert_equals(url.href, 'http://www.example.org/foo');
   assert_throws(new TypeError(), function() {
-    url.href = "./bar";
+    url.href = './bar';
   });
 }, "Setting URL's href attribute and base URLs");
 
 test(function() {
   assert_equals(URL.domainToASCII, undefined);
-}, "URL.domainToASCII should be undefined");
+}, 'URL.domainToASCII should be undefined');
 
 test(function() {
   assert_equals(URL.domainToUnicode, undefined);
-}, "URL.domainToUnicode should be undefined");
+}, 'URL.domainToUnicode should be undefined');
 
 done();
diff --git a/test/fixtures/wpt/url/idlharness.any.js b/test/fixtures/wpt/url/idlharness.any.js
index 4a0e52f12b3c32..94e2ab966c4af1 100644
--- a/test/fixtures/wpt/url/idlharness.any.js
+++ b/test/fixtures/wpt/url/idlharness.any.js
@@ -4,7 +4,7 @@
 idl_test(
   ['url'],
   [], // no deps
-  idl_array => {
+  (idl_array) => {
     idl_array.add_objects({
       URL: ['new URL("http://foo")'],
       URLSearchParams: ['new URLSearchParams("hi=there&thank=you")']
diff --git a/test/fixtures/wpt/url/resources/a-element-origin.js b/test/fixtures/wpt/url/resources/a-element-origin.js
index 3b8cb1cbbe7c75..23244537eb6282 100644
--- a/test/fixtures/wpt/url/resources/a-element-origin.js
+++ b/test/fixtures/wpt/url/resources/a-element-origin.js
@@ -1,25 +1,35 @@
-promise_test(() => fetch("resources/urltestdata.json").then(res => res.json()).then(runURLTests), "Loading data…");
+promise_test(
+  () =>
+    fetch('resources/urltestdata.json')
+      .then((res) => res.json())
+      .then(runURLTests),
+  'Loading data…'
+);
 
 function setBase(base) {
-  document.getElementById("base").href = base
+  document.getElementById('base').href = base;
 }
 
 function bURL(url, base) {
-  base = base || "about:blank"
-  setBase(base)
-  var a = document.createElement("a")
-  a.setAttribute("href", url)
-  return a
+  base = base || 'about:blank';
+  setBase(base);
+  var a = document.createElement('a');
+  a.setAttribute('href', url);
+  return a;
 }
 
 function runURLTests(urltests) {
-  for(var i = 0, l = urltests.length; i < l; i++) {
-    var expected = urltests[i]
-    if (typeof expected === "string" || !("origin" in expected)) continue
+  for (var i = 0, l = urltests.length; i < l; i++) {
+    var expected = urltests[i];
+    if (typeof expected === 'string' || !('origin' in expected)) continue;
 
     test(function() {
-      var url = bURL(expected.input, expected.base)
-      assert_equals(url.origin, expected.origin, "origin")
-    }, "Parsing origin: <" + expected.input + "> against <" + expected.base + ">")
+      var url = bURL(expected.input, expected.base);
+      assert_equals(url.origin, expected.origin, 'origin');
+    }, 'Parsing origin: <' +
+      expected.input +
+      '> against <' +
+      expected.base +
+      '>');
   }
 }
diff --git a/test/fixtures/wpt/url/resources/a-element.js b/test/fixtures/wpt/url/resources/a-element.js
index f64531bc8bd528..9820001d52a4f1 100644
--- a/test/fixtures/wpt/url/resources/a-element.js
+++ b/test/fixtures/wpt/url/resources/a-element.js
@@ -1,42 +1,52 @@
-promise_test(() => fetch("resources/urltestdata.json").then(res => res.json()).then(runURLTests), "Loading data…");
+promise_test(
+  () =>
+    fetch('resources/urltestdata.json')
+      .then((res) => res.json())
+      .then(runURLTests),
+  'Loading data…'
+);
 
 function setBase(base) {
-  document.getElementById("base").href = base
+  document.getElementById('base').href = base;
 }
 
 function bURL(url, base) {
-  base = base || "about:blank"
-  setBase(base)
-  var a = document.createElement("a")
-  a.setAttribute("href", url)
-  return a
+  base = base || 'about:blank';
+  setBase(base);
+  var a = document.createElement('a');
+  a.setAttribute('href', url);
+  return a;
 }
 
 function runURLTests(urltests) {
-  for(var i = 0, l = urltests.length; i < l; i++) {
-    var expected = urltests[i]
-    if (typeof expected === "string") continue // skip comments
+  for (var i = 0, l = urltests.length; i < l; i++) {
+    var expected = urltests[i];
+    if (typeof expected === 'string') continue; // skip comments
 
     test(function() {
-      var url = bURL(expected.input, expected.base)
-      if(expected.failure) {
-        if(url.protocol !== ':') {
-          assert_unreached("Expected URL to fail parsing")
+      var url = bURL(expected.input, expected.base);
+      if (expected.failure) {
+        if (url.protocol !== ':') {
+          assert_unreached('Expected URL to fail parsing');
         }
-        assert_equals(url.href, expected.input, "failure should set href to input")
-        return
+        assert_equals(
+          url.href,
+          expected.input,
+          'failure should set href to input'
+        );
+        return;
       }
 
-      assert_equals(url.href, expected.href, "href")
-      assert_equals(url.protocol, expected.protocol, "protocol")
-      assert_equals(url.username, expected.username, "username")
-      assert_equals(url.password, expected.password, "password")
-      assert_equals(url.host, expected.host, "host")
-      assert_equals(url.hostname, expected.hostname, "hostname")
-      assert_equals(url.port, expected.port, "port")
-      assert_equals(url.pathname, expected.pathname, "pathname")
-      assert_equals(url.search, expected.search, "search")
-      assert_equals(url.hash, expected.hash, "hash")
-    }, "Parsing: <" + expected.input + "> against <" + expected.base + ">")
+      assert_equals(url.href, expected.href, 'href');
+      assert_equals(url.protocol, expected.protocol, 'protocol');
+      assert_equals(url.username, expected.username, 'username');
+      assert_equals(url.password, expected.password, 'password');
+      assert_equals(url.host, expected.host, 'host');
+      assert_equals(url.hostname, expected.hostname, 'hostname');
+      assert_equals(url.port, expected.port, 'port');
+      assert_equals(url.pathname, expected.pathname, 'pathname');
+      assert_equals(url.search, expected.search, 'search');
+      assert_equals(url.hash, expected.hash, 'hash');
+    }, 'Parsing: <' + expected.input + '> against <' + expected.base + '>');
   }
 }
diff --git a/test/fixtures/wpt/url/toascii.window.js b/test/fixtures/wpt/url/toascii.window.js
index b28c664479a26a..214d9286ea75a8 100644
--- a/test/fixtures/wpt/url/toascii.window.js
+++ b/test/fixtures/wpt/url/toascii.window.js
@@ -1,54 +1,62 @@
-promise_test(() => fetch("resources/toascii.json").then(res => res.json()).then(runTests), "Loading data…");
+promise_test(
+  () =>
+    fetch('resources/toascii.json')
+      .then((res) => res.json())
+      .then(runTests),
+  'Loading data…'
+);
 
 function makeURL(type, input) {
-  input = "https://" + input + "/x"
-  if(type === "url") {
-    return new URL(input)
+  input = 'https://' + input + '/x';
+  if (type === 'url') {
+    return new URL(input);
   } else {
-    const url = document.createElement(type)
-    url.href = input
-    return url
+    const url = document.createElement(type);
+    url.href = input;
+    return url;
   }
 }
 
 function runTests(tests) {
-  for(var i = 0, l = tests.length; i < l; i++) {
-    let hostTest = tests[i]
-    if (typeof hostTest === "string") {
-      continue // skip comments
+  for (var i = 0, l = tests.length; i < l; i++) {
+    let hostTest = tests[i];
+    if (typeof hostTest === 'string') {
+      continue; // skip comments
     }
-    const typeName = { "url": "URL", "a": "<a>", "area": "<area>" }
-    ;["url", "a", "area"].forEach((type) => {
+    const typeName = { url: 'URL', a: '<a>', area: '<area>' };
+    ['url', 'a', 'area'].forEach((type) => {
       test(() => {
-        if(hostTest.output !== null) {
-          const url = makeURL("url", hostTest.input)
-          assert_equals(url.host, hostTest.output)
-          assert_equals(url.hostname, hostTest.output)
-          assert_equals(url.pathname, "/x")
-          assert_equals(url.href, "https://" + hostTest.output + "/x")
+        if (hostTest.output !== null) {
+          const url = makeURL('url', hostTest.input);
+          assert_equals(url.host, hostTest.output);
+          assert_equals(url.hostname, hostTest.output);
+          assert_equals(url.pathname, '/x');
+          assert_equals(url.href, 'https://' + hostTest.output + '/x');
         } else {
-          if(type === "url") {
-            assert_throws(new TypeError, () => makeURL("url", hostTest.input))
+          if (type === 'url') {
+            assert_throws(new TypeError(), () =>
+              makeURL('url', hostTest.input)
+            );
           } else {
-            const url = makeURL(type, hostTest.input)
-            assert_equals(url.host, "")
-            assert_equals(url.hostname, "")
-            assert_equals(url.pathname, "")
-            assert_equals(url.href, "https://" + hostTest.input + "/x")
+            const url = makeURL(type, hostTest.input);
+            assert_equals(url.host, '');
+            assert_equals(url.hostname, '');
+            assert_equals(url.pathname, '');
+            assert_equals(url.href, 'https://' + hostTest.input + '/x');
           }
         }
-      }, hostTest.input + " (using " + typeName[type] + ")")
-      ;["host", "hostname"].forEach((val) => {
+      }, hostTest.input + ' (using ' + typeName[type] + ')');
+      ['host', 'hostname'].forEach((val) => {
         test(() => {
-          const url = makeURL(type, "x")
-          url[val] = hostTest.input
-          if(hostTest.output !== null) {
-            assert_equals(url[val], hostTest.output)
+          const url = makeURL(type, 'x');
+          url[val] = hostTest.input;
+          if (hostTest.output !== null) {
+            assert_equals(url[val], hostTest.output);
           } else {
-            assert_equals(url[val], "x")
+            assert_equals(url[val], 'x');
           }
-        }, hostTest.input + " (using " + typeName[type] + "." + val + ")")
-      })
-    })
+        }, hostTest.input + ' (using ' + typeName[type] + '.' + val + ')');
+      });
+    });
   }
 }
diff --git a/test/fixtures/wpt/url/url-searchparams.any.js b/test/fixtures/wpt/url/url-searchparams.any.js
index c55ae58d3b1e5b..857528a8263a17 100644
--- a/test/fixtures/wpt/url/url-searchparams.any.js
+++ b/test/fixtures/wpt/url/url-searchparams.any.js
@@ -1,72 +1,77 @@
 function bURL(url, base) {
-  return new URL(url, base || "about:blank")
+  return new URL(url, base || 'about:blank');
 }
 
 function runURLSearchParamTests() {
   test(function() {
-    var url = bURL('http://example.org/?a=b')
-    assert_true("searchParams" in url)
-    var searchParams = url.searchParams
-    assert_true(url.searchParams === searchParams, 'Object identity should hold.')
-  }, 'URL.searchParams getter')
+    var url = bURL('http://example.org/?a=b');
+    assert_true('searchParams' in url);
+    var searchParams = url.searchParams;
+    assert_true(
+      url.searchParams === searchParams,
+      'Object identity should hold.'
+    );
+  }, 'URL.searchParams getter');
 
   test(function() {
-    var url = bURL('http://example.org/?a=b')
-    assert_true("searchParams" in url)
-    var searchParams = url.searchParams
-    assert_equals(searchParams.toString(), 'a=b')
+    var url = bURL('http://example.org/?a=b');
+    assert_true('searchParams' in url);
+    var searchParams = url.searchParams;
+    assert_equals(searchParams.toString(), 'a=b');
 
-    searchParams.set('a', 'b')
-    assert_equals(url.searchParams.toString(), 'a=b')
-    assert_equals(url.search, '?a=b')
-    url.search = ''
-    assert_equals(url.searchParams.toString(), '')
-    assert_equals(url.search, '')
-    assert_equals(searchParams.toString(), '')
-  }, 'URL.searchParams updating, clearing')
+    searchParams.set('a', 'b');
+    assert_equals(url.searchParams.toString(), 'a=b');
+    assert_equals(url.search, '?a=b');
+    url.search = '';
+    assert_equals(url.searchParams.toString(), '');
+    assert_equals(url.search, '');
+    assert_equals(searchParams.toString(), '');
+  }, 'URL.searchParams updating, clearing');
 
   test(function() {
-    'use strict'
-    var urlString = 'http://example.org'
-    var url = bURL(urlString)
-    assert_throws(TypeError(), function() { url.searchParams = new URLSearchParams(urlString) })
-  }, 'URL.searchParams setter, invalid values')
+    'use strict';
+    var urlString = 'http://example.org';
+    var url = bURL(urlString);
+    assert_throws(TypeError(), function() {
+      url.searchParams = new URLSearchParams(urlString);
+    });
+  }, 'URL.searchParams setter, invalid values');
 
   test(function() {
-    var url = bURL('http://example.org/file?a=b&c=d')
-    assert_true("searchParams" in url)
-    var searchParams = url.searchParams
-    assert_equals(url.search, '?a=b&c=d')
-    assert_equals(searchParams.toString(), 'a=b&c=d')
+    var url = bURL('http://example.org/file?a=b&c=d');
+    assert_true('searchParams' in url);
+    var searchParams = url.searchParams;
+    assert_equals(url.search, '?a=b&c=d');
+    assert_equals(searchParams.toString(), 'a=b&c=d');
 
     // Test that setting 'search' propagates to the URL object's query object.
-    url.search = 'e=f&g=h'
-    assert_equals(url.search, '?e=f&g=h')
-    assert_equals(searchParams.toString(), 'e=f&g=h')
+    url.search = 'e=f&g=h';
+    assert_equals(url.search, '?e=f&g=h');
+    assert_equals(searchParams.toString(), 'e=f&g=h');
 
     // ..and same but with a leading '?'.
-    url.search = '?e=f&g=h'
-    assert_equals(url.search, '?e=f&g=h')
-    assert_equals(searchParams.toString(), 'e=f&g=h')
+    url.search = '?e=f&g=h';
+    assert_equals(url.search, '?e=f&g=h');
+    assert_equals(searchParams.toString(), 'e=f&g=h');
 
     // And in the other direction, altering searchParams propagates
     // back to 'search'.
-    searchParams.append('i', ' j ')
-    assert_equals(url.search, '?e=f&g=h&i=+j+')
-    assert_equals(url.searchParams.toString(), 'e=f&g=h&i=+j+')
-    assert_equals(searchParams.get('i'), ' j ')
+    searchParams.append('i', ' j ');
+    assert_equals(url.search, '?e=f&g=h&i=+j+');
+    assert_equals(url.searchParams.toString(), 'e=f&g=h&i=+j+');
+    assert_equals(searchParams.get('i'), ' j ');
 
-    searchParams.set('e', 'updated')
-    assert_equals(url.search, '?e=updated&g=h&i=+j+')
-    assert_equals(searchParams.get('e'), 'updated')
+    searchParams.set('e', 'updated');
+    assert_equals(url.search, '?e=updated&g=h&i=+j+');
+    assert_equals(searchParams.get('e'), 'updated');
 
-    var url2 = bURL('http://example.org/file??a=b&c=d')
-    assert_equals(url2.search, '??a=b&c=d')
-    assert_equals(url2.searchParams.toString(), '%3Fa=b&c=d')
+    var url2 = bURL('http://example.org/file??a=b&c=d');
+    assert_equals(url2.search, '??a=b&c=d');
+    assert_equals(url2.searchParams.toString(), '%3Fa=b&c=d');
 
-    url2.href = 'http://example.org/file??a=b'
-    assert_equals(url2.search, '??a=b')
-    assert_equals(url2.searchParams.toString(), '%3Fa=b')
-  }, 'URL.searchParams and URL.search setters, update propagation')
+    url2.href = 'http://example.org/file??a=b';
+    assert_equals(url2.search, '??a=b');
+    assert_equals(url2.searchParams.toString(), '%3Fa=b');
+  }, 'URL.searchParams and URL.search setters, update propagation');
 }
-runURLSearchParamTests()
+runURLSearchParamTests();
diff --git a/test/fixtures/wpt/url/url-tojson.any.js b/test/fixtures/wpt/url/url-tojson.any.js
index 65165f96c572d9..baee8548f1e8f6 100644
--- a/test/fixtures/wpt/url/url-tojson.any.js
+++ b/test/fixtures/wpt/url/url-tojson.any.js
@@ -1,4 +1,4 @@
 test(() => {
-  const a = new URL("https://example.com/")
-  assert_equals(JSON.stringify(a), "\"https://example.com/\"")
-})
+  const a = new URL('https://example.com/');
+  assert_equals(JSON.stringify(a), '"https://example.com/"');
+});
diff --git a/test/fixtures/wpt/url/urlencoded-parser.any.js b/test/fixtures/wpt/url/urlencoded-parser.any.js
index 65e894b94c26b0..32de846be78f61 100644
--- a/test/fixtures/wpt/url/urlencoded-parser.any.js
+++ b/test/fixtures/wpt/url/urlencoded-parser.any.js
@@ -1,63 +1,76 @@
 [
-  { "input": "test", "output": [["test", ""]] },
-  { "input": "\uFEFFtest=\uFEFF", "output": [["\uFEFFtest", "\uFEFF"]] },
-  { "input": "%EF%BB%BFtest=%EF%BB%BF", "output": [["\uFEFFtest", "\uFEFF"]] },
-  { "input": "%FE%FF", "output": [["\uFFFD\uFFFD", ""]] },
-  { "input": "%FF%FE", "output": [["\uFFFD\uFFFD", ""]] },
-  { "input": "†&†=x", "output": [["†", ""], ["†", "x"]] },
-  { "input": "%C2", "output": [["\uFFFD", ""]] },
-  { "input": "%C2x", "output": [["\uFFFDx", ""]] },
-  { "input": "_charset_=windows-1252&test=%C2x", "output": [["_charset_", "windows-1252"], ["test", "\uFFFDx"]] },
-  { "input": '', "output": [] },
-  { "input": 'a', "output": [['a', '']] },
-  { "input": 'a=b', "output": [['a', 'b']] },
-  { "input": 'a=', "output": [['a', '']] },
-  { "input": '=b', "output": [['', 'b']] },
-  { "input": '&', "output": [] },
-  { "input": '&a', "output": [['a', '']] },
-  { "input": 'a&', "output": [['a', '']] },
-  { "input": 'a&a', "output": [['a', ''], ['a', '']] },
-  { "input": 'a&b&c', "output": [['a', ''], ['b', ''], ['c', '']] },
-  { "input": 'a=b&c=d', "output": [['a', 'b'], ['c', 'd']] },
-  { "input": 'a=b&c=d&', "output": [['a', 'b'], ['c', 'd']] },
-  { "input": '&&&a=b&&&&c=d&', "output": [['a', 'b'], ['c', 'd']] },
-  { "input": 'a=a&a=b&a=c', "output": [['a', 'a'], ['a', 'b'], ['a', 'c']] },
-  { "input": 'a==a', "output": [['a', '=a']] },
-  { "input": 'a=a+b+c+d', "output": [['a', 'a b c d']] },
-  { "input": '%=a', "output": [['%', 'a']] },
-  { "input": '%a=a', "output": [['%a', 'a']] },
-  { "input": '%a_=a', "output": [['%a_', 'a']] },
-  { "input": '%61=a', "output": [['a', 'a']] },
-  { "input": '%61+%4d%4D=', "output": [['a MM', '']] }
+  { input: 'test', output: [['test', '']] },
+  { input: '\uFEFFtest=\uFEFF', output: [['\uFEFFtest', '\uFEFF']] },
+  { input: '%EF%BB%BFtest=%EF%BB%BF', output: [['\uFEFFtest', '\uFEFF']] },
+  { input: '%FE%FF', output: [['\uFFFD\uFFFD', '']] },
+  { input: '%FF%FE', output: [['\uFFFD\uFFFD', '']] },
+  { input: '†&†=x', output: [['†', ''], ['†', 'x']] },
+  { input: '%C2', output: [['\uFFFD', '']] },
+  { input: '%C2x', output: [['\uFFFDx', '']] },
+  {
+    input: '_charset_=windows-1252&test=%C2x',
+    output: [['_charset_', 'windows-1252'], ['test', '\uFFFDx']]
+  },
+  { input: '', output: [] },
+  { input: 'a', output: [['a', '']] },
+  { input: 'a=b', output: [['a', 'b']] },
+  { input: 'a=', output: [['a', '']] },
+  { input: '=b', output: [['', 'b']] },
+  { input: '&', output: [] },
+  { input: '&a', output: [['a', '']] },
+  { input: 'a&', output: [['a', '']] },
+  { input: 'a&a', output: [['a', ''], ['a', '']] },
+  { input: 'a&b&c', output: [['a', ''], ['b', ''], ['c', '']] },
+  { input: 'a=b&c=d', output: [['a', 'b'], ['c', 'd']] },
+  { input: 'a=b&c=d&', output: [['a', 'b'], ['c', 'd']] },
+  { input: '&&&a=b&&&&c=d&', output: [['a', 'b'], ['c', 'd']] },
+  { input: 'a=a&a=b&a=c', output: [['a', 'a'], ['a', 'b'], ['a', 'c']] },
+  { input: 'a==a', output: [['a', '=a']] },
+  { input: 'a=a+b+c+d', output: [['a', 'a b c d']] },
+  { input: '%=a', output: [['%', 'a']] },
+  { input: '%a=a', output: [['%a', 'a']] },
+  { input: '%a_=a', output: [['%a_', 'a']] },
+  { input: '%61=a', output: [['a', 'a']] },
+  { input: '%61+%4d%4D=', output: [['a MM', '']] }
 ].forEach((val) => {
   test(() => {
     let sp = new URLSearchParams(val.input),
-        i = 0
+      i = 0;
     for (let item of sp) {
-       assert_array_equals(item, val.output[i])
-       i++
+      assert_array_equals(item, val.output[i]);
+      i++;
     }
-  }, "URLSearchParams constructed with: " + val.input)
+  }, 'URLSearchParams constructed with: ' + val.input);
 
   promise_test(() => {
-    let init = new Request("about:blank", { body: val.input, method: "LADIDA", headers: {"Content-Type": "application/x-www-form-urlencoded;charset=windows-1252"} }).formData()
+    let init = new Request('about:blank', {
+      body: val.input,
+      method: 'LADIDA',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded;charset=windows-1252'
+      }
+    }).formData();
     return init.then((fd) => {
-      let i = 0
+      let i = 0;
       for (let item of fd) {
-         assert_array_equals(item, val.output[i])
-         i++
+        assert_array_equals(item, val.output[i]);
+        i++;
       }
-    })
-  }, "request.formData() with input: " + val.input)
+    });
+  }, 'request.formData() with input: ' + val.input);
 
   promise_test(() => {
-    let init = new Response(val.input, { headers: {"Content-Type": "application/x-www-form-urlencoded;charset=shift_jis"} }).formData()
+    let init = new Response(val.input, {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded;charset=shift_jis'
+      }
+    }).formData();
     return init.then((fd) => {
-      let i = 0
+      let i = 0;
       for (let item of fd) {
-         assert_array_equals(item, val.output[i])
-         i++
+        assert_array_equals(item, val.output[i]);
+        i++;
       }
-    })
-  }, "response.formData() with input: " + val.input)
+    });
+  }, 'response.formData() with input: ' + val.input);
 });
diff --git a/test/fixtures/wpt/url/urlsearchparams-append.any.js b/test/fixtures/wpt/url/urlsearchparams-append.any.js
index 5a7376144d0637..880e4634f5561a 100644
--- a/test/fixtures/wpt/url/urlsearchparams-append.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-append.any.js
@@ -1,39 +1,55 @@
 test(function() {
-    var params = new URLSearchParams();
-    params.append('a', 'b');
-    assert_equals(params + '', 'a=b');
-    params.append('a', 'b');
-    assert_equals(params + '', 'a=b&a=b');
-    params.append('a', 'c');
-    assert_equals(params + '', 'a=b&a=b&a=c');
+  var params = new URLSearchParams();
+  params.append('a', 'b');
+  assert_equals(params + '', 'a=b');
+  params.append('a', 'b');
+  assert_equals(params + '', 'a=b&a=b');
+  params.append('a', 'c');
+  assert_equals(params + '', 'a=b&a=b&a=c');
 }, 'Append same name');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('', '');
-    assert_equals(params + '', '=');
-    params.append('', '');
-    assert_equals(params + '', '=&=');
+  var params = new URLSearchParams();
+  params.append('', '');
+  assert_equals(params + '', '=');
+  params.append('', '');
+  assert_equals(params + '', '=&=');
 }, 'Append empty strings');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append(null, null);
-    assert_equals(params + '', 'null=null');
-    params.append(null, null);
-    assert_equals(params + '', 'null=null&null=null');
+  var params = new URLSearchParams();
+  params.append(null, null);
+  assert_equals(params + '', 'null=null');
+  params.append(null, null);
+  assert_equals(params + '', 'null=null&null=null');
 }, 'Append null');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('first', 1);
-    params.append('second', 2);
-    params.append('third', '');
-    params.append('first', 10);
-    assert_true(params.has('first'), 'Search params object has name "first"');
-    assert_equals(params.get('first'), '1', 'Search params object has name "first" with value "1"');
-    assert_equals(params.get('second'), '2', 'Search params object has name "second" with value "2"');
-    assert_equals(params.get('third'), '', 'Search params object has name "third" with value ""');
-    params.append('first', 10);
-    assert_equals(params.get('first'), '1', 'Search params object has name "first" with value "1"');
+  var params = new URLSearchParams();
+  params.append('first', 1);
+  params.append('second', 2);
+  params.append('third', '');
+  params.append('first', 10);
+  assert_true(params.has('first'), 'Search params object has name "first"');
+  assert_equals(
+    params.get('first'),
+    '1',
+    'Search params object has name "first" with value "1"'
+  );
+  assert_equals(
+    params.get('second'),
+    '2',
+    'Search params object has name "second" with value "2"'
+  );
+  assert_equals(
+    params.get('third'),
+    '',
+    'Search params object has name "third" with value ""'
+  );
+  params.append('first', 10);
+  assert_equals(
+    params.get('first'),
+    '1',
+    'Search params object has name "first" with value "1"'
+  );
 }, 'Append multiple');
diff --git a/test/fixtures/wpt/url/urlsearchparams-constructor.any.js b/test/fixtures/wpt/url/urlsearchparams-constructor.any.js
index 6fff03f00fdddd..248406f7280b23 100644
--- a/test/fixtures/wpt/url/urlsearchparams-constructor.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-constructor.any.js
@@ -1,178 +1,207 @@
 test(function() {
-    var params = new URLSearchParams();
-    assert_equals(params + '', '');
-    params = new URLSearchParams('');
-    assert_equals(params + '', '');
-    params = new URLSearchParams('a=b');
-    assert_equals(params + '', 'a=b');
-    params = new URLSearchParams(params);
-    assert_equals(params + '', 'a=b');
+  var params = new URLSearchParams();
+  assert_equals(params + '', '');
+  params = new URLSearchParams('');
+  assert_equals(params + '', '');
+  params = new URLSearchParams('a=b');
+  assert_equals(params + '', 'a=b');
+  params = new URLSearchParams(params);
+  assert_equals(params + '', 'a=b');
 }, 'Basic URLSearchParams construction');
 
 test(function() {
-    var params = new URLSearchParams()
-    assert_equals(params.toString(), "")
-}, "URLSearchParams constructor, no arguments")
+  var params = new URLSearchParams();
+  assert_equals(params.toString(), '');
+}, 'URLSearchParams constructor, no arguments');
 
 test(() => {
-    var params = new URLSearchParams(DOMException);
-    assert_equals(params.toString(), "INDEX_SIZE_ERR=1&DOMSTRING_SIZE_ERR=2&HIERARCHY_REQUEST_ERR=3&WRONG_DOCUMENT_ERR=4&INVALID_CHARACTER_ERR=5&NO_DATA_ALLOWED_ERR=6&NO_MODIFICATION_ALLOWED_ERR=7&NOT_FOUND_ERR=8&NOT_SUPPORTED_ERR=9&INUSE_ATTRIBUTE_ERR=10&INVALID_STATE_ERR=11&SYNTAX_ERR=12&INVALID_MODIFICATION_ERR=13&NAMESPACE_ERR=14&INVALID_ACCESS_ERR=15&VALIDATION_ERR=16&TYPE_MISMATCH_ERR=17&SECURITY_ERR=18&NETWORK_ERR=19&ABORT_ERR=20&URL_MISMATCH_ERR=21&QUOTA_EXCEEDED_ERR=22&TIMEOUT_ERR=23&INVALID_NODE_TYPE_ERR=24&DATA_CLONE_ERR=25")
-    assert_throws(new TypeError(), () => new URLSearchParams(DOMException.prototype),
-                  "Constructing a URLSearchParams from DOMException.prototype should throw due to branding checks");
-}, "URLSearchParams constructor, DOMException as argument")
+  var params = new URLSearchParams(DOMException);
+  assert_equals(
+    params.toString(),
+    'INDEX_SIZE_ERR=1&DOMSTRING_SIZE_ERR=2&HIERARCHY_REQUEST_ERR=3&WRONG_DOCUMENT_ERR=4&INVALID_CHARACTER_ERR=5&NO_DATA_ALLOWED_ERR=6&NO_MODIFICATION_ALLOWED_ERR=7&NOT_FOUND_ERR=8&NOT_SUPPORTED_ERR=9&INUSE_ATTRIBUTE_ERR=10&INVALID_STATE_ERR=11&SYNTAX_ERR=12&INVALID_MODIFICATION_ERR=13&NAMESPACE_ERR=14&INVALID_ACCESS_ERR=15&VALIDATION_ERR=16&TYPE_MISMATCH_ERR=17&SECURITY_ERR=18&NETWORK_ERR=19&ABORT_ERR=20&URL_MISMATCH_ERR=21&QUOTA_EXCEEDED_ERR=22&TIMEOUT_ERR=23&INVALID_NODE_TYPE_ERR=24&DATA_CLONE_ERR=25'
+  );
+  assert_throws(
+    new TypeError(),
+    () => new URLSearchParams(DOMException.prototype),
+    'Constructing a URLSearchParams from DOMException.prototype should throw due to branding checks'
+  );
+}, 'URLSearchParams constructor, DOMException as argument');
 
 test(() => {
-    var params = new URLSearchParams('');
-    assert_true(params != null, 'constructor returned non-null value.');
-    assert_equals(params.__proto__, URLSearchParams.prototype, 'expected URLSearchParams.prototype as prototype.');
-}, "URLSearchParams constructor, empty string as argument")
+  var params = new URLSearchParams('');
+  assert_true(params != null, 'constructor returned non-null value.');
+  assert_equals(
+    params.__proto__,
+    URLSearchParams.prototype,
+    'expected URLSearchParams.prototype as prototype.'
+  );
+}, 'URLSearchParams constructor, empty string as argument');
 
 test(() => {
-    var params = new URLSearchParams({});
-    assert_equals(params + '', "");
+  var params = new URLSearchParams({});
+  assert_equals(params + '', '');
 }, 'URLSearchParams constructor, {} as argument');
 
 test(function() {
-    var params = new URLSearchParams('a=b');
-    assert_true(params != null, 'constructor returned non-null value.');
-    assert_true(params.has('a'), 'Search params object has name "a"');
-    assert_false(params.has('b'), 'Search params object has not got name "b"');
-
-    params = new URLSearchParams('a=b&c');
-    assert_true(params != null, 'constructor returned non-null value.');
-    assert_true(params.has('a'), 'Search params object has name "a"');
-    assert_true(params.has('c'), 'Search params object has name "c"');
-
-    params = new URLSearchParams('&a&&& &&&&&a+b=& c&m%c3%b8%c3%b8');
-    assert_true(params != null, 'constructor returned non-null value.');
-    assert_true(params.has('a'), 'Search params object has name "a"');
-    assert_true(params.has('a b'), 'Search params object has name "a b"');
-    assert_true(params.has(' '), 'Search params object has name " "');
-    assert_false(params.has('c'), 'Search params object did not have the name "c"');
-    assert_true(params.has(' c'), 'Search params object has name " c"');
-    assert_true(params.has('møø'), 'Search params object has name "møø"');
+  var params = new URLSearchParams('a=b');
+  assert_true(params != null, 'constructor returned non-null value.');
+  assert_true(params.has('a'), 'Search params object has name "a"');
+  assert_false(params.has('b'), 'Search params object has not got name "b"');
+
+  params = new URLSearchParams('a=b&c');
+  assert_true(params != null, 'constructor returned non-null value.');
+  assert_true(params.has('a'), 'Search params object has name "a"');
+  assert_true(params.has('c'), 'Search params object has name "c"');
+
+  params = new URLSearchParams('&a&&& &&&&&a+b=& c&m%c3%b8%c3%b8');
+  assert_true(params != null, 'constructor returned non-null value.');
+  assert_true(params.has('a'), 'Search params object has name "a"');
+  assert_true(params.has('a b'), 'Search params object has name "a b"');
+  assert_true(params.has(' '), 'Search params object has name " "');
+  assert_false(
+    params.has('c'),
+    'Search params object did not have the name "c"'
+  );
+  assert_true(params.has(' c'), 'Search params object has name " c"');
+  assert_true(params.has('møø'), 'Search params object has name "møø"');
 }, 'URLSearchParams constructor, string.');
 
 test(function() {
-    var seed = new URLSearchParams('a=b&c=d');
-    var params = new URLSearchParams(seed);
-    assert_true(params != null, 'constructor returned non-null value.');
-    assert_equals(params.get('a'), 'b');
-    assert_equals(params.get('c'), 'd');
-    assert_false(params.has('d'));
-    // The name-value pairs are copied when created; later updates
-    // should not be observable.
-    seed.append('e', 'f');
-    assert_false(params.has('e'));
-    params.append('g', 'h');
-    assert_false(seed.has('g'));
+  var seed = new URLSearchParams('a=b&c=d');
+  var params = new URLSearchParams(seed);
+  assert_true(params != null, 'constructor returned non-null value.');
+  assert_equals(params.get('a'), 'b');
+  assert_equals(params.get('c'), 'd');
+  assert_false(params.has('d'));
+  // The name-value pairs are copied when created; later updates
+  // should not be observable.
+  seed.append('e', 'f');
+  assert_false(params.has('e'));
+  params.append('g', 'h');
+  assert_false(seed.has('g'));
 }, 'URLSearchParams constructor, object.');
 
 test(function() {
-    var params = new URLSearchParams('a=b+c');
-    assert_equals(params.get('a'), 'b c');
-    params = new URLSearchParams('a+b=c');
-    assert_equals(params.get('a b'), 'c');
+  var params = new URLSearchParams('a=b+c');
+  assert_equals(params.get('a'), 'b c');
+  params = new URLSearchParams('a+b=c');
+  assert_equals(params.get('a b'), 'c');
 }, 'Parse +');
 
 test(function() {
-    const testValue = '+15555555555';
-    const params = new URLSearchParams();
-    params.set('query', testValue);
-    var newParams = new URLSearchParams(params.toString());
-
-    assert_equals(params.toString(), 'query=%2B15555555555');
-    assert_equals(params.get('query'), testValue);
-    assert_equals(newParams.get('query'), testValue);
+  const testValue = '+15555555555';
+  const params = new URLSearchParams();
+  params.set('query', testValue);
+  var newParams = new URLSearchParams(params.toString());
+
+  assert_equals(params.toString(), 'query=%2B15555555555');
+  assert_equals(params.get('query'), testValue);
+  assert_equals(newParams.get('query'), testValue);
 }, 'Parse encoded +');
 
 test(function() {
-    var params = new URLSearchParams('a=b c');
-    assert_equals(params.get('a'), 'b c');
-    params = new URLSearchParams('a b=c');
-    assert_equals(params.get('a b'), 'c');
+  var params = new URLSearchParams('a=b c');
+  assert_equals(params.get('a'), 'b c');
+  params = new URLSearchParams('a b=c');
+  assert_equals(params.get('a b'), 'c');
 }, 'Parse space');
 
 test(function() {
-    var params = new URLSearchParams('a=b%20c');
-    assert_equals(params.get('a'), 'b c');
-    params = new URLSearchParams('a%20b=c');
-    assert_equals(params.get('a b'), 'c');
+  var params = new URLSearchParams('a=b%20c');
+  assert_equals(params.get('a'), 'b c');
+  params = new URLSearchParams('a%20b=c');
+  assert_equals(params.get('a b'), 'c');
 }, 'Parse %20');
 
 test(function() {
-    var params = new URLSearchParams('a=b\0c');
-    assert_equals(params.get('a'), 'b\0c');
-    params = new URLSearchParams('a\0b=c');
-    assert_equals(params.get('a\0b'), 'c');
+  var params = new URLSearchParams('a=b\0c');
+  assert_equals(params.get('a'), 'b\0c');
+  params = new URLSearchParams('a\0b=c');
+  assert_equals(params.get('a\0b'), 'c');
 }, 'Parse \\0');
 
 test(function() {
-    var params = new URLSearchParams('a=b%00c');
-    assert_equals(params.get('a'), 'b\0c');
-    params = new URLSearchParams('a%00b=c');
-    assert_equals(params.get('a\0b'), 'c');
+  var params = new URLSearchParams('a=b%00c');
+  assert_equals(params.get('a'), 'b\0c');
+  params = new URLSearchParams('a%00b=c');
+  assert_equals(params.get('a\0b'), 'c');
 }, 'Parse %00');
 
 test(function() {
-    var params = new URLSearchParams('a=b\u2384');
-    assert_equals(params.get('a'), 'b\u2384');
-    params = new URLSearchParams('a\u2384b=c');
-    assert_equals(params.get('a\u2384b'), 'c');
-}, 'Parse \u2384');  // Unicode Character 'COMPOSITION SYMBOL' (U+2384)
+  var params = new URLSearchParams('a=b\u2384');
+  assert_equals(params.get('a'), 'b\u2384');
+  params = new URLSearchParams('a\u2384b=c');
+  assert_equals(params.get('a\u2384b'), 'c');
+}, 'Parse \u2384'); // Unicode Character 'COMPOSITION SYMBOL' (U+2384)
 
 test(function() {
-    var params = new URLSearchParams('a=b%e2%8e%84');
-    assert_equals(params.get('a'), 'b\u2384');
-    params = new URLSearchParams('a%e2%8e%84b=c');
-    assert_equals(params.get('a\u2384b'), 'c');
-}, 'Parse %e2%8e%84');  // Unicode Character 'COMPOSITION SYMBOL' (U+2384)
+  var params = new URLSearchParams('a=b%e2%8e%84');
+  assert_equals(params.get('a'), 'b\u2384');
+  params = new URLSearchParams('a%e2%8e%84b=c');
+  assert_equals(params.get('a\u2384b'), 'c');
+}, 'Parse %e2%8e%84'); // Unicode Character 'COMPOSITION SYMBOL' (U+2384)
 
 test(function() {
-    var params = new URLSearchParams('a=b\uD83D\uDCA9c');
-    assert_equals(params.get('a'), 'b\uD83D\uDCA9c');
-    params = new URLSearchParams('a\uD83D\uDCA9b=c');
-    assert_equals(params.get('a\uD83D\uDCA9b'), 'c');
-}, 'Parse \uD83D\uDCA9');  // Unicode Character 'PILE OF POO' (U+1F4A9)
+  var params = new URLSearchParams('a=b\uD83D\uDCA9c');
+  assert_equals(params.get('a'), 'b\uD83D\uDCA9c');
+  params = new URLSearchParams('a\uD83D\uDCA9b=c');
+  assert_equals(params.get('a\uD83D\uDCA9b'), 'c');
+}, 'Parse \uD83D\uDCA9'); // Unicode Character 'PILE OF POO' (U+1F4A9)
 
 test(function() {
-    var params = new URLSearchParams('a=b%f0%9f%92%a9c');
-    assert_equals(params.get('a'), 'b\uD83D\uDCA9c');
-    params = new URLSearchParams('a%f0%9f%92%a9b=c');
-    assert_equals(params.get('a\uD83D\uDCA9b'), 'c');
-}, 'Parse %f0%9f%92%a9');  // Unicode Character 'PILE OF POO' (U+1F4A9)
+  var params = new URLSearchParams('a=b%f0%9f%92%a9c');
+  assert_equals(params.get('a'), 'b\uD83D\uDCA9c');
+  params = new URLSearchParams('a%f0%9f%92%a9b=c');
+  assert_equals(params.get('a\uD83D\uDCA9b'), 'c');
+}, 'Parse %f0%9f%92%a9'); // Unicode Character 'PILE OF POO' (U+1F4A9)
 
 test(function() {
-    var params = new URLSearchParams([]);
-    assert_true(params != null, 'constructor returned non-null value.');
-    params = new URLSearchParams([['a', 'b'], ['c', 'd']]);
-    assert_equals(params.get("a"), "b");
-    assert_equals(params.get("c"), "d");
-    assert_throws(new TypeError(), function() { new URLSearchParams([[1]]); });
-    assert_throws(new TypeError(), function() { new URLSearchParams([[1,2,3]]); });
-}, "Constructor with sequence of sequences of strings");
+  var params = new URLSearchParams([]);
+  assert_true(params != null, 'constructor returned non-null value.');
+  params = new URLSearchParams([['a', 'b'], ['c', 'd']]);
+  assert_equals(params.get('a'), 'b');
+  assert_equals(params.get('c'), 'd');
+  assert_throws(new TypeError(), function() {
+    new URLSearchParams([[1]]);
+  });
+  assert_throws(new TypeError(), function() {
+    new URLSearchParams([[1, 2, 3]]);
+  });
+}, 'Constructor with sequence of sequences of strings');
 
 [
-  { "input": {"+": "%C2"}, "output": [["+", "%C2"]], "name": "object with +" },
-  { "input": {c: "x", a: "?"}, "output": [["c", "x"], ["a", "?"]], "name": "object with two keys" },
-  { "input": [["c", "x"], ["a", "?"]], "output": [["c", "x"], ["a", "?"]], "name": "array with two keys" },
-  { "input": {"a\0b": "42", "c\uD83D": "23", "d\u1234": "foo"}, "output": [["a\0b", "42"], ["c\uFFFD", "23"], ["d\u1234", "foo"]], "name": "object with NULL, non-ASCII, and surrogate keys" }
+  { input: { '+': '%C2' }, output: [['+', '%C2']], name: 'object with +' },
+  {
+    input: { c: 'x', a: '?' },
+    output: [['c', 'x'], ['a', '?']],
+    name: 'object with two keys'
+  },
+  {
+    input: [['c', 'x'], ['a', '?']],
+    output: [['c', 'x'], ['a', '?']],
+    name: 'array with two keys'
+  },
+  {
+    input: { 'a\0b': '42', 'c\uD83D': '23', dሴ: 'foo' },
+    output: [['a\0b', '42'], ['c\uFFFD', '23'], ['d\u1234', 'foo']],
+    name: 'object with NULL, non-ASCII, and surrogate keys'
+  }
 ].forEach((val) => {
-    test(() => {
-        let params = new URLSearchParams(val.input),
-            i = 0
-        for (let param of params) {
-            assert_array_equals(param, val.output[i])
-            i++
-        }
-    }, "Construct with " + val.name)
-})
+  test(() => {
+    let params = new URLSearchParams(val.input),
+      i = 0;
+    for (let param of params) {
+      assert_array_equals(param, val.output[i]);
+      i++;
+    }
+  }, 'Construct with ' + val.name);
+});
 
 test(() => {
-  var params = new URLSearchParams()
-  params[Symbol.iterator] = function *() {
-    yield ["a", "b"]
-  }
-  let params2 = new URLSearchParams(params)
-  assert_equals(params2.get("a"), "b")
-}, "Custom [Symbol.iterator]")
+  var params = new URLSearchParams();
+  params[Symbol.iterator] = function*() {
+    yield ['a', 'b'];
+  };
+  let params2 = new URLSearchParams(params);
+  assert_equals(params2.get('a'), 'b');
+}, 'Custom [Symbol.iterator]');
diff --git a/test/fixtures/wpt/url/urlsearchparams-delete.any.js b/test/fixtures/wpt/url/urlsearchparams-delete.any.js
index 1aa9b313736de2..b859b93e1637e0 100644
--- a/test/fixtures/wpt/url/urlsearchparams-delete.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-delete.any.js
@@ -1,45 +1,49 @@
 test(function() {
-    var params = new URLSearchParams('a=b&c=d');
-    params.delete('a');
-    assert_equals(params + '', 'c=d');
-    params = new URLSearchParams('a=a&b=b&a=a&c=c');
-    params.delete('a');
-    assert_equals(params + '', 'b=b&c=c');
-    params = new URLSearchParams('a=a&=&b=b&c=c');
-    params.delete('');
-    assert_equals(params + '', 'a=a&b=b&c=c');
-    params = new URLSearchParams('a=a&null=null&b=b');
-    params.delete(null);
-    assert_equals(params + '', 'a=a&b=b');
-    params = new URLSearchParams('a=a&undefined=undefined&b=b');
-    params.delete(undefined);
-    assert_equals(params + '', 'a=a&b=b');
+  var params = new URLSearchParams('a=b&c=d');
+  params.delete('a');
+  assert_equals(params + '', 'c=d');
+  params = new URLSearchParams('a=a&b=b&a=a&c=c');
+  params.delete('a');
+  assert_equals(params + '', 'b=b&c=c');
+  params = new URLSearchParams('a=a&=&b=b&c=c');
+  params.delete('');
+  assert_equals(params + '', 'a=a&b=b&c=c');
+  params = new URLSearchParams('a=a&null=null&b=b');
+  params.delete(null);
+  assert_equals(params + '', 'a=a&b=b');
+  params = new URLSearchParams('a=a&undefined=undefined&b=b');
+  params.delete(undefined);
+  assert_equals(params + '', 'a=a&b=b');
 }, 'Delete basics');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('first', 1);
-    assert_true(params.has('first'), 'Search params object has name "first"');
-    assert_equals(params.get('first'), '1', 'Search params object has name "first" with value "1"');
-    params.delete('first');
-    assert_false(params.has('first'), 'Search params object has no "first" name');
-    params.append('first', 1);
-    params.append('first', 10);
-    params.delete('first');
-    assert_false(params.has('first'), 'Search params object has no "first" name');
+  var params = new URLSearchParams();
+  params.append('first', 1);
+  assert_true(params.has('first'), 'Search params object has name "first"');
+  assert_equals(
+    params.get('first'),
+    '1',
+    'Search params object has name "first" with value "1"'
+  );
+  params.delete('first');
+  assert_false(params.has('first'), 'Search params object has no "first" name');
+  params.append('first', 1);
+  params.append('first', 10);
+  params.delete('first');
+  assert_false(params.has('first'), 'Search params object has no "first" name');
 }, 'Deleting appended multiple');
 
 test(function() {
-    var url = new URL('http://example.com/?param1&param2');
-    url.searchParams.delete('param1');
-    url.searchParams.delete('param2');
-    assert_equals(url.href, 'http://example.com/', 'url.href does not have ?');
-    assert_equals(url.search, '', 'url.search does not have ?');
+  var url = new URL('http://example.com/?param1&param2');
+  url.searchParams.delete('param1');
+  url.searchParams.delete('param2');
+  assert_equals(url.href, 'http://example.com/', 'url.href does not have ?');
+  assert_equals(url.search, '', 'url.search does not have ?');
 }, 'Deleting all params removes ? from URL');
 
 test(function() {
-    var url = new URL('http://example.com/?');
-    url.searchParams.delete('param1');
-    assert_equals(url.href, 'http://example.com/', 'url.href does not have ?');
-    assert_equals(url.search, '', 'url.search does not have ?');
+  var url = new URL('http://example.com/?');
+  url.searchParams.delete('param1');
+  assert_equals(url.href, 'http://example.com/', 'url.href does not have ?');
+  assert_equals(url.search, '', 'url.search does not have ?');
 }, 'Removing non-existent param removes ? from URL');
diff --git a/test/fixtures/wpt/url/urlsearchparams-foreach.any.js b/test/fixtures/wpt/url/urlsearchparams-foreach.any.js
index 7969a0cb11a271..c254ee8e4a56ca 100644
--- a/test/fixtures/wpt/url/urlsearchparams-foreach.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-foreach.any.js
@@ -1,76 +1,80 @@
 test(function() {
-    var params = new URLSearchParams('a=1&b=2&c=3');
-    var keys = [];
-    var values = [];
-    params.forEach(function(value, key) {
-        keys.push(key);
-        values.push(value);
-    });
-    assert_array_equals(keys, ['a', 'b', 'c']);
-    assert_array_equals(values, ['1', '2', '3']);
-}, "ForEach Check");
+  var params = new URLSearchParams('a=1&b=2&c=3');
+  var keys = [];
+  var values = [];
+  params.forEach(function(value, key) {
+    keys.push(key);
+    values.push(value);
+  });
+  assert_array_equals(keys, ['a', 'b', 'c']);
+  assert_array_equals(values, ['1', '2', '3']);
+}, 'ForEach Check');
 
 test(function() {
-    let a = new URL("http://a.b/c?a=1&b=2&c=3&d=4");
-    let b = a.searchParams;
-    var c = [];
-    for (i of b) {
-        a.search = "x=1&y=2&z=3";
-        c.push(i);
-    }
-    assert_array_equals(c[0], ["a","1"]);
-    assert_array_equals(c[1], ["y","2"]);
-    assert_array_equals(c[2], ["z","3"]);
-}, "For-of Check");
+  let a = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
+  let b = a.searchParams;
+  var c = [];
+  for (i of b) {
+    a.search = 'x=1&y=2&z=3';
+    c.push(i);
+  }
+  assert_array_equals(c[0], ['a', '1']);
+  assert_array_equals(c[1], ['y', '2']);
+  assert_array_equals(c[2], ['z', '3']);
+}, 'For-of Check');
 
 test(function() {
-    let a = new URL("http://a.b/c");
-    let b = a.searchParams;
-    for (i of b) {
-        assert_unreached(i);
-    }
-}, "empty");
+  let a = new URL('http://a.b/c');
+  let b = a.searchParams;
+  for (i of b) {
+    assert_unreached(i);
+  }
+}, 'empty');
 
 test(function() {
-    const url = new URL("http://localhost/query?param0=0&param1=1&param2=2");
-    const searchParams = url.searchParams;
-    const seen = [];
-    for (param of searchParams) {
-        if (param[0] === 'param0') {
-            searchParams.delete('param1');
-        }
-        seen.push(param);
+  const url = new URL('http://localhost/query?param0=0&param1=1&param2=2');
+  const searchParams = url.searchParams;
+  const seen = [];
+  for (param of searchParams) {
+    if (param[0] === 'param0') {
+      searchParams.delete('param1');
     }
+    seen.push(param);
+  }
 
-    assert_array_equals(seen[0], ["param0", "0"]);
-    assert_array_equals(seen[1], ["param2", "2"]);
-}, "delete next param during iteration");
+  assert_array_equals(seen[0], ['param0', '0']);
+  assert_array_equals(seen[1], ['param2', '2']);
+}, 'delete next param during iteration');
 
 test(function() {
-    const url = new URL("http://localhost/query?param0=0&param1=1&param2=2");
-    const searchParams = url.searchParams;
-    const seen = [];
-    for (param of searchParams) {
-        if (param[0] === 'param0') {
-            searchParams.delete('param0');
-            // 'param1=1' is now in the first slot, so the next iteration will see 'param2=2'.
-        } else {
-            seen.push(param);
-        }
+  const url = new URL('http://localhost/query?param0=0&param1=1&param2=2');
+  const searchParams = url.searchParams;
+  const seen = [];
+  for (param of searchParams) {
+    if (param[0] === 'param0') {
+      searchParams.delete('param0');
+      // 'param1=1' is now in the first slot, so the next iteration will see 'param2=2'.
+    } else {
+      seen.push(param);
     }
+  }
 
-    assert_array_equals(seen[0], ["param2", "2"]);
-}, "delete current param during iteration");
+  assert_array_equals(seen[0], ['param2', '2']);
+}, 'delete current param during iteration');
 
 test(function() {
-    const url = new URL("http://localhost/query?param0=0&param1=1&param2=2");
-    const searchParams = url.searchParams;
-    const seen = [];
-    for (param of searchParams) {
-        seen.push(param[0]);
-        searchParams.delete(param[0]);
-    }
+  const url = new URL('http://localhost/query?param0=0&param1=1&param2=2');
+  const searchParams = url.searchParams;
+  const seen = [];
+  for (param of searchParams) {
+    seen.push(param[0]);
+    searchParams.delete(param[0]);
+  }
 
-    assert_array_equals(seen, ["param0", "param2"], "param1 should not have been seen by the loop");
-    assert_equals(String(searchParams), "param1=1", "param1 should remain");
-}, "delete every param seen during iteration");
+  assert_array_equals(
+    seen,
+    ['param0', 'param2'],
+    'param1 should not have been seen by the loop'
+  );
+  assert_equals(String(searchParams), 'param1=1', 'param1 should remain');
+}, 'delete every param seen during iteration');
diff --git a/test/fixtures/wpt/url/urlsearchparams-get.any.js b/test/fixtures/wpt/url/urlsearchparams-get.any.js
index a2610fc933a772..d8a41816c81eae 100644
--- a/test/fixtures/wpt/url/urlsearchparams-get.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-get.any.js
@@ -1,21 +1,33 @@
 test(function() {
-    var params = new URLSearchParams('a=b&c=d');
-    assert_equals(params.get('a'), 'b');
-    assert_equals(params.get('c'), 'd');
-    assert_equals(params.get('e'), null);
-    params = new URLSearchParams('a=b&c=d&a=e');
-    assert_equals(params.get('a'), 'b');
-    params = new URLSearchParams('=b&c=d');
-    assert_equals(params.get(''), 'b');
-    params = new URLSearchParams('a=&c=d&a=e');
-    assert_equals(params.get('a'), '');
+  var params = new URLSearchParams('a=b&c=d');
+  assert_equals(params.get('a'), 'b');
+  assert_equals(params.get('c'), 'd');
+  assert_equals(params.get('e'), null);
+  params = new URLSearchParams('a=b&c=d&a=e');
+  assert_equals(params.get('a'), 'b');
+  params = new URLSearchParams('=b&c=d');
+  assert_equals(params.get(''), 'b');
+  params = new URLSearchParams('a=&c=d&a=e');
+  assert_equals(params.get('a'), '');
 }, 'Get basics');
 
 test(function() {
-    var params = new URLSearchParams('first=second&third&&');
-    assert_true(params != null, 'constructor returned non-null value.');
-    assert_true(params.has('first'), 'Search params object has name "first"');
-    assert_equals(params.get('first'), 'second', 'Search params object has name "first" with value "second"');
-    assert_equals(params.get('third'), '', 'Search params object has name "third" with the empty value.');
-    assert_equals(params.get('fourth'), null, 'Search params object has no "fourth" name and value.');
+  var params = new URLSearchParams('first=second&third&&');
+  assert_true(params != null, 'constructor returned non-null value.');
+  assert_true(params.has('first'), 'Search params object has name "first"');
+  assert_equals(
+    params.get('first'),
+    'second',
+    'Search params object has name "first" with value "second"'
+  );
+  assert_equals(
+    params.get('third'),
+    '',
+    'Search params object has name "third" with the empty value.'
+  );
+  assert_equals(
+    params.get('fourth'),
+    null,
+    'Search params object has no "fourth" name and value.'
+  );
 }, 'More get() basics');
diff --git a/test/fixtures/wpt/url/urlsearchparams-getall.any.js b/test/fixtures/wpt/url/urlsearchparams-getall.any.js
index 5d1a35352acf2c..2ba27c6e99657f 100644
--- a/test/fixtures/wpt/url/urlsearchparams-getall.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-getall.any.js
@@ -1,25 +1,43 @@
 test(function() {
-    var params = new URLSearchParams('a=b&c=d');
-    assert_array_equals(params.getAll('a'), ['b']);
-    assert_array_equals(params.getAll('c'), ['d']);
-    assert_array_equals(params.getAll('e'), []);
-    params = new URLSearchParams('a=b&c=d&a=e');
-    assert_array_equals(params.getAll('a'), ['b', 'e']);
-    params = new URLSearchParams('=b&c=d');
-    assert_array_equals(params.getAll(''), ['b']);
-    params = new URLSearchParams('a=&c=d&a=e');
-    assert_array_equals(params.getAll('a'), ['', 'e']);
+  var params = new URLSearchParams('a=b&c=d');
+  assert_array_equals(params.getAll('a'), ['b']);
+  assert_array_equals(params.getAll('c'), ['d']);
+  assert_array_equals(params.getAll('e'), []);
+  params = new URLSearchParams('a=b&c=d&a=e');
+  assert_array_equals(params.getAll('a'), ['b', 'e']);
+  params = new URLSearchParams('=b&c=d');
+  assert_array_equals(params.getAll(''), ['b']);
+  params = new URLSearchParams('a=&c=d&a=e');
+  assert_array_equals(params.getAll('a'), ['', 'e']);
 }, 'getAll() basics');
 
 test(function() {
-    var params = new URLSearchParams('a=1&a=2&a=3&a');
-    assert_true(params.has('a'), 'Search params object has name "a"');
-    var matches = params.getAll('a');
-    assert_true(matches && matches.length == 4, 'Search params object has values for name "a"');
-    assert_array_equals(matches, ['1', '2', '3', ''], 'Search params object has expected name "a" values');
-    params.set('a', 'one');
-    assert_equals(params.get('a'), 'one', 'Search params object has name "a" with value "one"');
-    var matches = params.getAll('a');
-    assert_true(matches && matches.length == 1, 'Search params object has values for name "a"');
-    assert_array_equals(matches, ['one'], 'Search params object has expected name "a" values');
+  var params = new URLSearchParams('a=1&a=2&a=3&a');
+  assert_true(params.has('a'), 'Search params object has name "a"');
+  var matches = params.getAll('a');
+  assert_true(
+    matches && matches.length == 4,
+    'Search params object has values for name "a"'
+  );
+  assert_array_equals(
+    matches,
+    ['1', '2', '3', ''],
+    'Search params object has expected name "a" values'
+  );
+  params.set('a', 'one');
+  assert_equals(
+    params.get('a'),
+    'one',
+    'Search params object has name "a" with value "one"'
+  );
+  var matches = params.getAll('a');
+  assert_true(
+    matches && matches.length == 1,
+    'Search params object has values for name "a"'
+  );
+  assert_array_equals(
+    matches,
+    ['one'],
+    'Search params object has expected name "a" values'
+  );
 }, 'getAll() multiples');
diff --git a/test/fixtures/wpt/url/urlsearchparams-has.any.js b/test/fixtures/wpt/url/urlsearchparams-has.any.js
index 673dce77dc44ab..7bc5e4872055ea 100644
--- a/test/fixtures/wpt/url/urlsearchparams-has.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-has.any.js
@@ -1,24 +1,24 @@
 test(function() {
-    var params = new URLSearchParams('a=b&c=d');
-    assert_true(params.has('a'));
-    assert_true(params.has('c'));
-    assert_false(params.has('e'));
-    params = new URLSearchParams('a=b&c=d&a=e');
-    assert_true(params.has('a'));
-    params = new URLSearchParams('=b&c=d');
-    assert_true(params.has(''));
-    params = new URLSearchParams('null=a');
-    assert_true(params.has(null));
+  var params = new URLSearchParams('a=b&c=d');
+  assert_true(params.has('a'));
+  assert_true(params.has('c'));
+  assert_false(params.has('e'));
+  params = new URLSearchParams('a=b&c=d&a=e');
+  assert_true(params.has('a'));
+  params = new URLSearchParams('=b&c=d');
+  assert_true(params.has(''));
+  params = new URLSearchParams('null=a');
+  assert_true(params.has(null));
 }, 'Has basics');
 
 test(function() {
-    var params = new URLSearchParams('a=b&c=d&&');
-    params.append('first', 1);
-    params.append('first', 2);
-    assert_true(params.has('a'), 'Search params object has name "a"');
-    assert_true(params.has('c'), 'Search params object has name "c"');
-    assert_true(params.has('first'), 'Search params object has name "first"');
-    assert_false(params.has('d'), 'Search params object has no name "d"');
-    params.delete('first');
-    assert_false(params.has('first'), 'Search params object has no name "first"');
+  var params = new URLSearchParams('a=b&c=d&&');
+  params.append('first', 1);
+  params.append('first', 2);
+  assert_true(params.has('a'), 'Search params object has name "a"');
+  assert_true(params.has('c'), 'Search params object has name "c"');
+  assert_true(params.has('first'), 'Search params object has name "first"');
+  assert_false(params.has('d'), 'Search params object has no name "d"');
+  params.delete('first');
+  assert_false(params.has('first'), 'Search params object has no name "first"');
 }, 'has() following delete()');
diff --git a/test/fixtures/wpt/url/urlsearchparams-set.any.js b/test/fixtures/wpt/url/urlsearchparams-set.any.js
index eb24cac87b6dca..c7d8a842f2627c 100644
--- a/test/fixtures/wpt/url/urlsearchparams-set.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-set.any.js
@@ -1,22 +1,34 @@
 test(function() {
-    var params = new URLSearchParams('a=b&c=d');
-    params.set('a', 'B');
-    assert_equals(params + '', 'a=B&c=d');
-    params = new URLSearchParams('a=b&c=d&a=e');
-    params.set('a', 'B');
-    assert_equals(params + '', 'a=B&c=d')
-    params.set('e', 'f');
-    assert_equals(params + '', 'a=B&c=d&e=f')
+  var params = new URLSearchParams('a=b&c=d');
+  params.set('a', 'B');
+  assert_equals(params + '', 'a=B&c=d');
+  params = new URLSearchParams('a=b&c=d&a=e');
+  params.set('a', 'B');
+  assert_equals(params + '', 'a=B&c=d');
+  params.set('e', 'f');
+  assert_equals(params + '', 'a=B&c=d&e=f');
 }, 'Set basics');
 
 test(function() {
-    var params = new URLSearchParams('a=1&a=2&a=3');
-    assert_true(params.has('a'), 'Search params object has name "a"');
-    assert_equals(params.get('a'), '1', 'Search params object has name "a" with value "1"');
-    params.set('first', 4);
-    assert_true(params.has('a'), 'Search params object has name "a"');
-    assert_equals(params.get('a'), '1', 'Search params object has name "a" with value "1"');
-    params.set('a', 4);
-    assert_true(params.has('a'), 'Search params object has name "a"');
-    assert_equals(params.get('a'), '4', 'Search params object has name "a" with value "4"');
+  var params = new URLSearchParams('a=1&a=2&a=3');
+  assert_true(params.has('a'), 'Search params object has name "a"');
+  assert_equals(
+    params.get('a'),
+    '1',
+    'Search params object has name "a" with value "1"'
+  );
+  params.set('first', 4);
+  assert_true(params.has('a'), 'Search params object has name "a"');
+  assert_equals(
+    params.get('a'),
+    '1',
+    'Search params object has name "a" with value "1"'
+  );
+  params.set('a', 4);
+  assert_true(params.has('a'), 'Search params object has name "a"');
+  assert_equals(
+    params.get('a'),
+    '4',
+    'Search params object has name "a" with value "4"'
+  );
 }, 'URLSearchParams.set');
diff --git a/test/fixtures/wpt/url/urlsearchparams-sort.any.js b/test/fixtures/wpt/url/urlsearchparams-sort.any.js
index 4fd8cef69239d2..fb80cd59e7a981 100644
--- a/test/fixtures/wpt/url/urlsearchparams-sort.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-sort.any.js
@@ -1,62 +1,77 @@
 [
   {
-    "input": "z=b&a=b&z=a&a=a",
-    "output": [["a", "b"], ["a", "a"], ["z", "b"], ["z", "a"]]
+    input: 'z=b&a=b&z=a&a=a',
+    output: [['a', 'b'], ['a', 'a'], ['z', 'b'], ['z', 'a']]
   },
   {
-    "input": "\uFFFD=x&\uFFFC&\uFFFD=a",
-    "output": [["\uFFFC", ""], ["\uFFFD", "x"], ["\uFFFD", "a"]]
+    input: '\uFFFD=x&\uFFFC&\uFFFD=a',
+    output: [['\uFFFC', ''], ['\uFFFD', 'x'], ['\uFFFD', 'a']]
   },
   {
-    "input": "ffi&🌈", // 🌈 > code point, but < code unit because two code units
-    "output": [["🌈", ""], ["ffi", ""]]
+    input: 'ffi&🌈', // 🌈 > code point, but < code unit because two code units
+    output: [['🌈', ''], ['ffi', '']]
   },
   {
-    "input": "é&e\uFFFD&e\u0301",
-    "output": [["e\u0301", ""], ["e\uFFFD", ""], ["é", ""]]
+    input: 'é&e\uFFFD&e\u0301',
+    output: [['e\u0301', ''], ['e\uFFFD', ''], ['é', '']]
   },
   {
-    "input": "z=z&a=a&z=y&a=b&z=x&a=c&z=w&a=d&z=v&a=e&z=u&a=f&z=t&a=g",
-    "output": [["a", "a"], ["a", "b"], ["a", "c"], ["a", "d"], ["a", "e"], ["a", "f"], ["a", "g"], ["z", "z"], ["z", "y"], ["z", "x"], ["z", "w"], ["z", "v"], ["z", "u"], ["z", "t"]]
+    input: 'z=z&a=a&z=y&a=b&z=x&a=c&z=w&a=d&z=v&a=e&z=u&a=f&z=t&a=g',
+    output: [
+      ['a', 'a'],
+      ['a', 'b'],
+      ['a', 'c'],
+      ['a', 'd'],
+      ['a', 'e'],
+      ['a', 'f'],
+      ['a', 'g'],
+      ['z', 'z'],
+      ['z', 'y'],
+      ['z', 'x'],
+      ['z', 'w'],
+      ['z', 'v'],
+      ['z', 'u'],
+      ['z', 't']
+    ]
   },
   {
-    "input": "bbb&bb&aaa&aa=x&aa=y",
-    "output": [["aa", "x"], ["aa", "y"], ["aaa", ""], ["bb", ""], ["bbb", ""]]
+    input: 'bbb&bb&aaa&aa=x&aa=y',
+    output: [['aa', 'x'], ['aa', 'y'], ['aaa', ''], ['bb', ''], ['bbb', '']]
   },
   {
-    "input": "z=z&=f&=t&=x",
-    "output": [["", "f"], ["", "t"], ["", "x"], ["z", "z"]]
+    input: 'z=z&=f&=t&=x',
+    output: [['', 'f'], ['', 't'], ['', 'x'], ['z', 'z']]
   },
   {
-    "input": "a🌈&a💩",
-    "output": [["a🌈", ""], ["a💩", ""]]
+    input: 'a🌈&a💩',
+    output: [['a🌈', ''], ['a💩', '']]
   }
 ].forEach((val) => {
   test(() => {
     let params = new URLSearchParams(val.input),
-        i = 0
-    params.sort()
-    for(let param of params) {
-      assert_array_equals(param, val.output[i])
-      i++
+      i = 0;
+    params.sort();
+    for (let param of params) {
+      assert_array_equals(param, val.output[i]);
+      i++;
     }
-  }, "Parse and sort: " + val.input)
+  }, 'Parse and sort: ' + val.input);
 
   test(() => {
-    let url = new URL("?" + val.input, "https://example/")
-    url.searchParams.sort()
+    let url = new URL('?' + val.input, 'https://example/');
+    url.searchParams.sort();
     let params = new URLSearchParams(url.search),
-        i = 0
-    for(let param of params) {
-      assert_array_equals(param, val.output[i])
-      i++
+      i = 0;
+    for (let param of params) {
+      assert_array_equals(param, val.output[i]);
+      i++;
     }
-  }, "URL parse and sort: " + val.input)
-})
+  }, 'URL parse and sort: ' + val.input);
+});
 
 test(function() {
-  const url = new URL("http://example.com/?")
-  url.searchParams.sort()
-  assert_equals(url.href, "http://example.com/")
-  assert_equals(url.search, "")
-}, "Sorting non-existent params removes ? from URL")
+  const url = new URL('http://example.com/?');
+  url.searchParams.sort();
+  assert_equals(url.href, 'http://example.com/');
+  assert_equals(url.search, '');
+}, 'Sorting non-existent params removes ? from URL');
diff --git a/test/fixtures/wpt/url/urlsearchparams-stringifier.any.js b/test/fixtures/wpt/url/urlsearchparams-stringifier.any.js
index ef95c1434c7964..7c32e6301d5ceb 100644
--- a/test/fixtures/wpt/url/urlsearchparams-stringifier.any.js
+++ b/test/fixtures/wpt/url/urlsearchparams-stringifier.any.js
@@ -1,123 +1,123 @@
 test(function() {
-    var params = new URLSearchParams();
-    params.append('a', 'b c');
-    assert_equals(params + '', 'a=b+c');
-    params.delete('a');
-    params.append('a b', 'c');
-    assert_equals(params + '', 'a+b=c');
+  var params = new URLSearchParams();
+  params.append('a', 'b c');
+  assert_equals(params + '', 'a=b+c');
+  params.delete('a');
+  params.append('a b', 'c');
+  assert_equals(params + '', 'a+b=c');
 }, 'Serialize space');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('a', '');
-    assert_equals(params + '', 'a=');
-    params.append('a', '');
-    assert_equals(params + '', 'a=&a=');
-    params.append('', 'b');
-    assert_equals(params + '', 'a=&a=&=b');
-    params.append('', '');
-    assert_equals(params + '', 'a=&a=&=b&=');
-    params.append('', '');
-    assert_equals(params + '', 'a=&a=&=b&=&=');
+  var params = new URLSearchParams();
+  params.append('a', '');
+  assert_equals(params + '', 'a=');
+  params.append('a', '');
+  assert_equals(params + '', 'a=&a=');
+  params.append('', 'b');
+  assert_equals(params + '', 'a=&a=&=b');
+  params.append('', '');
+  assert_equals(params + '', 'a=&a=&=b&=');
+  params.append('', '');
+  assert_equals(params + '', 'a=&a=&=b&=&=');
 }, 'Serialize empty value');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('', 'b');
-    assert_equals(params + '', '=b');
-    params.append('', 'b');
-    assert_equals(params + '', '=b&=b');
+  var params = new URLSearchParams();
+  params.append('', 'b');
+  assert_equals(params + '', '=b');
+  params.append('', 'b');
+  assert_equals(params + '', '=b&=b');
 }, 'Serialize empty name');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('', '');
-    assert_equals(params + '', '=');
-    params.append('', '');
-    assert_equals(params + '', '=&=');
+  var params = new URLSearchParams();
+  params.append('', '');
+  assert_equals(params + '', '=');
+  params.append('', '');
+  assert_equals(params + '', '=&=');
 }, 'Serialize empty name and value');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('a', 'b+c');
-    assert_equals(params + '', 'a=b%2Bc');
-    params.delete('a');
-    params.append('a+b', 'c');
-    assert_equals(params + '', 'a%2Bb=c');
+  var params = new URLSearchParams();
+  params.append('a', 'b+c');
+  assert_equals(params + '', 'a=b%2Bc');
+  params.delete('a');
+  params.append('a+b', 'c');
+  assert_equals(params + '', 'a%2Bb=c');
 }, 'Serialize +');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('=', 'a');
-    assert_equals(params + '', '%3D=a');
-    params.append('b', '=');
-    assert_equals(params + '', '%3D=a&b=%3D');
+  var params = new URLSearchParams();
+  params.append('=', 'a');
+  assert_equals(params + '', '%3D=a');
+  params.append('b', '=');
+  assert_equals(params + '', '%3D=a&b=%3D');
 }, 'Serialize =');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('&', 'a');
-    assert_equals(params + '', '%26=a');
-    params.append('b', '&');
-    assert_equals(params + '', '%26=a&b=%26');
+  var params = new URLSearchParams();
+  params.append('&', 'a');
+  assert_equals(params + '', '%26=a');
+  params.append('b', '&');
+  assert_equals(params + '', '%26=a&b=%26');
 }, 'Serialize &');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('a', '*-._');
-    assert_equals(params + '', 'a=*-._');
-    params.delete('a');
-    params.append('*-._', 'c');
-    assert_equals(params + '', '*-._=c');
+  var params = new URLSearchParams();
+  params.append('a', '*-._');
+  assert_equals(params + '', 'a=*-._');
+  params.delete('a');
+  params.append('*-._', 'c');
+  assert_equals(params + '', '*-._=c');
 }, 'Serialize *-._');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('a', 'b%c');
-    assert_equals(params + '', 'a=b%25c');
-    params.delete('a');
-    params.append('a%b', 'c');
-    assert_equals(params + '', 'a%25b=c');
+  var params = new URLSearchParams();
+  params.append('a', 'b%c');
+  assert_equals(params + '', 'a=b%25c');
+  params.delete('a');
+  params.append('a%b', 'c');
+  assert_equals(params + '', 'a%25b=c');
 }, 'Serialize %');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('a', 'b\0c');
-    assert_equals(params + '', 'a=b%00c');
-    params.delete('a');
-    params.append('a\0b', 'c');
-    assert_equals(params + '', 'a%00b=c');
+  var params = new URLSearchParams();
+  params.append('a', 'b\0c');
+  assert_equals(params + '', 'a=b%00c');
+  params.delete('a');
+  params.append('a\0b', 'c');
+  assert_equals(params + '', 'a%00b=c');
 }, 'Serialize \\0');
 
 test(function() {
-    var params = new URLSearchParams();
-    params.append('a', 'b\uD83D\uDCA9c');
-    assert_equals(params + '', 'a=b%F0%9F%92%A9c');
-    params.delete('a');
-    params.append('a\uD83D\uDCA9b', 'c');
-    assert_equals(params + '', 'a%F0%9F%92%A9b=c');
-}, 'Serialize \uD83D\uDCA9');  // Unicode Character 'PILE OF POO' (U+1F4A9)
+  var params = new URLSearchParams();
+  params.append('a', 'b\uD83D\uDCA9c');
+  assert_equals(params + '', 'a=b%F0%9F%92%A9c');
+  params.delete('a');
+  params.append('a\uD83D\uDCA9b', 'c');
+  assert_equals(params + '', 'a%F0%9F%92%A9b=c');
+}, 'Serialize \uD83D\uDCA9'); // Unicode Character 'PILE OF POO' (U+1F4A9)
 
 test(function() {
-    var params;
-    params = new URLSearchParams('a=b&c=d&&e&&');
-    assert_equals(params.toString(), 'a=b&c=d&e=');
-    params = new URLSearchParams('a = b &a=b&c=d%20');
-    assert_equals(params.toString(), 'a+=+b+&a=b&c=d+');
-    // The lone '=' _does_ survive the roundtrip.
-    params = new URLSearchParams('a=&a=b');
-    assert_equals(params.toString(), 'a=&a=b');
+  var params;
+  params = new URLSearchParams('a=b&c=d&&e&&');
+  assert_equals(params.toString(), 'a=b&c=d&e=');
+  params = new URLSearchParams('a = b &a=b&c=d%20');
+  assert_equals(params.toString(), 'a+=+b+&a=b&c=d+');
+  // The lone '=' _does_ survive the roundtrip.
+  params = new URLSearchParams('a=&a=b');
+  assert_equals(params.toString(), 'a=&a=b');
 }, 'URLSearchParams.toString');
 
 test(() => {
-    const url = new URL('http://www.example.com/?a=b,c');
-    const params = url.searchParams;
+  const url = new URL('http://www.example.com/?a=b,c');
+  const params = url.searchParams;
 
-    assert_equals(url.toString(), 'http://www.example.com/?a=b,c');
-    assert_equals(params.toString(), 'a=b%2Cc');
+  assert_equals(url.toString(), 'http://www.example.com/?a=b,c');
+  assert_equals(params.toString(), 'a=b%2Cc');
 
-    params.append('x', 'y');
+  params.append('x', 'y');
 
-    assert_equals(url.toString(), 'http://www.example.com/?a=b%2Cc&x=y');
-    assert_equals(params.toString(), 'a=b%2Cc&x=y');
+  assert_equals(url.toString(), 'http://www.example.com/?a=b%2Cc&x=y');
+  assert_equals(params.toString(), 'a=b%2Cc&x=y');
 }, 'URLSearchParams connected to URL');
diff --git a/test/internet/test-dgram-broadcast-multi-process.js b/test/internet/test-dgram-broadcast-multi-process.js
index a8d97869703e58..59c58fcb8f6888 100644
--- a/test/internet/test-dgram-broadcast-multi-process.js
+++ b/test/internet/test-dgram-broadcast-multi-process.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (common.inFreeBSDJail)
-  common.skip('in a FreeBSD jail');
+if (common.inFreeBSDJail) common.skip('in a FreeBSD jail');
 
 const assert = require('assert');
 const dgram = require('dgram');
@@ -66,8 +65,10 @@ if (process.argv[2] !== 'child') {
 
   // Exit the test if it doesn't succeed within TIMEOUT
   timer = setTimeout(function() {
-    console.error('[PARENT] Responses were not received within %d ms.',
-                  TIMEOUT);
+    console.error(
+      '[PARENT] Responses were not received within %d ms.',
+      TIMEOUT
+    );
     console.error('[PARENT] Fail');
 
     killSubprocesses(workers);
@@ -93,10 +94,12 @@ if (process.argv[2] !== 'child') {
         }
 
         dead += 1;
-        console.error('[PARENT] Worker %d died. %d dead of %d',
-                      worker.pid,
-                      dead,
-                      listeners);
+        console.error(
+          '[PARENT] Worker %d died. %d dead of %d',
+          worker.pid,
+          dead,
+          listeners
+        );
 
         if (dead === listeners) {
           console.error('[PARENT] All workers have died.');
@@ -122,15 +125,19 @@ if (process.argv[2] !== 'child') {
           if (worker.messagesReceived.length === messages.length) {
             done += 1;
             worker.isDone = true;
-            console.error('[PARENT] %d received %d messages total.',
-                          worker.pid,
-                          worker.messagesReceived.length);
+            console.error(
+              '[PARENT] %d received %d messages total.',
+              worker.pid,
+              worker.messagesReceived.length
+            );
           }
 
           if (done === listeners) {
-            console.error('[PARENT] All workers have received the ' +
-                          'required number of ' +
-                          'messages. Will now compare.');
+            console.error(
+              '[PARENT] All workers have received the ' +
+                'required number of ' +
+                'messages. Will now compare.'
+            );
 
             Object.keys(workers).forEach(function(pid) {
               const worker = workers[pid];
@@ -146,9 +153,11 @@ if (process.argv[2] !== 'child') {
                 }
               });
 
-              console.error('[PARENT] %d received %d matching messages.',
-                            worker.pid,
-                            count);
+              console.error(
+                '[PARENT] %d received %d matching messages.',
+                worker.pid,
+                count
+              );
 
               assert.strictEqual(count, messages.length);
             });
@@ -182,7 +191,9 @@ if (process.argv[2] !== 'child') {
     const buf = messages[i++];
 
     if (!buf) {
-      try { sendSocket.close(); } catch {}
+      try {
+        sendSocket.close();
+      } catch {}
       return;
     }
 
@@ -194,9 +205,12 @@ if (process.argv[2] !== 'child') {
       LOCAL_BROADCAST_HOST,
       function(err) {
         assert.ifError(err);
-        console.error('[PARENT] sent %s to %s:%s',
-                      util.inspect(buf.toString()),
-                      LOCAL_BROADCAST_HOST, common.PORT);
+        console.error(
+          '[PARENT] sent %s to %s:%s',
+          util.inspect(buf.toString()),
+          LOCAL_BROADCAST_HOST,
+          common.PORT
+        );
 
         process.nextTick(sendSocket.sendNext);
       }
@@ -222,10 +236,12 @@ if (process.argv[2] === 'child') {
     // receive udp messages only sent from parent
     if (rinfo.address !== bindAddress) return;
 
-    console.error('[CHILD] %s received %s from %j',
-                  process.pid,
-                  util.inspect(buf.toString()),
-                  rinfo);
+    console.error(
+      '[CHILD] %s received %s from %j',
+      process.pid,
+      util.inspect(buf.toString()),
+      rinfo
+    );
 
     receivedMessages.push(buf);
 
diff --git a/test/internet/test-dgram-membership.js b/test/internet/test-dgram-membership.js
index d4bad5c2daa08c..e4902bc2faf3a6 100644
--- a/test/internet/test-dgram-membership.js
+++ b/test/internet/test-dgram-membership.js
@@ -17,10 +17,9 @@ const setup = dgram.createSocket.bind(dgram, { type: 'udp4', reuseAddr: true });
 // dropMembership() without previous addMembership should throw
 {
   const socket = setup();
-  assert.throws(
-    () => { socket.dropMembership(multicastAddress); },
-    /^Error: dropMembership EADDRNOTAVAIL$/
-  );
+  assert.throws(() => {
+    socket.dropMembership(multicastAddress);
+  }, /^Error: dropMembership EADDRNOTAVAIL$/);
   socket.close();
 }
 
diff --git a/test/internet/test-dgram-multicast-multi-process.js b/test/internet/test-dgram-multicast-multi-process.js
index 9d2e2c9f3ffd84..c9e4342a38a274 100644
--- a/test/internet/test-dgram-multicast-multi-process.js
+++ b/test/internet/test-dgram-multicast-multi-process.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 // Skip test in FreeBSD jails.
-if (common.inFreeBSDJail)
-  common.skip('In a FreeBSD jail');
+if (common.inFreeBSDJail) common.skip('In a FreeBSD jail');
 
 const assert = require('assert');
 const dgram = require('dgram');
@@ -41,7 +40,6 @@ const workers = {};
 const listeners = 3;
 let listening, sendSocket, done, timer, dead;
 
-
 function launchChildProcess() {
   const worker = fork(__filename, ['child']);
   workers[worker.pid] = worker;
@@ -57,10 +55,12 @@ function launchChildProcess() {
     }
 
     dead += 1;
-    console.error('[PARENT] Worker %d died. %d dead of %d',
-                  worker.pid,
-                  dead,
-                  listeners);
+    console.error(
+      '[PARENT] Worker %d died. %d dead of %d',
+      worker.pid,
+      dead,
+      listeners
+    );
 
     if (dead === listeners) {
       console.error('[PARENT] All workers have died.');
@@ -85,14 +85,18 @@ function launchChildProcess() {
       if (worker.messagesReceived.length === messages.length) {
         done += 1;
         worker.isDone = true;
-        console.error('[PARENT] %d received %d messages total.',
-                      worker.pid,
-                      worker.messagesReceived.length);
+        console.error(
+          '[PARENT] %d received %d messages total.',
+          worker.pid,
+          worker.messagesReceived.length
+        );
       }
 
       if (done === listeners) {
-        console.error('[PARENT] All workers have received the ' +
-                      'required number of messages. Will now compare.');
+        console.error(
+          '[PARENT] All workers have received the ' +
+            'required number of messages. Will now compare.'
+        );
 
         Object.keys(workers).forEach(function(pid) {
           const worker = workers[pid];
@@ -108,8 +112,11 @@ function launchChildProcess() {
             }
           });
 
-          console.error('[PARENT] %d received %d matching messages.',
-                        worker.pid, count);
+          console.error(
+            '[PARENT] %d received %d matching messages.',
+            worker.pid,
+            count
+          );
 
           assert.strictEqual(count, messages.length);
         });
@@ -137,8 +144,10 @@ if (process.argv[2] !== 'child') {
 
   // Exit the test if it doesn't succeed within TIMEOUT.
   timer = setTimeout(function() {
-    console.error('[PARENT] Responses were not received within %d ms.',
-                  TIMEOUT);
+    console.error(
+      '[PARENT] Responses were not received within %d ms.',
+      TIMEOUT
+    );
     console.error('[PARENT] Fail');
 
     killSubprocesses(workers);
@@ -170,7 +179,9 @@ if (process.argv[2] !== 'child') {
     const buf = messages[i++];
 
     if (!buf) {
-      try { sendSocket.close(); } catch {}
+      try {
+        sendSocket.close();
+      } catch {}
       return;
     }
 
@@ -182,9 +193,12 @@ if (process.argv[2] !== 'child') {
       LOCAL_BROADCAST_HOST,
       function(err) {
         assert.ifError(err);
-        console.error('[PARENT] sent "%s" to %s:%s',
-                      buf.toString(),
-                      LOCAL_BROADCAST_HOST, common.PORT);
+        console.error(
+          '[PARENT] sent "%s" to %s:%s',
+          buf.toString(),
+          LOCAL_BROADCAST_HOST,
+          common.PORT
+        );
         process.nextTick(sendSocket.sendNext);
       }
     );
@@ -202,8 +216,12 @@ if (process.argv[2] === 'child') {
     listenSocket.addMembership(LOCAL_BROADCAST_HOST, LOCAL_HOST_IFADDR);
 
     listenSocket.on('message', function(buf, rinfo) {
-      console.error('[CHILD] %s received "%s" from %j', process.pid,
-                    buf.toString(), rinfo);
+      console.error(
+        '[CHILD] %s received "%s" from %j',
+        process.pid,
+        buf.toString(),
+        rinfo
+      );
 
       receivedMessages.push(buf);
 
diff --git a/test/internet/test-dgram-multicast-set-interface-lo.js b/test/internet/test-dgram-multicast-set-interface-lo.js
index 73ab31884d5eb6..cada95caf29c0b 100644
--- a/test/internet/test-dgram-multicast-set-interface-lo.js
+++ b/test/internet/test-dgram-multicast-set-interface-lo.js
@@ -52,8 +52,7 @@ const interfaceAddress = ((networkInterfaces) => {
       if (!localInterface.internal && localInterface.family === FAM) {
         let interfaceAddress = localInterface.address;
         // On Windows, IPv6 would need: `%${localInterface.scopeid}`
-        if (FAM === 'IPv6')
-          interfaceAddress += `${interfaceAddress}%${name}`;
+        if (FAM === 'IPv6') interfaceAddress += `${interfaceAddress}%${name}`;
         return interfaceAddress;
       }
     }
@@ -65,15 +64,22 @@ assert.ok(interfaceAddress);
 const messages = [
   { tail: 'First message to send', mcast: MULTICASTS[FAM][0], rcv: true },
   { tail: 'Second message to send', mcast: MULTICASTS[FAM][0], rcv: true },
-  { tail: 'Third message to send', mcast: MULTICASTS[FAM][1], rcv: true,
-    newAddr: interfaceAddress },
+  {
+    tail: 'Third message to send',
+    mcast: MULTICASTS[FAM][1],
+    rcv: true,
+    newAddr: interfaceAddress
+  },
   { tail: 'Fourth message to send', mcast: MULTICASTS[FAM][2] },
   { tail: 'Fifth message to send', mcast: MULTICASTS[FAM][1], rcv: true },
-  { tail: 'Sixth message to send', mcast: MULTICASTS[FAM][2], rcv: true,
-    newAddr: LOOPBACK[FAM] }
+  {
+    tail: 'Sixth message to send',
+    mcast: MULTICASTS[FAM][2],
+    rcv: true,
+    newAddr: LOOPBACK[FAM]
+  }
 ];
 
-
 if (process.argv[2] !== 'child') {
   const IFACES = [ANY[FAM], interfaceAddress, LOOPBACK[FAM]];
   const workers = {};
@@ -85,8 +91,10 @@ if (process.argv[2] !== 'child') {
   let timer = null;
   // Exit the test if it doesn't succeed within the TIMEOUT.
   timer = setTimeout(function() {
-    console.error('[PARENT] Responses were not received within %d ms.',
-                  TIMEOUT);
+    console.error(
+      '[PARENT] Responses were not received within %d ms.',
+      TIMEOUT
+    );
     console.error('[PARENT] Skip');
 
     killSubprocesses(workers);
@@ -100,15 +108,16 @@ if (process.argv[2] !== 'child') {
     const IFACE = IFACES[i % IFACES.length];
     const MULTICAST = MULTICASTS[FAM][i % MULTICASTS[FAM].length];
 
-    const messagesNeeded = messages.filter((m) => m.rcv &&
-                                                  m.mcast === MULTICAST)
-                                   .map((m) => TMPL(m.tail));
-    const worker = fork(process.argv[1],
-                        ['child',
-                         IFACE,
-                         MULTICAST,
-                         messagesNeeded.length,
-                         NOW]);
+    const messagesNeeded = messages
+      .filter((m) => m.rcv && m.mcast === MULTICAST)
+      .map((m) => TMPL(m.tail));
+    const worker = fork(process.argv[1], [
+      'child',
+      IFACE,
+      MULTICAST,
+      messagesNeeded.length,
+      NOW
+    ]);
     workers[worker.pid] = worker;
 
     worker.messagesReceived = [];
@@ -123,10 +132,12 @@ if (process.argv[2] !== 'child') {
       }
 
       dead += 1;
-      console.error('[PARENT] Worker %d died. %d dead of %d',
-                    worker.pid,
-                    dead,
-                    listeners);
+      console.error(
+        '[PARENT] Worker %d died. %d dead of %d',
+        worker.pid,
+        dead,
+        listeners
+      );
 
       if (dead === listeners) {
         console.error('[PARENT] All workers have died.');
@@ -152,15 +163,19 @@ if (process.argv[2] !== 'child') {
         if (worker.messagesReceived.length === worker.messagesNeeded.length) {
           done += 1;
           worker.isDone = true;
-          console.error('[PARENT] %d received %d messages total.',
-                        worker.pid,
-                        worker.messagesReceived.length);
+          console.error(
+            '[PARENT] %d received %d messages total.',
+            worker.pid,
+            worker.messagesReceived.length
+          );
         }
 
         if (done === listeners) {
-          console.error('[PARENT] All workers have received the ' +
-                        'required number of ' +
-                        'messages. Will now compare.');
+          console.error(
+            '[PARENT] All workers have received the ' +
+              'required number of ' +
+              'messages. Will now compare.'
+          );
 
           Object.keys(workers).forEach(function(pid) {
             const worker = workers[pid];
@@ -176,13 +191,17 @@ if (process.argv[2] !== 'child') {
               }
             });
 
-            console.error('[PARENT] %d received %d matching messages.',
-                          worker.pid,
-                          count);
-
-            assert.strictEqual(count, worker.messagesNeeded.length,
-                               'A worker received ' +
-                               'an invalid multicast message');
+            console.error(
+              '[PARENT] %d received %d matching messages.',
+              worker.pid,
+              count
+            );
+
+            assert.strictEqual(
+              count,
+              worker.messagesNeeded.length,
+              'A worker received ' + 'an invalid multicast message'
+            );
           });
 
           clearTimeout(timer);
@@ -222,26 +241,23 @@ if (process.argv[2] !== 'child') {
       console.error(`changing outgoing multicast ${msg.newAddr}`);
       sendSocket.setMulticastInterface(msg.newAddr);
     }
-    sendSocket.send(
-      buf,
-      0,
-      buf.length,
-      PORTS[msg.mcast],
-      msg.mcast,
-      function(err) {
-        assert.ifError(err);
-        console.error('[PARENT] sent %s to %s:%s',
-                      util.inspect(buf.toString()),
-                      msg.mcast, PORTS[msg.mcast]);
-
-        process.nextTick(sendSocket.sendNext);
-      }
-    );
+    sendSocket.send(buf, 0, buf.length, PORTS[msg.mcast], msg.mcast, function(
+      err
+    ) {
+      assert.ifError(err);
+      console.error(
+        '[PARENT] sent %s to %s:%s',
+        util.inspect(buf.toString()),
+        msg.mcast,
+        PORTS[msg.mcast]
+      );
+
+      process.nextTick(sendSocket.sendNext);
+    });
   };
 
   function killSubprocesses(subprocesses) {
-    for (const i in subprocesses)
-      subprocesses[i].kill();
+    for (const i in subprocesses) subprocesses[i].kill();
   }
 }
 
@@ -262,10 +278,12 @@ if (process.argv[2] === 'child') {
     // Examine udp messages only when they were sent by the parent.
     if (!buf.toString().startsWith(SESSION)) return;
 
-    console.error('[CHILD] %s received %s from %j',
-                  process.pid,
-                  util.inspect(buf.toString()),
-                  rinfo);
+    console.error(
+      '[CHILD] %s received %s from %j',
+      process.pid,
+      util.inspect(buf.toString()),
+      rinfo
+    );
 
     receivedMessages.push(buf);
 
@@ -279,14 +297,11 @@ if (process.argv[2] === 'child') {
     process.send({ message: buf.toString() }, closecb);
   });
 
-
   listenSocket.on('listening', function() {
     listenSocket.addMembership(MULTICAST, IFACE);
     process.send({ listening: true });
   });
 
-  if (common.isWindows)
-    listenSocket.bind(PORTS[MULTICAST], ANY[FAM]);
-  else
-    listenSocket.bind(common.PORT, MULTICAST);
+  if (common.isWindows) listenSocket.bind(PORTS[MULTICAST], ANY[FAM]);
+  else listenSocket.bind(common.PORT, MULTICAST);
 }
diff --git a/test/internet/test-dgram-send-cb-quelches-error.js b/test/internet/test-dgram-send-cb-quelches-error.js
index 946b6bbb455325..da9aff4be72aa8 100644
--- a/test/internet/test-dgram-send-cb-quelches-error.js
+++ b/test/internet/test-dgram-send-cb-quelches-error.js
@@ -17,8 +17,14 @@ socket.once('error', onEvent);
 // * error is never emitter for missing dns entries
 //   if a callback that handles error is present
 // * error is emitted if a callback with no argument is passed
-socket.send(buffer, 0, buffer.length, 100,
-            'dne.example.com', mustCall(callbackOnly));
+socket.send(
+  buffer,
+  0,
+  buffer.length,
+  100,
+  'dne.example.com',
+  mustCall(callbackOnly)
+);
 
 function callbackOnly(err) {
   assert.ok(err);
diff --git a/test/internet/test-dns-any.js b/test/internet/test-dns-any.js
index e8425a6ca5632d..e8309527eb7ba1 100644
--- a/test/internet/test-dns-any.js
+++ b/test/internet/test-dns-any.js
@@ -13,7 +13,7 @@ const dnsPromises = dns.promises;
 const isIPv4 = net.isIPv4;
 const isIPv6 = net.isIPv6;
 
-dns.setServers([ '8.8.8.8', '8.8.4.4' ]);
+dns.setServers(['8.8.8.8', '8.8.4.4']);
 
 function checkWrap(req) {
   assert.ok(typeof req === 'object');
@@ -119,8 +119,8 @@ TEST(async function test_google(done) {
   function validateResult(res) {
     const types = processResult(res);
     assert.ok(
-      types.A && types.AAAA && types.MX &&
-      types.NS && types.TXT && types.SOA);
+      types.A && types.AAAA && types.MX && types.NS && types.TXT && types.SOA
+    );
   }
 
   validateResult(await dnsPromises.resolve('google.com', 'ANY'));
@@ -132,7 +132,8 @@ TEST(async function test_google(done) {
       assert.ifError(err);
       validateResult(ret);
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -152,7 +153,8 @@ TEST(async function test_sip2sip_for_naptr(done) {
       assert.ifError(err);
       validateResult(ret);
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -172,7 +174,8 @@ TEST(async function test_google_for_cname_and_srv(done) {
       assert.ifError(err);
       validateResult(ret);
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -192,7 +195,8 @@ TEST(async function test_ptr(done) {
       assert.ifError(err);
       validateResult(ret);
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
diff --git a/test/internet/test-dns-cares-domains.js b/test/internet/test-dns-cares-domains.js
index 6609758a7daf17..8f21e043af45ce 100644
--- a/test/internet/test-dns-cares-domains.js
+++ b/test/internet/test-dns-cares-domains.js
@@ -21,8 +21,11 @@ const methods = [
 methods.forEach(function(method) {
   const d = domain.create();
   d.run(function() {
-    dns[method](addresses.INET_HOST, common.mustCall(() => {
-      assert.strictEqual(process.domain, d, `${method} retains domain`);
-    }));
+    dns[method](
+      addresses.INET_HOST,
+      common.mustCall(() => {
+        assert.strictEqual(process.domain, d, `${method} retains domain`);
+      })
+    );
   });
 });
diff --git a/test/internet/test-dns-ipv4.js b/test/internet/test-dns-ipv4.js
index 1179cd6f5d6c7f..ef97294261d8f5 100644
--- a/test/internet/test-dns-ipv4.js
+++ b/test/internet/test-dns-ipv4.js
@@ -54,7 +54,8 @@ TEST(async function test_resolve4(done) {
       assert.ifError(err);
       validateResult(ips);
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -77,7 +78,8 @@ TEST(async function test_reverse_ipv4(done) {
       assert.ifError(err);
       validateResult(domains);
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -91,12 +93,14 @@ TEST(async function test_lookup_ipv4_explicit(done) {
   validateResult(await dnsPromises.lookup(addresses.INET4_HOST, 4));
 
   const req = dns.lookup(
-    addresses.INET4_HOST, 4,
+    addresses.INET4_HOST,
+    4,
     common.mustCall((err, ip, family) => {
       assert.ifError(err);
       validateResult({ address: ip, family });
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -115,7 +119,8 @@ TEST(async function test_lookup_ipv4_implicit(done) {
       assert.ifError(err);
       validateResult({ address: ip, family });
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -128,13 +133,17 @@ TEST(async function test_lookup_ipv4_explicit_object(done) {
 
   validateResult(await dnsPromises.lookup(addresses.INET4_HOST, { family: 4 }));
 
-  const req = dns.lookup(addresses.INET4_HOST, {
-    family: 4
-  }, common.mustCall((err, ip, family) => {
-    assert.ifError(err);
-    validateResult({ address: ip, family });
-    done();
-  }));
+  const req = dns.lookup(
+    addresses.INET4_HOST,
+    {
+      family: 4
+    },
+    common.mustCall((err, ip, family) => {
+      assert.ifError(err);
+      validateResult({ address: ip, family });
+      done();
+    })
+  );
 
   checkWrap(req);
 });
@@ -145,17 +154,23 @@ TEST(async function test_lookup_ipv4_hint_addrconfig(done) {
     assert.strictEqual(res.family, 4);
   }
 
-  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, {
-    hints: dns.ADDRCONFIG
-  }));
+  validateResult(
+    await dnsPromises.lookup(addresses.INET4_HOST, {
+      hints: dns.ADDRCONFIG
+    })
+  );
 
-  const req = dns.lookup(addresses.INET4_HOST, {
-    hints: dns.ADDRCONFIG
-  }, common.mustCall((err, ip, family) => {
-    assert.ifError(err);
-    validateResult({ address: ip, family });
-    done();
-  }));
+  const req = dns.lookup(
+    addresses.INET4_HOST,
+    {
+      hints: dns.ADDRCONFIG
+    },
+    common.mustCall((err, ip, family) => {
+      assert.ifError(err);
+      validateResult({ address: ip, family });
+      done();
+    })
+  );
 
   checkWrap(req);
 });
@@ -168,12 +183,14 @@ TEST(async function test_lookup_ip_ipv4(done) {
 
   validateResult(await dnsPromises.lookup('127.0.0.1'));
 
-  const req = dns.lookup('127.0.0.1',
-                         common.mustCall((err, ip, family) => {
-                           assert.ifError(err);
-                           validateResult({ address: ip, family });
-                           done();
-                         }));
+  const req = dns.lookup(
+    '127.0.0.1',
+    common.mustCall((err, ip, family) => {
+      assert.ifError(err);
+      validateResult({ address: ip, family });
+      done();
+    })
+  );
 
   checkWrap(req);
 });
@@ -186,12 +203,15 @@ TEST(async function test_lookup_localhost_ipv4(done) {
 
   validateResult(await dnsPromises.lookup('localhost', 4));
 
-  const req = dns.lookup('localhost', 4,
-                         common.mustCall((err, ip, family) => {
-                           assert.ifError(err);
-                           validateResult({ address: ip, family });
-                           done();
-                         }));
+  const req = dns.lookup(
+    'localhost',
+    4,
+    common.mustCall((err, ip, family) => {
+      assert.ifError(err);
+      validateResult({ address: ip, family });
+      done();
+    })
+  );
 
   checkWrap(req);
 });
@@ -207,10 +227,12 @@ TEST(async function test_lookup_all_ipv4(done) {
     });
   }
 
-  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, {
-    all: true,
-    family: 4
-  }));
+  validateResult(
+    await dnsPromises.lookup(addresses.INET4_HOST, {
+      all: true,
+      family: 4
+    })
+  );
 
   const req = dns.lookup(
     addresses.INET4_HOST,
@@ -235,7 +257,8 @@ TEST(async function test_lookupservice_ip_ipv4(done) {
   validateResult(await dnsPromises.lookupService('127.0.0.1', 80));
 
   const req = dns.lookupService(
-    '127.0.0.1', 80,
+    '127.0.0.1',
+    80,
     common.mustCall((err, hostname, service) => {
       assert.ifError(err);
       validateResult({ hostname, service });
@@ -247,11 +270,14 @@ TEST(async function test_lookupservice_ip_ipv4(done) {
 });
 
 TEST(function test_lookupservice_ip_ipv4_promise(done) {
-  util.promisify(dns.lookupService)('127.0.0.1', 80)
-    .then(common.mustCall(({ hostname, service }) => {
-      assert.strictEqual(typeof hostname, 'string');
-      assert(hostname.length > 0);
-      assert(['http', 'www', '80'].includes(service));
-      done();
-    }));
+  util
+    .promisify(dns.lookupService)('127.0.0.1', 80)
+    .then(
+      common.mustCall(({ hostname, service }) => {
+        assert.strictEqual(typeof hostname, 'string');
+        assert(hostname.length > 0);
+        assert(['http', 'www', '80'].includes(service));
+        done();
+      })
+    );
 });
diff --git a/test/internet/test-dns-ipv6.js b/test/internet/test-dns-ipv6.js
index b2cd6163e8007c..2844ed6a335132 100644
--- a/test/internet/test-dns-ipv6.js
+++ b/test/internet/test-dns-ipv6.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 const { addresses } = require('../common/internet');
-if (!common.hasIPv6)
-  common.skip('this test, no IPv6 support');
+if (!common.hasIPv6) common.skip('this test, no IPv6 support');
 
 const assert = require('assert');
 const dns = require('dns');
@@ -56,7 +55,8 @@ TEST(async function test_resolve6(done) {
       assert.ifError(err);
       validateResult(ips);
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -78,7 +78,8 @@ TEST(async function test_reverse_ipv6(done) {
       assert.ifError(err);
       validateResult(domains);
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -98,7 +99,8 @@ TEST(async function test_lookup_ipv6_explicit(done) {
       assert.ifError(err);
       validateResult({ address: ip, family });
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -125,41 +127,49 @@ TEST(async function test_lookup_ipv6_explicit_object(done) {
 
   validateResult(await dnsPromises.lookup(addresses.INET6_HOST, { family: 6 }));
 
-  const req = dns.lookup(addresses.INET6_HOST, {
-    family: 6
-  }, common.mustCall((err, ip, family) => {
-    assert.ifError(err);
-    validateResult({ address: ip, family });
-    done();
-  }));
+  const req = dns.lookup(
+    addresses.INET6_HOST,
+    {
+      family: 6
+    },
+    common.mustCall((err, ip, family) => {
+      assert.ifError(err);
+      validateResult({ address: ip, family });
+      done();
+    })
+  );
 
   checkWrap(req);
 });
 
 TEST(function test_lookup_ipv6_hint(done) {
-  const req = dns.lookup(addresses.INET6_HOST, {
-    family: 6,
-    hints: dns.V4MAPPED
-  }, common.mustCall((err, ip, family) => {
-    if (err) {
-      // FreeBSD does not support V4MAPPED
-      if (common.isFreeBSD) {
-        assert(err instanceof Error);
-        assert.strictEqual(err.code, 'EAI_BADFLAGS');
-        assert.strictEqual(err.hostname, addresses.INET_HOST);
-        assert.ok(/getaddrinfo EAI_BADFLAGS/.test(err.message));
-        done();
-        return;
+  const req = dns.lookup(
+    addresses.INET6_HOST,
+    {
+      family: 6,
+      hints: dns.V4MAPPED
+    },
+    common.mustCall((err, ip, family) => {
+      if (err) {
+        // FreeBSD does not support V4MAPPED
+        if (common.isFreeBSD) {
+          assert(err instanceof Error);
+          assert.strictEqual(err.code, 'EAI_BADFLAGS');
+          assert.strictEqual(err.hostname, addresses.INET_HOST);
+          assert.ok(/getaddrinfo EAI_BADFLAGS/.test(err.message));
+          done();
+          return;
+        }
+
+        assert.ifError(err);
       }
 
-      assert.ifError(err);
-    }
-
-    assert.ok(isIPv6(ip));
-    assert.strictEqual(family, 6);
+      assert.ok(isIPv6(ip));
+      assert.strictEqual(family, 6);
 
-    done();
-  }));
+      done();
+    })
+  );
 
   checkWrap(req);
 });
@@ -178,7 +188,8 @@ TEST(async function test_lookup_ip_ipv6(done) {
       assert.ifError(err);
       validateResult({ address: ip, family });
       done();
-    }));
+    })
+  );
 
   checkWrap(req);
 });
@@ -189,16 +200,17 @@ TEST(async function test_lookup_all_ipv6(done) {
     assert.ok(res.length > 0);
 
     res.forEach((ip) => {
-      assert.ok(isIPv6(ip.address),
-                `Invalid IPv6: ${ip.address.toString()}`);
+      assert.ok(isIPv6(ip.address), `Invalid IPv6: ${ip.address.toString()}`);
       assert.strictEqual(ip.family, 6);
     });
   }
 
-  validateResult(await dnsPromises.lookup(addresses.INET6_HOST, {
-    all: true,
-    family: 6
-  }));
+  validateResult(
+    await dnsPromises.lookup(addresses.INET6_HOST, {
+      all: true,
+      family: 6
+    })
+  );
 
   const req = dns.lookup(
     addresses.INET6_HOST,
@@ -215,7 +227,8 @@ TEST(async function test_lookup_all_ipv6(done) {
 
 TEST(function test_lookupservice_ip_ipv6(done) {
   const req = dns.lookupService(
-    '::1', 80,
+    '::1',
+    80,
     common.mustCall((err, host, service) => {
       if (err) {
         // Not skipping the test, rather checking an alternative result,
diff --git a/test/internet/test-dns-lookup.js b/test/internet/test-dns-lookup.js
index df5ccf99a56fc3..9430086a01e791 100644
--- a/test/internet/test-dns-lookup.js
+++ b/test/internet/test-dns-lookup.js
@@ -31,16 +31,20 @@ assert.rejects(
   }
 );
 
-dns.lookup(addresses.INVALID_HOST, {
-  hints: 0,
-  family: 0,
-  all: true
-}, common.mustCall((error) => {
-  assert.strictEqual(error.code, 'ENOTFOUND');
-  assert.strictEqual(
-    error.message,
-    `getaddrinfo ENOTFOUND ${addresses.INVALID_HOST}`
-  );
-  assert.strictEqual(error.syscall, 'getaddrinfo');
-  assert.strictEqual(error.hostname, addresses.INVALID_HOST);
-}));
+dns.lookup(
+  addresses.INVALID_HOST,
+  {
+    hints: 0,
+    family: 0,
+    all: true
+  },
+  common.mustCall((error) => {
+    assert.strictEqual(error.code, 'ENOTFOUND');
+    assert.strictEqual(
+      error.message,
+      `getaddrinfo ENOTFOUND ${addresses.INVALID_HOST}`
+    );
+    assert.strictEqual(error.syscall, 'getaddrinfo');
+    assert.strictEqual(error.hostname, addresses.INVALID_HOST);
+  })
+);
diff --git a/test/internet/test-dns-promises-resolve.js b/test/internet/test-dns-promises-resolve.js
index 430f4251379097..de66629a1a3661 100644
--- a/test/internet/test-dns-promises-resolve.js
+++ b/test/internet/test-dns-promises-resolve.js
@@ -7,28 +7,23 @@ const dnsPromises = require('dns').promises;
 // Error when rrtype is invalid.
 {
   const rrtype = 'DUMMY';
-  common.expectsError(
-    () => dnsPromises.resolve('example.org', rrtype),
-    {
-      code: 'ERR_INVALID_OPT_VALUE',
-      type: TypeError,
-      message: `The value "${rrtype}" is invalid for option "rrtype"`
-    }
-  );
+  common.expectsError(() => dnsPromises.resolve('example.org', rrtype), {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: TypeError,
+    message: `The value "${rrtype}" is invalid for option "rrtype"`
+  });
 }
 
 // Error when rrtype is a number.
 {
   const rrtype = 0;
-  common.expectsError(
-    () => dnsPromises.resolve('example.org', rrtype),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "rrtype" argument must be of type string. ' +
-               `Received type ${typeof rrtype}`
-    }
-  );
+  common.expectsError(() => dnsPromises.resolve('example.org', rrtype), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "rrtype" argument must be of type string. ' +
+      `Received type ${typeof rrtype}`
+  });
 }
 
 // rrtype is undefined, it's same as resolve4
diff --git a/test/internet/test-dns-setserver-in-callback-of-resolve4.js b/test/internet/test-dns-setserver-in-callback-of-resolve4.js
index 58b3327efe9475..029cb6b1f36ec3 100644
--- a/test/internet/test-dns-setserver-in-callback-of-resolve4.js
+++ b/test/internet/test-dns-setserver-in-callback-of-resolve4.js
@@ -11,8 +11,9 @@ const dns = require('dns');
 dns.resolve4(
   addresses.INET4_HOST,
   common.mustCall(function(/* err, nameServers */) {
-    dns.setServers([ addresses.DNS4_SERVER ]);
-  }));
+    dns.setServers([addresses.DNS4_SERVER]);
+  })
+);
 
 // Test https://github.com/nodejs/node/issues/14734
 dns.resolve4(addresses.INET4_HOST, common.mustCall());
diff --git a/test/internet/test-dns.js b/test/internet/test-dns.js
index 5c53781fde4a69..d7254e1004c944 100644
--- a/test/internet/test-dns.js
+++ b/test/internet/test-dns.js
@@ -37,7 +37,6 @@ let completed = 0;
 let running = false;
 const queue = [];
 
-
 function TEST(f) {
   function next() {
     const f = queue.shift();
@@ -62,14 +61,13 @@ function TEST(f) {
   }
 }
 
-
 function checkWrap(req) {
   assert.strictEqual(typeof req, 'object');
 }
 
-
 TEST(function test_reverse_bogus(done) {
-  dnsPromises.reverse('bogus ip')
+  dnsPromises
+    .reverse('bogus ip')
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'EINVAL' }));
 
@@ -94,17 +92,23 @@ TEST(async function test_resolve4_ttl(done) {
     }
   }
 
-  validateResult(await dnsPromises.resolve4(addresses.INET4_HOST, {
-    ttl: true
-  }));
+  validateResult(
+    await dnsPromises.resolve4(addresses.INET4_HOST, {
+      ttl: true
+    })
+  );
 
-  const req = dns.resolve4(addresses.INET4_HOST, {
-    ttl: true
-  }, function(err, result) {
-    assert.ifError(err);
-    validateResult(result);
-    done();
-  });
+  const req = dns.resolve4(
+    addresses.INET4_HOST,
+    {
+      ttl: true
+    },
+    function(err, result) {
+      assert.ifError(err);
+      validateResult(result);
+      done();
+    }
+  );
 
   checkWrap(req);
 });
@@ -124,17 +128,23 @@ TEST(async function test_resolve6_ttl(done) {
     }
   }
 
-  validateResult(await dnsPromises.resolve6(addresses.INET6_HOST, {
-    ttl: true
-  }));
+  validateResult(
+    await dnsPromises.resolve6(addresses.INET6_HOST, {
+      ttl: true
+    })
+  );
 
-  const req = dns.resolve6(addresses.INET6_HOST, {
-    ttl: true
-  }, function(err, result) {
-    assert.ifError(err);
-    validateResult(result);
-    done();
-  });
+  const req = dns.resolve6(
+    addresses.INET6_HOST,
+    {
+      ttl: true
+    },
+    function(err, result) {
+      assert.ifError(err);
+      validateResult(result);
+      done();
+    }
+  );
 
   checkWrap(req);
 });
@@ -165,7 +175,8 @@ TEST(async function test_resolveMx(done) {
 });
 
 TEST(function test_resolveMx_failure(done) {
-  dnsPromises.resolveMx(addresses.INVALID_HOST)
+  dnsPromises
+    .resolveMx(addresses.INVALID_HOST)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'ENOTFOUND' }));
 
@@ -205,7 +216,8 @@ TEST(async function test_resolveNs(done) {
 });
 
 TEST(function test_resolveNs_failure(done) {
-  dnsPromises.resolveNs(addresses.INVALID_HOST)
+  dnsPromises
+    .resolveNs(addresses.INVALID_HOST)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'ENOTFOUND' }));
 
@@ -251,7 +263,8 @@ TEST(async function test_resolveSrv(done) {
 });
 
 TEST(function test_resolveSrv_failure(done) {
-  dnsPromises.resolveSrv(addresses.INVALID_HOST)
+  dnsPromises
+    .resolveSrv(addresses.INVALID_HOST)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'ENOTFOUND' }));
 
@@ -290,7 +303,8 @@ TEST(async function test_resolvePtr(done) {
 });
 
 TEST(function test_resolvePtr_failure(done) {
-  dnsPromises.resolvePtr(addresses.INVALID_HOST)
+  dnsPromises
+    .resolvePtr(addresses.INVALID_HOST)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'ENOTFOUND' }));
 
@@ -335,7 +349,8 @@ TEST(async function test_resolveNaptr(done) {
 });
 
 TEST(function test_resolveNaptr_failure(done) {
-  dnsPromises.resolveNaptr(addresses.INVALID_HOST)
+  dnsPromises
+    .resolveNaptr(addresses.INVALID_HOST)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'ENOTFOUND' }));
 
@@ -360,15 +375,15 @@ TEST(async function test_resolveSoa(done) {
     assert.strictEqual(typeof result.hostmaster, 'string');
     assert.ok(result.hostmaster.length > 0);
     assert.strictEqual(typeof result.serial, 'number');
-    assert.ok((result.serial > 0) && (result.serial < 4294967295));
+    assert.ok(result.serial > 0 && result.serial < 4294967295);
     assert.strictEqual(typeof result.refresh, 'number');
-    assert.ok((result.refresh > 0) && (result.refresh < 2147483647));
+    assert.ok(result.refresh > 0 && result.refresh < 2147483647);
     assert.strictEqual(typeof result.retry, 'number');
-    assert.ok((result.retry > 0) && (result.retry < 2147483647));
+    assert.ok(result.retry > 0 && result.retry < 2147483647);
     assert.strictEqual(typeof result.expire, 'number');
-    assert.ok((result.expire > 0) && (result.expire < 2147483647));
+    assert.ok(result.expire > 0 && result.expire < 2147483647);
     assert.strictEqual(typeof result.minttl, 'number');
-    assert.ok((result.minttl >= 0) && (result.minttl < 2147483647));
+    assert.ok(result.minttl >= 0 && result.minttl < 2147483647);
   }
 
   validateResult(await dnsPromises.resolveSoa(addresses.SOA_HOST));
@@ -383,7 +398,8 @@ TEST(async function test_resolveSoa(done) {
 });
 
 TEST(function test_resolveSoa_failure(done) {
-  dnsPromises.resolveSoa(addresses.INVALID_HOST)
+  dnsPromises
+    .resolveSoa(addresses.INVALID_HOST)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'ENOTFOUND' }));
 
@@ -422,7 +438,8 @@ TEST(async function test_resolveCname(done) {
 });
 
 TEST(function test_resolveCname_failure(done) {
-  dnsPromises.resolveCname(addresses.INVALID_HOST)
+  dnsPromises
+    .resolveCname(addresses.INVALID_HOST)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'ENOTFOUND' }));
 
@@ -438,7 +455,6 @@ TEST(function test_resolveCname_failure(done) {
   checkWrap(req);
 });
 
-
 TEST(async function test_resolveTxt(done) {
   function validateResult(result) {
     assert.ok(Array.isArray(result[0]));
@@ -458,7 +474,8 @@ TEST(async function test_resolveTxt(done) {
 });
 
 TEST(function test_resolveTxt_failure(done) {
-  dnsPromises.resolveTxt(addresses.INVALID_HOST)
+  dnsPromises
+    .resolveTxt(addresses.INVALID_HOST)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: 'ENOTFOUND' }));
 
@@ -474,9 +491,9 @@ TEST(function test_resolveTxt_failure(done) {
   checkWrap(req);
 });
 
-
 TEST(function test_lookup_failure(done) {
-  dnsPromises.lookup(addresses.INVALID_HOST, 4)
+  dnsPromises
+    .lookup(addresses.INVALID_HOST, 4)
     .then(common.mustNotCall())
     .catch(common.expectsError({ errno: dns.NOTFOUND }));
 
@@ -493,7 +510,6 @@ TEST(function test_lookup_failure(done) {
   checkWrap(req);
 });
 
-
 TEST(async function test_lookup_ip_all(done) {
   function validateResult(result) {
     assert.ok(Array.isArray(result));
@@ -504,23 +520,23 @@ TEST(async function test_lookup_ip_all(done) {
 
   validateResult(await dnsPromises.lookup('127.0.0.1', { all: true }));
 
-  const req = dns.lookup(
-    '127.0.0.1',
-    { all: true },
-    function(err, ips, family) {
-      assert.ifError(err);
-      assert.strictEqual(family, undefined);
-      validateResult(ips);
-      done();
-    }
-  );
+  const req = dns.lookup('127.0.0.1', { all: true }, function(
+    err,
+    ips,
+    family
+  ) {
+    assert.ifError(err);
+    assert.strictEqual(family, undefined);
+    validateResult(ips);
+    done();
+  });
 
   checkWrap(req);
 });
 
-
 TEST(function test_lookup_ip_all_promise(done) {
-  const req = util.promisify(dns.lookup)('127.0.0.1', { all: true })
+  const req = util
+    .promisify(dns.lookup)('127.0.0.1', { all: true })
     .then(function(ips) {
       assert.ok(Array.isArray(ips));
       assert.ok(ips.length > 0);
@@ -533,9 +549,9 @@ TEST(function test_lookup_ip_all_promise(done) {
   checkWrap(req);
 });
 
-
 TEST(function test_lookup_ip_promise(done) {
-  util.promisify(dns.lookup)('127.0.0.1')
+  util
+    .promisify(dns.lookup)('127.0.0.1')
     .then(function({ address, family }) {
       assert.strictEqual(address, '127.0.0.1');
       assert.strictEqual(family, 4);
@@ -544,7 +560,6 @@ TEST(function test_lookup_ip_promise(done) {
     });
 });
 
-
 TEST(async function test_lookup_null_all(done) {
   assert.deepStrictEqual(await dnsPromises.lookup(null, { all: true }), []);
 
@@ -559,38 +574,38 @@ TEST(async function test_lookup_null_all(done) {
   checkWrap(req);
 });
 
-
 TEST(async function test_lookup_all_mixed(done) {
   function validateResult(result) {
     assert.ok(Array.isArray(result));
     assert.ok(result.length > 0);
 
     result.forEach(function(ip) {
-      if (isIPv4(ip.address))
-        assert.strictEqual(ip.family, 4);
-      else if (isIPv6(ip.address))
-        assert.strictEqual(ip.family, 6);
-      else
-        assert.fail('unexpected IP address');
+      if (isIPv4(ip.address)) assert.strictEqual(ip.family, 4);
+      else if (isIPv6(ip.address)) assert.strictEqual(ip.family, 6);
+      else assert.fail('unexpected IP address');
     });
   }
 
   validateResult(await dnsPromises.lookup(addresses.INET_HOST, { all: true }));
 
-  const req = dns.lookup(addresses.INET_HOST, {
-    all: true
-  }, function(err, ips) {
-    assert.ifError(err);
-    validateResult(ips);
-    done();
-  });
+  const req = dns.lookup(
+    addresses.INET_HOST,
+    {
+      all: true
+    },
+    function(err, ips) {
+      assert.ifError(err);
+      validateResult(ips);
+      done();
+    }
+  );
 
   checkWrap(req);
 });
 
-
 TEST(function test_lookupservice_invalid(done) {
-  dnsPromises.lookupService('1.2.3.4', 80)
+  dnsPromises
+    .lookupService('1.2.3.4', 80)
     .then(common.mustNotCall())
     .catch(common.expectsError({ code: 'ENOTFOUND' }));
 
@@ -605,19 +620,21 @@ TEST(function test_lookupservice_invalid(done) {
   checkWrap(req);
 });
 
-
 TEST(function test_reverse_failure(done) {
-  dnsPromises.reverse('203.0.113.0')
+  dnsPromises
+    .reverse('203.0.113.0')
     .then(common.mustNotCall())
-    .catch(common.expectsError({
-      code: 'ENOTFOUND',
-      hostname: '203.0.113.0'
-    }));
+    .catch(
+      common.expectsError({
+        code: 'ENOTFOUND',
+        hostname: '203.0.113.0'
+      })
+    );
 
   // 203.0.113.0/24 are addresses reserved for (RFC) documentation use only
   const req = dns.reverse('203.0.113.0', function(err) {
     assert(err instanceof Error);
-    assert.strictEqual(err.code, 'ENOTFOUND');  // Silly error code...
+    assert.strictEqual(err.code, 'ENOTFOUND'); // Silly error code...
     assert.strictEqual(err.hostname, '203.0.113.0');
     assert.ok(/203\.0\.113\.0/.test(err.message));
 
@@ -627,18 +644,20 @@ TEST(function test_reverse_failure(done) {
   checkWrap(req);
 });
 
-
 TEST(function test_lookup_failure(done) {
-  dnsPromises.lookup(addresses.INVALID_HOST)
+  dnsPromises
+    .lookup(addresses.INVALID_HOST)
     .then(common.mustNotCall())
-    .catch(common.expectsError({
-      code: 'ENOTFOUND',
-      hostname: addresses.INVALID_HOST
-    }));
+    .catch(
+      common.expectsError({
+        code: 'ENOTFOUND',
+        hostname: addresses.INVALID_HOST
+      })
+    );
 
   const req = dns.lookup(addresses.INVALID_HOST, (err) => {
     assert(err instanceof Error);
-    assert.strictEqual(err.code, 'ENOTFOUND');  // Silly error code...
+    assert.strictEqual(err.code, 'ENOTFOUND'); // Silly error code...
     assert.strictEqual(err.hostname, addresses.INVALID_HOST);
     assert.ok(err.message.includes(addresses.INVALID_HOST));
 
@@ -648,7 +667,6 @@ TEST(function test_lookup_failure(done) {
   checkWrap(req);
 });
 
-
 TEST(function test_resolve_failure(done) {
   const req = dns.resolve4(addresses.INVALID_HOST, (err) => {
     assert(err instanceof Error);
@@ -658,7 +676,7 @@ TEST(function test_resolve_failure(done) {
       case 'ESERVFAIL':
         break;
       default:
-        assert.strictEqual(err.code, 'ENOTFOUND');  // Silly error code...
+        assert.strictEqual(err.code, 'ENOTFOUND'); // Silly error code...
         break;
     }
 
@@ -671,15 +689,19 @@ TEST(function test_resolve_failure(done) {
   checkWrap(req);
 });
 
-
 let getaddrinfoCallbackCalled = false;
 
 console.log(`looking up ${addresses.INET4_HOST}..`);
 
 const cares = internalBinding('cares_wrap');
 const req = new cares.GetAddrInfoReqWrap();
-cares.getaddrinfo(req, addresses.INET4_HOST, 4,
-  /* hints */ 0, /* verbatim */ true);
+cares.getaddrinfo(
+  req,
+  addresses.INET4_HOST,
+  4,
+  /* hints */ 0,
+  /* verbatim */ true
+);
 
 req.oncomplete = function(err, domains) {
   assert.strictEqual(err, 0);
diff --git a/test/internet/test-http-dns-fail.js b/test/internet/test-http-dns-fail.js
index 82a7030465dbc9..18752a6bead085 100644
--- a/test/internet/test-http-dns-fail.js
+++ b/test/internet/test-http-dns-fail.js
@@ -32,17 +32,23 @@ const http = require('http');
 function httpreq(count) {
   if (count > 1) return;
 
-  const req = http.request({
-    host: 'not-a-real-domain-name.nobody-would-register-this-as-a-tld',
-    port: 80,
-    path: '/',
-    method: 'GET'
-  }, common.mustNotCall());
+  const req = http.request(
+    {
+      host: 'not-a-real-domain-name.nobody-would-register-this-as-a-tld',
+      port: 80,
+      path: '/',
+      method: 'GET'
+    },
+    common.mustNotCall()
+  );
 
-  req.on('error', common.mustCall((e) => {
-    assert.strictEqual(e.code, 'ENOTFOUND');
-    httpreq(count + 1);
-  }));
+  req.on(
+    'error',
+    common.mustCall((e) => {
+      assert.strictEqual(e.code, 'ENOTFOUND');
+      httpreq(count + 1);
+    })
+  );
 
   req.end();
 }
diff --git a/test/internet/test-http-https-default-ports.js b/test/internet/test-http-https-default-ports.js
index ddf4c5d73902bc..07c666f31688d4 100644
--- a/test/internet/test-http-https-default-ports.js
+++ b/test/internet/test-http-https-default-ports.js
@@ -23,17 +23,22 @@
 const common = require('../common');
 const { addresses } = require('../common/internet');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const https = require('https');
 
 const http = require('http');
 
-https.get(`https://${addresses.INET_HOST}/`, common.mustCall((res) => {
-  res.resume();
-}));
+https.get(
+  `https://${addresses.INET_HOST}/`,
+  common.mustCall((res) => {
+    res.resume();
+  })
+);
 
-http.get(`http://${addresses.INET_HOST}/`, common.mustCall((res) => {
-  res.resume();
-}));
+http.get(
+  `http://${addresses.INET_HOST}/`,
+  common.mustCall((res) => {
+    res.resume();
+  })
+);
diff --git a/test/internet/test-inspector-help-page.js b/test/internet/test-inspector-help-page.js
index a6a38bd0265e78..e284c44a278941 100644
--- a/test/internet/test-inspector-help-page.js
+++ b/test/internet/test-inspector-help-page.js
@@ -3,8 +3,7 @@ const common = require('../common');
 
 common.skipIfInspectorDisabled();
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -14,24 +13,31 @@ const stderr = child.stderr.toString();
 const helpUrl = stderr.match(/For help, see: (.+)/)[1];
 
 function check(url, cb) {
-  https.get(url, common.mustCall((res) => {
-    assert(res.statusCode >= 200 && res.statusCode < 400);
-
-    if (res.statusCode >= 300)
-      return check(res.headers.location, cb);
-
-    let result = '';
-
-    res.setEncoding('utf8');
-    res.on('data', (data) => {
-      result += data;
-    });
-
-    res.on('end', common.mustCall(() => {
-      assert(/>Debugging Guide</.test(result));
-      cb();
-    }));
-  })).on('error', common.mustNotCall);
+  https
+    .get(
+      url,
+      common.mustCall((res) => {
+        assert(res.statusCode >= 200 && res.statusCode < 400);
+
+        if (res.statusCode >= 300) return check(res.headers.location, cb);
+
+        let result = '';
+
+        res.setEncoding('utf8');
+        res.on('data', (data) => {
+          result += data;
+        });
+
+        res.on(
+          'end',
+          common.mustCall(() => {
+            assert(/>Debugging Guide</.test(result));
+            cb();
+          })
+        );
+      })
+    )
+    .on('error', common.mustNotCall);
 }
 
 check(helpUrl, common.mustCall());
diff --git a/test/internet/test-net-connect-timeout.js b/test/internet/test-net-connect-timeout.js
index 5d6d32cc723ff0..a34e55061e5914 100644
--- a/test/internet/test-net-connect-timeout.js
+++ b/test/internet/test-net-connect-timeout.js
@@ -40,11 +40,14 @@ const socket = net.createConnection(9999, '192.0.2.1');
 
 socket.setTimeout(T);
 
-socket.on('timeout', common.mustCall(function() {
-  console.error('timeout');
-  const now = new Date();
-  assert.ok(now - start < T + 500);
-  socket.destroy();
-}));
+socket.on(
+  'timeout',
+  common.mustCall(function() {
+    console.error('timeout');
+    const now = new Date();
+    assert.ok(now - start < T + 500);
+    socket.destroy();
+  })
+);
 
 socket.on('connect', common.mustNotCall());
diff --git a/test/internet/test-tls-add-ca-cert.js b/test/internet/test-tls-add-ca-cert.js
index c3780acd50671a..1c531d222647be 100644
--- a/test/internet/test-tls-add-ca-cert.js
+++ b/test/internet/test-tls-add-ca-cert.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // Test interaction of compiled-in CAs with user-provided CAs.
 
@@ -28,13 +27,24 @@ const opts = {
 };
 
 // Success relies on the compiled in well-known root CAs
-tls.connect(opts, common.mustCall(end));
+tls.connect(
+  opts,
+  common.mustCall(end)
+);
 
 // The .ca option replaces the well-known roots, so connection fails.
 opts.ca = caCert;
-tls.connect(opts, fail).on('error', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'unable to get local issuer certificate');
-}));
+tls
+  .connect(
+    opts,
+    fail
+  )
+  .on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.message, 'unable to get local issuer certificate');
+    })
+  );
 
 function fail() {
   assert.fail('should fail to connect');
@@ -42,12 +52,18 @@ function fail() {
 
 // New secure contexts have the well-known root CAs.
 opts.secureContext = tls.createSecureContext();
-tls.connect(opts, common.mustCall(end));
+tls.connect(
+  opts,
+  common.mustCall(end)
+);
 
 // Explicit calls to addCACert() add to the default well-known roots, instead
 // of replacing, so connection still succeeds.
 opts.secureContext.context.addCACert(caCert);
-tls.connect(opts, common.mustCall(end));
+tls.connect(
+  opts,
+  common.mustCall(end)
+);
 
 function end() {
   this.end();
diff --git a/test/internet/test-tls-connnect-melissadata.js b/test/internet/test-tls-connnect-melissadata.js
index ab5aa3950938b3..0802e207ca79eb 100644
--- a/test/internet/test-tls-connnect-melissadata.js
+++ b/test/internet/test-tls-connnect-melissadata.js
@@ -3,11 +3,14 @@
 // certification between Starfield Class 2 and ValiCert Class 2
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
-const socket = tls.connect(443, 'address.melissadata.net', function() {
-  socket.resume();
-  socket.destroy();
-});
+const socket = tls.connect(
+  443,
+  'address.melissadata.net',
+  function() {
+    socket.resume();
+    socket.destroy();
+  }
+);
diff --git a/test/internet/test-tls-reuse-host-from-socket.js b/test/internet/test-tls-reuse-host-from-socket.js
index f7093856c6ab95..ed580335f961b1 100644
--- a/test/internet/test-tls-reuse-host-from-socket.js
+++ b/test/internet/test-tls-reuse-host-from-socket.js
@@ -22,16 +22,22 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
 const net = require('net');
 
-const socket = net.connect(443, 'www.example.org', common.mustCall(() => {
-  const secureSocket = tls.connect({ socket }, common.mustCall(() => {
-    secureSocket.destroy();
-    console.log('ok');
-  }));
-}));
+const socket = net.connect(
+  443,
+  'www.example.org',
+  common.mustCall(() => {
+    const secureSocket = tls.connect(
+      { socket },
+      common.mustCall(() => {
+        secureSocket.destroy();
+        console.log('ok');
+      })
+    );
+  })
+);
diff --git a/test/internet/test-trace-events-dns.js b/test/internet/test-trace-events-dns.js
index 9e5a0ccb026c1a..6d1714052aa4ef 100644
--- a/test/internet/test-trace-events-dns.js
+++ b/test/internet/test-trace-events-dns.js
@@ -15,38 +15,37 @@ const traceFile = 'node_trace.1.log';
 tmpdir.refresh();
 process.chdir(tmpdir.path);
 
-const test_str = 'const dns = require("dns");' +
-'const options = {' +
-'  family: 4,' +
-'  hints: dns.ADDRCONFIG | dns.V4MAPPED,' +
-'};';
+const test_str =
+  'const dns = require("dns");' +
+  'const options = {' +
+  '  family: 4,' +
+  '  hints: dns.ADDRCONFIG | dns.V4MAPPED,' +
+  '};';
 
 const tests = {
-  'lookup': 'dns.lookup("example.com", options, (err, address, family) => {});',
-  'lookupService': 'dns.lookupService("127.0.0.1", 22, ' +
-                   '(err, hostname, service) => {});',
-  'reverse': 'dns.reverse("8.8.8.8", (err, hostnames) => {});',
-  'resolveAny': 'dns.resolveAny("example.com", (err, res) => {});',
-  'resolve4': 'dns.resolve4("example.com", (err, res) => {});',
-  'resolve6': 'dns.resolve6("example.com", (err, res) => {});',
-  'resolveCname': 'dns.resolveCname("example.com", (err, res) => {});',
-  'resolveMx': 'dns.resolveMx("example.com", (err, res) => {});',
-  'resolveNs': 'dns.resolveNs("example.com", (err, res) => {});',
-  'resolveTxt': 'dns.resolveTxt("example.com", (err, res) => {});',
-  'resolveSrv': 'dns.resolveSrv("example.com", (err, res) => {});',
-  'resolvePtr': 'dns.resolvePtr("example.com", (err, res) => {});',
-  'resolveNaptr': 'dns.resolveNaptr("example.com", (err, res) => {});',
-  'resolveSoa': 'dns.resolveSoa("example.com", (err, res) => {});'
+  lookup: 'dns.lookup("example.com", options, (err, address, family) => {});',
+  lookupService:
+    'dns.lookupService("127.0.0.1", 22, ' + '(err, hostname, service) => {});',
+  reverse: 'dns.reverse("8.8.8.8", (err, hostnames) => {});',
+  resolveAny: 'dns.resolveAny("example.com", (err, res) => {});',
+  resolve4: 'dns.resolve4("example.com", (err, res) => {});',
+  resolve6: 'dns.resolve6("example.com", (err, res) => {});',
+  resolveCname: 'dns.resolveCname("example.com", (err, res) => {});',
+  resolveMx: 'dns.resolveMx("example.com", (err, res) => {});',
+  resolveNs: 'dns.resolveNs("example.com", (err, res) => {});',
+  resolveTxt: 'dns.resolveTxt("example.com", (err, res) => {});',
+  resolveSrv: 'dns.resolveSrv("example.com", (err, res) => {});',
+  resolvePtr: 'dns.resolvePtr("example.com", (err, res) => {});',
+  resolveNaptr: 'dns.resolveNaptr("example.com", (err, res) => {});',
+  resolveSoa: 'dns.resolveSoa("example.com", (err, res) => {});'
 };
 
 for (const tr in tests) {
-  const proc = cp.spawnSync(process.execPath,
-                            [ '--trace-event-categories',
-                              'node.dns.native',
-                              '-e',
-                              test_str + tests[tr]
-                            ],
-                            { encoding: 'utf8' });
+  const proc = cp.spawnSync(
+    process.execPath,
+    ['--trace-event-categories', 'node.dns.native', '-e', test_str + tests[tr]],
+    { encoding: 'utf8' }
+  );
 
   // Make sure the operation is successful.
   // Don't use assert with a custom message here. Otherwise the
@@ -59,13 +58,16 @@ for (const tr in tests) {
   const file = path.join(tmpdir.path, traceFile);
 
   const data = fs.readFileSync(file);
-  const traces = JSON.parse(data.toString()).traceEvents
-        .filter((trace) => trace.cat !== '__metadata');
+  const traces = JSON.parse(data.toString()).traceEvents.filter(
+    (trace) => trace.cat !== '__metadata'
+  );
 
   assert(traces.length > 0);
 
   // DNS native trace events should be generated.
-  assert(traces.some((trace) => {
-    return (trace.name === tr && trace.pid === proc.pid);
-  }));
+  assert(
+    traces.some((trace) => {
+      return trace.name === tr && trace.pid === proc.pid;
+    })
+  );
 }
diff --git a/test/known_issues/test-cluster-bind-privileged-port.js b/test/known_issues/test-cluster-bind-privileged-port.js
index 6ada04aa030b31..4def2cff9239ac 100644
--- a/test/known_issues/test-cluster-bind-privileged-port.js
+++ b/test/known_issues/test-cluster-bind-privileged-port.js
@@ -7,19 +7,23 @@ const assert = require('assert');
 const cluster = require('cluster');
 const net = require('net');
 
-if (!common.isOSXMojave)
-  assert.fail('Code should fail only on macOS Mojave.');
-
+if (!common.isOSXMojave) assert.fail('Code should fail only on macOS Mojave.');
 
 if (cluster.isMaster) {
-  cluster.fork().on('exit', common.mustCall((exitCode) => {
-    assert.strictEqual(exitCode, 0);
-  }));
+  cluster.fork().on(
+    'exit',
+    common.mustCall((exitCode) => {
+      assert.strictEqual(exitCode, 0);
+    })
+  );
 } else {
   const s = net.createServer(common.mustNotCall());
   s.listen(42, common.mustNotCall('listen should have failed'));
-  s.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.code, 'EACCES');
-    process.disconnect();
-  }));
+  s.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.code, 'EACCES');
+      process.disconnect();
+    })
+  );
 }
diff --git a/test/known_issues/test-cwd-enoent-file.js b/test/known_issues/test-cwd-enoent-file.js
index 0f75896134f7e3..5e68d22fe923ab 100644
--- a/test/known_issues/test-cwd-enoent-file.js
+++ b/test/known_issues/test-cwd-enoent-file.js
@@ -22,8 +22,10 @@ if (process.argv[2] === 'child') {
   const dir = fs.mkdtempSync(`${tmpdir.path}/`);
   process.chdir(dir);
   fs.rmdirSync(dir);
-  assert.throws(process.cwd,
-                /^Error: ENOENT: no such file or directory, uv_cwd$/);
+  assert.throws(
+    process.cwd,
+    /^Error: ENOENT: no such file or directory, uv_cwd$/
+  );
 
   const r = cp.spawnSync(process.execPath, [__filename, 'child']);
 
diff --git a/test/known_issues/test-http-path-contains-unicode.js b/test/known_issues/test-http-path-contains-unicode.js
index a51b07210214b9..30bd80fea55299 100644
--- a/test/known_issues/test-http-path-contains-unicode.js
+++ b/test/known_issues/test-http-path-contains-unicode.js
@@ -12,26 +12,35 @@ const expected = '/café🐶';
 
 assert.strictEqual(expected, '/caf\u{e9}\u{1f436}');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  assert.strictEqual(req.url, expected);
-  req.on('data', common.mustCall(function() {
-  })).on('end', common.mustCall(function() {
-    server.close();
-    res.writeHead(200);
-    res.end('hello world\n');
-  }));
-
-}));
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    assert.strictEqual(req.url, expected);
+    req.on('data', common.mustCall(function() {})).on(
+      'end',
+      common.mustCall(function() {
+        server.close();
+        res.writeHead(200);
+        res.end('hello world\n');
+      })
+    );
+  })
+);
 
 server.listen(0, function() {
-  http.request({
-    port: this.address().port,
-    path: expected,
-    method: 'GET'
-  }, common.mustCall(function(res) {
-    res.resume();
-  })).on('error', function(e) {
-    console.log(e.message);
-    process.exit(1);
-  }).end();
+  http
+    .request(
+      {
+        port: this.address().port,
+        path: expected,
+        method: 'GET'
+      },
+      common.mustCall(function(res) {
+        res.resume();
+      })
+    )
+    .on('error', function(e) {
+      console.log(e.message);
+      process.exit(1);
+    })
+    .end();
 });
diff --git a/test/known_issues/test-inspector-cluster-port-clash.js b/test/known_issues/test-inspector-cluster-port-clash.js
index 0333ffcb98751c..7f3aa3f706226c 100644
--- a/test/known_issues/test-inspector-cluster-port-clash.js
+++ b/test/known_issues/test-inspector-cluster-port-clash.js
@@ -31,18 +31,24 @@ function serialFork() {
     worker.on('error', (err) => assert.fail(err));
     // no common.mustCall since 1 out of 3 should fail
     worker.on('online', () => {
-      worker.on('message', common.mustCall((message) => {
-        ports.push(message.debugPort);
-      }));
+      worker.on(
+        'message',
+        common.mustCall((message) => {
+          ports.push(message.debugPort);
+        })
+      );
     });
-    worker.on('exit', common.mustCall((code, signal) => {
-      assert.strictEqual(signal, null);
-      // worker 2 should fail because of port clash with `server`
-      if (code === 12) {
-        return assert.fail(`worker ${worker.id} failed to bind port`);
-      }
-      assert.strictEqual(code, 0);
-    }));
+    worker.on(
+      'exit',
+      common.mustCall((code, signal) => {
+        assert.strictEqual(signal, null);
+        // worker 2 should fail because of port clash with `server`
+        if (code === 12) {
+          return assert.fail(`worker ${worker.id} failed to bind port`);
+        }
+        assert.strictEqual(code, 0);
+      })
+    );
     worker.on('disconnect', common.mustCall(res));
   });
 }
@@ -52,12 +58,16 @@ if (cluster.isMaster) {
 
   // block one of the ports with a listening socket
   const server = net.createServer();
-  server.listen(clashPort, common.localhostIPv4, common.mustCall(() => {
-    // try to fork 3 workers No.2 should fail
-    Promise.all([serialFork(), serialFork(), serialFork()])
-      .then(common.mustNotCall())
-      .catch((err) => console.error(err));
-  }));
+  server.listen(
+    clashPort,
+    common.localhostIPv4,
+    common.mustCall(() => {
+      // try to fork 3 workers No.2 should fail
+      Promise.all([serialFork(), serialFork(), serialFork()])
+        .then(common.mustNotCall())
+        .catch((err) => console.error(err));
+    })
+  );
   server.unref();
 } else {
   const sentinel = common.mustCall();
diff --git a/test/known_issues/test-repl-require-context.js b/test/known_issues/test-repl-require-context.js
index 2b8737b8671669..56f308bd6abf90 100644
--- a/test/known_issues/test-repl-require-context.js
+++ b/test/known_issues/test-repl-require-context.js
@@ -16,13 +16,16 @@ const r = repl.start({
 
 let output = '';
 outputStream.setEncoding('utf8');
-outputStream.on('data', (data) => output += data);
+outputStream.on('data', (data) => (output += data));
 
-r.on('exit', common.mustCall(() => {
-  const results = output.replace(/^> /mg, '').split('\n');
+r.on(
+  'exit',
+  common.mustCall(() => {
+    const results = output.replace(/^> /gm, '').split('\n');
 
-  assert.deepStrictEqual(results, ['undefined', 'true', 'true', '']);
-}));
+    assert.deepStrictEqual(results, ['undefined', 'true', 'true', '']);
+  })
+);
 
 inputStream.write('const isObject = (obj) => obj.constructor === Object;\n');
 inputStream.write('isObject({});\n');
diff --git a/test/known_issues/test-stdin-is-always-net.socket.js b/test/known_issues/test-stdin-is-always-net.socket.js
index 8db33bd7a5ce37..cc86e5ec7acb3b 100644
--- a/test/known_issues/test-stdin-is-always-net.socket.js
+++ b/test/known_issues/test-stdin-is-always-net.socket.js
@@ -11,13 +11,14 @@ if (process.argv[2] === 'child') {
   return;
 }
 
-const proc = spawn(
-  process.execPath,
-  [__filename, 'child'],
-  { stdio: 'ignore' }
-);
+const proc = spawn(process.execPath, [__filename, 'child'], {
+  stdio: 'ignore'
+});
 // To double-check this test, set stdio to 'pipe' and uncomment the line below.
 // proc.stderr.pipe(process.stderr);
-proc.on('exit', common.mustCall(function(exitCode) {
-  assert.strictEqual(exitCode, 0);
-}));
+proc.on(
+  'exit',
+  common.mustCall(function(exitCode) {
+    assert.strictEqual(exitCode, 0);
+  })
+);
diff --git a/test/known_issues/test-url-parse-conformance.js b/test/known_issues/test-url-parse-conformance.js
index 7be8c16099df59..9fc3144b3fe951 100644
--- a/test/known_issues/test-url-parse-conformance.js
+++ b/test/known_issues/test-url-parse-conformance.js
@@ -5,9 +5,12 @@ require('../common');
 const url = require('url');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
-const tests = require(
-  fixtures.path('wpt', 'url', 'resources', 'urltestdata.json')
-);
+const tests = require(fixtures.path(
+  'wpt',
+  'url',
+  'resources',
+  'urltestdata.json'
+));
 
 let failed = 0;
 let attempted = 0;
@@ -49,8 +52,7 @@ tests.forEach((test) => {
     }
   } catch {
     // If Parse failed and it wasn't supposed to, treat it as a failure.
-    if (!test.failure)
-      failed++;
+    if (!test.failure) failed++;
   }
 });
 
diff --git a/test/known_issues/test-vm-timeout-escape-nexttick.js b/test/known_issues/test-vm-timeout-escape-nexttick.js
index 40937c96d91a69..54858017cfd4cb 100644
--- a/test/known_issues/test-vm-timeout-escape-nexttick.js
+++ b/test/known_issues/test-vm-timeout-escape-nexttick.js
@@ -21,22 +21,24 @@ function loop() {
     const current = hrtime();
     const span = (current - start) / NS_PER_MS;
     if (span >= waitDuration) {
-      throw new Error(
-        `escaped timeout at ${span} milliseconds!`);
+      throw new Error(`escaped timeout at ${span} milliseconds!`);
     }
   }
 }
 
-assert.throws(() => {
-  vm.runInNewContext(
-    'nextTick(loop); loop();',
-    {
-      hrtime,
-      nextTick,
-      loop
-    },
-    { timeout: common.platformTimeout(10) }
-  );
-}, {
-  code: 'ERR_SCRIPT_EXECUTION_TIMEOUT'
-});
+assert.throws(
+  () => {
+    vm.runInNewContext(
+      'nextTick(loop); loop();',
+      {
+        hrtime,
+        nextTick,
+        loop
+      },
+      { timeout: common.platformTimeout(10) }
+    );
+  },
+  {
+    code: 'ERR_SCRIPT_EXECUTION_TIMEOUT'
+  }
+);
diff --git a/test/known_issues/test-vm-timeout-escape-promise.js b/test/known_issues/test-vm-timeout-escape-promise.js
index 4452c83cd182e3..d433ade2b0d0ac 100644
--- a/test/known_issues/test-vm-timeout-escape-promise.js
+++ b/test/known_issues/test-vm-timeout-escape-promise.js
@@ -18,22 +18,24 @@ function loop() {
     const current = hrtime();
     const span = (current - start) / NS_PER_MS;
     if (span >= 100n) {
-      throw new Error(
-        `escaped timeout at ${span} milliseconds!`);
+      throw new Error(`escaped timeout at ${span} milliseconds!`);
     }
   }
 }
 
-assert.throws(() => {
-  vm.runInNewContext(
-    'Promise.resolve().then(loop); loop();',
-    {
-      hrtime,
-      loop
-    },
-    { timeout: 5 }
-  );
-}, {
-  code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
-  message: 'Script execution timed out after 5ms'
-});
+assert.throws(
+  () => {
+    vm.runInNewContext(
+      'Promise.resolve().then(loop); loop();',
+      {
+        hrtime,
+        loop
+      },
+      { timeout: 5 }
+    );
+  },
+  {
+    code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
+    message: 'Script execution timed out after 5ms'
+  }
+);
diff --git a/test/known_issues/test-vm-timeout-escape-queuemicrotask.js b/test/known_issues/test-vm-timeout-escape-queuemicrotask.js
index 1ed327f7793e7c..f779cdfada4803 100644
--- a/test/known_issues/test-vm-timeout-escape-queuemicrotask.js
+++ b/test/known_issues/test-vm-timeout-escape-queuemicrotask.js
@@ -18,23 +18,25 @@ function loop() {
     const current = hrtime();
     const span = (current - start) / NS_PER_MS;
     if (span >= 100n) {
-      throw new Error(
-        `escaped timeout at ${span} milliseconds!`);
+      throw new Error(`escaped timeout at ${span} milliseconds!`);
     }
   }
 }
 
-assert.throws(() => {
-  vm.runInNewContext(
-    'queueMicrotask(loop); loop();',
-    {
-      hrtime,
-      queueMicrotask,
-      loop
-    },
-    { timeout: common.platformTimeout(5) }
-  );
-}, {
-  code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
-  message: 'Script execution timed out after 5ms'
-});
+assert.throws(
+  () => {
+    vm.runInNewContext(
+      'queueMicrotask(loop); loop();',
+      {
+        hrtime,
+        queueMicrotask,
+        loop
+      },
+      { timeout: common.platformTimeout(5) }
+    );
+  },
+  {
+    code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
+    message: 'Script execution timed out after 5ms'
+  }
+);
diff --git a/test/message/2100bytes.js b/test/message/2100bytes.js
index ff1b51f4653394..649d245cea6fa7 100644
--- a/test/message/2100bytes.js
+++ b/test/message/2100bytes.js
@@ -22,47 +22,49 @@
 'use strict';
 require('../common');
 
-console.log([
-  '_______________________________________________50',
-  '______________________________________________100',
-  '______________________________________________150',
-  '______________________________________________200',
-  '______________________________________________250',
-  '______________________________________________300',
-  '______________________________________________350',
-  '______________________________________________400',
-  '______________________________________________450',
-  '______________________________________________500',
-  '______________________________________________550',
-  '______________________________________________600',
-  '______________________________________________650',
-  '______________________________________________700',
-  '______________________________________________750',
-  '______________________________________________800',
-  '______________________________________________850',
-  '______________________________________________900',
-  '______________________________________________950',
-  '_____________________________________________1000',
-  '_____________________________________________1050',
-  '_____________________________________________1100',
-  '_____________________________________________1150',
-  '_____________________________________________1200',
-  '_____________________________________________1250',
-  '_____________________________________________1300',
-  '_____________________________________________1350',
-  '_____________________________________________1400',
-  '_____________________________________________1450',
-  '_____________________________________________1500',
-  '_____________________________________________1550',
-  '_____________________________________________1600',
-  '_____________________________________________1650',
-  '_____________________________________________1700',
-  '_____________________________________________1750',
-  '_____________________________________________1800',
-  '_____________________________________________1850',
-  '_____________________________________________1900',
-  '_____________________________________________1950',
-  '_____________________________________________2000',
-  '_____________________________________________2050',
-  '_____________________________________________2100'
-].join('\n'));
+console.log(
+  [
+    '_______________________________________________50',
+    '______________________________________________100',
+    '______________________________________________150',
+    '______________________________________________200',
+    '______________________________________________250',
+    '______________________________________________300',
+    '______________________________________________350',
+    '______________________________________________400',
+    '______________________________________________450',
+    '______________________________________________500',
+    '______________________________________________550',
+    '______________________________________________600',
+    '______________________________________________650',
+    '______________________________________________700',
+    '______________________________________________750',
+    '______________________________________________800',
+    '______________________________________________850',
+    '______________________________________________900',
+    '______________________________________________950',
+    '_____________________________________________1000',
+    '_____________________________________________1050',
+    '_____________________________________________1100',
+    '_____________________________________________1150',
+    '_____________________________________________1200',
+    '_____________________________________________1250',
+    '_____________________________________________1300',
+    '_____________________________________________1350',
+    '_____________________________________________1400',
+    '_____________________________________________1450',
+    '_____________________________________________1500',
+    '_____________________________________________1550',
+    '_____________________________________________1600',
+    '_____________________________________________1650',
+    '_____________________________________________1700',
+    '_____________________________________________1750',
+    '_____________________________________________1800',
+    '_____________________________________________1850',
+    '_____________________________________________1900',
+    '_____________________________________________1950',
+    '_____________________________________________2000',
+    '_____________________________________________2050',
+    '_____________________________________________2100'
+  ].join('\n')
+);
diff --git a/test/message/assert_throws_stack.js b/test/message/assert_throws_stack.js
index 36bc5734cae37f..d09f8083ffea9b 100644
--- a/test/message/assert_throws_stack.js
+++ b/test/message/assert_throws_stack.js
@@ -3,4 +3,9 @@
 require('../common');
 const assert = require('assert').strict;
 
-assert.throws(() => { throw new Error('foo'); }, { bar: true });
+assert.throws(
+  () => {
+    throw new Error('foo');
+  },
+  { bar: true }
+);
diff --git a/test/message/eval_messages.js b/test/message/eval_messages.js
index 69dcbd6efa23a7..976d18c5a59aed 100644
--- a/test/message/eval_messages.js
+++ b/test/message/eval_messages.js
@@ -35,12 +35,13 @@ function run(cmd, strict, cb) {
   child.on('close', cb);
 }
 
-const queue =
-  [ 'with(this){__filename}',
-    '42',
-    'throw new Error("hello")',
-    'var x = 100; y = x;',
-    'var ______________________________________________; throw 10' ];
+const queue = [
+  'with(this){__filename}',
+  '42',
+  'throw new Error("hello")',
+  'var x = 100; y = x;',
+  'var ______________________________________________; throw 10'
+];
 
 function go() {
   const c = queue.shift();
diff --git a/test/message/max_tick_depth.js b/test/message/max_tick_depth.js
index 15462157d2160d..8398aa04c982c4 100644
--- a/test/message/max_tick_depth.js
+++ b/test/message/max_tick_depth.js
@@ -26,6 +26,5 @@ process.maxTickDepth = 10;
 let i = 20;
 process.nextTick(function f() {
   console.error(`tick ${i}`);
-  if (i-- > 0)
-    process.nextTick(f);
+  if (i-- > 0) process.nextTick(f);
 });
diff --git a/test/message/stack_overflow.js b/test/message/stack_overflow.js
index 9541ee78409b5d..4f908c1c323822 100644
--- a/test/message/stack_overflow.js
+++ b/test/message/stack_overflow.js
@@ -29,7 +29,7 @@ console.error('before');
 // Trigger stack overflow by stringifying a deeply nested array.
 let array = [];
 for (let i = 0; i < 100000; i++) {
-  array = [ array ];
+  array = [array];
 }
 
 JSON.stringify(array);
diff --git a/test/message/stdin_messages.js b/test/message/stdin_messages.js
index 66e06282b3b3e2..460ceb3f1eefcf 100644
--- a/test/message/stdin_messages.js
+++ b/test/message/stdin_messages.js
@@ -36,12 +36,13 @@ function run(cmd, strict, cb) {
   child.on('close', cb);
 }
 
-const queue =
-  [ 'with(this){__filename}',
-    '42',
-    'throw new Error("hello")',
-    'var x = 100; y = x;',
-    'var ______________________________________________; throw 10' ];
+const queue = [
+  'with(this){__filename}',
+  '42',
+  'throw new Error("hello")',
+  'var x = 100; y = x;',
+  'var ______________________________________________; throw 10'
+];
 
 function go() {
   const c = queue.shift();
diff --git a/test/message/throw_custom_error.js b/test/message/throw_custom_error.js
index 7290df53e12420..beb890aaf24f81 100644
--- a/test/message/throw_custom_error.js
+++ b/test/message/throw_custom_error.js
@@ -24,4 +24,4 @@ require('../common');
 
 // custom error throwing
 // eslint-disable-next-line no-throw-literal
-throw ({ name: 'MyCustomError', message: 'This is a custom message' });
+throw { name: 'MyCustomError', message: 'This is a custom message' };
diff --git a/test/message/throw_in_line_with_tabs.js b/test/message/throw_in_line_with_tabs.js
index fdc36b331ab8a1..96895ba6bef375 100644
--- a/test/message/throw_in_line_with_tabs.js
+++ b/test/message/throw_in_line_with_tabs.js
@@ -26,9 +26,9 @@ require('../common');
 console.error('before');
 
 (function() {
-	// these lines should contain tab!
-	// eslint-disable-next-line no-throw-literal
-	throw ({ foo: 'bar' });
+  // these lines should contain tab!
+  // eslint-disable-next-line no-throw-literal
+  throw { foo: 'bar' };
 })();
 
 console.error('after');
diff --git a/test/message/throw_non_error.js b/test/message/throw_non_error.js
index e7d2f54b85f78f..139831c44a1dfb 100644
--- a/test/message/throw_non_error.js
+++ b/test/message/throw_non_error.js
@@ -24,4 +24,4 @@ require('../common');
 
 // custom error throwing
 // eslint-disable-next-line no-throw-literal
-throw ({ foo: 'bar' });
+throw { foo: 'bar' };
diff --git a/test/message/vm_caught_custom_runtime_error.js b/test/message/vm_caught_custom_runtime_error.js
index 237e8e3a105436..6e8f677582df1f 100644
--- a/test/message/vm_caught_custom_runtime_error.js
+++ b/test/message/vm_caught_custom_runtime_error.js
@@ -7,10 +7,13 @@ console.error('beginning');
 // Regression test for https://github.com/nodejs/node/issues/7397:
 // vm.runInThisContext() should not print out anything to stderr by itself.
 try {
-  vm.runInThisContext(`throw ({
+  vm.runInThisContext(
+    `throw ({
     name: 'MyCustomError',
     message: 'This is a custom message'
-  })`, { filename: 'test.vm' });
+  })`,
+    { filename: 'test.vm' }
+  );
 } catch (e) {
   console.error('received error', e.name);
 }
diff --git a/test/parallel/test-accessor-properties.js b/test/parallel/test-accessor-properties.js
index 95b960b202cd53..5647dd4a5af2b0 100644
--- a/test/parallel/test-accessor-properties.js
+++ b/test/parallel/test-accessor-properties.js
@@ -55,7 +55,8 @@ const UDP = internalBinding('udp_wrap').UDP;
     'object'
   );
 
-  if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
+  if (common.hasCrypto) {
+    // eslint-disable-line node-core/crypto-check
     // There are accessor properties in crypto too
     const crypto = process.binding('crypto');
 
@@ -65,7 +66,9 @@ const UDP = internalBinding('udp_wrap').UDP;
 
     assert.strictEqual(
       typeof Object.getOwnPropertyDescriptor(
-        crypto.SecureContext.prototype, '_external'),
+        crypto.SecureContext.prototype,
+        '_external'
+      ),
       'object'
     );
   }
diff --git a/test/parallel/test-assert-async.js b/test/parallel/test-assert-async.js
index f148c7e3d84235..86543b8a98f7a3 100644
--- a/test/parallel/test-assert-async.js
+++ b/test/parallel/test-assert-async.js
@@ -23,11 +23,15 @@ const promises = [];
 
 {
   const handler = (err) => {
-    assert(err instanceof assert.AssertionError,
-           `${err.name} is not instance of AssertionError`);
+    assert(
+      err instanceof assert.AssertionError,
+      `${err.name} is not instance of AssertionError`
+    );
     assert.strictEqual(err.code, 'ERR_ASSERTION');
-    assert.strictEqual(err.message,
-                       'Missing expected rejection (mustNotCall).');
+    assert.strictEqual(
+      err.message,
+      'Missing expected rejection (mustNotCall).'
+    );
     assert.strictEqual(err.operator, 'rejects');
     assert.ok(!err.stack.includes('at Function.rejects'));
     return true;
@@ -37,12 +41,15 @@ const promises = [];
   promises.push(assert.rejects(promise, common.mustCall(handler)));
 
   promise = assert.rejects(() => {}, common.mustNotCall());
-  promises.push(assert.rejects(promise, {
-    name: 'TypeError [ERR_INVALID_RETURN_VALUE]',
-    code: 'ERR_INVALID_RETURN_VALUE',
-    message: 'Expected instance of Promise to be returned ' +
-             'from the "promiseFn" function but got type undefined.'
-  }));
+  promises.push(
+    assert.rejects(promise, {
+      name: 'TypeError [ERR_INVALID_RETURN_VALUE]',
+      code: 'ERR_INVALID_RETURN_VALUE',
+      message:
+        'Expected instance of Promise to be returned ' +
+        'from the "promiseFn" function but got type undefined.'
+    })
+  );
 
   promise = assert.rejects(Promise.resolve(), common.mustNotCall());
   promises.push(assert.rejects(promise, common.mustCall(handler)));
@@ -51,50 +58,65 @@ const promises = [];
 {
   const THROWN_ERROR = new Error();
 
-  promises.push(assert.rejects(() => {
-    throw THROWN_ERROR;
-  }, {}).catch(common.mustCall((err) => {
-    assert.strictEqual(err, THROWN_ERROR);
-  })));
+  promises.push(
+    assert
+      .rejects(() => {
+        throw THROWN_ERROR;
+      }, {})
+      .catch(
+        common.mustCall((err) => {
+          assert.strictEqual(err, THROWN_ERROR);
+        })
+      )
+  );
 }
 
-promises.push(assert.rejects(
-  assert.rejects('fail', {}),
-  {
+promises.push(
+  assert.rejects(assert.rejects('fail', {}), {
     code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "promiseFn" argument must be one of type ' +
-             'Function or Promise. Received type string'
-  }
-));
+    message:
+      'The "promiseFn" argument must be one of type ' +
+      'Function or Promise. Received type string'
+  })
+);
 
 // Check `assert.doesNotReject`.
 {
   // `assert.doesNotReject` accepts a function or a promise as first argument.
   const promise = assert.doesNotReject(() => new Map(), common.mustNotCall());
-  promises.push(assert.rejects(promise, {
-    message: 'Expected instance of Promise to be returned ' +
-             'from the "promiseFn" function but got instance of Map.',
-    code: 'ERR_INVALID_RETURN_VALUE',
-    name: 'TypeError [ERR_INVALID_RETURN_VALUE]'
-  }));
+  promises.push(
+    assert.rejects(promise, {
+      message:
+        'Expected instance of Promise to be returned ' +
+        'from the "promiseFn" function but got instance of Map.',
+      code: 'ERR_INVALID_RETURN_VALUE',
+      name: 'TypeError [ERR_INVALID_RETURN_VALUE]'
+    })
+  );
   promises.push(assert.doesNotReject(async () => {}));
   promises.push(assert.doesNotReject(Promise.resolve()));
 }
 
 {
   const handler1 = (err) => {
-    assert(err instanceof assert.AssertionError,
-           `${err.name} is not instance of AssertionError`);
+    assert(
+      err instanceof assert.AssertionError,
+      `${err.name} is not instance of AssertionError`
+    );
     assert.strictEqual(err.code, 'ERR_ASSERTION');
     assert.strictEqual(err.message, 'Failed');
     return true;
   };
   const handler2 = (err) => {
-    assert(err instanceof assert.AssertionError,
-           `${err.name} is not instance of AssertionError`);
+    assert(
+      err instanceof assert.AssertionError,
+      `${err.name} is not instance of AssertionError`
+    );
     assert.strictEqual(err.code, 'ERR_ASSERTION');
-    assert.strictEqual(err.message,
-                       'Got unwanted rejection.\nActual message: "Failed"');
+    assert.strictEqual(
+      err.message,
+      'Got unwanted rejection.\nActual message: "Failed"'
+    );
     assert.strictEqual(err.operator, 'doesNotReject');
     assert.ok(!err.stack.includes('at Function.doesNotReject'));
     return true;
@@ -112,14 +134,14 @@ promises.push(assert.rejects(
   promises.push(assert.rejects(promise, common.mustCall(handler1)));
 }
 
-promises.push(assert.rejects(
-  assert.doesNotReject(123),
-  {
+promises.push(
+  assert.rejects(assert.doesNotReject(123), {
     code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "promiseFn" argument must be one of type ' +
-             'Function or Promise. Received type number'
-  }
-));
+    message:
+      'The "promiseFn" argument must be one of type ' +
+      'Function or Promise. Received type number'
+  })
+);
 
 // Make sure all async code gets properly executed.
 Promise.all(promises).then(common.mustCall());
diff --git a/test/parallel/test-assert-builtins-not-read-from-filesystem.js b/test/parallel/test-assert-builtins-not-read-from-filesystem.js
index 7a713a2ea432c1..32b8afdf8fe937 100644
--- a/test/parallel/test-assert-builtins-not-read-from-filesystem.js
+++ b/test/parallel/test-assert-builtins-not-read-from-filesystem.js
@@ -23,10 +23,11 @@ if (process.argv[2] !== 'child') {
     // Spawn a child process to avoid the error having been cached in the assert
     // module's `errorCache` Map.
 
-    const { output, status, error } =
-      spawnSync(process.execPath,
-                [process.argv[1], 'child', filename, line, column],
-                { cwd: tmpdir.path, env: process.env });
+    const { output, status, error } = spawnSync(
+      process.execPath,
+      [process.argv[1], 'child', filename, line, column],
+      { cwd: tmpdir.path, env: process.env }
+    );
     assert.ifError(error);
     assert.strictEqual(status, 0, `Exit code: ${status}\n${output}`);
     threw = true;
@@ -35,14 +36,11 @@ if (process.argv[2] !== 'child') {
 } else {
   const { writeFileSync } = require('fs');
   const [, , , filename, line, column] = process.argv;
-  const data = `${'\n'.repeat(line - 1)}${' '.repeat(column - 1)}` +
-               'ok(failed(badly));';
+  const data =
+    `${'\n'.repeat(line - 1)}${' '.repeat(column - 1)}` + 'ok(failed(badly));';
 
   writeFileSync(filename, data);
-  assert.throws(
-    () => e.emit('hello', false),
-    {
-      message: 'false == true'
-    }
-  );
+  assert.throws(() => e.emit('hello', false), {
+    message: 'false == true'
+  });
 }
diff --git a/test/parallel/test-assert-checktag.js b/test/parallel/test-assert-checktag.js
index eeb25278ff186f..8208da43fce58c 100644
--- a/test/parallel/test-assert-checktag.js
+++ b/test/parallel/test-assert-checktag.js
@@ -5,8 +5,7 @@ const assert = require('assert');
 // Disable colored output to prevent color codes from breaking assertion
 // message comparisons. This should only be an issue when process.stdout
 // is a TTY.
-if (process.stdout.isTTY)
-  process.env.NODE_DISABLE_COLORS = '1';
+if (process.stdout.isTTY) process.env.NODE_DISABLE_COLORS = '1';
 
 // Turn off no-restricted-properties because we are testing deepEqual!
 /* eslint-disable no-restricted-properties */
@@ -23,23 +22,20 @@ if (process.stdout.isTTY)
 
   // For deepStrictEqual we check the runtime type,
   // then reveal the fakeness of the fake date
-  assert.throws(
-    () => assert.deepStrictEqual(date, fake),
-    {
-      message: 'Expected values to be strictly deep-equal:\n' +
-               '+ actual - expected\n\n+ 2016-01-01T00:00:00.000Z\n- Date {}'
-    }
-  );
-  assert.throws(
-    () => assert.deepStrictEqual(fake, date),
-    {
-      message: 'Expected values to be strictly deep-equal:\n' +
-               '+ actual - expected\n\n+ Date {}\n- 2016-01-01T00:00:00.000Z'
-    }
-  );
+  assert.throws(() => assert.deepStrictEqual(date, fake), {
+    message:
+      'Expected values to be strictly deep-equal:\n' +
+      '+ actual - expected\n\n+ 2016-01-01T00:00:00.000Z\n- Date {}'
+  });
+  assert.throws(() => assert.deepStrictEqual(fake, date), {
+    message:
+      'Expected values to be strictly deep-equal:\n' +
+      '+ actual - expected\n\n+ Date {}\n- 2016-01-01T00:00:00.000Z'
+  });
 }
 
-{  // At the moment global has its own type tag
+{
+  // At the moment global has its own type tag
   const fakeGlobal = {};
   Object.setPrototypeOf(fakeGlobal, Object.getPrototypeOf(global));
   for (const prop of Object.keys(global)) {
@@ -47,11 +43,14 @@ if (process.stdout.isTTY)
   }
   assert.deepEqual(fakeGlobal, global);
   // Message will be truncated anyway, don't validate
-  assert.throws(() => assert.deepStrictEqual(fakeGlobal, global),
-                assert.AssertionError);
+  assert.throws(
+    () => assert.deepStrictEqual(fakeGlobal, global),
+    assert.AssertionError
+  );
 }
 
-{ // At the moment process has its own type tag
+{
+  // At the moment process has its own type tag
   const fakeProcess = {};
   Object.setPrototypeOf(fakeProcess, Object.getPrototypeOf(process));
   for (const prop of Object.keys(process)) {
@@ -59,7 +58,9 @@ if (process.stdout.isTTY)
   }
   assert.deepEqual(fakeProcess, process);
   // Message will be truncated anyway, don't validate
-  assert.throws(() => assert.deepStrictEqual(fakeProcess, process),
-                assert.AssertionError);
+  assert.throws(
+    () => assert.deepStrictEqual(fakeProcess, process),
+    assert.AssertionError
+  );
 }
 /* eslint-enable */
diff --git a/test/parallel/test-assert-deep.js b/test/parallel/test-assert-deep.js
index ddbc5e78eafcaf..964d7b6d3708fc 100644
--- a/test/parallel/test-assert-deep.js
+++ b/test/parallel/test-assert-deep.js
@@ -10,8 +10,7 @@ const defaultMsgStartFull = `${defaultMsgStart}+ actual - expected`;
 // Disable colored output to prevent color codes from breaking assertion
 // message comparisons. This should only be an issue when process.stdout
 // is a TTY.
-if (process.stdout.isTTY)
-  process.env.NODE_DISABLE_COLORS = '1';
+if (process.stdout.isTTY) process.env.NODE_DISABLE_COLORS = '1';
 
 // Template tag function turning an error message into a RegExp
 // for assert.throws()
@@ -46,53 +45,47 @@ function re(literals, ...values) {
 const arr = new Uint8Array([120, 121, 122, 10]);
 const buf = Buffer.from(arr);
 // They have different [[Prototype]]
-assert.throws(
-  () => assert.deepStrictEqual(arr, buf),
-  {
-    code: 'ERR_ASSERTION',
-    message: `${defaultMsgStartFull} ... Lines skipped\n\n` +
-             '+ Uint8Array [\n' +
-             '- Buffer [Uint8Array] [\n    120,\n...\n    10\n  ]'
-  }
-);
+assert.throws(() => assert.deepStrictEqual(arr, buf), {
+  code: 'ERR_ASSERTION',
+  message:
+    `${defaultMsgStartFull} ... Lines skipped\n\n` +
+    '+ Uint8Array [\n' +
+    '- Buffer [Uint8Array] [\n    120,\n...\n    10\n  ]'
+});
 assert.deepEqual(arr, buf);
 
 {
   const buf2 = Buffer.from(arr);
   buf2.prop = 1;
 
-  assert.throws(
-    () => assert.deepStrictEqual(buf2, buf),
-    {
-      code: 'ERR_ASSERTION',
-      message: `${defaultMsgStartFull} ... Lines skipped\n\n` +
-               '  Buffer [Uint8Array] [\n' +
-               '    120,\n' +
-               '...\n' +
-               '    10,\n' +
-               '+   prop: 1\n' +
-               '  ]'
-    }
-  );
+  assert.throws(() => assert.deepStrictEqual(buf2, buf), {
+    code: 'ERR_ASSERTION',
+    message:
+      `${defaultMsgStartFull} ... Lines skipped\n\n` +
+      '  Buffer [Uint8Array] [\n' +
+      '    120,\n' +
+      '...\n' +
+      '    10,\n' +
+      '+   prop: 1\n' +
+      '  ]'
+  });
   assert.deepEqual(buf2, buf);
 }
 
 {
   const arr2 = new Uint8Array([120, 121, 122, 10]);
   arr2.prop = 5;
-  assert.throws(
-    () => assert.deepStrictEqual(arr, arr2),
-    {
-      code: 'ERR_ASSERTION',
-      message: `${defaultMsgStartFull} ... Lines skipped\n\n` +
-               '  Uint8Array [\n' +
-               '    120,\n' +
-               '...\n' +
-               '    10,\n' +
-               '-   prop: 5\n' +
-               '  ]'
-    }
-  );
+  assert.throws(() => assert.deepStrictEqual(arr, arr2), {
+    code: 'ERR_ASSERTION',
+    message:
+      `${defaultMsgStartFull} ... Lines skipped\n\n` +
+      '  Uint8Array [\n' +
+      '    120,\n' +
+      '...\n' +
+      '    10,\n' +
+      '-   prop: 5\n' +
+      '  ]'
+  });
   assert.deepEqual(arr, arr2);
 }
 
@@ -111,24 +104,20 @@ const date2 = new MyDate('2016');
 // but deepStrictEqual checks own properties
 assert.deepEqual(date, date2);
 assert.deepEqual(date2, date);
-assert.throws(
-  () => assert.deepStrictEqual(date, date2),
-  {
-    code: 'ERR_ASSERTION',
-    message: `${defaultMsgStartFull}\n\n` +
-             '+ 2016-01-01T00:00:00.000Z\n- 2016-01-01T00:00:00.000Z {\n' +
-             "-   '0': '1'\n- }"
-  }
-);
-assert.throws(
-  () => assert.deepStrictEqual(date2, date),
-  {
-    code: 'ERR_ASSERTION',
-    message: `${defaultMsgStartFull}\n\n` +
-             '+ 2016-01-01T00:00:00.000Z {\n' +
-             "+   '0': '1'\n+ }\n- 2016-01-01T00:00:00.000Z"
-  }
-);
+assert.throws(() => assert.deepStrictEqual(date, date2), {
+  code: 'ERR_ASSERTION',
+  message:
+    `${defaultMsgStartFull}\n\n` +
+    '+ 2016-01-01T00:00:00.000Z\n- 2016-01-01T00:00:00.000Z {\n' +
+    "-   '0': '1'\n- }"
+});
+assert.throws(() => assert.deepStrictEqual(date2, date), {
+  code: 'ERR_ASSERTION',
+  message:
+    `${defaultMsgStartFull}\n\n` +
+    '+ 2016-01-01T00:00:00.000Z {\n' +
+    "+   '0': '1'\n+ }\n- 2016-01-01T00:00:00.000Z"
+});
 
 class MyRegExp extends RegExp {
   constructor(...args) {
@@ -143,33 +132,30 @@ const re2 = new MyRegExp('test');
 // deepEqual returns true as long as the regexp-specific properties
 // are the same, but deepStrictEqual checks all properties
 assert.deepEqual(re1, re2);
-assert.throws(
-  () => assert.deepStrictEqual(re1, re2),
-  {
-    code: 'ERR_ASSERTION',
-    message: `${defaultMsgStartFull}\n\n` +
-             "+ /test/\n- /test/ {\n-   '0': '1'\n- }"
-  }
-);
+assert.throws(() => assert.deepStrictEqual(re1, re2), {
+  code: 'ERR_ASSERTION',
+  message:
+    `${defaultMsgStartFull}\n\n` + "+ /test/\n- /test/ {\n-   '0': '1'\n- }"
+});
 
 // For these weird cases, deepEqual should pass (at least for now),
 // but deepStrictEqual should throw.
 {
   const similar = new Set([
-    { 0: '1' },  // Object
-    { 0: 1 },  // Object
-    new String('1'),  // Object
-    ['1'],  // Array
-    [1],  // Array
-    date2,  // Date with this[0] = '1'
-    re2,  // RegExp with this[0] = '1'
+    { 0: '1' }, // Object
+    { 0: 1 }, // Object
+    new String('1'), // Object
+    ['1'], // Array
+    [1], // Array
+    date2, // Date with this[0] = '1'
+    re2, // RegExp with this[0] = '1'
     new Int8Array([1]), // Int8Array
     new Uint8Array([1]), // Uint8Array
     new Int16Array([1]), // Int16Array
     new Uint16Array([1]), // Uint16Array
     new Int32Array([1]), // Int32Array
     new Uint32Array([1]), // Uint32Array
-    Buffer.from([1]),
+    Buffer.from([1])
     // Arguments {'0': '1'} is not here
     // See https://github.com/nodejs/node-v0.x-archive/pull/7178
   ]);
@@ -178,10 +164,9 @@ assert.throws(
     for (const b of similar) {
       if (a !== b) {
         assert.deepEqual(a, b);
-        assert.throws(
-          () => assert.deepStrictEqual(a, b),
-          { code: 'ERR_ASSERTION' }
-        );
+        assert.throws(() => assert.deepStrictEqual(a, b), {
+          code: 'ERR_ASSERTION'
+        });
       }
     }
   }
@@ -241,10 +226,10 @@ assertDeepAndStrictEqual(new Set([[1, 2], [3, 4]]), new Set([[3, 4], [1, 2]]));
 assertNotDeepOrStrict(new Set([{ a: 0 }]), new Set([{ a: 1 }]));
 
 {
-  const a = [ 1, 2 ];
-  const b = [ 3, 4 ];
-  const c = [ 1, 2 ];
-  const d = [ 3, 4 ];
+  const a = [1, 2];
+  const b = [3, 4];
+  const c = [1, 2];
+  const d = [3, 4];
 
   assertDeepAndStrictEqual(
     { a: a, b: b, s: new Set([a, b]) },
@@ -313,10 +298,7 @@ assertOnlyDeepEqual(
   new Map([[1, 'a'], ['1', 'b']]),
   new Map([['1', 'a'], [true, 'b']])
 );
-assertNotDeepOrStrict(
-  new Set(['a']),
-  new Set(['b'])
-);
+assertNotDeepOrStrict(new Set(['a']), new Set(['b']));
 assertDeepAndStrictEqual(
   new Map([[{}, 'a'], [{}, 'b']]),
   new Map([[{}, 'b'], [{}, 'a']])
@@ -331,69 +313,39 @@ assertNotDeepOrStrict(
 );
 
 // Similar object keys
-assertNotDeepOrStrict(
-  new Set([{}, {}]),
-  new Set([{}, 1])
-);
-assertNotDeepOrStrict(
-  new Set([[{}, 1], [{}, 1]]),
-  new Set([[{}, 1], [1, 1]])
-);
-assertNotDeepOrStrict(
-  new Map([[{}, 1], [{}, 1]]),
-  new Map([[{}, 1], [1, 1]])
-);
-assertOnlyDeepEqual(
-  new Map([[{}, 1], [true, 1]]),
-  new Map([[{}, 1], [1, 1]])
-);
+assertNotDeepOrStrict(new Set([{}, {}]), new Set([{}, 1]));
+assertNotDeepOrStrict(new Set([[{}, 1], [{}, 1]]), new Set([[{}, 1], [1, 1]]));
+assertNotDeepOrStrict(new Map([[{}, 1], [{}, 1]]), new Map([[{}, 1], [1, 1]]));
+assertOnlyDeepEqual(new Map([[{}, 1], [true, 1]]), new Map([[{}, 1], [1, 1]]));
 
 // Similar primitive key / values
-assertNotDeepOrStrict(
-  new Set([1, true, false]),
-  new Set(['1', 0, '0'])
-);
+assertNotDeepOrStrict(new Set([1, true, false]), new Set(['1', 0, '0']));
 assertNotDeepOrStrict(
   new Map([[1, 5], [true, 5], [false, 5]]),
   new Map([['1', 5], [0, 5], ['0', 5]])
 );
 
 // undefined value in Map
-assertDeepAndStrictEqual(
-  new Map([[1, undefined]]),
-  new Map([[1, undefined]])
-);
+assertDeepAndStrictEqual(new Map([[1, undefined]]), new Map([[1, undefined]]));
 assertOnlyDeepEqual(
   new Map([[1, null], ['', '0']]),
   new Map([['1', undefined], [false, 0]])
 );
-assertNotDeepOrStrict(
-  new Map([[1, undefined]]),
-  new Map([[2, undefined]])
-);
+assertNotDeepOrStrict(new Map([[1, undefined]]), new Map([[2, undefined]]));
 
 // null as key
-assertDeepAndStrictEqual(
-  new Map([[null, 3]]),
-  new Map([[null, 3]])
-);
+assertDeepAndStrictEqual(new Map([[null, 3]]), new Map([[null, 3]]));
 assertOnlyDeepEqual(
   new Map([[undefined, null], ['+000', 2n]]),
-  new Map([[null, undefined], [false, '2']]),
+  new Map([[null, undefined], [false, '2']])
 );
 
 assertOnlyDeepEqual(
   new Set([null, '', 1n, 5, 2n, false]),
   new Set([undefined, 0, 5n, true, '2', '-000'])
 );
-assertNotDeepOrStrict(
-  new Set(['']),
-  new Set(['0'])
-);
-assertOnlyDeepEqual(
-  new Map([[1, {}]]),
-  new Map([[true, {}]])
-);
+assertNotDeepOrStrict(new Set(['']), new Set(['0']));
+assertOnlyDeepEqual(new Map([[1, {}]]), new Map([[true, {}]]));
 
 // GH-6416. Make sure circular refs don't throw.
 {
@@ -437,14 +389,18 @@ assertOnlyDeepEqual(
 // https://github.com/nodejs/node-v0.x-archive/pull/7178
 // Ensure reflexivity of deepEqual with `arguments` objects.
 {
-  const args = (function() { return arguments; })();
+  const args = (function() {
+    return arguments;
+  })();
   assertNotDeepOrStrict([], args);
 }
 
 // More checking that arguments objects are handled correctly
 {
   // eslint-disable-next-line func-style
-  const returnArguments = function() { return arguments; };
+  const returnArguments = function() {
+    return arguments;
+  };
 
   const someArgs = returnArguments('a');
   const sameArgs = returnArguments('a');
@@ -467,7 +423,7 @@ assertOnlyDeepEqual(
     true,
     {},
     [],
-    () => {},
+    () => {}
   ];
   assertDeepAndStrictEqual(new Set(values), new Set(values));
   assertDeepAndStrictEqual(new Set(values), new Set(values.reverse()));
@@ -517,14 +473,11 @@ assertOnlyDeepEqual(
   const map1 = new Map([[1, 1]]);
   const map2 = new Map([[1, '1']]);
   assert.deepEqual(map1, map2);
-  assert.throws(
-    () => assert.deepStrictEqual(map1, map2),
-    {
-      code: 'ERR_ASSERTION',
-      message: `${defaultMsgStartFull}\n\n` +
-               "  Map {\n+   1 => 1\n-   1 => '1'\n  }"
-    }
-  );
+  assert.throws(() => assert.deepStrictEqual(map1, map2), {
+    code: 'ERR_ASSERTION',
+    message:
+      `${defaultMsgStartFull}\n\n` + "  Map {\n+   1 => 1\n-   1 => '1'\n  }"
+  });
 }
 
 {
@@ -565,7 +518,7 @@ assertOnlyDeepEqual(
 
 // Handle sparse arrays
 assertDeepAndStrictEqual([1, , , 3], [1, , , 3]);
-assertOnlyDeepEqual([1, , , 3], [1, , , 3, , , ]);
+assertOnlyDeepEqual([1, , , 3], [1, , , 3, , ,]);
 
 // Handle different error messages
 {
@@ -579,10 +532,12 @@ assertOnlyDeepEqual([1, , , 3], [1, , , 3, , , ]);
 }
 
 // Handle NaN
-assert.throws(() => { assert.deepEqual(NaN, NaN); }, assert.AssertionError);
+assert.throws(() => {
+  assert.deepEqual(NaN, NaN);
+}, assert.AssertionError);
 assert.deepStrictEqual(NaN, NaN);
 assert.deepStrictEqual({ a: NaN }, { a: NaN });
-assert.deepStrictEqual([ 1, 2, NaN, 4 ], [ 1, 2, NaN, 4 ]);
+assert.deepStrictEqual([1, 2, NaN, 4], [1, 2, NaN, 4]);
 
 // Handle boxed primitives
 {
@@ -636,9 +591,11 @@ assertDeepAndStrictEqual(-0, -0);
 
 assert.deepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14));
 
-assert.throws(() => assert.deepEqual(new Date(), new Date(2000, 3, 14)),
-              AssertionError,
-              'deepEqual(new Date(), new Date(2000, 3, 14))');
+assert.throws(
+  () => assert.deepEqual(new Date(), new Date(2000, 3, 14)),
+  AssertionError,
+  'deepEqual(new Date(), new Date(2000, 3, 14))'
+);
 
 assert.throws(
   () => assert.notDeepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14)),
@@ -652,12 +609,12 @@ assertDeepAndStrictEqual(/a/, /a/);
 assertDeepAndStrictEqual(/a/g, /a/g);
 assertDeepAndStrictEqual(/a/i, /a/i);
 assertDeepAndStrictEqual(/a/m, /a/m);
-assertDeepAndStrictEqual(/a/igm, /a/igm);
+assertDeepAndStrictEqual(/a/gim, /a/gim);
 assertNotDeepOrStrict(/ab/, /a/);
 assertNotDeepOrStrict(/a/g, /a/);
 assertNotDeepOrStrict(/a/i, /a/);
 assertNotDeepOrStrict(/a/m, /a/);
-assertNotDeepOrStrict(/a/igm, /a/im);
+assertNotDeepOrStrict(/a/gim, /a/im);
 
 {
   const re1 = /a/g;
@@ -667,16 +624,20 @@ assertNotDeepOrStrict(/a/igm, /a/im);
 
 assert.deepEqual(4, '4');
 assert.deepEqual(true, 1);
-assert.throws(() => assert.deepEqual(4, '5'),
-              AssertionError,
-              'deepEqual( 4, \'5\')');
+assert.throws(
+  () => assert.deepEqual(4, '5'),
+  AssertionError,
+  "deepEqual( 4, '5')"
+);
 
 // Having the same number of owned properties && the same set of keys.
 assert.deepEqual({ a: 4 }, { a: 4 });
 assert.deepEqual({ a: 4, b: '2' }, { a: 4, b: '2' });
 assert.deepEqual([4], ['4']);
 assert.throws(
-  () => assert.deepEqual({ a: 4 }, { a: 4, b: true }), AssertionError);
+  () => assert.deepEqual({ a: 4 }, { a: 4, b: true }),
+  AssertionError
+);
 assert.deepEqual(['a'], { 0: 'a' });
 assert.deepEqual({ a: 4, b: '1' }, { b: '1', a: 4 });
 const a1 = [1, 2, 3];
@@ -685,13 +646,17 @@ a1.a = 'test';
 a1.b = true;
 a2.b = true;
 a2.a = 'test';
-assert.throws(() => assert.deepEqual(Object.keys(a1), Object.keys(a2)),
-              AssertionError);
+assert.throws(
+  () => assert.deepEqual(Object.keys(a1), Object.keys(a2)),
+  AssertionError
+);
 assert.deepEqual(a1, a2);
 
 // Having an identical prototype property.
 const nbRoot = {
-  toString() { return `${this.first} ${this.last}`; }
+  toString() {
+    return `${this.first} ${this.last}`;
+  }
 };
 
 function nameBuilder(first, last) {
@@ -756,48 +721,39 @@ assert.throws(
   () => assert.notDeepStrictEqual(new Date(2000, 3, 14), new Date(2000, 3, 14)),
   {
     name: 'AssertionError [ERR_ASSERTION]',
-    message: 'Expected "actual" not to be strictly deep-equal to: ' +
-             util.inspect(new Date(2000, 3, 14))
+    message:
+      'Expected "actual" not to be strictly deep-equal to: ' +
+      util.inspect(new Date(2000, 3, 14))
   }
 );
 
 assert.notDeepStrictEqual(new Date(), new Date(2000, 3, 14));
 
-assert.throws(
-  () => assert.deepStrictEqual(/ab/, /a/),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: `${defaultMsgStartFull}\n\n+ /ab/\n- /a/`
-  });
-assert.throws(
-  () => assert.deepStrictEqual(/a/g, /a/),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: `${defaultMsgStartFull}\n\n+ /a/g\n- /a/`
-  });
-assert.throws(
-  () => assert.deepStrictEqual(/a/i, /a/),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: `${defaultMsgStartFull}\n\n+ /a/i\n- /a/`
-  });
-assert.throws(
-  () => assert.deepStrictEqual(/a/m, /a/),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: `${defaultMsgStartFull}\n\n+ /a/m\n- /a/`
-  });
-assert.throws(
-  () => assert.deepStrictEqual(/a/igm, /a/im),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: `${defaultMsgStartFull}\n\n+ /a/gim\n- /a/im\n     ^`
-  });
+assert.throws(() => assert.deepStrictEqual(/ab/, /a/), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: `${defaultMsgStartFull}\n\n+ /ab/\n- /a/`
+});
+assert.throws(() => assert.deepStrictEqual(/a/g, /a/), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: `${defaultMsgStartFull}\n\n+ /a/g\n- /a/`
+});
+assert.throws(() => assert.deepStrictEqual(/a/i, /a/), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: `${defaultMsgStartFull}\n\n+ /a/i\n- /a/`
+});
+assert.throws(() => assert.deepStrictEqual(/a/m, /a/), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: `${defaultMsgStartFull}\n\n+ /a/m\n- /a/`
+});
+assert.throws(() => assert.deepStrictEqual(/a/gim, /a/im), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: `${defaultMsgStartFull}\n\n+ /a/gim\n- /a/im\n     ^`
+});
 
 {
   const re1 = /a/;
@@ -805,41 +761,33 @@ assert.throws(
   assert.deepStrictEqual(re1, /a/);
 }
 
-assert.throws(
-  () => assert.deepStrictEqual(4, '4'),
-  { message: `${defaultMsgStart}\n4 !== '4'\n` }
-);
+assert.throws(() => assert.deepStrictEqual(4, '4'), {
+  message: `${defaultMsgStart}\n4 !== '4'\n`
+});
 
-assert.throws(
-  () => assert.deepStrictEqual(true, 1),
-  { message: `${defaultMsgStart}\ntrue !== 1\n` }
-);
+assert.throws(() => assert.deepStrictEqual(true, 1), {
+  message: `${defaultMsgStart}\ntrue !== 1\n`
+});
 
 // Having the same number of owned properties && the same set of keys.
 assert.deepStrictEqual({ a: 4 }, { a: 4 });
 assert.deepStrictEqual({ a: 4, b: '2' }, { a: 4, b: '2' });
-assert.throws(() => assert.deepStrictEqual([4], ['4']),
-              {
-                code: 'ERR_ASSERTION',
-                name: 'AssertionError [ERR_ASSERTION]',
-                message: `${defaultMsgStartFull}\n\n  [\n+   4\n-   '4'\n  ]`
-              });
-assert.throws(
-  () => assert.deepStrictEqual({ a: 4 }, { a: 4, b: true }),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: `${defaultMsgStartFull}\n\n  ` +
-             '{\n    a: 4,\n-   b: true\n  }'
-  });
-assert.throws(
-  () => assert.deepStrictEqual(['a'], { 0: 'a' }),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: `${defaultMsgStartFull}\n\n` +
-             "+ [\n+   'a'\n+ ]\n- {\n-   '0': 'a'\n- }"
-  });
+assert.throws(() => assert.deepStrictEqual([4], ['4']), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: `${defaultMsgStartFull}\n\n  [\n+   4\n-   '4'\n  ]`
+});
+assert.throws(() => assert.deepStrictEqual({ a: 4 }, { a: 4, b: true }), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: `${defaultMsgStartFull}\n\n  ` + '{\n    a: 4,\n-   b: true\n  }'
+});
+assert.throws(() => assert.deepStrictEqual(['a'], { 0: 'a' }), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message:
+    `${defaultMsgStartFull}\n\n` + "+ [\n+   'a'\n+ ]\n- {\n-   '0': 'a'\n- }"
+});
 
 /* eslint-enable */
 
@@ -847,7 +795,8 @@ assert.deepStrictEqual({ a: 4, b: '1' }, { b: '1', a: 4 });
 
 assert.throws(
   () => assert.deepStrictEqual([0, 1, 2, 'a', 'b'], [0, 1, 2, 'b', 'a']),
-  AssertionError);
+  AssertionError
+);
 
 assert.deepStrictEqual(a1, a2);
 
@@ -879,13 +828,11 @@ assert.deepStrictEqual(obj1, obj2);
   a.foo = 'bar';
   b.foo = 'baz';
 
-  assert.throws(
-    () => assert.deepStrictEqual(a, b),
-    {
-      message: `${defaultMsgStartFull}\n\n` +
-               '  [TypeError: foo] {\n+   foo: \'bar\'\n-   foo: \'baz\'\n  }'
-    }
-  );
+  assert.throws(() => assert.deepStrictEqual(a, b), {
+    message:
+      `${defaultMsgStartFull}\n\n` +
+      "  [TypeError: foo] {\n+   foo: 'bar'\n-   foo: 'baz'\n  }"
+  });
 }
 
 // Check proxies.
@@ -896,23 +843,20 @@ assert.deepStrictEqual(obj1, obj2);
   assert.deepStrictEqual(arrProxy, [1, 2]);
   const tmp = util.inspect.defaultOptions;
   util.inspect.defaultOptions = { showProxy: true };
-  assert.throws(
-    () => assert.deepStrictEqual(arrProxy, [1, 2, 3]),
-    { message: `${defaultMsgStartFull}\n\n` +
-               '  [\n    1,\n    2,\n-   3\n  ]' }
-  );
+  assert.throws(() => assert.deepStrictEqual(arrProxy, [1, 2, 3]), {
+    message: `${defaultMsgStartFull}\n\n` + '  [\n    1,\n    2,\n-   3\n  ]'
+  });
   util.inspect.defaultOptions = tmp;
 
   const invalidTrap = new Proxy([1, 2, 3], {
-    ownKeys() { return []; }
-  });
-  assert.throws(
-    () => assert.deepStrictEqual(invalidTrap, [1, 2, 3]),
-    {
-      name: 'TypeError',
-      message: "'ownKeys' on proxy: trap result did not include 'length'"
+    ownKeys() {
+      return [];
     }
-  );
+  });
+  assert.throws(() => assert.deepStrictEqual(invalidTrap, [1, 2, 3]), {
+    name: 'TypeError',
+    message: "'ownKeys' on proxy: trap result did not include 'length'"
+  });
 }
 
 // Strict equal with identical objects that are not identical
@@ -926,14 +870,11 @@ assert.deepStrictEqual(obj1, obj2);
     b[`symbol${i}`] = Symbol();
   }
 
-  assert.throws(
-    () => assert.deepStrictEqual(a, b),
-    {
-      code: 'ERR_ASSERTION',
-      name: 'AssertionError [ERR_ASSERTION]',
-      message: /\.\.\./g
-    }
-  );
+  assert.throws(() => assert.deepStrictEqual(a, b), {
+    code: 'ERR_ASSERTION',
+    name: 'AssertionError [ERR_ASSERTION]',
+    message: /\.\.\./g
+  });
 }
 
 // Basic valueOf check.
diff --git a/test/parallel/test-assert-fail-deprecation.js b/test/parallel/test-assert-fail-deprecation.js
index 97cba760e03836..4f4381e9940e4d 100644
--- a/test/parallel/test-assert-fail-deprecation.js
+++ b/test/parallel/test-assert-fail-deprecation.js
@@ -11,53 +11,67 @@ common.expectWarning(
 );
 
 // Two args only, operator defaults to '!='
-assert.throws(() => {
-  assert.fail('first', 'second');
-}, {
-  code: 'ERR_ASSERTION',
-  name: 'AssertionError [ERR_ASSERTION]',
-  message: '\'first\' != \'second\'',
-  operator: '!=',
-  actual: 'first',
-  expected: 'second',
-  generatedMessage: true
-});
+assert.throws(
+  () => {
+    assert.fail('first', 'second');
+  },
+  {
+    code: 'ERR_ASSERTION',
+    name: 'AssertionError [ERR_ASSERTION]',
+    message: "'first' != 'second'",
+    operator: '!=',
+    actual: 'first',
+    expected: 'second',
+    generatedMessage: true
+  }
+);
 
 // Three args
-assert.throws(() => {
-  assert.fail('ignored', 'ignored', 'another custom message');
-}, {
-  code: 'ERR_ASSERTION',
-  name: 'AssertionError [ERR_ASSERTION]',
-  message: 'another custom message',
-  operator: 'fail',
-  actual: 'ignored',
-  expected: 'ignored',
-  generatedMessage: false
-});
+assert.throws(
+  () => {
+    assert.fail('ignored', 'ignored', 'another custom message');
+  },
+  {
+    code: 'ERR_ASSERTION',
+    name: 'AssertionError [ERR_ASSERTION]',
+    message: 'another custom message',
+    operator: 'fail',
+    actual: 'ignored',
+    expected: 'ignored',
+    generatedMessage: false
+  }
+);
 
 // Three args with custom Error
-assert.throws(() => {
-  assert.fail(typeof 1, 'object', new TypeError('another custom message'));
-}, {
-  name: 'TypeError',
-  message: 'another custom message'
-});
+assert.throws(
+  () => {
+    assert.fail(typeof 1, 'object', new TypeError('another custom message'));
+  },
+  {
+    name: 'TypeError',
+    message: 'another custom message'
+  }
+);
 
 // No third arg (but a fourth arg)
-assert.throws(() => {
-  assert.fail('first', 'second', undefined, 'operator');
-}, {
-  code: 'ERR_ASSERTION',
-  name: 'AssertionError [ERR_ASSERTION]',
-  message: '\'first\' operator \'second\'',
-  operator: 'operator',
-  actual: 'first',
-  expected: 'second'
-});
+assert.throws(
+  () => {
+    assert.fail('first', 'second', undefined, 'operator');
+  },
+  {
+    code: 'ERR_ASSERTION',
+    name: 'AssertionError [ERR_ASSERTION]',
+    message: "'first' operator 'second'",
+    operator: 'operator',
+    actual: 'first',
+    expected: 'second'
+  }
+);
 
 // The stackFrameFunction should exclude the foo frame
 assert.throws(
-  function foo() { assert.fail('first', 'second', 'message', '!==', foo); },
+  function foo() {
+    assert.fail('first', 'second', 'message', '!==', foo);
+  },
   (err) => !/^\s*at\sfoo\b/m.test(err.stack)
 );
diff --git a/test/parallel/test-assert-fail.js b/test/parallel/test-assert-fail.js
index 4410cc85442707..936f35cc4efc69 100644
--- a/test/parallel/test-assert-fail.js
+++ b/test/parallel/test-assert-fail.js
@@ -5,7 +5,9 @@ const assert = require('assert');
 
 // No args
 assert.throws(
-  () => { assert.fail(); },
+  () => {
+    assert.fail();
+  },
   {
     code: 'ERR_ASSERTION',
     name: 'AssertionError [ERR_ASSERTION]',
@@ -18,22 +20,28 @@ assert.throws(
 );
 
 // One arg = message
-assert.throws(() => {
-  assert.fail('custom message');
-}, {
-  code: 'ERR_ASSERTION',
-  name: 'AssertionError [ERR_ASSERTION]',
-  message: 'custom message',
-  operator: 'fail',
-  actual: undefined,
-  expected: undefined,
-  generatedMessage: false
-});
+assert.throws(
+  () => {
+    assert.fail('custom message');
+  },
+  {
+    code: 'ERR_ASSERTION',
+    name: 'AssertionError [ERR_ASSERTION]',
+    message: 'custom message',
+    operator: 'fail',
+    actual: undefined,
+    expected: undefined,
+    generatedMessage: false
+  }
+);
 
 // One arg = Error
-assert.throws(() => {
-  assert.fail(new TypeError('custom message'));
-}, {
-  name: 'TypeError',
-  message: 'custom message'
-});
+assert.throws(
+  () => {
+    assert.fail(new TypeError('custom message'));
+  },
+  {
+    name: 'TypeError',
+    message: 'custom message'
+  }
+);
diff --git a/test/parallel/test-assert-first-line.js b/test/parallel/test-assert-first-line.js
index 32eadbf74156c3..c1161b47030e24 100644
--- a/test/parallel/test-assert-first-line.js
+++ b/test/parallel/test-assert-first-line.js
@@ -6,18 +6,12 @@ require('../common');
 const assert = require('assert');
 const { path } = require('../common/fixtures');
 
-assert.throws(
-  () => require(path('assert-first-line')),
-  {
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: "The expression evaluated to a falsy value:\n\n  ässört.ok('')\n"
-  }
-);
+assert.throws(() => require(path('assert-first-line')), {
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: "The expression evaluated to a falsy value:\n\n  ässört.ok('')\n"
+});
 
-assert.throws(
-  () => require(path('assert-long-line')),
-  {
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: "The expression evaluated to a falsy value:\n\n  assert.ok('')\n"
-  }
-);
+assert.throws(() => require(path('assert-long-line')), {
+  name: 'AssertionError [ERR_ASSERTION]',
+  message: "The expression evaluated to a falsy value:\n\n  assert.ok('')\n"
+});
diff --git a/test/parallel/test-assert-if-error.js b/test/parallel/test-assert-if-error.js
index cd6f99dfa43ea7..341e1c3d64b377 100644
--- a/test/parallel/test-assert-if-error.js
+++ b/test/parallel/test-assert-if-error.js
@@ -39,29 +39,22 @@ const stack = err.stack;
   })();
 })();
 
-assert.throws(
-  () => assert.ifError(new TypeError()),
-  {
-    message: 'ifError got unwanted exception: TypeError'
-  }
-);
+assert.throws(() => assert.ifError(new TypeError()), {
+  message: 'ifError got unwanted exception: TypeError'
+});
 
-assert.throws(
-  () => assert.ifError({ stack: false }),
-  {
-    message: 'ifError got unwanted exception: { stack: false }'
-  }
-);
+assert.throws(() => assert.ifError({ stack: false }), {
+  message: 'ifError got unwanted exception: { stack: false }'
+});
 
-assert.throws(
-  () => assert.ifError({ constructor: null, message: '' }),
-  {
-    message: 'ifError got unwanted exception: '
-  }
-);
+assert.throws(() => assert.ifError({ constructor: null, message: '' }), {
+  message: 'ifError got unwanted exception: '
+});
 
 assert.throws(
-  () => { assert.ifError(false); },
+  () => {
+    assert.ifError(false);
+  },
   {
     message: 'ifError got unwanted exception: false'
   }
diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js
index 9028d9ae30702e..885a8bcf7e1a9d 100644
--- a/test/parallel/test-assert.js
+++ b/test/parallel/test-assert.js
@@ -33,26 +33,30 @@ const a = assert;
 // Disable colored output to prevent color codes from breaking assertion
 // message comparisons. This should only be an issue when process.stdout
 // is a TTY.
-if (process.stdout.isTTY)
-  process.env.NODE_DISABLE_COLORS = '1';
+if (process.stdout.isTTY) process.env.NODE_DISABLE_COLORS = '1';
 
 const strictEqualMessageStart = 'Expected values to be strictly equal:\n';
 const start = 'Expected values to be strictly deep-equal:';
 const actExp = '+ actual - expected';
 
-assert.ok(a.AssertionError.prototype instanceof Error,
-          'a.AssertionError instanceof Error');
+assert.ok(
+  a.AssertionError.prototype instanceof Error,
+  'a.AssertionError instanceof Error'
+);
 
 assert.throws(() => a(false), a.AssertionError, 'ok(false)');
 assert.throws(() => a.ok(false), a.AssertionError, 'ok(false)');
 
 a(true);
-a('test', 'ok(\'test\')');
+a('test', "ok('test')");
 a.ok(true);
 a.ok('test');
 
-assert.throws(() => a.equal(true, false),
-              a.AssertionError, 'equal(true, false)');
+assert.throws(
+  () => a.equal(true, false),
+  a.AssertionError,
+  'equal(true, false)'
+);
 
 a.equal(null, null);
 a.equal(undefined, undefined);
@@ -61,32 +65,35 @@ a.equal(true, true);
 a.equal(2, '2');
 a.notEqual(true, false);
 
-assert.throws(() => a.notEqual(true, true),
-              a.AssertionError, 'notEqual(true, true)');
-
-assert.throws(() => a.strictEqual(2, '2'),
-              a.AssertionError, 'strictEqual(2, \'2\')');
-
-assert.throws(() => a.strictEqual(null, undefined),
-              a.AssertionError, 'strictEqual(null, undefined)');
+assert.throws(
+  () => a.notEqual(true, true),
+  a.AssertionError,
+  'notEqual(true, true)'
+);
 
 assert.throws(
-  () => a.notStrictEqual(2, 2),
-  {
-    message: 'Expected "actual" to be strictly unequal to: 2',
-    name: 'AssertionError [ERR_ASSERTION]'
-  }
+  () => a.strictEqual(2, '2'),
+  a.AssertionError,
+  "strictEqual(2, '2')"
 );
 
 assert.throws(
-  () => a.notStrictEqual('a '.repeat(30), 'a '.repeat(30)),
-  {
-    message: 'Expected "actual" to be strictly unequal to: ' +
-             `'${'a '.repeat(30)}'`,
-    name: 'AssertionError [ERR_ASSERTION]'
-  }
+  () => a.strictEqual(null, undefined),
+  a.AssertionError,
+  'strictEqual(null, undefined)'
 );
 
+assert.throws(() => a.notStrictEqual(2, 2), {
+  message: 'Expected "actual" to be strictly unequal to: 2',
+  name: 'AssertionError [ERR_ASSERTION]'
+});
+
+assert.throws(() => a.notStrictEqual('a '.repeat(30), 'a '.repeat(30)), {
+  message:
+    'Expected "actual" to be strictly unequal to: ' + `'${'a '.repeat(30)}'`,
+  name: 'AssertionError [ERR_ASSERTION]'
+});
+
 a.notStrictEqual(2, '2');
 
 // Testing the throwing.
@@ -141,35 +148,27 @@ assert.throws(() => thrower(TypeError));
   assert.ok(threw, 'a.doesNotThrow is not catching type matching errors');
 }
 
-assert.throws(
-  () => a.doesNotThrow(() => thrower(Error), 'user message'),
-  {
-    name: 'AssertionError [ERR_ASSERTION]',
-    code: 'ERR_ASSERTION',
-    operator: 'doesNotThrow',
-    message: 'Got unwanted exception: user message\n' +
-             'Actual message: "[object Object]"'
-  }
-);
+assert.throws(() => a.doesNotThrow(() => thrower(Error), 'user message'), {
+  name: 'AssertionError [ERR_ASSERTION]',
+  code: 'ERR_ASSERTION',
+  operator: 'doesNotThrow',
+  message:
+    'Got unwanted exception: user message\n' +
+    'Actual message: "[object Object]"'
+});
 
-assert.throws(
-  () => a.doesNotThrow(() => thrower(Error)),
-  {
-    code: 'ERR_ASSERTION',
-    message: 'Got unwanted exception.\nActual message: "[object Object]"'
-  }
-);
+assert.throws(() => a.doesNotThrow(() => thrower(Error)), {
+  code: 'ERR_ASSERTION',
+  message: 'Got unwanted exception.\nActual message: "[object Object]"'
+});
 
 // Make sure that validating using constructor really works.
 {
   let threw = false;
   try {
-    assert.throws(
-      () => {
-        throw ({}); // eslint-disable-line no-throw-literal
-      },
-      Array
-    );
+    assert.throws(() => {
+      throw {}; // eslint-disable-line no-throw-literal
+    }, Array);
   } catch {
     threw = true;
   }
@@ -180,11 +179,14 @@ assert.throws(
 a.throws(() => thrower(TypeError), /\[object Object\]/);
 
 // Use a fn to validate the error object.
-a.throws(() => thrower(TypeError), (err) => {
-  if ((err instanceof TypeError) && /\[object Object\]/.test(err)) {
-    return true;
+a.throws(
+  () => thrower(TypeError),
+  (err) => {
+    if (err instanceof TypeError && /\[object Object\]/.test(err)) {
+      return true;
+    }
   }
-});
+);
 
 // https://github.com/nodejs/node/issues/3188
 {
@@ -194,11 +196,15 @@ a.throws(() => thrower(TypeError), (err) => {
     const ES6Error = class extends Error {};
     AnotherErrorType = class extends Error {};
 
-    assert.throws(() => { throw new AnotherErrorType('foo'); }, ES6Error);
+    assert.throws(() => {
+      throw new AnotherErrorType('foo');
+    }, ES6Error);
   } catch (e) {
     threw = true;
-    assert(e instanceof AnotherErrorType,
-           `expected AnotherErrorType, received ${e}`);
+    assert(
+      e instanceof AnotherErrorType,
+      `expected AnotherErrorType, received ${e}`
+    );
   }
 
   assert.ok(threw);
@@ -208,41 +214,53 @@ a.throws(() => thrower(TypeError), (err) => {
 {
   const noop = () => {};
   assert.throws(
-    () => { a.throws((noop)); },
+    () => {
+      a.throws(noop);
+    },
     {
       code: 'ERR_ASSERTION',
       message: 'Missing expected exception.',
       operator: 'throws',
       actual: undefined,
       expected: undefined
-    });
+    }
+  );
 
   assert.throws(
-    () => { a.throws(noop, TypeError); },
+    () => {
+      a.throws(noop, TypeError);
+    },
     {
       code: 'ERR_ASSERTION',
       message: 'Missing expected exception (TypeError).',
       actual: undefined,
       expected: TypeError
-    });
+    }
+  );
 
   assert.throws(
-    () => { a.throws(noop, 'fhqwhgads'); },
+    () => {
+      a.throws(noop, 'fhqwhgads');
+    },
     {
       code: 'ERR_ASSERTION',
       message: 'Missing expected exception: fhqwhgads',
       actual: undefined,
       expected: undefined
-    });
+    }
+  );
 
   assert.throws(
-    () => { a.throws(noop, TypeError, 'fhqwhgads'); },
+    () => {
+      a.throws(noop, TypeError, 'fhqwhgads');
+    },
     {
       code: 'ERR_ASSERTION',
       message: 'Missing expected exception (TypeError): fhqwhgads',
       actual: undefined,
       expected: TypeError
-    });
+    }
+  );
 
   let threw = false;
   try {
@@ -264,16 +282,19 @@ function testAssertionMessage(actual, expected, msg) {
   } catch (e) {
     assert.strictEqual(
       e.message,
-      msg || strictEqualMessageStart +
-             `+ actual - expected\n\n+ ${expected}\n- ''`
+      msg ||
+        strictEqualMessageStart + `+ actual - expected\n\n+ ${expected}\n- ''`
     );
     assert.ok(e.generatedMessage, 'Message not marked as generated');
   }
 }
 
 function testShortAssertionMessage(actual, expected) {
-  testAssertionMessage(actual, expected, strictEqualMessageStart +
-                                         `\n${inspect(actual)} !== ''\n`);
+  testAssertionMessage(
+    actual,
+    expected,
+    strictEqualMessageStart + `\n${inspect(actual)} !== ''\n`
+  );
 }
 
 testShortAssertionMessage(null, 'null');
@@ -283,7 +304,7 @@ testShortAssertionMessage(100, '100');
 testShortAssertionMessage(NaN, 'NaN');
 testShortAssertionMessage(Infinity, 'Infinity');
 testShortAssertionMessage('', '""');
-testShortAssertionMessage('foo', '\'foo\'');
+testShortAssertionMessage('foo', "'foo'");
 testShortAssertionMessage(0, '0');
 testShortAssertionMessage(Symbol(), 'Symbol()');
 testAssertionMessage([], '[]');
@@ -296,19 +317,20 @@ testAssertionMessage([1, 2, 3], '[\n+   1,\n+   2,\n+   3\n+ ]');
 testAssertionMessage(function f() {}, '[Function: f]');
 testAssertionMessage(function() {}, '[Function]');
 testAssertionMessage(circular, '{\n+   x: [Circular],\n+   y: 1\n+ }');
-testAssertionMessage({ a: undefined, b: null },
-                     '{\n+   a: undefined,\n+   b: null\n+ }');
-testAssertionMessage({ a: NaN, b: Infinity, c: -Infinity },
-                     '{\n+   a: NaN,\n+   b: Infinity,\n+   c: -Infinity\n+ }');
+testAssertionMessage(
+  { a: undefined, b: null },
+  '{\n+   a: undefined,\n+   b: null\n+ }'
+);
+testAssertionMessage(
+  { a: NaN, b: Infinity, c: -Infinity },
+  '{\n+   a: NaN,\n+   b: Infinity,\n+   c: -Infinity\n+ }'
+);
 
 // https://github.com/nodejs/node-v0.x-archive/issues/5292
 try {
   assert.strictEqual(1, 2);
 } catch (e) {
-  assert.strictEqual(
-    e.message,
-    `${strictEqualMessageStart}\n1 !== 2\n`
-  );
+  assert.strictEqual(e.message, `${strictEqualMessageStart}\n1 !== 2\n`);
   assert.ok(e.generatedMessage, 'Message not marked as generated');
 }
 
@@ -337,9 +359,13 @@ try {
 
   // Verify AssertionError is the result from doesNotThrow with custom Error.
   try {
-    a.doesNotThrow(() => {
-      throw new TypeError('wrong type');
-    }, TypeError, rangeError);
+    a.doesNotThrow(
+      () => {
+        throw new TypeError('wrong type');
+      },
+      TypeError,
+      rangeError
+    );
   } catch (e) {
     threw = true;
     assert.ok(e.message.includes(rangeError.message));
@@ -352,15 +378,13 @@ try {
 {
   // Verify that throws() and doesNotThrow() throw on non-functions.
   const testBlockTypeError = (method, fn) => {
-    common.expectsError(
-      () => method(fn),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        type: TypeError,
-        message: 'The "fn" argument must be of type Function. Received ' +
-                 `type ${typeof fn}`
-      }
-    );
+    common.expectsError(() => method(fn), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "fn" argument must be of type Function. Received ' +
+        `type ${typeof fn}`
+    });
   };
 
   testBlockTypeError(assert.throws, 'string');
@@ -385,43 +409,54 @@ try {
 
 // https://github.com/nodejs/node/issues/3275
 // eslint-disable-next-line no-throw-literal
-assert.throws(() => { throw 'error'; }, (err) => err === 'error');
-assert.throws(() => { throw new Error(); }, (err) => err instanceof Error);
+assert.throws(
+  () => {
+    throw 'error';
+  },
+  (err) => err === 'error'
+);
+assert.throws(
+  () => {
+    throw new Error();
+  },
+  (err) => err instanceof Error
+);
 
 // Long values should be truncated for display.
-assert.throws(() => {
-  assert.strictEqual('A'.repeat(1000), '');
-}, {
-  code: 'ERR_ASSERTION',
-  message: `${strictEqualMessageStart}+ actual - expected\n\n` +
-           `+ '${'A'.repeat(1000)}'\n- ''`
-});
+assert.throws(
+  () => {
+    assert.strictEqual('A'.repeat(1000), '');
+  },
+  {
+    code: 'ERR_ASSERTION',
+    message:
+      `${strictEqualMessageStart}+ actual - expected\n\n` +
+      `+ '${'A'.repeat(1000)}'\n- ''`
+  }
+);
 
 {
   // Bad args to AssertionError constructor should throw TypeError.
   const args = [1, true, false, '', null, Infinity, Symbol('test'), undefined];
   args.forEach((input) => {
-    assert.throws(
-      () => new assert.AssertionError(input),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-        message: 'The "options" argument must be of type Object. ' +
-                 `Received type ${typeof input}`
-      });
+    assert.throws(() => new assert.AssertionError(input), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "options" argument must be of type Object. ' +
+        `Received type ${typeof input}`
+    });
   });
 }
 
-assert.throws(
-  () => assert.strictEqual(new Error('foo'), new Error('foobar')),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: 'Expected "actual" to be reference-equal to "expected":\n' +
-             '+ actual - expected\n\n' +
-             '+ [Error: foo]\n- [Error: foobar]'
-  }
-);
+assert.throws(() => assert.strictEqual(new Error('foo'), new Error('foobar')), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message:
+    'Expected "actual" to be reference-equal to "expected":\n' +
+    '+ actual - expected\n\n' +
+    '+ [Error: foo]\n- [Error: foobar]'
+});
 
 // Test strict assert.
 {
@@ -439,36 +474,29 @@ assert.throws(
   assert.equal(assert.notDeepEqual, assert.notDeepStrictEqual);
   assert.equal(Object.keys(assert).length, Object.keys(a).length);
   assert(7);
-  assert.throws(
-    () => assert(...[]),
-    {
-      message: 'No value argument passed to `assert.ok()`',
-      name: 'AssertionError [ERR_ASSERTION]',
-      generatedMessage: true
-    }
-  );
-  assert.throws(
-    () => a(),
-    {
-      message: 'No value argument passed to `assert.ok()`',
-      name: 'AssertionError [ERR_ASSERTION]'
-    }
-  );
+  assert.throws(() => assert(...[]), {
+    message: 'No value argument passed to `assert.ok()`',
+    name: 'AssertionError [ERR_ASSERTION]',
+    generatedMessage: true
+  });
+  assert.throws(() => a(), {
+    message: 'No value argument passed to `assert.ok()`',
+    name: 'AssertionError [ERR_ASSERTION]'
+  });
 
   // Test setting the limit to zero and that assert.strict works properly.
   const tmpLimit = Error.stackTraceLimit;
   Error.stackTraceLimit = 0;
   common.expectsError(
     () => {
-      assert.ok(
-        typeof 123 === 'string'
-      );
+      assert.ok(typeof 123 === 'string');
     },
     {
       code: 'ERR_ASSERTION',
       type: assert.AssertionError,
-      message: 'The expression evaluated to a falsy value:\n\n  ' +
-               "assert.ok(\n    typeof 123 === 'string'\n  )\n"
+      message:
+        'The expression evaluated to a falsy value:\n\n  ' +
+        "assert.ok(\n    typeof 123 === 'string'\n  )\n"
     }
   );
   Error.stackTraceLimit = tmpLimit;
@@ -487,10 +515,12 @@ assert.throws(
     '      ]',
     '...',
     '    5',
-    '  ]'].join('\n');
+    '  ]'
+  ].join('\n');
   assert.throws(
     () => assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]),
-    { message });
+    { message }
+  );
 
   message = [
     start,
@@ -507,10 +537,13 @@ assert.throws(
     '  ]'
   ].join('\n');
   assert.throws(
-    () => assert.deepEqual(
-      [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1],
-      [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1]),
-    { message });
+    () =>
+      assert.deepEqual(
+        [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1],
+        [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1]
+      ),
+    { message }
+  );
 
   message = [
     start,
@@ -527,10 +560,13 @@ assert.throws(
     '  ]'
   ].join('\n');
   assert.throws(
-    () => assert.deepEqual(
-      [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1],
-      [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1]),
-    { message });
+    () =>
+      assert.deepEqual(
+        [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1],
+        [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1]
+      ),
+    { message }
+  );
 
   message = [
     start,
@@ -548,10 +584,9 @@ assert.throws(
     '  ]'
   ].join('\n');
   assert.throws(
-    () => assert.deepEqual(
-      [1, 2, 1, 1, 0, 1, 1],
-      [1, 1, 1, 1, 0, 1]),
-    { message });
+    () => assert.deepEqual([1, 2, 1, 1, 0, 1, 1], [1, 1, 1, 1, 0, 1]),
+    { message }
+  );
 
   message = [
     start,
@@ -562,27 +597,17 @@ assert.throws(
     '+   2,',
     '+   1',
     '+ ]',
-    '- undefined',
+    '- undefined'
   ].join('\n');
-  assert.throws(
-    () => assert.deepEqual([1, 2, 1]),
-    { message });
+  assert.throws(() => assert.deepEqual([1, 2, 1]), { message });
 
-  message = [
-    start,
-    actExp,
-    '',
-    '  [',
-    '+   1,',
-    '    2,',
-    '    1',
-    '  ]'
-  ].join('\n');
-  assert.throws(
-    () => assert.deepEqual([1, 2, 1], [2, 1]),
-    { message });
+  message = [start, actExp, '', '  [', '+   1,', '    2,', '    1', '  ]'].join(
+    '\n'
+  );
+  assert.throws(() => assert.deepEqual([1, 2, 1], [2, 1]), { message });
 
-  message = `${start}\n` +
+  message =
+    `${start}\n` +
     `${actExp} ... Lines skipped\n` +
     '\n' +
     '  [\n' +
@@ -590,73 +615,62 @@ assert.throws(
     '...\n' +
     '-   2,\n'.repeat(10) +
     '...';
-  assert.throws(
-    () => assert.deepEqual(Array(12).fill(1), Array(12).fill(2)),
-    { message });
+  assert.throws(() => assert.deepEqual(Array(12).fill(1), Array(12).fill(2)), {
+    message
+  });
 
   const obj1 = {};
   const obj2 = { loop: 'forever' };
   obj2[inspect.custom] = () => '{}';
   // No infinite loop and no custom inspect.
   assert.throws(() => assert.deepEqual(obj1, obj2), {
-    message: `${start}\n` +
-    `${actExp}\n` +
-    '\n' +
-    '+ {}\n' +
-    '- {\n' +
-    '-   [Symbol(nodejs.util.inspect.custom)]: [Function],\n' +
-    "-   loop: 'forever'\n" +
-    '- }'
+    message:
+      `${start}\n` +
+      `${actExp}\n` +
+      '\n' +
+      '+ {}\n' +
+      '- {\n' +
+      '-   [Symbol(nodejs.util.inspect.custom)]: [Function],\n' +
+      "-   loop: 'forever'\n" +
+      '- }'
   });
 
   // notDeepEqual tests
-  assert.throws(
-    () => assert.notDeepEqual([1], [1]),
-    {
-      message: 'Expected "actual" not to be strictly deep-equal to:\n\n' +
-               '[\n  1\n]\n'
-    }
-  );
+  assert.throws(() => assert.notDeepEqual([1], [1]), {
+    message:
+      'Expected "actual" not to be strictly deep-equal to:\n\n' + '[\n  1\n]\n'
+  });
 
-  message = 'Expected "actual" not to be strictly deep-equal to:' +
-            `\n\n[${'\n  1,'.repeat(25)}\n...\n`;
+  message =
+    'Expected "actual" not to be strictly deep-equal to:' +
+    `\n\n[${'\n  1,'.repeat(25)}\n...\n`;
   const data = Array(31).fill(1);
-  assert.throws(
-    () => assert.notDeepEqual(data, data),
-    { message });
+  assert.throws(() => assert.notDeepEqual(data, data), { message });
   /* eslint-enable no-restricted-properties */
 }
 
-common.expectsError(
-  () => assert.ok(null),
-  {
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    generatedMessage: true,
-    message: 'The expression evaluated to a falsy value:\n\n  ' +
-             'assert.ok(null)\n'
-  }
-);
-common.expectsError(
-  () => assert(typeof 123 === 'string'),
-  {
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    generatedMessage: true,
-    message: 'The expression evaluated to a falsy value:\n\n  ' +
-             "assert(typeof 123 === 'string')\n"
-  }
-);
+common.expectsError(() => assert.ok(null), {
+  code: 'ERR_ASSERTION',
+  type: assert.AssertionError,
+  generatedMessage: true,
+  message:
+    'The expression evaluated to a falsy value:\n\n  ' + 'assert.ok(null)\n'
+});
+common.expectsError(() => assert(typeof 123 === 'string'), {
+  code: 'ERR_ASSERTION',
+  type: assert.AssertionError,
+  generatedMessage: true,
+  message:
+    'The expression evaluated to a falsy value:\n\n  ' +
+    "assert(typeof 123 === 'string')\n"
+});
 
-common.expectsError(
-  () => assert(false, Symbol('foo')),
-  {
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    generatedMessage: false,
-    message: 'Symbol(foo)'
-  }
-);
+common.expectsError(() => assert(false, Symbol('foo')), {
+  code: 'ERR_ASSERTION',
+  type: assert.AssertionError,
+  generatedMessage: false,
+  message: 'Symbol(foo)'
+});
 
 {
   // Test caching.
@@ -665,132 +679,126 @@ common.expectsError(
   fs.close = common.mustCall(tmp, 1);
   function throwErr() {
     // eslint-disable-next-line prefer-assert-methods
-    assert(
-      (Buffer.from('test') instanceof Error)
-    );
+    assert(Buffer.from('test') instanceof Error);
   }
-  common.expectsError(
-    () => throwErr(),
-    {
-      code: 'ERR_ASSERTION',
-      type: assert.AssertionError,
-      message: 'The expression evaluated to a falsy value:\n\n  ' +
-               "assert(\n    (Buffer.from('test') instanceof Error)\n  )\n"
-    }
-  );
-  common.expectsError(
-    () => throwErr(),
-    {
-      code: 'ERR_ASSERTION',
-      type: assert.AssertionError,
-      message: 'The expression evaluated to a falsy value:\n\n  ' +
-               "assert(\n    (Buffer.from('test') instanceof Error)\n  )\n"
-    }
-  );
+  common.expectsError(() => throwErr(), {
+    code: 'ERR_ASSERTION',
+    type: assert.AssertionError,
+    message:
+      'The expression evaluated to a falsy value:\n\n  ' +
+      "assert(\n    (Buffer.from('test') instanceof Error)\n  )\n"
+  });
+  common.expectsError(() => throwErr(), {
+    code: 'ERR_ASSERTION',
+    type: assert.AssertionError,
+    message:
+      'The expression evaluated to a falsy value:\n\n  ' +
+      "assert(\n    (Buffer.from('test') instanceof Error)\n  )\n"
+  });
   fs.close = tmp;
 }
 
 common.expectsError(
   () => {
     a(
-      (() => 'string')()
-      // eslint-disable-next-line operator-linebreak
-      ===
-      123 instanceof
-          Buffer
+      (() => 'string')() ===
+        // eslint-disable-next-line operator-linebreak
+        123 instanceof Buffer
     );
   },
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
-    message: 'The expression evaluated to a falsy value:\n\n' +
-             '  a(\n' +
-             '    (() => \'string\')()\n' +
-             '    // eslint-disable-next-line operator-linebreak\n' +
-             '    ===\n' +
-             '    123 instanceof\n' +
-             '        Buffer\n' +
-             '  )\n'
+    message:
+      'The expression evaluated to a falsy value:\n\n' +
+      '  a(\n' +
+      "    (() => 'string')()\n" +
+      '    // eslint-disable-next-line operator-linebreak\n' +
+      '    ===\n' +
+      '    123 instanceof\n' +
+      '        Buffer\n' +
+      '  )\n'
   }
 );
 
 common.expectsError(
   () => {
     a(
-      (() => 'string')()
-      // eslint-disable-next-line operator-linebreak
-      ===
-  123 instanceof
-          Buffer
+      (() => 'string')() ===
+        // eslint-disable-next-line operator-linebreak
+        123 instanceof Buffer
     );
   },
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
-    message: 'The expression evaluated to a falsy value:\n\n' +
-             '  a(\n' +
-             '    (() => \'string\')()\n' +
-             '    // eslint-disable-next-line operator-linebreak\n' +
-             '    ===\n' +
-             '  123 instanceof\n' +
-             '        Buffer\n' +
-             '  )\n'
+    message:
+      'The expression evaluated to a falsy value:\n\n' +
+      '  a(\n' +
+      "    (() => 'string')()\n" +
+      '    // eslint-disable-next-line operator-linebreak\n' +
+      '    ===\n' +
+      '  123 instanceof\n' +
+      '        Buffer\n' +
+      '  )\n'
   }
 );
 
 /* eslint-disable indent */
-common.expectsError(() => {
-a((
-  () => 'string')() ===
-123 instanceof
-Buffer
-);
-}, {
-  code: 'ERR_ASSERTION',
-  type: assert.AssertionError,
-  message: 'The expression evaluated to a falsy value:\n\n' +
-           '  a((\n' +
-           '    () => \'string\')() ===\n' +
-           '  123 instanceof\n' +
-           '  Buffer\n' +
-           '  )\n'
+common.expectsError(
+  () => {
+    a((() => 'string')() === 123 instanceof Buffer);
+  },
+  {
+    code: 'ERR_ASSERTION',
+    type: assert.AssertionError,
+    message:
+      'The expression evaluated to a falsy value:\n\n' +
+      '  a((\n' +
+      "    () => 'string')() ===\n" +
+      '  123 instanceof\n' +
+      '  Buffer\n' +
+      '  )\n'
   }
 );
 /* eslint-enable indent */
 
 common.expectsError(
   () => {
-    assert(true); assert(null, undefined);
+    assert(true);
+    assert(null, undefined);
   },
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
-    message: 'The expression evaluated to a falsy value:\n\n  ' +
-             'assert(null, undefined)\n'
+    message:
+      'The expression evaluated to a falsy value:\n\n  ' +
+      'assert(null, undefined)\n'
   }
 );
 
 common.expectsError(
   () => {
-    assert
-     .ok(null, undefined);
+    assert.ok(null, undefined);
   },
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
-    message: 'The expression evaluated to a falsy value:\n\n  ' +
-             'ok(null, undefined)\n'
+    message:
+      'The expression evaluated to a falsy value:\n\n  ' +
+      'ok(null, undefined)\n'
   }
 );
 
 common.expectsError(
   // eslint-disable-next-line dot-notation, quotes
-  () => assert['ok']["apply"](null, [0]),
+  () => assert['ok']['apply'](null, [0]),
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
-    message: 'The expression evaluated to a falsy value:\n\n  ' +
-             'assert[\'ok\']["apply"](null, [0])\n'
+    message:
+      'The expression evaluated to a falsy value:\n\n  ' +
+      'assert[\'ok\']["apply"](null, [0])\n'
   }
 );
 
@@ -806,36 +814,28 @@ common.expectsError(
   }
 );
 
-common.expectsError(
-  () => assert.ok.call(null, 0),
-  {
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    message: 'The expression evaluated to a falsy value:\n\n  ' +
-             'assert.ok.call(null, 0)\n',
-    generatedMessage: true
-  }
-);
+common.expectsError(() => assert.ok.call(null, 0), {
+  code: 'ERR_ASSERTION',
+  type: assert.AssertionError,
+  message:
+    'The expression evaluated to a falsy value:\n\n  ' +
+    'assert.ok.call(null, 0)\n',
+  generatedMessage: true
+});
 
-common.expectsError(
-  () => assert.ok.call(null, 0, 'test'),
-  {
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    message: 'test',
-    generatedMessage: false
-  }
-);
+common.expectsError(() => assert.ok.call(null, 0, 'test'), {
+  code: 'ERR_ASSERTION',
+  type: assert.AssertionError,
+  message: 'test',
+  generatedMessage: false
+});
 
 // Works in eval.
-common.expectsError(
-  () => new Function('assert', 'assert(1 === 2);')(assert),
-  {
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    message: 'false == true'
-  }
-);
+common.expectsError(() => new Function('assert', 'assert(1 === 2);')(assert), {
+  code: 'ERR_ASSERTION',
+  type: assert.AssertionError,
+  message: 'false == true'
+});
 
 common.expectsError(
   // eslint-disable-next-line no-restricted-syntax
@@ -843,34 +843,32 @@ common.expectsError(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "error" argument must be one of type Object, Error, ' +
-             'Function, or RegExp. Received type string'
+    message:
+      'The "error" argument must be one of type Object, Error, ' +
+      'Function, or RegExp. Received type string'
   }
 );
 
-[
-  1,
-  false,
-  Symbol()
-].forEach((input) => {
+[1, false, Symbol()].forEach((input) => {
+  assert.throws(() => assert.throws(() => {}, input), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "error" argument must be one of type Object, Error, ' +
+      `Function, or RegExp. Received type ${typeof input}`
+  });
+});
+
+{
   assert.throws(
-    () => assert.throws(() => {}, input),
+    () => {
+      assert.ok((() => Boolean('
' === false))());
+    },
     {
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: 'The "error" argument must be one of type Object, Error, ' +
-               `Function, or RegExp. Received type ${typeof input}`
+      message:
+        'The expression evaluated to a falsy value:\n\n' +
+        "  assert.ok((() => Boolean('\\u0001' === false))())\n"
     }
   );
-});
-
-{
-
-  assert.throws(() => {
-    assert.ok((() => Boolean('
' === false))());
-  }, {
-    message: 'The expression evaluated to a falsy value:\n\n' +
-             "  assert.ok((() => Boolean('\\u0001' === false))())\n"
-  });
 
   const errFn = () => {
     const err = new TypeError('Wrong value');
@@ -889,41 +887,44 @@ common.expectsError(
   // Fail in case a expected property is undefined and not existent on the
   // error.
   errObj.foo = undefined;
-  assert.throws(
-    () => assert.throws(errFn, errObj),
-    {
-      code: 'ERR_ASSERTION',
-      name: 'AssertionError [ERR_ASSERTION]',
-      message: `${start}\n${actExp}\n\n` +
-               '  Comparison {\n' +
-               '    code: 404,\n' +
-               '-   foo: undefined,\n' +
-               "    message: 'Wrong value',\n" +
-               "    name: 'TypeError'\n" +
-               '  }'
-    }
-  );
+  assert.throws(() => assert.throws(errFn, errObj), {
+    code: 'ERR_ASSERTION',
+    name: 'AssertionError [ERR_ASSERTION]',
+    message:
+      `${start}\n${actExp}\n\n` +
+      '  Comparison {\n' +
+      '    code: 404,\n' +
+      '-   foo: undefined,\n' +
+      "    message: 'Wrong value',\n" +
+      "    name: 'TypeError'\n" +
+      '  }'
+  });
 
   // Show multiple wrong properties at the same time.
   errObj.code = '404';
-  assert.throws(
-    () => assert.throws(errFn, errObj),
-    {
-      code: 'ERR_ASSERTION',
-      name: 'AssertionError [ERR_ASSERTION]',
-      message: `${start}\n${actExp}\n\n` +
-               '  Comparison {\n' +
-               '+   code: 404,\n' +
-               "-   code: '404',\n" +
-               '-   foo: undefined,\n' +
-               "    message: 'Wrong value',\n" +
-               "    name: 'TypeError'\n" +
-               '  }'
-    }
-  );
+  assert.throws(() => assert.throws(errFn, errObj), {
+    code: 'ERR_ASSERTION',
+    name: 'AssertionError [ERR_ASSERTION]',
+    message:
+      `${start}\n${actExp}\n\n` +
+      '  Comparison {\n' +
+      '+   code: 404,\n' +
+      "-   code: '404',\n" +
+      '-   foo: undefined,\n' +
+      "    message: 'Wrong value',\n" +
+      "    name: 'TypeError'\n" +
+      '  }'
+  });
 
   common.expectsError(
-    () => assert.throws(() => { throw new Error(); }, { foo: 'bar' }, 'foobar'),
+    () =>
+      assert.throws(
+        () => {
+          throw new Error();
+        },
+        { foo: 'bar' },
+        'foobar'
+      ),
     {
       type: assert.AssertionError,
       code: 'ERR_ASSERTION',
@@ -932,49 +933,71 @@ common.expectsError(
   );
 
   common.expectsError(
-    () => a.doesNotThrow(() => { throw new Error(); }, { foo: 'bar' }),
+    () =>
+      a.doesNotThrow(
+        () => {
+          throw new Error();
+        },
+        { foo: 'bar' }
+      ),
     {
       type: TypeError,
       code: 'ERR_INVALID_ARG_TYPE',
-      message: 'The "expected" argument must be one of type Function or ' +
-               'RegExp. Received type object'
+      message:
+        'The "expected" argument must be one of type Function or ' +
+        'RegExp. Received type object'
     }
   );
 
-  assert.throws(() => { throw new Error('e'); }, new Error('e'));
+  assert.throws(() => {
+    throw new Error('e');
+  }, new Error('e'));
   assert.throws(
-    () => assert.throws(() => { throw new TypeError('e'); }, new Error('e')),
+    () =>
+      assert.throws(() => {
+        throw new TypeError('e');
+      }, new Error('e')),
     {
       name: 'AssertionError [ERR_ASSERTION]',
       code: 'ERR_ASSERTION',
-      message: `${start}\n${actExp}\n\n` +
-               '  Comparison {\n' +
-               "    message: 'e',\n" +
-               "+   name: 'TypeError'\n" +
-               "-   name: 'Error'\n" +
-               '  }'
+      message:
+        `${start}\n${actExp}\n\n` +
+        '  Comparison {\n' +
+        "    message: 'e',\n" +
+        "+   name: 'TypeError'\n" +
+        "-   name: 'Error'\n" +
+        '  }'
     }
   );
   assert.throws(
-    () => assert.throws(() => { throw new Error('foo'); }, new Error('')),
+    () =>
+      assert.throws(() => {
+        throw new Error('foo');
+      }, new Error('')),
     {
       name: 'AssertionError [ERR_ASSERTION]',
       code: 'ERR_ASSERTION',
       generatedMessage: true,
-      message: `${start}\n${actExp}\n\n` +
-               '  Comparison {\n' +
-               "+   message: 'foo',\n" +
-               "-   message: '',\n" +
-               "    name: 'Error'\n" +
-               '  }'
+      message:
+        `${start}\n${actExp}\n\n` +
+        '  Comparison {\n' +
+        "+   message: 'foo',\n" +
+        "-   message: '',\n" +
+        "    name: 'Error'\n" +
+        '  }'
     }
   );
 
   // eslint-disable-next-line no-throw-literal
-  assert.throws(() => { throw undefined; }, /undefined/);
+  assert.throws(() => {
+    throw undefined;
+  }, /undefined/);
   assert.throws(
     // eslint-disable-next-line no-throw-literal
-    () => a.doesNotThrow(() => { throw undefined; }),
+    () =>
+      a.doesNotThrow(() => {
+        throw undefined;
+      }),
     {
       name: 'AssertionError [ERR_ASSERTION]',
       code: 'ERR_ASSERTION',
@@ -984,7 +1007,10 @@ common.expectsError(
 }
 
 assert.throws(
-  () => assert.throws(() => { throw new Error(); }, {}),
+  () =>
+    assert.throws(() => {
+      throw new Error();
+    }, {}),
   {
     message: "The argument 'error' may not be an empty object. Received {}",
     code: 'ERR_INVALID_ARG_VALUE'
@@ -992,55 +1018,61 @@ assert.throws(
 );
 
 assert.throws(
-  () => a.throws(
-    // eslint-disable-next-line no-throw-literal
-    () => { throw 'foo'; },
-    'foo'
-  ),
+  () =>
+    a.throws(
+      // eslint-disable-next-line no-throw-literal
+      () => {
+        throw 'foo';
+      },
+      'foo'
+    ),
   {
     code: 'ERR_AMBIGUOUS_ARGUMENT',
-    message: 'The "error/message" argument is ambiguous. ' +
-             'The error "foo" is identical to the message.'
+    message:
+      'The "error/message" argument is ambiguous. ' +
+      'The error "foo" is identical to the message.'
   }
 );
 
 assert.throws(
-  () => a.throws(
-    () => { throw new TypeError('foo'); },
-    'foo'
-  ),
+  () =>
+    a.throws(() => {
+      throw new TypeError('foo');
+    }, 'foo'),
   {
     code: 'ERR_AMBIGUOUS_ARGUMENT',
-    message: 'The "error/message" argument is ambiguous. ' +
-             'The error message "foo" is identical to the message.'
+    message:
+      'The "error/message" argument is ambiguous. ' +
+      'The error message "foo" is identical to the message.'
   }
 );
 
 // Should not throw.
 // eslint-disable-next-line no-restricted-syntax, no-throw-literal
-assert.throws(() => { throw null; }, 'foo');
+assert.throws(() => {
+  throw null;
+}, 'foo');
 
-assert.throws(
-  () => assert.strictEqual([], []),
-  {
-    message: 'Values identical but not reference-equal:\n\n[]\n'
-  }
-);
+assert.throws(() => assert.strictEqual([], []), {
+  message: 'Values identical but not reference-equal:\n\n[]\n'
+});
 
 {
-  const args = (function() { return arguments; })('a');
-  assert.throws(
-    () => assert.strictEqual(args, { 0: 'a' }),
-    {
-      message: 'Expected "actual" to be reference-equal to "expected":\n' +
-               '+ actual - expected\n\n' +
-               "+ [Arguments] {\n- {\n    '0': 'a'\n  }"
-    }
-  );
+  const args = (function() {
+    return arguments;
+  })('a');
+  assert.throws(() => assert.strictEqual(args, { 0: 'a' }), {
+    message:
+      'Expected "actual" to be reference-equal to "expected":\n' +
+      '+ actual - expected\n\n' +
+      "+ [Arguments] {\n- {\n    '0': 'a'\n  }"
+  });
 }
 
 assert.throws(
-  () => { throw new TypeError('foobar'); },
+  () => {
+    throw new TypeError('foobar');
+  },
   {
     message: /foo/,
     name: /^TypeError$/
@@ -1048,20 +1080,24 @@ assert.throws(
 );
 
 assert.throws(
-  () => assert.throws(
-    () => { throw new TypeError('foobar'); },
-    {
-      message: /fooa/,
-      name: /^TypeError$/
-    }
-  ),
+  () =>
+    assert.throws(
+      () => {
+        throw new TypeError('foobar');
+      },
+      {
+        message: /fooa/,
+        name: /^TypeError$/
+      }
+    ),
   {
-    message: `${start}\n${actExp}\n\n` +
-             '  Comparison {\n' +
-             "+   message: 'foobar',\n" +
-             '-   message: /fooa/,\n' +
-             "    name: 'TypeError'\n" +
-             '  }'
+    message:
+      `${start}\n${actExp}\n\n` +
+      '  Comparison {\n' +
+      "+   message: 'foobar',\n" +
+      '-   message: /fooa/,\n' +
+      "    name: 'TypeError'\n" +
+      '  }'
   }
 );
 
@@ -1069,31 +1105,35 @@ assert.throws(
   let actual = null;
   const expected = { message: 'foo' };
   assert.throws(
-    () => assert.throws(
-      () => { throw actual; },
-      expected
-    ),
+    () =>
+      assert.throws(() => {
+        throw actual;
+      }, expected),
     {
       operator: 'throws',
       actual,
       expected,
       generatedMessage: true,
-      message: `${start}\n${actExp}\n\n` +
-              '+ null\n' +
-              '- {\n' +
-              "-   message: 'foo'\n" +
-              '- }'
+      message:
+        `${start}\n${actExp}\n\n` +
+        '+ null\n' +
+        '- {\n' +
+        "-   message: 'foo'\n" +
+        '- }'
     }
   );
 
   actual = 'foobar';
   const message = 'message';
   assert.throws(
-    () => assert.throws(
-      () => { throw actual; },
-      { message: 'foobar' },
-      message
-    ),
+    () =>
+      assert.throws(
+        () => {
+          throw actual;
+        },
+        { message: 'foobar' },
+        message
+      ),
     {
       actual,
       message,
@@ -1104,18 +1144,16 @@ assert.throws(
 }
 
 // Indicate where the strings diverge.
-assert.throws(
-  () => assert.strictEqual('test test', 'test foobar'),
-  {
-    code: 'ERR_ASSERTION',
-    name: 'AssertionError [ERR_ASSERTION]',
-    message: strictEqualMessageStart +
-             '+ actual - expected\n\n' +
-             "+ 'test test'\n" +
-             "- 'test foobar'\n" +
-             '        ^'
-  }
-);
+assert.throws(() => assert.strictEqual('test test', 'test foobar'), {
+  code: 'ERR_ASSERTION',
+  name: 'AssertionError [ERR_ASSERTION]',
+  message:
+    strictEqualMessageStart +
+    '+ actual - expected\n\n' +
+    "+ 'test test'\n" +
+    "- 'test foobar'\n" +
+    '        ^'
+});
 
 // Check for reference-equal objects in `notStrictEqual()`
 assert.throws(
@@ -1138,7 +1176,8 @@ assert.throws(
   {
     code: 'ERR_ASSERTION',
     name: 'AssertionError [ERR_ASSERTION]',
-    message: 'Expected "actual" not to be reference-equal to "expected":\n\n' +
-             '{\n  a: true\n}\n'
+    message:
+      'Expected "actual" not to be reference-equal to "expected":\n\n' +
+      '{\n  a: true\n}\n'
   }
 );
diff --git a/test/parallel/test-async-hooks-async-await.js b/test/parallel/test-async-hooks-async-await.js
index 791adab75c8621..9ecc15d55a2d7a 100644
--- a/test/parallel/test-async-hooks-async-await.js
+++ b/test/parallel/test-async-hooks-async-await.js
@@ -7,11 +7,13 @@ const async_hooks = require('async_hooks');
 const assert = require('assert');
 
 const asyncIds = [];
-async_hooks.createHook({
-  init: (asyncId, type, triggerAsyncId) => {
-    asyncIds.push([triggerAsyncId, asyncId]);
-  }
-}).enable();
+async_hooks
+  .createHook({
+    init: (asyncId, type, triggerAsyncId) => {
+      asyncIds.push([triggerAsyncId, asyncId]);
+    }
+  })
+  .enable();
 
 async function main() {
   await null;
diff --git a/test/parallel/test-async-hooks-asyncresource-constructor.js b/test/parallel/test-async-hooks-asyncresource-constructor.js
index ebd5a4cf646bfd..b687c4bb4f04bb 100644
--- a/test/parallel/test-async-hooks-asyncresource-constructor.js
+++ b/test/parallel/test-async-hooks-asyncresource-constructor.js
@@ -7,34 +7,48 @@ const async_hooks = require('async_hooks');
 const { AsyncResource } = async_hooks;
 
 // Setup init hook such parameters are validated
-async_hooks.createHook({
-  init() {}
-}).enable();
+async_hooks
+  .createHook({
+    init() {}
+  })
+  .enable();
 
-common.expectsError(() => {
-  return new AsyncResource();
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-});
+common.expectsError(
+  () => {
+    return new AsyncResource();
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }
+);
 
-common.expectsError(() => {
-  new AsyncResource('');
-}, {
-  code: 'ERR_ASYNC_TYPE',
-  type: TypeError,
-});
+common.expectsError(
+  () => {
+    new AsyncResource('');
+  },
+  {
+    code: 'ERR_ASYNC_TYPE',
+    type: TypeError
+  }
+);
 
-common.expectsError(() => {
-  new AsyncResource('type', -4);
-}, {
-  code: 'ERR_INVALID_ASYNC_ID',
-  type: RangeError,
-});
+common.expectsError(
+  () => {
+    new AsyncResource('type', -4);
+  },
+  {
+    code: 'ERR_INVALID_ASYNC_ID',
+    type: RangeError
+  }
+);
 
-common.expectsError(() => {
-  new AsyncResource('type', Math.PI);
-}, {
-  code: 'ERR_INVALID_ASYNC_ID',
-  type: RangeError,
-});
+common.expectsError(
+  () => {
+    new AsyncResource('type', Math.PI);
+  },
+  {
+    code: 'ERR_INVALID_ASYNC_ID',
+    type: RangeError
+  }
+);
diff --git a/test/parallel/test-async-hooks-close-during-destroy.js b/test/parallel/test-async-hooks-close-during-destroy.js
index abdeab2404251a..cfc4af04b9be16 100644
--- a/test/parallel/test-async-hooks-close-during-destroy.js
+++ b/test/parallel/test-async-hooks-close-during-destroy.js
@@ -10,25 +10,26 @@ const initCalls = new Set();
 let destroyResCallCount = 0;
 let res2;
 
-async_hooks.createHook({
-  init: common.mustCallAtLeast((id, provider, triggerAsyncId) => {
-    if (provider === 'foobar')
-      initCalls.add(id);
-  }, 2),
-  destroy: common.mustCallAtLeast((id) => {
-    if (!initCalls.has(id)) return;
+async_hooks
+  .createHook({
+    init: common.mustCallAtLeast((id, provider, triggerAsyncId) => {
+      if (provider === 'foobar') initCalls.add(id);
+    }, 2),
+    destroy: common.mustCallAtLeast((id) => {
+      if (!initCalls.has(id)) return;
 
-    switch (destroyResCallCount++) {
-      case 0:
-        // Trigger the second `destroy` call.
-        res2.emitDestroy();
-        break;
-      case 2:
-        assert.fail('More than 2 destroy() invocations');
-        break;
-    }
-  }, 2)
-}).enable();
+      switch (destroyResCallCount++) {
+        case 0:
+          // Trigger the second `destroy` call.
+          res2.emitDestroy();
+          break;
+        case 2:
+          assert.fail('More than 2 destroy() invocations');
+          break;
+      }
+    }, 2)
+  })
+  .enable();
 
 const res1 = new async_hooks.AsyncResource('foobar');
 res2 = new async_hooks.AsyncResource('foobar');
diff --git a/test/parallel/test-async-hooks-constructor.js b/test/parallel/test-async-hooks-constructor.js
index f2b4df6a9f9f99..56b5db6bb38173 100644
--- a/test/parallel/test-async-hooks-constructor.js
+++ b/test/parallel/test-async-hooks-constructor.js
@@ -13,11 +13,14 @@ typeErrorForFunction('destroy');
 typeErrorForFunction('promiseResolve');
 
 function typeErrorForFunction(functionName) {
-  common.expectsError(() => {
-    async_hooks.createHook({ [functionName]: non_function });
-  }, {
-    code: 'ERR_ASYNC_CALLBACK',
-    type: TypeError,
-    message: `hook.${functionName} must be a function`
-  });
+  common.expectsError(
+    () => {
+      async_hooks.createHook({ [functionName]: non_function });
+    },
+    {
+      code: 'ERR_ASYNC_CALLBACK',
+      type: TypeError,
+      message: `hook.${functionName} must be a function`
+    }
+  );
 }
diff --git a/test/parallel/test-async-hooks-destroy-on-gc.js b/test/parallel/test-async-hooks-destroy-on-gc.js
index fe6325e189734b..794b0c6a608a82 100644
--- a/test/parallel/test-async-hooks-destroy-on-gc.js
+++ b/test/parallel/test-async-hooks-destroy-on-gc.js
@@ -9,11 +9,13 @@ const assert = require('assert');
 const async_hooks = require('async_hooks');
 
 const destroyedIds = new Set();
-async_hooks.createHook({
-  destroy: common.mustCallAtLeast((asyncId) => {
-    destroyedIds.add(asyncId);
-  }, 1)
-}).enable();
+async_hooks
+  .createHook({
+    destroy: common.mustCallAtLeast((asyncId) => {
+      destroyedIds.add(asyncId);
+    }, 1)
+  })
+  .enable();
 
 let asyncId = null;
 {
diff --git a/test/parallel/test-async-hooks-disable-during-promise.js b/test/parallel/test-async-hooks-disable-during-promise.js
index 6b9b53bd30f0f5..39f9e9d015ca5f 100644
--- a/test/parallel/test-async-hooks-disable-during-promise.js
+++ b/test/parallel/test-async-hooks-disable-during-promise.js
@@ -5,16 +5,20 @@ const async_hooks = require('async_hooks');
 if (!common.isMainThread)
   common.skip('Worker bootstrapping works differently -> different AsyncWraps');
 
-const hook = async_hooks.createHook({
-  init: common.mustCall(2),
-  before: common.mustCall(1),
-  after: common.mustNotCall()
-}).enable();
+const hook = async_hooks
+  .createHook({
+    init: common.mustCall(2),
+    before: common.mustCall(1),
+    after: common.mustNotCall()
+  })
+  .enable();
 
-Promise.resolve(1).then(common.mustCall(() => {
-  hook.disable();
+Promise.resolve(1).then(
+  common.mustCall(() => {
+    hook.disable();
 
-  Promise.resolve(42).then(common.mustCall());
+    Promise.resolve(42).then(common.mustCall());
 
-  process.nextTick(common.mustCall());
-}));
+    process.nextTick(common.mustCall());
+  })
+);
diff --git a/test/parallel/test-async-hooks-disable-gc-tracking.js b/test/parallel/test-async-hooks-disable-gc-tracking.js
index 84c5043aad3335..906c9c774922c9 100644
--- a/test/parallel/test-async-hooks-disable-gc-tracking.js
+++ b/test/parallel/test-async-hooks-disable-gc-tracking.js
@@ -7,9 +7,11 @@
 const common = require('../common');
 const async_hooks = require('async_hooks');
 
-const hook = async_hooks.createHook({
-  destroy: common.mustCallAtLeast(1) // only 1 immediate is destroyed
-}).enable();
+const hook = async_hooks
+  .createHook({
+    destroy: common.mustCallAtLeast(1) // only 1 immediate is destroyed
+  })
+  .enable();
 
 new async_hooks.AsyncResource('foobar', { requireManualDestroy: true });
 
diff --git a/test/parallel/test-async-hooks-enable-during-promise.js b/test/parallel/test-async-hooks-enable-during-promise.js
index ce3253b01c1279..3180bb2b15dc51 100644
--- a/test/parallel/test-async-hooks-enable-during-promise.js
+++ b/test/parallel/test-async-hooks-enable-during-promise.js
@@ -2,12 +2,16 @@
 const common = require('../common');
 const async_hooks = require('async_hooks');
 
-Promise.resolve(1).then(common.mustCall(() => {
-  async_hooks.createHook({
-    init: common.mustCall(),
-    before: common.mustCallAtLeast(),
-    after: common.mustCallAtLeast(2)
-  }).enable();
+Promise.resolve(1).then(
+  common.mustCall(() => {
+    async_hooks
+      .createHook({
+        init: common.mustCall(),
+        before: common.mustCallAtLeast(),
+        after: common.mustCallAtLeast(2)
+      })
+      .enable();
 
-  process.nextTick(common.mustCall());
-}));
+    process.nextTick(common.mustCall());
+  })
+);
diff --git a/test/parallel/test-async-hooks-enable-recursive.js b/test/parallel/test-async-hooks-enable-recursive.js
index bcb0dcc0ce0a66..a2e57f947803b5 100644
--- a/test/parallel/test-async-hooks-enable-recursive.js
+++ b/test/parallel/test-async-hooks-enable-recursive.js
@@ -8,12 +8,17 @@ const nestedHook = async_hooks.createHook({
   init: common.mustCall()
 });
 
-async_hooks.createHook({
-  init: common.mustCall((id, type) => {
-    nestedHook.enable();
-  }, 2)
-}).enable();
+async_hooks
+  .createHook({
+    init: common.mustCall((id, type) => {
+      nestedHook.enable();
+    }, 2)
+  })
+  .enable();
 
-fs.access(__filename, common.mustCall(() => {
-  fs.access(__filename, common.mustCall());
-}));
+fs.access(
+  __filename,
+  common.mustCall(() => {
+    fs.access(__filename, common.mustCall());
+  })
+);
diff --git a/test/parallel/test-async-hooks-http-agent-destroy.js b/test/parallel/test-async-hooks-http-agent-destroy.js
index 637f2c511410e7..9719808cd6bf1e 100644
--- a/test/parallel/test-async-hooks-http-agent-destroy.js
+++ b/test/parallel/test-async-hooks-http-agent-destroy.js
@@ -13,11 +13,13 @@ const http = require('http');
 // a fresh asyncId is assigned to the net.Socket instance).
 
 const destroyedIds = new Set();
-async_hooks.createHook({
-  destroy: common.mustCallAtLeast((asyncId) => {
-    destroyedIds.add(asyncId);
-  }, 1)
-}).enable();
+async_hooks
+  .createHook({
+    destroy: common.mustCallAtLeast((asyncId) => {
+      destroyedIds.add(asyncId);
+    }, 1)
+  })
+  .enable();
 
 // Make sure a single socket is transparently reused for 2 requests.
 const agent = new http.Agent({
@@ -26,59 +28,90 @@ const agent = new http.Agent({
   maxSockets: 1
 });
 
-const server = http.createServer(common.mustCall((req, res) => {
-  req.once('data', common.mustCallAtLeast(() => {
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write('foo');
-  }));
-  req.on('end', common.mustCall(() => {
-    res.end('bar');
-  }));
-}, 2)).listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const payload = 'hello world';
+const server = http
+  .createServer(
+    common.mustCall((req, res) => {
+      req.once(
+        'data',
+        common.mustCallAtLeast(() => {
+          res.writeHead(200, { 'Content-Type': 'text/plain' });
+          res.write('foo');
+        })
+      );
+      req.on(
+        'end',
+        common.mustCall(() => {
+          res.end('bar');
+        })
+      );
+    }, 2)
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const payload = 'hello world';
 
-  // First request. This is useless except for adding a socket to the
-  // agent’s pool for reuse.
-  const r1 = http.request({
-    agent, port, method: 'POST'
-  }, common.mustCall((res) => {
-    // Remember which socket we used.
-    const socket = res.socket;
-    const asyncIdAtFirstRequest = socket[async_id_symbol];
-    assert.ok(asyncIdAtFirstRequest > 0, `${asyncIdAtFirstRequest} > 0`);
-    // Check that request and response share their socket.
-    assert.strictEqual(r1.socket, socket);
+      // First request. This is useless except for adding a socket to the
+      // agent’s pool for reuse.
+      const r1 = http.request(
+        {
+          agent,
+          port,
+          method: 'POST'
+        },
+        common.mustCall((res) => {
+          // Remember which socket we used.
+          const socket = res.socket;
+          const asyncIdAtFirstRequest = socket[async_id_symbol];
+          assert.ok(asyncIdAtFirstRequest > 0, `${asyncIdAtFirstRequest} > 0`);
+          // Check that request and response share their socket.
+          assert.strictEqual(r1.socket, socket);
 
-    res.on('data', common.mustCallAtLeast(() => {}));
-    res.on('end', common.mustCall(() => {
-      // setImmediate() to give the agent time to register the freed socket.
-      setImmediate(common.mustCall(() => {
-        // The socket is free for reuse now.
-        assert.strictEqual(socket[async_id_symbol], -1);
+          res.on('data', common.mustCallAtLeast(() => {}));
+          res.on(
+            'end',
+            common.mustCall(() => {
+              // setImmediate() to give the agent time to register the freed socket.
+              setImmediate(
+                common.mustCall(() => {
+                  // The socket is free for reuse now.
+                  assert.strictEqual(socket[async_id_symbol], -1);
 
-        // second request:
-        const r2 = http.request({
-          agent, port, method: 'POST'
-        }, common.mustCall((res) => {
-          assert.ok(destroyedIds.has(asyncIdAtFirstRequest));
+                  // second request:
+                  const r2 = http.request(
+                    {
+                      agent,
+                      port,
+                      method: 'POST'
+                    },
+                    common.mustCall((res) => {
+                      assert.ok(destroyedIds.has(asyncIdAtFirstRequest));
 
-          // Empty payload, to hit the “right” code path.
-          r2.end('');
+                      // Empty payload, to hit the “right” code path.
+                      r2.end('');
 
-          res.on('data', common.mustCallAtLeast(() => {}));
-          res.on('end', common.mustCall(() => {
-            // Clean up to let the event loop stop.
-            server.close();
-            agent.destroy();
-          }));
-        }));
+                      res.on('data', common.mustCallAtLeast(() => {}));
+                      res.on(
+                        'end',
+                        common.mustCall(() => {
+                          // Clean up to let the event loop stop.
+                          server.close();
+                          agent.destroy();
+                        })
+                      );
+                    })
+                  );
 
-        // Schedule a payload to be written immediately, but do not end the
-        // request just yet.
-        r2.write(payload);
-      }));
-    }));
-  }));
-  r1.end(payload);
-}));
+                  // Schedule a payload to be written immediately, but do not end the
+                  // request just yet.
+                  r2.write(payload);
+                })
+              );
+            })
+          );
+        })
+      );
+      r1.end(payload);
+    })
+  );
diff --git a/test/parallel/test-async-hooks-http-agent.js b/test/parallel/test-async-hooks-http-agent.js
index a55858947337b2..95ec58824dd75a 100644
--- a/test/parallel/test-async-hooks-http-agent.js
+++ b/test/parallel/test-async-hooks-http-agent.js
@@ -16,65 +16,97 @@ const agent = new http.Agent({
   maxSockets: 1
 });
 
-const server = http.createServer(common.mustCall((req, res) => {
-  req.once('data', common.mustCallAtLeast(() => {
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write('foo');
-  }));
-  req.on('end', common.mustCall(() => {
-    res.end('bar');
-  }));
-}, 2)).listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const payload = 'hello world';
+const server = http
+  .createServer(
+    common.mustCall((req, res) => {
+      req.once(
+        'data',
+        common.mustCallAtLeast(() => {
+          res.writeHead(200, { 'Content-Type': 'text/plain' });
+          res.write('foo');
+        })
+      );
+      req.on(
+        'end',
+        common.mustCall(() => {
+          res.end('bar');
+        })
+      );
+    }, 2)
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const payload = 'hello world';
 
-  // First request. This is useless except for adding a socket to the
-  // agent’s pool for reuse.
-  const r1 = http.request({
-    agent, port, method: 'POST'
-  }, common.mustCall((res) => {
-    // Remember which socket we used.
-    const socket = res.socket;
-    const asyncIdAtFirstRequest = socket[async_id_symbol];
-    assert.ok(asyncIdAtFirstRequest > 0, `${asyncIdAtFirstRequest} > 0`);
-    // Check that request and response share their socket.
-    assert.strictEqual(r1.socket, socket);
+      // First request. This is useless except for adding a socket to the
+      // agent’s pool for reuse.
+      const r1 = http.request(
+        {
+          agent,
+          port,
+          method: 'POST'
+        },
+        common.mustCall((res) => {
+          // Remember which socket we used.
+          const socket = res.socket;
+          const asyncIdAtFirstRequest = socket[async_id_symbol];
+          assert.ok(asyncIdAtFirstRequest > 0, `${asyncIdAtFirstRequest} > 0`);
+          // Check that request and response share their socket.
+          assert.strictEqual(r1.socket, socket);
 
-    res.on('data', common.mustCallAtLeast(() => {}));
-    res.on('end', common.mustCall(() => {
-      // setImmediate() to give the agent time to register the freed socket.
-      setImmediate(common.mustCall(() => {
-        // The socket is free for reuse now.
-        assert.strictEqual(socket[async_id_symbol], -1);
+          res.on('data', common.mustCallAtLeast(() => {}));
+          res.on(
+            'end',
+            common.mustCall(() => {
+              // setImmediate() to give the agent time to register the freed socket.
+              setImmediate(
+                common.mustCall(() => {
+                  // The socket is free for reuse now.
+                  assert.strictEqual(socket[async_id_symbol], -1);
 
-        // Second request. To re-create the exact conditions from the
-        // referenced issue, we use a POST request without chunked encoding
-        // (hence the Content-Length header) and call .end() after the
-        // response header has already been received.
-        const r2 = http.request({
-          agent, port, method: 'POST', headers: {
-            'Content-Length': payload.length
-          }
-        }, common.mustCall((res) => {
-          const asyncId = res.socket[async_id_symbol];
-          assert.ok(asyncId > 0, `${asyncId} > 0`);
-          assert.strictEqual(r2.socket, socket);
-          // Empty payload, to hit the “right” code path.
-          r2.end('');
+                  // Second request. To re-create the exact conditions from the
+                  // referenced issue, we use a POST request without chunked encoding
+                  // (hence the Content-Length header) and call .end() after the
+                  // response header has already been received.
+                  const r2 = http.request(
+                    {
+                      agent,
+                      port,
+                      method: 'POST',
+                      headers: {
+                        'Content-Length': payload.length
+                      }
+                    },
+                    common.mustCall((res) => {
+                      const asyncId = res.socket[async_id_symbol];
+                      assert.ok(asyncId > 0, `${asyncId} > 0`);
+                      assert.strictEqual(r2.socket, socket);
+                      // Empty payload, to hit the “right” code path.
+                      r2.end('');
 
-          res.on('data', common.mustCallAtLeast(() => {}));
-          res.on('end', common.mustCall(() => {
-            // Clean up to let the event loop stop.
-            server.close();
-            agent.destroy();
-          }));
-        }));
+                      res.on('data', common.mustCallAtLeast(() => {}));
+                      res.on(
+                        'end',
+                        common.mustCall(() => {
+                          // Clean up to let the event loop stop.
+                          server.close();
+                          agent.destroy();
+                        })
+                      );
+                    })
+                  );
 
-        // Schedule a payload to be written immediately, but do not end the
-        // request just yet.
-        r2.write(payload);
-      }));
-    }));
-  }));
-  r1.end(payload);
-}));
+                  // Schedule a payload to be written immediately, but do not end the
+                  // request just yet.
+                  r2.write(payload);
+                })
+              );
+            })
+          );
+        })
+      );
+      r1.end(payload);
+    })
+  );
diff --git a/test/parallel/test-async-hooks-http-parser-destroy.js b/test/parallel/test-async-hooks-http-parser-destroy.js
index aeb805702d89e9..a8246d13f67d4e 100644
--- a/test/parallel/test-async-hooks-http-parser-destroy.js
+++ b/test/parallel/test-async-hooks-http-parser-destroy.js
@@ -14,16 +14,18 @@ const KEEP_ALIVE = 100;
 
 const createdIds = [];
 const destroyedIds = [];
-async_hooks.createHook({
-  init: common.mustCallAtLeast((asyncId, type) => {
-    if (type === 'HTTPPARSER') {
-      createdIds.push(asyncId);
+async_hooks
+  .createHook({
+    init: common.mustCallAtLeast((asyncId, type) => {
+      if (type === 'HTTPPARSER') {
+        createdIds.push(asyncId);
+      }
+    }, N),
+    destroy: (asyncId) => {
+      destroyedIds.push(asyncId);
     }
-  }, N),
-  destroy: (asyncId) => {
-    destroyedIds.push(asyncId);
-  }
-}).enable();
+  })
+  .enable();
 
 const server = http.createServer(function(req, res) {
   res.end('Hello');
@@ -31,7 +33,7 @@ const server = http.createServer(function(req, res) {
 
 const keepAliveAgent = new http.Agent({
   keepAlive: true,
-  keepAliveMsecs: KEEP_ALIVE,
+  keepAliveMsecs: KEEP_ALIVE
 });
 
 const countdown = new Countdown(N, () => {
@@ -49,13 +51,16 @@ const countdown = new Countdown(N, () => {
 server.listen(0, function() {
   for (let i = 0; i < N; ++i) {
     (function makeRequest() {
-      http.get({
-        port: server.address().port,
-        agent: keepAliveAgent
-      }, function(res) {
-        countdown.dec();
-        res.resume();
-      });
+      http.get(
+        {
+          port: server.address().port,
+          agent: keepAliveAgent
+        },
+        function(res) {
+          countdown.dec();
+          res.resume();
+        }
+      );
     })();
   }
 });
diff --git a/test/parallel/test-async-hooks-prevent-double-destroy.js b/test/parallel/test-async-hooks-prevent-double-destroy.js
index 689dc399f9d2f2..07a1d3bfe8cfa3 100644
--- a/test/parallel/test-async-hooks-prevent-double-destroy.js
+++ b/test/parallel/test-async-hooks-prevent-double-destroy.js
@@ -7,9 +7,11 @@
 const common = require('../common');
 const async_hooks = require('async_hooks');
 
-const hook = async_hooks.createHook({
-  destroy: common.mustCallAtLeast(2) // 1 immediate + manual destroy
-}).enable();
+const hook = async_hooks
+  .createHook({
+    destroy: common.mustCallAtLeast(2) // 1 immediate + manual destroy
+  })
+  .enable();
 
 {
   const res = new async_hooks.AsyncResource('foobar');
diff --git a/test/parallel/test-async-hooks-promise-enable-disable.js b/test/parallel/test-async-hooks-promise-enable-disable.js
index 47a259166ee182..09f44c34b2aa96 100644
--- a/test/parallel/test-async-hooks-promise-enable-disable.js
+++ b/test/parallel/test-async-hooks-promise-enable-disable.js
@@ -10,35 +10,45 @@ let p_inits = 0;
 // Not useful to place common.mustCall() around 'exit' event b/c it won't be
 // able to check it anyway.
 process.on('exit', (code) => {
-  if (code !== 0)
-    return;
-  if (p_er !== null)
-    throw p_er;
+  if (code !== 0) return;
+  if (p_er !== null) throw p_er;
   // Expecting exactly 2 PROMISE types to reach init.
   assert.strictEqual(p_inits, EXPECTED_INITS);
 });
 
 const mustCallInit = common.mustCall(function init(id, type, tid, resource) {
-  if (type !== 'PROMISE')
-    return;
+  if (type !== 'PROMISE') return;
   p_inits++;
 }, EXPECTED_INITS);
 
-const hook = async_hooks.createHook({
-  init: mustCallInit
-// Enable then disable to test whether disable() actually works.
-}).enable().disable().disable();
+const hook = async_hooks
+  .createHook({
+    init: mustCallInit
+    // Enable then disable to test whether disable() actually works.
+  })
+  .enable()
+  .disable()
+  .disable();
 
-new Promise(common.mustCall((res) => {
-  res(42);
-})).then(common.mustCall((val) => {
-  hook.enable().enable();
-  const p = new Promise((res) => res(val));
-  hook.disable();
-  return p;
-})).then(common.mustCall((val2) => {
-  hook.enable();
-  const p = new Promise((res) => res(val2));
-  hook.disable();
-  return p;
-})).catch((er) => p_er = er);
+new Promise(
+  common.mustCall((res) => {
+    res(42);
+  })
+)
+  .then(
+    common.mustCall((val) => {
+      hook.enable().enable();
+      const p = new Promise((res) => res(val));
+      hook.disable();
+      return p;
+    })
+  )
+  .then(
+    common.mustCall((val2) => {
+      hook.enable();
+      const p = new Promise((res) => res(val2));
+      hook.disable();
+      return p;
+    })
+  )
+  .catch((er) => (p_er = er));
diff --git a/test/parallel/test-async-hooks-promise-triggerid.js b/test/parallel/test-async-hooks-promise-triggerid.js
index 467fddd359d835..f3dda43b94b752 100644
--- a/test/parallel/test-async-hooks-promise-triggerid.js
+++ b/test/parallel/test-async-hooks-promise-triggerid.js
@@ -8,26 +8,32 @@ if (!common.isMainThread)
 
 const promiseAsyncIds = [];
 
-async_hooks.createHook({
-  init: common.mustCallAtLeast((id, type, triggerId) => {
-    if (type === 'PROMISE') {
-      // Check that the last known Promise is triggering the creation of
-      // this one.
-      assert.strictEqual(promiseAsyncIds[promiseAsyncIds.length - 1] || 1,
-                         triggerId);
-      promiseAsyncIds.push(id);
-    }
-  }, 3),
-  before: common.mustCall((id) => {
-    assert.strictEqual(id, promiseAsyncIds[1]);
-  }),
-  after: common.mustCall((id) => {
-    assert.strictEqual(id, promiseAsyncIds[1]);
+async_hooks
+  .createHook({
+    init: common.mustCallAtLeast((id, type, triggerId) => {
+      if (type === 'PROMISE') {
+        // Check that the last known Promise is triggering the creation of
+        // this one.
+        assert.strictEqual(
+          promiseAsyncIds[promiseAsyncIds.length - 1] || 1,
+          triggerId
+        );
+        promiseAsyncIds.push(id);
+      }
+    }, 3),
+    before: common.mustCall((id) => {
+      assert.strictEqual(id, promiseAsyncIds[1]);
+    }),
+    after: common.mustCall((id) => {
+      assert.strictEqual(id, promiseAsyncIds[1]);
+    })
   })
-}).enable();
+  .enable();
 
-Promise.resolve(42).then(common.mustCall(() => {
-  assert.strictEqual(async_hooks.executionAsyncId(), promiseAsyncIds[1]);
-  assert.strictEqual(async_hooks.triggerAsyncId(), promiseAsyncIds[0]);
-  Promise.resolve(10);
-}));
+Promise.resolve(42).then(
+  common.mustCall(() => {
+    assert.strictEqual(async_hooks.executionAsyncId(), promiseAsyncIds[1]);
+    assert.strictEqual(async_hooks.triggerAsyncId(), promiseAsyncIds[0]);
+    Promise.resolve(10);
+  })
+);
diff --git a/test/parallel/test-async-hooks-promise.js b/test/parallel/test-async-hooks-promise.js
index 637d287b506ba9..9622236f20c79c 100644
--- a/test/parallel/test-async-hooks-promise.js
+++ b/test/parallel/test-async-hooks-promise.js
@@ -9,16 +9,18 @@ if (!common.isMainThread)
 const initCalls = [];
 const resolveCalls = [];
 
-async_hooks.createHook({
-  init: common.mustCall((id, type, triggerId, resource) => {
-    assert.strictEqual(type, 'PROMISE');
-    initCalls.push({ id, triggerId, resource });
-  }, 2),
-  promiseResolve: common.mustCall((id) => {
-    assert.strictEqual(initCalls[resolveCalls.length].id, id);
-    resolveCalls.push(id);
-  }, 2)
-}).enable();
+async_hooks
+  .createHook({
+    init: common.mustCall((id, type, triggerId, resource) => {
+      assert.strictEqual(type, 'PROMISE');
+      initCalls.push({ id, triggerId, resource });
+    }, 2),
+    promiseResolve: common.mustCall((id) => {
+      assert.strictEqual(initCalls[resolveCalls.length].id, id);
+      resolveCalls.push(id);
+    }, 2)
+  })
+  .enable();
 
 const a = Promise.resolve(42);
 a.then(common.mustCall());
diff --git a/test/parallel/test-async-hooks-recursive-stack-runInAsyncScope.js b/test/parallel/test-async-hooks-recursive-stack-runInAsyncScope.js
index bc4ac86e7f1ca1..c715d0c84aaff3 100644
--- a/test/parallel/test-async-hooks-recursive-stack-runInAsyncScope.js
+++ b/test/parallel/test-async-hooks-recursive-stack-runInAsyncScope.js
@@ -10,8 +10,7 @@ function recurse(n) {
   a.runInAsyncScope(() => {
     assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
     assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
-    if (n >= 0)
-      recurse(n - 1);
+    if (n >= 0) recurse(n - 1);
     assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
     assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
   });
diff --git a/test/parallel/test-async-hooks-recursive-stack.js b/test/parallel/test-async-hooks-recursive-stack.js
index 7ab73dc1bf4538..ca7beb42a563a1 100644
--- a/test/parallel/test-async-hooks-recursive-stack.js
+++ b/test/parallel/test-async-hooks-recursive-stack.js
@@ -10,8 +10,7 @@ function recurse(n) {
   a.emitBefore();
   assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
   assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
-  if (n >= 0)
-    recurse(n - 1);
+  if (n >= 0) recurse(n - 1);
   assert.strictEqual(a.asyncId(), async_hooks.executionAsyncId());
   assert.strictEqual(a.triggerAsyncId(), async_hooks.triggerAsyncId());
   a.emitAfter();
diff --git a/test/parallel/test-async-hooks-top-level-clearimmediate.js b/test/parallel/test-async-hooks-top-level-clearimmediate.js
index cc5fcf48eb50b3..f14adf6869172c 100644
--- a/test/parallel/test-async-hooks-top-level-clearimmediate.js
+++ b/test/parallel/test-async-hooks-top-level-clearimmediate.js
@@ -11,19 +11,21 @@ if (!common.isMainThread)
 
 let seenId, seenResource;
 
-async_hooks.createHook({
-  init: common.mustCall((id, provider, triggerAsyncId, resource) => {
-    seenId = id;
-    seenResource = resource;
-    assert.strictEqual(provider, 'Immediate');
-    assert.strictEqual(triggerAsyncId, 1);
-  }),
-  before: common.mustNotCall(),
-  after: common.mustNotCall(),
-  destroy: common.mustCall((id) => {
-    assert.strictEqual(seenId, id);
+async_hooks
+  .createHook({
+    init: common.mustCall((id, provider, triggerAsyncId, resource) => {
+      seenId = id;
+      seenResource = resource;
+      assert.strictEqual(provider, 'Immediate');
+      assert.strictEqual(triggerAsyncId, 1);
+    }),
+    before: common.mustNotCall(),
+    after: common.mustNotCall(),
+    destroy: common.mustCall((id) => {
+      assert.strictEqual(seenId, id);
+    })
   })
-}).enable();
+  .enable();
 
 const immediate = setImmediate(common.mustNotCall());
 assert.strictEqual(immediate, seenResource);
diff --git a/test/parallel/test-async-wrap-constructor.js b/test/parallel/test-async-wrap-constructor.js
index 6b1764337128b9..1d754562e03899 100644
--- a/test/parallel/test-async-wrap-constructor.js
+++ b/test/parallel/test-async-wrap-constructor.js
@@ -8,11 +8,14 @@ const async_hooks = require('async_hooks');
 for (const badArg of [0, 1, false, true, null, 'hello']) {
   const hookNames = ['init', 'before', 'after', 'destroy', 'promiseResolve'];
   for (const field of hookNames) {
-    common.expectsError(() => {
-      async_hooks.createHook({ [field]: badArg });
-    }, {
-      code: 'ERR_ASYNC_CALLBACK',
-      type: TypeError,
-    });
+    common.expectsError(
+      () => {
+        async_hooks.createHook({ [field]: badArg });
+      },
+      {
+        code: 'ERR_ASYNC_CALLBACK',
+        type: TypeError
+      }
+    );
   }
 }
diff --git a/test/parallel/test-async-wrap-destroyid.js b/test/parallel/test-async-wrap-destroyid.js
index 25a33246e7756c..6593cc127fc6f2 100644
--- a/test/parallel/test-async-wrap-destroyid.js
+++ b/test/parallel/test-async-wrap-destroyid.js
@@ -11,23 +11,26 @@ let test_id = null;
 let run_cntr = 0;
 let hooks = null;
 
-process.on('beforeExit', common.mustCall(() => {
-  process.removeAllListeners('uncaughtException');
-  hooks.disable();
-  assert.strictEqual(test_id, null);
-  assert.strictEqual(run_cntr, RUNS);
-}));
-
+process.on(
+  'beforeExit',
+  common.mustCall(() => {
+    process.removeAllListeners('uncaughtException');
+    hooks.disable();
+    assert.strictEqual(test_id, null);
+    assert.strictEqual(run_cntr, RUNS);
+  })
+);
 
-hooks = async_hooks.createHook({
-  destroy(id) {
-    if (id === test_id) {
-      run_cntr++;
-      test_id = null;
+hooks = async_hooks
+  .createHook({
+    destroy(id) {
+      if (id === test_id) {
+        run_cntr++;
+        test_id = null;
+      }
     }
-  },
-}).enable();
-
+  })
+  .enable();
 
 (function runner(n) {
   assert.strictEqual(test_id, null);
diff --git a/test/parallel/test-async-wrap-missing-method.js b/test/parallel/test-async-wrap-missing-method.js
index 72d6d9fdf3fac4..244ed43a92e3c3 100644
--- a/test/parallel/test-async-wrap-missing-method.js
+++ b/test/parallel/test-async-wrap-missing-method.js
@@ -26,10 +26,13 @@ const { MessageChannel } = require('worker_threads');
 
 {
   const err = new Error('eyecatcher');
-  process.on('uncaughtException', common.mustCall((exception) => {
-    port1.unref();
-    assert.strictEqual(exception, err);
-  }));
+  process.on(
+    'uncaughtException',
+    common.mustCall((exception) => {
+      port1.unref();
+      assert.strictEqual(exception, err);
+    })
+  );
 
   const { port1, port2 } = new MessageChannel();
 
diff --git a/test/parallel/test-async-wrap-pop-id-during-load.js b/test/parallel/test-async-wrap-pop-id-during-load.js
index cff7e85fdffef4..453a3b5946c59c 100644
--- a/test/parallel/test-async-wrap-pop-id-during-load.js
+++ b/test/parallel/test-async-wrap-pop-id-during-load.js
@@ -8,18 +8,24 @@ if (process.argv[2] === 'async') {
     fn();
     throw new Error();
   }
-  return (async function() { await fn(); })();
+  return (async function() {
+    await fn();
+  })();
 }
 
 const assert = require('assert');
 const { spawnSync } = require('child_process');
 
-const ret = spawnSync(
-  process.execPath,
-  ['--stack_size=150', __filename, 'async']
+const ret = spawnSync(process.execPath, [
+  '--stack_size=150',
+  __filename,
+  'async'
+]);
+assert.strictEqual(
+  ret.status,
+  0,
+  `EXIT CODE: ${ret.status}, STDERR:\n${ret.stderr}`
 );
-assert.strictEqual(ret.status, 0,
-                   `EXIT CODE: ${ret.status}, STDERR:\n${ret.stderr}`);
 const stderr = ret.stderr.toString('utf8', 0, 2048);
 assert.ok(!/async.*hook/i.test(stderr));
 assert.ok(stderr.includes('UnhandledPromiseRejectionWarning: Error'), stderr);
diff --git a/test/parallel/test-async-wrap-trigger-id.js b/test/parallel/test-async-wrap-trigger-id.js
index e8b4682b7167f8..60e893b5744529 100644
--- a/test/parallel/test-async-wrap-trigger-id.js
+++ b/test/parallel/test-async-wrap-trigger-id.js
@@ -13,16 +13,12 @@ process.nextTick(() => {
     triggerAsyncId1 = triggerAsyncId();
     // Async resources having different causal ancestry
     // should have different triggerAsyncIds
-    assert.notStrictEqual(
-      triggerAsyncId0,
-      triggerAsyncId1);
+    assert.notStrictEqual(triggerAsyncId0, triggerAsyncId1);
   });
   process.nextTick(() => {
     const triggerAsyncId2 = triggerAsyncId();
     // Async resources having the same causal ancestry
     // should have the same triggerAsyncId
-    assert.strictEqual(
-      triggerAsyncId1,
-      triggerAsyncId2);
+    assert.strictEqual(triggerAsyncId1, triggerAsyncId2);
   });
 });
diff --git a/test/parallel/test-async-wrap-uncaughtexception.js b/test/parallel/test-async-wrap-uncaughtexception.js
index 37557b4aacc341..5e7fe875afe298 100644
--- a/test/parallel/test-async-wrap-uncaughtexception.js
+++ b/test/parallel/test-async-wrap-uncaughtexception.js
@@ -1,46 +1,51 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const async_hooks = require('async_hooks');
-const call_log = [0, 0, 0, 0];  // [before, callback, exception, after];
+const call_log = [0, 0, 0, 0]; // [before, callback, exception, after];
 let call_id = null;
 let hooks = null;
 
-
-process.on('beforeExit', common.mustCall(() => {
-  process.removeAllListeners('uncaughtException');
-  hooks.disable();
-  assert.strictEqual(typeof call_id, 'number');
-  assert.deepStrictEqual(call_log, [1, 1, 1, 1]);
-}));
-
-
-hooks = async_hooks.createHook({
-  init(id, type) {
-    if (type === 'RANDOMBYTESREQUEST')
-      call_id = id;
-  },
-  before(id) {
-    if (id === call_id) call_log[0]++;
-  },
-  after(id) {
-    if (id === call_id) call_log[3]++;
-  },
-}).enable();
-
-
-process.on('uncaughtException', common.mustCall(() => {
-  assert.strictEqual(call_id, async_hooks.executionAsyncId());
-  call_log[2]++;
-}));
-
-
-require('crypto').randomBytes(1, common.mustCall(() => {
-  assert.strictEqual(call_id, async_hooks.executionAsyncId());
-  call_log[1]++;
-  throw new Error();
-}));
+process.on(
+  'beforeExit',
+  common.mustCall(() => {
+    process.removeAllListeners('uncaughtException');
+    hooks.disable();
+    assert.strictEqual(typeof call_id, 'number');
+    assert.deepStrictEqual(call_log, [1, 1, 1, 1]);
+  })
+);
+
+hooks = async_hooks
+  .createHook({
+    init(id, type) {
+      if (type === 'RANDOMBYTESREQUEST') call_id = id;
+    },
+    before(id) {
+      if (id === call_id) call_log[0]++;
+    },
+    after(id) {
+      if (id === call_id) call_log[3]++;
+    }
+  })
+  .enable();
+
+process.on(
+  'uncaughtException',
+  common.mustCall(() => {
+    assert.strictEqual(call_id, async_hooks.executionAsyncId());
+    call_log[2]++;
+  })
+);
+
+require('crypto').randomBytes(
+  1,
+  common.mustCall(() => {
+    assert.strictEqual(call_id, async_hooks.executionAsyncId());
+    call_log[1]++;
+    throw new Error();
+  })
+);
diff --git a/test/parallel/test-atomics-notify.js b/test/parallel/test-atomics-notify.js
index fc59d5aa331084..590b502e8f56e9 100644
--- a/test/parallel/test-atomics-notify.js
+++ b/test/parallel/test-atomics-notify.js
@@ -14,6 +14,8 @@ assert.strictEqual(runInNewContext('typeof Atomics.notify'), 'function');
 expectWarning(
   'Atomics',
   'Atomics.wake will be removed in a future version, ' +
-  'use Atomics.notify instead.', noWarnCode);
+    'use Atomics.notify instead.',
+  noWarnCode
+);
 
 Atomics.wake(new Int32Array(new SharedArrayBuffer(4)), 0, 0);
diff --git a/test/parallel/test-bash-completion.js b/test/parallel/test-bash-completion.js
index 50378a7b0f8028..1346cb9d82c104 100644
--- a/test/parallel/test-bash-completion.js
+++ b/test/parallel/test-bash-completion.js
@@ -3,21 +3,26 @@ require('../common');
 const assert = require('assert');
 const child_process = require('child_process');
 
-const p = child_process.spawnSync(
-  process.execPath, [ '--completion-bash' ]);
+const p = child_process.spawnSync(process.execPath, ['--completion-bash']);
 assert.ifError(p.error);
-assert.ok(p.stdout.toString().includes(
-  `_node_complete() {
+assert.ok(
+  p.stdout.toString().includes(
+    `_node_complete() {
   local cur_word options
   cur_word="\${COMP_WORDS[COMP_CWORD]}"
   if [[ "\${cur_word}" == -* ]] ; then
-    COMPREPLY=( $(compgen -W '`));
-assert.ok(p.stdout.toString().includes(
-  `' -- "\${cur_word}") )
+    COMPREPLY=( $(compgen -W '`
+  )
+);
+assert.ok(
+  p.stdout.toString().includes(
+    `' -- "\${cur_word}") )
     return 0
   else
     COMPREPLY=( $(compgen -f "\${cur_word}") )
     return 0
   fi
 }
-complete -F _node_complete node node_g`));
+complete -F _node_complete node node_g`
+  )
+);
diff --git a/test/parallel/test-binding-constants.js b/test/parallel/test-binding-constants.js
index 9855af19422882..0bdff0ddf14dda 100644
--- a/test/parallel/test-binding-constants.js
+++ b/test/parallel/test-binding-constants.js
@@ -4,14 +4,21 @@ require('../common');
 const constants = process.binding('constants');
 const assert = require('assert');
 
-assert.deepStrictEqual(
-  Object.keys(constants).sort(), ['crypto', 'fs', 'os', 'trace', 'zlib']
-);
+assert.deepStrictEqual(Object.keys(constants).sort(), [
+  'crypto',
+  'fs',
+  'os',
+  'trace',
+  'zlib'
+]);
 
-assert.deepStrictEqual(
-  Object.keys(constants.os).sort(), ['UV_UDP_REUSEADDR', 'dlopen', 'errno',
-                                     'priority', 'signals']
-);
+assert.deepStrictEqual(Object.keys(constants.os).sort(), [
+  'UV_UDP_REUSEADDR',
+  'dlopen',
+  'errno',
+  'priority',
+  'signals'
+]);
 
 // Make sure all the constants objects don't inherit from Object.prototype
 const inheritedProperties = Object.getOwnPropertyNames(Object.prototype);
@@ -26,6 +33,13 @@ function test(obj) {
 }
 
 [
-  constants, constants.crypto, constants.fs, constants.os, constants.trace,
-  constants.zlib, constants.os.dlopen, constants.os.errno, constants.os.signals
+  constants,
+  constants.crypto,
+  constants.fs,
+  constants.os,
+  constants.trace,
+  constants.zlib,
+  constants.os.dlopen,
+  constants.os.errno,
+  constants.os.signals
 ].forEach(test);
diff --git a/test/parallel/test-buffer-alloc.js b/test/parallel/test-buffer-alloc.js
index 313a13cb1e41ad..3f83b1c65956c6 100644
--- a/test/parallel/test-buffer-alloc.js
+++ b/test/parallel/test-buffer-alloc.js
@@ -5,7 +5,6 @@ const vm = require('vm');
 
 const SlowBuffer = require('buffer').SlowBuffer;
 
-
 const b = Buffer.allocUnsafe(1024);
 assert.strictEqual(b.length, 1024);
 
@@ -52,15 +51,14 @@ assert.strictEqual(d.length, 0);
 }
 
 // Test invalid encoding for Buffer.toString
-assert.throws(() => b.toString('invalid'),
-              /Unknown encoding: invalid/);
+assert.throws(() => b.toString('invalid'), /Unknown encoding: invalid/);
 // invalid encoding for Buffer.write
-assert.throws(() => b.write('test string', 0, 5, 'invalid'),
-              /Unknown encoding: invalid/);
+assert.throws(
+  () => b.write('test string', 0, 5, 'invalid'),
+  /Unknown encoding: invalid/
+);
 // unsupported arguments for Buffer.write
-assert.throws(() => b.write('test', 'utf8', 0),
-              /is no longer supported/);
-
+assert.throws(() => b.write('test', 'utf8', 0), /is no longer supported/);
 
 // Try to create 0-length buffers. Should not throw.
 Buffer.from('');
@@ -161,10 +159,15 @@ Buffer.alloc(1).write('', 1, 0);
   let utf8Slice = b.toString('utf8', 0, Buffer.byteLength(utf8String));
   assert.strictEqual(utf8String, utf8Slice);
 
-  assert.strictEqual(Buffer.byteLength(utf8String),
-                     b.write(utf8String, offset, 'utf8'));
-  utf8Slice = b.toString('utf8', offset,
-                         offset + Buffer.byteLength(utf8String));
+  assert.strictEqual(
+    Buffer.byteLength(utf8String),
+    b.write(utf8String, offset, 'utf8')
+  );
+  utf8Slice = b.toString(
+    'utf8',
+    offset,
+    offset + Buffer.byteLength(utf8String)
+  );
   assert.strictEqual(utf8String, utf8Slice);
 
   const sliceA = b.slice(offset, offset + Buffer.byteLength(utf8String));
@@ -254,7 +257,8 @@ Buffer.alloc(1).write('', 1, 0);
     // Length should be 12
     const f = Buffer.from('привет', encoding);
     assert.deepStrictEqual(
-      f, Buffer.from([63, 4, 64, 4, 56, 4, 50, 4, 53, 4, 66, 4])
+      f,
+      Buffer.from([63, 4, 64, 4, 56, 4, 50, 4, 53, 4, 66, 4])
     );
     assert.strictEqual(f.toString(encoding), 'привет');
   }
@@ -287,32 +291,38 @@ Buffer.alloc(1).write('', 1, 0);
 //
 // Test toString('base64')
 //
-assert.strictEqual((Buffer.from('Man')).toString('base64'), 'TWFu');
+assert.strictEqual(Buffer.from('Man').toString('base64'), 'TWFu');
 
 {
   // test that regular and URL-safe base64 both work
   const expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff];
-  assert.deepStrictEqual(Buffer.from('//++/++/++//', 'base64'),
-                         Buffer.from(expected));
-  assert.deepStrictEqual(Buffer.from('__--_--_--__', 'base64'),
-                         Buffer.from(expected));
+  assert.deepStrictEqual(
+    Buffer.from('//++/++/++//', 'base64'),
+    Buffer.from(expected)
+  );
+  assert.deepStrictEqual(
+    Buffer.from('__--_--_--__', 'base64'),
+    Buffer.from(expected)
+  );
 }
 
 {
   // big example
-  const quote = 'Man is distinguished, not only by his reason, but by this ' +
-                'singular passion from other animals, which is a lust ' +
-                'of the mind, that by a perseverance of delight in the ' +
-                'continued and indefatigable generation of knowledge, ' +
-                'exceeds the short vehemence of any carnal pleasure.';
-  const expected = 'TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb' +
-                   '24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlci' +
-                   'BhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQ' +
-                   'gYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu' +
-                   'dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZ' +
-                   'GdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm' +
-                   '5hbCBwbGVhc3VyZS4=';
-  assert.strictEqual(expected, (Buffer.from(quote)).toString('base64'));
+  const quote =
+    'Man is distinguished, not only by his reason, but by this ' +
+    'singular passion from other animals, which is a lust ' +
+    'of the mind, that by a perseverance of delight in the ' +
+    'continued and indefatigable generation of knowledge, ' +
+    'exceeds the short vehemence of any carnal pleasure.';
+  const expected =
+    'TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb' +
+    '24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlci' +
+    'BhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQ' +
+    'gYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu' +
+    'dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZ' +
+    'GdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm' +
+    '5hbCBwbGVhc3VyZS4=';
+  assert.strictEqual(expected, Buffer.from(quote).toString('base64'));
 
   let b = Buffer.allocUnsafe(1024);
   let bytesWritten = b.write(expected, 0, 'base64');
@@ -320,12 +330,13 @@ assert.strictEqual((Buffer.from('Man')).toString('base64'), 'TWFu');
   assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
 
   // check that the base64 decoder ignores whitespace
-  const expectedWhite = `${expected.slice(0, 60)} \n` +
-                        `${expected.slice(60, 120)} \n` +
-                        `${expected.slice(120, 180)} \n` +
-                        `${expected.slice(180, 240)} \n` +
-                        `${expected.slice(240, 300)}\n` +
-                        `${expected.slice(300, 360)}\n`;
+  const expectedWhite =
+    `${expected.slice(0, 60)} \n` +
+    `${expected.slice(60, 120)} \n` +
+    `${expected.slice(120, 180)} \n` +
+    `${expected.slice(180, 240)} \n` +
+    `${expected.slice(240, 300)}\n` +
+    `${expected.slice(300, 360)}\n`;
   b = Buffer.allocUnsafe(1024);
   bytesWritten = b.write(expectedWhite, 0, 'base64');
   assert.strictEqual(quote.length, bytesWritten);
@@ -338,12 +349,18 @@ assert.strictEqual((Buffer.from('Man')).toString('base64'), 'TWFu');
   assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
 
   // check that the base64 decoder ignores illegal chars
-  const expectedIllegal = expected.slice(0, 60) + ' \x80' +
-                          expected.slice(60, 120) + ' \xff' +
-                          expected.slice(120, 180) + ' \x00' +
-                          expected.slice(180, 240) + ' \x98' +
-                          expected.slice(240, 300) + '\x03' +
-                          expected.slice(300, 360);
+  const expectedIllegal =
+    expected.slice(0, 60) +
+    ' \x80' +
+    expected.slice(60, 120) +
+    ' \xff' +
+    expected.slice(120, 180) +
+    ' \x00' +
+    expected.slice(180, 240) +
+    ' \x98' +
+    expected.slice(240, 300) +
+    '\x03' +
+    expected.slice(300, 360);
   b = Buffer.from(expectedIllegal, 'base64');
   assert.strictEqual(quote.length, b.length);
   assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
@@ -359,64 +376,108 @@ assert.strictEqual(Buffer.from('Kioq', 'base64').toString(), '*'.repeat(3));
 assert.strictEqual(Buffer.from('KioqKg==', 'base64').toString(), '*'.repeat(4));
 assert.strictEqual(Buffer.from('KioqKio=', 'base64').toString(), '*'.repeat(5));
 assert.strictEqual(Buffer.from('KioqKioq', 'base64').toString(), '*'.repeat(6));
-assert.strictEqual(Buffer.from('KioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(7));
-assert.strictEqual(Buffer.from('KioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(8));
-assert.strictEqual(Buffer.from('KioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(9));
-assert.strictEqual(Buffer.from('KioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(10));
-assert.strictEqual(Buffer.from('KioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(11));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(12));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(13));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(14));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(15));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(16));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(17));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(18));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKg==',
-                               'base64').toString(),
-                   '*'.repeat(19));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKio=',
-                               'base64').toString(),
-                   '*'.repeat(20));
+assert.strictEqual(
+  Buffer.from('KioqKioqKg==', 'base64').toString(),
+  '*'.repeat(7)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKio=', 'base64').toString(),
+  '*'.repeat(8)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioq', 'base64').toString(),
+  '*'.repeat(9)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKg==', 'base64').toString(),
+  '*'.repeat(10)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKio=', 'base64').toString(),
+  '*'.repeat(11)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioq', 'base64').toString(),
+  '*'.repeat(12)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKg==', 'base64').toString(),
+  '*'.repeat(13)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKio=', 'base64').toString(),
+  '*'.repeat(14)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioq', 'base64').toString(),
+  '*'.repeat(15)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKg==', 'base64').toString(),
+  '*'.repeat(16)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKio=', 'base64').toString(),
+  '*'.repeat(17)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKioq', 'base64').toString(),
+  '*'.repeat(18)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKioqKg==', 'base64').toString(),
+  '*'.repeat(19)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKioqKio=', 'base64').toString(),
+  '*'.repeat(20)
+);
 
 // no padding, not a multiple of 4
 assert.strictEqual(Buffer.from('Kg', 'base64').toString(), '*');
 assert.strictEqual(Buffer.from('Kio', 'base64').toString(), '*'.repeat(2));
 assert.strictEqual(Buffer.from('KioqKg', 'base64').toString(), '*'.repeat(4));
 assert.strictEqual(Buffer.from('KioqKio', 'base64').toString(), '*'.repeat(5));
-assert.strictEqual(Buffer.from('KioqKioqKg', 'base64').toString(),
-                   '*'.repeat(7));
-assert.strictEqual(Buffer.from('KioqKioqKio', 'base64').toString(),
-                   '*'.repeat(8));
-assert.strictEqual(Buffer.from('KioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(10));
-assert.strictEqual(Buffer.from('KioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(11));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(13));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(14));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(16));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(17));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKg',
-                               'base64').toString(),
-                   '*'.repeat(19));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKio',
-                               'base64').toString(),
-                   '*'.repeat(20));
+assert.strictEqual(
+  Buffer.from('KioqKioqKg', 'base64').toString(),
+  '*'.repeat(7)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKio', 'base64').toString(),
+  '*'.repeat(8)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKg', 'base64').toString(),
+  '*'.repeat(10)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKio', 'base64').toString(),
+  '*'.repeat(11)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKg', 'base64').toString(),
+  '*'.repeat(13)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKio', 'base64').toString(),
+  '*'.repeat(14)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKg', 'base64').toString(),
+  '*'.repeat(16)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKio', 'base64').toString(),
+  '*'.repeat(17)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKioqKg', 'base64').toString(),
+  '*'.repeat(19)
+);
+assert.strictEqual(
+  Buffer.from('KioqKioqKioqKioqKioqKioqKio', 'base64').toString(),
+  '*'.repeat(20)
+);
 
 // handle padding graciously, multiple-of-4 or not
 assert.strictEqual(
@@ -445,7 +506,7 @@ assert.strictEqual(
 );
 
 {
-// This string encodes single '.' character in UTF-16
+  // This string encodes single '.' character in UTF-16
   const dot = Buffer.from('//4uAA==', 'base64');
   assert.strictEqual(dot[0], 0xff);
   assert.strictEqual(dot[1], 0xfe);
@@ -465,20 +526,26 @@ assert.strictEqual(
   for (let i = 0; i < segments.length; ++i) {
     pos += b.write(segments[i], pos, 'base64');
   }
-  assert.strictEqual(b.toString('latin1', 0, pos),
-                     'Madness?! This is node.js!');
+  assert.strictEqual(
+    b.toString('latin1', 0, pos),
+    'Madness?! This is node.js!'
+  );
 }
 
 // Regression test for https://github.com/nodejs/node/issues/3496.
 assert.strictEqual(Buffer.from('=bad'.repeat(1e4), 'base64').length, 0);
 
 // Regression test for https://github.com/nodejs/node/issues/11987.
-assert.deepStrictEqual(Buffer.from('w0  ', 'base64'),
-                       Buffer.from('w0', 'base64'));
+assert.deepStrictEqual(
+  Buffer.from('w0  ', 'base64'),
+  Buffer.from('w0', 'base64')
+);
 
 // Regression test for https://github.com/nodejs/node/issues/13657.
-assert.deepStrictEqual(Buffer.from(' YWJvcnVtLg', 'base64'),
-                       Buffer.from('YWJvcnVtLg', 'base64'));
+assert.deepStrictEqual(
+  Buffer.from(' YWJvcnVtLg', 'base64'),
+  Buffer.from('YWJvcnVtLg', 'base64')
+);
 
 {
   // Creating buffers larger than pool size.
@@ -502,23 +569,25 @@ assert.deepStrictEqual(Buffer.from(' YWJvcnVtLg', 'base64'),
     hexb[i] = i;
   }
   const hexStr = hexb.toString('hex');
-  assert.strictEqual(hexStr,
-                     '000102030405060708090a0b0c0d0e0f' +
-                     '101112131415161718191a1b1c1d1e1f' +
-                     '202122232425262728292a2b2c2d2e2f' +
-                     '303132333435363738393a3b3c3d3e3f' +
-                     '404142434445464748494a4b4c4d4e4f' +
-                     '505152535455565758595a5b5c5d5e5f' +
-                     '606162636465666768696a6b6c6d6e6f' +
-                     '707172737475767778797a7b7c7d7e7f' +
-                     '808182838485868788898a8b8c8d8e8f' +
-                     '909192939495969798999a9b9c9d9e9f' +
-                     'a0a1a2a3a4a5a6a7a8a9aaabacadaeaf' +
-                     'b0b1b2b3b4b5b6b7b8b9babbbcbdbebf' +
-                     'c0c1c2c3c4c5c6c7c8c9cacbcccdcecf' +
-                     'd0d1d2d3d4d5d6d7d8d9dadbdcdddedf' +
-                     'e0e1e2e3e4e5e6e7e8e9eaebecedeeef' +
-                     'f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff');
+  assert.strictEqual(
+    hexStr,
+    '000102030405060708090a0b0c0d0e0f' +
+      '101112131415161718191a1b1c1d1e1f' +
+      '202122232425262728292a2b2c2d2e2f' +
+      '303132333435363738393a3b3c3d3e3f' +
+      '404142434445464748494a4b4c4d4e4f' +
+      '505152535455565758595a5b5c5d5e5f' +
+      '606162636465666768696a6b6c6d6e6f' +
+      '707172737475767778797a7b7c7d7e7f' +
+      '808182838485868788898a8b8c8d8e8f' +
+      '909192939495969798999a9b9c9d9e9f' +
+      'a0a1a2a3a4a5a6a7a8a9aaabacadaeaf' +
+      'b0b1b2b3b4b5b6b7b8b9babbbcbdbebf' +
+      'c0c1c2c3c4c5c6c7c8c9cacbcccdcecf' +
+      'd0d1d2d3d4d5d6d7d8d9dadbdcdddedf' +
+      'e0e1e2e3e4e5e6e7e8e9eaebecedeeef' +
+      'f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff'
+  );
 
   const hexb2 = Buffer.from(hexStr, 'hex');
   for (let i = 0; i < 256; i++) {
@@ -535,7 +604,6 @@ assert.deepStrictEqual(Buffer.from('Abx', 'hex'), Buffer.from('Ab', 'hex'));
 // Test single base64 char encodes as 0.
 assert.strictEqual(Buffer.from('A', 'base64').length, 0);
 
-
 {
   // test an invalid slice end.
   const b = Buffer.from([1, 2, 3, 4, 5]);
@@ -549,7 +617,7 @@ assert.strictEqual(Buffer.from('A', 'base64').length, 0);
 function buildBuffer(data) {
   if (Array.isArray(data)) {
     const buffer = Buffer.allocUnsafe(data.length);
-    data.forEach((v, k) => buffer[k] = v);
+    data.forEach((v, k) => (buffer[k] = v));
     return buffer;
   }
   return null;
@@ -674,41 +742,41 @@ assert.strictEqual(x.inspect(), '<Buffer 81 a3 66 6f 6f a3 62 61 72>');
   // https://github.com/nodejs/node-v0.x-archive/issues/243
   // Test write() with maxLength
   const buf = Buffer.allocUnsafe(4);
-  buf.fill(0xFF);
+  buf.fill(0xff);
   assert.strictEqual(buf.write('abcd', 1, 2, 'utf8'), 2);
-  assert.strictEqual(buf[0], 0xFF);
+  assert.strictEqual(buf[0], 0xff);
   assert.strictEqual(buf[1], 0x61);
   assert.strictEqual(buf[2], 0x62);
-  assert.strictEqual(buf[3], 0xFF);
+  assert.strictEqual(buf[3], 0xff);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   assert.strictEqual(buf.write('abcd', 1, 4), 3);
-  assert.strictEqual(buf[0], 0xFF);
+  assert.strictEqual(buf[0], 0xff);
   assert.strictEqual(buf[1], 0x61);
   assert.strictEqual(buf[2], 0x62);
   assert.strictEqual(buf[3], 0x63);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   assert.strictEqual(buf.write('abcd', 1, 2, 'utf8'), 2);
-  assert.strictEqual(buf[0], 0xFF);
+  assert.strictEqual(buf[0], 0xff);
   assert.strictEqual(buf[1], 0x61);
   assert.strictEqual(buf[2], 0x62);
-  assert.strictEqual(buf[3], 0xFF);
+  assert.strictEqual(buf[3], 0xff);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   assert.strictEqual(buf.write('abcdef', 1, 2, 'hex'), 2);
-  assert.strictEqual(buf[0], 0xFF);
-  assert.strictEqual(buf[1], 0xAB);
-  assert.strictEqual(buf[2], 0xCD);
-  assert.strictEqual(buf[3], 0xFF);
+  assert.strictEqual(buf[0], 0xff);
+  assert.strictEqual(buf[1], 0xab);
+  assert.strictEqual(buf[2], 0xcd);
+  assert.strictEqual(buf[3], 0xff);
 
   ['ucs2', 'ucs-2', 'utf16le', 'utf-16le'].forEach((encoding) => {
-    buf.fill(0xFF);
+    buf.fill(0xff);
     assert.strictEqual(buf.write('abcd', 0, 2, encoding), 2);
     assert.strictEqual(buf[0], 0x61);
     assert.strictEqual(buf[1], 0x00);
-    assert.strictEqual(buf[2], 0xFF);
-    assert.strictEqual(buf[3], 0xFF);
+    assert.strictEqual(buf[2], 0xff);
+    assert.strictEqual(buf[3], 0xff);
   });
 }
 
@@ -739,7 +807,7 @@ assert.strictEqual(x.inspect(), '<Buffer 81 a3 66 6f 6f a3 62 61 72>');
 {
   // test for buffer overrun
   const buf = Buffer.from([0, 0, 0, 0, 0]); // length: 5
-  const sub = buf.slice(0, 4);         // length: 4
+  const sub = buf.slice(0, 4); // length: 4
   assert.strictEqual(sub.write('12345', 'latin1'), 4);
   assert.strictEqual(buf[4], 0);
   assert.strictEqual(sub.write('12345', 'binary'), 4);
@@ -756,14 +824,17 @@ assert.strictEqual(x.inspect(), '<Buffer 81 a3 66 6f 6f a3 62 61 72>');
   assert.strictEqual(buf[4], 128);
 }
 
-
 // Check for fractional length args, junk length args, etc.
 // https://github.com/joyent/node/issues/1758
 
 // Call .fill() first, stops valgrind warning about uninitialized memory reads.
-Buffer.allocUnsafe(3.3).fill().toString();
+Buffer.allocUnsafe(3.3)
+  .fill()
+  .toString();
 // throws bad argument error in commit 43cb4ec
-Buffer.alloc(3.3).fill().toString();
+Buffer.alloc(3.3)
+  .fill()
+  .toString();
 assert.strictEqual(Buffer.allocUnsafe(NaN).length, 0);
 assert.strictEqual(Buffer.allocUnsafe(3.3).length, 3);
 assert.strictEqual(Buffer.from({ length: 3.3 }).length, 3);
@@ -790,10 +861,7 @@ assert.strictEqual(Buffer.from('13.37').length, 5);
 Buffer.from(Buffer.allocUnsafe(0), 0, 0);
 
 // issue GH-5587
-common.expectsError(
-  () => Buffer.alloc(8).writeFloatLE(0, 5),
-  outOfRangeError
-);
+common.expectsError(() => Buffer.alloc(8).writeFloatLE(0, 5), outOfRangeError);
 common.expectsError(
   () => Buffer.alloc(16).writeDoubleLE(0, 9),
   outOfRangeError
@@ -826,47 +894,47 @@ common.expectsError(
   assert.deepStrictEqual(buf.toJSON().data, [0x56, 0x34, 0x12]);
   assert.strictEqual(buf.readUIntLE(0, 3), 0x123456);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeUIntBE(0x123456, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56]);
   assert.strictEqual(buf.readUIntBE(0, 3), 0x123456);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntLE(0x123456, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0x56, 0x34, 0x12]);
   assert.strictEqual(buf.readIntLE(0, 3), 0x123456);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntBE(0x123456, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56]);
   assert.strictEqual(buf.readIntBE(0, 3), 0x123456);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntLE(-0x123456, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0xaa, 0xcb, 0xed]);
   assert.strictEqual(buf.readIntLE(0, 3), -0x123456);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntBE(-0x123456, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcb, 0xaa]);
   assert.strictEqual(buf.readIntBE(0, 3), -0x123456);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntLE(-0x123400, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0x00, 0xcc, 0xed]);
   assert.strictEqual(buf.readIntLE(0, 3), -0x123400);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntBE(-0x123400, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcc, 0x00]);
   assert.strictEqual(buf.readIntBE(0, 3), -0x123400);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntLE(-0x120000, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0x00, 0x00, 0xee]);
   assert.strictEqual(buf.readIntLE(0, 3), -0x120000);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntBE(-0x120000, 0, 3);
   assert.deepStrictEqual(buf.toJSON().data, [0xee, 0x00, 0x00]);
   assert.strictEqual(buf.readIntBE(0, 3), -0x120000);
@@ -876,37 +944,37 @@ common.expectsError(
   assert.deepStrictEqual(buf.toJSON().data, [0x90, 0x78, 0x56, 0x34, 0x12]);
   assert.strictEqual(buf.readUIntLE(0, 5), 0x1234567890);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeUIntBE(0x1234567890, 0, 5);
   assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56, 0x78, 0x90]);
   assert.strictEqual(buf.readUIntBE(0, 5), 0x1234567890);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntLE(0x1234567890, 0, 5);
   assert.deepStrictEqual(buf.toJSON().data, [0x90, 0x78, 0x56, 0x34, 0x12]);
   assert.strictEqual(buf.readIntLE(0, 5), 0x1234567890);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntBE(0x1234567890, 0, 5);
   assert.deepStrictEqual(buf.toJSON().data, [0x12, 0x34, 0x56, 0x78, 0x90]);
   assert.strictEqual(buf.readIntBE(0, 5), 0x1234567890);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntLE(-0x1234567890, 0, 5);
   assert.deepStrictEqual(buf.toJSON().data, [0x70, 0x87, 0xa9, 0xcb, 0xed]);
   assert.strictEqual(buf.readIntLE(0, 5), -0x1234567890);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntBE(-0x1234567890, 0, 5);
   assert.deepStrictEqual(buf.toJSON().data, [0xed, 0xcb, 0xa9, 0x87, 0x70]);
   assert.strictEqual(buf.readIntBE(0, 5), -0x1234567890);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntLE(-0x0012000000, 0, 5);
   assert.deepStrictEqual(buf.toJSON().data, [0x00, 0x00, 0x00, 0xee, 0xff]);
   assert.strictEqual(buf.readIntLE(0, 5), -0x0012000000);
 
-  buf.fill(0xFF);
+  buf.fill(0xff);
   buf.writeIntBE(-0x0012000000, 0, 5);
   assert.deepStrictEqual(buf.toJSON().data, [0xff, 0xee, 0x00, 0x00, 0x00]);
   assert.strictEqual(buf.readIntBE(0, 5), -0x0012000000);
@@ -914,14 +982,11 @@ common.expectsError(
 
 // Regression test for https://github.com/nodejs/node-v0.x-archive/issues/5482:
 // should throw but not assert in C++ land.
-common.expectsError(
-  () => Buffer.from('', 'buffer'),
-  {
-    code: 'ERR_UNKNOWN_ENCODING',
-    type: TypeError,
-    message: 'Unknown encoding: buffer'
-  }
-);
+common.expectsError(() => Buffer.from('', 'buffer'), {
+  code: 'ERR_UNKNOWN_ENCODING',
+  type: TypeError,
+  message: 'Unknown encoding: buffer'
+});
 
 // Regression test for https://github.com/nodejs/node-v0.x-archive/issues/6111.
 // Constructing a buffer from another buffer should a) work, and b) not corrupt
@@ -939,7 +1004,8 @@ common.expectsError(
   }
 }
 
-if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
+if (common.hasCrypto) {
+  // eslint-disable-line node-core/crypto-check
   // Test truncation after decode
   const crypto = require('crypto');
 
@@ -947,8 +1013,14 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
   const b2 = Buffer.from('YW55', 'base64');
 
   assert.strictEqual(
-    crypto.createHash('sha1').update(b1).digest('hex'),
-    crypto.createHash('sha1').update(b2).digest('hex')
+    crypto
+      .createHash('sha1')
+      .update(b1)
+      .digest('hex'),
+    crypto
+      .createHash('sha1')
+      .update(b2)
+      .digest('hex')
   );
 } else {
   common.printSkipMessage('missing crypto');
@@ -959,23 +1031,23 @@ Buffer.poolSize = 0;
 assert(Buffer.allocUnsafe(1).parent instanceof ArrayBuffer);
 Buffer.poolSize = ps;
 
-common.expectsError(
-  () => Buffer.allocUnsafe(10).copy(),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'argument must be a buffer'
-  });
+common.expectsError(() => Buffer.allocUnsafe(10).copy(), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'argument must be a buffer'
+});
 
 assert.throws(() => Buffer.from(), {
   name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-  message: 'The first argument must be one of type string, Buffer, ' +
-  'ArrayBuffer, Array, or Array-like Object. Received type undefined'
+  message:
+    'The first argument must be one of type string, Buffer, ' +
+    'ArrayBuffer, Array, or Array-like Object. Received type undefined'
 });
 assert.throws(() => Buffer.from(null), {
   name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-  message: 'The first argument must be one of type string, Buffer, ' +
-  'ArrayBuffer, Array, or Array-like Object. Received type object'
+  message:
+    'The first argument must be one of type string, Buffer, ' +
+    'ArrayBuffer, Array, or Array-like Object. Received type object'
 });
 
 // Test prototype getters don't throw
@@ -984,21 +1056,20 @@ assert.strictEqual(Buffer.prototype.offset, undefined);
 assert.strictEqual(SlowBuffer.prototype.parent, undefined);
 assert.strictEqual(SlowBuffer.prototype.offset, undefined);
 
-
 {
   // Test that large negative Buffer length inputs don't affect the pool offset.
   // Use the fromArrayLike() variant here because it's more lenient
   // about its input and passes the length directly to allocate().
-  assert.deepStrictEqual(Buffer.from({ length: -Buffer.poolSize }),
-                         Buffer.from(''));
-  assert.deepStrictEqual(Buffer.from({ length: -100 }),
-                         Buffer.from(''));
+  assert.deepStrictEqual(
+    Buffer.from({ length: -Buffer.poolSize }),
+    Buffer.from('')
+  );
+  assert.deepStrictEqual(Buffer.from({ length: -100 }), Buffer.from(''));
 
   // Check pool offset after that by trying to write string into the pool.
   Buffer.from('abc');
 }
 
-
 // Test that ParseArrayIndex handles full uint32
 {
   const errMsg = common.expectsError({
@@ -1032,10 +1103,14 @@ const arrayBuf = vm.runInNewContext('new ArrayBuffer()');
 Buffer.from(arrayBuf);
 Buffer.from({ buffer: arrayBuf });
 
-assert.throws(() => Buffer.alloc({ valueOf: () => 1 }),
-              /"size" argument must be of type number/);
-assert.throws(() => Buffer.alloc({ valueOf: () => -1 }),
-              /"size" argument must be of type number/);
+assert.throws(
+  () => Buffer.alloc({ valueOf: () => 1 }),
+  /"size" argument must be of type number/
+);
+assert.throws(
+  () => Buffer.alloc({ valueOf: () => -1 }),
+  /"size" argument must be of type number/
+);
 
 assert.strictEqual(Buffer.prototype.toLocaleString, Buffer.prototype.toString);
 {
@@ -1043,30 +1118,42 @@ assert.strictEqual(Buffer.prototype.toLocaleString, Buffer.prototype.toString);
   assert.strictEqual(buf.toLocaleString(), buf.toString());
 }
 
-common.expectsError(() => {
-  Buffer.alloc(0x1000, 'This is not correctly encoded', 'hex');
-}, {
-  code: 'ERR_INVALID_ARG_VALUE',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    Buffer.alloc(0x1000, 'This is not correctly encoded', 'hex');
+  },
+  {
+    code: 'ERR_INVALID_ARG_VALUE',
+    type: TypeError
+  }
+);
 
-common.expectsError(() => {
-  Buffer.alloc(0x1000, 'c', 'hex');
-}, {
-  code: 'ERR_INVALID_ARG_VALUE',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    Buffer.alloc(0x1000, 'c', 'hex');
+  },
+  {
+    code: 'ERR_INVALID_ARG_VALUE',
+    type: TypeError
+  }
+);
 
-common.expectsError(() => {
-  Buffer.alloc(1, Buffer.alloc(0));
-}, {
-  code: 'ERR_INVALID_ARG_VALUE',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    Buffer.alloc(1, Buffer.alloc(0));
+  },
+  {
+    code: 'ERR_INVALID_ARG_VALUE',
+    type: TypeError
+  }
+);
 
-common.expectsError(() => {
-  Buffer.alloc(40, 'x', 20);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    Buffer.alloc(40, 'x', 20);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }
+);
diff --git a/test/parallel/test-buffer-arraybuffer.js b/test/parallel/test-buffer-arraybuffer.js
index 2a1ce141079279..a5308f546d8d55 100644
--- a/test/parallel/test-buffer-arraybuffer.js
+++ b/test/parallel/test-buffer-arraybuffer.js
@@ -10,42 +10,43 @@ const dv = new DataView(ab);
 const ui = new Uint8Array(ab);
 const buf = Buffer.from(ab);
 
-
 assert.ok(buf instanceof Buffer);
 assert.strictEqual(buf.parent, buf.buffer);
 assert.strictEqual(buf.buffer, ab);
 assert.strictEqual(buf.length, ab.byteLength);
 
-
-buf.fill(0xC);
+buf.fill(0xc);
 for (let i = 0; i < LENGTH; i++) {
-  assert.strictEqual(ui[i], 0xC);
-  ui[i] = 0xF;
-  assert.strictEqual(buf[i], 0xF);
+  assert.strictEqual(ui[i], 0xc);
+  ui[i] = 0xf;
+  assert.strictEqual(buf[i], 0xf);
 }
 
-buf.writeUInt32LE(0xF00, 0);
-buf.writeUInt32BE(0xB47, 4);
+buf.writeUInt32LE(0xf00, 0);
+buf.writeUInt32BE(0xb47, 4);
 buf.writeDoubleLE(3.1415, 8);
 
-assert.strictEqual(dv.getUint32(0, true), 0xF00);
-assert.strictEqual(dv.getUint32(4), 0xB47);
+assert.strictEqual(dv.getUint32(0, true), 0xf00);
+assert.strictEqual(dv.getUint32(4), 0xb47);
 assert.strictEqual(dv.getFloat64(8, true), 3.1415);
 
-
 // Now test protecting users from doing stupid things
 
-assert.throws(function() {
-  function AB() { }
-  Object.setPrototypeOf(AB, ArrayBuffer);
-  Object.setPrototypeOf(AB.prototype, ArrayBuffer.prototype);
-  Buffer.from(new AB());
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-  message: 'The first argument must be one of type string, Buffer,' +
-  ' ArrayBuffer, Array, or Array-like Object. Received type object'
-});
+assert.throws(
+  function() {
+    function AB() {}
+    Object.setPrototypeOf(AB, ArrayBuffer);
+    Object.setPrototypeOf(AB.prototype, ArrayBuffer.prototype);
+    Buffer.from(new AB());
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message:
+      'The first argument must be one of type string, Buffer,' +
+      ' ArrayBuffer, Array, or Array-like Object. Received type object'
+  }
+);
 
 // Test the byteOffset and length arguments
 {
@@ -116,13 +117,16 @@ assert.throws(function() {
   assert.deepStrictEqual(Buffer.from(ab, [1]), Buffer.from(ab, 1));
 
   // If byteOffset is Infinity, throw.
-  assert.throws(() => {
-    Buffer.from(ab, Infinity);
-  }, {
-    code: 'ERR_BUFFER_OUT_OF_BOUNDS',
-    name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
-    message: '"offset" is outside of buffer bounds'
-  });
+  assert.throws(
+    () => {
+      Buffer.from(ab, Infinity);
+    },
+    {
+      code: 'ERR_BUFFER_OUT_OF_BOUNDS',
+      name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
+      message: '"offset" is outside of buffer bounds'
+    }
+  );
 }
 
 {
@@ -138,13 +142,16 @@ assert.throws(function() {
   assert.deepStrictEqual(Buffer.from(ab, 0, [1]), Buffer.from(ab, 0, 1));
 
   // If length is Infinity, throw.
-  assert.throws(() => {
-    Buffer.from(ab, 0, Infinity);
-  }, {
-    code: 'ERR_BUFFER_OUT_OF_BOUNDS',
-    name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
-    message: '"length" is outside of buffer bounds'
-  });
+  assert.throws(
+    () => {
+      Buffer.from(ab, 0, Infinity);
+    },
+    {
+      code: 'ERR_BUFFER_OUT_OF_BOUNDS',
+      name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
+      message: '"length" is outside of buffer bounds'
+    }
+  );
 }
 
 // Test an array like entry with the length set to NaN.
diff --git a/test/parallel/test-buffer-ascii.js b/test/parallel/test-buffer-ascii.js
index afedb7252cb8dc..1b91af16fcab35 100644
--- a/test/parallel/test-buffer-ascii.js
+++ b/test/parallel/test-buffer-ascii.js
@@ -28,12 +28,14 @@ const assert = require('assert');
 assert.strictEqual(Buffer.from('hérité').toString('ascii'), 'hC)ritC)');
 
 // 71 characters, 78 bytes. The ’ character is a triple-byte sequence.
-const input = 'C’est, graphiquement, la réunion d’un accent aigu ' +
-              'et d’un accent grave.';
+const input =
+  'C’est, graphiquement, la réunion d’un accent aigu ' +
+  'et d’un accent grave.';
 
-const expected = 'Cb\u0000\u0019est, graphiquement, la rC)union ' +
-                 'db\u0000\u0019un accent aigu et db\u0000\u0019un ' +
-                 'accent grave.';
+const expected =
+  'Cb\u0000\u0019est, graphiquement, la rC)union ' +
+  'db\u0000\u0019un accent aigu et db\u0000\u0019un ' +
+  'accent grave.';
 
 const buf = Buffer.from(input);
 
diff --git a/test/parallel/test-buffer-bad-overload.js b/test/parallel/test-buffer-bad-overload.js
index 63acb8ebfb6d49..6c5185486b1be7 100644
--- a/test/parallel/test-buffer-bad-overload.js
+++ b/test/parallel/test-buffer-bad-overload.js
@@ -7,8 +7,8 @@ Buffer.allocUnsafe(10); // Should not throw.
 const err = common.expectsError({
   code: 'ERR_INVALID_ARG_TYPE',
   type: TypeError,
-  message: 'The "value" argument must not be of type number. ' +
-           'Received type number'
+  message:
+    'The "value" argument must not be of type number. ' + 'Received type number'
 });
 assert.throws(function() {
   Buffer.from(10, 'hex');
diff --git a/test/parallel/test-buffer-badhex.js b/test/parallel/test-buffer-badhex.js
index 61086659fa7b6e..b2adbc40d8aa6b 100644
--- a/test/parallel/test-buffer-badhex.js
+++ b/test/parallel/test-buffer-badhex.js
@@ -37,8 +37,7 @@ const assert = require('assert');
 
 {
   const buf = Buffer.alloc(256);
-  for (let i = 0; i < 256; i++)
-    buf[i] = i;
+  for (let i = 0; i < 256; i++) buf[i] = i;
 
   const hex = buf.toString('hex');
   assert.deepStrictEqual(Buffer.from(hex, 'hex'), buf);
diff --git a/test/parallel/test-buffer-bytelength.js b/test/parallel/test-buffer-bytelength.js
index 45bd4cf3dfd393..a9b8e64a41e296 100644
--- a/test/parallel/test-buffer-bytelength.js
+++ b/test/parallel/test-buffer-bytelength.js
@@ -5,21 +5,14 @@ const assert = require('assert');
 const SlowBuffer = require('buffer').SlowBuffer;
 const vm = require('vm');
 
-[
-  [32, 'latin1'],
-  [NaN, 'utf8'],
-  [{}, 'latin1'],
-  []
-].forEach((args) => {
-  common.expectsError(
-    () => Buffer.byteLength(...args),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "string" argument must be one of type string, ' +
-               `Buffer, or ArrayBuffer. Received type ${typeof args[0]}`
-    }
-  );
+[[32, 'latin1'], [NaN, 'utf8'], [{}, 'latin1'], []].forEach((args) => {
+  common.expectsError(() => Buffer.byteLength(...args), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "string" argument must be one of type string, ' +
+      `Buffer, or ArrayBuffer. Received type ${typeof args[0]}`
+  });
 });
 
 assert.strictEqual(Buffer.byteLength('', undefined, true), -1);
@@ -88,7 +81,8 @@ assert.strictEqual(Buffer.byteLength('aGVsbG8gd29ybGQ=', 'BASE64'), 11);
 assert.strictEqual(Buffer.byteLength('bm9kZS5qcyByb2NrcyE=', 'base64'), 14);
 assert.strictEqual(Buffer.byteLength('aGkk', 'base64'), 3);
 assert.strictEqual(
-  Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==', 'base64'), 25
+  Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==', 'base64'),
+  25
 );
 // special padding
 assert.strictEqual(Buffer.byteLength('aaa=', 'base64'), 2);
@@ -118,6 +112,8 @@ for (let i = 1; i < 10; i++) {
   const encoding = String(i).repeat(i);
 
   assert.ok(!Buffer.isEncoding(encoding));
-  assert.strictEqual(Buffer.byteLength('foo', encoding),
-                     Buffer.byteLength('foo', 'utf8'));
+  assert.strictEqual(
+    Buffer.byteLength('foo', encoding),
+    Buffer.byteLength('foo', 'utf8')
+  );
 }
diff --git a/test/parallel/test-buffer-compare-offset.js b/test/parallel/test-buffer-compare-offset.js
index a437d8fa6345f6..2e486ab74d796e 100644
--- a/test/parallel/test-buffer-compare-offset.js
+++ b/test/parallel/test-buffer-compare-offset.js
@@ -69,6 +69,7 @@ assert.throws(() => a.compare(b, -Infinity, Infinity), oor);
 common.expectsError(() => a.compare(), {
   code: 'ERR_INVALID_ARG_TYPE',
   type: TypeError,
-  message: 'The "target" argument must be one of ' +
-           'type Buffer or Uint8Array. Received type undefined'
+  message:
+    'The "target" argument must be one of ' +
+    'type Buffer or Uint8Array. Received type undefined'
 });
diff --git a/test/parallel/test-buffer-compare.js b/test/parallel/test-buffer-compare.js
index e2bd1380d2ce15..9b3f54326f0268 100644
--- a/test/parallel/test-buffer-compare.js
+++ b/test/parallel/test-buffer-compare.js
@@ -6,7 +6,7 @@ const assert = require('assert');
 const b = Buffer.alloc(1, 'a');
 const c = Buffer.alloc(1, 'c');
 const d = Buffer.alloc(2, 'aa');
-const e = new Uint8Array([ 0x61, 0x61 ]); // ASCII 'aa', same as d
+const e = new Uint8Array([0x61, 0x61]); // ASCII 'aa', same as d
 
 assert.strictEqual(b.compare(c), -1);
 assert.strictEqual(c.compare(d), 1);
@@ -30,18 +30,21 @@ assert.strictEqual(Buffer.compare(Buffer.alloc(1), Buffer.alloc(0)), 1);
 
 assert.throws(() => Buffer.compare(Buffer.alloc(1), 'abc'), {
   code: 'ERR_INVALID_ARG_TYPE',
-  message: 'The "buf2" argument must be one of type Buffer or Uint8Array. ' +
-           'Received type string'
+  message:
+    'The "buf2" argument must be one of type Buffer or Uint8Array. ' +
+    'Received type string'
 });
 assert.throws(() => Buffer.compare('abc', Buffer.alloc(1)), {
   code: 'ERR_INVALID_ARG_TYPE',
-  message: 'The "buf1" argument must be one of type Buffer or Uint8Array. ' +
-           'Received type string'
+  message:
+    'The "buf1" argument must be one of type Buffer or Uint8Array. ' +
+    'Received type string'
 });
 
 common.expectsError(() => Buffer.alloc(1).compare('abc'), {
   code: 'ERR_INVALID_ARG_TYPE',
   type: TypeError,
-  message: 'The "target" argument must be one of ' +
-           'type Buffer or Uint8Array. Received type string'
+  message:
+    'The "target" argument must be one of ' +
+    'type Buffer or Uint8Array. Received type string'
 });
diff --git a/test/parallel/test-buffer-concat.js b/test/parallel/test-buffer-concat.js
index 07c2189d97db43..c5880c6bcfe93c 100644
--- a/test/parallel/test-buffer-concat.js
+++ b/test/parallel/test-buffer-concat.js
@@ -24,7 +24,7 @@ const common = require('../common');
 const assert = require('assert');
 
 const zero = [];
-const one = [ Buffer.from('asdf') ];
+const one = [Buffer.from('asdf')];
 const long = [];
 for (let i = 0; i < 10; i++) long.push(Buffer.from('asdf'));
 
@@ -45,37 +45,49 @@ assert.strictEqual(flatLong.toString(), check);
 assert.strictEqual(flatLongLen.toString(), check);
 
 [undefined, null, Buffer.from('hello')].forEach((value) => {
-  assert.throws(() => {
-    Buffer.concat(value);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "list" argument must be one of type Array, Buffer, ' +
-             `or Uint8Array. Received type ${typeof value}`
-  });
+  assert.throws(
+    () => {
+      Buffer.concat(value);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message:
+        'The "list" argument must be one of type Array, Buffer, ' +
+        `or Uint8Array. Received type ${typeof value}`
+    }
+  );
 });
 
 [[42], ['hello', Buffer.from('world')]].forEach((value) => {
-  assert.throws(() => {
-    Buffer.concat(value);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "list[0]" argument must be one of type Array, Buffer, ' +
-             `or Uint8Array. Received type ${typeof value[0]}`
-  });
+  assert.throws(
+    () => {
+      Buffer.concat(value);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message:
+        'The "list[0]" argument must be one of type Array, Buffer, ' +
+        `or Uint8Array. Received type ${typeof value[0]}`
+    }
+  );
 });
 
-assert.throws(() => {
-  Buffer.concat([Buffer.from('hello'), 3]);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  message: 'The "list[1]" argument must be one of type Array, Buffer, ' +
-           'or Uint8Array. Received type number'
-});
+assert.throws(
+  () => {
+    Buffer.concat([Buffer.from('hello'), 3]);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "list[1]" argument must be one of type Array, Buffer, ' +
+      'or Uint8Array. Received type number'
+  }
+);
 
 // eslint-disable-next-line node-core/crypto-check
-const random10 = common.hasCrypto ?
-  require('crypto').randomBytes(10) :
-  Buffer.alloc(10, 1);
+const random10 = common.hasCrypto
+  ? require('crypto').randomBytes(10)
+  : Buffer.alloc(10, 1);
 const empty = Buffer.alloc(0);
 
 assert.notDeepStrictEqual(random10, empty);
@@ -93,8 +105,10 @@ assert.deepStrictEqual(Buffer.concat([empty], 100), Buffer.alloc(100));
 assert.deepStrictEqual(Buffer.concat([empty], 4096), Buffer.alloc(4096));
 assert.deepStrictEqual(
   Buffer.concat([random10], 40),
-  Buffer.concat([random10, Buffer.alloc(30)]));
+  Buffer.concat([random10, Buffer.alloc(30)])
+);
 
-assert.deepStrictEqual(Buffer.concat([new Uint8Array([0x41, 0x42]),
-                                      new Uint8Array([0x43, 0x44])]),
-                       Buffer.from('ABCD'));
+assert.deepStrictEqual(
+  Buffer.concat([new Uint8Array([0x41, 0x42]), new Uint8Array([0x43, 0x44])]),
+  Buffer.from('ABCD')
+);
diff --git a/test/parallel/test-buffer-constants.js b/test/parallel/test-buffer-constants.js
index f6f0dbddc39d3e..5e779d614aa4b7 100644
--- a/test/parallel/test-buffer-constants.js
+++ b/test/parallel/test-buffer-constants.js
@@ -8,8 +8,10 @@ const { MAX_LENGTH, MAX_STRING_LENGTH } = require('buffer').constants;
 assert.strictEqual(typeof MAX_LENGTH, 'number');
 assert.strictEqual(typeof MAX_STRING_LENGTH, 'number');
 assert(MAX_STRING_LENGTH <= MAX_LENGTH);
-assert.throws(() => ' '.repeat(MAX_STRING_LENGTH + 1),
-              /^RangeError: Invalid string length$/);
+assert.throws(
+  () => ' '.repeat(MAX_STRING_LENGTH + 1),
+  /^RangeError: Invalid string length$/
+);
 
 ' '.repeat(MAX_STRING_LENGTH); // Should not throw.
 
diff --git a/test/parallel/test-buffer-constructor-deprecation-error.js b/test/parallel/test-buffer-constructor-deprecation-error.js
index 46535e103b33ee..3dfd3544e562fd 100644
--- a/test/parallel/test-buffer-constructor-deprecation-error.js
+++ b/test/parallel/test-buffer-constructor-deprecation-error.js
@@ -2,9 +2,10 @@
 
 const common = require('../common');
 
-const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
-                      'issues. Please use the Buffer.alloc(), ' +
-                      'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
+const bufferWarning =
+  'Buffer() is deprecated due to security and usability ' +
+  'issues. Please use the Buffer.alloc(), ' +
+  'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
 
 common.expectWarning('DeprecationWarning', bufferWarning, 'DEP0005');
 
diff --git a/test/parallel/test-buffer-constructor-node-modules-paths.js b/test/parallel/test-buffer-constructor-node-modules-paths.js
index c6a419f82ade79..9ad3079ab171f0 100644
--- a/test/parallel/test-buffer-constructor-node-modules-paths.js
+++ b/test/parallel/test-buffer-constructor-node-modules-paths.js
@@ -8,16 +8,21 @@ if (process.env.NODE_PENDING_DEPRECATION)
   common.skip('test does not work when NODE_PENDING_DEPRECATION is set');
 
 function test(main, callSite, expected) {
-  const { stderr } = child_process.spawnSync(process.execPath, ['-p', `
+  const { stderr } = child_process.spawnSync(
+    process.execPath,
+    [
+      '-p',
+      `
   process.mainModule = { filename: ${JSON.stringify(main)} };
 
   vm.runInNewContext('new Buffer(10)', { Buffer }, {
     filename: ${JSON.stringify(callSite)}
-  });`], { encoding: 'utf8' });
-  if (expected)
-    assert(stderr.includes('[DEP0005] DeprecationWarning'), stderr);
-  else
-    assert.strictEqual(stderr.trim(), '');
+  });`
+    ],
+    { encoding: 'utf8' }
+  );
+  if (expected) assert(stderr.includes('[DEP0005] DeprecationWarning'), stderr);
+  else assert.strictEqual(stderr.trim(), '');
 }
 
 test('/a/node_modules/b.js', '/a/node_modules/x.js', false);
@@ -28,10 +33,16 @@ test('/a.js', '/b.js', true);
 test('/a.js', '/node_modules/b.js', false);
 test('/node_modules/a.js.js', '/b.js', true);
 test('c:\\a\\node_modules\\b.js', 'c:\\a\\node_modules\\x.js', false);
-test('c:\\a\\node_modules\\b.js',
-     'c:\\a\\node_modules\\foo\\node_modules\\x.js', false);
-test('c:\\node_modules\\foo\\b.js',
-     'c:\\node_modules\\foo\\node_modules\\x.js', false);
+test(
+  'c:\\a\\node_modules\\b.js',
+  'c:\\a\\node_modules\\foo\\node_modules\\x.js',
+  false
+);
+test(
+  'c:\\node_modules\\foo\\b.js',
+  'c:\\node_modules\\foo\\node_modules\\x.js',
+  false
+);
 test('c:\\a.js', 'c:\\b.js', true);
 test('c:\\a.js', 'c:\\node_modules\\b.js', false);
 test('c:\\node_modules\\a.js', 'c:\\b.js', true);
diff --git a/test/parallel/test-buffer-constructor-outside-node-modules.js b/test/parallel/test-buffer-constructor-outside-node-modules.js
index 1a1e146f2dd9d7..3828941a38e522 100644
--- a/test/parallel/test-buffer-constructor-outside-node-modules.js
+++ b/test/parallel/test-buffer-constructor-outside-node-modules.js
@@ -10,20 +10,32 @@ if (new Error().stack.includes('node_modules'))
 if (process.env.NODE_PENDING_DEPRECATION)
   common.skip('test does not work when NODE_PENDING_DEPRECATION is set');
 
-const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
-                      'issues. Please use the Buffer.alloc(), ' +
-                      'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
+const bufferWarning =
+  'Buffer() is deprecated due to security and usability ' +
+  'issues. Please use the Buffer.alloc(), ' +
+  'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
 
-process.addListener('warning', common.mustCall((warning) => {
-  assert(warning.stack.includes('this_should_emit_a_warning'), warning.stack);
-}));
+process.addListener(
+  'warning',
+  common.mustCall((warning) => {
+    assert(warning.stack.includes('this_should_emit_a_warning'), warning.stack);
+  })
+);
 
-vm.runInNewContext('new Buffer(10)', { Buffer }, {
-  filename: '/a/node_modules/b'
-});
+vm.runInNewContext(
+  'new Buffer(10)',
+  { Buffer },
+  {
+    filename: '/a/node_modules/b'
+  }
+);
 
 common.expectWarning('DeprecationWarning', bufferWarning, 'DEP0005');
 
-vm.runInNewContext('new Buffer(10)', { Buffer }, {
-  filename: '/this_should_emit_a_warning'
-});
+vm.runInNewContext(
+  'new Buffer(10)',
+  { Buffer },
+  {
+    filename: '/this_should_emit_a_warning'
+  }
+);
diff --git a/test/parallel/test-buffer-copy.js b/test/parallel/test-buffer-copy.js
index 6fb6a4ec707ef0..03197497e523be 100644
--- a/test/parallel/test-buffer-copy.js
+++ b/test/parallel/test-buffer-copy.js
@@ -98,14 +98,14 @@ let cntr = 0;
 const bb = Buffer.allocUnsafe(10);
 bb.fill('hello crazy world');
 
-
 // Try to copy from before the beginning of b. Should not throw.
 b.copy(c, 0, 100, 10);
 
 // copy throws at negative sourceStart
 common.expectsError(
   () => Buffer.allocUnsafe(5).copy(Buffer.allocUnsafe(5), 0, -1),
-  errorProperty);
+  errorProperty
+);
 
 {
   // check sourceEnd resets to targetEnd if former is greater than the latter
@@ -118,8 +118,7 @@ common.expectsError(
 }
 
 // throw with negative sourceEnd
-common.expectsError(
-  () => b.copy(c, 0, -1), errorProperty);
+common.expectsError(() => b.copy(c, 0, -1), errorProperty);
 
 // when sourceStart is greater than sourceEnd, zero copied
 assert.strictEqual(b.copy(c, 0, 100, 10), 0);
diff --git a/test/parallel/test-buffer-equals.js b/test/parallel/test-buffer-equals.js
index 91c79a5be8b169..07d1d1f6aa238b 100644
--- a/test/parallel/test-buffer-equals.js
+++ b/test/parallel/test-buffer-equals.js
@@ -14,12 +14,10 @@ assert.ok(!d.equals(e));
 assert.ok(d.equals(d));
 assert.ok(d.equals(new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65])));
 
-common.expectsError(
-  () => Buffer.alloc(1).equals('abc'),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "otherBuffer" argument must be one of type ' +
+common.expectsError(() => Buffer.alloc(1).equals('abc'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "otherBuffer" argument must be one of type ' +
     'Buffer or Uint8Array. Received type string'
-  }
-);
+});
diff --git a/test/parallel/test-buffer-fakes.js b/test/parallel/test-buffer-fakes.js
index d126d39aa95263..c632619739576c 100644
--- a/test/parallel/test-buffer-fakes.js
+++ b/test/parallel/test-buffer-fakes.js
@@ -3,7 +3,7 @@
 require('../common');
 const assert = require('assert');
 
-function FakeBuffer() { }
+function FakeBuffer() {}
 Object.setPrototypeOf(FakeBuffer, Buffer);
 Object.setPrototypeOf(FakeBuffer.prototype, Buffer.prototype);
 
diff --git a/test/parallel/test-buffer-fill.js b/test/parallel/test-buffer-fill.js
index 61ff6bbb501f4d..0e86898b1fa886 100644
--- a/test/parallel/test-buffer-fill.js
+++ b/test/parallel/test-buffer-fill.js
@@ -2,7 +2,9 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
-const { codes: { ERR_OUT_OF_RANGE } } = require('internal/errors');
+const {
+  codes: { ERR_OUT_OF_RANGE }
+} = require('internal/errors');
 const { internalBinding } = require('internal/test/binding');
 const SIZE = 28;
 
@@ -42,7 +44,12 @@ testBufs('abc', 5, 1, 'utf8');
 testBufs('\u0222aa', 8, 1, 'utf8');
 testBufs('a\u0234b\u0235c\u0236', 4, 1, 'utf8');
 testBufs('a\u0234b\u0235c\u0236', 12, 1, 'utf8');
-assert.strictEqual(Buffer.allocUnsafe(1).fill(0).fill('\u0222')[0], 0xc8);
+assert.strictEqual(
+  Buffer.allocUnsafe(1)
+    .fill(0)
+    .fill('\u0222')[0],
+  0xc8
+);
 
 // BINARY
 testBufs('abc', 'binary');
@@ -112,23 +119,29 @@ testBufs('c8a26161', 8, 1, 'hex');
 testBufs('61c8b462c8b563c8b6', 4, 1, 'hex');
 testBufs('61c8b462c8b563c8b6', 12, 1, 'hex');
 
-common.expectsError(() => {
-  const buf = Buffer.allocUnsafe(SIZE);
+common.expectsError(
+  () => {
+    const buf = Buffer.allocUnsafe(SIZE);
 
-  buf.fill('yKJh', 'hex');
-}, {
-  code: 'ERR_INVALID_ARG_VALUE',
-  type: TypeError
-});
+    buf.fill('yKJh', 'hex');
+  },
+  {
+    code: 'ERR_INVALID_ARG_VALUE',
+    type: TypeError
+  }
+);
 
-common.expectsError(() => {
-  const buf = Buffer.allocUnsafe(SIZE);
+common.expectsError(
+  () => {
+    const buf = Buffer.allocUnsafe(SIZE);
 
-  buf.fill('\u0222', 'hex');
-}, {
-  code: 'ERR_INVALID_ARG_VALUE',
-  type: TypeError
-});
+    buf.fill('\u0222', 'hex');
+  },
+  {
+    code: 'ERR_INVALID_ARG_VALUE',
+    type: TypeError
+  }
+);
 
 // BASE64
 testBufs('YWJj', 'ucs2');
@@ -158,7 +171,9 @@ deepStrictEqualValues(genBuffer(4, [buf2Fill]), [2, 2, 2, 2]);
 deepStrictEqualValues(genBuffer(4, [buf2Fill, 1]), [0, 2, 2, 2]);
 deepStrictEqualValues(genBuffer(4, [buf2Fill, 1, 3]), [0, 2, 2, 0]);
 deepStrictEqualValues(genBuffer(4, [buf2Fill, 1, 1]), [0, 0, 0, 0]);
-const hexBufFill = Buffer.allocUnsafe(2).fill(0).fill('0102', 'hex');
+const hexBufFill = Buffer.allocUnsafe(2)
+  .fill(0)
+  .fill('0102', 'hex');
 deepStrictEqualValues(genBuffer(4, [hexBufFill]), [1, 2, 1, 2]);
 deepStrictEqualValues(genBuffer(4, [hexBufFill, 1]), [0, 1, 2, 1]);
 deepStrictEqualValues(genBuffer(4, [hexBufFill, 1, 3]), [0, 1, 2, 0]);
@@ -170,45 +185,31 @@ deepStrictEqualValues(genBuffer(4, [hexBufFill, 1, 1]), [0, 0, 0, 0]);
   [0, 0, buf1.length + 1],
   ['', -1],
   ['', 0, buf1.length + 1],
-  ['', 1, -1],
+  ['', 1, -1]
 ].forEach((args) => {
-  common.expectsError(
-    () => buf1.fill(...args),
-    { code: 'ERR_OUT_OF_RANGE' }
-  );
+  common.expectsError(() => buf1.fill(...args), { code: 'ERR_OUT_OF_RANGE' });
 });
 
-common.expectsError(
-  () => buf1.fill('a', 0, buf1.length, 'node rocks!'),
-  {
-    code: 'ERR_UNKNOWN_ENCODING',
-    type: TypeError,
-    message: 'Unknown encoding: node rocks!'
-  }
-);
+common.expectsError(() => buf1.fill('a', 0, buf1.length, 'node rocks!'), {
+  code: 'ERR_UNKNOWN_ENCODING',
+  type: TypeError,
+  message: 'Unknown encoding: node rocks!'
+});
 
-[
-  ['a', 0, 0, NaN],
-  ['a', 0, 0, false]
-].forEach((args) => {
-  common.expectsError(
-    () => buf1.fill(...args),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: 'The "encoding" argument must be of type ' +
+[['a', 0, 0, NaN], ['a', 0, 0, false]].forEach((args) => {
+  common.expectsError(() => buf1.fill(...args), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "encoding" argument must be of type ' +
       `string. Received type ${args[3] === null ? 'null' : typeof args[3]}`
-    }
-  );
+  });
 });
 
-common.expectsError(
-  () => buf1.fill('a', 0, 0, 'foo'),
-  {
-    code: 'ERR_UNKNOWN_ENCODING',
-    type: TypeError,
-    message: 'Unknown encoding: foo'
-  }
-);
+common.expectsError(() => buf1.fill('a', 0, 0, 'foo'), {
+  code: 'ERR_UNKNOWN_ENCODING',
+  type: TypeError,
+  message: 'Unknown encoding: foo'
+});
 
 function genBuffer(size, args) {
   const b = Buffer.allocUnsafe(size);
@@ -237,11 +238,9 @@ function writeToFill(string, offset, end, encoding) {
   }
 
   // Should never be reached.
-  if (offset < 0 || end > buf2.length)
-    throw new ERR_OUT_OF_RANGE();
+  if (offset < 0 || end > buf2.length) throw new ERR_OUT_OF_RANGE();
 
-  if (end <= offset)
-    return buf2;
+  if (end <= offset) return buf2;
 
   offset >>>= 0;
   end >>>= 0;
@@ -256,10 +255,8 @@ function writeToFill(string, offset, end, encoding) {
     offset += written;
     // Safety check in case write falls into infinite loop.
     if (written === 0) {
-      if (wasZero)
-        throw new Error('Could not write all data to Buffer');
-      else
-        wasZero = true;
+      if (wasZero) throw new Error('Could not write all data to Buffer');
+      else wasZero = true;
     }
   } while (offset < buf2.length);
 
@@ -270,17 +267,19 @@ function testBufs(string, offset, length, encoding) {
   bufReset();
   buf1.fill.apply(buf1, arguments);
   // Swap bytes on BE archs for ucs2 encoding.
-  assert.deepStrictEqual(buf1.fill.apply(buf1, arguments),
-                         writeToFill.apply(null, arguments));
+  assert.deepStrictEqual(
+    buf1.fill.apply(buf1, arguments),
+    writeToFill.apply(null, arguments)
+  );
 }
 
 // Make sure these throw.
-common.expectsError(
-  () => Buffer.allocUnsafe(8).fill('a', -1),
-  { code: 'ERR_OUT_OF_RANGE' });
-common.expectsError(
-  () => Buffer.allocUnsafe(8).fill('a', 0, 9),
-  { code: 'ERR_OUT_OF_RANGE' });
+common.expectsError(() => Buffer.allocUnsafe(8).fill('a', -1), {
+  code: 'ERR_OUT_OF_RANGE'
+});
+common.expectsError(() => Buffer.allocUnsafe(8).fill('a', 0, 9), {
+  code: 'ERR_OUT_OF_RANGE'
+});
 
 // Make sure this doesn't hang indefinitely.
 Buffer.allocUnsafe(8).fill('');
@@ -288,12 +287,10 @@ Buffer.alloc(8, '');
 
 {
   const buf = Buffer.alloc(64, 10);
-  for (let i = 0; i < buf.length; i++)
-    assert.strictEqual(buf[i], 10);
+  for (let i = 0; i < buf.length; i++) assert.strictEqual(buf[i], 10);
 
   buf.fill(11, 0, buf.length >> 1);
-  for (let i = 0; i < buf.length >> 1; i++)
-    assert.strictEqual(buf[i], 11);
+  for (let i = 0; i < buf.length >> 1; i++) assert.strictEqual(buf[i], 11);
   for (let i = (buf.length >> 1) + 1; i < buf.length; i++)
     assert.strictEqual(buf[i], 10);
 
@@ -302,20 +299,15 @@ Buffer.alloc(8, '');
     assert.strictEqual('h'.charCodeAt(0), buf[i]);
 
   buf.fill(0);
-  for (let i = 0; i < buf.length; i++)
-    assert.strictEqual(buf[i], 0);
+  for (let i = 0; i < buf.length; i++) assert.strictEqual(buf[i], 0);
 
   buf.fill(null);
-  for (let i = 0; i < buf.length; i++)
-    assert.strictEqual(buf[i], 0);
+  for (let i = 0; i < buf.length; i++) assert.strictEqual(buf[i], 0);
 
   buf.fill(1, 16, 32);
-  for (let i = 0; i < 16; i++)
-    assert.strictEqual(buf[i], 0);
-  for (let i = 16; i < 32; i++)
-    assert.strictEqual(buf[i], 1);
-  for (let i = 32; i < buf.length; i++)
-    assert.strictEqual(buf[i], 0);
+  for (let i = 0; i < 16; i++) assert.strictEqual(buf[i], 0);
+  for (let i = 16; i < 32; i++) assert.strictEqual(buf[i], 1);
+  for (let i = 32; i < buf.length; i++) assert.strictEqual(buf[i], 0);
 }
 
 {
@@ -328,7 +320,9 @@ Buffer.alloc(8, '');
 // Testing process.binding. Make sure "start" is properly checked for -1 wrap
 // around.
 assert.strictEqual(
-  internalBinding('buffer').fill(Buffer.alloc(1), 1, -1, 0, 1), -2);
+  internalBinding('buffer').fill(Buffer.alloc(1), 1, -1, 0, 1),
+  -2
+);
 
 // Make sure "end" is properly checked, even if it's magically mangled using
 // Symbol.toPrimitive.
@@ -337,91 +331,126 @@ assert.strictEqual(
   const expectedErrorMessage =
     'The value of "end" is out of range. It must be >= 0 and <= 1. Received -1';
 
-  common.expectsError(() => {
-    let ctr = 0;
-    const end = {
-      [Symbol.toPrimitive]() {
-        // We use this condition to get around the check in lib/buffer.js
-        if (ctr === 0) {
-          elseWasLast = false;
-          ctr++;
-          return 1;
+  common.expectsError(
+    () => {
+      let ctr = 0;
+      const end = {
+        [Symbol.toPrimitive]() {
+          // We use this condition to get around the check in lib/buffer.js
+          if (ctr === 0) {
+            elseWasLast = false;
+            ctr++;
+            return 1;
+          }
+          elseWasLast = true;
+          // Once buffer.js calls the C++ implementation of fill, return -1
+          return -1;
         }
-        elseWasLast = true;
-        // Once buffer.js calls the C++ implementation of fill, return -1
-        return -1;
-      }
-    };
-    Buffer.alloc(1).fill(Buffer.alloc(1), 0, end);
-  }, {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: expectedErrorMessage
-  });
+      };
+      Buffer.alloc(1).fill(Buffer.alloc(1), 0, end);
+    },
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      type: RangeError,
+      message: expectedErrorMessage
+    }
+  );
   // Make sure -1 is making it to Buffer::Fill().
-  assert.ok(elseWasLast,
-            'internal API changed, -1 no longer in correct location');
+  assert.ok(
+    elseWasLast,
+    'internal API changed, -1 no longer in correct location'
+  );
 }
 
 // Testing process.binding. Make sure "end" is properly checked for -1 wrap
 // around.
 assert.strictEqual(
-  internalBinding('buffer').fill(Buffer.alloc(1), 1, 1, -2, 1), -2);
+  internalBinding('buffer').fill(Buffer.alloc(1), 1, 1, -2, 1),
+  -2
+);
 
 // Test that bypassing 'length' won't cause an abort.
-common.expectsError(() => {
-  const buf = Buffer.from('w00t');
-  Object.defineProperty(buf, 'length', {
-    value: 1337,
-    enumerable: true
-  });
-  buf.fill('');
-}, {
-  code: 'ERR_BUFFER_OUT_OF_BOUNDS',
-  type: RangeError,
-  message: 'Attempt to write outside buffer bounds'
-});
+common.expectsError(
+  () => {
+    const buf = Buffer.from('w00t');
+    Object.defineProperty(buf, 'length', {
+      value: 1337,
+      enumerable: true
+    });
+    buf.fill('');
+  },
+  {
+    code: 'ERR_BUFFER_OUT_OF_BOUNDS',
+    type: RangeError,
+    message: 'Attempt to write outside buffer bounds'
+  }
+);
 
 assert.deepStrictEqual(
   Buffer.allocUnsafeSlow(16).fill('ab', 'utf16le'),
-  Buffer.from('61006200610062006100620061006200', 'hex'));
+  Buffer.from('61006200610062006100620061006200', 'hex')
+);
 
 assert.deepStrictEqual(
   Buffer.allocUnsafeSlow(15).fill('ab', 'utf16le'),
-  Buffer.from('610062006100620061006200610062', 'hex'));
+  Buffer.from('610062006100620061006200610062', 'hex')
+);
 
 assert.deepStrictEqual(
   Buffer.allocUnsafeSlow(16).fill('ab', 'utf16le'),
-  Buffer.from('61006200610062006100620061006200', 'hex'));
+  Buffer.from('61006200610062006100620061006200', 'hex')
+);
 assert.deepStrictEqual(
   Buffer.allocUnsafeSlow(16).fill('a', 'utf16le'),
-  Buffer.from('61006100610061006100610061006100', 'hex'));
+  Buffer.from('61006100610061006100610061006100', 'hex')
+);
 
 assert.strictEqual(
-  Buffer.allocUnsafeSlow(16).fill('a', 'utf16le').toString('utf16le'),
-  'a'.repeat(8));
+  Buffer.allocUnsafeSlow(16)
+    .fill('a', 'utf16le')
+    .toString('utf16le'),
+  'a'.repeat(8)
+);
 assert.strictEqual(
-  Buffer.allocUnsafeSlow(16).fill('a', 'latin1').toString('latin1'),
-  'a'.repeat(16));
+  Buffer.allocUnsafeSlow(16)
+    .fill('a', 'latin1')
+    .toString('latin1'),
+  'a'.repeat(16)
+);
 assert.strictEqual(
-  Buffer.allocUnsafeSlow(16).fill('a', 'utf8').toString('utf8'),
-  'a'.repeat(16));
+  Buffer.allocUnsafeSlow(16)
+    .fill('a', 'utf8')
+    .toString('utf8'),
+  'a'.repeat(16)
+);
 
 assert.strictEqual(
-  Buffer.allocUnsafeSlow(16).fill('Љ', 'utf16le').toString('utf16le'),
-  'Љ'.repeat(8));
+  Buffer.allocUnsafeSlow(16)
+    .fill('Љ', 'utf16le')
+    .toString('utf16le'),
+  'Љ'.repeat(8)
+);
 assert.strictEqual(
-  Buffer.allocUnsafeSlow(16).fill('Љ', 'latin1').toString('latin1'),
-  '\t'.repeat(16));
+  Buffer.allocUnsafeSlow(16)
+    .fill('Љ', 'latin1')
+    .toString('latin1'),
+  '\t'.repeat(16)
+);
 assert.strictEqual(
-  Buffer.allocUnsafeSlow(16).fill('Љ', 'utf8').toString('utf8'),
-  'Љ'.repeat(8));
+  Buffer.allocUnsafeSlow(16)
+    .fill('Љ', 'utf8')
+    .toString('utf8'),
+  'Љ'.repeat(8)
+);
 
-common.expectsError(() => {
-  const buf = Buffer.from('a'.repeat(1000));
+common.expectsError(
+  () => {
+    const buf = Buffer.from('a'.repeat(1000));
 
-  buf.fill('This is not correctly encoded', 'hex');
-}, {
-  code: 'ERR_INVALID_ARG_VALUE',
-  type: TypeError
-});
+    buf.fill('This is not correctly encoded', 'hex');
+  },
+  {
+    code: 'ERR_INVALID_ARG_VALUE',
+    type: TypeError
+  }
+);
diff --git a/test/parallel/test-buffer-from.js b/test/parallel/test-buffer-from.js
index e8a9196b3d9d8c..4c1088937ee4e8 100644
--- a/test/parallel/test-buffer-from.js
+++ b/test/parallel/test-buffer-from.js
@@ -37,30 +37,43 @@ deepStrictEqual(
 [
   [{}, 'object'],
   [new Boolean(true), 'boolean'],
-  [{ valueOf() { return null; } }, 'object'],
-  [{ valueOf() { return undefined; } }, 'object'],
+  [
+    {
+      valueOf() {
+        return null;
+      }
+    },
+    'object'
+  ],
+  [
+    {
+      valueOf() {
+        return undefined;
+      }
+    },
+    'object'
+  ],
   [{ valueOf: null }, 'object'],
   [Object.create(null), 'object']
 ].forEach(([input, actualType]) => {
   const err = common.expectsError({
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The first argument must be one of type string, Buffer, ' +
-             'ArrayBuffer, Array, or Array-like Object. Received ' +
-             `type ${actualType}`
+    message:
+      'The first argument must be one of type string, Buffer, ' +
+      'ArrayBuffer, Array, or Array-like Object. Received ' +
+      `type ${actualType}`
   });
   throws(() => Buffer.from(input), err);
 });
 
-[
-  new Number(true),
-  new MyBadPrimitive()
-].forEach((input) => {
+[new Number(true), new MyBadPrimitive()].forEach((input) => {
   const errMsg = common.expectsError({
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "value" argument must not be of type number. ' +
-             'Received type number'
+    message:
+      'The "value" argument must not be of type number. ' +
+      'Received type number'
   });
   throws(() => Buffer.from(input), errMsg);
 });
diff --git a/test/parallel/test-buffer-includes.js b/test/parallel/test-buffer-includes.js
index 50f0d469b649eb..de7c812fdf0376 100644
--- a/test/parallel/test-buffer-includes.js
+++ b/test/parallel/test-buffer-includes.js
@@ -78,87 +78,98 @@ assert(!Buffer.from('ff').includes(Buffer.from('f'), 1, 'ucs2'));
 
 // test hex encoding
 assert.strictEqual(
-  Buffer.from(b.toString('hex'), 'hex')
-    .includes('64', 0, 'hex'),
+  Buffer.from(b.toString('hex'), 'hex').includes('64', 0, 'hex'),
   true
 );
 assert.strictEqual(
-  Buffer.from(b.toString('hex'), 'hex')
-    .includes(Buffer.from('64', 'hex'), 0, 'hex'),
+  Buffer.from(b.toString('hex'), 'hex').includes(
+    Buffer.from('64', 'hex'),
+    0,
+    'hex'
+  ),
   true
 );
 
 // test base64 encoding
 assert.strictEqual(
-  Buffer.from(b.toString('base64'), 'base64')
-    .includes('ZA==', 0, 'base64'),
+  Buffer.from(b.toString('base64'), 'base64').includes('ZA==', 0, 'base64'),
   true
 );
 assert.strictEqual(
-  Buffer.from(b.toString('base64'), 'base64')
-    .includes(Buffer.from('ZA==', 'base64'), 0, 'base64'),
+  Buffer.from(b.toString('base64'), 'base64').includes(
+    Buffer.from('ZA==', 'base64'),
+    0,
+    'base64'
+  ),
   true
 );
 
 // test ascii encoding
 assert.strictEqual(
-  Buffer.from(b.toString('ascii'), 'ascii')
-    .includes('d', 0, 'ascii'),
+  Buffer.from(b.toString('ascii'), 'ascii').includes('d', 0, 'ascii'),
   true
 );
 assert.strictEqual(
-  Buffer.from(b.toString('ascii'), 'ascii')
-    .includes(Buffer.from('d', 'ascii'), 0, 'ascii'),
+  Buffer.from(b.toString('ascii'), 'ascii').includes(
+    Buffer.from('d', 'ascii'),
+    0,
+    'ascii'
+  ),
   true
 );
 
 // test latin1 encoding
 assert.strictEqual(
-  Buffer.from(b.toString('latin1'), 'latin1')
-    .includes('d', 0, 'latin1'),
+  Buffer.from(b.toString('latin1'), 'latin1').includes('d', 0, 'latin1'),
   true
 );
 assert.strictEqual(
-  Buffer.from(b.toString('latin1'), 'latin1')
-    .includes(Buffer.from('d', 'latin1'), 0, 'latin1'),
+  Buffer.from(b.toString('latin1'), 'latin1').includes(
+    Buffer.from('d', 'latin1'),
+    0,
+    'latin1'
+  ),
   true
 );
 
 // test binary encoding
 assert.strictEqual(
-  Buffer.from(b.toString('binary'), 'binary')
-    .includes('d', 0, 'binary'),
+  Buffer.from(b.toString('binary'), 'binary').includes('d', 0, 'binary'),
   true
 );
 assert.strictEqual(
-  Buffer.from(b.toString('binary'), 'binary')
-    .includes(Buffer.from('d', 'binary'), 0, 'binary'),
+  Buffer.from(b.toString('binary'), 'binary').includes(
+    Buffer.from('d', 'binary'),
+    0,
+    'binary'
+  ),
   true
 );
 
-
 // test ucs2 encoding
 let twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
 
 assert(twoByteString.includes('\u0395', 4, 'ucs2'));
 assert(twoByteString.includes('\u03a3', -4, 'ucs2'));
 assert(twoByteString.includes('\u03a3', -6, 'ucs2'));
-assert(twoByteString.includes(
-  Buffer.from('\u03a3', 'ucs2'), -6, 'ucs2'));
+assert(twoByteString.includes(Buffer.from('\u03a3', 'ucs2'), -6, 'ucs2'));
 assert(!twoByteString.includes('\u03a3', -2, 'ucs2'));
 
-const mixedByteStringUcs2 =
-  Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395', 'ucs2');
+const mixedByteStringUcs2 = Buffer.from(
+  '\u039a\u0391abc\u03a3\u03a3\u0395',
+  'ucs2'
+);
 assert(mixedByteStringUcs2.includes('bc', 0, 'ucs2'));
 assert(mixedByteStringUcs2.includes('\u03a3', 0, 'ucs2'));
 assert(!mixedByteStringUcs2.includes('\u0396', 0, 'ucs2'));
 
+assert.ok(mixedByteStringUcs2.includes(Buffer.from('bc', 'ucs2'), 0, 'ucs2'));
 assert.ok(
-  mixedByteStringUcs2.includes(Buffer.from('bc', 'ucs2'), 0, 'ucs2'));
-assert.ok(
-  mixedByteStringUcs2.includes(Buffer.from('\u03a3', 'ucs2'), 0, 'ucs2'));
+  mixedByteStringUcs2.includes(Buffer.from('\u03a3', 'ucs2'), 0, 'ucs2')
+);
 assert.ok(
-  !mixedByteStringUcs2.includes(Buffer.from('\u0396', 'ucs2'), 0, 'ucs2'));
+  !mixedByteStringUcs2.includes(Buffer.from('\u0396', 'ucs2'), 0, 'ucs2')
+);
 
 twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
 
@@ -183,11 +194,11 @@ assert(mixedByteStringUtf8.includes('bc', -8));
 assert(mixedByteStringUtf8.includes('\u03a3'));
 assert(!mixedByteStringUtf8.includes('\u0396'));
 
-
 // Test complex string includes algorithms. Only trigger for long strings.
 // Long string that isn't a simple repeat of a shorter string.
 let longString = 'A';
-for (let i = 66; i < 76; i++) {  // from 'B' to 'K'
+for (let i = 66; i < 76; i++) {
+  // from 'B' to 'K'
   longString = longString + String.fromCharCode(i) + longString;
 }
 
@@ -208,7 +219,8 @@ assert(longBufferString.includes(pattern, 512), 'Long JABACABA..., Second J');
 
 // Search for a non-ASCII string in a pure ASCII string.
 const asciiString = Buffer.from(
-  'arglebargleglopglyfarglebargleglopglyfarglebargleglopglyf');
+  'arglebargleglopglyfarglebargleglopglyfarglebargleglopglyf'
+);
 assert(!asciiString.includes('\x2061'));
 assert(asciiString.includes('leb', 0));
 
@@ -225,22 +237,22 @@ assert(!allCharsBufferUtf8.includes('notfound'));
 assert(!allCharsBufferUcs2.includes('notfound'));
 
 // Find substrings in Utf8.
-let lengths = [1, 3, 15];  // Single char, simple and complex.
-let indices = [0x5, 0x60, 0x400, 0x680, 0x7ee, 0xFF02, 0x16610, 0x2f77b];
+let lengths = [1, 3, 15]; // Single char, simple and complex.
+let indices = [0x5, 0x60, 0x400, 0x680, 0x7ee, 0xff02, 0x16610, 0x2f77b];
 for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
   for (let i = 0; i < indices.length; i++) {
     const index = indices[i];
     let length = lengths[lengthIndex];
 
-    if (index + length > 0x7F) {
+    if (index + length > 0x7f) {
       length = 2 * length;
     }
 
-    if (index + length > 0x7FF) {
+    if (index + length > 0x7ff) {
       length = 3 * length;
     }
 
-    if (index + length > 0xFFFF) {
+    if (index + length > 0xffff) {
       length = 4 * length;
     }
 
@@ -253,38 +265,29 @@ for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
 }
 
 // Find substrings in Usc2.
-lengths = [2, 4, 16];  // Single char, simple and complex.
+lengths = [2, 4, 16]; // Single char, simple and complex.
 indices = [0x5, 0x65, 0x105, 0x205, 0x285, 0x2005, 0x2085, 0xfff0];
 for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
   for (let i = 0; i < indices.length; i++) {
     const index = indices[i] * 2;
     const length = lengths[lengthIndex];
 
-    const patternBufferUcs2 =
-      allCharsBufferUcs2.slice(index, index + length);
-    assert.ok(
-      allCharsBufferUcs2.includes(patternBufferUcs2, 0, 'ucs2'));
+    const patternBufferUcs2 = allCharsBufferUcs2.slice(index, index + length);
+    assert.ok(allCharsBufferUcs2.includes(patternBufferUcs2, 0, 'ucs2'));
 
     const patternStringUcs2 = patternBufferUcs2.toString('ucs2');
-    assert.ok(
-      allCharsBufferUcs2.includes(patternStringUcs2, 0, 'ucs2'));
+    assert.ok(allCharsBufferUcs2.includes(patternStringUcs2, 0, 'ucs2'));
   }
 }
 
-[
-  () => { },
-  {},
-  []
-].forEach((val) => {
-  common.expectsError(
-    () => b.includes(val),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "value" argument must be one of type string, ' +
-               `Buffer, or Uint8Array. Received type ${typeof val}`
-    }
-  );
+[() => {}, {}, []].forEach((val) => {
+  common.expectsError(() => b.includes(val), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "value" argument must be one of type string, ' +
+      `Buffer, or Uint8Array. Received type ${typeof val}`
+  });
 });
 
 // test truncation of Number arguments to uint8
diff --git a/test/parallel/test-buffer-indexof.js b/test/parallel/test-buffer-indexof.js
index 3647d115b0dc5b..05e46886a4cde9 100644
--- a/test/parallel/test-buffer-indexof.js
+++ b/test/parallel/test-buffer-indexof.js
@@ -86,95 +86,104 @@ assert.throws(() => b.indexOf('bad', 'enc'), /Unknown encoding: enc/);
 
 // test hex encoding
 assert.strictEqual(
-  Buffer.from(b.toString('hex'), 'hex')
-    .indexOf('64', 0, 'hex'),
+  Buffer.from(b.toString('hex'), 'hex').indexOf('64', 0, 'hex'),
   3
 );
 assert.strictEqual(
-  Buffer.from(b.toString('hex'), 'hex')
-    .indexOf(Buffer.from('64', 'hex'), 0, 'hex'),
+  Buffer.from(b.toString('hex'), 'hex').indexOf(
+    Buffer.from('64', 'hex'),
+    0,
+    'hex'
+  ),
   3
 );
 
 // test base64 encoding
 assert.strictEqual(
-  Buffer.from(b.toString('base64'), 'base64')
-    .indexOf('ZA==', 0, 'base64'),
+  Buffer.from(b.toString('base64'), 'base64').indexOf('ZA==', 0, 'base64'),
   3
 );
 assert.strictEqual(
-  Buffer.from(b.toString('base64'), 'base64')
-    .indexOf(Buffer.from('ZA==', 'base64'), 0, 'base64'),
+  Buffer.from(b.toString('base64'), 'base64').indexOf(
+    Buffer.from('ZA==', 'base64'),
+    0,
+    'base64'
+  ),
   3
 );
 
 // test ascii encoding
 assert.strictEqual(
-  Buffer.from(b.toString('ascii'), 'ascii')
-    .indexOf('d', 0, 'ascii'),
+  Buffer.from(b.toString('ascii'), 'ascii').indexOf('d', 0, 'ascii'),
   3
 );
 assert.strictEqual(
-  Buffer.from(b.toString('ascii'), 'ascii')
-    .indexOf(Buffer.from('d', 'ascii'), 0, 'ascii'),
+  Buffer.from(b.toString('ascii'), 'ascii').indexOf(
+    Buffer.from('d', 'ascii'),
+    0,
+    'ascii'
+  ),
   3
 );
 
 // test latin1 encoding
 assert.strictEqual(
-  Buffer.from(b.toString('latin1'), 'latin1')
-    .indexOf('d', 0, 'latin1'),
+  Buffer.from(b.toString('latin1'), 'latin1').indexOf('d', 0, 'latin1'),
   3
 );
 assert.strictEqual(
-  Buffer.from(b.toString('latin1'), 'latin1')
-    .indexOf(Buffer.from('d', 'latin1'), 0, 'latin1'),
+  Buffer.from(b.toString('latin1'), 'latin1').indexOf(
+    Buffer.from('d', 'latin1'),
+    0,
+    'latin1'
+  ),
   3
 );
 assert.strictEqual(
-  Buffer.from('aa\u00e8aa', 'latin1')
-    .indexOf('\u00e8', 'latin1'),
+  Buffer.from('aa\u00e8aa', 'latin1').indexOf('\u00e8', 'latin1'),
   2
 );
 assert.strictEqual(
-  Buffer.from('\u00e8', 'latin1')
-    .indexOf('\u00e8', 'latin1'),
+  Buffer.from('\u00e8', 'latin1').indexOf('\u00e8', 'latin1'),
   0
 );
 assert.strictEqual(
-  Buffer.from('\u00e8', 'latin1')
-    .indexOf(Buffer.from('\u00e8', 'latin1'), 'latin1'),
+  Buffer.from('\u00e8', 'latin1').indexOf(
+    Buffer.from('\u00e8', 'latin1'),
+    'latin1'
+  ),
   0
 );
 
 // test binary encoding
 assert.strictEqual(
-  Buffer.from(b.toString('binary'), 'binary')
-    .indexOf('d', 0, 'binary'),
+  Buffer.from(b.toString('binary'), 'binary').indexOf('d', 0, 'binary'),
   3
 );
 assert.strictEqual(
-  Buffer.from(b.toString('binary'), 'binary')
-    .indexOf(Buffer.from('d', 'binary'), 0, 'binary'),
+  Buffer.from(b.toString('binary'), 'binary').indexOf(
+    Buffer.from('d', 'binary'),
+    0,
+    'binary'
+  ),
   3
 );
 assert.strictEqual(
-  Buffer.from('aa\u00e8aa', 'binary')
-    .indexOf('\u00e8', 'binary'),
+  Buffer.from('aa\u00e8aa', 'binary').indexOf('\u00e8', 'binary'),
   2
 );
 assert.strictEqual(
-  Buffer.from('\u00e8', 'binary')
-    .indexOf('\u00e8', 'binary'),
+  Buffer.from('\u00e8', 'binary').indexOf('\u00e8', 'binary'),
   0
 );
 assert.strictEqual(
-  Buffer.from('\u00e8', 'binary')
-    .indexOf(Buffer.from('\u00e8', 'binary'), 'binary'),
+  Buffer.from('\u00e8', 'binary').indexOf(
+    Buffer.from('\u00e8', 'binary'),
+    'binary'
+  ),
   0
 );
 
-
 // test optional offset with passed encoding
 assert.strictEqual(Buffer.from('aaaa0').indexOf('30', 'hex'), 4);
 assert.strictEqual(Buffer.from('aaaa00a').indexOf('3030', 'hex'), 4);
@@ -186,23 +195,33 @@ assert.strictEqual(Buffer.from('aaaa00a').indexOf('3030', 'hex'), 4);
   assert.strictEqual(twoByteString.indexOf('\u0395', 4, 'ucs2'), 8);
   assert.strictEqual(twoByteString.indexOf('\u03a3', -4, 'ucs2'), 6);
   assert.strictEqual(twoByteString.indexOf('\u03a3', -6, 'ucs2'), 4);
-  assert.strictEqual(twoByteString.indexOf(
-    Buffer.from('\u03a3', 'ucs2'), -6, 'ucs2'), 4);
+  assert.strictEqual(
+    twoByteString.indexOf(Buffer.from('\u03a3', 'ucs2'), -6, 'ucs2'),
+    4
+  );
   assert.strictEqual(-1, twoByteString.indexOf('\u03a3', -2, 'ucs2'));
 }
 
-const mixedByteStringUcs2 =
-    Buffer.from('\u039a\u0391abc\u03a3\u03a3\u0395', 'ucs2');
+const mixedByteStringUcs2 = Buffer.from(
+  '\u039a\u0391abc\u03a3\u03a3\u0395',
+  'ucs2'
+);
 assert.strictEqual(mixedByteStringUcs2.indexOf('bc', 0, 'ucs2'), 6);
 assert.strictEqual(mixedByteStringUcs2.indexOf('\u03a3', 0, 'ucs2'), 10);
 assert.strictEqual(-1, mixedByteStringUcs2.indexOf('\u0396', 0, 'ucs2'));
 
 assert.strictEqual(
-  mixedByteStringUcs2.indexOf(Buffer.from('bc', 'ucs2'), 0, 'ucs2'), 6);
+  mixedByteStringUcs2.indexOf(Buffer.from('bc', 'ucs2'), 0, 'ucs2'),
+  6
+);
 assert.strictEqual(
-  mixedByteStringUcs2.indexOf(Buffer.from('\u03a3', 'ucs2'), 0, 'ucs2'), 10);
+  mixedByteStringUcs2.indexOf(Buffer.from('\u03a3', 'ucs2'), 0, 'ucs2'),
+  10
+);
 assert.strictEqual(
-  -1, mixedByteStringUcs2.indexOf(Buffer.from('\u0396', 'ucs2'), 0, 'ucs2'));
+  -1,
+  mixedByteStringUcs2.indexOf(Buffer.from('\u0396', 'ucs2'), 0, 'ucs2')
+);
 
 {
   const twoByteString = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
@@ -238,11 +257,11 @@ assert.strictEqual(mixedByteStringUtf8.indexOf('bc', -8), 5);
 assert.strictEqual(mixedByteStringUtf8.indexOf('\u03a3'), 7);
 assert.strictEqual(-1, mixedByteStringUtf8.indexOf('\u0396'));
 
-
 // Test complex string indexOf algorithms. Only trigger for long strings.
 // Long string that isn't a simple repeat of a shorter string.
 let longString = 'A';
-for (let i = 66; i < 76; i++) {  // from 'B' to 'K'
+for (let i = 66; i < 76; i++) {
+  // from 'B' to 'K'
   longString = longString + String.fromCharCode(i) + longString;
 }
 
@@ -252,8 +271,11 @@ const longBufferString = Buffer.from(longString);
 let pattern = 'ABACABADABACABA';
 for (let i = 0; i < longBufferString.length - pattern.length; i += 7) {
   const index = longBufferString.indexOf(pattern, i);
-  assert.strictEqual((i + 15) & ~0xf, index,
-                     `Long ABACABA...-string at index ${i}`);
+  assert.strictEqual(
+    (i + 15) & ~0xf,
+    index,
+    `Long ABACABA...-string at index ${i}`
+  );
 }
 
 let index = longBufferString.indexOf('AJABACA');
@@ -266,11 +288,15 @@ index = longBufferString.indexOf(pattern);
 assert.strictEqual(index, 511, `Long JABACABA..., First J - at index ${index}`);
 index = longBufferString.indexOf(pattern, 512);
 assert.strictEqual(
-  index, 1535, `Long JABACABA..., Second J - at index ${index}`);
+  index,
+  1535,
+  `Long JABACABA..., Second J - at index ${index}`
+);
 
 // Search for a non-ASCII string in a pure ASCII string.
 const asciiString = Buffer.from(
-  'arglebargleglopglyfarglebargleglopglyfarglebargleglopglyf');
+  'arglebargleglopglyfarglebargleglopglyfarglebargleglopglyf'
+);
 assert.strictEqual(-1, asciiString.indexOf('\x2061'));
 assert.strictEqual(asciiString.indexOf('leb', 0), 3);
 
@@ -297,22 +323,22 @@ assert.strictEqual(Buffer.from('aaaaa').indexOf('b', 'ucs2'), -1);
 
 {
   // Find substrings in Utf8.
-  const lengths = [1, 3, 15];  // Single char, simple and complex.
-  const indices = [0x5, 0x60, 0x400, 0x680, 0x7ee, 0xFF02, 0x16610, 0x2f77b];
+  const lengths = [1, 3, 15]; // Single char, simple and complex.
+  const indices = [0x5, 0x60, 0x400, 0x680, 0x7ee, 0xff02, 0x16610, 0x2f77b];
   for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
     for (let i = 0; i < indices.length; i++) {
       const index = indices[i];
       let length = lengths[lengthIndex];
 
-      if (index + length > 0x7F) {
+      if (index + length > 0x7f) {
         length = 2 * length;
       }
 
-      if (index + length > 0x7FF) {
+      if (index + length > 0x7ff) {
         length = 3 * length;
       }
 
-      if (index + length > 0xFFFF) {
+      if (index + length > 0xffff) {
         length = 4 * length;
       }
 
@@ -327,39 +353,36 @@ assert.strictEqual(Buffer.from('aaaaa').indexOf('b', 'ucs2'), -1);
 
 {
   // Find substrings in Usc2.
-  const lengths = [2, 4, 16];  // Single char, simple and complex.
+  const lengths = [2, 4, 16]; // Single char, simple and complex.
   const indices = [0x5, 0x65, 0x105, 0x205, 0x285, 0x2005, 0x2085, 0xfff0];
   for (let lengthIndex = 0; lengthIndex < lengths.length; lengthIndex++) {
     for (let i = 0; i < indices.length; i++) {
       const index = indices[i] * 2;
       const length = lengths[lengthIndex];
 
-      const patternBufferUcs2 =
-          allCharsBufferUcs2.slice(index, index + length);
+      const patternBufferUcs2 = allCharsBufferUcs2.slice(index, index + length);
       assert.strictEqual(
-        index, allCharsBufferUcs2.indexOf(patternBufferUcs2, 0, 'ucs2'));
+        index,
+        allCharsBufferUcs2.indexOf(patternBufferUcs2, 0, 'ucs2')
+      );
 
       const patternStringUcs2 = patternBufferUcs2.toString('ucs2');
       assert.strictEqual(
-        index, allCharsBufferUcs2.indexOf(patternStringUcs2, 0, 'ucs2'));
+        index,
+        allCharsBufferUcs2.indexOf(patternStringUcs2, 0, 'ucs2')
+      );
     }
   }
 }
 
-[
-  () => {},
-  {},
-  []
-].forEach((val) => {
-  common.expectsError(
-    () => b.indexOf(val),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "value" argument must be one of type string, ' +
-               `Buffer, or Uint8Array. Received type ${typeof val}`
-    }
-  );
+[() => {}, {}, []].forEach((val) => {
+  common.expectsError(() => b.indexOf(val), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "value" argument must be one of type string, ' +
+      `Buffer, or Uint8Array. Received type ${typeof val}`
+  });
 });
 
 // Test weird offset arguments.
@@ -374,24 +397,12 @@ assert.strictEqual(b.indexOf('b', []), 1);
 assert.strictEqual(b.indexOf('b', [2]), -1);
 
 // Behavior should match String.indexOf()
-assert.strictEqual(
-  b.indexOf('b', undefined),
-  s.indexOf('b', undefined));
-assert.strictEqual(
-  b.indexOf('b', {}),
-  s.indexOf('b', {}));
-assert.strictEqual(
-  b.indexOf('b', 0),
-  s.indexOf('b', 0));
-assert.strictEqual(
-  b.indexOf('b', null),
-  s.indexOf('b', null));
-assert.strictEqual(
-  b.indexOf('b', []),
-  s.indexOf('b', []));
-assert.strictEqual(
-  b.indexOf('b', [2]),
-  s.indexOf('b', [2]));
+assert.strictEqual(b.indexOf('b', undefined), s.indexOf('b', undefined));
+assert.strictEqual(b.indexOf('b', {}), s.indexOf('b', {}));
+assert.strictEqual(b.indexOf('b', 0), s.indexOf('b', 0));
+assert.strictEqual(b.indexOf('b', null), s.indexOf('b', null));
+assert.strictEqual(b.indexOf('b', []), s.indexOf('b', []));
+assert.strictEqual(b.indexOf('b', [2]), s.indexOf('b', [2]));
 
 // All code for handling encodings is shared between Buffer.indexOf and
 // Buffer.lastIndexOf, so only testing the separate lastIndexOf semantics.
@@ -462,22 +473,13 @@ assert.strictEqual(b.lastIndexOf('b', [2]), 1);
 // Behavior should match String.lastIndexOf()
 assert.strictEqual(
   b.lastIndexOf('b', undefined),
-  s.lastIndexOf('b', undefined));
-assert.strictEqual(
-  b.lastIndexOf('b', {}),
-  s.lastIndexOf('b', {}));
-assert.strictEqual(
-  b.lastIndexOf('b', 0),
-  s.lastIndexOf('b', 0));
-assert.strictEqual(
-  b.lastIndexOf('b', null),
-  s.lastIndexOf('b', null));
-assert.strictEqual(
-  b.lastIndexOf('b', []),
-  s.lastIndexOf('b', []));
-assert.strictEqual(
-  b.lastIndexOf('b', [2]),
-  s.lastIndexOf('b', [2]));
+  s.lastIndexOf('b', undefined)
+);
+assert.strictEqual(b.lastIndexOf('b', {}), s.lastIndexOf('b', {}));
+assert.strictEqual(b.lastIndexOf('b', 0), s.lastIndexOf('b', 0));
+assert.strictEqual(b.lastIndexOf('b', null), s.lastIndexOf('b', null));
+assert.strictEqual(b.lastIndexOf('b', []), s.lastIndexOf('b', []));
+assert.strictEqual(b.lastIndexOf('b', [2]), s.lastIndexOf('b', [2]));
 
 // Test needles longer than the haystack.
 assert.strictEqual(b.lastIndexOf('aaaaaaaaaaaaaaa', 'ucs2'), -1);
@@ -509,8 +511,10 @@ assert.strictEqual(bufferString.lastIndexOf('canal'), 15);
 assert.strictEqual(bufferString.lastIndexOf('panama'), 21);
 assert.strictEqual(bufferString.lastIndexOf('a man a plan a canal panama'), 0);
 assert.strictEqual(-1, bufferString.lastIndexOf('a man a plan a canal mexico'));
-assert.strictEqual(-1, bufferString
-  .lastIndexOf('a man a plan a canal mexico city'));
+assert.strictEqual(
+  -1,
+  bufferString.lastIndexOf('a man a plan a canal mexico city')
+);
 assert.strictEqual(-1, bufferString.lastIndexOf(Buffer.from('a'.repeat(1000))));
 assert.strictEqual(bufferString.lastIndexOf('a man a plan', 4), 0);
 assert.strictEqual(bufferString.lastIndexOf('a '), 13);
@@ -564,21 +568,21 @@ function countBits(n) {
 }
 const parts = [];
 for (let i = 0; i < 1000000; i++) {
-  parts.push((countBits(i) % 2 === 0) ? 'yolo' : 'swag');
+  parts.push(countBits(i) % 2 === 0 ? 'yolo' : 'swag');
 }
 const reallyLong = Buffer.from(parts.join(' '));
 assert.strictEqual(reallyLong.slice(0, 19).toString(), 'yolo swag swag yolo');
 
 // Expensive reverse searches. Stress test lastIndexOf:
-pattern = reallyLong.slice(0, 100000);  // First 1/50th of the pattern.
+pattern = reallyLong.slice(0, 100000); // First 1/50th of the pattern.
 assert.strictEqual(reallyLong.lastIndexOf(pattern), 4751360);
 assert.strictEqual(reallyLong.lastIndexOf(pattern, 4000000), 3932160);
 assert.strictEqual(reallyLong.lastIndexOf(pattern, 3000000), 2949120);
-pattern = reallyLong.slice(100000, 200000);  // Second 1/50th.
+pattern = reallyLong.slice(100000, 200000); // Second 1/50th.
 assert.strictEqual(reallyLong.lastIndexOf(pattern), 4728480);
-pattern = reallyLong.slice(0, 1000000);  // First 1/5th.
+pattern = reallyLong.slice(0, 1000000); // First 1/5th.
 assert.strictEqual(reallyLong.lastIndexOf(pattern), 3932160);
-pattern = reallyLong.slice(0, 2000000);  // first 2/5ths.
+pattern = reallyLong.slice(0, 2000000); // first 2/5ths.
 assert.strictEqual(reallyLong.lastIndexOf(pattern), 0);
 
 // test truncation of Number arguments to uint8
@@ -599,7 +603,7 @@ assert.strictEqual(reallyLong.lastIndexOf(pattern), 0);
 
 // Test that Uint8Array arguments are okay.
 {
-  const needle = new Uint8Array([ 0x66, 0x6f, 0x6f ]);
+  const needle = new Uint8Array([0x66, 0x6f, 0x6f]);
   const haystack = Buffer.from('a foo b foo');
   assert.strictEqual(haystack.indexOf(needle), 2);
   assert.strictEqual(haystack.lastIndexOf(needle), haystack.length - 3);
diff --git a/test/parallel/test-buffer-inheritance.js b/test/parallel/test-buffer-inheritance.js
index 0798fe4a177c14..808cba40a05096 100644
--- a/test/parallel/test-buffer-inheritance.js
+++ b/test/parallel/test-buffer-inheritance.js
@@ -3,7 +3,6 @@
 require('../common');
 const assert = require('assert');
 
-
 function T(n) {
   const ui8 = new Uint8Array(n);
   Object.setPrototypeOf(ui8, T.prototype);
@@ -14,24 +13,23 @@ Object.setPrototypeOf(T, Buffer);
 
 T.prototype.sum = function sum() {
   let cntr = 0;
-  for (let i = 0; i < this.length; i++)
-    cntr += this[i];
+  for (let i = 0; i < this.length; i++) cntr += this[i];
   return cntr;
 };
 
-
 const vals = [new T(4), T(4)];
 
 vals.forEach(function(t) {
   assert.strictEqual(t.constructor, T);
   assert.strictEqual(Object.getPrototypeOf(t), T.prototype);
-  assert.strictEqual(Object.getPrototypeOf(Object.getPrototypeOf(t)),
-                     Buffer.prototype);
+  assert.strictEqual(
+    Object.getPrototypeOf(Object.getPrototypeOf(t)),
+    Buffer.prototype
+  );
 
   t.fill(5);
   let cntr = 0;
-  for (let i = 0; i < t.length; i++)
-    cntr += t[i];
+  for (let i = 0; i < t.length; i++) cntr += t[i];
   assert.strictEqual(t.length * 5, cntr);
 
   // Check this does not throw
diff --git a/test/parallel/test-buffer-iterator.js b/test/parallel/test-buffer-iterator.js
index 3120ff1d2ab457..91ede56a6fcc4f 100644
--- a/test/parallel/test-buffer-iterator.js
+++ b/test/parallel/test-buffer-iterator.js
@@ -10,53 +10,38 @@ let b;
 
 arr = [];
 
-for (b of buffer)
-  arr.push(b);
+for (b of buffer) arr.push(b);
 
 assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
 
-
 // buffer iterators should be iterable
 
 arr = [];
 
-for (b of buffer[Symbol.iterator]())
-  arr.push(b);
+for (b of buffer[Symbol.iterator]()) arr.push(b);
 
 assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
 
-
 // buffer#values() should return iterator for values
 
 arr = [];
 
-for (b of buffer.values())
-  arr.push(b);
+for (b of buffer.values()) arr.push(b);
 
 assert.deepStrictEqual(arr, [1, 2, 3, 4, 5]);
 
-
 // buffer#keys() should return iterator for keys
 
 arr = [];
 
-for (b of buffer.keys())
-  arr.push(b);
+for (b of buffer.keys()) arr.push(b);
 
 assert.deepStrictEqual(arr, [0, 1, 2, 3, 4]);
 
-
 // buffer#entries() should return iterator for entries
 
 arr = [];
 
-for (b of buffer.entries())
-  arr.push(b);
+for (b of buffer.entries()) arr.push(b);
 
-assert.deepStrictEqual(arr, [
-  [0, 1],
-  [1, 2],
-  [2, 3],
-  [3, 4],
-  [4, 5]
-]);
+assert.deepStrictEqual(arr, [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]]);
diff --git a/test/parallel/test-buffer-negative-length.js b/test/parallel/test-buffer-negative-length.js
index bf903b933d2689..4aefe24ec4ccbb 100644
--- a/test/parallel/test-buffer-negative-length.js
+++ b/test/parallel/test-buffer-negative-length.js
@@ -4,14 +4,19 @@ const common = require('../common');
 const assert = require('assert');
 const SlowBuffer = require('buffer').SlowBuffer;
 
-const bufferNegativeMsg = common.expectsError({
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: RangeError,
-  message: /^The value "[^"]*" is invalid for option "size"$/
-}, 5);
+const bufferNegativeMsg = common.expectsError(
+  {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: RangeError,
+    message: /^The value "[^"]*" is invalid for option "size"$/
+  },
+  5
+);
 assert.throws(() => Buffer(-1).toString('utf8'), bufferNegativeMsg);
 assert.throws(() => SlowBuffer(-1).toString('utf8'), bufferNegativeMsg);
 assert.throws(() => Buffer.alloc(-1).toString('utf8'), bufferNegativeMsg);
 assert.throws(() => Buffer.allocUnsafe(-1).toString('utf8'), bufferNegativeMsg);
-assert.throws(() => Buffer.allocUnsafeSlow(-1).toString('utf8'),
-              bufferNegativeMsg);
+assert.throws(
+  () => Buffer.allocUnsafeSlow(-1).toString('utf8'),
+  bufferNegativeMsg
+);
diff --git a/test/parallel/test-buffer-no-negative-allocation.js b/test/parallel/test-buffer-no-negative-allocation.js
index b34477aa8c4b45..317219cd0e7c10 100644
--- a/test/parallel/test-buffer-no-negative-allocation.js
+++ b/test/parallel/test-buffer-no-negative-allocation.js
@@ -3,11 +3,14 @@
 const common = require('../common');
 const assert = require('assert');
 
-const msg = common.expectsError({
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: RangeError,
-  message: /^The value "[^"]*" is invalid for option "size"$/
-}, 12);
+const msg = common.expectsError(
+  {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: RangeError,
+    message: /^The value "[^"]*" is invalid for option "size"$/
+  },
+  12
+);
 
 // Test that negative Buffer length inputs throw errors.
 
diff --git a/test/parallel/test-buffer-over-max-length.js b/test/parallel/test-buffer-over-max-length.js
index b1267b19ff439e..3eef3e2ee9491c 100644
--- a/test/parallel/test-buffer-over-max-length.js
+++ b/test/parallel/test-buffer-over-max-length.js
@@ -6,11 +6,14 @@ const buffer = require('buffer');
 const SlowBuffer = buffer.SlowBuffer;
 
 const kMaxLength = buffer.kMaxLength;
-const bufferMaxSizeMsg = common.expectsError({
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: RangeError,
-  message: /^The value "[^"]*" is invalid for option "size"$/
-}, 12);
+const bufferMaxSizeMsg = common.expectsError(
+  {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: RangeError,
+    message: /^The value "[^"]*" is invalid for option "size"$/
+  },
+  12
+);
 
 assert.throws(() => Buffer((-1 >>> 0) + 1), bufferMaxSizeMsg);
 assert.throws(() => SlowBuffer((-1 >>> 0) + 1), bufferMaxSizeMsg);
@@ -25,5 +28,5 @@ assert.throws(() => Buffer.allocUnsafe(kMaxLength + 1), bufferMaxSizeMsg);
 assert.throws(() => Buffer.allocUnsafeSlow(kMaxLength + 1), bufferMaxSizeMsg);
 
 // issue GH-4331
-assert.throws(() => Buffer.allocUnsafe(0xFFFFFFFF), bufferMaxSizeMsg);
-assert.throws(() => Buffer.allocUnsafe(0xFFFFFFFFF), bufferMaxSizeMsg);
+assert.throws(() => Buffer.allocUnsafe(0xffffffff), bufferMaxSizeMsg);
+assert.throws(() => Buffer.allocUnsafe(0xfffffffff), bufferMaxSizeMsg);
diff --git a/test/parallel/test-buffer-parent-property.js b/test/parallel/test-buffer-parent-property.js
index 5dae996b87feff..d4e756931faffd 100644
--- a/test/parallel/test-buffer-parent-property.js
+++ b/test/parallel/test-buffer-parent-property.js
@@ -10,10 +10,10 @@ require('../common');
 const assert = require('assert');
 
 // If the length of the buffer object is zero
-assert((new Buffer(0)).parent instanceof ArrayBuffer);
+assert(new Buffer(0).parent instanceof ArrayBuffer);
 
 // If the length of the buffer object is equal to the underlying ArrayBuffer
-assert((new Buffer(Buffer.poolSize)).parent instanceof ArrayBuffer);
+assert(new Buffer(Buffer.poolSize).parent instanceof ArrayBuffer);
 
 // Same as the previous test, but with user created buffer
 const arrayBuffer = new ArrayBuffer(0);
diff --git a/test/parallel/test-buffer-pending-deprecation.js b/test/parallel/test-buffer-pending-deprecation.js
index 1bb7b0bee19f9b..2fcbdfb9a05720 100644
--- a/test/parallel/test-buffer-pending-deprecation.js
+++ b/test/parallel/test-buffer-pending-deprecation.js
@@ -3,9 +3,10 @@
 
 const common = require('../common');
 
-const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
-                      'issues. Please use the Buffer.alloc(), ' +
-                      'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
+const bufferWarning =
+  'Buffer() is deprecated due to security and usability ' +
+  'issues. Please use the Buffer.alloc(), ' +
+  'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
 
 common.expectWarning('DeprecationWarning', bufferWarning, 'DEP0005');
 
diff --git a/test/parallel/test-buffer-read.js b/test/parallel/test-buffer-read.js
index 6f4ff3ca86f5e9..9d45a5a66be37d 100644
--- a/test/parallel/test-buffer-read.js
+++ b/test/parallel/test-buffer-read.js
@@ -7,18 +7,17 @@ const buf = Buffer.from([0xa4, 0xfd, 0x48, 0xea, 0xcf, 0xff, 0xd9, 0x01, 0xde]);
 
 function read(buff, funx, args, expected) {
   assert.strictEqual(buff[funx](...args), expected);
-  common.expectsError(
-    () => buff[funx](-1, args[1]),
-    { code: 'ERR_OUT_OF_RANGE' }
-  );
+  common.expectsError(() => buff[funx](-1, args[1]), {
+    code: 'ERR_OUT_OF_RANGE'
+  });
 }
 
 // testing basic functionality of readDoubleBE() and readDoubleLE()
-read(buf, 'readDoubleBE', [1], -3.1827727774563287e+295);
-read(buf, 'readDoubleLE', [1], -6.966010051009108e+144);
+read(buf, 'readDoubleBE', [1], -3.1827727774563287e295);
+read(buf, 'readDoubleLE', [1], -6.966010051009108e144);
 
 // testing basic functionality of readFloatBE() and readFloatLE()
-read(buf, 'readFloatBE', [1], -1.6691549692541768e+37);
+read(buf, 'readFloatBE', [1], -1.6691549692541768e37);
 read(buf, 'readFloatLE', [1], -7861303808);
 
 // testing basic functionality of readInt8()
@@ -52,55 +51,50 @@ read(buf, 'readUIntBE', [2, 2], 0x48ea);
 read(buf, 'readUIntLE', [2, 2], 0xea48);
 
 // Error name and message
-const OOR_ERROR =
-{
+const OOR_ERROR = {
   name: 'RangeError [ERR_OUT_OF_RANGE]'
 };
 
-const OOB_ERROR =
-{
+const OOB_ERROR = {
   name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
   message: 'Attempt to write outside buffer bounds'
 };
 
 // Attempt to overflow buffers, similar to previous bug in array buffers
-assert.throws(
-  () => Buffer.allocUnsafe(8).readFloatBE(0xffffffff), OOR_ERROR);
+assert.throws(() => Buffer.allocUnsafe(8).readFloatBE(0xffffffff), OOR_ERROR);
 
-assert.throws(
-  () => Buffer.allocUnsafe(8).readFloatLE(0xffffffff), OOR_ERROR);
+assert.throws(() => Buffer.allocUnsafe(8).readFloatLE(0xffffffff), OOR_ERROR);
 
 // Ensure negative values can't get past offset
-assert.throws(
-  () => Buffer.allocUnsafe(8).readFloatBE(-1), OOR_ERROR);
-assert.throws(
-  () => Buffer.allocUnsafe(8).readFloatLE(-1), OOR_ERROR);
+assert.throws(() => Buffer.allocUnsafe(8).readFloatBE(-1), OOR_ERROR);
+assert.throws(() => Buffer.allocUnsafe(8).readFloatLE(-1), OOR_ERROR);
 
 // Offset checks
 {
   const buf = Buffer.allocUnsafe(0);
 
-  assert.throws(
-    () => buf.readUInt8(0), OOB_ERROR);
-  assert.throws(
-    () => buf.readInt8(0), OOB_ERROR);
+  assert.throws(() => buf.readUInt8(0), OOB_ERROR);
+  assert.throws(() => buf.readInt8(0), OOB_ERROR);
 }
 
 [16, 32].forEach((bit) => {
   const buf = Buffer.allocUnsafe(bit / 8 - 1);
   [`Int${bit}B`, `Int${bit}L`, `UInt${bit}B`, `UInt${bit}L`].forEach((fn) => {
-    assert.throws(
-      () => buf[`read${fn}E`](0), OOB_ERROR);
+    assert.throws(() => buf[`read${fn}E`](0), OOB_ERROR);
   });
 });
 
 [16, 32].forEach((bits) => {
-  const buf = Buffer.from([0xFF, 0xFF, 0xFF, 0xFF]);
+  const buf = Buffer.from([0xff, 0xff, 0xff, 0xff]);
   ['LE', 'BE'].forEach((endian) => {
-    assert.strictEqual(buf[`readUInt${bits}${endian}`](0),
-                       (0xFFFFFFFF >>> (32 - bits)));
-
-    assert.strictEqual(buf[`readInt${bits}${endian}`](0),
-                       (0xFFFFFFFF >> (32 - bits)));
+    assert.strictEqual(
+      buf[`readUInt${bits}${endian}`](0),
+      0xffffffff >>> (32 - bits)
+    );
+
+    assert.strictEqual(
+      buf[`readInt${bits}${endian}`](0),
+      0xffffffff >> (32 - bits)
+    );
   });
 });
diff --git a/test/parallel/test-buffer-readdouble.js b/test/parallel/test-buffer-readdouble.js
index a61ab352c12d0f..8f3119a6cc3581 100644
--- a/test/parallel/test-buffer-readdouble.js
+++ b/test/parallel/test-buffer-readdouble.js
@@ -14,7 +14,7 @@ buffer[4] = 0x55;
 buffer[5] = 0x55;
 buffer[6] = 0xd5;
 buffer[7] = 0x3f;
-assert.strictEqual(buffer.readDoubleBE(0), 1.1945305291680097e+103);
+assert.strictEqual(buffer.readDoubleBE(0), 1.1945305291680097e103);
 assert.strictEqual(buffer.readDoubleLE(0), 0.3333333333333333);
 
 buffer[0] = 1;
@@ -52,7 +52,7 @@ assert.strictEqual(buffer.readDoubleLE(0), 2.225073858507201e-308);
 buffer[6] = 0xef;
 buffer[7] = 0x7f;
 assert.ok(Number.isNaN(buffer.readDoubleBE(0)));
-assert.strictEqual(buffer.readDoubleLE(0), 1.7976931348623157e+308);
+assert.strictEqual(buffer.readDoubleLE(0), 1.7976931348623157e308);
 
 buffer[0] = 0;
 buffer[1] = 0;
@@ -99,45 +99,37 @@ assert.strictEqual(buffer.readDoubleBE(0), 3.04814e-319);
 assert.strictEqual(buffer.readDoubleLE(0), -Infinity);
 
 ['readDoubleLE', 'readDoubleBE'].forEach((fn) => {
-
   // Verify that default offset works fine.
   buffer[fn](undefined);
   buffer[fn]();
 
   ['', '0', null, {}, [], () => {}, true, false].forEach((off) => {
-    assert.throws(
-      () => buffer[fn](off),
-      { code: 'ERR_INVALID_ARG_TYPE' }
-    );
+    assert.throws(() => buffer[fn](off), { code: 'ERR_INVALID_ARG_TYPE' });
   });
 
   [Infinity, -1, 1].forEach((offset) => {
-    assert.throws(
-      () => buffer[fn](offset),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "offset" is out of range. ' +
-                 `It must be >= 0 and <= 0. Received ${offset}`
-      });
+    assert.throws(() => buffer[fn](offset), {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError [ERR_OUT_OF_RANGE]',
+      message:
+        'The value of "offset" is out of range. ' +
+        `It must be >= 0 and <= 0. Received ${offset}`
+    });
   });
 
-  assert.throws(
-    () => Buffer.alloc(1)[fn](1),
-    {
-      code: 'ERR_BUFFER_OUT_OF_BOUNDS',
-      name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
-      message: 'Attempt to write outside buffer bounds'
-    });
+  assert.throws(() => Buffer.alloc(1)[fn](1), {
+    code: 'ERR_BUFFER_OUT_OF_BOUNDS',
+    name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
+    message: 'Attempt to write outside buffer bounds'
+  });
 
   [NaN, 1.01].forEach((offset) => {
-    assert.throws(
-      () => buffer[fn](offset),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "offset" is out of range. ' +
-                 `It must be an integer. Received ${offset}`
-      });
+    assert.throws(() => buffer[fn](offset), {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError [ERR_OUT_OF_RANGE]',
+      message:
+        'The value of "offset" is out of range. ' +
+        `It must be an integer. Received ${offset}`
+    });
   });
 });
diff --git a/test/parallel/test-buffer-readfloat.js b/test/parallel/test-buffer-readfloat.js
index e6bb779804e9bb..106e11f5ce8123 100644
--- a/test/parallel/test-buffer-readfloat.js
+++ b/test/parallel/test-buffer-readfloat.js
@@ -25,7 +25,7 @@ buffer[1] = 0xff;
 buffer[2] = 0x7f;
 buffer[3] = 0x7f;
 assert.ok(Number.isNaN(buffer.readFloatBE(0)));
-assert.strictEqual(buffer.readFloatLE(0), 3.4028234663852886e+38);
+assert.strictEqual(buffer.readFloatLE(0), 3.4028234663852886e38);
 
 buffer[0] = 0xab;
 buffer[1] = 0xaa;
@@ -62,45 +62,37 @@ assert.strictEqual(buffer.readFloatBE(0), 4.627507918739843e-41);
 assert.strictEqual(buffer.readFloatLE(0), -Infinity);
 
 ['readFloatLE', 'readFloatBE'].forEach((fn) => {
-
   // Verify that default offset works fine.
   buffer[fn](undefined);
   buffer[fn]();
 
   ['', '0', null, {}, [], () => {}, true, false].forEach((off) => {
-    assert.throws(
-      () => buffer[fn](off),
-      { code: 'ERR_INVALID_ARG_TYPE' }
-    );
+    assert.throws(() => buffer[fn](off), { code: 'ERR_INVALID_ARG_TYPE' });
   });
 
   [Infinity, -1, 1].forEach((offset) => {
-    assert.throws(
-      () => buffer[fn](offset),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "offset" is out of range. ' +
-                 `It must be >= 0 and <= 0. Received ${offset}`
-      });
+    assert.throws(() => buffer[fn](offset), {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError [ERR_OUT_OF_RANGE]',
+      message:
+        'The value of "offset" is out of range. ' +
+        `It must be >= 0 and <= 0. Received ${offset}`
+    });
   });
 
-  assert.throws(
-    () => Buffer.alloc(1)[fn](1),
-    {
-      code: 'ERR_BUFFER_OUT_OF_BOUNDS',
-      name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
-      message: 'Attempt to write outside buffer bounds'
-    });
+  assert.throws(() => Buffer.alloc(1)[fn](1), {
+    code: 'ERR_BUFFER_OUT_OF_BOUNDS',
+    name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
+    message: 'Attempt to write outside buffer bounds'
+  });
 
   [NaN, 1.01].forEach((offset) => {
-    assert.throws(
-      () => buffer[fn](offset),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "offset" is out of range. ' +
-                 `It must be an integer. Received ${offset}`
-      });
+    assert.throws(() => buffer[fn](offset), {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError [ERR_OUT_OF_RANGE]',
+      message:
+        'The value of "offset" is out of range. ' +
+        `It must be an integer. Received ${offset}`
+    });
   });
 });
diff --git a/test/parallel/test-buffer-readint.js b/test/parallel/test-buffer-readint.js
index 971dd3bb959444..fa228e65334b53 100644
--- a/test/parallel/test-buffer-readint.js
+++ b/test/parallel/test-buffer-readint.js
@@ -8,38 +8,32 @@ const assert = require('assert');
   const buffer = Buffer.alloc(4);
 
   ['Int8', 'Int16BE', 'Int16LE', 'Int32BE', 'Int32LE'].forEach((fn) => {
-
     // Verify that default offset works fine.
     buffer[`read${fn}`](undefined);
     buffer[`read${fn}`]();
 
     ['', '0', null, {}, [], () => {}, true, false].forEach((o) => {
-      assert.throws(
-        () => buffer[`read${fn}`](o),
-        {
-          code: 'ERR_INVALID_ARG_TYPE',
-          name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-        });
+      assert.throws(() => buffer[`read${fn}`](o), {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+      });
     });
 
     [Infinity, -1, -4294967295].forEach((offset) => {
-      assert.throws(
-        () => buffer[`read${fn}`](offset),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]'
-        });
+      assert.throws(() => buffer[`read${fn}`](offset), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]'
+      });
     });
 
     [NaN, 1.01].forEach((offset) => {
-      assert.throws(
-        () => buffer[`read${fn}`](offset),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "offset" is out of range. ' +
-                   `It must be an integer. Received ${offset}`
-        });
+      assert.throws(() => buffer[`read${fn}`](offset), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "offset" is out of range. ' +
+          `It must be an integer. Received ${offset}`
+      });
     });
   });
 }
@@ -132,30 +126,26 @@ const assert = require('assert');
   // Check byteLength.
   ['readIntBE', 'readIntLE'].forEach((fn) => {
     ['', '0', null, {}, [], () => {}, true, false, undefined].forEach((len) => {
-      assert.throws(
-        () => buffer[fn](0, len),
-        { code: 'ERR_INVALID_ARG_TYPE' });
+      assert.throws(() => buffer[fn](0, len), { code: 'ERR_INVALID_ARG_TYPE' });
     });
 
     [Infinity, -1].forEach((byteLength) => {
-      assert.throws(
-        () => buffer[fn](0, byteLength),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          message: 'The value of "byteLength" is out of range. ' +
-                   `It must be >= 1 and <= 6. Received ${byteLength}`
-        });
+      assert.throws(() => buffer[fn](0, byteLength), {
+        code: 'ERR_OUT_OF_RANGE',
+        message:
+          'The value of "byteLength" is out of range. ' +
+          `It must be >= 1 and <= 6. Received ${byteLength}`
+      });
     });
 
     [NaN, 1.01].forEach((byteLength) => {
-      assert.throws(
-        () => buffer[fn](0, byteLength),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "byteLength" is out of range. ' +
-                   `It must be an integer. Received ${byteLength}`
-        });
+      assert.throws(() => buffer[fn](0, byteLength), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "byteLength" is out of range. ' +
+          `It must be an integer. Received ${byteLength}`
+      });
     });
   });
 
@@ -163,34 +153,30 @@ const assert = require('assert');
   for (let i = 1; i <= 6; i++) {
     ['readIntBE', 'readIntLE'].forEach((fn) => {
       ['', '0', null, {}, [], () => {}, true, false, undefined].forEach((o) => {
-        assert.throws(
-          () => buffer[fn](o, i),
-          {
-            code: 'ERR_INVALID_ARG_TYPE',
-            name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-          });
+        assert.throws(() => buffer[fn](o, i), {
+          code: 'ERR_INVALID_ARG_TYPE',
+          name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+        });
       });
 
       [Infinity, -1, -4294967295].forEach((offset) => {
-        assert.throws(
-          () => buffer[fn](offset, i),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            name: 'RangeError [ERR_OUT_OF_RANGE]',
-            message: 'The value of "offset" is out of range. ' +
-                     `It must be >= 0 and <= ${8 - i}. Received ${offset}`
-          });
+        assert.throws(() => buffer[fn](offset, i), {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "offset" is out of range. ' +
+            `It must be >= 0 and <= ${8 - i}. Received ${offset}`
+        });
       });
 
       [NaN, 1.01].forEach((offset) => {
-        assert.throws(
-          () => buffer[fn](offset, i),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            name: 'RangeError [ERR_OUT_OF_RANGE]',
-            message: 'The value of "offset" is out of range. ' +
-                     `It must be an integer. Received ${offset}`
-          });
+        assert.throws(() => buffer[fn](offset, i), {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "offset" is out of range. ' +
+            `It must be an integer. Received ${offset}`
+        });
       });
     });
   }
diff --git a/test/parallel/test-buffer-readuint.js b/test/parallel/test-buffer-readuint.js
index f532febd0faf19..7d1c78fc201359 100644
--- a/test/parallel/test-buffer-readuint.js
+++ b/test/parallel/test-buffer-readuint.js
@@ -8,38 +8,32 @@ const assert = require('assert');
   const buffer = Buffer.alloc(4);
 
   ['UInt8', 'UInt16BE', 'UInt16LE', 'UInt32BE', 'UInt32LE'].forEach((fn) => {
-
     // Verify that default offset works fine.
     buffer[`read${fn}`](undefined);
     buffer[`read${fn}`]();
 
     ['', '0', null, {}, [], () => {}, true, false].forEach((o) => {
-      assert.throws(
-        () => buffer[`read${fn}`](o),
-        {
-          code: 'ERR_INVALID_ARG_TYPE',
-          name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-        });
+      assert.throws(() => buffer[`read${fn}`](o), {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+      });
     });
 
     [Infinity, -1, -4294967295].forEach((offset) => {
-      assert.throws(
-        () => buffer[`read${fn}`](offset),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]'
-        });
+      assert.throws(() => buffer[`read${fn}`](offset), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]'
+      });
     });
 
     [NaN, 1.01].forEach((offset) => {
-      assert.throws(
-        () => buffer[`read${fn}`](offset),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "offset" is out of range. ' +
-                   `It must be an integer. Received ${offset}`
-        });
+      assert.throws(() => buffer[`read${fn}`](offset), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "offset" is out of range. ' +
+          `It must be an integer. Received ${offset}`
+      });
     });
   });
 }
@@ -100,30 +94,26 @@ const assert = require('assert');
   // Check byteLength.
   ['readUIntBE', 'readUIntLE'].forEach((fn) => {
     ['', '0', null, {}, [], () => {}, true, false, undefined].forEach((len) => {
-      assert.throws(
-        () => buffer[fn](0, len),
-        { code: 'ERR_INVALID_ARG_TYPE' });
+      assert.throws(() => buffer[fn](0, len), { code: 'ERR_INVALID_ARG_TYPE' });
     });
 
     [Infinity, -1].forEach((byteLength) => {
-      assert.throws(
-        () => buffer[fn](0, byteLength),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          message: 'The value of "byteLength" is out of range. ' +
-                   `It must be >= 1 and <= 6. Received ${byteLength}`
-        });
+      assert.throws(() => buffer[fn](0, byteLength), {
+        code: 'ERR_OUT_OF_RANGE',
+        message:
+          'The value of "byteLength" is out of range. ' +
+          `It must be >= 1 and <= 6. Received ${byteLength}`
+      });
     });
 
     [NaN, 1.01].forEach((byteLength) => {
-      assert.throws(
-        () => buffer[fn](0, byteLength),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "byteLength" is out of range. ' +
-                   `It must be an integer. Received ${byteLength}`
-        });
+      assert.throws(() => buffer[fn](0, byteLength), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "byteLength" is out of range. ' +
+          `It must be an integer. Received ${byteLength}`
+      });
     });
   });
 
@@ -131,34 +121,30 @@ const assert = require('assert');
   for (let i = 1; i <= 6; i++) {
     ['readUIntBE', 'readUIntLE'].forEach((fn) => {
       ['', '0', null, {}, [], () => {}, true, false, undefined].forEach((o) => {
-        assert.throws(
-          () => buffer[fn](o, i),
-          {
-            code: 'ERR_INVALID_ARG_TYPE',
-            name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-          });
+        assert.throws(() => buffer[fn](o, i), {
+          code: 'ERR_INVALID_ARG_TYPE',
+          name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+        });
       });
 
       [Infinity, -1, -4294967295].forEach((offset) => {
-        assert.throws(
-          () => buffer[fn](offset, i),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            name: 'RangeError [ERR_OUT_OF_RANGE]',
-            message: 'The value of "offset" is out of range. ' +
-                     `It must be >= 0 and <= ${8 - i}. Received ${offset}`
-          });
+        assert.throws(() => buffer[fn](offset, i), {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "offset" is out of range. ' +
+            `It must be >= 0 and <= ${8 - i}. Received ${offset}`
+        });
       });
 
       [NaN, 1.01].forEach((offset) => {
-        assert.throws(
-          () => buffer[fn](offset, i),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            name: 'RangeError [ERR_OUT_OF_RANGE]',
-            message: 'The value of "offset" is out of range. ' +
-                     `It must be an integer. Received ${offset}`
-          });
+        assert.throws(() => buffer[fn](offset, i), {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "offset" is out of range. ' +
+            `It must be an integer. Received ${offset}`
+        });
       });
     });
   }
diff --git a/test/parallel/test-buffer-safe-unsafe.js b/test/parallel/test-buffer-safe-unsafe.js
index 9f8b6b7410b8fb..7d06fb4e0f07d5 100644
--- a/test/parallel/test-buffer-safe-unsafe.js
+++ b/test/parallel/test-buffer-safe-unsafe.js
@@ -6,8 +6,7 @@ const assert = require('assert');
 const safe = Buffer.alloc(10);
 
 function isZeroFilled(buf) {
-  for (let n = 0; n < buf.length; n++)
-    if (buf[n] !== 0) return false;
+  for (let n = 0; n < buf.length; n++) if (buf[n] !== 0) return false;
   return true;
 }
 
diff --git a/test/parallel/test-buffer-slice.js b/test/parallel/test-buffer-slice.js
index f40a495b206079..0e72404b08964b 100644
--- a/test/parallel/test-buffer-slice.js
+++ b/test/parallel/test-buffer-slice.js
@@ -83,8 +83,12 @@ assert.strictEqual(Buffer.alloc(0).slice(0, 1).length, 0);
 
 {
   // Single argument slice
-  assert.strictEqual(Buffer.from('abcde', 'utf8').slice(1).toString('utf8'),
-                     'bcde');
+  assert.strictEqual(
+    Buffer.from('abcde', 'utf8')
+      .slice(1)
+      .toString('utf8'),
+    'bcde'
+  );
 }
 
 // slice(0,0).length === 0
@@ -94,16 +98,15 @@ assert.strictEqual(Buffer.from('hello', 'utf8').slice(0, 0).length, 0);
   // Regression tests for https://github.com/nodejs/node/issues/9096
   const buf = Buffer.from('abcd', 'utf8');
   assert.strictEqual(buf.slice(buf.length / 3).toString('utf8'), 'bcd');
-  assert.strictEqual(
-    buf.slice(buf.length / 3, buf.length).toString(),
-    'bcd'
-  );
+  assert.strictEqual(buf.slice(buf.length / 3, buf.length).toString(), 'bcd');
 }
 
 {
   const buf = Buffer.from('abcdefg', 'utf8');
-  assert.strictEqual(buf.slice(-(-1 >>> 0) - 1).toString('utf8'),
-                     buf.toString('utf8'));
+  assert.strictEqual(
+    buf.slice(-(-1 >>> 0) - 1).toString('utf8'),
+    buf.toString('utf8')
+  );
 }
 
 {
@@ -113,15 +116,50 @@ assert.strictEqual(Buffer.from('hello', 'utf8').slice(0, 0).length, 0);
 
 {
   const buf = Buffer.from([
-    1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0,
-    0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0
+    1,
+    29,
+    0,
+    0,
+    1,
+    143,
+    216,
+    162,
+    92,
+    254,
+    248,
+    63,
+    0,
+    0,
+    0,
+    18,
+    184,
+    6,
+    0,
+    175,
+    29,
+    0,
+    8,
+    11,
+    1,
+    0,
+    0
   ]);
   const chunk1 = Buffer.from([
-    1, 29, 0, 0, 1, 143, 216, 162, 92, 254, 248, 63, 0
-  ]);
-  const chunk2 = Buffer.from([
-    0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0
+    1,
+    29,
+    0,
+    0,
+    1,
+    143,
+    216,
+    162,
+    92,
+    254,
+    248,
+    63,
+    0
   ]);
+  const chunk2 = Buffer.from([0, 0, 18, 184, 6, 0, 175, 29, 0, 8, 11, 1, 0, 0]);
   const middle = buf.length / 2;
 
   assert.deepStrictEqual(buf.slice(0, middle), chunk1);
diff --git a/test/parallel/test-buffer-slow.js b/test/parallel/test-buffer-slow.js
index e41dd1dd0fd3a0..98f70f93264272 100644
--- a/test/parallel/test-buffer-slow.js
+++ b/test/parallel/test-buffer-slow.js
@@ -31,8 +31,7 @@ for (const [key, value] of sb.entries()) {
 // should work with edge cases
 assert.strictEqual(SlowBuffer(0).length, 0);
 try {
-  assert.strictEqual(
-    SlowBuffer(buffer.kMaxLength).length, buffer.kMaxLength);
+  assert.strictEqual(SlowBuffer(buffer.kMaxLength).length, buffer.kMaxLength);
 } catch (e) {
   // Don't match on message as it is from the JavaScript engine. V8 and
   // ChakraCore provide different messages.
@@ -50,21 +49,27 @@ assert.strictEqual(SlowBuffer({}).length, 0);
 assert.strictEqual(SlowBuffer('string').length, 0);
 
 // should throw with invalid length
-const bufferMaxSizeMsg = common.expectsError({
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: RangeError,
-  message: /^The value "[^"]*" is invalid for option "size"$/
-}, 2);
+const bufferMaxSizeMsg = common.expectsError(
+  {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: RangeError,
+    message: /^The value "[^"]*" is invalid for option "size"$/
+  },
+  2
+);
 assert.throws(function() {
   SlowBuffer(Infinity);
 }, bufferMaxSizeMsg);
-common.expectsError(function() {
-  SlowBuffer(-1);
-}, {
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: RangeError,
-  message: 'The value "-1" is invalid for option "size"'
-});
+common.expectsError(
+  function() {
+    SlowBuffer(-1);
+  },
+  {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: RangeError,
+    message: 'The value "-1" is invalid for option "size"'
+  }
+);
 
 assert.throws(function() {
   SlowBuffer(buffer.kMaxLength + 1);
diff --git a/test/parallel/test-buffer-swap.js b/test/parallel/test-buffer-swap.js
index 82b550790e7232..1129eeddc5265b 100644
--- a/test/parallel/test-buffer-swap.js
+++ b/test/parallel/test-buffer-swap.js
@@ -5,25 +5,95 @@ const assert = require('assert');
 
 // Test buffers small enough to use the JS implementation
 {
-  const buf = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
-                           0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]);
+  const buf = Buffer.from([
+    0x01,
+    0x02,
+    0x03,
+    0x04,
+    0x05,
+    0x06,
+    0x07,
+    0x08,
+    0x09,
+    0x0a,
+    0x0b,
+    0x0c,
+    0x0d,
+    0x0e,
+    0x0f,
+    0x10
+  ]);
 
   assert.strictEqual(buf, buf.swap16());
-  assert.deepStrictEqual(buf, Buffer.from([0x02, 0x01, 0x04, 0x03, 0x06, 0x05,
-                                           0x08, 0x07, 0x0a, 0x09, 0x0c, 0x0b,
-                                           0x0e, 0x0d, 0x10, 0x0f]));
+  assert.deepStrictEqual(
+    buf,
+    Buffer.from([
+      0x02,
+      0x01,
+      0x04,
+      0x03,
+      0x06,
+      0x05,
+      0x08,
+      0x07,
+      0x0a,
+      0x09,
+      0x0c,
+      0x0b,
+      0x0e,
+      0x0d,
+      0x10,
+      0x0f
+    ])
+  );
   buf.swap16(); // restore
 
   assert.strictEqual(buf, buf.swap32());
-  assert.deepStrictEqual(buf, Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07,
-                                           0x06, 0x05, 0x0c, 0x0b, 0x0a, 0x09,
-                                           0x10, 0x0f, 0x0e, 0x0d]));
+  assert.deepStrictEqual(
+    buf,
+    Buffer.from([
+      0x04,
+      0x03,
+      0x02,
+      0x01,
+      0x08,
+      0x07,
+      0x06,
+      0x05,
+      0x0c,
+      0x0b,
+      0x0a,
+      0x09,
+      0x10,
+      0x0f,
+      0x0e,
+      0x0d
+    ])
+  );
   buf.swap32(); // restore
 
   assert.strictEqual(buf, buf.swap64());
-  assert.deepStrictEqual(buf, Buffer.from([0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
-                                           0x02, 0x01, 0x10, 0x0f, 0x0e, 0x0d,
-                                           0x0c, 0x0b, 0x0a, 0x09]));
+  assert.deepStrictEqual(
+    buf,
+    Buffer.from([
+      0x08,
+      0x07,
+      0x06,
+      0x05,
+      0x04,
+      0x03,
+      0x02,
+      0x01,
+      0x10,
+      0x0f,
+      0x0e,
+      0x0d,
+      0x0c,
+      0x0b,
+      0x0a,
+      0x09
+    ])
+  );
 }
 
 // Operates in-place
@@ -49,19 +119,80 @@ const assert = require('assert');
 }
 
 {
-  const buf = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-                           0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]);
+  const buf = Buffer.from([
+    0x01,
+    0x02,
+    0x03,
+    0x04,
+    0x05,
+    0x06,
+    0x07,
+    0x08,
+    0x09,
+    0x0a,
+    0x0b,
+    0x0c,
+    0x0d,
+    0x0e,
+    0x0f,
+    0x10,
+    0x01,
+    0x02,
+    0x03,
+    0x04,
+    0x05,
+    0x06,
+    0x07,
+    0x08,
+    0x09,
+    0x0a,
+    0x0b,
+    0x0c,
+    0x0d,
+    0x0e,
+    0x0f,
+    0x10
+  ]);
 
   buf.slice(2, 18).swap64();
 
-  assert.deepStrictEqual(buf, Buffer.from([0x01, 0x02, 0x0a, 0x09, 0x08, 0x07,
-                                           0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
-                                           0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b,
-                                           0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                                           0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
-                                           0x0f, 0x10]));
+  assert.deepStrictEqual(
+    buf,
+    Buffer.from([
+      0x01,
+      0x02,
+      0x0a,
+      0x09,
+      0x08,
+      0x07,
+      0x06,
+      0x05,
+      0x04,
+      0x03,
+      0x02,
+      0x01,
+      0x10,
+      0x0f,
+      0x0e,
+      0x0d,
+      0x0c,
+      0x0b,
+      0x03,
+      0x04,
+      0x05,
+      0x06,
+      0x07,
+      0x08,
+      0x09,
+      0x0a,
+      0x0b,
+      0x0c,
+      0x0d,
+      0x0e,
+      0x0f,
+      0x10
+    ])
+  );
 }
 
 // Force use of native code (Buffer size above threshold limit for js impl)
diff --git a/test/parallel/test-buffer-tojson.js b/test/parallel/test-buffer-tojson.js
index d9a4a85e812cfb..773095c985d7e1 100644
--- a/test/parallel/test-buffer-tojson.js
+++ b/test/parallel/test-buffer-tojson.js
@@ -4,10 +4,14 @@ require('../common');
 const assert = require('assert');
 
 {
-  assert.strictEqual(JSON.stringify(Buffer.alloc(0)),
-                     '{"type":"Buffer","data":[]}');
-  assert.strictEqual(JSON.stringify(Buffer.from([1, 2, 3, 4])),
-                     '{"type":"Buffer","data":[1,2,3,4]}');
+  assert.strictEqual(
+    JSON.stringify(Buffer.alloc(0)),
+    '{"type":"Buffer","data":[]}'
+  );
+  assert.strictEqual(
+    JSON.stringify(Buffer.from([1, 2, 3, 4])),
+    '{"type":"Buffer","data":[1,2,3,4]}'
+  );
 }
 
 // issue GH-7849
diff --git a/test/parallel/test-buffer-tostring-range.js b/test/parallel/test-buffer-tostring-range.js
index f6ee846dd8ef34..83fd2843424090 100644
--- a/test/parallel/test-buffer-tostring-range.js
+++ b/test/parallel/test-buffer-tostring-range.js
@@ -79,22 +79,33 @@ assert.strictEqual(rangeBuffer.toString('ascii', 0, 1.99), 'a');
 assert.strictEqual(rangeBuffer.toString('ascii', 0, true), 'a');
 
 // try toString() with a object as a encoding
-assert.strictEqual(rangeBuffer.toString({ toString: function() {
-  return 'ascii';
-} }), 'abc');
+assert.strictEqual(
+  rangeBuffer.toString({
+    toString: function() {
+      return 'ascii';
+    }
+  }),
+  'abc'
+);
 
 // try toString() with 0 and null as the encoding
-common.expectsError(() => {
-  rangeBuffer.toString(0, 1, 2);
-}, {
-  code: 'ERR_UNKNOWN_ENCODING',
-  type: TypeError,
-  message: 'Unknown encoding: 0'
-});
-common.expectsError(() => {
-  rangeBuffer.toString(null, 1, 2);
-}, {
-  code: 'ERR_UNKNOWN_ENCODING',
-  type: TypeError,
-  message: 'Unknown encoding: null'
-});
+common.expectsError(
+  () => {
+    rangeBuffer.toString(0, 1, 2);
+  },
+  {
+    code: 'ERR_UNKNOWN_ENCODING',
+    type: TypeError,
+    message: 'Unknown encoding: 0'
+  }
+);
+common.expectsError(
+  () => {
+    rangeBuffer.toString(null, 1, 2);
+  },
+  {
+    code: 'ERR_UNKNOWN_ENCODING',
+    type: TypeError,
+    message: 'Unknown encoding: null'
+  }
+);
diff --git a/test/parallel/test-buffer-tostring-rangeerror.js b/test/parallel/test-buffer-tostring-rangeerror.js
index ccfb40bee75a40..8ff8bae7bb13bf 100644
--- a/test/parallel/test-buffer-tostring-rangeerror.js
+++ b/test/parallel/test-buffer-tostring-rangeerror.js
@@ -9,11 +9,14 @@ const assert = require('assert');
 const SlowBuffer = require('buffer').SlowBuffer;
 
 const len = 1422561062959;
-const message = common.expectsError({
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: RangeError,
-  message: /^The value "[^"]*" is invalid for option "size"$/
-}, 5);
+const message = common.expectsError(
+  {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: RangeError,
+    message: /^The value "[^"]*" is invalid for option "size"$/
+  },
+  5
+);
 assert.throws(() => Buffer(len).toString('utf8'), message);
 assert.throws(() => SlowBuffer(len).toString('utf8'), message);
 assert.throws(() => Buffer.alloc(len).toString('utf8'), message);
diff --git a/test/parallel/test-buffer-tostring.js b/test/parallel/test-buffer-tostring.js
index 7ea7ce8539f3a4..0f3172eb13a4d3 100644
--- a/test/parallel/test-buffer-tostring.js
+++ b/test/parallel/test-buffer-tostring.js
@@ -4,8 +4,17 @@ const common = require('../common');
 const assert = require('assert');
 
 // utf8, ucs2, ascii, latin1, utf16le
-const encodings = ['utf8', 'utf-8', 'ucs2', 'ucs-2', 'ascii', 'latin1',
-                   'binary', 'utf16le', 'utf-16le'];
+const encodings = [
+  'utf8',
+  'utf-8',
+  'ucs2',
+  'ucs-2',
+  'ascii',
+  'latin1',
+  'binary',
+  'utf16le',
+  'utf-16le'
+];
 
 encodings
   .reduce((es, e) => es.concat(e, e.toUpperCase()), [])
@@ -20,8 +29,10 @@ encodings
 
 // hex
 ['hex', 'HEX'].forEach((encoding) => {
-  assert.strictEqual(Buffer.from('666f6f', encoding).toString(encoding),
-                     '666f6f');
+  assert.strictEqual(
+    Buffer.from('666f6f', encoding).toString(encoding),
+    '666f6f'
+  );
 });
 
 // Invalid encodings
diff --git a/test/parallel/test-buffer-write.js b/test/parallel/test-buffer-write.js
index c0c5e9c88fbc6c..894fbaa1e73d47 100644
--- a/test/parallel/test-buffer-write.js
+++ b/test/parallel/test-buffer-write.js
@@ -3,11 +3,14 @@
 const common = require('../common');
 const assert = require('assert');
 
-const outsideBounds = common.expectsError({
-  code: 'ERR_BUFFER_OUT_OF_BOUNDS',
-  type: RangeError,
-  message: 'Attempt to write outside buffer bounds'
-}, 2);
+const outsideBounds = common.expectsError(
+  {
+    code: 'ERR_BUFFER_OUT_OF_BOUNDS',
+    type: RangeError,
+    message: 'Attempt to write outside buffer bounds'
+  },
+  2
+);
 
 assert.throws(() => Buffer.alloc(9).write('foo', -1), outsideBounds);
 assert.throws(() => Buffer.alloc(9).write('foo', 10), outsideBounds);
@@ -24,8 +27,17 @@ const resultMap = new Map([
 ]);
 
 // utf8, ucs2, ascii, latin1, utf16le
-const encodings = ['utf8', 'utf-8', 'ucs2', 'ucs-2', 'ascii', 'latin1',
-                   'binary', 'utf16le', 'utf-16le'];
+const encodings = [
+  'utf8',
+  'utf-8',
+  'ucs2',
+  'ucs-2',
+  'ascii',
+  'latin1',
+  'binary',
+  'utf16le',
+  'utf-16le'
+];
 
 encodings
   .reduce((es, e) => es.concat(e, e.toUpperCase()), [])
@@ -34,8 +46,7 @@ encodings
     const len = Buffer.byteLength('foo', encoding);
     assert.strictEqual(buf.write('foo', 0, len, encoding), len);
 
-    if (encoding.includes('-'))
-      encoding = encoding.replace('-', '');
+    if (encoding.includes('-')) encoding = encoding.replace('-', '');
 
     assert.deepStrictEqual(buf, resultMap.get(encoding.toLowerCase()));
   });
@@ -89,5 +100,7 @@ assert.strictEqual(z.write('\u0001', 3, 'ucs2'), 0);
 assert.strictEqual(Buffer.compare(z, Buffer.alloc(4, 0)), 0);
 
 // Large overrun could corrupt the process
-assert.strictEqual(Buffer.alloc(4)
-  .write('ыыыыыы'.repeat(100), 3, 'utf16le'), 0);
+assert.strictEqual(
+  Buffer.alloc(4).write('ыыыыыы'.repeat(100), 3, 'utf16le'),
+  0
+);
diff --git a/test/parallel/test-buffer-writedouble.js b/test/parallel/test-buffer-writedouble.js
index 8a17d536909dce..69121ae0350a74 100644
--- a/test/parallel/test-buffer-writedouble.js
+++ b/test/parallel/test-buffer-writedouble.js
@@ -9,46 +9,154 @@ const buffer = Buffer.allocUnsafe(16);
 
 buffer.writeDoubleBE(2.225073858507201e-308, 0);
 buffer.writeDoubleLE(2.225073858507201e-308, 8);
-assert.ok(buffer.equals(new Uint8Array([
-  0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00
-])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([
+      0x00,
+      0x0f,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0x0f,
+      0x00
+    ])
+  )
+);
 
 buffer.writeDoubleBE(1.0000000000000004, 0);
 buffer.writeDoubleLE(1.0000000000000004, 8);
-assert.ok(buffer.equals(new Uint8Array([
-  0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
-  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f
-])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([
+      0x3f,
+      0xf0,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x02,
+      0x02,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0xf0,
+      0x3f
+    ])
+  )
+);
 
 buffer.writeDoubleBE(-2, 0);
 buffer.writeDoubleLE(-2, 8);
-assert.ok(buffer.equals(new Uint8Array([
-  0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0
-])));
-
-buffer.writeDoubleBE(1.7976931348623157e+308, 0);
-buffer.writeDoubleLE(1.7976931348623157e+308, 8);
-assert.ok(buffer.equals(new Uint8Array([
-  0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0x7f
-])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([
+      0xc0,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0xc0
+    ])
+  )
+);
+
+buffer.writeDoubleBE(1.7976931348623157e308, 0);
+buffer.writeDoubleLE(1.7976931348623157e308, 8);
+assert.ok(
+  buffer.equals(
+    new Uint8Array([
+      0x7f,
+      0xef,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xef,
+      0x7f
+    ])
+  )
+);
 
 buffer.writeDoubleBE(0 * -1, 0);
 buffer.writeDoubleLE(0 * -1, 8);
-assert.ok(buffer.equals(new Uint8Array([
-  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
-])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([
+      0x80,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x80
+    ])
+  )
+);
 
 buffer.writeDoubleBE(Infinity, 0);
 buffer.writeDoubleLE(Infinity, 8);
 
-assert.ok(buffer.equals(new Uint8Array([
-  0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x7F
-])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([
+      0x7f,
+      0xf0,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0xf0,
+      0x7f
+    ])
+  )
+);
 
 assert.strictEqual(buffer.readDoubleBE(0), Infinity);
 assert.strictEqual(buffer.readDoubleLE(8), Infinity);
@@ -56,10 +164,28 @@ assert.strictEqual(buffer.readDoubleLE(8), Infinity);
 buffer.writeDoubleBE(-Infinity, 0);
 buffer.writeDoubleLE(-Infinity, 8);
 
-assert.ok(buffer.equals(new Uint8Array([
-  0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF
-])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([
+      0xff,
+      0xf0,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0xf0,
+      0xff
+    ])
+  )
+);
 
 assert.strictEqual(buffer.readDoubleBE(0), -Infinity);
 assert.strictEqual(buffer.readDoubleLE(8), -Infinity);
@@ -69,16 +195,52 @@ buffer.writeDoubleLE(NaN, 8);
 
 // JS only knows a single NaN but there exist two platform specific
 // implementations. Therefore, allow both quiet and signalling NaNs.
-if (buffer[1] === 0xF7) {
-  assert.ok(buffer.equals(new Uint8Array([
-    0x7F, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x7F
-  ])));
+if (buffer[1] === 0xf7) {
+  assert.ok(
+    buffer.equals(
+      new Uint8Array([
+        0x7f,
+        0xf7,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xf7,
+        0x7f
+      ])
+    )
+  );
 } else {
-  assert.ok(buffer.equals(new Uint8Array([
-    0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F
-  ])));
+  assert.ok(
+    buffer.equals(
+      new Uint8Array([
+        0x7f,
+        0xf8,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xf8,
+        0x7f
+      ])
+    )
+  );
 }
 
 assert.ok(Number.isNaN(buffer.readDoubleBE(0)));
@@ -89,45 +251,38 @@ assert.ok(Number.isNaN(buffer.readDoubleLE(8)));
   const small = Buffer.allocUnsafe(1);
 
   ['writeDoubleLE', 'writeDoubleBE'].forEach((fn) => {
-
     // Verify that default offset works fine.
     buffer[fn](23, undefined);
     buffer[fn](23);
 
-    assert.throws(
-      () => small[fn](11.11, 0),
-      {
-        code: 'ERR_BUFFER_OUT_OF_BOUNDS',
-        name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
-        message: 'Attempt to write outside buffer bounds'
-      });
+    assert.throws(() => small[fn](11.11, 0), {
+      code: 'ERR_BUFFER_OUT_OF_BOUNDS',
+      name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
+      message: 'Attempt to write outside buffer bounds'
+    });
 
     ['', '0', null, {}, [], () => {}, true, false].forEach((off) => {
-      assert.throws(
-        () => small[fn](23, off),
-        { code: 'ERR_INVALID_ARG_TYPE' });
+      assert.throws(() => small[fn](23, off), { code: 'ERR_INVALID_ARG_TYPE' });
     });
 
     [Infinity, -1, 9].forEach((offset) => {
-      assert.throws(
-        () => buffer[fn](23, offset),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "offset" is out of range. ' +
-                     `It must be >= 0 and <= 8. Received ${offset}`
-        });
+      assert.throws(() => buffer[fn](23, offset), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "offset" is out of range. ' +
+          `It must be >= 0 and <= 8. Received ${offset}`
+      });
     });
 
     [NaN, 1.01].forEach((offset) => {
-      assert.throws(
-        () => buffer[fn](42, offset),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "offset" is out of range. ' +
-                   `It must be an integer. Received ${offset}`
-        });
+      assert.throws(() => buffer[fn](42, offset), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "offset" is out of range. ' +
+          `It must be an integer. Received ${offset}`
+      });
     });
   });
 }
diff --git a/test/parallel/test-buffer-writefloat.js b/test/parallel/test-buffer-writefloat.js
index 4c2c7539eaafcb..0c830b5723d5f3 100644
--- a/test/parallel/test-buffer-writefloat.js
+++ b/test/parallel/test-buffer-writefloat.js
@@ -9,41 +9,62 @@ const buffer = Buffer.allocUnsafe(8);
 
 buffer.writeFloatBE(1, 0);
 buffer.writeFloatLE(1, 4);
-assert.ok(buffer.equals(
-  new Uint8Array([ 0x3f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f ])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([0x3f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f])
+  )
+);
 
 buffer.writeFloatBE(1 / 3, 0);
 buffer.writeFloatLE(1 / 3, 4);
-assert.ok(buffer.equals(
-  new Uint8Array([ 0x3e, 0xaa, 0xaa, 0xab, 0xab, 0xaa, 0xaa, 0x3e ])));
-
-buffer.writeFloatBE(3.4028234663852886e+38, 0);
-buffer.writeFloatLE(3.4028234663852886e+38, 4);
-assert.ok(buffer.equals(
-  new Uint8Array([ 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f ])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([0x3e, 0xaa, 0xaa, 0xab, 0xab, 0xaa, 0xaa, 0x3e])
+  )
+);
+
+buffer.writeFloatBE(3.4028234663852886e38, 0);
+buffer.writeFloatLE(3.4028234663852886e38, 4);
+assert.ok(
+  buffer.equals(
+    new Uint8Array([0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f])
+  )
+);
 
 buffer.writeFloatLE(1.1754943508222875e-38, 0);
 buffer.writeFloatBE(1.1754943508222875e-38, 4);
-assert.ok(buffer.equals(
-  new Uint8Array([ 0x00, 0x00, 0x80, 0x00, 0x00, 0x80, 0x00, 0x00 ])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([0x00, 0x00, 0x80, 0x00, 0x00, 0x80, 0x00, 0x00])
+  )
+);
 
 buffer.writeFloatBE(0 * -1, 0);
 buffer.writeFloatLE(0 * -1, 4);
-assert.ok(buffer.equals(
-  new Uint8Array([ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 ])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80])
+  )
+);
 
 buffer.writeFloatBE(Infinity, 0);
 buffer.writeFloatLE(Infinity, 4);
-assert.ok(buffer.equals(
-  new Uint8Array([ 0x7F, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7F ])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([0x7f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f])
+  )
+);
 
 assert.strictEqual(buffer.readFloatBE(0), Infinity);
 assert.strictEqual(buffer.readFloatLE(4), Infinity);
 
 buffer.writeFloatBE(-Infinity, 0);
 buffer.writeFloatLE(-Infinity, 4);
-assert.ok(buffer.equals(
-  new Uint8Array([ 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF ])));
+assert.ok(
+  buffer.equals(
+    new Uint8Array([0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff])
+  )
+);
 
 assert.strictEqual(buffer.readFloatBE(0), -Infinity);
 assert.strictEqual(buffer.readFloatLE(4), -Infinity);
@@ -53,14 +74,18 @@ buffer.writeFloatLE(NaN, 4);
 
 // JS only knows a single NaN but there exist two platform specific
 // implementations. Therefore, allow both quiet and signalling NaNs.
-if (buffer[1] === 0xBF) {
+if (buffer[1] === 0xbf) {
   assert.ok(
-    buffer.equals(new Uint8Array(
-      [ 0x7F, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0x7F ])));
+    buffer.equals(
+      new Uint8Array([0x7f, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xbf, 0x7f])
+    )
+  );
 } else {
   assert.ok(
-    buffer.equals(new Uint8Array(
-      [ 0x7F, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x7F ])));
+    buffer.equals(
+      new Uint8Array([0x7f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f])
+    )
+  );
 }
 
 assert.ok(Number.isNaN(buffer.readFloatBE(0)));
@@ -71,47 +96,38 @@ assert.ok(Number.isNaN(buffer.readFloatLE(4)));
   const small = Buffer.allocUnsafe(1);
 
   ['writeFloatLE', 'writeFloatBE'].forEach((fn) => {
-
     // Verify that default offset works fine.
     buffer[fn](23, undefined);
     buffer[fn](23);
 
-    assert.throws(
-      () => small[fn](11.11, 0),
-      {
-        code: 'ERR_BUFFER_OUT_OF_BOUNDS',
-        name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
-        message: 'Attempt to write outside buffer bounds'
-      });
+    assert.throws(() => small[fn](11.11, 0), {
+      code: 'ERR_BUFFER_OUT_OF_BOUNDS',
+      name: 'RangeError [ERR_BUFFER_OUT_OF_BOUNDS]',
+      message: 'Attempt to write outside buffer bounds'
+    });
 
     ['', '0', null, {}, [], () => {}, true, false].forEach((off) => {
-      assert.throws(
-        () => small[fn](23, off),
-        { code: 'ERR_INVALID_ARG_TYPE' }
-      );
+      assert.throws(() => small[fn](23, off), { code: 'ERR_INVALID_ARG_TYPE' });
     });
 
     [Infinity, -1, 5].forEach((offset) => {
-      assert.throws(
-        () => buffer[fn](23, offset),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "offset" is out of range. ' +
-                   `It must be >= 0 and <= 4. Received ${offset}`
-        }
-      );
+      assert.throws(() => buffer[fn](23, offset), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "offset" is out of range. ' +
+          `It must be >= 0 and <= 4. Received ${offset}`
+      });
     });
 
     [NaN, 1.01].forEach((offset) => {
-      assert.throws(
-        () => buffer[fn](42, offset),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "offset" is out of range. ' +
-                   `It must be an integer. Received ${offset}`
-        });
+      assert.throws(() => buffer[fn](42, offset), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "offset" is out of range. ' +
+          `It must be an integer. Received ${offset}`
+      });
     });
   });
 }
diff --git a/test/parallel/test-buffer-writeint.js b/test/parallel/test-buffer-writeint.js
index 0e5b4960ab234d..f0f8dae2beae44 100644
--- a/test/parallel/test-buffer-writeint.js
+++ b/test/parallel/test-buffer-writeint.js
@@ -4,12 +4,17 @@
 
 const common = require('../common');
 const assert = require('assert');
-const errorOutOfBounds = common.expectsError({
-  code: 'ERR_OUT_OF_RANGE',
-  type: RangeError,
-  message: new RegExp('^The value of "value" is out of range\\. ' +
-                      'It must be >= -\\d+ and <= \\d+\\. Received .+$')
-}, 10);
+const errorOutOfBounds = common.expectsError(
+  {
+    code: 'ERR_OUT_OF_RANGE',
+    type: RangeError,
+    message: new RegExp(
+      '^The value of "value" is out of range\\. ' +
+        'It must be >= -\\d+ and <= \\d+\\. Received .+$'
+    )
+  },
+  10
+);
 
 // Test 8 bit
 {
@@ -17,12 +22,12 @@ const errorOutOfBounds = common.expectsError({
 
   buffer.writeInt8(0x23, 0);
   buffer.writeInt8(-5, 1);
-  assert.ok(buffer.equals(new Uint8Array([ 0x23, 0xfb ])));
+  assert.ok(buffer.equals(new Uint8Array([0x23, 0xfb])));
 
   /* Make sure we handle min/max correctly */
   buffer.writeInt8(0x7f, 0);
   buffer.writeInt8(-0x80, 1);
-  assert.ok(buffer.equals(new Uint8Array([ 0x7f, 0x80 ])));
+  assert.ok(buffer.equals(new Uint8Array([0x7f, 0x80])));
 
   assert.throws(() => {
     buffer.writeInt8(0x7f + 1, 0);
@@ -36,15 +41,15 @@ const errorOutOfBounds = common.expectsError({
   buffer.writeInt8(23);
 
   ['', '0', null, {}, [], () => {}, true, false].forEach((off) => {
-    assert.throws(
-      () => buffer.writeInt8(23, off),
-      { code: 'ERR_INVALID_ARG_TYPE' });
+    assert.throws(() => buffer.writeInt8(23, off), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
   });
 
   [NaN, Infinity, -1, 1.01].forEach((off) => {
-    assert.throws(
-      () => buffer.writeInt8(23, off),
-      { code: 'ERR_OUT_OF_RANGE' });
+    assert.throws(() => buffer.writeInt8(23, off), {
+      code: 'ERR_OUT_OF_RANGE'
+    });
   });
 }
 
@@ -54,27 +59,26 @@ const errorOutOfBounds = common.expectsError({
 
   buffer.writeInt16BE(0x0023, 0);
   buffer.writeInt16LE(0x0023, 2);
-  assert.ok(buffer.equals(new Uint8Array([ 0x00, 0x23, 0x23, 0x00 ])));
+  assert.ok(buffer.equals(new Uint8Array([0x00, 0x23, 0x23, 0x00])));
 
   buffer.writeInt16BE(-5, 0);
   buffer.writeInt16LE(-5, 2);
-  assert.ok(buffer.equals(new Uint8Array([ 0xff, 0xfb, 0xfb, 0xff ])));
+  assert.ok(buffer.equals(new Uint8Array([0xff, 0xfb, 0xfb, 0xff])));
 
   buffer.writeInt16BE(-1679, 0);
   buffer.writeInt16LE(-1679, 2);
-  assert.ok(buffer.equals(new Uint8Array([ 0xf9, 0x71, 0x71, 0xf9 ])));
+  assert.ok(buffer.equals(new Uint8Array([0xf9, 0x71, 0x71, 0xf9])));
 
   /* Make sure we handle min/max correctly */
   buffer.writeInt16BE(0x7fff, 0);
   buffer.writeInt16BE(-0x8000, 2);
-  assert.ok(buffer.equals(new Uint8Array([ 0x7f, 0xff, 0x80, 0x00 ])));
+  assert.ok(buffer.equals(new Uint8Array([0x7f, 0xff, 0x80, 0x00])));
 
   buffer.writeInt16LE(0x7fff, 0);
   buffer.writeInt16LE(-0x8000, 2);
-  assert.ok(buffer.equals(new Uint8Array([ 0xff, 0x7f, 0x00, 0x80 ])));
+  assert.ok(buffer.equals(new Uint8Array([0xff, 0x7f, 0x00, 0x80])));
 
   ['writeInt16BE', 'writeInt16LE'].forEach((fn) => {
-
     // Verify that default offset works fine.
     buffer[fn](23, undefined);
     buffer[fn](23);
@@ -87,15 +91,13 @@ const errorOutOfBounds = common.expectsError({
     }, errorOutOfBounds);
 
     ['', '0', null, {}, [], () => {}, true, false].forEach((off) => {
-      assert.throws(
-        () => buffer[fn](23, off),
-        { code: 'ERR_INVALID_ARG_TYPE' });
+      assert.throws(() => buffer[fn](23, off), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      });
     });
 
     [NaN, Infinity, -1, 1.01].forEach((off) => {
-      assert.throws(
-        () => buffer[fn](23, off),
-        { code: 'ERR_OUT_OF_RANGE' });
+      assert.throws(() => buffer[fn](23, off), { code: 'ERR_OUT_OF_RANGE' });
     });
   });
 }
@@ -106,37 +108,46 @@ const errorOutOfBounds = common.expectsError({
 
   buffer.writeInt32BE(0x23, 0);
   buffer.writeInt32LE(0x23, 4);
-  assert.ok(buffer.equals(new Uint8Array([
-    0x00, 0x00, 0x00, 0x23, 0x23, 0x00, 0x00, 0x00
-  ])));
+  assert.ok(
+    buffer.equals(
+      new Uint8Array([0x00, 0x00, 0x00, 0x23, 0x23, 0x00, 0x00, 0x00])
+    )
+  );
 
   buffer.writeInt32BE(-5, 0);
   buffer.writeInt32LE(-5, 4);
-  assert.ok(buffer.equals(new Uint8Array([
-    0xff, 0xff, 0xff, 0xfb, 0xfb, 0xff, 0xff, 0xff
-  ])));
+  assert.ok(
+    buffer.equals(
+      new Uint8Array([0xff, 0xff, 0xff, 0xfb, 0xfb, 0xff, 0xff, 0xff])
+    )
+  );
 
   buffer.writeInt32BE(-805306713, 0);
   buffer.writeInt32LE(-805306713, 4);
-  assert.ok(buffer.equals(new Uint8Array([
-    0xcf, 0xff, 0xfe, 0xa7, 0xa7, 0xfe, 0xff, 0xcf
-  ])));
+  assert.ok(
+    buffer.equals(
+      new Uint8Array([0xcf, 0xff, 0xfe, 0xa7, 0xa7, 0xfe, 0xff, 0xcf])
+    )
+  );
 
   /* Make sure we handle min/max correctly */
   buffer.writeInt32BE(0x7fffffff, 0);
   buffer.writeInt32BE(-0x80000000, 4);
-  assert.ok(buffer.equals(new Uint8Array([
-    0x7f, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00
-  ])));
+  assert.ok(
+    buffer.equals(
+      new Uint8Array([0x7f, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00])
+    )
+  );
 
   buffer.writeInt32LE(0x7fffffff, 0);
   buffer.writeInt32LE(-0x80000000, 4);
-  assert.ok(buffer.equals(new Uint8Array([
-    0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x80
-  ])));
+  assert.ok(
+    buffer.equals(
+      new Uint8Array([0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x80])
+    )
+  );
 
   ['writeInt32BE', 'writeInt32LE'].forEach((fn) => {
-
     // Verify that default offset works fine.
     buffer[fn](23, undefined);
     buffer[fn](23);
@@ -149,15 +160,13 @@ const errorOutOfBounds = common.expectsError({
     }, errorOutOfBounds);
 
     ['', '0', null, {}, [], () => {}, true, false].forEach((off) => {
-      assert.throws(
-        () => buffer[fn](23, off),
-        { code: 'ERR_INVALID_ARG_TYPE' });
+      assert.throws(() => buffer[fn](23, off), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      });
     });
 
     [NaN, Infinity, -1, 1.01].forEach((off) => {
-      assert.throws(
-        () => buffer[fn](23, off),
-        { code: 'ERR_OUT_OF_RANGE' });
+      assert.throws(() => buffer[fn](23, off), { code: 'ERR_OUT_OF_RANGE' });
     });
   });
 }
@@ -167,14 +176,14 @@ const errorOutOfBounds = common.expectsError({
   const value = 0x1234567890ab;
   const buffer = Buffer.allocUnsafe(6);
   buffer.writeIntBE(value, 0, 6);
-  assert.ok(buffer.equals(new Uint8Array([
-    0x12, 0x34, 0x56, 0x78, 0x90, 0xab
-  ])));
+  assert.ok(
+    buffer.equals(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]))
+  );
 
   buffer.writeIntLE(value, 0, 6);
-  assert.ok(buffer.equals(new Uint8Array([
-    0xab, 0x90, 0x78, 0x56, 0x34, 0x12
-  ])));
+  assert.ok(
+    buffer.equals(new Uint8Array([0xab, 0x90, 0x78, 0x56, 0x34, 0x12]))
+  );
 }
 
 // Test Int
@@ -184,31 +193,28 @@ const errorOutOfBounds = common.expectsError({
   // Check byteLength.
   ['writeIntBE', 'writeIntLE'].forEach((fn) => {
     ['', '0', null, {}, [], () => {}, true, false, undefined].forEach((bl) => {
-      assert.throws(
-        () => data[fn](23, 0, bl),
-        { code: 'ERR_INVALID_ARG_TYPE' });
+      assert.throws(() => data[fn](23, 0, bl), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      });
     });
 
     [Infinity, -1].forEach((byteLength) => {
-      assert.throws(
-        () => data[fn](23, 0, byteLength),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          message: 'The value of "byteLength" is out of range. ' +
-                   `It must be >= 1 and <= 6. Received ${byteLength}`
-        }
-      );
+      assert.throws(() => data[fn](23, 0, byteLength), {
+        code: 'ERR_OUT_OF_RANGE',
+        message:
+          'The value of "byteLength" is out of range. ' +
+          `It must be >= 1 and <= 6. Received ${byteLength}`
+      });
     });
 
     [NaN, 1.01].forEach((byteLength) => {
-      assert.throws(
-        () => data[fn](42, 0, byteLength),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "byteLength" is out of range. ' +
-                   `It must be an integer. Received ${byteLength}`
-        });
+      assert.throws(() => data[fn](42, 0, byteLength), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "byteLength" is out of range. ' +
+          `It must be an integer. Received ${byteLength}`
+      });
     });
   });
 
@@ -219,45 +225,45 @@ const errorOutOfBounds = common.expectsError({
       const max = 2 ** (i * 8 - 1) - 1;
 
       [min - 1, max + 1].forEach((val) => {
-        assert.throws(() => {
-          data[fn](val, 0, i);
-        }, {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "value" is out of range. ' +
-                   `It must be >= ${min} and <= ${max}. Received ${val}`
-        });
+        assert.throws(
+          () => {
+            data[fn](val, 0, i);
+          },
+          {
+            code: 'ERR_OUT_OF_RANGE',
+            name: 'RangeError [ERR_OUT_OF_RANGE]',
+            message:
+              'The value of "value" is out of range. ' +
+              `It must be >= ${min} and <= ${max}. Received ${val}`
+          }
+        );
       });
 
       ['', '0', null, {}, [], () => {}, true, false, undefined].forEach((o) => {
-        assert.throws(
-          () => data[fn](min, o, i),
-          {
-            code: 'ERR_INVALID_ARG_TYPE',
-            name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-          });
+        assert.throws(() => data[fn](min, o, i), {
+          code: 'ERR_INVALID_ARG_TYPE',
+          name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+        });
       });
 
       [Infinity, -1, -4294967295].forEach((offset) => {
-        assert.throws(
-          () => data[fn](min, offset, i),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            name: 'RangeError [ERR_OUT_OF_RANGE]',
-            message: 'The value of "offset" is out of range. ' +
-                     `It must be >= 0 and <= ${8 - i}. Received ${offset}`
-          });
+        assert.throws(() => data[fn](min, offset, i), {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "offset" is out of range. ' +
+            `It must be >= 0 and <= ${8 - i}. Received ${offset}`
+        });
       });
 
       [NaN, 1.01].forEach((offset) => {
-        assert.throws(
-          () => data[fn](max, offset, i),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            name: 'RangeError [ERR_OUT_OF_RANGE]',
-            message: 'The value of "offset" is out of range. ' +
-                     `It must be an integer. Received ${offset}`
-          });
+        assert.throws(() => data[fn](max, offset, i), {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "offset" is out of range. ' +
+            `It must be an integer. Received ${offset}`
+        });
       });
     });
   }
diff --git a/test/parallel/test-buffer-writeuint.js b/test/parallel/test-buffer-writeuint.js
index 387aafd3354a35..5d8f4d53931321 100644
--- a/test/parallel/test-buffer-writeuint.js
+++ b/test/parallel/test-buffer-writeuint.js
@@ -11,29 +11,30 @@ const assert = require('assert');
  *  - Correctly interpreting values that are beyond the signed range as unsigned
  */
 
-{ // OOB
+{
+  // OOB
   const data = Buffer.alloc(8);
   ['UInt8', 'UInt16BE', 'UInt16LE', 'UInt32BE', 'UInt32LE'].forEach((fn) => {
-
     // Verify that default offset works fine.
     data[`write${fn}`](23, undefined);
     data[`write${fn}`](23);
 
     ['', '0', null, {}, [], () => {}, true, false].forEach((o) => {
-      assert.throws(
-        () => data[`write${fn}`](23, o),
-        { code: 'ERR_INVALID_ARG_TYPE' });
+      assert.throws(() => data[`write${fn}`](23, o), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      });
     });
 
     [NaN, Infinity, -1, 1.01].forEach((o) => {
-      assert.throws(
-        () => data[`write${fn}`](23, o),
-        { code: 'ERR_OUT_OF_RANGE' });
+      assert.throws(() => data[`write${fn}`](23, o), {
+        code: 'ERR_OUT_OF_RANGE'
+      });
     });
   });
 }
 
-{ // Test 8 bit
+{
+  // Test 8 bit
   const data = Buffer.alloc(4);
 
   data.writeUInt8(23, 0);
@@ -87,14 +88,12 @@ const assert = require('assert');
 
   value = 0xfffff;
   ['writeUInt16BE', 'writeUInt16LE'].forEach((fn) => {
-    assert.throws(
-      () => data[fn](value, 0),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        message: 'The value of "value" is out of range. ' +
-                 `It must be >= 0 and <= 65535. Received ${value}`
-      }
-    );
+    assert.throws(() => data[fn](value, 0), {
+      code: 'ERR_OUT_OF_RANGE',
+      message:
+        'The value of "value" is out of range. ' +
+        `It must be >= 0 and <= 65535. Received ${value}`
+    });
   });
 }
 
@@ -141,75 +140,72 @@ const assert = require('assert');
   // Check byteLength.
   ['writeUIntBE', 'writeUIntLE'].forEach((fn) => {
     ['', '0', null, {}, [], () => {}, true, false, undefined].forEach((bl) => {
-      assert.throws(
-        () => data[fn](23, 0, bl),
-        { code: 'ERR_INVALID_ARG_TYPE' });
+      assert.throws(() => data[fn](23, 0, bl), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      });
     });
 
     [Infinity, -1].forEach((byteLength) => {
-      assert.throws(
-        () => data[fn](23, 0, byteLength),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          message: 'The value of "byteLength" is out of range. ' +
-                   `It must be >= 1 and <= 6. Received ${byteLength}`
-        }
-      );
+      assert.throws(() => data[fn](23, 0, byteLength), {
+        code: 'ERR_OUT_OF_RANGE',
+        message:
+          'The value of "byteLength" is out of range. ' +
+          `It must be >= 1 and <= 6. Received ${byteLength}`
+      });
     });
 
     [NaN, 1.01].forEach((byteLength) => {
-      assert.throws(
-        () => data[fn](42, 0, byteLength),
-        {
-          code: 'ERR_OUT_OF_RANGE',
-          name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "byteLength" is out of range. ' +
-                   `It must be an integer. Received ${byteLength}`
-        });
+      assert.throws(() => data[fn](42, 0, byteLength), {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError [ERR_OUT_OF_RANGE]',
+        message:
+          'The value of "byteLength" is out of range. ' +
+          `It must be an integer. Received ${byteLength}`
+      });
     });
   });
 
   // Test 1 to 6 bytes.
   for (let i = 1; i < 6; i++) {
     ['writeUIntBE', 'writeUIntLE'].forEach((fn) => {
-      assert.throws(() => {
-        data[fn](val, 0, i);
-      }, {
-        code: 'ERR_OUT_OF_RANGE',
-        name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "value" is out of range. ' +
-                 `It must be >= 0 and <= ${val - 1}. Received ${val}`
-      });
+      assert.throws(
+        () => {
+          data[fn](val, 0, i);
+        },
+        {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "value" is out of range. ' +
+            `It must be >= 0 and <= ${val - 1}. Received ${val}`
+        }
+      );
 
       ['', '0', null, {}, [], () => {}, true, false].forEach((o) => {
-        assert.throws(
-          () => data[fn](23, o, i),
-          {
-            code: 'ERR_INVALID_ARG_TYPE',
-            name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-          });
+        assert.throws(() => data[fn](23, o, i), {
+          code: 'ERR_INVALID_ARG_TYPE',
+          name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+        });
       });
 
       [Infinity, -1, -4294967295].forEach((offset) => {
-        assert.throws(
-          () => data[fn](val - 1, offset, i),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            name: 'RangeError [ERR_OUT_OF_RANGE]',
-            message: 'The value of "offset" is out of range. ' +
-                     `It must be >= 0 and <= ${8 - i}. Received ${offset}`
-          });
+        assert.throws(() => data[fn](val - 1, offset, i), {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "offset" is out of range. ' +
+            `It must be >= 0 and <= ${8 - i}. Received ${offset}`
+        });
       });
 
       [NaN, 1.01].forEach((offset) => {
-        assert.throws(
-          () => data[fn](val - 1, offset, i),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            name: 'RangeError [ERR_OUT_OF_RANGE]',
-            message: 'The value of "offset" is out of range. ' +
-                     `It must be an integer. Received ${offset}`
-          });
+        assert.throws(() => data[fn](val - 1, offset, i), {
+          code: 'ERR_OUT_OF_RANGE',
+          name: 'RangeError [ERR_OUT_OF_RANGE]',
+          message:
+            'The value of "offset" is out of range. ' +
+            `It must be an integer. Received ${offset}`
+        });
       });
     });
 
diff --git a/test/parallel/test-buffer-zero-fill-cli.js b/test/parallel/test-buffer-zero-fill-cli.js
index 91679498a1a560..40b912618ab58f 100644
--- a/test/parallel/test-buffer-zero-fill-cli.js
+++ b/test/parallel/test-buffer-zero-fill-cli.js
@@ -9,8 +9,7 @@ const SlowBuffer = require('buffer').SlowBuffer;
 const assert = require('assert');
 
 function isZeroFilled(buf) {
-  for (let n = 0; n < buf.length; n++)
-    if (buf[n] > 0) return false;
+  for (let n = 0; n < buf.length; n++) if (buf[n] > 0) return false;
   return true;
 }
 
diff --git a/test/parallel/test-buffer-zero-fill-reset.js b/test/parallel/test-buffer-zero-fill-reset.js
index 334ee1b618b919..34ca68cc725d85 100644
--- a/test/parallel/test-buffer-zero-fill-reset.js
+++ b/test/parallel/test-buffer-zero-fill-reset.js
@@ -3,15 +3,12 @@
 require('../common');
 const assert = require('assert');
 
-
 function testUint8Array(ui) {
   const length = ui.length;
-  for (let i = 0; i < length; i++)
-    if (ui[i] !== 0) return false;
+  for (let i = 0; i < length; i++) if (ui[i] !== 0) return false;
   return true;
 }
 
-
 for (let i = 0; i < 100; i++) {
   Buffer.alloc(0);
   const ui = new Uint8Array(65);
diff --git a/test/parallel/test-buffer-zero-fill.js b/test/parallel/test-buffer-zero-fill.js
index 7a9f0c12500481..8649e0fc9af1a2 100644
--- a/test/parallel/test-buffer-zero-fill.js
+++ b/test/parallel/test-buffer-zero-fill.js
@@ -7,8 +7,6 @@ const assert = require('assert');
 const buf1 = Buffer(100);
 const buf2 = new Buffer(100);
 
-for (let n = 0; n < buf1.length; n++)
-  assert.strictEqual(buf1[n], 0);
+for (let n = 0; n < buf1.length; n++) assert.strictEqual(buf1[n], 0);
 
-for (let n = 0; n < buf2.length; n++)
-  assert.strictEqual(buf2[n], 0);
+for (let n = 0; n < buf2.length; n++) assert.strictEqual(buf2[n], 0);
diff --git a/test/parallel/test-c-ares.js b/test/parallel/test-c-ares.js
index 45e7d46829b00a..858f4bfc46721b 100644
--- a/test/parallel/test-c-ares.js
+++ b/test/parallel/test-c-ares.js
@@ -44,23 +44,32 @@ const dnsPromises = dns.promises;
 
 // Try resolution without callback
 
-dns.lookup(null, common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
-  assert.strictEqual(result, null);
-  assert.strictEqual(addressType, 4);
-}));
+dns.lookup(
+  null,
+  common.mustCall((error, result, addressType) => {
+    assert.ifError(error);
+    assert.strictEqual(result, null);
+    assert.strictEqual(addressType, 4);
+  })
+);
 
-dns.lookup('127.0.0.1', common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
-  assert.strictEqual(result, '127.0.0.1');
-  assert.strictEqual(addressType, 4);
-}));
+dns.lookup(
+  '127.0.0.1',
+  common.mustCall((error, result, addressType) => {
+    assert.ifError(error);
+    assert.strictEqual(result, '127.0.0.1');
+    assert.strictEqual(addressType, 4);
+  })
+);
 
-dns.lookup('::1', common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
-  assert.strictEqual(result, '::1');
-  assert.strictEqual(addressType, 6);
-}));
+dns.lookup(
+  '::1',
+  common.mustCall((error, result, addressType) => {
+    assert.ifError(error);
+    assert.strictEqual(result, '::1');
+    assert.strictEqual(addressType, 6);
+  })
+);
 
 [
   // Try calling resolve with an unsupported type.
@@ -74,10 +83,7 @@ dns.lookup('::1', common.mustCall((error, result, addressType) => {
     message: `The value "${val}" is invalid for option "rrtype"`
   };
 
-  common.expectsError(
-    () => dns.resolve('www.google.com', val),
-    err
-  );
+  common.expectsError(() => dns.resolve('www.google.com', val), err);
 
   common.expectsError(() => dnsPromises.resolve('www.google.com', val), err);
 });
@@ -86,10 +92,13 @@ dns.lookup('::1', common.mustCall((error, result, addressType) => {
 // C:\Windows\System32\drivers\etc\hosts
 // so we disable this test on Windows.
 if (!common.isWindows) {
-  dns.reverse('127.0.0.1', common.mustCall(function(error, domains) {
-    assert.ifError(error);
-    assert.ok(Array.isArray(domains));
-  }));
+  dns.reverse(
+    '127.0.0.1',
+    common.mustCall(function(error, domains) {
+      assert.ifError(error);
+      assert.ok(Array.isArray(domains));
+    })
+  );
 
   (async function() {
     assert.ok(Array.isArray(await dnsPromises.reverse('127.0.0.1')));
diff --git a/test/parallel/test-child-process-can-write-to-stdout.js b/test/parallel/test-child-process-can-write-to-stdout.js
index bb9ddb71c827bc..ad79066012d56f 100644
--- a/test/parallel/test-child-process-can-write-to-stdout.js
+++ b/test/parallel/test-child-process-can-write-to-stdout.js
@@ -7,9 +7,7 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const spawn = require('child_process').spawn;
 
-const child = spawn(process.argv[0], [
-  fixtures.path('GH-1899-output.js')
-]);
+const child = spawn(process.argv[0], [fixtures.path('GH-1899-output.js')]);
 let output = '';
 
 child.stdout.on('data', function(data) {
diff --git a/test/parallel/test-child-process-constructor.js b/test/parallel/test-child-process-constructor.js
index bf7fffd9c5456f..95eb4708f4adce 100644
--- a/test/parallel/test-child-process-constructor.js
+++ b/test/parallel/test-child-process-constructor.js
@@ -14,14 +14,18 @@ function typeName(value) {
   const child = new ChildProcess();
 
   [undefined, null, 'foo', 0, 1, NaN, true, false].forEach((options) => {
-    common.expectsError(() => {
-      child.spawn(options);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "options" argument must be of type Object. ' +
-               `Received type ${typeName(options)}`
-    });
+    common.expectsError(
+      () => {
+        child.spawn(options);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "options" argument must be of type Object. ' +
+          `Received type ${typeName(options)}`
+      }
+    );
   });
 }
 
@@ -30,14 +34,18 @@ function typeName(value) {
   const child = new ChildProcess();
 
   [undefined, null, 0, 1, NaN, true, false, {}].forEach((file) => {
-    common.expectsError(() => {
-      child.spawn({ file });
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "options.file" property must be of type string. ' +
-               `Received type ${typeName(file)}`
-    });
+    common.expectsError(
+      () => {
+        child.spawn({ file });
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "options.file" property must be of type string. ' +
+          `Received type ${typeName(file)}`
+      }
+    );
   });
 }
 
@@ -46,14 +54,18 @@ function typeName(value) {
   const child = new ChildProcess();
 
   [null, 0, 1, NaN, true, false, {}, 'foo'].forEach((envPairs) => {
-    common.expectsError(() => {
-      child.spawn({ envPairs, stdio: ['ignore', 'ignore', 'ignore', 'ipc'] });
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "options.envPairs" property must be of type Array. ' +
-               `Received type ${typeName(envPairs)}`
-    });
+    common.expectsError(
+      () => {
+        child.spawn({ envPairs, stdio: ['ignore', 'ignore', 'ignore', 'ipc'] });
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "options.envPairs" property must be of type Array. ' +
+          `Received type ${typeName(envPairs)}`
+      }
+    );
   });
 }
 
@@ -62,14 +74,18 @@ function typeName(value) {
   const child = new ChildProcess();
 
   [null, 0, 1, NaN, true, false, {}, 'foo'].forEach((args) => {
-    common.expectsError(() => {
-      child.spawn({ file: 'foo', args });
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "options.args" property must be of type Array. ' +
-               `Received type ${typeName(args)}`
-    });
+    common.expectsError(
+      () => {
+        child.spawn({ file: 'foo', args });
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "options.args" property must be of type Array. ' +
+          `Received type ${typeName(args)}`
+      }
+    );
   });
 }
 
@@ -87,7 +103,9 @@ assert(Number.isInteger(child.pid));
 
 // try killing with invalid signal
 common.expectsError(
-  () => { child.kill('foo'); },
+  () => {
+    child.kill('foo');
+  },
   { code: 'ERR_UNKNOWN_SIGNAL', type: TypeError }
 );
 
diff --git a/test/parallel/test-child-process-custom-fds.js b/test/parallel/test-child-process-custom-fds.js
index 1c89c207d37f99..e8ea850264cef3 100644
--- a/test/parallel/test-child-process-custom-fds.js
+++ b/test/parallel/test-child-process-custom-fds.js
@@ -10,8 +10,9 @@ if (!common.isMainThread)
 
 // This test uses the deprecated `customFds` option. We expect a deprecation
 // warning, but only once (per node process).
-const msg = 'child_process: options.customFds option is deprecated. ' +
-            'Use options.stdio instead.';
+const msg =
+  'child_process: options.customFds option is deprecated. ' +
+  'Use options.stdio instead.';
 common.expectWarning('DeprecationWarning', msg, 'DEP0006');
 
 // Verify that customFds is used if stdio is not provided.
diff --git a/test/parallel/test-child-process-cwd.js b/test/parallel/test-child-process-cwd.js
index fdca618a8bcc9c..c3bc112c2b501e 100644
--- a/test/parallel/test-child-process-cwd.js
+++ b/test/parallel/test-child-process-cwd.js
@@ -46,20 +46,24 @@ function testCwd(options, expectCode = 0, expectData) {
     assert.strictEqual(expectCode, code);
   });
 
-  child.on('close', common.mustCall(function() {
-    expectData && assert.strictEqual(data.trim(), expectData);
-  }));
+  child.on(
+    'close',
+    common.mustCall(function() {
+      expectData && assert.strictEqual(data.trim(), expectData);
+    })
+  );
 
   return child;
 }
 
-
 // Assume does-not-exist doesn't exist, expect exitCode=-1 and errno=ENOENT
 {
-  testCwd({ cwd: 'does-not-exist' }, -1)
-    .on('error', common.mustCall(function(e) {
+  testCwd({ cwd: 'does-not-exist' }, -1).on(
+    'error',
+    common.mustCall(function(e) {
       assert.strictEqual(e.code, 'ENOENT');
-    }));
+    })
+  );
 }
 
 // Assume these exist, and 'pwd' gives us the right directory back
diff --git a/test/parallel/test-child-process-default-options.js b/test/parallel/test-child-process-default-options.js
index a0ab2bfd4d98e9..da8c22e3807038 100644
--- a/test/parallel/test-child-process-default-options.js
+++ b/test/parallel/test-child-process-default-options.js
@@ -44,7 +44,9 @@ child.stdout.on('data', function(chunk) {
 });
 
 process.on('exit', function() {
-  assert.ok(response.includes('HELLO=WORLD'),
-            'spawn did not use process.env as default ' +
-            `(process.env.HELLO = ${process.env.HELLO})`);
+  assert.ok(
+    response.includes('HELLO=WORLD'),
+    'spawn did not use process.env as default ' +
+      `(process.env.HELLO = ${process.env.HELLO})`
+  );
 });
diff --git a/test/parallel/test-child-process-detached.js b/test/parallel/test-child-process-detached.js
index 8242536d1f49ad..a953fd70bde08d 100644
--- a/test/parallel/test-child-process-detached.js
+++ b/test/parallel/test-child-process-detached.js
@@ -28,7 +28,7 @@ const spawn = require('child_process').spawn;
 const childPath = fixtures.path('parent-process-nonpersistent.js');
 let persistentPid = -1;
 
-const child = spawn(process.execPath, [ childPath ]);
+const child = spawn(process.execPath, [childPath]);
 
 child.stdout.on('data', function(data) {
   persistentPid = parseInt(data, 10);
diff --git a/test/parallel/test-child-process-disconnect.js b/test/parallel/test-child-process-disconnect.js
index e1b2c2de016d66..659697dc3f8496 100644
--- a/test/parallel/test-child-process-disconnect.js
+++ b/test/parallel/test-child-process-disconnect.js
@@ -27,7 +27,6 @@ const net = require('net');
 
 // child
 if (process.argv[2] === 'child') {
-
   // Check that the 'disconnect' event is deferred to the next event loop tick.
   const disconnect = process.disconnect;
   process.disconnect = function() {
@@ -41,11 +40,10 @@ if (process.argv[2] === 'child') {
   const server = net.createServer();
 
   server.on('connection', function(socket) {
-
     socket.resume();
 
     process.on('disconnect', function() {
-      socket.end((process.connected).toString());
+      socket.end(process.connected.toString());
     });
 
     // when the socket is closed, we will close the server
@@ -63,7 +61,6 @@ if (process.argv[2] === 'child') {
   });
 
   server.listen(0);
-
 } else {
   // testcase
   const child = fork(process.argv[1], ['child']);
@@ -73,9 +70,12 @@ if (process.argv[2] === 'child') {
 
   // when calling .disconnect the event should emit
   // and the disconnected flag should be true.
-  child.on('disconnect', common.mustCall(function() {
-    parentFlag = child.connected;
-  }));
+  child.on(
+    'disconnect',
+    common.mustCall(function() {
+      parentFlag = child.connected;
+    })
+  );
 
   // the process should also self terminate without using signals
   child.on('exit', common.mustCall());
@@ -83,7 +83,6 @@ if (process.argv[2] === 'child') {
   // when child is listening
   child.on('message', function(obj) {
     if (obj && obj.msg === 'ready') {
-
       // connect to child using TCP to know if disconnect was emitted
       const socket = net.connect(obj.port);
 
@@ -93,18 +92,15 @@ if (process.argv[2] === 'child') {
         // ready to be disconnected
         if (data === 'ready') {
           child.disconnect();
-          assert.throws(
-            child.disconnect.bind(child),
-            {
-              code: 'ERR_IPC_DISCONNECTED'
-            });
+          assert.throws(child.disconnect.bind(child), {
+            code: 'ERR_IPC_DISCONNECTED'
+          });
           return;
         }
 
         // disconnect is emitted
-        childFlag = (data === 'true');
+        childFlag = data === 'true';
       });
-
     }
   });
 
diff --git a/test/parallel/test-child-process-double-pipe.js b/test/parallel/test-child-process-double-pipe.js
index 8503ebf69cc89d..065feb68625eab 100644
--- a/test/parallel/test-child-process-double-pipe.js
+++ b/test/parallel/test-child-process-double-pipe.js
@@ -31,15 +31,23 @@ const spawn = require('child_process').spawn;
 let grep, sed, echo;
 
 if (common.isWindows) {
-  grep = spawn('grep', ['--binary', 'o']),
-  sed = spawn('sed', ['--binary', 's/o/O/']),
-  echo = spawn('cmd.exe',
-               ['/c', 'echo', 'hello&&', 'echo',
-                'node&&', 'echo', 'and&&', 'echo', 'world']);
+  (grep = spawn('grep', ['--binary', 'o'])),
+    (sed = spawn('sed', ['--binary', 's/o/O/'])),
+    (echo = spawn('cmd.exe', [
+      '/c',
+      'echo',
+      'hello&&',
+      'echo',
+      'node&&',
+      'echo',
+      'and&&',
+      'echo',
+      'world'
+    ]));
 } else {
-  grep = spawn('grep', ['o']),
-  sed = spawn('sed', ['s/o/O/']),
-  echo = spawn('echo', ['hello\nnode\nand\nworld\n']);
+  (grep = spawn('grep', ['o'])),
+    (sed = spawn('sed', ['s/o/O/'])),
+    (echo = spawn('echo', ['hello\nnode\nand\nworld\n']));
 }
 
 /*
@@ -52,7 +60,6 @@ if (common.isWindows) {
  * explained above.
  */
 
-
 // pipe echo | grep
 echo.stdout.on('data', function(data) {
   console.error(`grep stdin write ${data.length}`);
@@ -82,7 +89,6 @@ sed.on('exit', function() {
   console.error('sed exit');
 });
 
-
 // pipe grep | sed
 grep.stdout.on('data', function(data) {
   console.error(`grep stdout ${data.length}`);
@@ -101,7 +107,6 @@ grep.stdout.on('end', function(code) {
   sed.stdin.end();
 });
 
-
 let result = '';
 
 // print sed's output
diff --git a/test/parallel/test-child-process-env.js b/test/parallel/test-child-process-env.js
index 2eec658872518a..20ad42dbe47cf5 100644
--- a/test/parallel/test-child-process-env.js
+++ b/test/parallel/test-child-process-env.js
@@ -27,13 +27,13 @@ const os = require('os');
 const spawn = require('child_process').spawn;
 
 const env = Object.assign({}, process.env, {
-  'HELLO': 'WORLD',
-  'UNDEFINED': undefined,
-  'NULL': null,
-  'EMPTY': ''
+  HELLO: 'WORLD',
+  UNDEFINED: undefined,
+  NULL: null,
+  EMPTY: ''
 });
 Object.setPrototypeOf(env, {
-  'FOO': 'BAR'
+  FOO: 'BAR'
 });
 
 let child;
@@ -43,7 +43,6 @@ if (common.isWindows) {
   child = spawn('/usr/bin/env', [], { env });
 }
 
-
 let response = '';
 
 child.stdout.setEncoding('utf8');
diff --git a/test/parallel/test-child-process-exec-any-shells-windows.js b/test/parallel/test-child-process-exec-any-shells-windows.js
index 8cdd03d7e510d5..645e2c0b1ff164 100644
--- a/test/parallel/test-child-process-exec-any-shells-windows.js
+++ b/test/parallel/test-child-process-exec-any-shells-windows.js
@@ -6,8 +6,7 @@ const fs = require('fs');
 const tmpdir = require('../common/tmpdir');
 
 // This test is only relevant on Windows.
-if (!common.isWindows)
-  common.skip('Windows specific test.');
+if (!common.isWindows) common.skip('Windows specific test.');
 
 // This test ensures that child_process.exec can work with any shells.
 
@@ -16,11 +15,14 @@ const tmpPath = `${tmpdir.path}\\path with spaces`;
 fs.mkdirSync(tmpPath);
 
 const test = (shell) => {
-  cp.exec('echo foo bar', { shell: shell },
-          common.mustCall((error, stdout, stderror) => {
-            assert.ok(!error && !stderror);
-            assert.ok(stdout.includes('foo') && stdout.includes('bar'));
-          }));
+  cp.exec(
+    'echo foo bar',
+    { shell: shell },
+    common.mustCall((error, stdout, stderror) => {
+      assert.ok(!error && !stderror);
+      assert.ok(stdout.includes('foo') && stdout.includes('bar'));
+    })
+  );
 };
 const testCopy = (shellName, shellPath) => {
   // Copy the executable to a path with spaces, to ensure there are no issues
@@ -41,28 +43,38 @@ test('CMD');
 
 // Test PowerShell
 test('powershell');
-testCopy('powershell.exe',
-         `${system32}\\WindowsPowerShell\\v1.0\\powershell.exe`);
-fs.writeFile(`${tmpPath}\\test file`, 'Test', common.mustCall((err) => {
-  assert.ifError(err);
-  cp.exec(`Get-ChildItem "${tmpPath}" | Select-Object -Property Name`,
-          { shell: 'PowerShell' },
-          common.mustCall((error, stdout, stderror) => {
-            assert.ok(!error && !stderror);
-            assert.ok(stdout.includes(
-              'test file'));
-          }));
-}));
+testCopy(
+  'powershell.exe',
+  `${system32}\\WindowsPowerShell\\v1.0\\powershell.exe`
+);
+fs.writeFile(
+  `${tmpPath}\\test file`,
+  'Test',
+  common.mustCall((err) => {
+    assert.ifError(err);
+    cp.exec(
+      `Get-ChildItem "${tmpPath}" | Select-Object -Property Name`,
+      { shell: 'PowerShell' },
+      common.mustCall((error, stdout, stderror) => {
+        assert.ok(!error && !stderror);
+        assert.ok(stdout.includes('test file'));
+      })
+    );
+  })
+);
 
 // Test Bash (from WSL and Git), if available
-cp.exec('where bash', common.mustCall((error, stdout) => {
-  if (error) {
-    return;
-  }
-  const lines = stdout.trim().split(/[\r\n]+/g);
-  for (let i = 0; i < lines.length; ++i) {
-    const bashPath = lines[i].trim();
-    test(bashPath);
-    testCopy(`bash_${i}.exe`, bashPath);
-  }
-}));
+cp.exec(
+  'where bash',
+  common.mustCall((error, stdout) => {
+    if (error) {
+      return;
+    }
+    const lines = stdout.trim().split(/[\r\n]+/g);
+    for (let i = 0; i < lines.length; ++i) {
+      const bashPath = lines[i].trim();
+      test(bashPath);
+      testCopy(`bash_${i}.exe`, bashPath);
+    }
+  })
+);
diff --git a/test/parallel/test-child-process-exec-cwd.js b/test/parallel/test-child-process-exec-cwd.js
index c16f77f4c52906..15342ab067521c 100644
--- a/test/parallel/test-child-process-exec-cwd.js
+++ b/test/parallel/test-child-process-exec-cwd.js
@@ -34,7 +34,11 @@ if (common.isWindows) {
   dir = '/dev';
 }
 
-exec(pwdcommand, { cwd: dir }, common.mustCall(function(err, stdout, stderr) {
-  assert.ifError(err);
-  assert(stdout.startsWith(dir));
-}));
+exec(
+  pwdcommand,
+  { cwd: dir },
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ifError(err);
+    assert(stdout.startsWith(dir));
+  })
+);
diff --git a/test/parallel/test-child-process-exec-encoding.js b/test/parallel/test-child-process-exec-encoding.js
index d7c059a65ab4d8..9e168933a0ea30 100644
--- a/test/parallel/test-child-process-exec-encoding.js
+++ b/test/parallel/test-child-process-exec-encoding.js
@@ -15,10 +15,14 @@ if (process.argv[2] === 'child') {
   function run(options, callback) {
     const cmd = `"${process.execPath}" "${__filename}" child`;
 
-    cp.exec(cmd, options, common.mustCall((err, stdout, stderr) => {
-      assert.ifError(err);
-      callback(stdout, stderr);
-    }));
+    cp.exec(
+      cmd,
+      options,
+      common.mustCall((err, stdout, stderr) => {
+        assert.ifError(err);
+        callback(stdout, stderr);
+      })
+    );
   }
 
   // Test default encoding, which should be utf8.
diff --git a/test/parallel/test-child-process-exec-env.js b/test/parallel/test-child-process-exec-env.js
index 41aaf992cfc8c9..440784ebb3c8f0 100644
--- a/test/parallel/test-child-process-exec-env.js
+++ b/test/parallel/test-child-process-exec-env.js
@@ -42,11 +42,13 @@ function after(err, stdout, stderr) {
 }
 
 if (!common.isWindows) {
-  child = exec('/usr/bin/env', { env: { 'HELLO': 'WORLD' } }, after);
+  child = exec('/usr/bin/env', { env: { HELLO: 'WORLD' } }, after);
 } else {
-  child = exec('set',
-               { env: Object.assign({}, process.env, { 'HELLO': 'WORLD' }) },
-               after);
+  child = exec(
+    'set',
+    { env: Object.assign({}, process.env, { HELLO: 'WORLD' }) },
+    after
+  );
 }
 
 child.stdout.setEncoding('utf8');
diff --git a/test/parallel/test-child-process-exec-error.js b/test/parallel/test-child-process-exec-error.js
index cb8ace0a9bf3e8..0bd60b1bb0eeb8 100644
--- a/test/parallel/test-child-process-exec-error.js
+++ b/test/parallel/test-child-process-exec-error.js
@@ -25,10 +25,13 @@ const assert = require('assert');
 const child_process = require('child_process');
 
 function test(fn, code) {
-  fn('does-not-exist', common.mustCall(function(err) {
-    assert.strictEqual(err.code, code);
-    assert(err.cmd.includes('does-not-exist'));
-  }));
+  fn(
+    'does-not-exist',
+    common.mustCall(function(err) {
+      assert.strictEqual(err.code, code);
+      assert(err.cmd.includes('does-not-exist'));
+    })
+  );
 }
 
 if (common.isWindows) {
diff --git a/test/parallel/test-child-process-exec-kill-throws.js b/test/parallel/test-child-process-exec-kill-throws.js
index d6a0d4da19eae7..92326177b1d06f 100644
--- a/test/parallel/test-child-process-exec-kill-throws.js
+++ b/test/parallel/test-child-process-exec-kill-throws.js
@@ -21,11 +21,15 @@ if (process.argv[2] === 'child') {
   const cmd = `"${process.execPath}" "${__filename}" child`;
   const options = { maxBuffer: 0, killSignal: 'SIGKILL' };
 
-  const child = cp.exec(cmd, options, common.mustCall((err, stdout, stderr) => {
-    // Verify that if ChildProcess#kill() throws, the error is reported.
-    assert.strictEqual(err.message, 'mock error', err);
-    assert.strictEqual(stdout, '');
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(child.killed, true);
-  }));
+  const child = cp.exec(
+    cmd,
+    options,
+    common.mustCall((err, stdout, stderr) => {
+      // Verify that if ChildProcess#kill() throws, the error is reported.
+      assert.strictEqual(err.message, 'mock error', err);
+      assert.strictEqual(stdout, '');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(child.killed, true);
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-exec-maxBuffer.js b/test/parallel/test-child-process-exec-maxBuffer.js
index 94545e719ba2d7..ec3b017cc8985f 100644
--- a/test/parallel/test-child-process-exec-maxBuffer.js
+++ b/test/parallel/test-child-process-exec-maxBuffer.js
@@ -15,11 +15,15 @@ function checkFactory(streamName) {
   const cmd = `"${process.execPath}" -e "console.log('hello world');"`;
   const options = { maxBuffer: Infinity };
 
-  cp.exec(cmd, options, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
-    assert.strictEqual(stdout.trim(), 'hello world');
-    assert.strictEqual(stderr, '');
-  }));
+  cp.exec(
+    cmd,
+    options,
+    common.mustCall((err, stdout, stderr) => {
+      assert.ifError(err);
+      assert.strictEqual(stdout.trim(), 'hello world');
+      assert.strictEqual(stderr, '');
+    })
+  );
 }
 
 {
@@ -48,7 +52,8 @@ const unicode = '中文测试'; // length = 4, byte length = 12
   const child = cp.exec(
     cmd,
     { encoding: null, maxBuffer: 10 },
-    checkFactory('stdout'));
+    checkFactory('stdout')
+  );
 
   child.stdout.setEncoding('utf-8');
 }
@@ -59,7 +64,8 @@ const unicode = '中文测试'; // length = 4, byte length = 12
   const child = cp.exec(
     cmd,
     { encoding: null, maxBuffer: 10 },
-    checkFactory('stderr'));
+    checkFactory('stderr')
+  );
 
   child.stderr.setEncoding('utf-8');
 }
diff --git a/test/parallel/test-child-process-exec-std-encoding.js b/test/parallel/test-child-process-exec-std-encoding.js
index 11cb66cf42cc5b..eedcab6691f841 100644
--- a/test/parallel/test-child-process-exec-std-encoding.js
+++ b/test/parallel/test-child-process-exec-std-encoding.js
@@ -13,11 +13,14 @@ if (process.argv[2] === 'child') {
   console.error(stderrData);
 } else {
   const cmd = `"${process.execPath}" "${__filename}" child`;
-  const child = cp.exec(cmd, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
-    assert.strictEqual(stdout, expectedStdout);
-    assert.strictEqual(stderr, expectedStderr);
-  }));
+  const child = cp.exec(
+    cmd,
+    common.mustCall((err, stdout, stderr) => {
+      assert.ifError(err);
+      assert.strictEqual(stdout, expectedStdout);
+      assert.strictEqual(stderr, expectedStderr);
+    })
+  );
   child.stdout.setEncoding('utf-8');
   child.stderr.setEncoding('utf-8');
 }
diff --git a/test/parallel/test-child-process-exec-stdout-stderr-data-string.js b/test/parallel/test-child-process-exec-stdout-stderr-data-string.js
index 1fbdfbf8e45b4d..c1016e02f29f5a 100644
--- a/test/parallel/test-child-process-exec-stdout-stderr-data-string.js
+++ b/test/parallel/test-child-process-exec-stdout-stderr-data-string.js
@@ -8,6 +8,9 @@ const command = common.isWindows ? 'dir' : 'ls';
 
 exec(command).stdout.on('data', common.mustCallAtLeast());
 
-exec('fhqwhgads').stderr.on('data', common.mustCallAtLeast((data) => {
-  assert.strictEqual(typeof data, 'string');
-}));
+exec('fhqwhgads').stderr.on(
+  'data',
+  common.mustCallAtLeast((data) => {
+    assert.strictEqual(typeof data, 'string');
+  })
+);
diff --git a/test/parallel/test-child-process-exec-timeout.js b/test/parallel/test-child-process-exec-timeout.js
index e08aff908522f2..a4e00d8134e8f5 100644
--- a/test/parallel/test-child-process-exec-timeout.js
+++ b/test/parallel/test-child-process-exec-timeout.js
@@ -15,44 +15,55 @@ if (process.argv[2] === 'child') {
 const cmd = `"${process.execPath}" "${__filename}" child`;
 
 // Test the case where a timeout is set, and it expires.
-cp.exec(cmd, { timeout: 1 }, common.mustCall((err, stdout, stderr) => {
-  let sigterm = 'SIGTERM';
-  assert.strictEqual(err.killed, true);
-  // TODO OpenBSD returns a null signal and 143 for code
-  if (common.isOpenBSD) {
-    assert.strictEqual(err.code, 143);
-    sigterm = null;
-  } else {
-    assert.strictEqual(err.code, null);
-  }
-  // At least starting with Darwin Kernel Version 16.4.0, sending a SIGTERM to a
-  // process that is still starting up kills it with SIGKILL instead of SIGTERM.
-  // See: https://github.com/libuv/libuv/issues/1226
-  if (common.isOSX)
-    assert.ok(err.signal === 'SIGTERM' || err.signal === 'SIGKILL');
-  else
-    assert.strictEqual(err.signal, sigterm);
-  assert.strictEqual(err.cmd, cmd);
-  assert.strictEqual(stdout.trim(), '');
-  assert.strictEqual(stderr.trim(), '');
-}));
+cp.exec(
+  cmd,
+  { timeout: 1 },
+  common.mustCall((err, stdout, stderr) => {
+    let sigterm = 'SIGTERM';
+    assert.strictEqual(err.killed, true);
+    // TODO OpenBSD returns a null signal and 143 for code
+    if (common.isOpenBSD) {
+      assert.strictEqual(err.code, 143);
+      sigterm = null;
+    } else {
+      assert.strictEqual(err.code, null);
+    }
+    // At least starting with Darwin Kernel Version 16.4.0, sending a SIGTERM to a
+    // process that is still starting up kills it with SIGKILL instead of SIGTERM.
+    // See: https://github.com/libuv/libuv/issues/1226
+    if (common.isOSX)
+      assert.ok(err.signal === 'SIGTERM' || err.signal === 'SIGKILL');
+    else assert.strictEqual(err.signal, sigterm);
+    assert.strictEqual(err.cmd, cmd);
+    assert.strictEqual(stdout.trim(), '');
+    assert.strictEqual(stderr.trim(), '');
+  })
+);
 
 // Test with a different kill signal.
-cp.exec(cmd, {
-  timeout: 1,
-  killSignal: 'SIGKILL'
-}, common.mustCall((err, stdout, stderr) => {
-  assert.strictEqual(err.killed, true);
-  assert.strictEqual(err.code, null);
-  assert.strictEqual(err.signal, 'SIGKILL');
-  assert.strictEqual(err.cmd, cmd);
-  assert.strictEqual(stdout.trim(), '');
-  assert.strictEqual(stderr.trim(), '');
-}));
+cp.exec(
+  cmd,
+  {
+    timeout: 1,
+    killSignal: 'SIGKILL'
+  },
+  common.mustCall((err, stdout, stderr) => {
+    assert.strictEqual(err.killed, true);
+    assert.strictEqual(err.code, null);
+    assert.strictEqual(err.signal, 'SIGKILL');
+    assert.strictEqual(err.cmd, cmd);
+    assert.strictEqual(stdout.trim(), '');
+    assert.strictEqual(stderr.trim(), '');
+  })
+);
 
 // Test the case where a timeout is set, but not expired.
-cp.exec(cmd, { timeout: 2 ** 30 }, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
-  assert.strictEqual(stdout.trim(), 'child stdout');
-  assert.strictEqual(stderr.trim(), 'child stderr');
-}));
+cp.exec(
+  cmd,
+  { timeout: 2 ** 30 },
+  common.mustCall((err, stdout, stderr) => {
+    assert.ifError(err);
+    assert.strictEqual(stdout.trim(), 'child stdout');
+    assert.strictEqual(stderr.trim(), 'child stderr');
+  })
+);
diff --git a/test/parallel/test-child-process-execfile.js b/test/parallel/test-child-process-execfile.js
index af69d685789d62..2b4cf799933dba 100644
--- a/test/parallel/test-child-process-execfile.js
+++ b/test/parallel/test-child-process-execfile.js
@@ -15,8 +15,10 @@ const execOpts = { encoding: 'utf8', shell: true };
     [fixture, 42],
     common.mustCall((e) => {
       // Check that arguments are included in message
-      assert.strictEqual(e.message.trim(),
-                         `Command failed: ${process.execPath} ${fixture} 42`);
+      assert.strictEqual(
+        e.message.trim(),
+        `Command failed: ${process.execPath} ${fixture} 42`
+      );
       assert.strictEqual(e.code, 42);
     })
   );
@@ -43,7 +45,12 @@ const execOpts = { encoding: 'utf8', shell: true };
 
 {
   // Verify the shell option works properly
-  execFile(process.execPath, [fixture, 0], execOpts, common.mustCall((err) => {
-    assert.ifError(err);
-  }));
+  execFile(
+    process.execPath,
+    [fixture, 0],
+    execOpts,
+    common.mustCall((err) => {
+      assert.ifError(err);
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-exit-code.js b/test/parallel/test-child-process-exit-code.js
index 7f5e54be42f69c..db8664f2966900 100644
--- a/test/parallel/test-child-process-exit-code.js
+++ b/test/parallel/test-child-process-exit-code.js
@@ -27,15 +27,20 @@ const fixtures = require('../common/fixtures');
 
 const exitScript = fixtures.path('exit.js');
 const exitChild = spawn(process.argv[0], [exitScript, 23]);
-exitChild.on('exit', common.mustCall(function(code, signal) {
-  assert.strictEqual(code, 23);
-  assert.strictEqual(signal, null);
-}));
-
+exitChild.on(
+  'exit',
+  common.mustCall(function(code, signal) {
+    assert.strictEqual(code, 23);
+    assert.strictEqual(signal, null);
+  })
+);
 
 const errorScript = fixtures.path('child_process_should_emit_error.js');
 const errorChild = spawn(process.argv[0], [errorScript]);
-errorChild.on('exit', common.mustCall(function(code, signal) {
-  assert.ok(code !== 0);
-  assert.strictEqual(signal, null);
-}));
+errorChild.on(
+  'exit',
+  common.mustCall(function(code, signal) {
+    assert.ok(code !== 0);
+    assert.strictEqual(signal, null);
+  })
+);
diff --git a/test/parallel/test-child-process-flush-stdio.js b/test/parallel/test-child-process-flush-stdio.js
index a7c1ea21be22a4..09cd93595d44ec 100644
--- a/test/parallel/test-child-process-flush-stdio.js
+++ b/test/parallel/test-child-process-flush-stdio.js
@@ -9,25 +9,35 @@ const opts = { shell: common.isWindows };
 
 const p = cp.spawn('echo', [], opts);
 
-p.on('close', common.mustCall((code, signal) => {
-  assert.strictEqual(code, 0);
-  assert.strictEqual(signal, null);
-  spawnWithReadable();
-}));
+p.on(
+  'close',
+  common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+    spawnWithReadable();
+  })
+);
 
 p.stdout.read();
 
 const spawnWithReadable = () => {
   const buffer = [];
   const p = cp.spawn('echo', ['123'], opts);
-  p.on('close', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-    assert.strictEqual(Buffer.concat(buffer).toString().trim(), '123');
-  }));
+  p.on(
+    'close',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+      assert.strictEqual(
+        Buffer.concat(buffer)
+          .toString()
+          .trim(),
+        '123'
+      );
+    })
+  );
   p.stdout.on('readable', () => {
     let buf;
-    while (buf = p.stdout.read())
-      buffer.push(buf);
+    while ((buf = p.stdout.read())) buffer.push(buf);
   });
 };
diff --git a/test/parallel/test-child-process-fork-and-spawn.js b/test/parallel/test-child-process-fork-and-spawn.js
index 88e634ba8b0522..9bbca0b44ab182 100644
--- a/test/parallel/test-child-process-fork-and-spawn.js
+++ b/test/parallel/test-child-process-fork-and-spawn.js
@@ -30,8 +30,10 @@ switch (process.argv[2] || '') {
     fork(__filename, ['fork']).on('exit', common.mustCall(checkExit));
     break;
   case 'fork':
-    spawn(process.execPath, [__filename, 'spawn'])
-      .on('exit', common.mustCall(checkExit));
+    spawn(process.execPath, [__filename, 'spawn']).on(
+      'exit',
+      common.mustCall(checkExit)
+    );
     break;
   case 'spawn':
     break;
diff --git a/test/parallel/test-child-process-fork-close.js b/test/parallel/test-child-process-fork-close.js
index bfaabd3d2f4e03..3dcc4f7a286815 100644
--- a/test/parallel/test-child-process-fork-close.js
+++ b/test/parallel/test-child-process-fork-close.js
@@ -31,22 +31,31 @@ let gotMessage = false;
 let gotExit = false;
 let gotClose = false;
 
-cp.on('message', common.mustCall(function(message) {
-  assert(!gotMessage);
-  assert(!gotClose);
-  assert.strictEqual(message, 'hello');
-  gotMessage = true;
-}));
+cp.on(
+  'message',
+  common.mustCall(function(message) {
+    assert(!gotMessage);
+    assert(!gotClose);
+    assert.strictEqual(message, 'hello');
+    gotMessage = true;
+  })
+);
 
-cp.on('exit', common.mustCall(function() {
-  assert(!gotExit);
-  assert(!gotClose);
-  gotExit = true;
-}));
+cp.on(
+  'exit',
+  common.mustCall(function() {
+    assert(!gotExit);
+    assert(!gotClose);
+    gotExit = true;
+  })
+);
 
-cp.on('close', common.mustCall(function() {
-  assert(gotMessage);
-  assert(gotExit);
-  assert(!gotClose);
-  gotClose = true;
-}));
+cp.on(
+  'close',
+  common.mustCall(function() {
+    assert(gotMessage);
+    assert(gotExit);
+    assert(!gotClose);
+    gotClose = true;
+  })
+);
diff --git a/test/parallel/test-child-process-fork-closed-channel-segfault.js b/test/parallel/test-child-process-fork-closed-channel-segfault.js
index c24a62379bf66e..9e97baf7f64367 100644
--- a/test/parallel/test-child-process-fork-closed-channel-segfault.js
+++ b/test/parallel/test-child-process-fork-closed-channel-segfault.js
@@ -42,9 +42,12 @@ const server = net
     });
 
     function send(callback) {
-      const s = net.connect(server.address().port, function() {
-        worker.send({}, s, callback);
-      });
+      const s = net.connect(
+        server.address().port,
+        function() {
+          worker.send({}, s, callback);
+        }
+      );
 
       // https://github.com/nodejs/node/issues/3635#issuecomment-157714683
       // ECONNREFUSED or ECONNRESET errors can happen if this connection is
@@ -76,10 +79,13 @@ const server = net
         send(function(err) {
           // Ignore errors when sending the second handle because the worker
           // may already have exited.
-          if (err && err.code !== 'ERR_IPC_CHANNEL_CLOSED' &&
-                     err.code !== 'ECONNRESET' &&
-                     err.code !== 'ECONNREFUSED' &&
-                     err.code !== 'EMFILE') {
+          if (
+            err &&
+            err.code !== 'ERR_IPC_CHANNEL_CLOSED' &&
+            err.code !== 'ECONNRESET' &&
+            err.code !== 'ECONNREFUSED' &&
+            err.code !== 'EMFILE'
+          ) {
             throw err;
           }
         });
diff --git a/test/parallel/test-child-process-fork-dgram.js b/test/parallel/test-child-process-fork-dgram.js
index 4aa36261dbb24b..45ad478335a77e 100644
--- a/test/parallel/test-child-process-fork-dgram.js
+++ b/test/parallel/test-child-process-fork-dgram.js
@@ -48,7 +48,6 @@ if (process.argv[2] === 'child') {
 
     process.send('handleReceived');
   });
-
 } else {
   const parentServer = dgram.createSocket('udp4');
   const client = dgram.createSocket('udp4');
@@ -70,7 +69,7 @@ if (process.argv[2] === 'child') {
     child.on('message', function(msg) {
       if (msg === 'gotMessage') {
         childGotMessage = true;
-      } else if (msg = 'handlReceived') {
+      } else if ((msg = 'handlReceived')) {
         sendMessages();
       }
     });
@@ -88,16 +87,9 @@ if (process.argv[2] === 'child') {
         clearInterval(timer);
         client.close();
       } else {
-        client.send(
-          msg,
-          0,
-          msg.length,
-          serverPort,
-          '127.0.0.1',
-          function(err) {
-            assert.ifError(err);
-          }
-        );
+        client.send(msg, 0, msg.length, serverPort, '127.0.0.1', function(err) {
+          assert.ifError(err);
+        });
       }
     }, 1);
   }
diff --git a/test/parallel/test-child-process-fork-exec-argv.js b/test/parallel/test-child-process-fork-exec-argv.js
index f1e3bbbc58ec66..530a348df6c002 100644
--- a/test/parallel/test-child-process-fork-exec-argv.js
+++ b/test/parallel/test-child-process-fork-exec-argv.js
@@ -43,7 +43,10 @@ if (process.argv[2] === 'fork') {
     out += chunk;
   });
 
-  child.on('exit', common.mustCall(function() {
-    assert.deepStrictEqual(JSON.parse(out), execArgv);
-  }));
+  child.on(
+    'exit',
+    common.mustCall(function() {
+      assert.deepStrictEqual(JSON.parse(out), execArgv);
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-fork-exec-path.js b/test/parallel/test-child-process-fork-exec-path.js
index cabd8893475630..bbef9c08cc023e 100644
--- a/test/parallel/test-child-process-fork-exec-path.js
+++ b/test/parallel/test-child-process-fork-exec-path.js
@@ -55,11 +55,17 @@ if (process.env.FORK) {
     execPath: copyPath,
     env: envCopy
   });
-  child.on('message', common.mustCall(function(recv) {
-    assert.deepStrictEqual(msg, recv);
-  }));
-  child.on('exit', common.mustCall(function(code) {
-    fs.unlinkSync(copyPath);
-    assert.strictEqual(code, 0);
-  }));
+  child.on(
+    'message',
+    common.mustCall(function(recv) {
+      assert.deepStrictEqual(msg, recv);
+    })
+  );
+  child.on(
+    'exit',
+    common.mustCall(function(code) {
+      fs.unlinkSync(copyPath);
+      assert.strictEqual(code, 0);
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-fork-net-server.js b/test/parallel/test-child-process-fork-net-server.js
index 340b3075f9622a..d7f84ee470e5fb 100644
--- a/test/parallel/test-child-process-fork-net-server.js
+++ b/test/parallel/test-child-process-fork-net-server.js
@@ -38,7 +38,6 @@ ProgressTracker.prototype.check = function() {
 };
 
 if (process.argv[2] === 'child') {
-
   let serverScope;
 
   process.on('message', function onServer(msg, server) {
@@ -70,17 +69,18 @@ if (process.argv[2] === 'child') {
 
   process.send({ what: 'ready' });
 } else {
-
   const child = fork(process.argv[1], ['child']);
 
-  child.on('exit', common.mustCall(function(code, signal) {
-    const message = `CHILD: died with ${code}, ${signal}`;
-    assert.strictEqual(code, 0, message);
-  }));
+  child.on(
+    'exit',
+    common.mustCall(function(code, signal) {
+      const message = `CHILD: died with ${code}, ${signal}`;
+      assert.strictEqual(code, 0, message);
+    })
+  );
 
   // Send net.Server to child and test by connecting.
   function testServer(callback) {
-
     // Destroy server execute callback when done.
     const progress = new ProgressTracker(2, function() {
       server.on('close', function() {
@@ -109,20 +109,21 @@ if (process.argv[2] === 'child') {
 
     // Handle client messages.
     function messageHandlers(msg) {
-
       if (msg.what === 'listening') {
         // Make connections.
         let socket;
         for (let i = 0; i < 4; i++) {
-          socket = net.connect(server.address().port, function() {
-            console.log('CLIENT: connected');
-          });
+          socket = net.connect(
+            server.address().port,
+            function() {
+              console.log('CLIENT: connected');
+            }
+          );
           socket.on('close', function() {
             closed.done();
             console.log('CLIENT: closed');
           });
         }
-
       } else if (msg.what === 'connection') {
         // child got connection
         connections.done();
diff --git a/test/parallel/test-child-process-fork-net-socket.js b/test/parallel/test-child-process-fork-net-socket.js
index 8e3d9ee16e2e56..1c91638f738613 100644
--- a/test/parallel/test-child-process-fork-net-socket.js
+++ b/test/parallel/test-child-process-fork-net-socket.js
@@ -26,7 +26,6 @@ const fork = require('child_process').fork;
 const net = require('net');
 
 if (process.argv[2] === 'child') {
-
   process.on('message', function onSocket(msg, socket) {
     if (msg.what !== 'socket') return;
     process.removeListener('message', onSocket);
@@ -36,17 +35,18 @@ if (process.argv[2] === 'child') {
 
   process.send({ what: 'ready' });
 } else {
-
   const child = fork(process.argv[1], ['child']);
 
-  child.on('exit', common.mustCall(function(code, signal) {
-    const message = `CHILD: died with ${code}, ${signal}`;
-    assert.strictEqual(code, 0, message);
-  }));
+  child.on(
+    'exit',
+    common.mustCall(function(code, signal) {
+      const message = `CHILD: died with ${code}, ${signal}`;
+      assert.strictEqual(code, 0, message);
+    })
+  );
 
   // Send net.Socket to child.
   function testSocket(callback) {
-
     // Create a new server and connect to it,
     // but the socket will be handled by the child.
     const server = net.createServer();
diff --git a/test/parallel/test-child-process-fork-net.js b/test/parallel/test-child-process-fork-net.js
index 48521a7fdafe08..7b6682ac70df38 100644
--- a/test/parallel/test-child-process-fork-net.js
+++ b/test/parallel/test-child-process-fork-net.js
@@ -78,9 +78,7 @@ if (process.argv[2] === 'child') {
       endMe.end('end');
     });
   });
-
 } else {
-
   const child1 = fork(process.argv[1], ['child', '1']);
   const child2 = fork(process.argv[1], ['child', '2']);
   const child3 = fork(process.argv[1], ['child', '3']);
@@ -92,17 +90,23 @@ if (process.argv[2] === 'child') {
   server.on('connection', function(socket) {
     switch (connected % 6) {
       case 0:
-        child1.send('end', socket); break;
+        child1.send('end', socket);
+        break;
       case 1:
-        child1.send('write', socket); break;
+        child1.send('write', socket);
+        break;
       case 2:
-        child2.send('end', socket); break;
+        child2.send('end', socket);
+        break;
       case 3:
-        child2.send('write', socket); break;
+        child2.send('write', socket);
+        break;
       case 4:
-        child3.send('end', socket); break;
+        child3.send('end', socket);
+        break;
       case 5:
-        child3.send('write', socket); break;
+        child3.send('write', socket);
+        break;
     }
     connected += 1;
 
@@ -117,10 +121,12 @@ if (process.argv[2] === 'child') {
 
   let disconnected = 0;
   server.on('listening', function() {
-
     let j = count;
     while (j--) {
-      const client = net.connect(this.address().port, '127.0.0.1');
+      const client = net.connect(
+        this.address().port,
+        '127.0.0.1'
+      );
       client.on('error', function() {
         // This can happen if we kill the subprocess too early.
         // The client should still get a close event afterwards.
@@ -135,13 +141,16 @@ if (process.argv[2] === 'child') {
   });
 
   let closeEmitted = false;
-  server.on('close', common.mustCall(function() {
-    closeEmitted = true;
-
-    child1.kill();
-    child2.kill();
-    child3.kill();
-  }));
+  server.on(
+    'close',
+    common.mustCall(function() {
+      closeEmitted = true;
+
+      child1.kill();
+      child2.kill();
+      child3.kill();
+    })
+  );
 
   server.listen(0, '127.0.0.1');
 
diff --git a/test/parallel/test-child-process-fork-no-shell.js b/test/parallel/test-child-process-fork-no-shell.js
index 168f115b0cbcbf..cca36894b3a238 100644
--- a/test/parallel/test-child-process-fork-no-shell.js
+++ b/test/parallel/test-child-process-fork-no-shell.js
@@ -11,10 +11,13 @@ if (process.argv[2] === undefined) {
     env: Object.assign({}, process.env, { foo: 'bar' })
   });
 
-  child.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  }));
+  child.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 } else {
   assert.strictEqual(process.argv[2], expected);
 }
diff --git a/test/parallel/test-child-process-fork-options.js b/test/parallel/test-child-process-fork-options.js
index 5efb9bdbb49735..27781dff824daf 100644
--- a/test/parallel/test-child-process-fork-options.js
+++ b/test/parallel/test-child-process-fork-options.js
@@ -11,27 +11,41 @@ const { fork } = require('child_process');
 const expectedEnv = { foo: 'bar' };
 
 {
-  const cp = fork(fixtures.path('child-process-echo-options.js'), undefined,
-                  { env: Object.assign({}, process.env, expectedEnv) });
-
-  cp.on('message', common.mustCall(({ env }) => {
-    assert.strictEqual(env.foo, expectedEnv.foo);
-  }));
-
-  cp.on('exit', common.mustCall((code) => {
-    assert.strictEqual(code, 0);
-  }));
+  const cp = fork(fixtures.path('child-process-echo-options.js'), undefined, {
+    env: Object.assign({}, process.env, expectedEnv)
+  });
+
+  cp.on(
+    'message',
+    common.mustCall(({ env }) => {
+      assert.strictEqual(env.foo, expectedEnv.foo);
+    })
+  );
+
+  cp.on(
+    'exit',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 0);
+    })
+  );
 }
 
 {
-  const cp = fork(fixtures.path('child-process-echo-options.js'), null,
-                  { env: Object.assign({}, process.env, expectedEnv) });
-
-  cp.on('message', common.mustCall(({ env }) => {
-    assert.strictEqual(env.foo, expectedEnv.foo);
-  }));
-
-  cp.on('exit', common.mustCall((code) => {
-    assert.strictEqual(code, 0);
-  }));
+  const cp = fork(fixtures.path('child-process-echo-options.js'), null, {
+    env: Object.assign({}, process.env, expectedEnv)
+  });
+
+  cp.on(
+    'message',
+    common.mustCall(({ env }) => {
+      assert.strictEqual(env.foo, expectedEnv.foo);
+    })
+  );
+
+  cp.on(
+    'exit',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 0);
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-fork-ref.js b/test/parallel/test-child-process-fork-ref.js
index 3eae2b242e9ce2..fed9780a983a1b 100644
--- a/test/parallel/test-child-process-fork-ref.js
+++ b/test/parallel/test-child-process-fork-ref.js
@@ -35,7 +35,6 @@ if (process.argv[2] === 'child') {
   process.on('disconnect', function() {
     process.stdout.write('3');
   });
-
 } else {
   const child = fork(__filename, ['child'], { silent: true });
 
diff --git a/test/parallel/test-child-process-fork-ref2.js b/test/parallel/test-child-process-fork-ref2.js
index f34d67ee17fcec..13e8e79b1eb858 100644
--- a/test/parallel/test-child-process-fork-ref2.js
+++ b/test/parallel/test-child-process-fork-ref2.js
@@ -31,7 +31,6 @@ if (process.argv[2] === 'child') {
     console.log('child -> will this keep it alive?');
     process.on('message', common.mustNotCall());
   }, 400);
-
 } else {
   const child = fork(__filename, ['child']);
 
diff --git a/test/parallel/test-child-process-fork-stdio-string-variant.js b/test/parallel/test-child-process-fork-stdio-string-variant.js
index 2bfcfc59e6343c..d5af84c1920052 100644
--- a/test/parallel/test-child-process-fork-stdio-string-variant.js
+++ b/test/parallel/test-child-process-fork-stdio-string-variant.js
@@ -13,16 +13,20 @@ const childScript = fixtures.path('child-process-spawn-node');
 const malFormedOpts = { stdio: '33' };
 const payload = { hello: 'world' };
 
-common.expectsError(
-  () => fork(childScript, malFormedOpts),
-  { code: 'ERR_INVALID_OPT_VALUE', type: TypeError });
+common.expectsError(() => fork(childScript, malFormedOpts), {
+  code: 'ERR_INVALID_OPT_VALUE',
+  type: TypeError
+});
 
 function test(stringVariant) {
   const child = fork(childScript, { stdio: stringVariant });
 
-  child.on('message', common.mustCall((message) => {
-    assert.deepStrictEqual(message, { foo: 'bar' });
-  }));
+  child.on(
+    'message',
+    common.mustCall((message) => {
+      assert.deepStrictEqual(message, { foo: 'bar' });
+    })
+  );
 
   child.send(payload);
 
diff --git a/test/parallel/test-child-process-fork-stdio.js b/test/parallel/test-child-process-fork-stdio.js
index d8e7abfe28944d..3bfa9c4272a44a 100644
--- a/test/parallel/test-child-process-fork-stdio.js
+++ b/test/parallel/test-child-process-fork-stdio.js
@@ -21,7 +21,8 @@ if (process.argv[2] === 'child') {
 } else {
   common.expectsError(
     () => cp.fork(__filename, { stdio: ['pipe', 'pipe', 'pipe', 'pipe'] }),
-    { code: 'ERR_CHILD_PROCESS_IPC_REQUIRED', type: Error });
+    { code: 'ERR_CHILD_PROCESS_IPC_REQUIRED', type: Error }
+  );
 
   let ipc = '';
   let stderr = '';
@@ -44,11 +45,14 @@ if (process.argv[2] === 'child') {
     stderr += chunk;
   });
 
-  child.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-    assert.strictEqual(stderr, 'this should not be ignored');
-  }));
+  child.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+      assert.strictEqual(stderr, 'this should not be ignored');
+    })
+  );
 
   child.stdio[4].write(buf);
 }
diff --git a/test/parallel/test-child-process-fork.js b/test/parallel/test-child-process-fork.js
index 6cfeeefb51952d..8052a64fa1a874 100644
--- a/test/parallel/test-child-process-fork.js
+++ b/test/parallel/test-child-process-fork.js
@@ -51,6 +51,9 @@ assert.throws(() => n.send(), {
 
 n.send({ hello: 'world' });
 
-n.on('exit', common.mustCall((c) => {
-  assert.strictEqual(c, 0);
-}));
+n.on(
+  'exit',
+  common.mustCall((c) => {
+    assert.strictEqual(c, 0);
+  })
+);
diff --git a/test/parallel/test-child-process-http-socket-leak.js b/test/parallel/test-child-process-http-socket-leak.js
index 553a3277532b04..82f831ae8b0ab1 100644
--- a/test/parallel/test-child-process-http-socket-leak.js
+++ b/test/parallel/test-child-process-http-socket-leak.js
@@ -23,35 +23,46 @@ const { kTimeout } = require('internal/timers');
 let child;
 let socket;
 
-const server = http.createServer(common.mustCall((req, res) => {
-  const r = {
-    method: req.method,
-    headers: req.headers,
-    path: req.path,
-    httpVersionMajor: req.httpVersionMajor,
-    query: req.query,
-  };
-
-  socket = res.socket;
-  child.send(r, socket);
-  server.close();
-}));
-
-server.listen(0, common.mustCall(() => {
-  child = fork(__filename, [ 'child' ]);
-  child.once('message', (msg) => {
-    assert.strictEqual(msg, 'ready');
-    const req = http.request({
-      port: server.address().port,
-    }, common.mustCall((res) => {
-      res.on('data', () => {});
-      res.on('end', common.mustCall(() => {
-        assert.strictEqual(socket[kTimeout]._idleTimeout, -1);
-        assert.strictEqual(socket.parser, null);
-        assert.strictEqual(socket._httpMessage, null);
-      }));
-    }));
-
-    req.end();
-  });
-}));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    const r = {
+      method: req.method,
+      headers: req.headers,
+      path: req.path,
+      httpVersionMajor: req.httpVersionMajor,
+      query: req.query
+    };
+
+    socket = res.socket;
+    child.send(r, socket);
+    server.close();
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    child = fork(__filename, ['child']);
+    child.once('message', (msg) => {
+      assert.strictEqual(msg, 'ready');
+      const req = http.request(
+        {
+          port: server.address().port
+        },
+        common.mustCall((res) => {
+          res.on('data', () => {});
+          res.on(
+            'end',
+            common.mustCall(() => {
+              assert.strictEqual(socket[kTimeout]._idleTimeout, -1);
+              assert.strictEqual(socket.parser, null);
+              assert.strictEqual(socket._httpMessage, null);
+            })
+          );
+        })
+      );
+
+      req.end();
+    });
+  })
+);
diff --git a/test/parallel/test-child-process-internal.js b/test/parallel/test-child-process-internal.js
index c6ce0a8e04718c..210550f8712dff 100644
--- a/test/parallel/test-child-process-internal.js
+++ b/test/parallel/test-child-process-internal.js
@@ -36,17 +36,21 @@ if (process.argv[2] === 'child') {
   process.send(internal);
 
   process.exit(0);
-
 } else {
-
   const fork = require('child_process').fork;
   const child = fork(process.argv[1], ['child']);
 
-  child.once('message', common.mustCall(function(data) {
-    assert.deepStrictEqual(data, normal);
-  }));
-
-  child.once('internalMessage', common.mustCall(function(data) {
-    assert.deepStrictEqual(data, internal);
-  }));
+  child.once(
+    'message',
+    common.mustCall(function(data) {
+      assert.deepStrictEqual(data, normal);
+    })
+  );
+
+  child.once(
+    'internalMessage',
+    common.mustCall(function(data) {
+      assert.deepStrictEqual(data, internal);
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-ipc-next-tick.js b/test/parallel/test-child-process-ipc-next-tick.js
index b23aefc85d11d8..786a33f368645b 100644
--- a/test/parallel/test-child-process-ipc-next-tick.js
+++ b/test/parallel/test-child-process-ipc-next-tick.js
@@ -10,15 +10,21 @@ for (let i = 0; i < NUM_MESSAGES; ++i) {
 }
 
 if (process.argv[2] === 'child') {
-  const received = values.map(() => { return false; });
+  const received = values.map(() => {
+    return false;
+  });
 
-  process.on('uncaughtException', common.mustCall((err) => {
-    received[err] = true;
-    const done = received.every((element) => { return element === true; });
+  process.on(
+    'uncaughtException',
+    common.mustCall((err) => {
+      received[err] = true;
+      const done = received.every((element) => {
+        return element === true;
+      });
 
-    if (done)
-      process.disconnect();
-  }, NUM_MESSAGES));
+      if (done) process.disconnect();
+    }, NUM_MESSAGES)
+  );
 
   process.on('message', (msg) => {
     // If messages are handled synchronously, throwing should break the IPC
@@ -30,10 +36,13 @@ if (process.argv[2] === 'child') {
 } else {
   const child = cp.fork(__filename, ['child']);
 
-  child.on('message', common.mustCall((msg) => {
-    assert.strictEqual(msg, 'ready');
-    values.forEach((value) => {
-      child.send(value);
-    });
-  }));
+  child.on(
+    'message',
+    common.mustCall((msg) => {
+      assert.strictEqual(msg, 'ready');
+      values.forEach((value) => {
+        child.send(value);
+      });
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-ipc.js b/test/parallel/test-child-process-ipc.js
index f1652a91e6968e..9a6b3623f62e75 100644
--- a/test/parallel/test-child-process-ipc.js
+++ b/test/parallel/test-child-process-ipc.js
@@ -60,7 +60,6 @@ child.stdout.on('end', function(data) {
   console.log('child end');
 });
 
-
 process.on('exit', function() {
   assert.ok(gotHelloWorld);
   assert.ok(gotEcho);
diff --git a/test/parallel/test-child-process-kill.js b/test/parallel/test-child-process-kill.js
index 6f986c0ffa932f..26f5478989e310 100644
--- a/test/parallel/test-child-process-kill.js
+++ b/test/parallel/test-child-process-kill.js
@@ -29,10 +29,13 @@ cat.stdout.on('end', common.mustCall());
 cat.stderr.on('data', common.mustNotCall());
 cat.stderr.on('end', common.mustCall());
 
-cat.on('exit', common.mustCall(function(code, signal) {
-  assert.strictEqual(code, null);
-  assert.strictEqual(signal, 'SIGTERM');
-}));
+cat.on(
+  'exit',
+  common.mustCall(function(code, signal) {
+    assert.strictEqual(code, null);
+    assert.strictEqual(signal, 'SIGTERM');
+  })
+);
 
 assert.strictEqual(cat.killed, false);
 cat.kill();
diff --git a/test/parallel/test-child-process-promisified.js b/test/parallel/test-child-process-promisified.js
index 877bf06662e4e0..041fede46177f3 100644
--- a/test/parallel/test-child-process-promisified.js
+++ b/test/parallel/test-child-process-promisified.js
@@ -8,44 +8,54 @@ const exec = promisify(child_process.exec);
 const execFile = promisify(child_process.execFile);
 
 {
-  exec(`${process.execPath} -p 42`).then(common.mustCall((obj) => {
-    assert.deepStrictEqual(obj, { stdout: '42\n', stderr: '' });
-  }));
+  exec(`${process.execPath} -p 42`).then(
+    common.mustCall((obj) => {
+      assert.deepStrictEqual(obj, { stdout: '42\n', stderr: '' });
+    })
+  );
 }
 
 {
-  execFile(process.execPath, ['-p', '42']).then(common.mustCall((obj) => {
-    assert.deepStrictEqual(obj, { stdout: '42\n', stderr: '' });
-  }));
+  execFile(process.execPath, ['-p', '42']).then(
+    common.mustCall((obj) => {
+      assert.deepStrictEqual(obj, { stdout: '42\n', stderr: '' });
+    })
+  );
 }
 
 {
-  exec('doesntexist').catch(common.mustCall((err) => {
-    assert(err.message.includes('doesntexist'));
-  }));
+  exec('doesntexist').catch(
+    common.mustCall((err) => {
+      assert(err.message.includes('doesntexist'));
+    })
+  );
 }
 
 {
-  execFile('doesntexist', ['-p', '42']).catch(common.mustCall((err) => {
-    assert(err.message.includes('doesntexist'));
-  }));
+  execFile('doesntexist', ['-p', '42']).catch(
+    common.mustCall((err) => {
+      assert(err.message.includes('doesntexist'));
+    })
+  );
 }
 const failingCodeWithStdoutErr =
   'console.log(42);console.error(43);process.exit(1)';
 {
-  exec(`${process.execPath} -e "${failingCodeWithStdoutErr}"`)
-    .catch(common.mustCall((err) => {
+  exec(`${process.execPath} -e "${failingCodeWithStdoutErr}"`).catch(
+    common.mustCall((err) => {
       assert.strictEqual(err.code, 1);
       assert.strictEqual(err.stdout, '42\n');
       assert.strictEqual(err.stderr, '43\n');
-    }));
+    })
+  );
 }
 
 {
-  execFile(process.execPath, ['-e', failingCodeWithStdoutErr])
-    .catch(common.mustCall((err) => {
+  execFile(process.execPath, ['-e', failingCodeWithStdoutErr]).catch(
+    common.mustCall((err) => {
       assert.strictEqual(err.code, 1);
       assert.strictEqual(err.stdout, '42\n');
       assert.strictEqual(err.stderr, '43\n');
-    }));
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-recv-handle.js b/test/parallel/test-child-process-recv-handle.js
index 24c6b07037f2d0..0391e907d1b9a8 100644
--- a/test/parallel/test-child-process-recv-handle.js
+++ b/test/parallel/test-child-process-recv-handle.js
@@ -28,10 +28,8 @@ const assert = require('assert');
 const net = require('net');
 const spawn = require('child_process').spawn;
 
-if (process.argv[2] === 'worker')
-  worker();
-else
-  master();
+if (process.argv[2] === 'worker') worker();
+else master();
 
 function master() {
   // spawn() can only create one IPC channel so we use stdin/stdout as an
@@ -43,41 +41,50 @@ function master() {
   proc.on('exit', () => {
     handle.close();
   });
-  proc.stdout.on('data', common.mustCall((data) => {
-    assert.strictEqual(data.toString(), 'ok\r\n');
-    net.createServer(common.mustNotCall()).listen(0, function() {
-      handle = this._handle;
-      proc.send('one');
-      proc.send('two', handle);
-      proc.send('three');
-      proc.stdin.write('ok\r\n');
-    });
-  }));
+  proc.stdout.on(
+    'data',
+    common.mustCall((data) => {
+      assert.strictEqual(data.toString(), 'ok\r\n');
+      net.createServer(common.mustNotCall()).listen(0, function() {
+        handle = this._handle;
+        proc.send('one');
+        proc.send('two', handle);
+        proc.send('three');
+        proc.stdin.write('ok\r\n');
+      });
+    })
+  );
   proc.stderr.pipe(process.stderr);
 }
 
 function worker() {
-  process.channel.readStop();  // Make messages batch up.
+  process.channel.readStop(); // Make messages batch up.
   process.stdout.ref();
   process.stdout.write('ok\r\n');
-  process.stdin.once('data', common.mustCall((data) => {
-    assert.strictEqual(data.toString(), 'ok\r\n');
-    process.channel.readStart();
-  }));
+  process.stdin.once(
+    'data',
+    common.mustCall((data) => {
+      assert.strictEqual(data.toString(), 'ok\r\n');
+      process.channel.readStart();
+    })
+  );
   let n = 0;
-  process.on('message', common.mustCall((msg, handle) => {
-    n += 1;
-    if (n === 1) {
-      assert.strictEqual(msg, 'one');
-      assert.strictEqual(handle, undefined);
-    } else if (n === 2) {
-      assert.strictEqual(msg, 'two');
-      assert.ok(handle !== null && typeof handle === 'object');
-      handle.close();
-    } else if (n === 3) {
-      assert.strictEqual(msg, 'three');
-      assert.strictEqual(handle, undefined);
-      process.exit();
-    }
-  }, 3));
+  process.on(
+    'message',
+    common.mustCall((msg, handle) => {
+      n += 1;
+      if (n === 1) {
+        assert.strictEqual(msg, 'one');
+        assert.strictEqual(handle, undefined);
+      } else if (n === 2) {
+        assert.strictEqual(msg, 'two');
+        assert.ok(handle !== null && typeof handle === 'object');
+        handle.close();
+      } else if (n === 3) {
+        assert.strictEqual(msg, 'three');
+        assert.strictEqual(handle, undefined);
+        process.exit();
+      }
+    }, 3)
+  );
 }
diff --git a/test/parallel/test-child-process-send-after-close.js b/test/parallel/test-child-process-send-after-close.js
index 4e26d1261866a0..bbc25186c5439d 100644
--- a/test/parallel/test-child-process-send-after-close.js
+++ b/test/parallel/test-child-process-send-after-close.js
@@ -7,25 +7,31 @@ const fixtures = require('../common/fixtures');
 const fixture = fixtures.path('empty.js');
 const child = cp.fork(fixture);
 
-child.on('close', common.mustCall((code, signal) => {
-  assert.strictEqual(code, 0);
-  assert.strictEqual(signal, null);
+child.on(
+  'close',
+  common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
 
-  const testError = common.expectsError({
-    type: Error,
-    message: 'Channel closed',
-    code: 'ERR_IPC_CHANNEL_CLOSED'
-  }, 2);
+    const testError = common.expectsError(
+      {
+        type: Error,
+        message: 'Channel closed',
+        code: 'ERR_IPC_CHANNEL_CLOSED'
+      },
+      2
+    );
 
-  child.on('error', testError);
+    child.on('error', testError);
 
-  {
-    const result = child.send('ping');
-    assert.strictEqual(result, false);
-  }
+    {
+      const result = child.send('ping');
+      assert.strictEqual(result, false);
+    }
 
-  {
-    const result = child.send('pong', testError);
-    assert.strictEqual(result, false);
-  }
-}));
+    {
+      const result = child.send('pong', testError);
+      assert.strictEqual(result, false);
+    }
+  })
+);
diff --git a/test/parallel/test-child-process-send-cb.js b/test/parallel/test-child-process-send-cb.js
index daecd722533f57..5d465b3b5e1314 100644
--- a/test/parallel/test-child-process-send-cb.js
+++ b/test/parallel/test-child-process-send-cb.js
@@ -4,16 +4,25 @@ const assert = require('assert');
 const fork = require('child_process').fork;
 
 if (process.argv[2] === 'child') {
-  process.send('ok', common.mustCall((err) => {
-    assert.strictEqual(err, null);
-  }));
+  process.send(
+    'ok',
+    common.mustCall((err) => {
+      assert.strictEqual(err, null);
+    })
+  );
 } else {
   const child = fork(process.argv[1], ['child']);
-  child.on('message', common.mustCall((message) => {
-    assert.strictEqual(message, 'ok');
-  }));
-  child.on('exit', common.mustCall((exitCode, signalCode) => {
-    assert.strictEqual(exitCode, 0);
-    assert.strictEqual(signalCode, null);
-  }));
+  child.on(
+    'message',
+    common.mustCall((message) => {
+      assert.strictEqual(message, 'ok');
+    })
+  );
+  child.on(
+    'exit',
+    common.mustCall((exitCode, signalCode) => {
+      assert.strictEqual(exitCode, 0);
+      assert.strictEqual(signalCode, null);
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-send-keep-open.js b/test/parallel/test-child-process-send-keep-open.js
index 2d8a28121ac1fb..d655288b666c3c 100644
--- a/test/parallel/test-child-process-send-keep-open.js
+++ b/test/parallel/test-child-process-send-keep-open.js
@@ -18,35 +18,52 @@ if (process.argv[2] !== 'child') {
   const child = cp.fork(__filename, ['child']);
 
   // Verify that the child exits successfully
-  child.on('exit', common.mustCall((exitCode, signalCode) => {
-    assert.strictEqual(exitCode, 0);
-    assert.strictEqual(signalCode, null);
-  }));
+  child.on(
+    'exit',
+    common.mustCall((exitCode, signalCode) => {
+      assert.strictEqual(exitCode, 0);
+      assert.strictEqual(signalCode, null);
+    })
+  );
 
   const server = net.createServer((socket) => {
-    child.on('message', common.mustCall((msg) => {
-      assert.strictEqual(msg, 'child_done');
-      socket.end('parent', () => {
-        server.close();
-        child.disconnect();
-      });
-    }));
+    child.on(
+      'message',
+      common.mustCall((msg) => {
+        assert.strictEqual(msg, 'child_done');
+        socket.end('parent', () => {
+          server.close();
+          child.disconnect();
+        });
+      })
+    );
 
-    child.send('socket', socket, { keepOpen: true }, common.mustCall((err) => {
-      assert.ifError(err);
-    }));
+    child.send(
+      'socket',
+      socket,
+      { keepOpen: true },
+      common.mustCall((err) => {
+        assert.ifError(err);
+      })
+    );
   });
 
   server.listen(0, () => {
-    const socket = net.connect(server.address().port, common.localhostIPv4);
+    const socket = net.connect(
+      server.address().port,
+      common.localhostIPv4
+    );
     socket.setEncoding('utf8');
-    socket.on('data', (data) => result += data);
+    socket.on('data', (data) => (result += data));
   });
 } else {
   // The child process receives the socket from the parent, writes data to
   // the socket, then signals the parent process to write
-  process.on('message', common.mustCall((msg, socket) => {
-    assert.strictEqual(msg, 'socket');
-    socket.write('child', () => process.send('child_done'));
-  }));
+  process.on(
+    'message',
+    common.mustCall((msg, socket) => {
+      assert.strictEqual(msg, 'socket');
+      socket.write('child', () => process.send('child_done'));
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-send-returns-boolean.js b/test/parallel/test-child-process-send-returns-boolean.js
index 8c3ef46438379c..3f35a16e58fa59 100644
--- a/test/parallel/test-child-process-send-returns-boolean.js
+++ b/test/parallel/test-child-process-send-returns-boolean.js
@@ -33,19 +33,27 @@ const subScript = fixtures.path('child-process-persistent.js');
 
     // Sending a handle and not giving the tickQueue time to acknowledge should
     // create the internal backlog, but leave it empty.
-    const rv1 = s.send('one', handle, (err) => { if (err) assert.fail(err); });
+    const rv1 = s.send('one', handle, (err) => {
+      if (err) assert.fail(err);
+    });
     assert.strictEqual(rv1, true);
     // Since the first `send` included a handle (should be unacknowledged),
     // we can safely queue up only one more message.
-    const rv2 = s.send('two', (err) => { if (err) assert.fail(err); });
+    const rv2 = s.send('two', (err) => {
+      if (err) assert.fail(err);
+    });
     assert.strictEqual(rv2, true);
     // The backlog should now be indicate to backoff.
-    const rv3 = s.send('three', (err) => { if (err) assert.fail(err); });
+    const rv3 = s.send('three', (err) => {
+      if (err) assert.fail(err);
+    });
     assert.strictEqual(rv3, false);
     const rv4 = s.send('four', (err) => {
       if (err) assert.fail(err);
       // `send` queue should have been drained.
-      const rv5 = s.send('5', handle, (err) => { if (err) assert.fail(err); });
+      const rv5 = s.send('5', handle, (err) => {
+        if (err) assert.fail(err);
+      });
       assert.strictEqual(rv5, true);
 
       // End test and cleanup.
diff --git a/test/parallel/test-child-process-send-type-error.js b/test/parallel/test-child-process-send-type-error.js
index 9c3a502a49a257..541e07ce318ff4 100644
--- a/test/parallel/test-child-process-send-type-error.js
+++ b/test/parallel/test-child-process-send-type-error.js
@@ -5,19 +5,25 @@ const assert = require('assert');
 const cp = require('child_process');
 
 function fail(proc, args) {
-  common.expectsError(() => {
-    proc.send.apply(proc, args);
-  }, { code: 'ERR_INVALID_ARG_TYPE', type: TypeError });
+  common.expectsError(
+    () => {
+      proc.send.apply(proc, args);
+    },
+    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
+  );
 }
 
 let target = process;
 
 if (process.argv[2] !== 'child') {
   target = cp.fork(__filename, ['child']);
-  target.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  }));
+  target.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 }
 
 fail(target, ['msg', null, null]);
diff --git a/test/parallel/test-child-process-send-utf8.js b/test/parallel/test-child-process-send-utf8.js
index 2609dd0d6d6393..a164ae8a09cc19 100644
--- a/test/parallel/test-child-process-send-utf8.js
+++ b/test/parallel/test-child-process-send-utf8.js
@@ -29,7 +29,10 @@ if (process.argv[2] === 'child') {
   process.send(expected);
 } else {
   const child = fork(process.argv[1], ['child']);
-  child.on('message', common.mustCall((actual) => {
-    assert.strictEqual(actual, expected);
-  }));
+  child.on(
+    'message',
+    common.mustCall((actual) => {
+      assert.strictEqual(actual, expected);
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-set-blocking.js b/test/parallel/test-child-process-set-blocking.js
index 51a079ef5fac73..89897e5e61c64d 100644
--- a/test/parallel/test-child-process-set-blocking.js
+++ b/test/parallel/test-child-process-set-blocking.js
@@ -30,6 +30,9 @@ const cp = ch.spawn('python', ['-c', `print ${SIZE} * "C"`], {
   stdio: 'inherit'
 });
 
-cp.on('exit', common.mustCall(function(code) {
-  assert.strictEqual(code, 0);
-}));
+cp.on(
+  'exit',
+  common.mustCall(function(code) {
+    assert.strictEqual(code, 0);
+  })
+);
diff --git a/test/parallel/test-child-process-silent.js b/test/parallel/test-child-process-silent.js
index ce916306d14e42..356b777ec3c7c9 100644
--- a/test/parallel/test-child-process-silent.js
+++ b/test/parallel/test-child-process-silent.js
@@ -28,14 +28,12 @@ const childProcess = require('child_process');
 if (process.argv[2] === 'pipe') {
   process.stdout.write('stdout message');
   process.stderr.write('stderr message');
-
 } else if (process.argv[2] === 'ipc') {
   // Child IPC test
   process.send('message from child');
   process.on('message', function() {
     process.send('got message from master');
   });
-
 } else if (process.argv[2] === 'parent') {
   // Parent | start child pipe test
 
@@ -48,7 +46,6 @@ if (process.argv[2] === 'pipe') {
   child.on('exit', function() {
     process.exit(0);
   });
-
 } else {
   // testcase | start parent && child IPC test
 
@@ -70,18 +67,24 @@ if (process.argv[2] === 'pipe') {
   const child = childProcess.fork(process.argv[1], ['ipc'], { silent: true });
 
   // Manual pipe so we will get errors
-  child.stderr.pipe(process.stderr, { end: false });
-  child.stdout.pipe(process.stdout, { end: false });
+  child.stderr.pipe(
+    process.stderr,
+    { end: false }
+  );
+  child.stdout.pipe(
+    process.stdout,
+    { end: false }
+  );
 
   let childSending = false;
   let childReceiving = false;
   child.on('message', function(message) {
     if (childSending === false) {
-      childSending = (message === 'message from child');
+      childSending = message === 'message from child';
     }
 
     if (childReceiving === false) {
-      childReceiving = (message === 'got message from master');
+      childReceiving = message === 'got message from master';
     }
 
     if (childReceiving === true) {
diff --git a/test/parallel/test-child-process-spawn-argv0.js b/test/parallel/test-child-process-spawn-argv0.js
index a426fe8053bbd8..a6767edd413eb4 100644
--- a/test/parallel/test-child-process-spawn-argv0.js
+++ b/test/parallel/test-child-process-spawn-argv0.js
@@ -13,6 +13,7 @@ if (process.argv[2] === 'child') {
 const noArgv0 = cp.spawnSync(process.execPath, [__filename, 'child']);
 assert.strictEqual(noArgv0.stdout.toString().trim(), process.execPath);
 
-const withArgv0 = cp.spawnSync(process.execPath, [__filename, 'child'],
-                               { argv0: 'withArgv0' });
+const withArgv0 = cp.spawnSync(process.execPath, [__filename, 'child'], {
+  argv0: 'withArgv0'
+});
 assert.strictEqual(withArgv0.stdout.toString().trim(), 'withArgv0');
diff --git a/test/parallel/test-child-process-spawn-error.js b/test/parallel/test-child-process-spawn-error.js
index 28591f88fa0e39..425d74d6a73640 100644
--- a/test/parallel/test-child-process-spawn-error.js
+++ b/test/parallel/test-child-process-spawn-error.js
@@ -30,10 +30,13 @@ const spawnargs = ['bar'];
 assert.strictEqual(fs.existsSync(enoentPath), false);
 
 const enoentChild = spawn(enoentPath, spawnargs);
-enoentChild.on('error', common.mustCall(function(err) {
-  assert.strictEqual(err.code, 'ENOENT');
-  assert.strictEqual(err.errno, 'ENOENT');
-  assert.strictEqual(err.syscall, `spawn ${enoentPath}`);
-  assert.strictEqual(err.path, enoentPath);
-  assert.deepStrictEqual(err.spawnargs, spawnargs);
-}));
+enoentChild.on(
+  'error',
+  common.mustCall(function(err) {
+    assert.strictEqual(err.code, 'ENOENT');
+    assert.strictEqual(err.errno, 'ENOENT');
+    assert.strictEqual(err.syscall, `spawn ${enoentPath}`);
+    assert.strictEqual(err.path, enoentPath);
+    assert.deepStrictEqual(err.spawnargs, spawnargs);
+  })
+);
diff --git a/test/parallel/test-child-process-spawn-shell.js b/test/parallel/test-child-process-spawn-shell.js
index e9a753e91a4e48..de2fcf92123a0a 100644
--- a/test/parallel/test-child-process-spawn-shell.js
+++ b/test/parallel/test-child-process-spawn-shell.js
@@ -8,14 +8,16 @@ const doesNotExist = cp.spawn('does-not-exist', { shell: true });
 
 assert.notStrictEqual(doesNotExist.spawnfile, 'does-not-exist');
 doesNotExist.on('error', common.mustNotCall());
-doesNotExist.on('exit', common.mustCall((code, signal) => {
-  assert.strictEqual(signal, null);
+doesNotExist.on(
+  'exit',
+  common.mustCall((code, signal) => {
+    assert.strictEqual(signal, null);
 
-  if (common.isWindows)
-    assert.strictEqual(code, 1);    // Exit code of cmd.exe
-  else
-    assert.strictEqual(code, 127);  // Exit code of /bin/sh
-}));
+    if (common.isWindows) assert.strictEqual(code, 1);
+    // Exit code of cmd.exe
+    else assert.strictEqual(code, 127); // Exit code of /bin/sh
+  })
+);
 
 // Verify that passing arguments works
 const echo = cp.spawn('echo', ['foo'], {
@@ -24,14 +26,19 @@ const echo = cp.spawn('echo', ['foo'], {
 });
 let echoOutput = '';
 
-assert.strictEqual(echo.spawnargs[echo.spawnargs.length - 1].replace(/"/g, ''),
-                   'echo foo');
+assert.strictEqual(
+  echo.spawnargs[echo.spawnargs.length - 1].replace(/"/g, ''),
+  'echo foo'
+);
 echo.stdout.on('data', (data) => {
   echoOutput += data;
 });
-echo.on('close', common.mustCall((code, signal) => {
-  assert.strictEqual(echoOutput.trim(), 'foo');
-}));
+echo.on(
+  'close',
+  common.mustCall((code, signal) => {
+    assert.strictEqual(echoOutput.trim(), 'foo');
+  })
+);
 
 // Verify that shell features can be used
 const cmd = 'echo bar | cat';
@@ -44,9 +51,12 @@ let commandOutput = '';
 command.stdout.on('data', (data) => {
   commandOutput += data;
 });
-command.on('close', common.mustCall((code, signal) => {
-  assert.strictEqual(commandOutput.trim(), 'bar');
-}));
+command.on(
+  'close',
+  common.mustCall((code, signal) => {
+    assert.strictEqual(commandOutput.trim(), 'bar');
+  })
+);
 
 // Verify that the environment is properly inherited
 const env = cp.spawn(`"${process.execPath}" -pe process.env.BAZ`, {
@@ -59,6 +69,9 @@ let envOutput = '';
 env.stdout.on('data', (data) => {
   envOutput += data;
 });
-env.on('close', common.mustCall((code, signal) => {
-  assert.strictEqual(envOutput.trim(), 'buzz');
-}));
+env.on(
+  'close',
+  common.mustCall((code, signal) => {
+    assert.strictEqual(envOutput.trim(), 'buzz');
+  })
+);
diff --git a/test/parallel/test-child-process-spawn-typeerror.js b/test/parallel/test-child-process-spawn-typeerror.js
index 82acaf8e088038..e515f99f782626 100644
--- a/test/parallel/test-child-process-spawn-typeerror.js
+++ b/test/parallel/test-child-process-spawn-typeerror.js
@@ -29,11 +29,15 @@ const invalidcmd = 'hopefully_you_dont_have_this_on_your_machine';
 
 const empty = fixtures.path('empty.js');
 
-const invalidArgValueError =
-  common.expectsError({ code: 'ERR_INVALID_ARG_VALUE', type: TypeError }, 14);
+const invalidArgValueError = common.expectsError(
+  { code: 'ERR_INVALID_ARG_VALUE', type: TypeError },
+  14
+);
 
-const invalidArgTypeError =
-  common.expectsError({ code: 'ERR_INVALID_ARG_TYPE', type: TypeError }, 13);
+const invalidArgTypeError = common.expectsError(
+  { code: 'ERR_INVALID_ARG_TYPE', type: TypeError },
+  13
+);
 
 assert.throws(function() {
   spawn(invalidcmd, 'this is not an array');
@@ -55,7 +59,11 @@ assert.throws(function() {
 }, invalidArgValueError);
 
 assert.throws(function() {
-  const file = { toString() { return null; } };
+  const file = {
+    toString() {
+      return null;
+    }
+  };
   spawn(file);
 }, invalidArgTypeError);
 
@@ -105,12 +113,19 @@ spawn(cmd, o);
 spawn(cmd, u, o);
 spawn(cmd, a, u);
 
-assert.throws(function() { spawn(cmd, n, o); }, invalidArgTypeError);
-assert.throws(function() { spawn(cmd, a, n); }, invalidArgTypeError);
-
-assert.throws(function() { spawn(cmd, s); }, invalidArgTypeError);
-assert.throws(function() { spawn(cmd, a, s); }, invalidArgTypeError);
+assert.throws(function() {
+  spawn(cmd, n, o);
+}, invalidArgTypeError);
+assert.throws(function() {
+  spawn(cmd, a, n);
+}, invalidArgTypeError);
 
+assert.throws(function() {
+  spawn(cmd, s);
+}, invalidArgTypeError);
+assert.throws(function() {
+  spawn(cmd, a, s);
+}, invalidArgTypeError);
 
 // Verify that execFile has same argument parsing behavior as spawn.
 //
@@ -158,17 +173,39 @@ execFile(cmd, c, n);
 // String is invalid in arg position (this may seem strange, but is
 // consistent across node API, cf. `net.createServer('not options', 'not
 // callback')`.
-assert.throws(function() { execFile(cmd, s, o, c); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, a, s, c); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, a, o, s); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, a, s); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, o, s); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, u, u, s); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, n, n, s); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, a, u, s); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, a, n, s); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, u, o, s); }, invalidArgValueError);
-assert.throws(function() { execFile(cmd, n, o, s); }, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, s, o, c);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, a, s, c);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, a, o, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, a, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, o, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, u, u, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, n, n, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, a, u, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, a, n, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, u, o, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  execFile(cmd, n, o, s);
+}, invalidArgValueError);
 
 execFile(cmd, c, s); // Should not throw.
 
@@ -190,5 +227,9 @@ fork(empty, n, n);
 fork(empty, n, o);
 fork(empty, a, n);
 
-assert.throws(function() { fork(empty, s); }, invalidArgValueError);
-assert.throws(function() { fork(empty, a, s); }, invalidArgValueError);
+assert.throws(function() {
+  fork(empty, s);
+}, invalidArgValueError);
+assert.throws(function() {
+  fork(empty, a, s);
+}, invalidArgValueError);
diff --git a/test/parallel/test-child-process-spawnsync-input.js b/test/parallel/test-child-process-spawnsync-input.js
index 6e4a22c0e32d97..582d9147715049 100644
--- a/test/parallel/test-child-process-spawnsync-input.js
+++ b/test/parallel/test-child-process-spawnsync-input.js
@@ -33,14 +33,10 @@ const msgErr = 'this is stderr';
 const msgOutBuf = Buffer.from(`${msgOut}\n`);
 const msgErrBuf = Buffer.from(`${msgErr}\n`);
 
-const args = [
-  '-e',
-  `console.log("${msgOut}"); console.error("${msgErr}");`
-];
+const args = ['-e', `console.log("${msgOut}"); console.error("${msgErr}");`];
 
 let ret;
 
-
 function checkSpawnSyncRet(ret) {
   assert.strictEqual(ret.status, 0);
   assert.strictEqual(ret.error, undefined);
@@ -76,9 +72,10 @@ let options = {
   input: 1234
 };
 
-common.expectsError(
-  () => spawnSync('cat', [], options),
-  { code: 'ERR_INVALID_ARG_TYPE', type: TypeError });
+common.expectsError(() => spawnSync('cat', [], options), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError
+});
 
 options = {
   input: 'hello world'
diff --git a/test/parallel/test-child-process-spawnsync-kill-signal.js b/test/parallel/test-child-process-spawnsync-kill-signal.js
index 90222e04c97c9e..1a27f76ea74b3b 100644
--- a/test/parallel/test-child-process-spawnsync-kill-signal.js
+++ b/test/parallel/test-child-process-spawnsync-kill-signal.js
@@ -18,20 +18,23 @@ if (process.argv[2] === 'child') {
         return oldSpawnSync(opts);
       });
     }
-    const child = cp.spawnSync(process.execPath,
-                               [__filename, 'child'],
-                               { killSignal, timeout: 100 });
-    if (beforeSpawn)
-      internalCp.spawnSync = oldSpawnSync;
+    const child = cp.spawnSync(process.execPath, [__filename, 'child'], {
+      killSignal,
+      timeout: 100
+    });
+    if (beforeSpawn) internalCp.spawnSync = oldSpawnSync;
     assert.strictEqual(child.status, null);
     assert.strictEqual(child.error.code, 'ETIMEDOUT');
     return child;
   }
 
   // Verify that an error is thrown for unknown signals.
-  common.expectsError(() => {
-    spawn('SIG_NOT_A_REAL_SIGNAL');
-  }, { code: 'ERR_UNKNOWN_SIGNAL', type: TypeError });
+  common.expectsError(
+    () => {
+      spawn('SIG_NOT_A_REAL_SIGNAL');
+    },
+    { code: 'ERR_UNKNOWN_SIGNAL', type: TypeError }
+  );
 
   // Verify that the default kill signal is SIGTERM.
   {
diff --git a/test/parallel/test-child-process-spawnsync-maxbuf.js b/test/parallel/test-child-process-spawnsync-maxbuf.js
index 022c090c338d13..c0dc0988c49b5d 100644
--- a/test/parallel/test-child-process-spawnsync-maxbuf.js
+++ b/test/parallel/test-child-process-spawnsync-maxbuf.js
@@ -9,10 +9,7 @@ const spawnSync = require('child_process').spawnSync;
 const msgOut = 'this is stdout';
 const msgOutBuf = Buffer.from(`${msgOut}\n`);
 
-const args = [
-  '-e',
-  `console.log("${msgOut}");`
-];
+const args = ['-e', `console.log("${msgOut}");`];
 
 // Verify that an error is returned if maxBuffer is surpassed.
 {
diff --git a/test/parallel/test-child-process-spawnsync-shell.js b/test/parallel/test-child-process-spawnsync-shell.js
index 01c5aef9e8d919..ba20e737e5342e 100644
--- a/test/parallel/test-child-process-spawnsync-shell.js
+++ b/test/parallel/test-child-process-spawnsync-shell.js
@@ -13,15 +13,16 @@ assert.notStrictEqual(doesNotExist.file, 'does-not-exist');
 assert.strictEqual(doesNotExist.error, undefined);
 assert.strictEqual(doesNotExist.signal, null);
 
-if (common.isWindows)
-  assert.strictEqual(doesNotExist.status, 1);    // Exit code of cmd.exe
-else
-  assert.strictEqual(doesNotExist.status, 127);  // Exit code of /bin/sh
+if (common.isWindows) assert.strictEqual(doesNotExist.status, 1);
+// Exit code of cmd.exe
+else assert.strictEqual(doesNotExist.status, 127); // Exit code of /bin/sh
 
 // Verify that passing arguments works
 internalCp.spawnSync = common.mustCall(function(opts) {
-  assert.strictEqual(opts.args[opts.args.length - 1].replace(/"/g, ''),
-                     'echo foo');
+  assert.strictEqual(
+    opts.args[opts.args.length - 1].replace(/"/g, ''),
+    'echo foo'
+  );
   return oldSpawnSync(opts);
 });
 const echo = cp.spawnSync('echo', ['foo'], { shell: true });
@@ -62,14 +63,19 @@ assert.strictEqual(env.stdout.toString().trim(), 'buzz');
     const windowsVerbatim = isCmd ? true : undefined;
     internalCp.spawnSync = common.mustCall(function(opts) {
       assert.strictEqual(opts.file, shellOutput);
-      assert.deepStrictEqual(opts.args,
-                             [shellOutput, ...shellFlags, outputCmd]);
+      assert.deepStrictEqual(opts.args, [
+        shellOutput,
+        ...shellFlags,
+        outputCmd
+      ]);
       assert.strictEqual(opts.options.shell, shell);
       assert.strictEqual(opts.options.file, opts.file);
       assert.deepStrictEqual(opts.options.args, opts.args);
       assert.strictEqual(opts.options.windowsHide, undefined);
-      assert.strictEqual(opts.options.windowsVerbatimArguments,
-                         windowsVerbatim);
+      assert.strictEqual(
+        opts.options.windowsVerbatimArguments,
+        windowsVerbatim
+      );
     });
     cp.spawnSync(cmd, { shell });
     internalCp.spawnSync = oldSpawnSync;
@@ -99,6 +105,5 @@ assert.strictEqual(env.stdout.toString().trim(), 'buzz');
   platform = originalPlatform;
 
   // Restore the original comspec environment variable if necessary.
-  if (originalComspec)
-    process.env.comspec = originalComspec;
+  if (originalComspec) process.env.comspec = originalComspec;
 }
diff --git a/test/parallel/test-child-process-spawnsync-timeout.js b/test/parallel/test-child-process-spawnsync-timeout.js
index 35df6cee22f5f2..102bff181640e8 100644
--- a/test/parallel/test-child-process-spawnsync-timeout.js
+++ b/test/parallel/test-child-process-spawnsync-timeout.js
@@ -37,8 +37,9 @@ switch (process.argv[2]) {
     break;
   default:
     const start = Date.now();
-    const ret = spawnSync(process.execPath, [__filename, 'child'],
-                          { timeout: TIMER });
+    const ret = spawnSync(process.execPath, [__filename, 'child'], {
+      timeout: TIMER
+    });
     assert.strictEqual(ret.error.errno, 'ETIMEDOUT');
     const end = Date.now() - start;
     assert(end < SLEEP);
diff --git a/test/parallel/test-child-process-spawnsync-validation-errors.js b/test/parallel/test-child-process-spawnsync-validation-errors.js
index 17545d4af7bf50..95b69a702b6e6a 100644
--- a/test/parallel/test-child-process-spawnsync-validation-errors.js
+++ b/test/parallel/test-child-process-spawnsync-validation-errors.js
@@ -7,10 +7,13 @@ const rootUser = common.isWindows ? false : process.getuid() === 0;
 
 const invalidArgTypeError = common.expectsError(
   { code: 'ERR_INVALID_ARG_TYPE', type: TypeError },
-  common.isWindows || rootUser ? 42 : 62);
+  common.isWindows || rootUser ? 42 : 62
+);
 
-const invalidRangeError =
-  common.expectsError({ code: 'ERR_OUT_OF_RANGE', type: RangeError }, 20);
+const invalidRangeError = common.expectsError(
+  { code: 'ERR_OUT_OF_RANGE', type: RangeError },
+  20
+);
 
 function pass(option, value) {
   // Run the command with the specified option. Since it's not a real command,
@@ -188,8 +191,10 @@ if (!common.isWindows) {
 
 {
   // Validate the killSignal option
-  const unknownSignalErr =
-    common.expectsError({ code: 'ERR_UNKNOWN_SIGNAL', type: TypeError }, 17);
+  const unknownSignalErr = common.expectsError(
+    { code: 'ERR_UNKNOWN_SIGNAL', type: TypeError },
+    17
+  );
 
   pass('killSignal', undefined);
   pass('killSignal', null);
diff --git a/test/parallel/test-child-process-spawnsync.js b/test/parallel/test-child-process-spawnsync.js
index 99ce75da12091a..f39bcc451a226b 100644
--- a/test/parallel/test-child-process-spawnsync.js
+++ b/test/parallel/test-child-process-spawnsync.js
@@ -46,7 +46,6 @@ assert.deepStrictEqual(ret_err.spawnargs, ['bar']);
   assert.strictEqual(response.stdout.toString().trim(), cwd);
 }
 
-
 {
   // Assert Buffer is the default encoding
   const retDefault = spawnSync(...common.pwdCommand);
diff --git a/test/parallel/test-child-process-stdin-ipc.js b/test/parallel/test-child-process-stdin-ipc.js
index b162ced916096d..b267137fba4a62 100644
--- a/test/parallel/test-child-process-stdin-ipc.js
+++ b/test/parallel/test-child-process-stdin-ipc.js
@@ -35,6 +35,9 @@ const proc = spawn(process.execPath, [__filename, 'child'], {
   stdio: ['ipc', 'inherit', 'inherit']
 });
 
-proc.on('exit', common.mustCall(function(code) {
-  assert.strictEqual(code, 0);
-}));
+proc.on(
+  'exit',
+  common.mustCall(function(code) {
+    assert.strictEqual(code, 0);
+  })
+);
diff --git a/test/parallel/test-child-process-stdin.js b/test/parallel/test-child-process-stdin.js
index 29f78df7d0ae88..7802484dbd8672 100644
--- a/test/parallel/test-child-process-stdin.js
+++ b/test/parallel/test-child-process-stdin.js
@@ -49,10 +49,16 @@ cat.stderr.on('data', common.mustNotCall());
 
 cat.stderr.on('end', common.mustCall());
 
-cat.on('exit', common.mustCall(function(status) {
-  assert.strictEqual(status, 0);
-}));
+cat.on(
+  'exit',
+  common.mustCall(function(status) {
+    assert.strictEqual(status, 0);
+  })
+);
 
-cat.on('close', common.mustCall(function() {
-  assert.strictEqual(response, 'hello world');
-}));
+cat.on(
+  'close',
+  common.mustCall(function() {
+    assert.strictEqual(response, 'hello world');
+  })
+);
diff --git a/test/parallel/test-child-process-stdio-big-write-end.js b/test/parallel/test-child-process-stdio-big-write-end.js
index 00fc0471d235aa..b8a91f87b73a33 100644
--- a/test/parallel/test-child-process-stdio-big-write-end.js
+++ b/test/parallel/test-child-process-stdio-big-write-end.js
@@ -43,10 +43,13 @@ function parent() {
   child.stdout.on('data', function(c) {
     n += c;
   });
-  child.stdout.on('end', common.mustCall(function() {
-    assert.strictEqual(+n, sent);
-    console.log('ok');
-  }));
+  child.stdout.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(+n, sent);
+      console.log('ok');
+    })
+  );
 
   // Write until the buffer fills up.
   let buf;
diff --git a/test/parallel/test-child-process-stdio-inherit.js b/test/parallel/test-child-process-stdio-inherit.js
index b77391d87dca2c..a269a5e950f151 100644
--- a/test/parallel/test-child-process-stdio-inherit.js
+++ b/test/parallel/test-child-process-stdio-inherit.js
@@ -24,10 +24,8 @@ require('../common');
 const assert = require('assert');
 const spawn = require('child_process').spawn;
 
-if (process.argv[2] === 'parent')
-  parent();
-else
-  grandparent();
+if (process.argv[2] === 'parent') parent();
+else grandparent();
 
 function grandparent() {
   const child = spawn(process.execPath, [__filename, 'parent']);
diff --git a/test/parallel/test-child-process-stdio.js b/test/parallel/test-child-process-stdio.js
index a5e5f952259cee..e298df6549d656 100644
--- a/test/parallel/test-child-process-stdio.js
+++ b/test/parallel/test-child-process-stdio.js
@@ -55,23 +55,28 @@ const { spawn } = require('child_process');
     output += s;
   });
 
-  child.on('exit', common.mustCall(function(code) {
-    assert.strictEqual(code, 0);
-  }));
+  child.on(
+    'exit',
+    common.mustCall(function(code) {
+      assert.strictEqual(code, 0);
+    })
+  );
 
-  child.on('close', common.mustCall(function() {
-    assert.strictEqual(output.length > 1, true);
-    assert.strictEqual(output[output.length - 1], '\n');
-  }));
+  child.on(
+    'close',
+    common.mustCall(function() {
+      assert.strictEqual(output.length > 1, true);
+      assert.strictEqual(output[output.length - 1], '\n');
+    })
+  );
 }
 
 // Assert only one IPC pipe allowed.
 common.expectsError(
   () => {
-    spawn(
-      ...common.pwdCommand,
-      { stdio: ['pipe', 'pipe', 'pipe', 'ipc', 'ipc'] }
-    );
+    spawn(...common.pwdCommand, {
+      stdio: ['pipe', 'pipe', 'pipe', 'ipc', 'ipc']
+    });
   },
   { code: 'ERR_IPC_ONE_PIPE', type: Error }
 );
diff --git a/test/parallel/test-child-process-stdout-flush-exit.js b/test/parallel/test-child-process-stdout-flush-exit.js
index f3fdf4949aadd5..62a77a81e208b5 100644
--- a/test/parallel/test-child-process-stdout-flush-exit.js
+++ b/test/parallel/test-child-process-stdout-flush-exit.js
@@ -51,8 +51,11 @@ if (process.argv[2] === 'child') {
     stdout += data;
   });
 
-  child.on('close', common.mustCall(function() {
-    assert.strictEqual(stdout.slice(0, 6), 'hello\n');
-    assert.strictEqual(stdout.slice(stdout.length - 8), 'goodbye\n');
-  }));
+  child.on(
+    'close',
+    common.mustCall(function() {
+      assert.strictEqual(stdout.slice(0, 6), 'hello\n');
+      assert.strictEqual(stdout.slice(stdout.length - 8), 'goodbye\n');
+    })
+  );
 }
diff --git a/test/parallel/test-child-process-stdout-flush.js b/test/parallel/test-child-process-stdout-flush.js
index bc549fb6f311ec..658a9d4f781494 100644
--- a/test/parallel/test-child-process-stdout-flush.js
+++ b/test/parallel/test-child-process-stdout-flush.js
@@ -41,8 +41,11 @@ child.stdout.on('data', (data) => {
   count += data.length;
 });
 
-child.on('close', common.mustCall((code, signal) => {
-  assert.strictEqual(code, 0);
-  assert.strictEqual(signal, null);
-  assert.strictEqual(n, count);
-}));
+child.on(
+  'close',
+  common.mustCall((code, signal) => {
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+    assert.strictEqual(n, count);
+  })
+);
diff --git a/test/parallel/test-child-process-stdout-ipc.js b/test/parallel/test-child-process-stdout-ipc.js
index c916be95b73fc0..bddfb8b3566d71 100644
--- a/test/parallel/test-child-process-stdout-ipc.js
+++ b/test/parallel/test-child-process-stdout-ipc.js
@@ -13,6 +13,9 @@ const proc = spawn(process.execPath, [__filename, 'child'], {
   stdio: ['inherit', 'ipc', 'inherit']
 });
 
-proc.on('exit', common.mustCall(function(code) {
-  assert.strictEqual(code, 0);
-}));
+proc.on(
+  'exit',
+  common.mustCall(function(code) {
+    assert.strictEqual(code, 0);
+  })
+);
diff --git a/test/parallel/test-child-process-validate-stdio.js b/test/parallel/test-child-process-validate-stdio.js
index 26e4c297672ef6..1ff2d80ab57ebc 100644
--- a/test/parallel/test-child-process-validate-stdio.js
+++ b/test/parallel/test-child-process-validate-stdio.js
@@ -5,8 +5,10 @@ const common = require('../common');
 const assert = require('assert');
 const _validateStdio = require('internal/child_process')._validateStdio;
 
-const expectedError =
-  common.expectsError({ code: 'ERR_INVALID_OPT_VALUE', type: TypeError }, 2);
+const expectedError = common.expectsError(
+  { code: 'ERR_INVALID_OPT_VALUE', type: TypeError },
+  2
+);
 
 // should throw if string and not ignore, pipe, or inherit
 assert.throws(() => _validateStdio('foo'), expectedError);
@@ -26,10 +28,10 @@ assert.throws(() => _validateStdio(600), expectedError);
 
 // should throw if stdio has ipc and sync is true
 const stdio2 = ['ipc', 'ipc', 'ipc'];
-common.expectsError(() => _validateStdio(stdio2, true),
-                    { code: 'ERR_IPC_SYNC_FORK', type: Error }
-);
-
+common.expectsError(() => _validateStdio(stdio2, true), {
+  code: 'ERR_IPC_SYNC_FORK',
+  type: Error
+});
 
 if (common.isMainThread) {
   const stdio3 = [process.stdin, process.stdout, process.stderr];
@@ -45,5 +47,6 @@ if (common.isMainThread) {
   });
 } else {
   common.printSkipMessage(
-    'stdio is not associated with file descriptors in Workers');
+    'stdio is not associated with file descriptors in Workers'
+  );
 }
diff --git a/test/parallel/test-child-process-windows-hide.js b/test/parallel/test-child-process-windows-hide.js
index 67ed18d7338d83..4295b3ac305453 100644
--- a/test/parallel/test-child-process-windows-hide.js
+++ b/test/parallel/test-child-process-windows-hide.js
@@ -35,10 +35,13 @@ internalCp.spawnSync = common.mustCall(function(options) {
 {
   const child = cp.spawn(cmd, args, options);
 
-  child.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  }));
+  child.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 }
 
 {
diff --git a/test/parallel/test-cli-eval-event.js b/test/parallel/test-cli-eval-event.js
index df356e50d37b66..31326dab51e251 100644
--- a/test/parallel/test-cli-eval-event.js
+++ b/test/parallel/test-cli-eval-event.js
@@ -4,12 +4,18 @@ const common = require('../common');
 const assert = require('assert');
 const spawn = require('child_process').spawn;
 
-const child = spawn(process.execPath, ['-e', `
+const child = spawn(process.execPath, [
+  '-e',
+  `
     const server = require('net').createServer().listen(0);
     server.once('listening', server.close);
-`]);
+`
+]);
 
-child.once('exit', common.mustCall(function(exitCode, signalCode) {
-  assert.strictEqual(exitCode, 0);
-  assert.strictEqual(signalCode, null);
-}));
+child.once(
+  'exit',
+  common.mustCall(function(exitCode, signalCode) {
+    assert.strictEqual(exitCode, 0);
+    assert.strictEqual(signalCode, null);
+  })
+);
diff --git a/test/parallel/test-cli-eval.js b/test/parallel/test-cli-eval.js
index 7a2c7a82aa797f..879b8cfcfe4487 100644
--- a/test/parallel/test-cli-eval.js
+++ b/test/parallel/test-cli-eval.js
@@ -43,35 +43,46 @@ if (process.argv.length > 2) {
 }
 
 // Assert that nothing is written to stdout.
-child.exec(`${nodejs} --eval 42`, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
-  assert.strictEqual(stdout, '');
-  assert.strictEqual(stderr, '');
-}));
+child.exec(
+  `${nodejs} --eval 42`,
+  common.mustCall((err, stdout, stderr) => {
+    assert.ifError(err);
+    assert.strictEqual(stdout, '');
+    assert.strictEqual(stderr, '');
+  })
+);
 
 // Assert that "42\n" is written to stderr.
-child.exec(`${nodejs} --eval "console.error(42)"`,
-           common.mustCall((err, stdout, stderr) => {
-             assert.ifError(err);
-             assert.strictEqual(stdout, '');
-             assert.strictEqual(stderr, '42\n');
-           }));
+child.exec(
+  `${nodejs} --eval "console.error(42)"`,
+  common.mustCall((err, stdout, stderr) => {
+    assert.ifError(err);
+    assert.strictEqual(stdout, '');
+    assert.strictEqual(stderr, '42\n');
+  })
+);
 
 // Assert that the expected output is written to stdout.
 ['--print', '-p -e', '-pe', '-p'].forEach((s) => {
   const cmd = `${nodejs} ${s} `;
 
-  child.exec(`${cmd}42`, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
-    assert.strictEqual(stdout, '42\n');
-    assert.strictEqual(stderr, '');
-  }));
+  child.exec(
+    `${cmd}42`,
+    common.mustCall((err, stdout, stderr) => {
+      assert.ifError(err);
+      assert.strictEqual(stdout, '42\n');
+      assert.strictEqual(stderr, '');
+    })
+  );
 
-  child.exec(`${cmd} '[]'`, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
-    assert.strictEqual(stdout, '[]\n');
-    assert.strictEqual(stderr, '');
-  }));
+  child.exec(
+    `${cmd} '[]'`,
+    common.mustCall((err, stdout, stderr) => {
+      assert.ifError(err);
+      assert.strictEqual(stdout, '[]\n');
+      assert.strictEqual(stderr, '');
+    })
+  );
 });
 
 // Assert that module loading works.
@@ -80,65 +91,89 @@ child.exec(`${nodejs} --eval "console.error(42)"`,
   // interpreted as the escape character when put between quotes.
   const filename = __filename.replace(/\\/g, '/');
 
-  child.exec(`${nodejs} --eval "require('${filename}')"`,
-             common.mustCall((err, stdout, stderr) => {
-               assert.strictEqual(err.code, 42);
-               assert.strictEqual(
-                 stdout, 'Loaded as a module, exiting with status code 42.\n');
-               assert.strictEqual(stderr, '');
-             }));
+  child.exec(
+    `${nodejs} --eval "require('${filename}')"`,
+    common.mustCall((err, stdout, stderr) => {
+      assert.strictEqual(err.code, 42);
+      assert.strictEqual(
+        stdout,
+        'Loaded as a module, exiting with status code 42.\n'
+      );
+      assert.strictEqual(stderr, '');
+    })
+  );
 }
 
 // Check that builtin modules are pre-defined.
-child.exec(`${nodejs} --print "os.platform()"`,
-           common.mustCall((err, stdout, stderr) => {
-             assert.ifError(err);
-             assert.strictEqual(stderr, '');
-             assert.strictEqual(stdout.trim(), require('os').platform());
-           }));
+child.exec(
+  `${nodejs} --print "os.platform()"`,
+  common.mustCall((err, stdout, stderr) => {
+    assert.ifError(err);
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout.trim(), require('os').platform());
+  })
+);
 
 // Module path resolve bug regression test.
 const cwd = process.cwd();
 process.chdir(path.resolve(__dirname, '../../'));
-child.exec(`${nodejs} --eval "require('./test/parallel/test-cli-eval.js')"`,
-           common.mustCall((err, stdout, stderr) => {
-             assert.strictEqual(err.code, 42);
-             assert.strictEqual(
-               stdout, 'Loaded as a module, exiting with status code 42.\n');
-             assert.strictEqual(stderr, '');
-           }));
+child.exec(
+  `${nodejs} --eval "require('./test/parallel/test-cli-eval.js')"`,
+  common.mustCall((err, stdout, stderr) => {
+    assert.strictEqual(err.code, 42);
+    assert.strictEqual(
+      stdout,
+      'Loaded as a module, exiting with status code 42.\n'
+    );
+    assert.strictEqual(stderr, '');
+  })
+);
 process.chdir(cwd);
 
 // Missing argument should not crash.
-child.exec(`${nodejs} -e`, common.mustCall((err, stdout, stderr) => {
-  assert.strictEqual(err.code, 9);
-  assert.strictEqual(stdout, '');
-  assert.strictEqual(stderr.trim(),
-                     `${process.execPath}: -e requires an argument`);
-}));
+child.exec(
+  `${nodejs} -e`,
+  common.mustCall((err, stdout, stderr) => {
+    assert.strictEqual(err.code, 9);
+    assert.strictEqual(stdout, '');
+    assert.strictEqual(
+      stderr.trim(),
+      `${process.execPath}: -e requires an argument`
+    );
+  })
+);
 
 // Empty program should do nothing.
-child.exec(`${nodejs} -e ""`, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
-  assert.strictEqual(stdout, '');
-  assert.strictEqual(stderr, '');
-}));
+child.exec(
+  `${nodejs} -e ""`,
+  common.mustCall((err, stdout, stderr) => {
+    assert.ifError(err);
+    assert.strictEqual(stdout, '');
+    assert.strictEqual(stderr, '');
+  })
+);
 
 // "\\-42" should be interpreted as an escaped expression, not a switch.
-child.exec(`${nodejs} -p "\\-42"`, common.mustCall((err, stdout, stderr) => {
-  assert.ifError(err);
-  assert.strictEqual(stdout, '-42\n');
-  assert.strictEqual(stderr, '');
-}));
-
-child.exec(`${nodejs} --use-strict -p process.execArgv`,
-           common.mustCall((err, stdout, stderr) => {
-             assert.ifError(err);
-             assert.strictEqual(
-               stdout, "[ '--use-strict', '-p', 'process.execArgv' ]\n"
-             );
-             assert.strictEqual(stderr, '');
-           }));
+child.exec(
+  `${nodejs} -p "\\-42"`,
+  common.mustCall((err, stdout, stderr) => {
+    assert.ifError(err);
+    assert.strictEqual(stdout, '-42\n');
+    assert.strictEqual(stderr, '');
+  })
+);
+
+child.exec(
+  `${nodejs} --use-strict -p process.execArgv`,
+  common.mustCall((err, stdout, stderr) => {
+    assert.ifError(err);
+    assert.strictEqual(
+      stdout,
+      "[ '--use-strict', '-p', 'process.execArgv' ]\n"
+    );
+    assert.strictEqual(stderr, '');
+  })
+);
 
 // Regression test for https://github.com/nodejs/node/issues/3574.
 {
@@ -147,23 +182,26 @@ child.exec(`${nodejs} --use-strict -p process.execArgv`,
     emptyFile = emptyFile.replace(/\\/g, '\\\\');
   }
 
-  child.exec(`${nodejs} -e 'require("child_process").fork("${emptyFile}")'`,
-             common.mustCall((err, stdout, stderr) => {
-               assert.ifError(err);
-               assert.strictEqual(stdout, '');
-               assert.strictEqual(stderr, '');
-             }));
+  child.exec(
+    `${nodejs} -e 'require("child_process").fork("${emptyFile}")'`,
+    common.mustCall((err, stdout, stderr) => {
+      assert.ifError(err);
+      assert.strictEqual(stdout, '');
+      assert.strictEqual(stderr, '');
+    })
+  );
 
   // Make sure that monkey-patching process.execArgv doesn't cause child_process
   // to incorrectly munge execArgv.
   child.exec(
     `${nodejs} -e "process.execArgv = ['-e', 'console.log(42)', 'thirdArg'];` +
-                  `require('child_process').fork('${emptyFile}')"`,
+      `require('child_process').fork('${emptyFile}')"`,
     common.mustCall((err, stdout, stderr) => {
       assert.ifError(err);
       assert.strictEqual(stdout, '42\n');
       assert.strictEqual(stderr, '');
-    }));
+    })
+  );
 }
 
 // Regression test for https://github.com/nodejs/node/issues/8534.
@@ -190,47 +228,54 @@ child.exec(`${nodejs} --use-strict -p process.execArgv`,
       });
   `;
   const proc = child.fork('-e', [script]);
-  proc.on('exit', common.mustCall((exitCode, signalCode) => {
-    assert.strictEqual(exitCode, 0);
-    assert.strictEqual(signalCode, null);
-  }));
+  proc.on(
+    'exit',
+    common.mustCall((exitCode, signalCode) => {
+      assert.strictEqual(exitCode, 0);
+      assert.strictEqual(signalCode, null);
+    })
+  );
   proc.on('message', (message) => {
     if (message === 'pong') proc.send('exit');
   });
   proc.send('ping');
 }
 
-[ '-arg1',
-  '-arg1 arg2 --arg3',
-  '--',
-  'arg1 -- arg2',
-].forEach(function(args) {
-
+['-arg1', '-arg1 arg2 --arg3', '--', 'arg1 -- arg2'].forEach(function(args) {
   // Ensure that arguments are successfully passed to eval.
   const opt = ' --eval "console.log(process.argv.slice(1).join(\' \'))"';
   const cmd = `${nodejs}${opt} -- ${args}`;
-  child.exec(cmd, common.mustCall(function(err, stdout, stderr) {
-    assert.strictEqual(stdout, `${args}\n`);
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(err, null);
-  }));
+  child.exec(
+    cmd,
+    common.mustCall(function(err, stdout, stderr) {
+      assert.strictEqual(stdout, `${args}\n`);
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(err, null);
+    })
+  );
 
   // Ensure that arguments are successfully passed to print.
   const popt = ' --print "process.argv.slice(1).join(\' \')"';
   const pcmd = `${nodejs}${popt} -- ${args}`;
-  child.exec(pcmd, common.mustCall(function(err, stdout, stderr) {
-    assert.strictEqual(stdout, `${args}\n`);
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(err, null);
-  }));
+  child.exec(
+    pcmd,
+    common.mustCall(function(err, stdout, stderr) {
+      assert.strictEqual(stdout, `${args}\n`);
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(err, null);
+    })
+  );
 
   // Ensure that arguments are successfully passed to a script.
   // The first argument after '--' should be interpreted as a script
   // filename.
   const filecmd = `${nodejs} -- "${__filename}" ${args}`;
-  child.exec(filecmd, common.mustCall(function(err, stdout, stderr) {
-    assert.strictEqual(stdout, `${args}\n`);
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(err, null);
-  }));
+  child.exec(
+    filecmd,
+    common.mustCall(function(err, stdout, stderr) {
+      assert.strictEqual(stdout, `${args}\n`);
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(err, null);
+    })
+  );
 });
diff --git a/test/parallel/test-cli-node-options-disallowed.js b/test/parallel/test-cli-node-options-disallowed.js
index 733e5cd7c7b977..0f0321e96ffc71 100644
--- a/test/parallel/test-cli-node-options-disallowed.js
+++ b/test/parallel/test-cli-node-options-disallowed.js
@@ -32,11 +32,17 @@ disallow('--');
 
 function disallow(opt) {
   const env = Object.assign({}, process.env, { NODE_OPTIONS: opt });
-  exec(process.execPath, { env }, common.mustCall(function(err) {
-    const message = err.message.split(/\r?\n/)[1];
-    const expect = `${process.execPath}: ${opt} is not allowed in NODE_OPTIONS`;
+  exec(
+    process.execPath,
+    { env },
+    common.mustCall(function(err) {
+      const message = err.message.split(/\r?\n/)[1];
+      const expect = `${
+        process.execPath
+      }: ${opt} is not allowed in NODE_OPTIONS`;
 
-    assert.strictEqual(err.code, 9);
-    assert.strictEqual(message, expect);
-  }));
+      assert.strictEqual(err.code, 9);
+      assert.strictEqual(message, expect);
+    })
+  );
 }
diff --git a/test/parallel/test-cli-node-options.js b/test/parallel/test-cli-node-options.js
index 4ff63009a7a1e3..33ad3047d8e5bd 100644
--- a/test/parallel/test-cli-node-options.js
+++ b/test/parallel/test-cli-node-options.js
@@ -33,8 +33,11 @@ expect('--trace-event-categories node', 'B\n');
 // eslint-disable-next-line no-template-curly-in-string
 expect('--trace-event-file-pattern {pid}-${rotation}.trace_events', 'B\n');
 // eslint-disable-next-line no-template-curly-in-string
-expect('--trace-event-file-pattern {pid}-${rotation}.trace_events ' +
-       '--trace-event-categories node.async_hooks', 'B\n');
+expect(
+  '--trace-event-file-pattern {pid}-${rotation}.trace_events ' +
+    '--trace-event-categories node.async_hooks',
+  'B\n'
+);
 
 if (!common.isWindows) {
   expect('--perf-basic-prof', 'B\n');
@@ -54,28 +57,34 @@ if (common.hasCrypto) {
 // V8 options
 expect('--abort_on-uncaught_exception', 'B\n');
 expect('--max-old-space-size=0', 'B\n');
-expect('--stack-trace-limit=100',
-       /(\s*at f \(\[eval\]:1:\d*\)\r?\n){100}/,
-       '(function f() { f(); })();',
-       true);
+expect(
+  '--stack-trace-limit=100',
+  /(\s*at f \(\[eval\]:1:\d*\)\r?\n){100}/,
+  '(function f() { f(); })();',
+  true
+);
 
 function expect(opt, want, command = 'console.log("B")', wantsError = false) {
   const argv = ['-e', command];
   const opts = {
     env: Object.assign({}, process.env, { NODE_OPTIONS: opt }),
-    maxBuffer: 1e6,
+    maxBuffer: 1e6
   };
-  if (typeof want === 'string')
-    want = new RegExp(want);
-  exec(process.execPath, argv, opts, common.mustCall((err, stdout, stderr) => {
-    if (wantsError) {
-      stdout = stderr;
-    } else {
-      assert.ifError(err);
-    }
-    if (want.test(stdout)) return;
+  if (typeof want === 'string') want = new RegExp(want);
+  exec(
+    process.execPath,
+    argv,
+    opts,
+    common.mustCall((err, stdout, stderr) => {
+      if (wantsError) {
+        stdout = stderr;
+      } else {
+        assert.ifError(err);
+      }
+      if (want.test(stdout)) return;
 
-    const o = JSON.stringify(opt);
-    assert.fail(`For ${o}, failed to find ${want} in: <\n${stdout}\n>`);
-  }));
+      const o = JSON.stringify(opt);
+      assert.fail(`For ${o}, failed to find ${want} in: <\n${stdout}\n>`);
+    })
+  );
 }
diff --git a/test/parallel/test-cli-node-print-help.js b/test/parallel/test-cli-node-print-help.js
index 3f9354b89cdb71..f884a4c9419517 100644
--- a/test/parallel/test-cli-node-print-help.js
+++ b/test/parallel/test-cli-node-print-help.js
@@ -9,13 +9,15 @@ const assert = require('assert');
 const { exec } = require('child_process');
 let stdOut;
 
-
 function startPrintHelpTest() {
-  exec(`${process.execPath} --help`, common.mustCall((err, stdout, stderr) => {
-    assert.ifError(err);
-    stdOut = stdout;
-    validateNodePrintHelp();
-  }));
+  exec(
+    `${process.execPath} --help`,
+    common.mustCall((err, stdout, stderr) => {
+      assert.ifError(err);
+      stdOut = stdout;
+      validateNodePrintHelp();
+    })
+  );
 }
 
 function validateNodePrintHelp() {
@@ -26,16 +28,31 @@ function validateNodePrintHelp() {
   const HAVE_INSPECTOR = config.variables.v8_enable_inspector === 1;
 
   const cliHelpOptions = [
-    { compileConstant: HAVE_OPENSSL,
-      flags: [ '--openssl-config=...', '--tls-cipher-list=...',
-               '--use-bundled-ca', '--use-openssl-ca' ] },
-    { compileConstant: NODE_FIPS_MODE,
-      flags: [ '--enable-fips', '--force-fips' ] },
-    { compileConstant: NODE_HAVE_I18N_SUPPORT,
-      flags: [ '--icu-data-dir=...', 'NODE_ICU_DATA' ] },
-    { compileConstant: HAVE_INSPECTOR,
-      flags: [ '--inspect-brk[=[host:]port]', '--inspect-port=[host:]port',
-               '--inspect[=[host:]port]' ] },
+    {
+      compileConstant: HAVE_OPENSSL,
+      flags: [
+        '--openssl-config=...',
+        '--tls-cipher-list=...',
+        '--use-bundled-ca',
+        '--use-openssl-ca'
+      ]
+    },
+    {
+      compileConstant: NODE_FIPS_MODE,
+      flags: ['--enable-fips', '--force-fips']
+    },
+    {
+      compileConstant: NODE_HAVE_I18N_SUPPORT,
+      flags: ['--icu-data-dir=...', 'NODE_ICU_DATA']
+    },
+    {
+      compileConstant: HAVE_INSPECTOR,
+      flags: [
+        '--inspect-brk[=[host:]port]',
+        '--inspect-port=[host:]port',
+        '--inspect[=[host:]port]'
+      ]
+    }
   ];
 
   cliHelpOptions.forEach(testForSubstring);
@@ -44,13 +61,19 @@ function validateNodePrintHelp() {
 function testForSubstring(options) {
   if (options.compileConstant) {
     options.flags.forEach((flag) => {
-      assert.strictEqual(stdOut.indexOf(flag) !== -1, true,
-                         `Missing flag ${flag} in ${stdOut}`);
+      assert.strictEqual(
+        stdOut.indexOf(flag) !== -1,
+        true,
+        `Missing flag ${flag} in ${stdOut}`
+      );
     });
   } else {
     options.flags.forEach((flag) => {
-      assert.strictEqual(stdOut.indexOf(flag), -1,
-                         `Unexpected flag ${flag} in ${stdOut}`);
+      assert.strictEqual(
+        stdOut.indexOf(flag),
+        -1,
+        `Unexpected flag ${flag} in ${stdOut}`
+      );
     });
   }
 }
diff --git a/test/parallel/test-cli-syntax.js b/test/parallel/test-cli-syntax.js
index d80e8c698d72de..3f3eb6ba62d663 100644
--- a/test/parallel/test-cli-syntax.js
+++ b/test/parallel/test-cli-syntax.js
@@ -8,10 +8,7 @@ const fixtures = require('../common/fixtures');
 const node = process.execPath;
 
 // test both sets of arguments that check syntax
-const syntaxArgs = [
-  ['-c'],
-  ['--check']
-];
+const syntaxArgs = [['-c'], ['--check']];
 
 // Match on the name of the `Error` but not the message as it is different
 // depending on the JavaScript engine.
@@ -33,11 +30,14 @@ const notFoundRE = /^Error: Cannot find module/m;
     const _args = args.concat(file);
 
     const cmd = [node, ..._args].join(' ');
-    exec(cmd, common.mustCall((err, stdout, stderr) => {
-      assert.ifError(err);
-      assert.strictEqual(stdout, '');
-      assert.strictEqual(stderr, '');
-    }));
+    exec(
+      cmd,
+      common.mustCall((err, stdout, stderr) => {
+        assert.ifError(err);
+        assert.strictEqual(stdout, '');
+        assert.strictEqual(stderr, '');
+      })
+    );
   });
 });
 
@@ -54,42 +54,45 @@ const notFoundRE = /^Error: Cannot find module/m;
   syntaxArgs.forEach(function(args) {
     const _args = args.concat(file);
     const cmd = [node, ..._args].join(' ');
-    exec(cmd, common.mustCall((err, stdout, stderr) => {
-      assert.strictEqual(err instanceof Error, true);
-      assert.strictEqual(err.code, 1);
-
-      // no stdout should be produced
-      assert.strictEqual(stdout, '');
-
-      // stderr should have a syntax error message
-      assert(syntaxErrorRE.test(stderr), `${syntaxErrorRE} === ${stderr}`);
-
-      // stderr should include the filename
-      assert(stderr.startsWith(file), `${stderr} starts with ${file}`);
-    }));
+    exec(
+      cmd,
+      common.mustCall((err, stdout, stderr) => {
+        assert.strictEqual(err instanceof Error, true);
+        assert.strictEqual(err.code, 1);
+
+        // no stdout should be produced
+        assert.strictEqual(stdout, '');
+
+        // stderr should have a syntax error message
+        assert(syntaxErrorRE.test(stderr), `${syntaxErrorRE} === ${stderr}`);
+
+        // stderr should include the filename
+        assert(stderr.startsWith(file), `${stderr} starts with ${file}`);
+      })
+    );
   });
 });
 
 // test file not found
-[
-  'syntax/file_not_found.js',
-  'syntax/file_not_found'
-].forEach(function(file) {
+['syntax/file_not_found.js', 'syntax/file_not_found'].forEach(function(file) {
   file = fixtures.path(file);
 
   // loop each possible option, `-c` or `--check`
   syntaxArgs.forEach(function(args) {
     const _args = args.concat(file);
     const cmd = [node, ..._args].join(' ');
-    exec(cmd, common.mustCall((err, stdout, stderr) => {
-      // no stdout should be produced
-      assert.strictEqual(stdout, '');
-
-      // stderr should have a module not found error message
-      assert(notFoundRE.test(stderr), `${notFoundRE} === ${stderr}`);
-
-      assert.strictEqual(err.code, 1);
-    }));
+    exec(
+      cmd,
+      common.mustCall((err, stdout, stderr) => {
+        // no stdout should be produced
+        assert.strictEqual(stdout, '');
+
+        // stderr should have a module not found error message
+        assert(notFoundRE.test(stderr), `${notFoundRE} === ${stderr}`);
+
+        assert.strictEqual(err.code, 1);
+      })
+    );
   });
 });
 
@@ -129,15 +132,18 @@ syntaxArgs.forEach(function(args) {
   ['-e', '--eval'].forEach(function(evalFlag) {
     const args = [checkFlag, evalFlag, 'foo'];
     const cmd = [node, ...args].join(' ');
-    exec(cmd, common.mustCall((err, stdout, stderr) => {
-      assert.strictEqual(err instanceof Error, true);
-      assert.strictEqual(err.code, 9);
-      assert(
-        stderr.startsWith(
-          `${node}: either --check or --eval can be used, not both`
-        )
-      );
-    }));
+    exec(
+      cmd,
+      common.mustCall((err, stdout, stderr) => {
+        assert.strictEqual(err instanceof Error, true);
+        assert.strictEqual(err.code, 9);
+        assert(
+          stderr.startsWith(
+            `${node}: either --check or --eval can be used, not both`
+          )
+        );
+      })
+    );
   });
 });
 
@@ -148,18 +154,21 @@ syntaxArgs.forEach(function(args) {
     const file = fixtures.path('syntax', 'illegal_if_not_wrapped.js');
     const args = [requireFlag, preloadFile, checkFlag, file];
     const cmd = [node, ...args].join(' ');
-    exec(cmd, common.mustCall((err, stdout, stderr) => {
-      assert.strictEqual(err instanceof Error, true);
-      assert.strictEqual(err.code, 1);
-
-      // no stdout should be produced
-      assert.strictEqual(stdout, '');
-
-      // stderr should have a syntax error message
-      assert(syntaxErrorRE.test(stderr), `${syntaxErrorRE} === ${stderr}`);
-
-      // stderr should include the filename
-      assert(stderr.startsWith(file), `${stderr} starts with ${file}`);
-    }));
+    exec(
+      cmd,
+      common.mustCall((err, stdout, stderr) => {
+        assert.strictEqual(err instanceof Error, true);
+        assert.strictEqual(err.code, 1);
+
+        // no stdout should be produced
+        assert.strictEqual(stdout, '');
+
+        // stderr should have a syntax error message
+        assert(syntaxErrorRE.test(stderr), `${syntaxErrorRE} === ${stderr}`);
+
+        // stderr should include the filename
+        assert(stderr.startsWith(file), `${stderr} starts with ${file}`);
+      })
+    );
   });
 });
diff --git a/test/parallel/test-cluster-basic.js b/test/parallel/test-cluster-basic.js
index 0d51a18607f6bf..dfc1fb6c82b9d7 100644
--- a/test/parallel/test-cluster-basic.js
+++ b/test/parallel/test-cluster-basic.js
@@ -25,9 +25,12 @@ const common = require('../common');
 const assert = require('assert');
 const cluster = require('cluster');
 
-assert.strictEqual('NODE_UNIQUE_ID' in process.env, false,
-                   `NODE_UNIQUE_ID (${process.env.NODE_UNIQUE_ID}) ` +
-                   'should be removed on startup');
+assert.strictEqual(
+  'NODE_UNIQUE_ID' in process.env,
+  false,
+  `NODE_UNIQUE_ID (${process.env.NODE_UNIQUE_ID}) ` +
+    'should be removed on startup'
+);
 
 function forEach(obj, fn) {
   Object.keys(obj).forEach((name, index) => {
@@ -35,11 +38,11 @@ function forEach(obj, fn) {
   });
 }
 
-
 if (cluster.isWorker) {
-  require('http').Server(common.mustNotCall()).listen(0, '127.0.0.1');
+  require('http')
+    .Server(common.mustNotCall())
+    .listen(0, '127.0.0.1');
 } else if (cluster.isMaster) {
-
   const checks = {
     cluster: {
       events: {
@@ -80,26 +83,30 @@ if (cluster.isWorker) {
 
   // Check events, states, and emit arguments
   forEach(checks.cluster.events, (bool, name, index) => {
-
     // Listen on event
-    cluster.on(name, common.mustCall(function(/* worker */) {
-
-      // Set event
-      checks.cluster.events[name] = true;
-
-      // Check argument
-      checks.cluster.equal[name] = worker === arguments[0];
-
-      // Check state
-      const state = stateNames[index];
-      checks.worker.states[state] = (state === worker.state);
-    }));
+    cluster.on(
+      name,
+      common.mustCall(function(/* worker */) {
+        // Set event
+        checks.cluster.events[name] = true;
+
+        // Check argument
+        checks.cluster.equal[name] = worker === arguments[0];
+
+        // Check state
+        const state = stateNames[index];
+        checks.worker.states[state] = state === worker.state;
+      })
+    );
   });
 
   // Kill worker when listening
-  cluster.on('listening', common.mustCall(() => {
-    worker.kill();
-  }));
+  cluster.on(
+    'listening',
+    common.mustCall(() => {
+      worker.kill();
+    })
+  );
 
   // Kill process when worker is killed
   cluster.on('exit', common.mustCall());
@@ -107,76 +114,87 @@ if (cluster.isWorker) {
   // Create worker
   const worker = cluster.fork();
   assert.strictEqual(worker.id, 1);
-  assert(worker instanceof cluster.Worker,
-         'the worker is not a instance of the Worker constructor');
+  assert(
+    worker instanceof cluster.Worker,
+    'the worker is not a instance of the Worker constructor'
+  );
 
   // Check event
   forEach(checks.worker.events, function(bool, name, index) {
-    worker.on(name, common.mustCall(function() {
-      // Set event
-      checks.worker.events[name] = true;
-
-      // Check argument
-      checks.worker.equal[name] = (worker === this);
-
-      switch (name) {
-        case 'exit':
-          assert.strictEqual(arguments[0], worker.process.exitCode);
-          assert.strictEqual(arguments[1], worker.process.signalCode);
-          assert.strictEqual(arguments.length, 2);
-          break;
-
-        case 'listening':
-          assert.strictEqual(arguments.length, 1);
-          assert.strictEqual(Object.keys(arguments[0]).length, 4);
-          assert.strictEqual(arguments[0].address, '127.0.0.1');
-          assert.strictEqual(arguments[0].addressType, 4);
-          assert(arguments[0].hasOwnProperty('fd'));
-          assert.strictEqual(arguments[0].fd, undefined);
-          const port = arguments[0].port;
-          assert(Number.isInteger(port));
-          assert(port >= 1);
-          assert(port <= 65535);
-          break;
-
-        default:
-          assert.strictEqual(arguments.length, 0);
-          break;
-      }
-    }));
+    worker.on(
+      name,
+      common.mustCall(function() {
+        // Set event
+        checks.worker.events[name] = true;
+
+        // Check argument
+        checks.worker.equal[name] = worker === this;
+
+        switch (name) {
+          case 'exit':
+            assert.strictEqual(arguments[0], worker.process.exitCode);
+            assert.strictEqual(arguments[1], worker.process.signalCode);
+            assert.strictEqual(arguments.length, 2);
+            break;
+
+          case 'listening':
+            assert.strictEqual(arguments.length, 1);
+            assert.strictEqual(Object.keys(arguments[0]).length, 4);
+            assert.strictEqual(arguments[0].address, '127.0.0.1');
+            assert.strictEqual(arguments[0].addressType, 4);
+            assert(arguments[0].hasOwnProperty('fd'));
+            assert.strictEqual(arguments[0].fd, undefined);
+            const port = arguments[0].port;
+            assert(Number.isInteger(port));
+            assert(port >= 1);
+            assert(port <= 65535);
+            break;
+
+          default:
+            assert.strictEqual(arguments.length, 0);
+            break;
+        }
+      })
+    );
   });
 
   // Check all values
   process.once('exit', () => {
     // Check cluster events
     forEach(checks.cluster.events, (check, name) => {
-      assert(check,
-             `The cluster event "${name}" on the cluster object did not fire`);
+      assert(
+        check,
+        `The cluster event "${name}" on the cluster object did not fire`
+      );
     });
 
     // Check cluster event arguments
     forEach(checks.cluster.equal, (check, name) => {
-      assert(check,
-             `The cluster event "${name}" did not emit with correct argument`);
+      assert(
+        check,
+        `The cluster event "${name}" did not emit with correct argument`
+      );
     });
 
     // Check worker states
     forEach(checks.worker.states, (check, name) => {
-      assert(check,
-             `The worker state "${name}" was not set to true`);
+      assert(check, `The worker state "${name}" was not set to true`);
     });
 
     // Check worker events
     forEach(checks.worker.events, (check, name) => {
-      assert(check,
-             `The worker event "${name}" on the worker object did not fire`);
+      assert(
+        check,
+        `The worker event "${name}" on the worker object did not fire`
+      );
     });
 
     // Check worker event arguments
     forEach(checks.worker.equal, (check, name) => {
-      assert(check,
-             `The worker event "${name}" did not emit with correct argument`);
+      assert(
+        check,
+        `The worker event "${name}" did not emit with correct argument`
+      );
     });
   });
-
 }
diff --git a/test/parallel/test-cluster-bind-privileged-port.js b/test/parallel/test-cluster-bind-privileged-port.js
index 9d155259c3789e..862942739f587c 100644
--- a/test/parallel/test-cluster-bind-privileged-port.js
+++ b/test/parallel/test-cluster-bind-privileged-port.js
@@ -23,11 +23,9 @@
 const common = require('../common');
 
 // Skip on OS X Mojave. https://github.com/nodejs/node/issues/21679
-if (common.isOSXMojave)
-  common.skip('bypass test for Mojave due to OSX issue');
+if (common.isOSXMojave) common.skip('bypass test for Mojave due to OSX issue');
 
-if (common.isWindows)
-  common.skip('not reliable on Windows.');
+if (common.isWindows) common.skip('not reliable on Windows.');
 
 if (process.getuid() === 0)
   common.skip('Test is not supposed to be run as root.');
@@ -37,14 +35,20 @@ const cluster = require('cluster');
 const net = require('net');
 
 if (cluster.isMaster) {
-  cluster.fork().on('exit', common.mustCall((exitCode) => {
-    assert.strictEqual(exitCode, 0);
-  }));
+  cluster.fork().on(
+    'exit',
+    common.mustCall((exitCode) => {
+      assert.strictEqual(exitCode, 0);
+    })
+  );
 } else {
   const s = net.createServer(common.mustNotCall());
   s.listen(42, common.mustNotCall('listen should have failed'));
-  s.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.code, 'EACCES');
-    process.disconnect();
-  }));
+  s.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.code, 'EACCES');
+      process.disconnect();
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-bind-twice.js b/test/parallel/test-cluster-bind-twice.js
index 4ef319ae80d409..319125aaf82b7f 100644
--- a/test/parallel/test-cluster-bind-twice.js
+++ b/test/parallel/test-cluster-bind-twice.js
@@ -51,56 +51,78 @@ if (!id) {
   const a = fork(__filename, ['one']);
   const b = fork(__filename, ['two']);
 
-  a.on('exit', common.mustCall((c) => {
-    if (c) {
-      b.send('QUIT');
-      throw new Error(`A exited with ${c}`);
-    }
-  }));
-
-  b.on('exit', common.mustCall((c) => {
-    if (c) {
-      a.send('QUIT');
-      throw new Error(`B exited with ${c}`);
-    }
-  }));
+  a.on(
+    'exit',
+    common.mustCall((c) => {
+      if (c) {
+        b.send('QUIT');
+        throw new Error(`A exited with ${c}`);
+      }
+    })
+  );
 
+  b.on(
+    'exit',
+    common.mustCall((c) => {
+      if (c) {
+        a.send('QUIT');
+        throw new Error(`B exited with ${c}`);
+      }
+    })
+  );
 
-  a.on('message', common.mustCall((m) => {
-    assert.strictEqual(m.msg, 'READY');
-    b.send({ msg: 'START', port: m.port });
-  }));
-
-  b.on('message', common.mustCall((m) => {
-    assert.strictEqual(m, 'EADDRINUSE');
-    a.send('QUIT');
-    b.send('QUIT');
-  }));
+  a.on(
+    'message',
+    common.mustCall((m) => {
+      assert.strictEqual(m.msg, 'READY');
+      b.send({ msg: 'START', port: m.port });
+    })
+  );
 
+  b.on(
+    'message',
+    common.mustCall((m) => {
+      assert.strictEqual(m, 'EADDRINUSE');
+      a.send('QUIT');
+      b.send('QUIT');
+    })
+  );
 } else if (id === 'one') {
   if (cluster.isMaster) return startWorker();
 
   const server = http.createServer(common.mustNotCall());
-  server.listen(0, common.mustCall(() => {
-    process.send({ msg: 'READY', port: server.address().port });
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      process.send({ msg: 'READY', port: server.address().port });
+    })
+  );
 
-  process.on('message', common.mustCall((m) => {
-    if (m === 'QUIT') process.exit();
-  }));
+  process.on(
+    'message',
+    common.mustCall((m) => {
+      if (m === 'QUIT') process.exit();
+    })
+  );
 } else if (id === 'two') {
   if (cluster.isMaster) return startWorker();
 
   const server = http.createServer(common.mustNotCall());
-  process.on('message', common.mustCall((m) => {
-    if (m === 'QUIT') process.exit();
-    assert.strictEqual(m.msg, 'START');
-    server.listen(m.port, common.mustNotCall());
-    server.on('error', common.mustCall((e) => {
-      assert.strictEqual(e.code, 'EADDRINUSE');
-      process.send(e.code);
-    }));
-  }, 2));
+  process.on(
+    'message',
+    common.mustCall((m) => {
+      if (m === 'QUIT') process.exit();
+      assert.strictEqual(m.msg, 'START');
+      server.listen(m.port, common.mustNotCall());
+      server.on(
+        'error',
+        common.mustCall((e) => {
+          assert.strictEqual(e.code, 'EADDRINUSE');
+          process.send(e.code);
+        })
+      );
+    }, 2)
+  );
 } else {
   assert(0); // bad command line argument
 }
diff --git a/test/parallel/test-cluster-cwd.js b/test/parallel/test-cluster-cwd.js
index 485276befaf39b..80c2cec1a54709 100644
--- a/test/parallel/test-cluster-cwd.js
+++ b/test/parallel/test-cluster-cwd.js
@@ -8,15 +8,21 @@ if (cluster.isMaster) {
   tmpdir.refresh();
 
   assert.strictEqual(cluster.settings.cwd, undefined);
-  cluster.fork().on('message', common.mustCall((msg) => {
-    assert.strictEqual(msg, process.cwd());
-  }));
+  cluster.fork().on(
+    'message',
+    common.mustCall((msg) => {
+      assert.strictEqual(msg, process.cwd());
+    })
+  );
 
   cluster.setupMaster({ cwd: tmpdir.path });
   assert.strictEqual(cluster.settings.cwd, tmpdir.path);
-  cluster.fork().on('message', common.mustCall((msg) => {
-    assert.strictEqual(msg, tmpdir.path);
-  }));
+  cluster.fork().on(
+    'message',
+    common.mustCall((msg) => {
+      assert.strictEqual(msg, tmpdir.path);
+    })
+  );
 } else {
   process.send(process.cwd());
   process.disconnect();
diff --git a/test/parallel/test-cluster-dgram-1.js b/test/parallel/test-cluster-dgram-1.js
index 4e7bf97d271eaf..3f82ccaebd4064 100644
--- a/test/parallel/test-cluster-dgram-1.js
+++ b/test/parallel/test-cluster-dgram-1.js
@@ -31,81 +31,93 @@ const assert = require('assert');
 const cluster = require('cluster');
 const dgram = require('dgram');
 
-if (cluster.isMaster)
-  master();
-else
-  worker();
-
+if (cluster.isMaster) master();
+else worker();
 
 function master() {
   let listening = 0;
 
   // Fork 4 workers.
-  for (let i = 0; i < NUM_WORKERS; i++)
-    cluster.fork();
+  for (let i = 0; i < NUM_WORKERS; i++) cluster.fork();
 
   // Wait until all workers are listening.
-  cluster.on('listening', common.mustCall((worker, address) => {
-    if (++listening < NUM_WORKERS)
-      return;
-
-    // Start sending messages.
-    const buf = Buffer.from('hello world');
-    const socket = dgram.createSocket('udp4');
-    let sent = 0;
-    doSend();
-
-    function doSend() {
-      socket.send(buf, 0, buf.length, address.port, address.address, afterSend);
-    }
-
-    function afterSend() {
-      sent++;
-      if (sent < NUM_WORKERS * PACKETS_PER_WORKER) {
-        doSend();
-      } else {
-        socket.close();
+  cluster.on(
+    'listening',
+    common.mustCall((worker, address) => {
+      if (++listening < NUM_WORKERS) return;
+
+      // Start sending messages.
+      const buf = Buffer.from('hello world');
+      const socket = dgram.createSocket('udp4');
+      let sent = 0;
+      doSend();
+
+      function doSend() {
+        socket.send(
+          buf,
+          0,
+          buf.length,
+          address.port,
+          address.address,
+          afterSend
+        );
+      }
+
+      function afterSend() {
+        sent++;
+        if (sent < NUM_WORKERS * PACKETS_PER_WORKER) {
+          doSend();
+        } else {
+          socket.close();
+        }
       }
-    }
-  }, NUM_WORKERS));
+    }, NUM_WORKERS)
+  );
 
   // Set up event handlers for every worker. Each worker sends a message when
   // it has received the expected number of packets. After that it disconnects.
   for (const key in cluster.workers) {
-    if (cluster.workers.hasOwnProperty(key))
-      setupWorker(cluster.workers[key]);
+    if (cluster.workers.hasOwnProperty(key)) setupWorker(cluster.workers[key]);
   }
 
   function setupWorker(worker) {
     let received = 0;
 
-    worker.on('message', common.mustCall((msg) => {
-      received = msg.received;
-      worker.disconnect();
-    }));
-
-    worker.on('exit', common.mustCall(() => {
-      assert.strictEqual(received, PACKETS_PER_WORKER);
-    }));
+    worker.on(
+      'message',
+      common.mustCall((msg) => {
+        received = msg.received;
+        worker.disconnect();
+      })
+    );
+
+    worker.on(
+      'exit',
+      common.mustCall(() => {
+        assert.strictEqual(received, PACKETS_PER_WORKER);
+      })
+    );
   }
 }
 
-
 function worker() {
   let received = 0;
 
   // Create udp socket and start listening.
   const socket = dgram.createSocket('udp4');
 
-  socket.on('message', common.mustCall((data, info) => {
-    received++;
+  socket.on(
+    'message',
+    common.mustCall((data, info) => {
+      received++;
 
-    // Every 10 messages, notify the master.
-    if (received === PACKETS_PER_WORKER) {
-      process.send({ received });
-      socket.close();
-    }
-  }, PACKETS_PER_WORKER));
+      // Every 10 messages, notify the master.
+      if (received === PACKETS_PER_WORKER) {
+        process.send({ received });
+        socket.close();
+      }
+    }, PACKETS_PER_WORKER)
+  );
 
   socket.bind(0);
 }
diff --git a/test/parallel/test-cluster-dgram-2.js b/test/parallel/test-cluster-dgram-2.js
index 7c1dae65600fc0..7d3de253558372 100644
--- a/test/parallel/test-cluster-dgram-2.js
+++ b/test/parallel/test-cluster-dgram-2.js
@@ -31,43 +31,43 @@ const cluster = require('cluster');
 const dgram = require('dgram');
 const assert = require('assert');
 
-if (cluster.isMaster)
-  master();
-else
-  worker();
-
+if (cluster.isMaster) master();
+else worker();
 
 function master() {
   let received = 0;
 
   // Start listening on a socket.
   const socket = dgram.createSocket('udp4');
-  socket.bind({ port: 0 }, common.mustCall(() => {
-
-    // Fork workers.
-    for (let i = 0; i < NUM_WORKERS; i++) {
-      const worker = cluster.fork();
-      worker.send({ port: socket.address().port });
-    }
-  }));
+  socket.bind(
+    { port: 0 },
+    common.mustCall(() => {
+      // Fork workers.
+      for (let i = 0; i < NUM_WORKERS; i++) {
+        const worker = cluster.fork();
+        worker.send({ port: socket.address().port });
+      }
+    })
+  );
 
   // Disconnect workers when the expected number of messages have been
   // received.
-  socket.on('message', common.mustCall((data, info) => {
-    received++;
-
-    if (received === PACKETS_PER_WORKER * NUM_WORKERS) {
-
-      // Close the socket.
-      socket.close();
-
-      // Disconnect all workers.
-      cluster.disconnect();
-    }
-  }, NUM_WORKERS * PACKETS_PER_WORKER));
+  socket.on(
+    'message',
+    common.mustCall((data, info) => {
+      received++;
+
+      if (received === PACKETS_PER_WORKER * NUM_WORKERS) {
+        // Close the socket.
+        socket.close();
+
+        // Disconnect all workers.
+        cluster.disconnect();
+      }
+    }, NUM_WORKERS * PACKETS_PER_WORKER)
+  );
 }
 
-
 function worker() {
   // Create udp socket and send packets to master.
   const socket = dgram.createSocket('udp4');
@@ -78,17 +78,20 @@ function worker() {
   // send(), explicitly bind them to an ephemeral port.
   socket.bind(0);
 
-  process.on('message', common.mustCall((msg) => {
-    assert(msg.port);
-
-    // There is no guarantee that a sent dgram packet will be received so keep
-    // sending until disconnect.
-    const interval = setInterval(() => {
-      socket.send(buf, 0, buf.length, msg.port, '127.0.0.1');
-    }, 1);
-
-    cluster.worker.on('disconnect', () => {
-      clearInterval(interval);
-    });
-  }));
+  process.on(
+    'message',
+    common.mustCall((msg) => {
+      assert(msg.port);
+
+      // There is no guarantee that a sent dgram packet will be received so keep
+      // sending until disconnect.
+      const interval = setInterval(() => {
+        socket.send(buf, 0, buf.length, msg.port, '127.0.0.1');
+      }, 1);
+
+      cluster.worker.on('disconnect', () => {
+        clearInterval(interval);
+      });
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-dgram-bind-fd.js b/test/parallel/test-cluster-dgram-bind-fd.js
index 7b6fb89501fae1..87000dbbfdbb8d 100644
--- a/test/parallel/test-cluster-dgram-bind-fd.js
+++ b/test/parallel/test-cluster-dgram-bind-fd.js
@@ -11,11 +11,8 @@ const assert = require('assert');
 const cluster = require('cluster');
 const dgram = require('dgram');
 
-if (cluster.isMaster)
-  master();
-else
-  worker();
-
+if (cluster.isMaster) master();
+else worker();
 
 function master() {
   const { internalBinding } = require('internal/test/binding');
@@ -32,80 +29,98 @@ function master() {
   let listening = 0;
 
   // Fork 4 workers.
-  for (let i = 0; i < NUM_WORKERS; i++)
-    cluster.fork();
+  for (let i = 0; i < NUM_WORKERS; i++) cluster.fork();
 
   // Wait until all workers are listening.
-  cluster.on('listening', common.mustCall((worker, address) => {
-    if (++listening < NUM_WORKERS)
-      return;
-
-    // Start sending messages.
-    const buf = Buffer.from('hello world');
-    const socket = dgram.createSocket('udp4');
-    let sent = 0;
-    doSend();
-
-    function doSend() {
-      socket.send(buf, 0, buf.length, address.port, address.address, afterSend);
-    }
-
-    function afterSend() {
-      sent++;
-      if (sent < NUM_WORKERS * PACKETS_PER_WORKER) {
-        doSend();
-      } else {
-        socket.close();
+  cluster.on(
+    'listening',
+    common.mustCall((worker, address) => {
+      if (++listening < NUM_WORKERS) return;
+
+      // Start sending messages.
+      const buf = Buffer.from('hello world');
+      const socket = dgram.createSocket('udp4');
+      let sent = 0;
+      doSend();
+
+      function doSend() {
+        socket.send(
+          buf,
+          0,
+          buf.length,
+          address.port,
+          address.address,
+          afterSend
+        );
+      }
+
+      function afterSend() {
+        sent++;
+        if (sent < NUM_WORKERS * PACKETS_PER_WORKER) {
+          doSend();
+        } else {
+          socket.close();
+        }
       }
-    }
-  }, NUM_WORKERS));
+    }, NUM_WORKERS)
+  );
 
   // Set up event handlers for every worker. Each worker sends a message when
   // it has received the expected number of packets. After that it disconnects.
   for (const key in cluster.workers) {
-    if (cluster.workers.hasOwnProperty(key))
-      setupWorker(cluster.workers[key]);
+    if (cluster.workers.hasOwnProperty(key)) setupWorker(cluster.workers[key]);
   }
 
   function setupWorker(worker) {
     let received = 0;
 
     worker.send({
-      fd,
+      fd
     });
 
-    worker.on('message', common.mustCall((msg) => {
-      received = msg.received;
-      worker.disconnect();
-    }));
-
-    worker.on('exit', common.mustCall(() => {
-      assert.strictEqual(received, PACKETS_PER_WORKER);
-    }));
+    worker.on(
+      'message',
+      common.mustCall((msg) => {
+        received = msg.received;
+        worker.disconnect();
+      })
+    );
+
+    worker.on(
+      'exit',
+      common.mustCall(() => {
+        assert.strictEqual(received, PACKETS_PER_WORKER);
+      })
+    );
   }
 }
 
-
 function worker() {
   let received = 0;
 
-  process.on('message', common.mustCall((data) => {
-    const { fd } = data;
-    // Create udp socket and start listening.
-    const socket = dgram.createSocket('udp4');
-
-    socket.on('message', common.mustCall((data, info) => {
-      received++;
-
-      // Every 10 messages, notify the master.
-      if (received === PACKETS_PER_WORKER) {
-        process.send({ received });
-        socket.close();
-      }
-    }, PACKETS_PER_WORKER));
-
-    socket.bind({
-      fd,
-    });
-  }));
+  process.on(
+    'message',
+    common.mustCall((data) => {
+      const { fd } = data;
+      // Create udp socket and start listening.
+      const socket = dgram.createSocket('udp4');
+
+      socket.on(
+        'message',
+        common.mustCall((data, info) => {
+          received++;
+
+          // Every 10 messages, notify the master.
+          if (received === PACKETS_PER_WORKER) {
+            process.send({ received });
+            socket.close();
+          }
+        }, PACKETS_PER_WORKER)
+      );
+
+      socket.bind({
+        fd
+      });
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-dgram-reuse.js b/test/parallel/test-cluster-dgram-reuse.js
index 51a4944e554856..857fdc9b099754 100644
--- a/test/parallel/test-cluster-dgram-reuse.js
+++ b/test/parallel/test-cluster-dgram-reuse.js
@@ -8,16 +8,18 @@ const cluster = require('cluster');
 const dgram = require('dgram');
 
 if (cluster.isMaster) {
-  cluster.fork().on('exit', common.mustCall((code) => {
-    assert.strictEqual(code, 0);
-  }));
+  cluster.fork().on(
+    'exit',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 0);
+    })
+  );
   return;
 }
 
 let waiting = 2;
 function close() {
-  if (--waiting === 0)
-    cluster.worker.disconnect();
+  if (--waiting === 0) cluster.worker.disconnect();
 }
 
 const options = { type: 'udp4', reuseAddr: true };
diff --git a/test/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js b/test/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js
index db2aa6d34a6116..cfce21d7c17b3d 100644
--- a/test/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js
+++ b/test/parallel/test-cluster-disconnect-exitedAfterDisconnect-race.js
@@ -19,10 +19,15 @@ let eventFired = false;
 
 cluster.worker.disconnect();
 
-process.nextTick(common.mustCall(() => {
-  assert.ok(!eventFired, 'disconnect event should wait for ack');
-}));
-
-cluster.worker.on('disconnect', common.mustCall(() => {
-  eventFired = true;
-}));
+process.nextTick(
+  common.mustCall(() => {
+    assert.ok(!eventFired, 'disconnect event should wait for ack');
+  })
+);
+
+cluster.worker.on(
+  'disconnect',
+  common.mustCall(() => {
+    eventFired = true;
+  })
+);
diff --git a/test/parallel/test-cluster-disconnect-idle-worker.js b/test/parallel/test-cluster-disconnect-idle-worker.js
index 5b7e73ba079115..4b5386f617f24c 100644
--- a/test/parallel/test-cluster-disconnect-idle-worker.js
+++ b/test/parallel/test-cluster-disconnect-idle-worker.js
@@ -28,7 +28,9 @@ const fork = cluster.fork;
 if (cluster.isMaster) {
   fork(); // it is intentionally called `fork` instead of
   fork(); // `cluster.fork` to test that `this` is not used
-  cluster.disconnect(common.mustCall(() => {
-    assert.deepStrictEqual(Object.keys(cluster.workers), []);
-  }));
+  cluster.disconnect(
+    common.mustCall(() => {
+      assert.deepStrictEqual(Object.keys(cluster.workers), []);
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-disconnect-race.js b/test/parallel/test-cluster-disconnect-race.js
index 9e8b6d41d5c99e..be2cf1eb0ecf07 100644
--- a/test/parallel/test-cluster-disconnect-race.js
+++ b/test/parallel/test-cluster-disconnect-race.js
@@ -4,8 +4,7 @@
 // Ref: https://github.com/nodejs/node/issues/4205
 
 const common = require('../common');
-if (common.isWindows)
-  common.skip('This test does not apply to Windows.');
+if (common.isWindows) common.skip('This test does not apply to Windows.');
 
 const assert = require('assert');
 const net = require('net');
@@ -17,15 +16,21 @@ if (cluster.isMaster) {
   let worker2;
 
   const worker1 = cluster.fork();
-  worker1.on('message', common.mustCall(function() {
-    worker2 = cluster.fork();
-    worker1.disconnect();
-    worker2.on('online', common.mustCall(worker2.disconnect));
-  }));
-
-  cluster.on('exit', common.mustCall(function(worker, code) {
-    assert.strictEqual(code, 0, `worker exited with error code ${code}`);
-  }, 2));
+  worker1.on(
+    'message',
+    common.mustCall(function() {
+      worker2 = cluster.fork();
+      worker1.disconnect();
+      worker2.on('online', common.mustCall(worker2.disconnect));
+    })
+  );
+
+  cluster.on(
+    'exit',
+    common.mustCall(function(worker, code) {
+      assert.strictEqual(code, 0, `worker exited with error code ${code}`);
+    }, 2)
+  );
 
   return;
 }
diff --git a/test/parallel/test-cluster-disconnect.js b/test/parallel/test-cluster-disconnect.js
index 219c084a7e7073..633d2c2d7f5c44 100644
--- a/test/parallel/test-cluster-disconnect.js
+++ b/test/parallel/test-cluster-disconnect.js
@@ -26,30 +26,43 @@ const cluster = require('cluster');
 const net = require('net');
 
 if (cluster.isWorker) {
-  net.createServer((socket) => {
-    socket.end('echo');
-  }).listen(0, '127.0.0.1');
+  net
+    .createServer((socket) => {
+      socket.end('echo');
+    })
+    .listen(0, '127.0.0.1');
 
-  net.createServer((socket) => {
-    socket.end('echo');
-  }).listen(0, '127.0.0.1');
+  net
+    .createServer((socket) => {
+      socket.end('echo');
+    })
+    .listen(0, '127.0.0.1');
 } else if (cluster.isMaster) {
   const servers = 2;
   const serverPorts = new Set();
 
   // test a single TCP server
   const testConnection = (port, cb) => {
-    const socket = net.connect(port, '127.0.0.1', () => {
-      // buffer result
-      let result = '';
-      socket.on('data', (chunk) => { result += chunk; });
+    const socket = net.connect(
+      port,
+      '127.0.0.1',
+      () => {
+        // buffer result
+        let result = '';
+        socket.on('data', (chunk) => {
+          result += chunk;
+        });
 
-      // check result
-      socket.on('end', common.mustCall(() => {
-        cb(result === 'echo');
-        serverPorts.delete(port);
-      }));
-    });
+        // check result
+        socket.on(
+          'end',
+          common.mustCall(() => {
+            cb(result === 'echo');
+            serverPorts.delete(port);
+          })
+        );
+      }
+    );
   };
 
   // test both servers created in the cluster
@@ -74,31 +87,40 @@ if (cluster.isWorker) {
     let online = 0;
 
     for (let i = 0, l = workers; i < l; i++) {
-      cluster.fork().on('listening', common.mustCall((address) => {
-        serverPorts.add(address.port);
+      cluster.fork().on(
+        'listening',
+        common.mustCall((address) => {
+          serverPorts.add(address.port);
 
-        online += 1;
-        if (online === workers * servers) {
-          cb();
-        }
-      }, servers));
+          online += 1;
+          if (online === workers * servers) {
+            cb();
+          }
+        }, servers)
+      );
     }
   };
 
   const test = (again) => {
     // 1. start cluster
-    startCluster(common.mustCall(() => {
-      // 2. test cluster
-      testCluster(common.mustCall(() => {
-        // 3. disconnect cluster
-        cluster.disconnect(common.mustCall(() => {
-          // run test again to confirm cleanup
-          if (again) {
-            test();
-          }
-        }));
-      }));
-    }));
+    startCluster(
+      common.mustCall(() => {
+        // 2. test cluster
+        testCluster(
+          common.mustCall(() => {
+            // 3. disconnect cluster
+            cluster.disconnect(
+              common.mustCall(() => {
+                // run test again to confirm cleanup
+                if (again) {
+                  test();
+                }
+              })
+            );
+          })
+        );
+      })
+    );
   };
 
   test(true);
diff --git a/test/parallel/test-cluster-eaccess.js b/test/parallel/test-cluster-eaccess.js
index 346eb26110c12f..920894187562bb 100644
--- a/test/parallel/test-cluster-eaccess.js
+++ b/test/parallel/test-cluster-eaccess.js
@@ -44,39 +44,48 @@ if (cluster.isMaster && process.argv.length !== 3) {
   // makes sure the worker is ready
   worker.on('online', common.mustCall());
 
-  worker.on('message', common.mustCall(function(err) {
-    // disconnect first, so that we will not leave zombies
-    worker.disconnect();
-    assert.strictEqual(err.code, 'EADDRINUSE');
-  }));
+  worker.on(
+    'message',
+    common.mustCall(function(err) {
+      // disconnect first, so that we will not leave zombies
+      worker.disconnect();
+      assert.strictEqual(err.code, 'EADDRINUSE');
+    })
+  );
 } else if (process.argv.length !== 3) {
   // cluster.worker
   const PIPE_NAME = process.env.PIPE_NAME;
   const cp = fork(__filename, [PIPE_NAME], { stdio: 'inherit' });
 
   // message from the child indicates it's ready and listening
-  cp.on('message', common.mustCall(function() {
-    const server = net.createServer().listen(PIPE_NAME, function() {
-      // message child process so that it can exit
-      cp.send('end');
-      // inform master about the unexpected situation
-      process.send('PIPE should have been in use.');
-    });
+  cp.on(
+    'message',
+    common.mustCall(function() {
+      const server = net.createServer().listen(PIPE_NAME, function() {
+        // message child process so that it can exit
+        cp.send('end');
+        // inform master about the unexpected situation
+        process.send('PIPE should have been in use.');
+      });
 
-    server.on('error', function(err) {
-      // message to child process tells it to exit
-      cp.send('end');
-      // propagate error to parent
-      process.send(err);
-    });
-  }));
+      server.on('error', function(err) {
+        // message to child process tells it to exit
+        cp.send('end');
+        // propagate error to parent
+        process.send(err);
+      });
+    })
+  );
 } else if (process.argv.length === 3) {
   // child process (of cluster.worker)
   const PIPE_NAME = process.argv[2];
 
-  const server = net.createServer().listen(PIPE_NAME, common.mustCall(() => {
-    process.send('listening');
-  }));
+  const server = net.createServer().listen(
+    PIPE_NAME,
+    common.mustCall(() => {
+      process.send('listening');
+    })
+  );
   process.once('message', common.mustCall(() => server.close()));
 } else {
   assert.fail('Impossible state');
diff --git a/test/parallel/test-cluster-eaddrinuse.js b/test/parallel/test-cluster-eaddrinuse.js
index eae6d9a455c773..10f38dfea85016 100644
--- a/test/parallel/test-cluster-eaddrinuse.js
+++ b/test/parallel/test-cluster-eaddrinuse.js
@@ -46,17 +46,23 @@ if (id === 'undefined') {
 } else if (id === 'worker') {
   let server = net.createServer(common.mustNotCall());
   server.listen(port, common.mustNotCall());
-  server.on('error', common.mustCall(function(e) {
-    assert(e.code, 'EADDRINUSE');
-    process.send('stop-listening');
-    process.once('message', function(msg) {
-      if (msg !== 'stopped-listening') return;
-      server = net.createServer(common.mustNotCall());
-      server.listen(port, common.mustCall(function() {
-        server.close();
-      }));
-    });
-  }));
+  server.on(
+    'error',
+    common.mustCall(function(e) {
+      assert(e.code, 'EADDRINUSE');
+      process.send('stop-listening');
+      process.once('message', function(msg) {
+        if (msg !== 'stopped-listening') return;
+        server = net.createServer(common.mustNotCall());
+        server.listen(
+          port,
+          common.mustCall(function() {
+            server.close();
+          })
+        );
+      });
+    })
+  );
 } else {
-  assert(0);  // Bad argument.
+  assert(0); // Bad argument.
 }
diff --git a/test/parallel/test-cluster-fork-env.js b/test/parallel/test-cluster-fork-env.js
index 57e7881013d0fd..f8f6dff9b2408c 100644
--- a/test/parallel/test-cluster-fork-env.js
+++ b/test/parallel/test-cluster-fork-env.js
@@ -37,7 +37,6 @@ if (cluster.isWorker) {
 
   assert.strictEqual(result, true);
 } else if (cluster.isMaster) {
-
   const checks = {
     using: false,
     overwrite: false
@@ -49,14 +48,14 @@ if (cluster.isWorker) {
 
   // Fork worker
   const worker = cluster.fork({
-    'cluster_test_prop': 'custom',
-    'cluster_test_overwrite': 'new'
+    cluster_test_prop: 'custom',
+    cluster_test_overwrite: 'new'
   });
 
   // Checks worker env
   worker.on('message', function(data) {
-    checks.using = (data.prop === 'custom');
-    checks.overwrite = (data.overwrite === 'new');
+    checks.using = data.prop === 'custom';
+    checks.overwrite = data.overwrite === 'new';
     process.exit(0);
   });
 
@@ -64,7 +63,7 @@ if (cluster.isWorker) {
     assert.ok(checks.using, 'The worker did not receive the correct env.');
     assert.ok(
       checks.overwrite,
-      'The custom environment did not overwrite the existing environment.');
+      'The custom environment did not overwrite the existing environment.'
+    );
   });
-
 }
diff --git a/test/parallel/test-cluster-fork-stdio.js b/test/parallel/test-cluster-fork-stdio.js
index 1d00e0768e5746..5e8f80552d114d 100644
--- a/test/parallel/test-cluster-fork-stdio.js
+++ b/test/parallel/test-cluster-fork-stdio.js
@@ -15,10 +15,13 @@ if (cluster.isMaster) {
   const channel = worker.process.stdio[4];
   let response = '';
 
-  worker.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  }));
+  worker.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 
   channel.setEncoding('utf8');
   channel.on('data', (data) => {
diff --git a/test/parallel/test-cluster-fork-windowsHide.js b/test/parallel/test-cluster-fork-windowsHide.js
index b9ee701beb65ff..055309940797cf 100644
--- a/test/parallel/test-cluster-fork-windowsHide.js
+++ b/test/parallel/test-cluster-fork-windowsHide.js
@@ -18,11 +18,11 @@ if (!process.argv[2]) {
   const master = child_process.spawn(
     process.argv[0],
     [process.argv[1], '--cluster'],
-    { detached: true, stdio: ['ignore', 'ignore', 'ignore', 'ipc'] });
+    { detached: true, stdio: ['ignore', 'ignore', 'ignore', 'ipc'] }
+  );
 
   const messageHandlers = {
-    workerOnline: common.mustCall((msg) => {
-    }),
+    workerOnline: common.mustCall((msg) => {}),
     mainWindowHandle: common.mustCall((msg) => {
       assert.ok(/0\s*/.test(msg.value));
     }),
@@ -38,11 +38,13 @@ if (!process.argv[2]) {
     handler(msg);
   });
 
-  master.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  }));
-
+  master.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 } else if (cluster.isMaster) {
   cluster.setupMaster({
     silent: true,
@@ -61,14 +63,14 @@ if (!process.argv[2]) {
     if (process.platform === 'win32') {
       output = child_process.execSync(
         'powershell -NoProfile -c ' +
-        `"(Get-Process -Id ${worker.process.pid}).MainWindowHandle"`,
-        { windowsHide: true, encoding: 'utf8' });
+          `"(Get-Process -Id ${worker.process.pid}).MainWindowHandle"`,
+        { windowsHide: true, encoding: 'utf8' }
+      );
     }
 
     process.send({ type: 'mainWindowHandle', value: output });
     worker.send('shutdown');
   });
-
 } else {
   cluster.worker.on('message', (msg) => {
     cluster.worker.disconnect();
diff --git a/test/parallel/test-cluster-http-pipe.js b/test/parallel/test-cluster-http-pipe.js
index 9e039541cd26f1..a0fd7d5022dda9 100644
--- a/test/parallel/test-cluster-http-pipe.js
+++ b/test/parallel/test-cluster-http-pipe.js
@@ -24,7 +24,8 @@
 const common = require('../common');
 if (common.isWindows) {
   common.skip(
-    'It is not possible to send pipe handles over the IPC pipe on Windows');
+    'It is not possible to send pipe handles over the IPC pipe on Windows'
+  );
 }
 
 const assert = require('assert');
@@ -35,26 +36,42 @@ if (cluster.isMaster) {
   const tmpdir = require('../common/tmpdir');
   tmpdir.refresh();
   const worker = cluster.fork();
-  worker.on('message', common.mustCall((msg) => {
-    assert.strictEqual(msg, 'DONE');
-  }));
+  worker.on(
+    'message',
+    common.mustCall((msg) => {
+      assert.strictEqual(msg, 'DONE');
+    })
+  );
   worker.on('exit', common.mustCall());
   return;
 }
 
-http.createServer(common.mustCall((req, res) => {
-  assert.strictEqual(req.connection.remoteAddress, undefined);
-  assert.strictEqual(req.connection.localAddress, undefined);
+http
+  .createServer(
+    common.mustCall((req, res) => {
+      assert.strictEqual(req.connection.remoteAddress, undefined);
+      assert.strictEqual(req.connection.localAddress, undefined);
 
-  res.writeHead(200);
-  res.end('OK');
-})).listen(common.PIPE, common.mustCall(() => {
-  http.get({ socketPath: common.PIPE, path: '/' }, common.mustCall((res) => {
-    res.resume();
-    res.on('end', common.mustCall((err) => {
-      assert.ifError(err);
-      process.send('DONE');
-      process.exit();
-    }));
-  }));
-}));
+      res.writeHead(200);
+      res.end('OK');
+    })
+  )
+  .listen(
+    common.PIPE,
+    common.mustCall(() => {
+      http.get(
+        { socketPath: common.PIPE, path: '/' },
+        common.mustCall((res) => {
+          res.resume();
+          res.on(
+            'end',
+            common.mustCall((err) => {
+              assert.ifError(err);
+              process.send('DONE');
+              process.exit();
+            })
+          );
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-cluster-invalid-message.js b/test/parallel/test-cluster-invalid-message.js
index 006c80a7aae8fc..1dd5b59fe8cb9a 100644
--- a/test/parallel/test-cluster-invalid-message.js
+++ b/test/parallel/test-cluster-invalid-message.js
@@ -6,17 +6,23 @@ const cluster = require('cluster');
 if (cluster.isMaster) {
   const worker = cluster.fork();
 
-  worker.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  }));
+  worker.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 
   worker.on('online', () => {
-    worker.send({
-      cmd: 'NODE_CLUSTER',
-      ack: -1
-    }, () => {
-      worker.disconnect();
-    });
+    worker.send(
+      {
+        cmd: 'NODE_CLUSTER',
+        ack: -1
+      },
+      () => {
+        worker.disconnect();
+      }
+    );
   });
 }
diff --git a/test/parallel/test-cluster-ipc-throw.js b/test/parallel/test-cluster-ipc-throw.js
index d19cf0c3811aa5..fb5b625007c410 100644
--- a/test/parallel/test-cluster-ipc-throw.js
+++ b/test/parallel/test-cluster-ipc-throw.js
@@ -9,18 +9,27 @@ cluster.schedulingPolicy = cluster.SCHED_RR;
 const server = http.createServer();
 
 if (cluster.isMaster) {
-  server.listen({ port: 0 }, common.mustCall(() => {
-    const worker = cluster.fork({ PORT: server.address().port });
-    worker.on('exit', common.mustCall(() => {
-      server.close();
-    }));
-  }));
+  server.listen(
+    { port: 0 },
+    common.mustCall(() => {
+      const worker = cluster.fork({ PORT: server.address().port });
+      worker.on(
+        'exit',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+    })
+  );
 } else {
   assert(process.env.PORT);
   process.on('uncaughtException', common.mustCall((e) => {}));
   server.listen(process.env.PORT);
-  server.on('error', common.mustCall((e) => {
-    cluster.worker.disconnect();
-    throw e;
-  }));
+  server.on(
+    'error',
+    common.mustCall((e) => {
+      cluster.worker.disconnect();
+      throw e;
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-kill-disconnect.js b/test/parallel/test-cluster-kill-disconnect.js
index f5407612a83b5f..b96c5439fef38f 100644
--- a/test/parallel/test-cluster-kill-disconnect.js
+++ b/test/parallel/test-cluster-kill-disconnect.js
@@ -12,13 +12,19 @@ const cluster = require('cluster');
 if (cluster.isMaster) {
   function forkWorker(action) {
     const worker = cluster.fork({ action });
-    worker.on('disconnect', common.mustCall(() => {
-      assert.strictEqual(worker.exitedAfterDisconnect, true);
-    }));
+    worker.on(
+      'disconnect',
+      common.mustCall(() => {
+        assert.strictEqual(worker.exitedAfterDisconnect, true);
+      })
+    );
 
-    worker.on('exit', common.mustCall(() => {
-      assert.strictEqual(worker.exitedAfterDisconnect, true);
-    }));
+    worker.on(
+      'exit',
+      common.mustCall(() => {
+        assert.strictEqual(worker.exitedAfterDisconnect, true);
+      })
+    );
   }
 
   forkWorker('disconnect');
diff --git a/test/parallel/test-cluster-kill-infinite-loop.js b/test/parallel/test-cluster-kill-infinite-loop.js
index f53e6e3976ec28..0ebdfe13de95de 100644
--- a/test/parallel/test-cluster-kill-infinite-loop.js
+++ b/test/parallel/test-cluster-kill-infinite-loop.js
@@ -6,16 +6,22 @@ const assert = require('assert');
 if (cluster.isMaster) {
   const worker = cluster.fork();
 
-  worker.on('online', common.mustCall(() => {
-    // Use worker.process.kill() instead of worker.kill() because the latter
-    // waits for a graceful disconnect, which will never happen.
-    worker.process.kill();
-  }));
+  worker.on(
+    'online',
+    common.mustCall(() => {
+      // Use worker.process.kill() instead of worker.kill() because the latter
+      // waits for a graceful disconnect, which will never happen.
+      worker.process.kill();
+    })
+  );
 
-  worker.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, null);
-    assert.strictEqual(signal, 'SIGTERM');
-  }));
+  worker.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, null);
+      assert.strictEqual(signal, 'SIGTERM');
+    })
+  );
 } else {
   while (true) {}
 }
diff --git a/test/parallel/test-cluster-listening-port.js b/test/parallel/test-cluster-listening-port.js
index 84bf49fa96c81f..7e70b66533c914 100644
--- a/test/parallel/test-cluster-listening-port.js
+++ b/test/parallel/test-cluster-listening-port.js
@@ -6,14 +6,17 @@ const net = require('net');
 
 if (cluster.isMaster) {
   cluster.fork();
-  cluster.on('listening', common.mustCall(function(worker, address) {
-    const port = address.port;
-    // ensure that the port is not 0 or null
-    assert(port);
-    // ensure that the port is numerical
-    assert.strictEqual(typeof port, 'number');
-    worker.kill();
-  }));
+  cluster.on(
+    'listening',
+    common.mustCall(function(worker, address) {
+      const port = address.port;
+      // ensure that the port is not 0 or null
+      assert(port);
+      // ensure that the port is numerical
+      assert.strictEqual(typeof port, 'number');
+      worker.kill();
+    })
+  );
 } else {
   net.createServer(common.mustNotCall()).listen(0);
 }
diff --git a/test/parallel/test-cluster-master-error.js b/test/parallel/test-cluster-master-error.js
index 9abb42e4225567..aa99c4812cb877 100644
--- a/test/parallel/test-cluster-master-error.js
+++ b/test/parallel/test-cluster-master-error.js
@@ -29,49 +29,47 @@ const totalWorkers = 2;
 // Cluster setup
 if (cluster.isWorker) {
   const http = require('http');
-  http.Server(() => {
-
-  }).listen(0, '127.0.0.1');
-
+  http.Server(() => {}).listen(0, '127.0.0.1');
 } else if (process.argv[2] === 'cluster') {
-
   // Send PID to testcase process
   let forkNum = 0;
-  cluster.on('fork', common.mustCall(function forkEvent(worker) {
-
-    // Send PID
-    process.send({
-      cmd: 'worker',
-      workerPID: worker.process.pid
-    });
+  cluster.on(
+    'fork',
+    common.mustCall(function forkEvent(worker) {
+      // Send PID
+      process.send({
+        cmd: 'worker',
+        workerPID: worker.process.pid
+      });
 
-    // Stop listening when done
-    if (++forkNum === totalWorkers) {
-      cluster.removeListener('fork', forkEvent);
-    }
-  }));
+      // Stop listening when done
+      if (++forkNum === totalWorkers) {
+        cluster.removeListener('fork', forkEvent);
+      }
+    })
+  );
 
   // Throw accidental error when all workers are listening
   let listeningNum = 0;
-  cluster.on('listening', common.mustCall(function listeningEvent() {
-
-    // When all workers are listening
-    if (++listeningNum === totalWorkers) {
-      // Stop listening
-      cluster.removeListener('listening', listeningEvent);
-
-      // Throw accidental error
-      process.nextTick(() => {
-        throw new Error('accidental error');
-      });
-    }
-
-  }));
+  cluster.on(
+    'listening',
+    common.mustCall(function listeningEvent() {
+      // When all workers are listening
+      if (++listeningNum === totalWorkers) {
+        // Stop listening
+        cluster.removeListener('listening', listeningEvent);
+
+        // Throw accidental error
+        process.nextTick(() => {
+          throw new Error('accidental error');
+        });
+      }
+    })
+  );
 
   // Startup a basic cluster
   cluster.fork();
   cluster.fork();
-
 } else {
   // This is the testcase
 
@@ -87,40 +85,44 @@ if (cluster.isWorker) {
   const master = fork(process.argv[1], ['cluster'], { silent: true });
 
   // Handle messages from the cluster
-  master.on('message', common.mustCall((data) => {
-
-    // Add worker pid to list and progress tracker
-    if (data.cmd === 'worker') {
-      workers.push(data.workerPID);
-    }
-  }, totalWorkers));
-
-  // When cluster is dead
-  master.on('exit', common.mustCall((code) => {
-
-    // Check that the cluster died accidentally (non-zero exit code)
-    masterExited = !!code;
-
-    const pollWorkers = () => {
-      // When master is dead all workers should be dead too
-      let alive = false;
-      workers.forEach((pid) => alive = common.isAlive(pid));
-      if (alive) {
-        setTimeout(pollWorkers, 50);
-      } else {
-        workersExited = true;
+  master.on(
+    'message',
+    common.mustCall((data) => {
+      // Add worker pid to list and progress tracker
+      if (data.cmd === 'worker') {
+        workers.push(data.workerPID);
       }
-    };
+    }, totalWorkers)
+  );
 
-    // Loop indefinitely until worker exit
-    pollWorkers();
-  }));
+  // When cluster is dead
+  master.on(
+    'exit',
+    common.mustCall((code) => {
+      // Check that the cluster died accidentally (non-zero exit code)
+      masterExited = !!code;
+
+      const pollWorkers = () => {
+        // When master is dead all workers should be dead too
+        let alive = false;
+        workers.forEach((pid) => (alive = common.isAlive(pid)));
+        if (alive) {
+          setTimeout(pollWorkers, 50);
+        } else {
+          workersExited = true;
+        }
+      };
+
+      // Loop indefinitely until worker exit
+      pollWorkers();
+    })
+  );
 
   process.once('exit', () => {
-    assert(masterExited,
-           'The master did not die after an error was thrown');
-    assert(workersExited,
-           'The workers did not die after an error in the master');
+    assert(masterExited, 'The master did not die after an error was thrown');
+    assert(
+      workersExited,
+      'The workers did not die after an error in the master'
+    );
   });
-
 }
diff --git a/test/parallel/test-cluster-master-kill.js b/test/parallel/test-cluster-master-kill.js
index 4e21d8e906cfaf..2334467a13f456 100644
--- a/test/parallel/test-cluster-master-kill.js
+++ b/test/parallel/test-cluster-master-kill.js
@@ -25,13 +25,10 @@ const assert = require('assert');
 const cluster = require('cluster');
 
 if (cluster.isWorker) {
-
   // keep the worker alive
   const http = require('http');
   http.Server().listen(0, '127.0.0.1');
-
 } else if (process.argv[2] === 'cluster') {
-
   const worker = cluster.fork();
 
   // send PID info to testcase process
@@ -40,14 +37,15 @@ if (cluster.isWorker) {
   });
 
   // terminate the cluster process
-  worker.once('listening', common.mustCall(() => {
-    setTimeout(() => {
-      process.exit(0);
-    }, 1000);
-  }));
-
+  worker.once(
+    'listening',
+    common.mustCall(() => {
+      setTimeout(() => {
+        process.exit(0);
+      }, 1000);
+    })
+  );
 } else {
-
   // This is the testcase
   const fork = require('child_process').fork;
 
@@ -62,27 +60,34 @@ if (cluster.isWorker) {
 
   // When master is dead
   let alive = true;
-  master.on('exit', common.mustCall((code) => {
-
-    // make sure that the master died on purpose
-    assert.strictEqual(code, 0);
-
-    // check worker process status
-    const pollWorker = () => {
-      alive = common.isAlive(pid);
-      if (alive) {
-        setTimeout(pollWorker, 50);
-      }
-    };
-    // Loop indefinitely until worker exit.
-    pollWorker();
-  }));
+  master.on(
+    'exit',
+    common.mustCall((code) => {
+      // make sure that the master died on purpose
+      assert.strictEqual(code, 0);
+
+      // check worker process status
+      const pollWorker = () => {
+        alive = common.isAlive(pid);
+        if (alive) {
+          setTimeout(pollWorker, 50);
+        }
+      };
+      // Loop indefinitely until worker exit.
+      pollWorker();
+    })
+  );
 
   process.once('exit', () => {
-    assert.strictEqual(typeof pid, 'number',
-                       `got ${pid} instead of a worker pid`);
-    assert.strictEqual(alive, false,
-                       `worker was alive after master died (alive = ${alive})`);
+    assert.strictEqual(
+      typeof pid,
+      'number',
+      `got ${pid} instead of a worker pid`
+    );
+    assert.strictEqual(
+      alive,
+      false,
+      `worker was alive after master died (alive = ${alive})`
+    );
   });
-
 }
diff --git a/test/parallel/test-cluster-message.js b/test/parallel/test-cluster-message.js
index 5585a64d48149d..e05cebe70937e1 100644
--- a/test/parallel/test-cluster-message.js
+++ b/test/parallel/test-cluster-message.js
@@ -41,10 +41,12 @@ if (cluster.isWorker) {
     if (!socket || !message) return;
 
     // Tell master using TCP socket that a message is received.
-    socket.write(JSON.stringify({
-      code: 'received message',
-      echo: message
-    }));
+    socket.write(
+      JSON.stringify({
+        code: 'received message',
+        echo: message
+      })
+    );
   }
 
   server.on('connection', function(socket_) {
@@ -62,23 +64,21 @@ if (cluster.isWorker) {
 
   server.listen(0, '127.0.0.1');
 } else if (cluster.isMaster) {
-
   const checks = {
     global: {
-      'receive': false,
-      'correct': false
+      receive: false,
+      correct: false
     },
     master: {
-      'receive': false,
-      'correct': false
+      receive: false,
+      correct: false
     },
     worker: {
-      'receive': false,
-      'correct': false
+      receive: false,
+      correct: false
     }
   };
 
-
   let client;
   const check = (type, result) => {
     checks[type].receive = true;
@@ -110,11 +110,13 @@ if (cluster.isWorker) {
 
   // When a TCP server is listening in the worker connect to it
   worker.on('listening', function(address) {
-
-    client = net.connect(address.port, function() {
-      // Send message to worker.
-      worker.send('message from master');
-    });
+    client = net.connect(
+      address.port,
+      function() {
+        // Send message to worker.
+        worker.send('message from master');
+      }
+    );
 
     client.on('data', function(data) {
       // All data is JSON
@@ -132,9 +134,12 @@ if (cluster.isWorker) {
       worker.kill();
     });
 
-    worker.on('exit', common.mustCall(function() {
-      process.exit(0);
-    }));
+    worker.on(
+      'exit',
+      common.mustCall(function() {
+        process.exit(0);
+      })
+    );
   });
 
   process.once('exit', function() {
diff --git a/test/parallel/test-cluster-net-listen-relative-path.js b/test/parallel/test-cluster-net-listen-relative-path.js
index 0e1c3f7cf7cf4a..ac7cd4b40e4e2f 100644
--- a/test/parallel/test-cluster-net-listen-relative-path.js
+++ b/test/parallel/test-cluster-net-listen-relative-path.js
@@ -2,8 +2,10 @@
 const common = require('../common');
 
 if (common.isWindows)
-  common.skip('On Windows named pipes live in their own ' +
-              'filesystem and don\'t have a ~100 byte limit');
+  common.skip(
+    'On Windows named pipes live in their own ' +
+      "filesystem and don't have a ~100 byte limit"
+  );
 if (!common.isMainThread)
   common.skip('process.chdir is not available in Workers');
 
@@ -20,28 +22,38 @@ const socketDir = './unix-socket-dir';
 const socketName = 'A'.repeat(100 - socketDir.length - 1);
 
 // Make sure we're not in a weird environment.
-assert.ok(path.resolve(socketDir, socketName).length > 100,
-          'absolute socket path should be longer than 100 bytes');
+assert.ok(
+  path.resolve(socketDir, socketName).length > 100,
+  'absolute socket path should be longer than 100 bytes'
+);
 
 if (cluster.isMaster) {
   // Ensure that the worker exits peacefully.
   tmpdir.refresh();
   process.chdir(tmpdir.path);
   fs.mkdirSync(socketDir);
-  cluster.fork().on('exit', common.mustCall((statusCode) => {
-    assert.strictEqual(statusCode, 0);
-
-    assert.ok(!fs.existsSync(path.join(socketDir, socketName)),
-              'Socket should be removed when the worker exits');
-  }));
+  cluster.fork().on(
+    'exit',
+    common.mustCall((statusCode) => {
+      assert.strictEqual(statusCode, 0);
+
+      assert.ok(
+        !fs.existsSync(path.join(socketDir, socketName)),
+        'Socket should be removed when the worker exits'
+      );
+    })
+  );
 } else {
   process.chdir(socketDir);
 
   const server = net.createServer(common.mustNotCall());
 
-  server.listen(socketName, common.mustCall(() => {
-    assert.ok(fs.existsSync(socketName), 'Socket created in CWD');
+  server.listen(
+    socketName,
+    common.mustCall(() => {
+      assert.ok(fs.existsSync(socketName), 'Socket created in CWD');
 
-    process.disconnect();
-  }));
+      process.disconnect();
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-net-listen.js b/test/parallel/test-cluster-net-listen.js
index f6b2c4e45a6eb9..08be1f04f04166 100644
--- a/test/parallel/test-cluster-net-listen.js
+++ b/test/parallel/test-cluster-net-listen.js
@@ -27,9 +27,12 @@ const net = require('net');
 
 if (cluster.isMaster) {
   // ensure that the worker exits peacefully
-  cluster.fork().on('exit', common.mustCall(function(statusCode) {
-    assert.strictEqual(statusCode, 0);
-  }));
+  cluster.fork().on(
+    'exit',
+    common.mustCall(function(statusCode) {
+      assert.strictEqual(statusCode, 0);
+    })
+  );
 } else {
   // listen() without port should not trigger a libuv assert
   net.createServer(common.mustNotCall()).listen(process.exit);
diff --git a/test/parallel/test-cluster-net-send.js b/test/parallel/test-cluster-net-send.js
index 14ce58474f128e..1da7291b8757be 100644
--- a/test/parallel/test-cluster-net-send.js
+++ b/test/parallel/test-cluster-net-send.js
@@ -31,20 +31,23 @@ if (process.argv[2] !== 'child') {
   const worker = fork(__filename, ['child']);
   let called = false;
 
-  worker.once('message', common.mustCall(function(msg, handle) {
-    assert.strictEqual(msg, 'handle');
-    assert.ok(handle);
-    worker.send('got');
+  worker.once(
+    'message',
+    common.mustCall(function(msg, handle) {
+      assert.strictEqual(msg, 'handle');
+      assert.ok(handle);
+      worker.send('got');
 
-    handle.on('data', function(data) {
-      called = true;
-      assert.strictEqual(data.toString(), 'hello');
-    });
+      handle.on('data', function(data) {
+        called = true;
+        assert.strictEqual(data.toString(), 'hello');
+      });
 
-    handle.on('end', function() {
-      worker.kill();
-    });
-  }));
+      handle.on('end', function() {
+        worker.kill();
+      });
+    })
+  );
 
   process.once('exit', function() {
     assert.ok(called);
@@ -55,20 +58,26 @@ if (process.argv[2] !== 'child') {
   let socket;
   let cbcalls = 0;
   function socketConnected() {
-    if (++cbcalls === 2)
-      process.send('handle', socket);
+    if (++cbcalls === 2) process.send('handle', socket);
   }
 
   const server = net.createServer(function(c) {
-    process.once('message', common.mustCall(function(msg) {
-      assert.strictEqual(msg, 'got');
-      c.end('hello');
-    }));
+    process.once(
+      'message',
+      common.mustCall(function(msg) {
+        assert.strictEqual(msg, 'got');
+        c.end('hello');
+      })
+    );
     socketConnected();
   });
 
   server.listen(0, function() {
-    socket = net.connect(server.address().port, '127.0.0.1', socketConnected);
+    socket = net.connect(
+      server.address().port,
+      '127.0.0.1',
+      socketConnected
+    );
   });
 
   process.on('disconnect', function() {
diff --git a/test/parallel/test-cluster-process-disconnect.js b/test/parallel/test-cluster-process-disconnect.js
index 39690ac9682917..00b755d9a392ee 100644
--- a/test/parallel/test-cluster-process-disconnect.js
+++ b/test/parallel/test-cluster-process-disconnect.js
@@ -5,22 +5,28 @@ const cluster = require('cluster');
 
 if (cluster.isMaster) {
   const worker = cluster.fork();
-  worker.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(
-      code,
-      0,
-      `Worker did not exit normally with code: ${code}`
-    );
-    assert.strictEqual(
-      signal,
-      null,
-      `Worker did not exit normally with signal: ${signal}`
-    );
-  }));
+  worker.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(
+        code,
+        0,
+        `Worker did not exit normally with code: ${code}`
+      );
+      assert.strictEqual(
+        signal,
+        null,
+        `Worker did not exit normally with signal: ${signal}`
+      );
+    })
+  );
 } else {
   const net = require('net');
   const server = net.createServer();
-  server.listen(0, common.mustCall(() => {
-    process.disconnect();
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      process.disconnect();
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-rr-domain-listen.js b/test/parallel/test-cluster-rr-domain-listen.js
index 0f94eb8e6b8060..3a1a7e99af3c11 100644
--- a/test/parallel/test-cluster-rr-domain-listen.js
+++ b/test/parallel/test-cluster-rr-domain-listen.js
@@ -33,9 +33,7 @@ if (cluster.isWorker) {
 
   const http = require('http');
   http.Server(() => {}).listen(0, '127.0.0.1');
-
 } else if (cluster.isMaster) {
-
   // Kill worker when listening
   cluster.on('listening', function() {
     worker.kill();
diff --git a/test/parallel/test-cluster-send-deadlock.js b/test/parallel/test-cluster-send-deadlock.js
index b02837e7fb1793..b93df7035e6e22 100644
--- a/test/parallel/test-cluster-send-deadlock.js
+++ b/test/parallel/test-cluster-send-deadlock.js
@@ -47,24 +47,29 @@ if (cluster.isMaster) {
   process.on('message', function(msg, handle) {
     if (msg.message && msg.message === 'listen') {
       assert(msg.port);
-      const client1 = net.connect({
-        host: 'localhost',
-        port: msg.port
-      }, function() {
-        const client2 = net.connect({
+      const client1 = net.connect(
+        {
           host: 'localhost',
           port: msg.port
-        }, function() {
-          client1.on('close', onclose);
-          client2.on('close', onclose);
-          client1.end();
-          client2.end();
-        });
-      });
+        },
+        function() {
+          const client2 = net.connect(
+            {
+              host: 'localhost',
+              port: msg.port
+            },
+            function() {
+              client1.on('close', onclose);
+              client2.on('close', onclose);
+              client1.end();
+              client2.end();
+            }
+          );
+        }
+      );
       let waiting = 2;
       function onclose() {
-        if (--waiting === 0)
-          cluster.worker.disconnect();
+        if (--waiting === 0) cluster.worker.disconnect();
       }
     } else {
       process.send('reply', handle);
diff --git a/test/parallel/test-cluster-send-handle-twice.js b/test/parallel/test-cluster-send-handle-twice.js
index 9eb87d826daa20..6fdb6fe190ecb0 100644
--- a/test/parallel/test-cluster-send-handle-twice.js
+++ b/test/parallel/test-cluster-send-handle-twice.js
@@ -34,26 +34,48 @@ const workers = {
 if (cluster.isMaster) {
   for (let i = 0; i < workers.toStart; ++i) {
     const worker = cluster.fork();
-    worker.on('exit', common.mustCall(function(code, signal) {
-      assert.strictEqual(code, 0, `Worker exited with an error code: ${code}`);
-      assert.strictEqual(signal, null, `Worker exited by a signal: ${signal}`);
-    }));
+    worker.on(
+      'exit',
+      common.mustCall(function(code, signal) {
+        assert.strictEqual(
+          code,
+          0,
+          `Worker exited with an error code: ${code}`
+        );
+        assert.strictEqual(
+          signal,
+          null,
+          `Worker exited by a signal: ${signal}`
+        );
+      })
+    );
   }
 } else {
-  const server = net.createServer(common.mustCall((socket) => {
-    process.send('send-handle-1', socket);
-    process.send('send-handle-2', socket);
-  }));
+  const server = net.createServer(
+    common.mustCall((socket) => {
+      process.send('send-handle-1', socket);
+      process.send('send-handle-2', socket);
+    })
+  );
 
-  server.listen(0, function() {
-    const client = net.connect({
-      host: 'localhost',
-      port: server.address().port
+  server
+    .listen(0, function() {
+      const client = net.connect({
+        host: 'localhost',
+        port: server.address().port
+      });
+      client.on(
+        'close',
+        common.mustCall(() => {
+          cluster.worker.disconnect();
+        })
+      );
+      client.on('connect', () => {
+        client.end();
+      });
+    })
+    .on('error', function(e) {
+      console.error(e);
+      assert.fail('server.listen failed');
     });
-    client.on('close', common.mustCall(() => { cluster.worker.disconnect(); }));
-    client.on('connect', () => { client.end(); });
-  }).on('error', function(e) {
-    console.error(e);
-    assert.fail('server.listen failed');
-  });
 }
diff --git a/test/parallel/test-cluster-send-socket-to-worker-http-server.js b/test/parallel/test-cluster-send-socket-to-worker-http-server.js
index 805603d2c9b069..70e6fca56c89f7 100644
--- a/test/parallel/test-cluster-send-socket-to-worker-http-server.js
+++ b/test/parallel/test-cluster-send-socket-to-worker-http-server.js
@@ -12,28 +12,42 @@ const net = require('net');
 
 if (cluster.isMaster) {
   const worker = cluster.fork();
-  const server = net.createServer(common.mustCall((socket) => {
-    worker.send('socket', socket);
-  }));
+  const server = net.createServer(
+    common.mustCall((socket) => {
+      worker.send('socket', socket);
+    })
+  );
 
-  worker.on('exit', common.mustCall((code) => {
-    assert.strictEqual(code, 0);
-    server.close();
-  }));
+  worker.on(
+    'exit',
+    common.mustCall((code) => {
+      assert.strictEqual(code, 0);
+      server.close();
+    })
+  );
 
-  server.listen(0, common.mustCall(() => {
-    net.createConnection(server.address().port);
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      net.createConnection(server.address().port);
+    })
+  );
 } else {
   const server = http.createServer();
 
-  server.on('connection', common.mustCall((socket) => {
-    assert.strictEqual(socket.server, server);
-    socket.destroy();
-    cluster.worker.disconnect();
-  }));
+  server.on(
+    'connection',
+    common.mustCall((socket) => {
+      assert.strictEqual(socket.server, server);
+      socket.destroy();
+      cluster.worker.disconnect();
+    })
+  );
 
-  process.on('message', common.mustCall((message, socket) => {
-    server.emit('connection', socket);
-  }));
+  process.on(
+    'message',
+    common.mustCall((message, socket) => {
+      server.emit('connection', socket);
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-server-restart-none.js b/test/parallel/test-cluster-server-restart-none.js
index 88a6e5858635d2..7e097f603164f5 100644
--- a/test/parallel/test-cluster-server-restart-none.js
+++ b/test/parallel/test-cluster-server-restart-none.js
@@ -7,39 +7,59 @@ cluster.schedulingPolicy = cluster.SCHED_NONE;
 
 if (cluster.isMaster) {
   const worker1 = cluster.fork();
-  worker1.on('listening', common.mustCall(() => {
-    const worker2 = cluster.fork();
-    worker2.on('exit', (code, signal) => {
-      assert.strictEqual(code, 0,
-                         'worker2 did not exit normally. ' +
-                         `exited with code ${code}`);
-      assert.strictEqual(signal, null,
-                         'worker2 did not exit normally. ' +
-                         `exited with signal ${signal}`);
-      worker1.disconnect();
-    });
-  }));
+  worker1.on(
+    'listening',
+    common.mustCall(() => {
+      const worker2 = cluster.fork();
+      worker2.on('exit', (code, signal) => {
+        assert.strictEqual(
+          code,
+          0,
+          'worker2 did not exit normally. ' + `exited with code ${code}`
+        );
+        assert.strictEqual(
+          signal,
+          null,
+          'worker2 did not exit normally. ' + `exited with signal ${signal}`
+        );
+        worker1.disconnect();
+      });
+    })
+  );
 
-  worker1.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0,
-                       'worker1 did not exit normally. ' +
-                       `exited with code ${code}`);
-    assert.strictEqual(signal, null,
-                       'worker1 did not exit normally. ' +
-                       `exited with signal ${signal}`);
-  }));
+  worker1.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(
+        code,
+        0,
+        'worker1 did not exit normally. ' + `exited with code ${code}`
+      );
+      assert.strictEqual(
+        signal,
+        null,
+        'worker1 did not exit normally. ' + `exited with signal ${signal}`
+      );
+    })
+  );
 } else {
   const net = require('net');
   const server = net.createServer();
-  server.listen(0, common.mustCall(() => {
-    if (cluster.worker.id === 2) {
-      server.close(() => {
-        server.listen(0, common.mustCall(() => {
-          server.close(() => {
-            process.disconnect();
-          });
-        }));
-      });
-    }
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      if (cluster.worker.id === 2) {
+        server.close(() => {
+          server.listen(
+            0,
+            common.mustCall(() => {
+              server.close(() => {
+                process.disconnect();
+              });
+            })
+          );
+        });
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-server-restart-rr.js b/test/parallel/test-cluster-server-restart-rr.js
index 63edaf9fac7b8d..f0151debfd01e7 100644
--- a/test/parallel/test-cluster-server-restart-rr.js
+++ b/test/parallel/test-cluster-server-restart-rr.js
@@ -7,47 +7,61 @@ cluster.schedulingPolicy = cluster.SCHED_RR;
 
 if (cluster.isMaster) {
   const worker1 = cluster.fork();
-  worker1.on('listening', common.mustCall(() => {
-    const worker2 = cluster.fork();
-    worker2.on('exit', (code, signal) => {
+  worker1.on(
+    'listening',
+    common.mustCall(() => {
+      const worker2 = cluster.fork();
+      worker2.on('exit', (code, signal) => {
+        assert.strictEqual(
+          code,
+          0,
+          `worker${worker2.id} did not exit normally. Exit with code: ${code}`
+        );
+        assert.strictEqual(
+          signal,
+          null,
+          `worker${
+            worker2.id
+          } did not exit normally. Exit with signal: ${signal}`
+        );
+        worker1.disconnect();
+      });
+    })
+  );
+
+  worker1.on(
+    'exit',
+    common.mustCall((code, signal) => {
       assert.strictEqual(
         code,
         0,
-        `worker${worker2.id} did not exit normally. Exit with code: ${code}`
+        `worker${worker1.id} did not exit normally. Exit with code: ${code}`
       );
       assert.strictEqual(
         signal,
         null,
-        `worker${worker2.id} did not exit normally. Exit with signal: ${signal}`
+        `worker${worker1.id} did not exit normally. Exit with code: ${signal}`
       );
-      worker1.disconnect();
-    });
-  }));
-
-  worker1.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(
-      code,
-      0,
-      `worker${worker1.id} did not exit normally. Exit with code: ${code}`
-    );
-    assert.strictEqual(
-      signal,
-      null,
-      `worker${worker1.id} did not exit normally. Exit with code: ${signal}`
-    );
-  }));
+    })
+  );
 } else {
   const net = require('net');
   const server = net.createServer();
-  server.listen(0, common.mustCall(() => {
-    if (cluster.worker.id === 2) {
-      server.close(() => {
-        server.listen(0, common.mustCall(() => {
-          server.close(() => {
-            process.disconnect();
-          });
-        }));
-      });
-    }
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      if (cluster.worker.id === 2) {
+        server.close(() => {
+          server.listen(
+            0,
+            common.mustCall(() => {
+              server.close(() => {
+                process.disconnect();
+              });
+            })
+          );
+        });
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-setup-master-argv.js b/test/parallel/test-cluster-setup-master-argv.js
index fa0779dca9a67d..41e94917f24eb8 100644
--- a/test/parallel/test-cluster-setup-master-argv.js
+++ b/test/parallel/test-cluster-setup-master-argv.js
@@ -26,12 +26,17 @@ const cluster = require('cluster');
 
 setTimeout(common.mustNotCall('setup not emitted'), 1000).unref();
 
-cluster.on('setup', common.mustCall(function() {
-  const clusterArgs = cluster.settings.args;
-  const realArgs = process.argv;
-  assert.strictEqual(clusterArgs[clusterArgs.length - 1],
-                     realArgs[realArgs.length - 1]);
-}));
+cluster.on(
+  'setup',
+  common.mustCall(function() {
+    const clusterArgs = cluster.settings.args;
+    const realArgs = process.argv;
+    assert.strictEqual(
+      clusterArgs[clusterArgs.length - 1],
+      realArgs[realArgs.length - 1]
+    );
+  })
+);
 
 assert.notStrictEqual(process.argv[process.argv.length - 1], 'OMG,OMG');
 process.argv.push('OMG,OMG');
diff --git a/test/parallel/test-cluster-setup-master-cumulative.js b/test/parallel/test-cluster-setup-master-cumulative.js
index 2621685e315bcc..01e80aeb608b0b 100644
--- a/test/parallel/test-cluster-setup-master-cumulative.js
+++ b/test/parallel/test-cluster-setup-master-cumulative.js
@@ -34,7 +34,7 @@ assert.deepStrictEqual(cluster.settings, {
   args: process.argv.slice(2),
   exec: process.argv[1],
   execArgv: process.execArgv,
-  silent: false,
+  silent: false
 });
 console.log('ok sets defaults');
 
@@ -57,6 +57,6 @@ assert.deepStrictEqual(cluster.settings, {
   args: ['foo', 'bar'],
   exec: 'overridden',
   execArgv: ['baz', 'bang'],
-  silent: false,
+  silent: false
 });
 console.log('ok preserves current settings');
diff --git a/test/parallel/test-cluster-setup-master-emit.js b/test/parallel/test-cluster-setup-master-emit.js
index d6643ef62a6700..acaa3213906ab6 100644
--- a/test/parallel/test-cluster-setup-master-emit.js
+++ b/test/parallel/test-cluster-setup-master-emit.js
@@ -27,21 +27,29 @@ const cluster = require('cluster');
 assert(cluster.isMaster);
 
 function emitAndCatch(next) {
-  cluster.once('setup', common.mustCall(function(settings) {
-    assert.strictEqual(settings.exec, 'new-exec');
-    setImmediate(next);
-  }));
+  cluster.once(
+    'setup',
+    common.mustCall(function(settings) {
+      assert.strictEqual(settings.exec, 'new-exec');
+      setImmediate(next);
+    })
+  );
   cluster.setupMaster({ exec: 'new-exec' });
 }
 
 function emitAndCatch2(next) {
-  cluster.once('setup', common.mustCall(function(settings) {
-    assert('exec' in settings);
-    setImmediate(next);
-  }));
+  cluster.once(
+    'setup',
+    common.mustCall(function(settings) {
+      assert('exec' in settings);
+      setImmediate(next);
+    })
+  );
   cluster.setupMaster();
 }
 
-emitAndCatch(common.mustCall(function() {
-  emitAndCatch2(common.mustCall());
-}));
+emitAndCatch(
+  common.mustCall(function() {
+    emitAndCatch2(common.mustCall());
+  })
+);
diff --git a/test/parallel/test-cluster-setup-master-multiple.js b/test/parallel/test-cluster-setup-master-multiple.js
index b33acccd411a0a..0d1eae633c0694 100644
--- a/test/parallel/test-cluster-setup-master-multiple.js
+++ b/test/parallel/test-cluster-setup-master-multiple.js
@@ -40,11 +40,7 @@ cluster.on('setup', () => {
   configs.push(cheapClone(cluster.settings));
 });
 
-const execs = [
-  'node-next',
-  'node-next-2',
-  'node-next-3',
-];
+const execs = ['node-next', 'node-next-2', 'node-next-3'];
 
 process.on('exit', () => {
   // Tests that "setup" is emitted for every call to setupMaster
diff --git a/test/parallel/test-cluster-setup-master.js b/test/parallel/test-cluster-setup-master.js
index 619a8439904d92..df7ec77683a989 100644
--- a/test/parallel/test-cluster-setup-master.js
+++ b/test/parallel/test-cluster-setup-master.js
@@ -25,12 +25,9 @@ const assert = require('assert');
 const cluster = require('cluster');
 
 if (cluster.isWorker) {
-
   // Just keep the worker alive
   process.send(process.argv[2]);
-
 } else if (cluster.isMaster) {
-
   const checks = {
     args: false,
     setupEvent: false,
@@ -50,27 +47,31 @@ if (cluster.isWorker) {
     checks.setupEvent = true;
 
     settings = cluster.settings;
-    if (settings &&
-        settings.args && settings.args[0] === 'custom argument' &&
-        settings.silent === true &&
-        settings.exec === process.argv[1]) {
+    if (
+      settings &&
+      settings.args &&
+      settings.args[0] === 'custom argument' &&
+      settings.silent === true &&
+      settings.exec === process.argv[1]
+    ) {
       checks.settingsObject = true;
     }
   });
 
   let correctInput = 0;
 
-  cluster.on('online', common.mustCall(function listener(worker) {
-
-    worker.once('message', function(data) {
-      correctInput += (data === 'custom argument' ? 1 : 0);
-      if (correctInput === totalWorkers) {
-        checks.args = true;
-      }
-      worker.kill();
-    });
-
-  }, totalWorkers));
+  cluster.on(
+    'online',
+    common.mustCall(function listener(worker) {
+      worker.once('message', function(data) {
+        correctInput += data === 'custom argument' ? 1 : 0;
+        if (correctInput === totalWorkers) {
+          checks.args = true;
+        }
+        worker.kill();
+      });
+    }, totalWorkers)
+  );
 
   // Start all workers
   cluster.fork();
@@ -78,16 +79,17 @@ if (cluster.isWorker) {
 
   // Check all values
   process.once('exit', function() {
-    const argsMsg = 'Arguments was not send for one or more worker. ' +
-                    `${correctInput} workers receive argument, ` +
-                    `but ${totalWorkers} were expected.`;
+    const argsMsg =
+      'Arguments was not send for one or more worker. ' +
+      `${correctInput} workers receive argument, ` +
+      `but ${totalWorkers} were expected.`;
     assert.ok(checks.args, argsMsg);
 
     assert.ok(checks.setupEvent, 'The setup event was never emitted');
 
-    const settingObjectMsg = 'The settingsObject do not have correct ' +
-                             `properties : ${JSON.stringify(settings)}`;
+    const settingObjectMsg =
+      'The settingsObject do not have correct ' +
+      `properties : ${JSON.stringify(settings)}`;
     assert.ok(checks.settingsObject, settingObjectMsg);
   });
-
 }
diff --git a/test/parallel/test-cluster-shared-handle-bind-error.js b/test/parallel/test-cluster-shared-handle-bind-error.js
index 1ce7a573cf6477..223b1a2ec88f5a 100644
--- a/test/parallel/test-cluster-shared-handle-bind-error.js
+++ b/test/parallel/test-cluster-shared-handle-bind-error.js
@@ -31,19 +31,28 @@ if (cluster.isMaster) {
   // Hog the TCP port so that when the worker tries to bind, it'll fail.
   const server = net.createServer(common.mustNotCall());
 
-  server.listen(0, common.mustCall(() => {
-    const worker = cluster.fork({ PORT: server.address().port });
-    worker.on('exit', common.mustCall((exitCode) => {
-      assert.strictEqual(exitCode, 0);
-      server.close();
-    }));
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const worker = cluster.fork({ PORT: server.address().port });
+      worker.on(
+        'exit',
+        common.mustCall((exitCode) => {
+          assert.strictEqual(exitCode, 0);
+          server.close();
+        })
+      );
+    })
+  );
 } else {
   assert(process.env.PORT);
   const s = net.createServer(common.mustNotCall());
   s.listen(process.env.PORT, common.mustNotCall('listen should have failed'));
-  s.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.code, 'EADDRINUSE');
-    process.disconnect();
-  }));
+  s.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.code, 'EADDRINUSE');
+      process.disconnect();
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-shared-handle-bind-privileged-port.js b/test/parallel/test-cluster-shared-handle-bind-privileged-port.js
index 1edece30af6de9..ae9b674113e5cf 100644
--- a/test/parallel/test-cluster-shared-handle-bind-privileged-port.js
+++ b/test/parallel/test-cluster-shared-handle-bind-privileged-port.js
@@ -23,11 +23,9 @@
 const common = require('../common');
 
 // Skip on OS X Mojave. https://github.com/nodejs/node/issues/21679
-if (common.isOSXMojave)
-  common.skip('bypass test for Mojave due to OSX issue');
+if (common.isOSXMojave) common.skip('bypass test for Mojave due to OSX issue');
 
-if (common.isWindows)
-  common.skip('not reliable on Windows');
+if (common.isWindows) common.skip('not reliable on Windows');
 
 if (process.getuid() === 0)
   common.skip('as this test should not be run as `root`');
@@ -39,14 +37,20 @@ const net = require('net');
 if (cluster.isMaster) {
   // Master opens and binds the socket and shares it with the worker.
   cluster.schedulingPolicy = cluster.SCHED_NONE;
-  cluster.fork().on('exit', common.mustCall(function(exitCode) {
-    assert.strictEqual(exitCode, 0);
-  }));
+  cluster.fork().on(
+    'exit',
+    common.mustCall(function(exitCode) {
+      assert.strictEqual(exitCode, 0);
+    })
+  );
 } else {
   const s = net.createServer(common.mustNotCall());
   s.listen(42, common.mustNotCall('listen should have failed'));
-  s.on('error', common.mustCall(function(err) {
-    assert.strictEqual(err.code, 'EACCES');
-    process.disconnect();
-  }));
+  s.on(
+    'error',
+    common.mustCall(function(err) {
+      assert.strictEqual(err.code, 'EACCES');
+      process.disconnect();
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-shared-leak.js b/test/parallel/test-cluster-shared-leak.js
index a7b3023f3ed3ba..d2e8f7be1815a4 100644
--- a/test/parallel/test-cluster-shared-leak.js
+++ b/test/parallel/test-cluster-shared-leak.js
@@ -13,27 +13,31 @@ if (cluster.isMaster) {
   let conn, worker2;
 
   const worker1 = cluster.fork();
-  worker1.on('listening', common.mustCall(function(address) {
-    worker2 = cluster.fork();
-    worker2.on('online', function() {
-      conn = net.connect(address.port, common.mustCall(function() {
-        worker1.disconnect();
-        worker2.disconnect();
-      }));
-      conn.on('error', function(e) {
-        // ECONNRESET is OK
-        if (e.code !== 'ECONNRESET')
-          throw e;
+  worker1.on(
+    'listening',
+    common.mustCall(function(address) {
+      worker2 = cluster.fork();
+      worker2.on('online', function() {
+        conn = net.connect(
+          address.port,
+          common.mustCall(function() {
+            worker1.disconnect();
+            worker2.disconnect();
+          })
+        );
+        conn.on('error', function(e) {
+          // ECONNRESET is OK
+          if (e.code !== 'ECONNRESET') throw e;
+        });
       });
-    });
-  }));
+    })
+  );
 
   cluster.on('exit', function(worker, exitCode, signalCode) {
     assert(worker === worker1 || worker === worker2);
     assert.strictEqual(exitCode, 0);
     assert.strictEqual(signalCode, null);
-    if (Object.keys(cluster.workers).length === 0)
-      conn.destroy();
+    if (Object.keys(cluster.workers).length === 0) conn.destroy();
   });
 
   return;
@@ -42,8 +46,7 @@ if (cluster.isMaster) {
 const server = net.createServer(function(c) {
   c.on('error', function(e) {
     // ECONNRESET is OK, so we don't exit with code !== 0
-    if (e.code !== 'ECONNRESET')
-      throw e;
+    if (e.code !== 'ECONNRESET') throw e;
   });
   c.end('bye');
 });
diff --git a/test/parallel/test-cluster-uncaught-exception.js b/test/parallel/test-cluster-uncaught-exception.js
index 3d31fece668501..26cc96d4bc94f3 100644
--- a/test/parallel/test-cluster-uncaught-exception.js
+++ b/test/parallel/test-cluster-uncaught-exception.js
@@ -35,15 +35,22 @@ const isTestRunner = process.argv[2] !== 'child';
 
 if (isTestRunner) {
   const master = fork(__filename, ['child']);
-  master.on('exit', common.mustCall((code) => {
-    assert.strictEqual(code, MAGIC_EXIT_CODE);
-  }));
+  master.on(
+    'exit',
+    common.mustCall((code) => {
+      assert.strictEqual(code, MAGIC_EXIT_CODE);
+    })
+  );
 } else if (cluster.isMaster) {
-  process.on('uncaughtException', common.mustCall(() => {
-    process.nextTick(() => process.exit(MAGIC_EXIT_CODE));
-  }));
+  process.on(
+    'uncaughtException',
+    common.mustCall(() => {
+      process.nextTick(() => process.exit(MAGIC_EXIT_CODE));
+    })
+  );
   cluster.fork();
   throw new Error('kill master');
-} else { // worker
+} else {
+  // worker
   process.exit();
 }
diff --git a/test/parallel/test-cluster-worker-death.js b/test/parallel/test-cluster-worker-death.js
index 0a7b081c117a85..3b9237f183be5a 100644
--- a/test/parallel/test-cluster-worker-death.js
+++ b/test/parallel/test-cluster-worker-death.js
@@ -28,11 +28,17 @@ if (!cluster.isMaster) {
   process.exit(42);
 } else {
   const worker = cluster.fork();
-  worker.on('exit', common.mustCall(function(exitCode, signalCode) {
-    assert.strictEqual(exitCode, 42);
-    assert.strictEqual(signalCode, null);
-  }));
-  cluster.on('exit', common.mustCall(function(worker_) {
-    assert.strictEqual(worker_, worker);
-  }));
+  worker.on(
+    'exit',
+    common.mustCall(function(exitCode, signalCode) {
+      assert.strictEqual(exitCode, 42);
+      assert.strictEqual(signalCode, null);
+    })
+  );
+  cluster.on(
+    'exit',
+    common.mustCall(function(worker_) {
+      assert.strictEqual(worker_, worker);
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-worker-disconnect-on-error.js b/test/parallel/test-cluster-worker-disconnect-on-error.js
index c55e69e256950f..fefc55ccf25c6c 100644
--- a/test/parallel/test-cluster-worker-disconnect-on-error.js
+++ b/test/parallel/test-cluster-worker-disconnect-on-error.js
@@ -10,24 +10,36 @@ const server = http.createServer();
 if (cluster.isMaster) {
   let worker;
 
-  server.listen(0, common.mustCall((error) => {
-    assert.ifError(error);
-    assert(worker);
+  server.listen(
+    0,
+    common.mustCall((error) => {
+      assert.ifError(error);
+      assert(worker);
 
-    worker.send({ port: server.address().port });
-  }));
+      worker.send({ port: server.address().port });
+    })
+  );
 
   worker = cluster.fork();
-  worker.on('exit', common.mustCall(() => {
-    server.close();
-  }));
+  worker.on(
+    'exit',
+    common.mustCall(() => {
+      server.close();
+    })
+  );
 } else {
-  process.on('message', common.mustCall((msg) => {
-    assert(msg.port);
+  process.on(
+    'message',
+    common.mustCall((msg) => {
+      assert(msg.port);
 
-    server.listen(msg.port);
-    server.on('error', common.mustCall((e) => {
-      cluster.worker.disconnect();
-    }));
-  }));
+      server.listen(msg.port);
+      server.on(
+        'error',
+        common.mustCall((e) => {
+          cluster.worker.disconnect();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-cluster-worker-disconnect.js b/test/parallel/test-cluster-worker-disconnect.js
index 71c151410cdb2c..596a9e5d3c0888 100644
--- a/test/parallel/test-cluster-worker-disconnect.js
+++ b/test/parallel/test-cluster-worker-disconnect.js
@@ -26,16 +26,15 @@ const cluster = require('cluster');
 
 if (cluster.isWorker) {
   const http = require('http');
-  http.Server(() => {
-
-  }).listen(0, '127.0.0.1');
-
-  cluster.worker.on('disconnect', common.mustCall(() => {
-    process.exit(42);
-  }));
-
+  http.Server(() => {}).listen(0, '127.0.0.1');
+
+  cluster.worker.on(
+    'disconnect',
+    common.mustCall(() => {
+      process.exit(42);
+    })
+  );
 } else if (cluster.isMaster) {
-
   const checks = {
     cluster: {
       emitDisconnect: false,
@@ -56,42 +55,58 @@ if (cluster.isWorker) {
   const worker = cluster.fork();
 
   // Disconnect worker when it is ready
-  worker.once('listening', common.mustCall(() => {
-    const w = worker.disconnect();
-    assert.strictEqual(worker, w, `${worker.id} did not return a reference`);
-  }));
+  worker.once(
+    'listening',
+    common.mustCall(() => {
+      const w = worker.disconnect();
+      assert.strictEqual(worker, w, `${worker.id} did not return a reference`);
+    })
+  );
 
   // Check cluster events
-  cluster.once('disconnect', common.mustCall(() => {
-    checks.cluster.emitDisconnect = true;
-  }));
-  cluster.once('exit', common.mustCall(() => {
-    checks.cluster.emitExit = true;
-  }));
+  cluster.once(
+    'disconnect',
+    common.mustCall(() => {
+      checks.cluster.emitDisconnect = true;
+    })
+  );
+  cluster.once(
+    'exit',
+    common.mustCall(() => {
+      checks.cluster.emitExit = true;
+    })
+  );
 
   // Check worker events and properties
-  worker.once('disconnect', common.mustCall(() => {
-    checks.worker.emitDisconnect = true;
-    checks.worker.voluntaryMode = worker.exitedAfterDisconnect;
-    checks.worker.state = worker.state;
-  }));
+  worker.once(
+    'disconnect',
+    common.mustCall(() => {
+      checks.worker.emitDisconnect = true;
+      checks.worker.voluntaryMode = worker.exitedAfterDisconnect;
+      checks.worker.state = worker.state;
+    })
+  );
 
   // Check that the worker died
-  worker.once('exit', common.mustCall((code) => {
-    checks.worker.emitExit = true;
-    checks.worker.died = !common.isAlive(worker.process.pid);
-    checks.worker.emitDisconnectInsideWorker = code === 42;
-  }));
+  worker.once(
+    'exit',
+    common.mustCall((code) => {
+      checks.worker.emitExit = true;
+      checks.worker.died = !common.isAlive(worker.process.pid);
+      checks.worker.emitDisconnectInsideWorker = code === 42;
+    })
+  );
 
   process.once('exit', () => {
-
     const w = checks.worker;
     const c = checks.cluster;
 
     // events
     assert.ok(w.emitDisconnect, 'Disconnect event did not emit');
-    assert.ok(w.emitDisconnectInsideWorker,
-              'Disconnect event did not emit inside worker');
+    assert.ok(
+      w.emitDisconnectInsideWorker,
+      'Disconnect event did not emit inside worker'
+    );
     assert.ok(c.emitDisconnect, 'Disconnect event did not emit');
     assert.ok(w.emitExit, 'Exit event did not emit');
     assert.ok(c.emitExit, 'Exit event did not emit');
diff --git a/test/parallel/test-cluster-worker-events.js b/test/parallel/test-cluster-worker-events.js
index 3b156addedc63f..ec3a5a99ad2f04 100644
--- a/test/parallel/test-cluster-worker-events.js
+++ b/test/parallel/test-cluster-worker-events.js
@@ -27,7 +27,6 @@ const cluster = require('cluster');
 const OK = 2;
 
 if (cluster.isMaster) {
-
   const worker = cluster.fork();
 
   worker.on('exit', (code) => {
diff --git a/test/parallel/test-cluster-worker-exit.js b/test/parallel/test-cluster-worker-exit.js
index ba9c4f8775760e..6bf54bc42a1a65 100644
--- a/test/parallel/test-cluster-worker-exit.js
+++ b/test/parallel/test-cluster-worker-exit.js
@@ -35,15 +35,16 @@ const EXIT_CODE = 42;
 
 if (cluster.isWorker) {
   const http = require('http');
-  const server = http.Server(() => { });
-
-  server.once('listening', common.mustCall(() => {
-    process.exit(EXIT_CODE);
-  }));
+  const server = http.Server(() => {});
+
+  server.once(
+    'listening',
+    common.mustCall(() => {
+      process.exit(EXIT_CODE);
+    })
+  );
   server.listen(0, '127.0.0.1');
-
 } else if (cluster.isMaster) {
-
   const expected_results = {
     cluster_emitDisconnect: [1, "the cluster did not emit 'disconnect'"],
     cluster_emitExit: [1, "the cluster did not emit 'exit'"],
@@ -53,7 +54,8 @@ if (cluster.isWorker) {
     worker_emitExit: [1, "the worker did not emit 'exit'"],
     worker_state: ['disconnected', 'the worker state is incorrect'],
     worker_exitedAfterDisconnect: [
-      false, 'the .exitedAfterDisconnect flag is incorrect'
+      false,
+      'the .exitedAfterDisconnect flag is incorrect'
     ],
     worker_died: [true, 'the worker is still running'],
     worker_exitCode: [EXIT_CODE, 'the worker exited w/ incorrect exitCode'],
@@ -66,40 +68,51 @@ if (cluster.isWorker) {
     worker_emitExit: 0
   };
 
-
   // start worker
   const worker = cluster.fork();
 
   // Check cluster events
-  cluster.on('disconnect', common.mustCall(() => {
-    results.cluster_emitDisconnect += 1;
-  }));
-  cluster.on('exit', common.mustCall((worker) => {
-    results.cluster_exitCode = worker.process.exitCode;
-    results.cluster_signalCode = worker.process.signalCode;
-    results.cluster_emitExit += 1;
-  }));
+  cluster.on(
+    'disconnect',
+    common.mustCall(() => {
+      results.cluster_emitDisconnect += 1;
+    })
+  );
+  cluster.on(
+    'exit',
+    common.mustCall((worker) => {
+      results.cluster_exitCode = worker.process.exitCode;
+      results.cluster_signalCode = worker.process.signalCode;
+      results.cluster_emitExit += 1;
+    })
+  );
 
   // Check worker events and properties
-  worker.on('disconnect', common.mustCall(() => {
-    results.worker_emitDisconnect += 1;
-    results.worker_exitedAfterDisconnect = worker.exitedAfterDisconnect;
-    results.worker_state = worker.state;
-    if (results.worker_emitExit > 0) {
-      process.nextTick(() => finish_test());
-    }
-  }));
+  worker.on(
+    'disconnect',
+    common.mustCall(() => {
+      results.worker_emitDisconnect += 1;
+      results.worker_exitedAfterDisconnect = worker.exitedAfterDisconnect;
+      results.worker_state = worker.state;
+      if (results.worker_emitExit > 0) {
+        process.nextTick(() => finish_test());
+      }
+    })
+  );
 
   // Check that the worker died
-  worker.once('exit', common.mustCall((exitCode, signalCode) => {
-    results.worker_exitCode = exitCode;
-    results.worker_signalCode = signalCode;
-    results.worker_emitExit += 1;
-    results.worker_died = !common.isAlive(worker.process.pid);
-    if (results.worker_emitDisconnect > 0) {
-      process.nextTick(() => finish_test());
-    }
-  }));
+  worker.once(
+    'exit',
+    common.mustCall((exitCode, signalCode) => {
+      results.worker_exitCode = exitCode;
+      results.worker_signalCode = signalCode;
+      results.worker_emitExit += 1;
+      results.worker_died = !common.isAlive(worker.process.pid);
+      if (results.worker_emitDisconnect > 0) {
+        process.nextTick(() => finish_test());
+      }
+    })
+  );
 
   const finish_test = () => {
     try {
@@ -124,7 +137,9 @@ function checkResults(expected_results, results) {
     const expected = expected_results[k];
 
     assert.strictEqual(
-      actual, expected && expected.length ? expected[0] : expected,
-      `${expected[1] || ''} [expected: ${expected[0]} / actual: ${actual}]`);
+      actual,
+      expected && expected.length ? expected[0] : expected,
+      `${expected[1] || ''} [expected: ${expected[0]} / actual: ${actual}]`
+    );
   }
 }
diff --git a/test/parallel/test-cluster-worker-forced-exit.js b/test/parallel/test-cluster-worker-forced-exit.js
index cc76b4ba3aff3a..2bd6ab01132135 100644
--- a/test/parallel/test-cluster-worker-forced-exit.js
+++ b/test/parallel/test-cluster-worker-forced-exit.js
@@ -48,11 +48,12 @@ checkForced();
 
 function checkUnforced() {
   const worker = cluster.fork();
-  worker
-    .on('online', common.mustCall(() => worker.disconnect()))
-    .on('exit', common.mustCall((status) => {
+  worker.on('online', common.mustCall(() => worker.disconnect())).on(
+    'exit',
+    common.mustCall((status) => {
       assert.strictEqual(status, SENTINEL);
-    }));
+    })
+  );
 }
 
 function checkForced() {
diff --git a/test/parallel/test-cluster-worker-init.js b/test/parallel/test-cluster-worker-init.js
index 47a884c1cdcc22..2f81c63e4cd32d 100644
--- a/test/parallel/test-cluster-worker-init.js
+++ b/test/parallel/test-cluster-worker-init.js
@@ -32,11 +32,14 @@ const msg = 'foo';
 if (cluster.isMaster) {
   const worker = cluster.fork();
 
-  worker.on('message', common.mustCall((message) => {
-    assert.strictEqual(message, true);
-    const w = worker.disconnect();
-    assert.strictEqual(worker, w);
-  }));
+  worker.on(
+    'message',
+    common.mustCall((message) => {
+      assert.strictEqual(message, true);
+      const w = worker.disconnect();
+      assert.strictEqual(worker, w);
+    })
+  );
 
   worker.on('online', () => {
     worker.send(msg);
diff --git a/test/parallel/test-cluster-worker-isconnected.js b/test/parallel/test-cluster-worker-isconnected.js
index a0ada77bd023b1..e580ab7679cc4a 100644
--- a/test/parallel/test-cluster-worker-isconnected.js
+++ b/test/parallel/test-cluster-worker-isconnected.js
@@ -8,9 +8,12 @@ if (cluster.isMaster) {
 
   assert.strictEqual(worker.isConnected(), true);
 
-  worker.on('disconnect', common.mustCall(() => {
-    assert.strictEqual(worker.isConnected(), false);
-  }));
+  worker.on(
+    'disconnect',
+    common.mustCall(() => {
+      assert.strictEqual(worker.isConnected(), false);
+    })
+  );
 
   worker.on('message', function(msg) {
     if (msg === 'readyToDisconnect') {
diff --git a/test/parallel/test-cluster-worker-isdead.js b/test/parallel/test-cluster-worker-isdead.js
index 15567b929a59e6..0f032ac9ca5881 100644
--- a/test/parallel/test-cluster-worker-isdead.js
+++ b/test/parallel/test-cluster-worker-isdead.js
@@ -6,15 +6,19 @@ const assert = require('assert');
 if (cluster.isMaster) {
   const worker = cluster.fork();
   let workerDead = worker.isDead();
-  assert.ok(!workerDead,
-            `isDead() returned ${workerDead}. isDead() should return ` +
-            'false right after the worker has been created.');
+  assert.ok(
+    !workerDead,
+    `isDead() returned ${workerDead}. isDead() should return ` +
+      'false right after the worker has been created.'
+  );
 
   worker.on('exit', function() {
     workerDead = worker.isDead();
-    assert.ok(workerDead,
-              `isDead() returned ${workerDead}. After an event has been ` +
-              'emitted, isDead should return true');
+    assert.ok(
+      workerDead,
+      `isDead() returned ${workerDead}. After an event has been ` +
+        'emitted, isDead should return true'
+    );
   });
 
   worker.on('message', function(msg) {
@@ -22,11 +26,12 @@ if (cluster.isMaster) {
       worker.kill();
     }
   });
-
 } else if (cluster.isWorker) {
   const workerDead = cluster.worker.isDead();
-  assert.ok(!workerDead,
-            `isDead() returned ${workerDead}. isDead() should return ` +
-            'false when called from within a worker');
+  assert.ok(
+    !workerDead,
+    `isDead() returned ${workerDead}. isDead() should return ` +
+      'false when called from within a worker'
+  );
   process.send('readyToDie');
 }
diff --git a/test/parallel/test-cluster-worker-kill.js b/test/parallel/test-cluster-worker-kill.js
index bb2d3495d95a4d..4caca8cb85dc7e 100644
--- a/test/parallel/test-cluster-worker-kill.js
+++ b/test/parallel/test-cluster-worker-kill.js
@@ -33,28 +33,30 @@ const cluster = require('cluster');
 
 if (cluster.isWorker) {
   const http = require('http');
-  const server = http.Server(() => { });
+  const server = http.Server(() => {});
 
-  server.once('listening', common.mustCall(() => { }));
+  server.once('listening', common.mustCall(() => {}));
   server.listen(0, '127.0.0.1');
-
 } else if (cluster.isMaster) {
-
   const KILL_SIGNAL = 'SIGKILL';
   const expected_results = {
     cluster_emitDisconnect: [1, "the cluster did not emit 'disconnect'"],
     cluster_emitExit: [1, "the cluster did not emit 'exit'"],
     cluster_exitCode: [null, 'the cluster exited w/ incorrect exitCode'],
-    cluster_signalCode: [KILL_SIGNAL,
-                         'the cluster exited w/ incorrect signalCode'],
+    cluster_signalCode: [
+      KILL_SIGNAL,
+      'the cluster exited w/ incorrect signalCode'
+    ],
     worker_emitDisconnect: [1, "the worker did not emit 'disconnect'"],
     worker_emitExit: [1, "the worker did not emit 'exit'"],
     worker_state: ['disconnected', 'the worker state is incorrect'],
     worker_exitedAfter: [false, 'the .exitedAfterDisconnect flag is incorrect'],
     worker_died: [true, 'the worker is still running'],
     worker_exitCode: [null, 'the worker exited w/ incorrect exitCode'],
-    worker_signalCode: [KILL_SIGNAL,
-                        'the worker exited w/ incorrect signalCode']
+    worker_signalCode: [
+      KILL_SIGNAL,
+      'the worker exited w/ incorrect signalCode'
+    ]
   };
   const results = {
     cluster_emitDisconnect: 0,
@@ -63,40 +65,53 @@ if (cluster.isWorker) {
     worker_emitExit: 0
   };
 
-
   // start worker
   const worker = cluster.fork();
 
   // when the worker is up and running, kill it
-  worker.once('listening', common.mustCall(() => {
-    worker.process.kill(KILL_SIGNAL);
-  }));
-
+  worker.once(
+    'listening',
+    common.mustCall(() => {
+      worker.process.kill(KILL_SIGNAL);
+    })
+  );
 
   // Check cluster events
-  cluster.on('disconnect', common.mustCall(() => {
-    results.cluster_emitDisconnect += 1;
-  }));
-  cluster.on('exit', common.mustCall((worker) => {
-    results.cluster_exitCode = worker.process.exitCode;
-    results.cluster_signalCode = worker.process.signalCode;
-    results.cluster_emitExit += 1;
-  }));
+  cluster.on(
+    'disconnect',
+    common.mustCall(() => {
+      results.cluster_emitDisconnect += 1;
+    })
+  );
+  cluster.on(
+    'exit',
+    common.mustCall((worker) => {
+      results.cluster_exitCode = worker.process.exitCode;
+      results.cluster_signalCode = worker.process.signalCode;
+      results.cluster_emitExit += 1;
+    })
+  );
 
   // Check worker events and properties
-  worker.on('disconnect', common.mustCall(() => {
-    results.worker_emitDisconnect += 1;
-    results.worker_exitedAfter = worker.exitedAfterDisconnect;
-    results.worker_state = worker.state;
-  }));
+  worker.on(
+    'disconnect',
+    common.mustCall(() => {
+      results.worker_emitDisconnect += 1;
+      results.worker_exitedAfter = worker.exitedAfterDisconnect;
+      results.worker_state = worker.state;
+    })
+  );
 
   // Check that the worker died
-  worker.once('exit', common.mustCall((exitCode, signalCode) => {
-    results.worker_exitCode = exitCode;
-    results.worker_signalCode = signalCode;
-    results.worker_emitExit += 1;
-    results.worker_died = !common.isAlive(worker.process.pid);
-  }));
+  worker.once(
+    'exit',
+    common.mustCall((exitCode, signalCode) => {
+      results.worker_exitCode = exitCode;
+      results.worker_signalCode = signalCode;
+      results.worker_emitExit += 1;
+      results.worker_died = !common.isAlive(worker.process.pid);
+    })
+  );
 
   process.on('exit', () => {
     checkResults(expected_results, results);
@@ -111,7 +126,9 @@ function checkResults(expected_results, results) {
     const expected = expected_results[k];
 
     assert.strictEqual(
-      actual, expected && expected.length ? expected[0] : expected,
-      `${expected[1] || ''} [expected: ${expected[0]} / actual: ${actual}]`);
+      actual,
+      expected && expected.length ? expected[0] : expected,
+      `${expected[1] || ''} [expected: ${expected[0]} / actual: ${actual}]`
+    );
   }
 }
diff --git a/test/parallel/test-cluster-worker-no-exit.js b/test/parallel/test-cluster-worker-no-exit.js
index b87b58b3f8b74a..8d2c0002717635 100644
--- a/test/parallel/test-cluster-worker-no-exit.js
+++ b/test/parallel/test-cluster-worker-no-exit.js
@@ -41,28 +41,30 @@ let server;
 // 4 destroy connection
 // 5 confirm it does exit
 if (cluster.isMaster) {
-  server = net.createServer(function(conn) {
-    server.close();
-    worker.disconnect();
-    worker.once('disconnect', function() {
-      setTimeout(function() {
-        conn.destroy();
-        destroyed = true;
-      }, 1000);
-    }).once('exit', function() {
-      // worker should not exit while it has a connection
-      assert(destroyed, 'worker exited before connection destroyed');
-      success = true;
-    });
-
-  }).listen(0, function() {
-    const port = this.address().port;
+  server = net
+    .createServer(function(conn) {
+      server.close();
+      worker.disconnect();
+      worker
+        .once('disconnect', function() {
+          setTimeout(function() {
+            conn.destroy();
+            destroyed = true;
+          }, 1000);
+        })
+        .once('exit', function() {
+          // worker should not exit while it has a connection
+          assert(destroyed, 'worker exited before connection destroyed');
+          success = true;
+        });
+    })
+    .listen(0, function() {
+      const port = this.address().port;
 
-    worker = cluster.fork()
-      .on('online', function() {
+      worker = cluster.fork().on('online', function() {
         this.send({ port });
       });
-  });
+    });
   process.on('exit', function() {
     assert(success);
   });
diff --git a/test/parallel/test-cluster-worker-wait-server-close.js b/test/parallel/test-cluster-worker-wait-server-close.js
index b8183afb06ae18..8aced4d050a55d 100644
--- a/test/parallel/test-cluster-worker-wait-server-close.js
+++ b/test/parallel/test-cluster-worker-wait-server-close.js
@@ -8,11 +8,13 @@ const net = require('net');
 let serverClosed = false;
 
 if (cluster.isWorker) {
-  const server = net.createServer(function(socket) {
-    // Wait for any data, then close connection
-    socket.write('.');
-    socket.on('data', () => {});
-  }).listen(0, common.localhostIPv4);
+  const server = net
+    .createServer(function(socket) {
+      // Wait for any data, then close connection
+      socket.write('.');
+      socket.on('data', () => {});
+    })
+    .listen(0, common.localhostIPv4);
 
   server.once('close', function() {
     serverClosed = true;
diff --git a/test/parallel/test-common-countdown.js b/test/parallel/test-common-countdown.js
index 6a1a2f1bbce98a..daac70995c2aa5 100644
--- a/test/parallel/test-common-countdown.js
+++ b/test/parallel/test-common-countdown.js
@@ -7,7 +7,7 @@ const fixtures = require('../common/fixtures');
 const { execFile } = require('child_process');
 
 let done = '';
-const countdown = new Countdown(2, () => done = true);
+const countdown = new Countdown(2, () => (done = true));
 assert.strictEqual(countdown.remaining, 2);
 countdown.dec();
 assert.strictEqual(countdown.remaining, 1);
@@ -18,16 +18,20 @@ assert.strictEqual(done, true);
 const failFixtures = [
   [
     fixtures.path('failcounter.js'),
-    'Mismatched <anonymous> function calls. Expected exactly 1, actual 0.',
+    'Mismatched <anonymous> function calls. Expected exactly 1, actual 0.'
   ]
 ];
 
 for (const p of failFixtures) {
   const [file, expected] = p;
-  execFile(process.argv[0], [file], common.mustCall((ex, stdout, stderr) => {
-    assert.ok(ex);
-    assert.strictEqual(stderr, '');
-    const firstLine = stdout.split('\n').shift();
-    assert.strictEqual(firstLine, expected);
-  }));
+  execFile(
+    process.argv[0],
+    [file],
+    common.mustCall((ex, stdout, stderr) => {
+      assert.ok(ex);
+      assert.strictEqual(stderr, '');
+      const firstLine = stdout.split('\n').shift();
+      assert.strictEqual(firstLine, expected);
+    })
+  );
 }
diff --git a/test/parallel/test-common-must-not-call.js b/test/parallel/test-common-must-not-call.js
index d70daabf0a4bd0..7788ba4020d761 100644
--- a/test/parallel/test-common-must-not-call.js
+++ b/test/parallel/test-common-must-not-call.js
@@ -13,8 +13,7 @@ const validateError = common.mustCall((e) => {
   if (process.platform === 'win32') {
     e.message = e.message.substring(2); // remove 'C:'
   }
-  const [ fileName, lineNumber ] = e.message
-                                    .substring(prefix.length).split(':');
+  const [fileName, lineNumber] = e.message.substring(prefix.length).split(':');
   assert.strictEqual(path.basename(fileName), 'test-common-must-not-call.js');
   assert.strictEqual(lineNumber, '8');
 });
diff --git a/test/parallel/test-common.js b/test/parallel/test-common.js
index a133204437facb..4b3d2ac8a4d773 100644
--- a/test/parallel/test-common.js
+++ b/test/parallel/test-common.js
@@ -29,10 +29,16 @@ const { execFile } = require('child_process');
 // test for leaked global detection
 {
   const p = fixtures.path('leakedGlobal.js');
-  execFile(process.execPath, [p], common.mustCall((err, stdout, stderr) => {
-    assert.notStrictEqual(err.code, 0);
-    assert.ok(/\bAssertionError\b.*\bUnexpected global\b.*\bgc\b/.test(stderr));
-  }));
+  execFile(
+    process.execPath,
+    [p],
+    common.mustCall((err, stdout, stderr) => {
+      assert.notStrictEqual(err.code, 0);
+      assert.ok(
+        /\bAssertionError\b.*\bUnexpected global\b.*\bgc\b/.test(stderr)
+      );
+    })
+  );
 }
 
 // common.mustCall() tests
@@ -50,11 +56,14 @@ assert.throws(function() {
 
 // assert.fail() tests
 common.expectsError(
-  () => { assert.fail('fhqwhgads'); },
+  () => {
+    assert.fail('fhqwhgads');
+  },
   {
     code: 'ERR_ASSERTION',
     message: /^fhqwhgads$/
-  });
+  }
+);
 
 const fnOnce = common.mustCall(() => {});
 fnOnce();
@@ -78,30 +87,37 @@ const failFixtures = [
   [
     fixtures.path('failmustcall1.js'),
     'Mismatched <anonymous> function calls. Expected exactly 2, actual 1.'
-  ], [
+  ],
+  [
     fixtures.path('failmustcall2.js'),
     'Mismatched <anonymous> function calls. Expected at least 2, actual 1.'
   ]
 ];
 for (const p of failFixtures) {
   const [file, expected] = p;
-  execFile(process.execPath, [file], common.mustCall((err, stdout, stderr) => {
-    assert.ok(err);
-    assert.strictEqual(stderr, '');
-    const firstLine = stdout.split('\n').shift();
-    assert.strictEqual(firstLine, expected);
-  }));
+  execFile(
+    process.execPath,
+    [file],
+    common.mustCall((err, stdout, stderr) => {
+      assert.ok(err);
+      assert.strictEqual(stderr, '');
+      const firstLine = stdout.split('\n').shift();
+      assert.strictEqual(firstLine, expected);
+    })
+  );
 }
 
 // hijackStderr and hijackStdout
-const HIJACK_TEST_ARRAY = [ 'foo\n', 'bar\n', 'baz\n' ];
-[ 'err', 'out' ].forEach((txt) => {
+const HIJACK_TEST_ARRAY = ['foo\n', 'bar\n', 'baz\n'];
+['err', 'out'].forEach((txt) => {
   const stream = process[`std${txt}`];
   const originalWrite = stream.write;
 
-  hijackstdio[`hijackStd${txt}`](common.mustCall(function(data) {
-    assert.strictEqual(data, HIJACK_TEST_ARRAY[stream.writeTimes]);
-  }, HIJACK_TEST_ARRAY.length));
+  hijackstdio[`hijackStd${txt}`](
+    common.mustCall(function(data) {
+      assert.strictEqual(data, HIJACK_TEST_ARRAY[stream.writeTimes]);
+    }, HIJACK_TEST_ARRAY.length)
+  );
   assert.notStrictEqual(originalWrite, stream.write);
 
   HIJACK_TEST_ARRAY.forEach((val) => {
@@ -115,23 +131,29 @@ const HIJACK_TEST_ARRAY = [ 'foo\n', 'bar\n', 'baz\n' ];
 
 // hijackStderr and hijackStdout again
 // for console
-[[ 'err', 'error' ], [ 'out', 'log' ]].forEach(([ type, method ]) => {
-  hijackstdio[`hijackStd${type}`](common.mustCall(function(data) {
-    assert.strictEqual(data, 'test\n');
+[['err', 'error'], ['out', 'log']].forEach(([type, method]) => {
+  hijackstdio[`hijackStd${type}`](
+    common.mustCall(function(data) {
+      assert.strictEqual(data, 'test\n');
 
-    // throw an error
-    throw new Error(`console ${type} error`);
-  }));
+      // throw an error
+      throw new Error(`console ${type} error`);
+    })
+  );
 
   console[method]('test');
   hijackstdio[`restoreStd${type}`]();
 });
 
 let uncaughtTimes = 0;
-process.on('uncaughtException', common.mustCallAtLeast(function(e) {
-  assert.strictEqual(uncaughtTimes < 2, true);
-  assert.strictEqual(e instanceof Error, true);
-  assert.strictEqual(
-    e.message,
-    `console ${([ 'err', 'out' ])[uncaughtTimes++]} error`);
-}, 2));
+process.on(
+  'uncaughtException',
+  common.mustCallAtLeast(function(e) {
+    assert.strictEqual(uncaughtTimes < 2, true);
+    assert.strictEqual(e instanceof Error, true);
+    assert.strictEqual(
+      e.message,
+      `console ${['err', 'out'][uncaughtTimes++]} error`
+    );
+  }, 2)
+);
diff --git a/test/parallel/test-console-assign-undefined.js b/test/parallel/test-console-assign-undefined.js
index 1021307b3c5f22..c3bf2e95baaffd 100644
--- a/test/parallel/test-console-assign-undefined.js
+++ b/test/parallel/test-console-assign-undefined.js
@@ -14,10 +14,7 @@ const assert = require('assert');
 assert.strictEqual(global.console, 42);
 assert.strictEqual(global.console, 42);
 
-assert.throws(
-  () => console.log('foo'),
-  { name: 'TypeError' }
-);
+assert.throws(() => console.log('foo'), { name: 'TypeError' });
 
 global.console = 1;
 assert.strictEqual(global.console, 1);
diff --git a/test/parallel/test-console-clear.js b/test/parallel/test-console-clear.js
index b6fc003165dc66..dec0a4c087b877 100644
--- a/test/parallel/test-console-clear.js
+++ b/test/parallel/test-console-clear.js
@@ -11,7 +11,7 @@ const check = '\u001b[1;1H\u001b[0J';
 function doTest(isTTY, check) {
   let buf = '';
   process.stdout.isTTY = isTTY;
-  process.stdout.write = (string) => buf += string;
+  process.stdout.write = (string) => (buf += string);
   console.clear();
   process.stdout.write = stdoutWrite;
   assert.strictEqual(buf, check);
diff --git a/test/parallel/test-console-count.js b/test/parallel/test-console-count.js
index 5c7b26aaa20d00..f516d65a48d5fc 100644
--- a/test/parallel/test-console-count.js
+++ b/test/parallel/test-console-count.js
@@ -7,7 +7,7 @@ const stdoutWrite = process.stdout.write;
 
 let buf = '';
 
-process.stdout.write = (string) => buf = string;
+process.stdout.write = (string) => (buf = string);
 
 console.count();
 assert.strictEqual(buf, 'default: 1\n');
@@ -57,9 +57,5 @@ process.stdout.write = stdoutWrite;
 // Symbol labels do not work. Only check that the `Error` is a `TypeError`. Do
 // not check the message because it is different depending on the JavaScript
 // engine.
-assert.throws(
-  () => console.count(Symbol('test')),
-  TypeError);
-assert.throws(
-  () => console.countReset(Symbol('test')),
-  TypeError);
+assert.throws(() => console.count(Symbol('test')), TypeError);
+assert.throws(() => console.countReset(Symbol('test')), TypeError);
diff --git a/test/parallel/test-console-group.js b/test/parallel/test-console-group.js
index 9ab6c9db7e8c16..0cf335ce58e159 100644
--- a/test/parallel/test-console-group.js
+++ b/test/parallel/test-console-group.js
@@ -34,13 +34,13 @@ function teardown() {
 // Basic group() functionality
 {
   setup();
-  const expectedOut = 'This is the outer level\n' +
-                      '  Level 2\n' +
-                      '    Level 3\n' +
-                      '  Back to level 2\n' +
-                      'Back to the outer level\n' +
-                      'Still at the outer level\n';
-
+  const expectedOut =
+    'This is the outer level\n' +
+    '  Level 2\n' +
+    '    Level 3\n' +
+    '  Back to level 2\n' +
+    'Back to the outer level\n' +
+    'Still at the outer level\n';
 
   const expectedErr = '    More of level 3\n';
 
@@ -65,10 +65,11 @@ function teardown() {
 // Group indentation is tracked per Console instance.
 {
   setup();
-  const expectedOut = 'No indentation\n' +
-                      'None here either\n' +
-                      '  Now the first console is indenting\n' +
-                      'But the second one does not\n';
+  const expectedOut =
+    'No indentation\n' +
+    'None here either\n' +
+    '  Now the first console is indenting\n' +
+    'But the second one does not\n';
   const expectedErr = '';
 
   const c2 = new Console(process.stdout, process.stderr);
@@ -86,8 +87,8 @@ function teardown() {
 // Make sure labels work.
 {
   setup();
-  const expectedOut = 'This is a label\n' +
-                      '  And this is the data for that label\n';
+  const expectedOut =
+    'This is a label\n' + '  And this is the data for that label\n';
   const expectedErr = '';
 
   c.group('This is a label');
@@ -101,9 +102,7 @@ function teardown() {
 // Check that console.groupCollapsed() is an alias of console.group()
 {
   setup();
-  const expectedOut = 'Label\n' +
-                      '  Level 2\n' +
-                      '    Level 3\n';
+  const expectedOut = 'Label\n' + '  Level 2\n' + '    Level 3\n';
   const expectedErr = '';
 
   c.groupCollapsed('Label');
@@ -119,24 +118,27 @@ function teardown() {
 // Check that multiline strings and object output are indented properly.
 {
   setup();
-  const expectedOut = 'not indented\n' +
-                      '  indented\n' +
-                      '  also indented\n' +
-                      "  { also: 'a',\n" +
-                      "    multiline: 'object',\n" +
-                      "    should: 'be',\n" +
-                      "    indented: 'properly',\n" +
-                      "    kthx: 'bai' }\n";
+  const expectedOut =
+    'not indented\n' +
+    '  indented\n' +
+    '  also indented\n' +
+    "  { also: 'a',\n" +
+    "    multiline: 'object',\n" +
+    "    should: 'be',\n" +
+    "    indented: 'properly',\n" +
+    "    kthx: 'bai' }\n";
   const expectedErr = '';
 
   c.log('not indented');
   c.group();
   c.log('indented\nalso indented');
-  c.log({ also: 'a',
-          multiline: 'object',
-          should: 'be',
-          indented: 'properly',
-          kthx: 'bai' });
+  c.log({
+    also: 'a',
+    multiline: 'object',
+    should: 'be',
+    indented: 'properly',
+    kthx: 'bai'
+  });
 
   assert.strictEqual(stdout, expectedOut);
   assert.strictEqual(stderr, expectedErr);
@@ -146,8 +148,10 @@ function teardown() {
 // Check that the kGroupIndent symbol property is not enumerable
 {
   const keys = Reflect.ownKeys(console)
-                      .filter((val) => console.propertyIsEnumerable(val))
-                      .map((val) => val.toString());
-  assert(!keys.includes('Symbol(groupIndent)'),
-         'groupIndent should not be enumerable');
+    .filter((val) => console.propertyIsEnumerable(val))
+    .map((val) => val.toString());
+  assert(
+    !keys.includes('Symbol(groupIndent)'),
+    'groupIndent should not be enumerable'
+  );
 }
diff --git a/test/parallel/test-console-instance.js b/test/parallel/test-console-instance.js
index 127e59e6e5b981..cc8317a1af9e4e 100644
--- a/test/parallel/test-console-instance.js
+++ b/test/parallel/test-console-instance.js
@@ -44,7 +44,9 @@ assert.ok(!({} instanceof Console));
 // Make sure that the Console constructor throws
 // when not given a writable stream instance.
 common.expectsError(
-  () => { new Console(); },
+  () => {
+    new Console();
+  },
   {
     code: 'ERR_CONSOLE_WRITABLE_STREAM',
     type: TypeError,
@@ -106,7 +108,9 @@ out.write = err.write = (d) => {};
   class MyConsole extends Console {
     hello() {}
     // See if the methods on Console.prototype are overridable.
-    log() { return 'overridden'; }
+    log() {
+      return 'overridden';
+    }
   }
   const myConsole = new MyConsole(process.stdout);
   assert.strictEqual(typeof myConsole.hello, 'function');
@@ -121,8 +125,12 @@ out.write = err.write = (d) => {};
 {
   const c2 = new Console(out, err, false);
 
-  out.write = () => { throw new Error('out'); };
-  err.write = () => { throw new Error('err'); };
+  out.write = () => {
+    throw new Error('out');
+  };
+  err.write = () => {
+    throw new Error('err');
+  };
 
   assert.throws(() => c2.log('foo'), /^Error: out$/);
   assert.throws(() => c2.warn('foo'), /^Error: err$/);
diff --git a/test/parallel/test-console-no-swallow-stack-overflow.js b/test/parallel/test-console-no-swallow-stack-overflow.js
index f36ba4857e363b..9decc09b276cc2 100644
--- a/test/parallel/test-console-no-swallow-stack-overflow.js
+++ b/test/parallel/test-console-no-swallow-stack-overflow.js
@@ -4,15 +4,18 @@ const { Console } = require('console');
 const { Writable } = require('stream');
 
 for (const method of ['dir', 'log', 'warn']) {
-  common.expectsError(() => {
-    const out = new Writable({
-      write: common.mustCall(function write(...args) {
-        // Exceeds call stack.
-        return write(...args);
-      }),
-    });
-    const c = new Console(out, out, true);
+  common.expectsError(
+    () => {
+      const out = new Writable({
+        write: common.mustCall(function write(...args) {
+          // Exceeds call stack.
+          return write(...args);
+        })
+      });
+      const c = new Console(out, out, true);
 
-    c[method]('Hello, world!');
-  }, { name: 'RangeError' });
+      c[method]('Hello, world!');
+    },
+    { name: 'RangeError' }
+  );
 }
diff --git a/test/parallel/test-console-table.js b/test/parallel/test-console-table.js
index 3a4d6fefbbc8f1..3339c1fad3b059 100644
--- a/test/parallel/test-console-table.js
+++ b/test/parallel/test-console-table.js
@@ -7,9 +7,16 @@ const { Console } = require('console');
 
 const queue = [];
 
-const console = new Console({ write: (x) => {
-  queue.push(x);
-}, removeListener: () => {} }, process.stderr, false);
+const console = new Console(
+  {
+    write: (x) => {
+      queue.push(x);
+    },
+    removeListener: () => {}
+  },
+  process.stderr,
+  false
+);
 
 function test(data, only, expected) {
   if (arguments.length === 2) {
@@ -24,7 +31,7 @@ function test(data, only, expected) {
 }
 
 common.expectsError(() => console.table([], false), {
-  code: 'ERR_INVALID_ARG_TYPE',
+  code: 'ERR_INVALID_ARG_TYPE'
 });
 
 test(null, 'null\n');
@@ -34,7 +41,9 @@ test('hi', 'hi\n');
 test(Symbol(), 'Symbol()\n');
 test(function() {}, '[Function]\n');
 
-test([1, 2, 3], `
+test(
+  [1, 2, 3],
+  `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
@@ -42,9 +51,12 @@ test([1, 2, 3], `
 │    1    │   2    │
 │    2    │   3    │
 └─────────┴────────┘
-`);
+`
+);
 
-test([Symbol(), 5, [10]], `
+test(
+  [Symbol(), 5, [10]],
+  `
 ┌─────────┬────┬──────────┐
 │ (index) │ 0  │  Values  │
 ├─────────┼────┼──────────┤
@@ -52,27 +64,36 @@ test([Symbol(), 5, [10]], `
 │    1    │    │    5     │
 │    2    │ 10 │          │
 └─────────┴────┴──────────┘
-`);
+`
+);
 
-test([null, 5], `
+test(
+  [null, 5],
+  `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
 │    0    │  null  │
 │    1    │   5    │
 └─────────┴────────┘
-`);
+`
+);
 
-test([undefined, 5], `
+test(
+  [undefined, 5],
+  `
 ┌─────────┬───────────┐
 │ (index) │  Values   │
 ├─────────┼───────────┤
 │    0    │ undefined │
 │    1    │     5     │
 └─────────┴───────────┘
-`);
+`
+);
 
-test({ a: 1, b: Symbol(), c: [10] }, `
+test(
+  { a: 1, b: Symbol(), c: [10] },
+  `
 ┌─────────┬────┬──────────┐
 │ (index) │ 0  │  Values  │
 ├─────────┼────┼──────────┤
@@ -80,18 +101,24 @@ test({ a: 1, b: Symbol(), c: [10] }, `
 │    b    │    │ Symbol() │
 │    c    │ 10 │          │
 └─────────┴────┴──────────┘
-`);
+`
+);
 
-test(new Map([ ['a', 1], [Symbol(), [2]] ]), `
+test(
+  new Map([['a', 1], [Symbol(), [2]]]),
+  `
 ┌───────────────────┬──────────┬────────┐
 │ (iteration index) │   Key    │ Values │
 ├───────────────────┼──────────┼────────┤
 │         0         │   'a'    │   1    │
 │         1         │ Symbol() │ [ 2 ]  │
 └───────────────────┴──────────┴────────┘
-`);
+`
+);
 
-test(new Set([1, 2, Symbol()]), `
+test(
+  new Set([1, 2, Symbol()]),
+  `
 ┌───────────────────┬──────────┐
 │ (iteration index) │  Values  │
 ├───────────────────┼──────────┤
@@ -99,27 +126,38 @@ test(new Set([1, 2, Symbol()]), `
 │         1         │    2     │
 │         2         │ Symbol() │
 └───────────────────┴──────────┘
-`);
+`
+);
 
-test({ a: 1, b: 2 }, ['a'], `
+test(
+  { a: 1, b: 2 },
+  ['a'],
+  `
 ┌─────────┬───┐
 │ (index) │ a │
 ├─────────┼───┤
 │    a    │   │
 │    b    │   │
 └─────────┴───┘
-`);
+`
+);
 
-test([{ a: 1, b: 2 }, { a: 3, c: 4 }], ['a'], `
+test(
+  [{ a: 1, b: 2 }, { a: 3, c: 4 }],
+  ['a'],
+  `
 ┌─────────┬───┐
 │ (index) │ a │
 ├─────────┼───┤
 │    0    │ 1 │
 │    1    │ 3 │
 └─────────┴───┘
-`);
+`
+);
 
-test(new Map([[1, 1], [2, 2], [3, 3]]).entries(), `
+test(
+  new Map([[1, 1], [2, 2], [3, 3]]).entries(),
+  `
 ┌───────────────────┬─────┬────────┐
 │ (iteration index) │ Key │ Values │
 ├───────────────────┼─────┼────────┤
@@ -127,9 +165,12 @@ test(new Map([[1, 1], [2, 2], [3, 3]]).entries(), `
 │         1         │  2  │   2    │
 │         2         │  3  │   3    │
 └───────────────────┴─────┴────────┘
-`);
+`
+);
 
-test(new Map([[1, 1], [2, 2], [3, 3]]).values(), `
+test(
+  new Map([[1, 1], [2, 2], [3, 3]]).values(),
+  `
 ┌───────────────────┬────────┐
 │ (iteration index) │ Values │
 ├───────────────────┼────────┤
@@ -137,9 +178,12 @@ test(new Map([[1, 1], [2, 2], [3, 3]]).values(), `
 │         1         │   2    │
 │         2         │   3    │
 └───────────────────┴────────┘
-`);
+`
+);
 
-test(new Map([[1, 1], [2, 2], [3, 3]]).keys(), `
+test(
+  new Map([[1, 1], [2, 2], [3, 3]]).keys(),
+  `
 ┌───────────────────┬────────┐
 │ (iteration index) │ Values │
 ├───────────────────┼────────┤
@@ -147,9 +191,12 @@ test(new Map([[1, 1], [2, 2], [3, 3]]).keys(), `
 │         1         │   2    │
 │         2         │   3    │
 └───────────────────┴────────┘
-`);
+`
+);
 
-test(new Set([1, 2, 3]).values(), `
+test(
+  new Set([1, 2, 3]).values(),
+  `
 ┌───────────────────┬────────┐
 │ (iteration index) │ Values │
 ├───────────────────┼────────┤
@@ -157,34 +204,45 @@ test(new Set([1, 2, 3]).values(), `
 │         1         │   2    │
 │         2         │   3    │
 └───────────────────┴────────┘
-`);
+`
+);
 
-
-test({ a: { a: 1, b: 2, c: 3 } }, `
+test(
+  { a: { a: 1, b: 2, c: 3 } },
+  `
 ┌─────────┬───┬───┬───┐
 │ (index) │ a │ b │ c │
 ├─────────┼───┼───┼───┤
 │    a    │ 1 │ 2 │ 3 │
 └─────────┴───┴───┴───┘
-`);
+`
+);
 
-test({ a: { a: { a: 1, b: 2, c: 3 } } }, `
+test(
+  { a: { a: { a: 1, b: 2, c: 3 } } },
+  `
 ┌─────────┬──────────┐
 │ (index) │    a     │
 ├─────────┼──────────┤
 │    a    │ [Object] │
 └─────────┴──────────┘
-`);
+`
+);
 
-test({ a: [1, 2] }, `
+test(
+  { a: [1, 2] },
+  `
 ┌─────────┬───┬───┐
 │ (index) │ 0 │ 1 │
 ├─────────┼───┼───┤
 │    a    │ 1 │ 2 │
 └─────────┴───┴───┘
-`);
+`
+);
 
-test({ a: [1, 2, 3, 4, 5], b: 5, c: { e: 5 } }, `
+test(
+  { a: [1, 2, 3, 4, 5], b: 5, c: { e: 5 } },
+  `
 ┌─────────┬───┬───┬───┬───┬───┬───┬────────┐
 │ (index) │ 0 │ 1 │ 2 │ 3 │ 4 │ e │ Values │
 ├─────────┼───┼───┼───┼───┼───┼───┼────────┤
@@ -192,9 +250,12 @@ test({ a: [1, 2, 3, 4, 5], b: 5, c: { e: 5 } }, `
 │    b    │   │   │   │   │   │   │   5    │
 │    c    │   │   │   │   │   │ 5 │        │
 └─────────┴───┴───┴───┴───┴───┴───┴────────┘
-`);
+`
+);
 
-test(new Uint8Array([1, 2, 3]), `
+test(
+  new Uint8Array([1, 2, 3]),
+  `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
@@ -202,9 +263,12 @@ test(new Uint8Array([1, 2, 3]), `
 │    1    │   2    │
 │    2    │   3    │
 └─────────┴────────┘
-`);
+`
+);
 
-test(Buffer.from([1, 2, 3]), `
+test(
+  Buffer.from([1, 2, 3]),
+  `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
@@ -212,35 +276,49 @@ test(Buffer.from([1, 2, 3]), `
 │    1    │   2    │
 │    2    │   3    │
 └─────────┴────────┘
-`);
+`
+);
 
-test({ a: undefined }, ['x'], `
+test(
+  { a: undefined },
+  ['x'],
+  `
 ┌─────────┬───┐
 │ (index) │ x │
 ├─────────┼───┤
 │    a    │   │
 └─────────┴───┘
-`);
+`
+);
 
-test([], `
+test(
+  [],
+  `
 ┌─────────┐
 │ (index) │
 ├─────────┤
 └─────────┘
-`);
+`
+);
 
-test(new Map(), `
+test(
+  new Map(),
+  `
 ┌───────────────────┬─────┬────────┐
 │ (iteration index) │ Key │ Values │
 ├───────────────────┼─────┼────────┤
 └───────────────────┴─────┴────────┘
-`);
+`
+);
 
-test([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], `
+test(
+  [{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }],
+  `
 ┌─────────┬─────┬─────┐
 │ (index) │  a  │  b  │
 ├─────────┼─────┼─────┤
 │    0    │  1  │ 'Y' │
 │    1    │ 'Z' │  2  │
 └─────────┴─────┴─────┘
-`);
+`
+);
diff --git a/test/parallel/test-console-tty-colors.js b/test/parallel/test-console-tty-colors.js
index 4f4064970ad6b7..07264e501d3bb4 100644
--- a/test/parallel/test-console-tty-colors.js
+++ b/test/parallel/test-console-tty-colors.js
@@ -6,20 +6,17 @@ const { Writable } = require('stream');
 const { Console } = require('console');
 
 function check(isTTY, colorMode, expectedColorMode) {
-  const items = [
-    1,
-    { a: 2 },
-    [ 'foo' ],
-    { '\\a': '\\bar' }
-  ];
+  const items = [1, { a: 2 }, ['foo'], { '\\a': '\\bar' }];
 
   let i = 0;
   const stream = new Writable({
     write: common.mustCall((chunk, enc, cb) => {
-      assert.strictEqual(chunk.trim(),
-                         util.inspect(items[i++], {
-                           colors: expectedColorMode
-                         }));
+      assert.strictEqual(
+        chunk.trim(),
+        util.inspect(items[i++], {
+          colors: expectedColorMode
+        })
+      );
       cb();
     }, items.length),
     decodeStrings: false
diff --git a/test/parallel/test-console.js b/test/parallel/test-console.js
index 92e66596d76ca7..6e88194a308e67 100644
--- a/test/parallel/test-console.js
+++ b/test/parallel/test-console.js
@@ -39,19 +39,16 @@ if (common.isMainThread) {
   assert.strictEqual(typeof process.stderr.fd, 'number');
 }
 
-common.expectWarning(
-  'Warning',
-  [
-    ['Count for \'noLabel\' does not exist', common.noWarnCode],
-    ['No such label \'noLabel\' for console.timeLog()', common.noWarnCode],
-    ['No such label \'noLabel\' for console.timeEnd()', common.noWarnCode],
-    ['Count for \'default\' does not exist', common.noWarnCode],
-    ['No such label \'default\' for console.timeLog()', common.noWarnCode],
-    ['No such label \'default\' for console.timeEnd()', common.noWarnCode],
-    ['Label \'default\' already exists for console.time()', common.noWarnCode],
-    ['Label \'test\' already exists for console.time()', common.noWarnCode]
-  ]
-);
+common.expectWarning('Warning', [
+  ["Count for 'noLabel' does not exist", common.noWarnCode],
+  ["No such label 'noLabel' for console.timeLog()", common.noWarnCode],
+  ["No such label 'noLabel' for console.timeEnd()", common.noWarnCode],
+  ["Count for 'default' does not exist", common.noWarnCode],
+  ["No such label 'default' for console.timeLog()", common.noWarnCode],
+  ["No such label 'default' for console.timeEnd()", common.noWarnCode],
+  ["Label 'default' already exists for console.time()", common.noWarnCode],
+  ["Label 'test' already exists for console.time()", common.noWarnCode]
+]);
 
 console.countReset('noLabel');
 console.timeLog('noLabel');
@@ -73,11 +70,8 @@ console.timeEnd();
 
 // Check that the `Error` is a `TypeError` but do not check the message as it
 // will be different in different JavaScript engines.
-assert.throws(() => console.time(Symbol('test')),
-              TypeError);
-assert.throws(() => console.timeEnd(Symbol('test')),
-              TypeError);
-
+assert.throws(() => console.time(Symbol('test')), TypeError);
+assert.throws(() => console.timeEnd(Symbol('test')), TypeError);
 
 // An Object with a custom inspect function.
 const custom_inspect = { foo: 'bar', [util.inspect.custom]: () => 'inspect' };
@@ -190,8 +184,10 @@ console.timeLog('log1', {}, [1, 2, 3]);
 console.timeEnd('log1');
 
 console.assert(false, '%s should', 'console.assert', 'not throw');
-assert.strictEqual(errStrings[errStrings.length - 1],
-                   'Assertion failed: console.assert should not throw\n');
+assert.strictEqual(
+  errStrings[errStrings.length - 1],
+  'Assertion failed: console.assert should not throw\n'
+);
 
 console.assert(true, 'this should not throw');
 
@@ -213,7 +209,11 @@ console.timeEnd('label3');
 assert.strictEqual(console._times.size, timesMapSize);
 
 const expectedStrings = [
-  'foo', 'foo bar', 'foo bar hop', "{ slashes: '\\\\\\\\' }", 'inspect'
+  'foo',
+  'foo bar',
+  'foo bar hop',
+  "{ slashes: '\\\\\\\\' }",
+  'inspect'
 ];
 
 for (const expected of expectedStrings) {
@@ -230,12 +230,16 @@ for (const expected of expectedStrings) {
   assert.strictEqual(strings.shift(), `${expected}\n`);
 }
 
-assert.strictEqual(strings.shift(),
-                   "{ foo: 'bar',\n  [Symbol(nodejs.util.inspect.custom)]: " +
-                    '[Function: [nodejs.util.inspect.custom]] }\n');
-assert.strictEqual(strings.shift(),
-                   "{ foo: 'bar',\n  [Symbol(nodejs.util.inspect.custom)]: " +
-                    '[Function: [nodejs.util.inspect.custom]] }\n');
+assert.strictEqual(
+  strings.shift(),
+  "{ foo: 'bar',\n  [Symbol(nodejs.util.inspect.custom)]: " +
+    '[Function: [nodejs.util.inspect.custom]] }\n'
+);
+assert.strictEqual(
+  strings.shift(),
+  "{ foo: 'bar',\n  [Symbol(nodejs.util.inspect.custom)]: " +
+    '[Function: [nodejs.util.inspect.custom]] }\n'
+);
 assert.ok(strings.shift().includes('foo: [Object]'));
 assert.strictEqual(strings.shift().includes('baz'), false);
 assert.strictEqual(strings.shift(), 'inspect inspect\n');
@@ -265,16 +269,23 @@ assert.ok(/^log1: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 // Make sure that we checked all strings
 assert.strictEqual(strings.length, 0);
 
-assert.strictEqual(errStrings.shift().split('\n').shift(),
-                   'Trace: This is a {"formatted":"trace"} 10 foo');
+assert.strictEqual(
+  errStrings
+    .shift()
+    .split('\n')
+    .shift(),
+  'Trace: This is a {"formatted":"trace"} 10 foo'
+);
 
 // hijack stderr to catch `process.emitWarning` which is using
 // `process.nextTick`
-hijackStderr(common.mustCall(function(data) {
-  restoreStderr();
-
-  // stderr.write will catch sync error, so use `process.nextTick` here
-  process.nextTick(function() {
-    assert.strictEqual(data.includes('noLabel'), true);
-  });
-}));
+hijackStderr(
+  common.mustCall(function(data) {
+    restoreStderr();
+
+    // stderr.write will catch sync error, so use `process.nextTick` here
+    process.nextTick(function() {
+      assert.strictEqual(data.includes('noLabel'), true);
+    });
+  })
+);
diff --git a/test/parallel/test-constants.js b/test/parallel/test-constants.js
index 945443d8866a2f..3d958577cf7d4b 100644
--- a/test/parallel/test-constants.js
+++ b/test/parallel/test-constants.js
@@ -14,12 +14,14 @@ assert.ok(binding.crypto);
 
 ['os', 'fs', 'crypto'].forEach((l) => {
   Object.keys(binding[l]).forEach((k) => {
-    if (typeof binding[l][k] === 'object') { // errno and signals
+    if (typeof binding[l][k] === 'object') {
+      // errno and signals
       Object.keys(binding[l][k]).forEach((j) => {
         assert.strictEqual(binding[l][k][j], constants[j]);
       });
     }
-    if (l !== 'os') { // top level os constant isn't currently copied
+    if (l !== 'os') {
+      // top level os constant isn't currently copied
       assert.strictEqual(binding[l][k], constants[k]);
     }
   });
diff --git a/test/parallel/test-crypto-aes-wrap.js b/test/parallel/test-crypto-aes-wrap.js
index 6fe35258f7d6b2..8da86cf40c5dcd 100644
--- a/test/parallel/test-crypto-aes-wrap.js
+++ b/test/parallel/test-crypto-aes-wrap.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -42,20 +41,22 @@ const test = [
     key: '29c9eab5ed5ad44134a1437fe2e673b4d88a5b7c72e68454fea08721392b7323',
     iv: '3fd838af',
     text: '12345678123456781234567812345678123'
-  },
+  }
 ];
 
 test.forEach((data) => {
   const cipher = crypto.createCipheriv(
     data.algorithm,
     Buffer.from(data.key, 'hex'),
-    Buffer.from(data.iv, 'hex'));
+    Buffer.from(data.iv, 'hex')
+  );
   const ciphertext = cipher.update(data.text, 'utf8');
 
   const decipher = crypto.createDecipheriv(
     data.algorithm,
     Buffer.from(data.key, 'hex'),
-    Buffer.from(data.iv, 'hex'));
+    Buffer.from(data.iv, 'hex')
+  );
   const msg = decipher.update(ciphertext, 'buffer', 'utf8');
 
   assert.strictEqual(msg, data.text, `${data.algorithm} test case failed`);
diff --git a/test/parallel/test-crypto-authenticated.js b/test/parallel/test-crypto-authenticated.js
index 01ce1d9996863e..0eebc4c3cd8e15 100644
--- a/test/parallel/test-crypto-authenticated.js
+++ b/test/parallel/test-crypto-authenticated.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -48,28 +47,29 @@ const errMessages = {
 
 const ciphers = crypto.getCiphers();
 
-const expectedWarnings = common.hasFipsCrypto ?
-  [] : [
-    ['Use Cipheriv for counter mode of aes-192-gcm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-192-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-192-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-128-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-128-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-128-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
-    ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode]
-  ];
+const expectedWarnings = common.hasFipsCrypto
+  ? []
+  : [
+      ['Use Cipheriv for counter mode of aes-192-gcm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-192-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-192-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-128-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-128-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-128-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode],
+      ['Use Cipheriv for counter mode of aes-256-ccm', common.noWarnCode]
+    ];
 
 const expectedDeprecationWarnings = [
   ['crypto.DEFAULT_ENCODING is deprecated.', 'DEP0091'],
@@ -110,13 +110,14 @@ for (const test of TEST_CASES) {
   }
 
   {
-    const encrypt = crypto.createCipheriv(test.algo,
-                                          Buffer.from(test.key, 'hex'),
-                                          Buffer.from(test.iv, 'hex'),
-                                          options);
+    const encrypt = crypto.createCipheriv(
+      test.algo,
+      Buffer.from(test.key, 'hex'),
+      Buffer.from(test.iv, 'hex'),
+      options
+    );
 
-    if (test.aad)
-      encrypt.setAAD(Buffer.from(test.aad, 'hex'), aadOptions);
+    if (test.aad) encrypt.setAAD(Buffer.from(test.aad, 'hex'), aadOptions);
 
     let hex = encrypt.update(test.plain, inputEncoding, 'hex');
     hex += encrypt.final('hex');
@@ -132,19 +133,22 @@ for (const test of TEST_CASES) {
   {
     if (isCCM && common.hasFipsCrypto) {
       assert.throws(() => {
-        crypto.createDecipheriv(test.algo,
-                                Buffer.from(test.key, 'hex'),
-                                Buffer.from(test.iv, 'hex'),
-                                options);
+        crypto.createDecipheriv(
+          test.algo,
+          Buffer.from(test.key, 'hex'),
+          Buffer.from(test.iv, 'hex'),
+          options
+        );
       }, errMessages.FIPS);
     } else {
-      const decrypt = crypto.createDecipheriv(test.algo,
-                                              Buffer.from(test.key, 'hex'),
-                                              Buffer.from(test.iv, 'hex'),
-                                              options);
+      const decrypt = crypto.createDecipheriv(
+        test.algo,
+        Buffer.from(test.key, 'hex'),
+        Buffer.from(test.iv, 'hex'),
+        options
+      );
       decrypt.setAuthTag(Buffer.from(test.tag, 'hex'));
-      if (test.aad)
-        decrypt.setAAD(Buffer.from(test.aad, 'hex'), aadOptions);
+      if (test.aad) decrypt.setAAD(Buffer.from(test.aad, 'hex'), aadOptions);
 
       const outputEncoding = test.plainIsHex ? 'hex' : 'ascii';
 
@@ -154,19 +158,21 @@ for (const test of TEST_CASES) {
         assert.strictEqual(msg, test.plain);
       } else {
         // assert that final throws if input data could not be verified!
-        assert.throws(function() { decrypt.final('hex'); }, errMessages.auth);
+        assert.throws(function() {
+          decrypt.final('hex');
+        }, errMessages.auth);
       }
     }
   }
 
   if (test.password) {
     if (common.hasFipsCrypto) {
-      assert.throws(() => { crypto.createCipher(test.algo, test.password); },
-                    errMessages.FIPS);
+      assert.throws(() => {
+        crypto.createCipher(test.algo, test.password);
+      }, errMessages.FIPS);
     } else {
       const encrypt = crypto.createCipher(test.algo, test.password, options);
-      if (test.aad)
-        encrypt.setAAD(Buffer.from(test.aad, 'hex'), aadOptions);
+      if (test.aad) encrypt.setAAD(Buffer.from(test.aad, 'hex'), aadOptions);
       let hex = encrypt.update(test.plain, 'ascii', 'hex');
       hex += encrypt.final('hex');
       const auth_tag = encrypt.getAuthTag();
@@ -180,32 +186,38 @@ for (const test of TEST_CASES) {
 
   if (test.password) {
     if (common.hasFipsCrypto) {
-      assert.throws(() => { crypto.createDecipher(test.algo, test.password); },
-                    errMessages.FIPS);
+      assert.throws(() => {
+        crypto.createDecipher(test.algo, test.password);
+      }, errMessages.FIPS);
     } else {
       const decrypt = crypto.createDecipher(test.algo, test.password, options);
       decrypt.setAuthTag(Buffer.from(test.tag, 'hex'));
-      if (test.aad)
-        decrypt.setAAD(Buffer.from(test.aad, 'hex'), aadOptions);
+      if (test.aad) decrypt.setAAD(Buffer.from(test.aad, 'hex'), aadOptions);
       let msg = decrypt.update(test.ct, 'hex', 'ascii');
       if (!test.tampered) {
         msg += decrypt.final('ascii');
         assert.strictEqual(msg, test.plain);
       } else {
         // assert that final throws if input data could not be verified!
-        assert.throws(function() { decrypt.final('ascii'); }, errMessages.auth);
+        assert.throws(function() {
+          decrypt.final('ascii');
+        }, errMessages.auth);
       }
     }
   }
 
   {
     // trying to get tag before inputting all data:
-    const encrypt = crypto.createCipheriv(test.algo,
-                                          Buffer.from(test.key, 'hex'),
-                                          Buffer.from(test.iv, 'hex'),
-                                          options);
+    const encrypt = crypto.createCipheriv(
+      test.algo,
+      Buffer.from(test.key, 'hex'),
+      Buffer.from(test.iv, 'hex'),
+      options
+    );
     encrypt.update('blah', 'ascii');
-    assert.throws(function() { encrypt.getAuthTag(); }, errMessages.state);
+    assert.throws(function() {
+      encrypt.getAuthTag();
+    }, errMessages.state);
   }
 
   {
@@ -222,54 +234,72 @@ for (const test of TEST_CASES) {
 
 // Non-authenticating mode:
 {
-  const encrypt =
-      crypto.createCipheriv('aes-128-cbc',
-                            'ipxp9a6i1Mb4USb4',
-                            '6fKjEjR3Vl30EUYC');
+  const encrypt = crypto.createCipheriv(
+    'aes-128-cbc',
+    'ipxp9a6i1Mb4USb4',
+    '6fKjEjR3Vl30EUYC'
+  );
   encrypt.update('blah', 'ascii');
   encrypt.final();
   assert.throws(() => encrypt.getAuthTag(), errMessages.state);
-  assert.throws(() => encrypt.setAAD(Buffer.from('123', 'ascii')),
-                errMessages.state);
+  assert.throws(
+    () => encrypt.setAAD(Buffer.from('123', 'ascii')),
+    errMessages.state
+  );
 }
 
 // GCM only supports specific authentication tag lengths, invalid lengths should
 // throw.
 {
   for (const length of [0, 1, 2, 6, 9, 10, 11, 17]) {
-    common.expectsError(() => {
-      const decrypt = crypto.createDecipheriv('aes-128-gcm',
-                                              'FxLKsqdmv0E9xrQh',
-                                              'qkuZpJWCewa6Szih');
-      decrypt.setAuthTag(Buffer.from('1'.repeat(length)));
-    }, {
-      type: Error,
-      message: `Invalid authentication tag length: ${length}`
-    });
-
-    common.expectsError(() => {
-      crypto.createCipheriv('aes-256-gcm',
-                            'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                            'qkuZpJWCewa6Szih',
-                            {
-                              authTagLength: length
-                            });
-    }, {
-      type: Error,
-      message: `Invalid authentication tag length: ${length}`
-    });
-
-    common.expectsError(() => {
-      crypto.createDecipheriv('aes-256-gcm',
-                              'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                              'qkuZpJWCewa6Szih',
-                              {
-                                authTagLength: length
-                              });
-    }, {
-      type: Error,
-      message: `Invalid authentication tag length: ${length}`
-    });
+    common.expectsError(
+      () => {
+        const decrypt = crypto.createDecipheriv(
+          'aes-128-gcm',
+          'FxLKsqdmv0E9xrQh',
+          'qkuZpJWCewa6Szih'
+        );
+        decrypt.setAuthTag(Buffer.from('1'.repeat(length)));
+      },
+      {
+        type: Error,
+        message: `Invalid authentication tag length: ${length}`
+      }
+    );
+
+    common.expectsError(
+      () => {
+        crypto.createCipheriv(
+          'aes-256-gcm',
+          'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+          'qkuZpJWCewa6Szih',
+          {
+            authTagLength: length
+          }
+        );
+      },
+      {
+        type: Error,
+        message: `Invalid authentication tag length: ${length}`
+      }
+    );
+
+    common.expectsError(
+      () => {
+        crypto.createDecipheriv(
+          'aes-256-gcm',
+          'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+          'qkuZpJWCewa6Szih',
+          {
+            authTagLength: length
+          }
+        );
+      },
+      {
+        type: Error,
+        message: `Invalid authentication tag length: ${length}`
+      }
+    );
   }
 }
 
@@ -277,11 +307,14 @@ for (const test of TEST_CASES) {
 {
   const fullTag = '1debb47b2c91ba2cea16fad021703070';
   for (const [authTagLength, e] of [[undefined, 16], [12, 12], [4, 4]]) {
-    const cipher = crypto.createCipheriv('aes-256-gcm',
-                                         'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                                         'qkuZpJWCewa6Szih', {
-                                           authTagLength
-                                         });
+    const cipher = crypto.createCipheriv(
+      'aes-256-gcm',
+      'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+      'qkuZpJWCewa6Szih',
+      {
+        authTagLength
+      }
+    );
     cipher.setAAD(Buffer.from('abcd'));
     cipher.update('01234567', 'hex');
     cipher.final();
@@ -292,19 +325,25 @@ for (const test of TEST_CASES) {
 
 // Test that users can manually restrict the GCM tag length to a single value.
 {
-  const decipher = crypto.createDecipheriv('aes-256-gcm',
-                                           'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                                           'qkuZpJWCewa6Szih', {
-                                             authTagLength: 8
-                                           });
-
-  common.expectsError(() => {
-    // This tag would normally be allowed.
-    decipher.setAuthTag(Buffer.from('1'.repeat(12)));
-  }, {
-    type: Error,
-    message: 'Invalid authentication tag length: 12'
-  });
+  const decipher = crypto.createDecipheriv(
+    'aes-256-gcm',
+    'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+    'qkuZpJWCewa6Szih',
+    {
+      authTagLength: 8
+    }
+  );
+
+  common.expectsError(
+    () => {
+      // This tag would normally be allowed.
+      decipher.setAuthTag(Buffer.from('1'.repeat(12)));
+    },
+    {
+      type: Error,
+      message: 'Invalid authentication tag length: 12'
+    }
+  );
 
   // The Decipher object should be left intact.
   decipher.setAuthTag(Buffer.from('445352d3ff85cf94', 'hex'));
@@ -319,52 +358,74 @@ for (const test of TEST_CASES) {
 // authentication tag length has been specified.
 {
   for (const authTagLength of [-1, true, false, NaN, 5.5]) {
-    common.expectsError(() => {
-      crypto.createCipheriv('aes-256-ccm',
-                            'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                            'qkuZpJWCewa6S',
-                            {
-                              authTagLength
-                            });
-    }, {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${authTagLength}" is invalid for option ` +
-               '"authTagLength"'
-    });
-
-    common.expectsError(() => {
-      crypto.createDecipheriv('aes-256-ccm',
-                              'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                              'qkuZpJWCewa6S',
-                              {
-                                authTagLength
-                              });
-    }, {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${authTagLength}" is invalid for option ` +
-               '"authTagLength"'
-    });
-
-    if (!common.hasFipsCrypto) {
-      common.expectsError(() => {
-        crypto.createCipher('aes-256-ccm', 'bad password', { authTagLength });
-      }, {
+    common.expectsError(
+      () => {
+        crypto.createCipheriv(
+          'aes-256-ccm',
+          'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+          'qkuZpJWCewa6S',
+          {
+            authTagLength
+          }
+        );
+      },
+      {
         type: TypeError,
         code: 'ERR_INVALID_OPT_VALUE',
-        message: `The value "${authTagLength}" is invalid for option ` +
-                 '"authTagLength"'
-      });
-
-      common.expectsError(() => {
-        crypto.createDecipher('aes-256-ccm', 'bad password', { authTagLength });
-      }, {
+        message:
+          `The value "${authTagLength}" is invalid for option ` +
+          '"authTagLength"'
+      }
+    );
+
+    common.expectsError(
+      () => {
+        crypto.createDecipheriv(
+          'aes-256-ccm',
+          'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+          'qkuZpJWCewa6S',
+          {
+            authTagLength
+          }
+        );
+      },
+      {
         type: TypeError,
         code: 'ERR_INVALID_OPT_VALUE',
-        message: `The value "${authTagLength}" is invalid for option ` +
-                 '"authTagLength"'
-      });
+        message:
+          `The value "${authTagLength}" is invalid for option ` +
+          '"authTagLength"'
+      }
+    );
+
+    if (!common.hasFipsCrypto) {
+      common.expectsError(
+        () => {
+          crypto.createCipher('aes-256-ccm', 'bad password', { authTagLength });
+        },
+        {
+          type: TypeError,
+          code: 'ERR_INVALID_OPT_VALUE',
+          message:
+            `The value "${authTagLength}" is invalid for option ` +
+            '"authTagLength"'
+        }
+      );
+
+      common.expectsError(
+        () => {
+          crypto.createDecipher('aes-256-ccm', 'bad password', {
+            authTagLength
+          });
+        },
+        {
+          type: TypeError,
+          code: 'ERR_INVALID_OPT_VALUE',
+          message:
+            `The value "${authTagLength}" is invalid for option ` +
+            '"authTagLength"'
+        }
+      );
     }
   }
 
@@ -372,22 +433,26 @@ for (const test of TEST_CASES) {
   // use the default error codes.
   for (const authTagLength of [0, 1, 2, 3, 5, 7, 9, 11, 13, 15, 17, 18]) {
     assert.throws(() => {
-      crypto.createCipheriv('aes-256-ccm',
-                            'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                            'qkuZpJWCewa6S',
-                            {
-                              authTagLength
-                            });
+      crypto.createCipheriv(
+        'aes-256-ccm',
+        'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+        'qkuZpJWCewa6S',
+        {
+          authTagLength
+        }
+      );
     }, errMessages.authTagLength);
 
     if (!common.hasFipsCrypto) {
       assert.throws(() => {
-        crypto.createDecipheriv('aes-256-ccm',
-                                'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                                'qkuZpJWCewa6S',
-                                {
-                                  authTagLength
-                                });
+        crypto.createDecipheriv(
+          'aes-256-ccm',
+          'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+          'qkuZpJWCewa6S',
+          {
+            authTagLength
+          }
+        );
       }, errMessages.authTagLength);
 
       assert.throws(() => {
@@ -405,57 +470,79 @@ for (const test of TEST_CASES) {
 // authentication tag has been specified.
 {
   for (const mode of ['ccm', 'ocb']) {
-    assert.throws(() => {
-      crypto.createCipheriv(`aes-256-${mode}`,
-                            'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                            'qkuZpJWCewa6S');
-    }, {
-      message: `authTagLength required for aes-256-${mode}`
-    });
+    assert.throws(
+      () => {
+        crypto.createCipheriv(
+          `aes-256-${mode}`,
+          'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+          'qkuZpJWCewa6S'
+        );
+      },
+      {
+        message: `authTagLength required for aes-256-${mode}`
+      }
+    );
 
     // CCM decryption and create(De|C)ipher are unsupported in FIPS mode.
     if (!common.hasFipsCrypto) {
-      assert.throws(() => {
-        crypto.createDecipheriv(`aes-256-${mode}`,
-                                'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                                'qkuZpJWCewa6S');
-      }, {
-        message: `authTagLength required for aes-256-${mode}`
-      });
+      assert.throws(
+        () => {
+          crypto.createDecipheriv(
+            `aes-256-${mode}`,
+            'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+            'qkuZpJWCewa6S'
+          );
+        },
+        {
+          message: `authTagLength required for aes-256-${mode}`
+        }
+      );
 
-      assert.throws(() => {
-        crypto.createCipher(`aes-256-${mode}`, 'very bad password');
-      }, {
-        message: `authTagLength required for aes-256-${mode}`
-      });
+      assert.throws(
+        () => {
+          crypto.createCipher(`aes-256-${mode}`, 'very bad password');
+        },
+        {
+          message: `authTagLength required for aes-256-${mode}`
+        }
+      );
 
-      assert.throws(() => {
-        crypto.createDecipher(`aes-256-${mode}`, 'very bad password');
-      }, {
-        message: `authTagLength required for aes-256-${mode}`
-      });
+      assert.throws(
+        () => {
+          crypto.createDecipher(`aes-256-${mode}`, 'very bad password');
+        },
+        {
+          message: `authTagLength required for aes-256-${mode}`
+        }
+      );
     }
   }
 }
 
 // Test that setAAD throws if an invalid plaintext length has been specified.
 {
-  const cipher = crypto.createCipheriv('aes-256-ccm',
-                                       'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                                       'qkuZpJWCewa6S',
-                                       {
-                                         authTagLength: 10
-                                       });
+  const cipher = crypto.createCipheriv(
+    'aes-256-ccm',
+    'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+    'qkuZpJWCewa6S',
+    {
+      authTagLength: 10
+    }
+  );
 
   for (const plaintextLength of [-1, true, false, NaN, 5.5]) {
-    common.expectsError(() => {
-      cipher.setAAD(Buffer.from('0123456789', 'hex'), { plaintextLength });
-    }, {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${plaintextLength}" is invalid for option ` +
-               '"plaintextLength"'
-    });
+    common.expectsError(
+      () => {
+        cipher.setAAD(Buffer.from('0123456789', 'hex'), { plaintextLength });
+      },
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${plaintextLength}" is invalid for option ` +
+          '"plaintextLength"'
+      }
+    );
   }
 }
 
@@ -464,11 +551,10 @@ for (const test of TEST_CASES) {
   for (const ivLength of [13, 12]) {
     const maxMessageSize = (1 << (8 * (15 - ivLength))) - 1;
     const key = 'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8';
-    const cipher = () => crypto.createCipheriv('aes-256-ccm', key,
-                                               '0'.repeat(ivLength),
-                                               {
-                                                 authTagLength: 10
-                                               });
+    const cipher = () =>
+      crypto.createCipheriv('aes-256-ccm', key, '0'.repeat(ivLength), {
+        authTagLength: 10
+      });
 
     assert.throws(() => {
       cipher().setAAD(Buffer.alloc(0), {
@@ -493,23 +579,27 @@ for (const test of TEST_CASES) {
 // been specified.
 {
   assert.throws(() => {
-    const cipher = crypto.createCipheriv('aes-256-ccm',
-                                         'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                                         'qkuZpJWCewa6S',
-                                         {
-                                           authTagLength: 10
-                                         });
+    const cipher = crypto.createCipheriv(
+      'aes-256-ccm',
+      'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+      'qkuZpJWCewa6S',
+      {
+        authTagLength: 10
+      }
+    );
     cipher.setAAD(Buffer.from('0123456789', 'hex'));
   }, /^Error: plaintextLength required for CCM mode with AAD$/);
 
   if (!common.hasFipsCrypto) {
     assert.throws(() => {
-      const cipher = crypto.createDecipheriv('aes-256-ccm',
-                                             'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
-                                             'qkuZpJWCewa6S',
-                                             {
-                                               authTagLength: 10
-                                             });
+      const cipher = crypto.createDecipheriv(
+        'aes-256-ccm',
+        'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
+        'qkuZpJWCewa6S',
+        {
+          authTagLength: 10
+        }
+      );
       cipher.setAAD(Buffer.from('0123456789', 'hex'));
     }, /^Error: plaintextLength required for CCM mode with AAD$/);
   }
@@ -553,7 +643,7 @@ for (const test of TEST_CASES) {
   const iv = Buffer.from('112233445566778899aabb', 'hex');
   const options = { authTagLength: 8 };
   const encrypt = crypto.createCipheriv('aes-128-ccm', key, iv, options);
-  encrypt.update('boom');  // Should not throw 'Message exceeds maximum size'.
+  encrypt.update('boom'); // Should not throw 'Message exceeds maximum size'.
   encrypt.final();
 }
 
diff --git a/test/parallel/test-crypto-binary-default.js b/test/parallel/test-crypto-binary-default.js
index 228e2cc8abdc81..2568f6ad1e6baa 100644
--- a/test/parallel/test-crypto-binary-default.js
+++ b/test/parallel/test-crypto-binary-default.js
@@ -25,11 +25,9 @@
 // This is the same as test/simple/test-crypto, but from before the shift
 // to use buffers by default.
 
-
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -64,10 +62,11 @@ assert.throws(function() {
 
 // Test HMAC
 {
-  const hmacHash = crypto.createHmac('sha1', 'Node')
-                         .update('some data')
-                         .update('to hmac')
-                         .digest('hex');
+  const hmacHash = crypto
+    .createHmac('sha1', 'Node')
+    .update('some data')
+    .update('to hmac')
+    .digest('hex');
   assert.strictEqual(hmacHash, '19fd6e1ba73d9ed2224dd5094a71babe85d9a892');
 }
 
@@ -80,72 +79,80 @@ assert.throws(function() {
       hmac: {
         sha224: '896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22',
         sha256:
-            'b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c' +
-            '2e32cff7',
+          'b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c' +
+          '2e32cff7',
         sha384:
-            'afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c' +
-            '7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6',
+          'afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c' +
+          '7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6',
         sha512:
-            '87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b305' +
-            '45e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f170' +
-            '2e696c203a126854'
+          '87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b305' +
+          '45e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f170' +
+          '2e696c203a126854'
       }
     },
     {
       key: Buffer.from('4a656665', 'hex'), // 'Jefe'
-      data: Buffer.from('7768617420646f2079612077616e7420666f72206e6f74686' +
-                        '96e673f', 'hex'), // 'what do ya want for nothing?'
+      data: Buffer.from(
+        '7768617420646f2079612077616e7420666f72206e6f74686' + '96e673f',
+        'hex'
+      ), // 'what do ya want for nothing?'
       hmac: {
         sha224: 'a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44',
         sha256:
-            '5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b9' +
-            '64ec3843',
+          '5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b9' +
+          '64ec3843',
         sha384:
-            'af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec373' +
-            '6322445e8e2240ca5e69e2c78b3239ecfab21649',
+          'af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec373' +
+          '6322445e8e2240ca5e69e2c78b3239ecfab21649',
         sha512:
-            '164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7' +
-            'ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b' +
-            '636e070a38bce737'
+          '164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7' +
+          'ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b' +
+          '636e070a38bce737'
       }
     },
     {
       key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
-      data: Buffer.from('ddddddddddddddddddddddddddddddddddddddddddddddddd' +
-                        'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
-                        'hex'),
+      data: Buffer.from(
+        'ddddddddddddddddddddddddddddddddddddddddddddddddd' +
+          'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
+        'hex'
+      ),
       hmac: {
         sha224: '7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea',
         sha256:
-            '773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514' +
-            'ced565fe',
+          '773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514' +
+          'ced565fe',
         sha384:
-            '88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e5' +
-            '5966144b2a5ab39dc13814b94e3ab6e101a34f27',
+          '88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e5' +
+          '5966144b2a5ab39dc13814b94e3ab6e101a34f27',
         sha512:
-            'fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33' +
-            'b2279d39bf3e848279a722c806b485a47e67c807b946a337bee89426' +
-            '74278859e13292fb'
+          'fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33' +
+          'b2279d39bf3e848279a722c806b485a47e67c807b946a337bee89426' +
+          '74278859e13292fb'
       }
     },
     {
-      key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819',
-                       'hex'),
-      data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
-                        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd',
-                        'hex'),
+      key: Buffer.from(
+        '0102030405060708090a0b0c0d0e0f10111213141516171819',
+        'hex'
+      ),
+      data: Buffer.from(
+        'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+          'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd',
+        'hex'
+      ),
       hmac: {
         sha224: '6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a',
         sha256:
-            '82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff4' +
-            '6729665b',
+          '82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff4' +
+          '6729665b',
         sha384:
-            '3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e' +
-            '1f573b4e6801dd23c4a7d679ccf8a386c674cffb',
+          '3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e' +
+          '1f573b4e6801dd23c4a7d679ccf8a386c674cffb',
         sha512:
-            'b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050' +
-            '361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2d' +
-            'e2adebeb10a298dd'
+          'b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050' +
+          '361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2d' +
+          'e2adebeb10a298dd'
       }
     },
     {
@@ -161,75 +168,85 @@ assert.throws(function() {
       truncate: true
     },
     {
-      key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaa', 'hex'),
+      key: Buffer.from(
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaa',
+        'hex'
+      ),
       // 'Test Using Larger Than Block-Size Key - Hash Key First'
-      data: Buffer.from('54657374205573696e67204c6172676572205468616e20426' +
-                        'c6f636b2d53697a65204b6579202d2048617368204b657920' +
-                        '4669727374', 'hex'),
+      data: Buffer.from(
+        '54657374205573696e67204c6172676572205468616e20426' +
+          'c6f636b2d53697a65204b6579202d2048617368204b657920' +
+          '4669727374',
+        'hex'
+      ),
       hmac: {
         sha224: '95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e',
         sha256:
-            '60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f' +
-            '0ee37f54',
+          '60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f' +
+          '0ee37f54',
         sha384:
-            '4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05' +
-            '033ac4c60c2ef6ab4030fe8296248df163f44952',
+          '4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05' +
+          '033ac4c60c2ef6ab4030fe8296248df163f44952',
         sha512:
-            '80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b0137' +
-            '83f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec' +
-            '8b915a985d786598'
+          '80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b0137' +
+          '83f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec' +
+          '8b915a985d786598'
       }
     },
     {
-      key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaa', 'hex'),
+      key: Buffer.from(
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaa',
+        'hex'
+      ),
       // 'This is a test using a larger than block-size key and a larger ' +
       // 'than block-size data. The key needs to be hashed before being ' +
       // 'used by the HMAC algorithm.'
-      data: Buffer.from('5468697320697320612074657374207573696e672061206c6' +
-                        '172676572207468616e20626c6f636b2d73697a65206b6579' +
-                        '20616e642061206c6172676572207468616e20626c6f636b2' +
-                        'd73697a6520646174612e20546865206b6579206e65656473' +
-                        '20746f20626520686173686564206265666f7265206265696' +
-                        'e6720757365642062792074686520484d414320616c676f72' +
-                        '6974686d2e', 'hex'),
+      data: Buffer.from(
+        '5468697320697320612074657374207573696e672061206c6' +
+          '172676572207468616e20626c6f636b2d73697a65206b6579' +
+          '20616e642061206c6172676572207468616e20626c6f636b2' +
+          'd73697a6520646174612e20546865206b6579206e65656473' +
+          '20746f20626520686173686564206265666f7265206265696' +
+          'e6720757365642062792074686520484d414320616c676f72' +
+          '6974686d2e',
+        'hex'
+      ),
       hmac: {
         sha224: '3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1',
         sha256:
-            '9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f5153' +
-            '5c3a35e2',
+          '9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f5153' +
+          '5c3a35e2',
         sha384:
-            '6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82' +
-            '461e99c5a678cc31e799176d3860e6110c46523e',
+          '6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82' +
+          '461e99c5a678cc31e799176d3860e6110c46523e',
         sha512:
-            'e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d' +
-            '20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de04460' +
-            '65c97440fa8c6a58'
+          'e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d' +
+          '20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de04460' +
+          '65c97440fa8c6a58'
       }
     }
   ];
 
   for (const testCase of rfc4231) {
     for (const hash in testCase.hmac) {
-      let result = crypto.createHmac(hash, testCase.key)
-                       .update(testCase.data)
-                       .digest('hex');
+      let result = crypto
+        .createHmac(hash, testCase.key)
+        .update(testCase.data)
+        .digest('hex');
       if (testCase.truncate) {
         result = result.substr(0, 32); // first 128 bits == 32 hex chars
       }
-      assert.strictEqual(
-        testCase.hmac[hash],
-        result
-      );
+      assert.strictEqual(testCase.hmac[hash], result);
     }
   }
 }
@@ -249,18 +266,24 @@ assert.throws(function() {
     },
     {
       key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
-      data: Buffer.from('ddddddddddddddddddddddddddddddddddddddddddddddddd' +
-                        'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
-                        'hex'),
+      data: Buffer.from(
+        'ddddddddddddddddddddddddddddddddddddddddddddddddd' +
+          'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
+        'hex'
+      ),
       hmac: '56be34521d144c88dbb8c733f0e8b3f6'
     },
     {
-      key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819',
-                       'hex'),
-      data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
-                        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
-                        'cdcdcdcdcd',
-                        'hex'),
+      key: Buffer.from(
+        '0102030405060708090a0b0c0d0e0f10111213141516171819',
+        'hex'
+      ),
+      data: Buffer.from(
+        'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+          'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
+          'cdcdcdcdcd',
+        'hex'
+      ),
       hmac: '697eaf0aca3a3aea3a75164746ffaa79'
     },
     {
@@ -269,23 +292,27 @@ assert.throws(function() {
       hmac: '56461ef2342edc00f9bab995690efd4c'
     },
     {
-      key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaa',
-                       'hex'),
+      key: Buffer.from(
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaa',
+        'hex'
+      ),
       data: 'Test Using Larger Than Block-Size Key - Hash Key First',
       hmac: '6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd'
     },
     {
-      key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaa',
-                       'hex'),
+      key: Buffer.from(
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaa',
+        'hex'
+      ),
       data:
-          'Test Using Larger Than Block-Size Key and Larger Than One ' +
-          'Block-Size Data',
+        'Test Using Larger Than Block-Size Key and Larger Than One ' +
+        'Block-Size Data',
       hmac: '6f630fad67cda0ee1fb1f562db3aa53e'
     }
   ];
@@ -302,19 +329,25 @@ assert.throws(function() {
     },
     {
       key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
-      data: Buffer.from('ddddddddddddddddddddddddddddddddddddddddddddd' +
-                        'ddddddddddddddddddddddddddddddddddddddddddddd' +
-                        'dddddddddd',
-                        'hex'),
+      data: Buffer.from(
+        'ddddddddddddddddddddddddddddddddddddddddddddd' +
+          'ddddddddddddddddddddddddddddddddddddddddddddd' +
+          'dddddddddd',
+        'hex'
+      ),
       hmac: '125d7342b9ac11cd91a39af48aa17b4f63f175d3'
     },
     {
-      key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819',
-                       'hex'),
-      data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
-                        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
-                        'cdcdcdcdcd',
-                        'hex'),
+      key: Buffer.from(
+        '0102030405060708090a0b0c0d0e0f10111213141516171819',
+        'hex'
+      ),
+      data: Buffer.from(
+        'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+          'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
+          'cdcdcdcdcd',
+        'hex'
+      ),
       hmac: '4c9007f4026250c6bc8414f9bf50c86c2d7235da'
     },
     {
@@ -323,23 +356,27 @@ assert.throws(function() {
       hmac: '4c1a03424b55e07fe7f27be1d58bb9324a9a5a04'
     },
     {
-      key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaa',
-                       'hex'),
+      key: Buffer.from(
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaa',
+        'hex'
+      ),
       data: 'Test Using Larger Than Block-Size Key - Hash Key First',
       hmac: 'aa4ae5e15272d00e95705637ce8a3b55ed402112'
     },
     {
-      key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                       'aaaaaaaaaaaaaaaaaaaaaa',
-                       'hex'),
+      key: Buffer.from(
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+          'aaaaaaaaaaaaaaaaaaaaaa',
+        'hex'
+      ),
       data:
-          'Test Using Larger Than Block-Size Key and Larger Than One ' +
-          'Block-Size Data',
+        'Test Using Larger Than Block-Size Key and Larger Than One ' +
+        'Block-Size Data',
       hmac: 'e8e99d0f45237d786d6bbaa7965c7808bbff1a91'
     }
   ];
@@ -348,7 +385,8 @@ assert.throws(function() {
     for (const testCase of rfc2202_md5) {
       assert.strictEqual(
         testCase.hmac,
-        crypto.createHmac('md5', testCase.key)
+        crypto
+          .createHmac('md5', testCase.key)
           .update(testCase.data)
           .digest('hex')
       );
@@ -357,7 +395,8 @@ assert.throws(function() {
   for (const testCase of rfc2202_sha1) {
     assert.strictEqual(
       testCase.hmac,
-      crypto.createHmac('sha1', testCase.key)
+      crypto
+        .createHmac('sha1', testCase.key)
         .update(testCase.data)
         .digest('hex')
     );
@@ -366,13 +405,28 @@ assert.throws(function() {
 
 // Test hashing
 {
-  const a1 = crypto.createHash('sha1').update('Test123').digest('hex');
-  const a2 = crypto.createHash('sha256').update('Test123').digest('base64');
-  const a3 = crypto.createHash('sha512').update('Test123').digest(); // binary
-  const a4 = crypto.createHash('sha1').update('Test123').digest('buffer');
+  const a1 = crypto
+    .createHash('sha1')
+    .update('Test123')
+    .digest('hex');
+  const a2 = crypto
+    .createHash('sha256')
+    .update('Test123')
+    .digest('base64');
+  const a3 = crypto
+    .createHash('sha512')
+    .update('Test123')
+    .digest(); // binary
+  const a4 = crypto
+    .createHash('sha1')
+    .update('Test123')
+    .digest('buffer');
 
   if (!common.hasFipsCrypto) {
-    const a0 = crypto.createHash('md5').update('Test123').digest('latin1');
+    const a0 = crypto
+      .createHash('md5')
+      .update('Test123')
+      .digest('latin1');
     assert.strictEqual(
       a0,
       'h\u00ea\u00cb\u0097\u00d8o\fF!\u00fa+\u000e\u0017\u00ca\u00bd\u008c'
@@ -386,11 +440,11 @@ assert.throws(function() {
   // Test SHA512 as assumed latin1
   assert.strictEqual(
     a3,
-    '\u00c1(4\u00f1\u0003\u001fd\u0097!O\'\u00d4C/&Qz\u00d4' +
-    '\u0094\u0015l\u00b8\u008dQ+\u00db\u001d\u00c4\u00b5}\u00b2' +
-    '\u00d6\u0092\u00a3\u00df\u00a2i\u00a1\u009b\n\n*\u000f' +
-    '\u00d7\u00d6\u00a2\u00a8\u0085\u00e3<\u0083\u009c\u0093' +
-    '\u00c2\u0006\u00da0\u00a1\u00879(G\u00ed\''
+    "\u00c1(4\u00f1\u0003\u001fd\u0097!O'\u00d4C/&Qz\u00d4" +
+      '\u0094\u0015l\u00b8\u008dQ+\u00db\u001d\u00c4\u00b5}\u00b2' +
+      '\u00d6\u0092\u00a3\u00df\u00a2i\u00a1\u009b\n\n*\u000f' +
+      '\u00d7\u00d6\u00a2\u00a8\u0085\u00e3<\u0083\u009c\u0093' +
+      "\u00c2\u0006\u00da0\u00a1\u00879(G\u00ed'"
   );
 
   assert.deepStrictEqual(
@@ -401,8 +455,14 @@ assert.throws(function() {
 
 // Test multiple updates to same hash
 {
-  const h1 = crypto.createHash('sha1').update('Test123').digest('hex');
-  const h2 = crypto.createHash('sha1').update('Test').update('123')
+  const h1 = crypto
+    .createHash('sha1')
+    .update('Test123')
+    .digest('hex');
+  const h2 = crypto
+    .createHash('sha1')
+    .update('Test')
+    .update('123')
     .digest('hex');
   assert.strictEqual(h1, h2);
 }
@@ -415,12 +475,15 @@ assert.throws(function() {
   fileStream.on('data', function(data) {
     sha1Hash.update(data);
   });
-  fileStream.on('close', common.mustCall(function() {
-    assert.strictEqual(
-      sha1Hash.digest('hex'),
-      '22723e553129a336ad96e10f6aecdf0f45e4149e'
-    );
-  }));
+  fileStream.on(
+    'close',
+    common.mustCall(function() {
+      assert.strictEqual(
+        sha1Hash.digest('hex'),
+        '22723e553129a336ad96e10f6aecdf0f45e4149e'
+      );
+    })
+  );
 }
 
 // Unknown digest method should throw an error:
@@ -431,35 +494,40 @@ assert.throws(function() {
 
 // Test signing and verifying
 {
-  const s1 = crypto.createSign('SHA1')
-                 .update('Test123')
-                 .sign(keyPem, 'base64');
-  const s1Verified = crypto.createVerify('SHA1')
-                         .update('Test')
-                         .update('123')
-                         .verify(certPem, s1, 'base64');
+  const s1 = crypto
+    .createSign('SHA1')
+    .update('Test123')
+    .sign(keyPem, 'base64');
+  const s1Verified = crypto
+    .createVerify('SHA1')
+    .update('Test')
+    .update('123')
+    .verify(certPem, s1, 'base64');
   assert.strictEqual(s1Verified, true);
 
-  const s2 = crypto.createSign('SHA256')
-                 .update('Test123')
-                 .sign(keyPem); // binary
-  const s2Verified = crypto.createVerify('SHA256')
-                         .update('Test')
-                         .update('123')
-                         .verify(certPem, s2); // binary
+  const s2 = crypto
+    .createSign('SHA256')
+    .update('Test123')
+    .sign(keyPem); // binary
+  const s2Verified = crypto
+    .createVerify('SHA256')
+    .update('Test')
+    .update('123')
+    .verify(certPem, s2); // binary
   assert.strictEqual(s2Verified, true);
 
-  const s3 = crypto.createSign('SHA1')
-                 .update('Test123')
-                 .sign(keyPem, 'buffer');
-  const s3Verified = crypto.createVerify('SHA1')
-                         .update('Test')
-                         .update('123')
-                         .verify(certPem, s3);
+  const s3 = crypto
+    .createSign('SHA1')
+    .update('Test123')
+    .sign(keyPem, 'buffer');
+  const s3Verified = crypto
+    .createVerify('SHA1')
+    .update('Test')
+    .update('123')
+    .verify(certPem, s3);
   assert.strictEqual(s3Verified, true);
 }
 
-
 function testCipher1(key) {
   // Test encryption and decryption
   const plaintext = 'Keep this a secret? No! Tell everyone about node.js!';
@@ -478,14 +546,13 @@ function testCipher1(key) {
   assert.strictEqual(txt, plaintext);
 }
 
-
 function testCipher2(key) {
   // encryption and decryption with Base64
   // reported in https://github.com/joyent/node/issues/738
   const plaintext =
-      '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
-      'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
-      'jAfaFg**';
+    '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
+    'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
+    'jAfaFg**';
   const cipher = crypto.createCipher('aes256', key);
 
   // encrypt plaintext which is in utf8 format
@@ -500,13 +567,12 @@ function testCipher2(key) {
   assert.strictEqual(txt, plaintext);
 }
 
-
 function testCipher3(key, iv) {
   // Test encryption and decryption with explicit key and iv
   const plaintext =
-      '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
-      'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
-      'jAfaFg**';
+    '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
+    'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
+    'jAfaFg**';
   const cipher = crypto.createCipheriv('des-ede3-cbc', key, iv);
   let ciph = cipher.update(plaintext, 'utf8', 'hex');
   ciph += cipher.final('hex');
@@ -518,13 +584,12 @@ function testCipher3(key, iv) {
   assert.strictEqual(txt, plaintext);
 }
 
-
 function testCipher4(key, iv) {
   // Test encryption and decryption with explicit key and iv
   const plaintext =
-      '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
-      'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
-      'jAfaFg**';
+    '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
+    'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
+    'jAfaFg**';
   const cipher = crypto.createCipheriv('des-ede3-cbc', key, iv);
   let ciph = cipher.update(plaintext, 'utf8', 'buffer');
   ciph = Buffer.concat([ciph, cipher.final('buffer')]);
@@ -536,13 +601,12 @@ function testCipher4(key, iv) {
   assert.strictEqual(txt, plaintext);
 }
 
-
 function testCipher5(key, iv) {
   // Test encryption and decryption with explicit key with aes128-wrap
   const plaintext =
-      '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
-      'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
-      'jAfaFg**';
+    '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
+    'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
+    'jAfaFg**';
   const cipher = crypto.createCipher('id-aes128-wrap', key);
   let ciph = cipher.update(plaintext, 'utf8', 'buffer');
   ciph = Buffer.concat([ciph, cipher.final('buffer')]);
@@ -571,15 +635,11 @@ testCipher3(Buffer.from('0123456789abcd0123456789'), Buffer.from('12345678'));
 
 testCipher4(Buffer.from('0123456789abcd0123456789'), Buffer.from('12345678'));
 
-
 // update() should only take buffers / strings
-common.expectsError(
-  () => crypto.createHash('sha1').update({ foo: 'bar' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError
-  });
-
+common.expectsError(() => crypto.createHash('sha1').update({ foo: 'bar' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError
+});
 
 // Test Diffie-Hellman with two parties sharing a secret,
 // using various encodings as we go along
@@ -611,10 +671,11 @@ common.expectsError(
   assert.strictEqual(secret1, secret3);
 
   // https://github.com/joyent/node/issues/2338
-  const p = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' +
-            '020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437' +
-            '4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' +
-            'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF';
+  const p =
+    'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' +
+    '020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437' +
+    '4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' +
+    'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF';
   const d = crypto.createDiffieHellman(p, 'hex');
   assert.strictEqual(d.verifyError, DH_NOT_SUITABLE_GENERATOR);
 
@@ -629,10 +690,10 @@ common.expectsError(
   assert.strictEqual(
     rsaSignature,
     '5c50e3145c4e2497aadb0eabc83b342d0b0021ece0d4c4a064b7c' +
-    '8f020d7e2688b122bfb54c724ac9ee169f83f66d2fe90abeb95e8' +
-    'e1290e7e177152a4de3d944cf7d4883114a20ed0f78e70e25ef0f' +
-    '60f06b858e6af42a2f276ede95bbc6bc9a9bbdda15bd663186a6f' +
-    '40819a7af19e577bb2efa5e579a1f5ce8a0d4ca8b8f6'
+      '8f020d7e2688b122bfb54c724ac9ee169f83f66d2fe90abeb95e8' +
+      'e1290e7e177152a4de3d944cf7d4883114a20ed0f78e70e25ef0f' +
+      '60f06b858e6af42a2f276ede95bbc6bc9a9bbdda15bd663186a6f' +
+      '40819a7af19e577bb2efa5e579a1f5ce8a0d4ca8b8f6'
   );
 
   rsaVerify.update(rsaPubPem);
@@ -649,11 +710,11 @@ common.expectsError(
   const input = 'I AM THE WALRUS';
 
   const signature =
-      '79d59d34f56d0e94aa6a3e306882b52ed4191f07521f25f505a078dc2f89' +
-      '396e0c8ac89e996fde5717f4cb89199d8fec249961fcb07b74cd3d2a4ffa' +
-      '235417b69618e4bcd76b97e29975b7ce862299410e1b522a328e44ac9bb2' +
-      '8195e0268da7eda23d9825ac43c724e86ceeee0d0d4465678652ccaf6501' +
-      '0ddfb299bedeb1ad';
+    '79d59d34f56d0e94aa6a3e306882b52ed4191f07521f25f505a078dc2f89' +
+    '396e0c8ac89e996fde5717f4cb89199d8fec249961fcb07b74cd3d2a4ffa' +
+    '235417b69618e4bcd76b97e29975b7ce862299410e1b522a328e44ac9bb2' +
+    '8195e0268da7eda23d9825ac43c724e86ceeee0d0d4465678652ccaf6501' +
+    '0ddfb299bedeb1ad';
 
   const sign = crypto.createSign('SHA256');
   sign.update(input);
@@ -667,7 +728,6 @@ common.expectsError(
   assert.strictEqual(verify.verify(publicKey, signature, 'hex'), true);
 }
 
-
 //
 // Test DSA signing and verification
 //
@@ -689,13 +749,17 @@ common.expectsError(
   assert.strictEqual(verify.verify(publicKey, signature, 'hex'), true);
 }
 
-
 //
 // Test PBKDF2 with RFC 6070 test vectors (except #4)
 //
 function testPBKDF2(password, salt, iterations, keylen, expected) {
-  const actual = crypto.pbkdf2Sync(password, salt, iterations, keylen,
-                                   'sha256');
+  const actual = crypto.pbkdf2Sync(
+    password,
+    salt,
+    iterations,
+    keylen,
+    'sha256'
+  );
   assert.strictEqual(actual, expected);
 
   const cb = common.mustCall((err, actual) => {
@@ -704,26 +768,46 @@ function testPBKDF2(password, salt, iterations, keylen, expected) {
   crypto.pbkdf2(password, salt, iterations, keylen, 'sha256', cb);
 }
 
-
-testPBKDF2('password', 'salt', 1, 20,
-           '\x12\x0f\xb6\xcf\xfc\xf8\xb3\x2c\x43\xe7\x22\x52' +
-           '\x56\xc4\xf8\x37\xa8\x65\x48\xc9');
-
-testPBKDF2('password', 'salt', 2, 20,
-           '\xae\x4d\x0c\x95\xaf\x6b\x46\xd3\x2d\x0a\xdf\xf9' +
-           '\x28\xf0\x6d\xd0\x2a\x30\x3f\x8e');
-
-testPBKDF2('password', 'salt', 4096, 20,
-           '\xc5\xe4\x78\xd5\x92\x88\xc8\x41\xaa\x53\x0d\xb6' +
-           '\x84\x5c\x4c\x8d\x96\x28\x93\xa0');
-
-testPBKDF2('passwordPASSWORDpassword',
-           'saltSALTsaltSALTsaltSALTsaltSALTsalt',
-           4096,
-           25,
-           '\x34\x8c\x89\xdb\xcb\xd3\x2b\x2f\x32\xd8\x14\xb8' +
-           '\x11\x6e\x84\xcf\x2b\x17\x34\x7e\xbc\x18\x00\x18\x1c');
-
-testPBKDF2('pass\0word', 'sa\0lt', 4096, 16,
-           '\x89\xb6\x9d\x05\x16\xf8\x29\x89\x3c\x69\x62\x26' +
-           '\x65\x0a\x86\x87');
+testPBKDF2(
+  'password',
+  'salt',
+  1,
+  20,
+  '\x12\x0f\xb6\xcf\xfc\xf8\xb3\x2c\x43\xe7\x22\x52' +
+    '\x56\xc4\xf8\x37\xa8\x65\x48\xc9'
+);
+
+testPBKDF2(
+  'password',
+  'salt',
+  2,
+  20,
+  '\xae\x4d\x0c\x95\xaf\x6b\x46\xd3\x2d\x0a\xdf\xf9' +
+    '\x28\xf0\x6d\xd0\x2a\x30\x3f\x8e'
+);
+
+testPBKDF2(
+  'password',
+  'salt',
+  4096,
+  20,
+  '\xc5\xe4\x78\xd5\x92\x88\xc8\x41\xaa\x53\x0d\xb6' +
+    '\x84\x5c\x4c\x8d\x96\x28\x93\xa0'
+);
+
+testPBKDF2(
+  'passwordPASSWORDpassword',
+  'saltSALTsaltSALTsaltSALTsaltSALTsalt',
+  4096,
+  25,
+  '\x34\x8c\x89\xdb\xcb\xd3\x2b\x2f\x32\xd8\x14\xb8' +
+    '\x11\x6e\x84\xcf\x2b\x17\x34\x7e\xbc\x18\x00\x18\x1c'
+);
+
+testPBKDF2(
+  'pass\0word',
+  'sa\0lt',
+  4096,
+  16,
+  '\x89\xb6\x9d\x05\x16\xf8\x29\x89\x3c\x69\x62\x26' + '\x65\x0a\x86\x87'
+);
diff --git a/test/parallel/test-crypto-certificate.js b/test/parallel/test-crypto-certificate.js
index a426e0be003da0..e151a4d1af363e 100644
--- a/test/parallel/test-crypto-certificate.js
+++ b/test/parallel/test-crypto-certificate.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -35,7 +34,6 @@ const spkacFail = fixtures.readSync('spkac.fail');
 const spkacPem = fixtures.readSync('spkac.pem');
 
 function checkMethods(certificate) {
-
   assert.strictEqual(certificate.verifySpkac(spkacValid), true);
   assert.strictEqual(certificate.verifySpkac(spkacFail), false);
 
@@ -70,21 +68,20 @@ function stripLineEndings(obj) {
 assert(Certificate() instanceof Certificate);
 
 [1, {}, [], Infinity, true, 'test', undefined, null].forEach((val) => {
-  assert.throws(
-    () => Certificate.verifySpkac(val),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: 'The "spkac" argument must be one of type Buffer, TypedArray, ' +
-               `or DataView. Received type ${typeof val}`
-    }
-  );
+  assert.throws(() => Certificate.verifySpkac(val), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "spkac" argument must be one of type Buffer, TypedArray, ' +
+      `or DataView. Received type ${typeof val}`
+  });
 });
 
 [1, {}, [], Infinity, true, undefined, null].forEach((val) => {
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "spkac" argument must be one of type string, Buffer,' +
-             ` TypedArray, or DataView. Received type ${typeof val}`
+    message:
+      'The "spkac" argument must be one of type string, Buffer,' +
+      ` TypedArray, or DataView. Received type ${typeof val}`
   };
   assert.throws(() => Certificate.exportPublicKey(val), errObj);
   assert.throws(() => Certificate.exportChallenge(val), errObj);
diff --git a/test/parallel/test-crypto-cipher-decipher.js b/test/parallel/test-crypto-cipher-decipher.js
index ed387c3c999026..69ebe98677b780 100644
--- a/test/parallel/test-crypto-cipher-decipher.js
+++ b/test/parallel/test-crypto-cipher-decipher.js
@@ -1,11 +1,9 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (common.hasFipsCrypto)
-  common.skip('not supported in FIPS mode');
+if (common.hasFipsCrypto) common.skip('not supported in FIPS mode');
 
 const crypto = require('crypto');
 const assert = require('assert');
@@ -14,9 +12,7 @@ common.expectWarning({
   Warning: [
     ['Use Cipheriv for counter mode of aes-256-gcm', common.noWarnCode]
   ],
-  DeprecationWarning: [
-    ['crypto.createCipher is deprecated.', 'DEP0106']
-  ]
+  DeprecationWarning: [['crypto.createCipher is deprecated.', 'DEP0106']]
 });
 
 function testCipher1(key) {
@@ -51,14 +47,13 @@ function testCipher1(key) {
   assert.strictEqual(txt, plaintext);
 }
 
-
 function testCipher2(key) {
   // encryption and decryption with Base64
   // reported in https://github.com/joyent/node/issues/738
   const plaintext =
-      '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
-      'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
-      'jAfaFg**';
+    '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
+    'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
+    'jAfaFg**';
   const cipher = crypto.createCipher('aes256', key);
 
   // encrypt plaintext which is in utf8 format
@@ -82,78 +77,83 @@ testCipher2(Buffer.from('0123456789abcdef'));
 {
   const Cipher = crypto.Cipher;
   const instance = crypto.Cipher('aes-256-cbc', 'secret');
-  assert(instance instanceof Cipher, 'Cipher is expected to return a new ' +
-                                     'instance when called without `new`');
-
-  common.expectsError(
-    () => crypto.createCipher(null),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "cipher" argument must be of type string. ' +
-               'Received type object'
-    });
+  assert(
+    instance instanceof Cipher,
+    'Cipher is expected to return a new ' + 'instance when called without `new`'
+  );
 
-  common.expectsError(
-    () => crypto.createCipher('aes-256-cbc', null),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "password" argument must be one of type string, Buffer, ' +
-               'TypedArray, or DataView. Received type object'
-    });
+  common.expectsError(() => crypto.createCipher(null), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "cipher" argument must be of type string. ' + 'Received type object'
+  });
+
+  common.expectsError(() => crypto.createCipher('aes-256-cbc', null), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "password" argument must be one of type string, Buffer, ' +
+      'TypedArray, or DataView. Received type object'
+  });
 
   common.expectsError(
     () => crypto.createCipher('aes-256-cbc', 'secret').update(null),
     {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError,
-      message: 'The "data" argument must be one of type string, Buffer, ' +
-               'TypedArray, or DataView. Received type object'
-    });
+      message:
+        'The "data" argument must be one of type string, Buffer, ' +
+        'TypedArray, or DataView. Received type object'
+    }
+  );
 
   common.expectsError(
     () => crypto.createCipher('aes-256-cbc', 'secret').setAAD(null),
     {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError,
-      message: 'The "buffer" argument must be one of type Buffer, ' +
-               'TypedArray, or DataView. Received type object'
-    });
+      message:
+        'The "buffer" argument must be one of type Buffer, ' +
+        'TypedArray, or DataView. Received type object'
+    }
+  );
 }
 
 {
   const Decipher = crypto.Decipher;
   const instance = crypto.Decipher('aes-256-cbc', 'secret');
-  assert(instance instanceof Decipher, 'Decipher is expected to return a new ' +
-                                       'instance when called without `new`');
+  assert(
+    instance instanceof Decipher,
+    'Decipher is expected to return a new ' +
+      'instance when called without `new`'
+  );
 
-  common.expectsError(
-    () => crypto.createDecipher(null),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "cipher" argument must be of type string. ' +
-               'Received type object'
-    });
+  common.expectsError(() => crypto.createDecipher(null), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "cipher" argument must be of type string. ' + 'Received type object'
+  });
 
   common.expectsError(
     () => crypto.createDecipher('aes-256-cbc', 'secret').setAuthTag(null),
     {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError,
-      message: 'The "buffer" argument must be one of type Buffer, ' +
-               'TypedArray, or DataView. Received type object'
-    });
+      message:
+        'The "buffer" argument must be one of type Buffer, ' +
+        'TypedArray, or DataView. Received type object'
+    }
+  );
 
-  common.expectsError(
-    () => crypto.createDecipher('aes-256-cbc', null),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "password" argument must be one of type string, Buffer, ' +
-               'TypedArray, or DataView. Received type object'
-    });
+  common.expectsError(() => crypto.createDecipher('aes-256-cbc', null), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "password" argument must be one of type string, Buffer, ' +
+      'TypedArray, or DataView. Received type object'
+  });
 }
 
 // Base64 padding regression test, see
@@ -168,13 +168,37 @@ testCipher2(Buffer.from('0123456789abcdef'));
 // not assert. See https://github.com/nodejs/node-v0.x-archive/issues/4886.
 {
   const c = crypto.createCipher('aes-256-cbc', 'secret');
-  try { c.final('xxx'); } catch { /* Ignore. */ }
-  try { c.final('xxx'); } catch { /* Ignore. */ }
-  try { c.final('xxx'); } catch { /* Ignore. */ }
+  try {
+    c.final('xxx');
+  } catch {
+    /* Ignore. */
+  }
+  try {
+    c.final('xxx');
+  } catch {
+    /* Ignore. */
+  }
+  try {
+    c.final('xxx');
+  } catch {
+    /* Ignore. */
+  }
   const d = crypto.createDecipher('aes-256-cbc', 'secret');
-  try { d.final('xxx'); } catch { /* Ignore. */ }
-  try { d.final('xxx'); } catch { /* Ignore. */ }
-  try { d.final('xxx'); } catch { /* Ignore. */ }
+  try {
+    d.final('xxx');
+  } catch {
+    /* Ignore. */
+  }
+  try {
+    d.final('xxx');
+  } catch {
+    /* Ignore. */
+  }
+  try {
+    d.final('xxx');
+  } catch {
+    /* Ignore. */
+  }
 }
 
 // Regression test for https://github.com/nodejs/node-v0.x-archive/issues/5482:
@@ -189,16 +213,16 @@ testCipher2(Buffer.from('0123456789abcdef'));
 // 'utf-8' and 'utf8' are identical.
 {
   let c = crypto.createCipher('aes192', '0123456789abcdef');
-  c.update('update', '');  // Defaults to "utf8".
-  c.final('utf-8');  // Should not throw.
+  c.update('update', ''); // Defaults to "utf8".
+  c.final('utf-8'); // Should not throw.
 
   c = crypto.createCipher('aes192', '0123456789abcdef');
   c.update('update', 'utf8');
-  c.final('utf-8');  // Should not throw.
+  c.final('utf-8'); // Should not throw.
 
   c = crypto.createCipher('aes192', '0123456789abcdef');
   c.update('update', 'utf-8');
-  c.final('utf8');  // Should not throw.
+  c.final('utf8'); // Should not throw.
 }
 
 // Regression tests for https://github.com/nodejs/node/issues/8236.
@@ -248,14 +272,11 @@ testCipher2(Buffer.from('0123456789abcdef'));
   cipher.setAAD(aadbuf);
   cipher.setAutoPadding();
 
-  common.expectsError(
-    () => cipher.getAuthTag(),
-    {
-      code: 'ERR_CRYPTO_INVALID_STATE',
-      type: Error,
-      message: 'Invalid state for operation getAuthTag'
-    }
-  );
+  common.expectsError(() => cipher.getAuthTag(), {
+    code: 'ERR_CRYPTO_INVALID_STATE',
+    type: Error,
+    message: 'Invalid state for operation getAuthTag'
+  });
 
   const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
 
@@ -266,28 +287,21 @@ testCipher2(Buffer.from('0123456789abcdef'));
   decipher.update(encrypted);
   decipher.final();
 
-  common.expectsError(
-    () => decipher.setAAD(aadbuf),
-    {
-      code: 'ERR_CRYPTO_INVALID_STATE',
-      type: Error,
-      message: 'Invalid state for operation setAAD'
-    });
-
-  common.expectsError(
-    () => decipher.setAuthTag(cipher.getAuthTag()),
-    {
-      code: 'ERR_CRYPTO_INVALID_STATE',
-      type: Error,
-      message: 'Invalid state for operation setAuthTag'
-    });
-
-  common.expectsError(
-    () => decipher.setAutoPadding(),
-    {
-      code: 'ERR_CRYPTO_INVALID_STATE',
-      type: Error,
-      message: 'Invalid state for operation setAutoPadding'
-    }
-  );
+  common.expectsError(() => decipher.setAAD(aadbuf), {
+    code: 'ERR_CRYPTO_INVALID_STATE',
+    type: Error,
+    message: 'Invalid state for operation setAAD'
+  });
+
+  common.expectsError(() => decipher.setAuthTag(cipher.getAuthTag()), {
+    code: 'ERR_CRYPTO_INVALID_STATE',
+    type: Error,
+    message: 'Invalid state for operation setAuthTag'
+  });
+
+  common.expectsError(() => decipher.setAutoPadding(), {
+    code: 'ERR_CRYPTO_INVALID_STATE',
+    type: Error,
+    message: 'Invalid state for operation setAutoPadding'
+  });
 }
diff --git a/test/parallel/test-crypto-cipheriv-decipheriv.js b/test/parallel/test-crypto-cipheriv-decipheriv.js
index c0073abcfd4ee9..2a795976e53d89 100644
--- a/test/parallel/test-crypto-cipheriv-decipheriv.js
+++ b/test/parallel/test-crypto-cipheriv-decipheriv.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -9,9 +8,9 @@ const crypto = require('crypto');
 function testCipher1(key, iv) {
   // Test encryption and decryption with explicit key and iv
   const plaintext =
-          '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
-          'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
-          'jAfaFg**';
+    '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
+    'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
+    'jAfaFg**';
   const cipher = crypto.createCipheriv('des-ede3-cbc', key, iv);
   let ciph = cipher.update(plaintext, 'utf8', 'hex');
   ciph += cipher.final('hex');
@@ -20,8 +19,11 @@ function testCipher1(key, iv) {
   let txt = decipher.update(ciph, 'hex', 'utf8');
   txt += decipher.final('utf8');
 
-  assert.strictEqual(txt, plaintext,
-                     `encryption/decryption with key ${key} and iv ${iv}`);
+  assert.strictEqual(
+    txt,
+    plaintext,
+    `encryption/decryption with key ${key} and iv ${iv}`
+  );
 
   // streaming cipher interface
   // NB: In real life, it's not guaranteed that you can get all of it
@@ -35,17 +37,19 @@ function testCipher1(key, iv) {
   dStream.end(ciph);
   txt = dStream.read().toString('utf8');
 
-  assert.strictEqual(txt, plaintext,
-                     `streaming cipher with key ${key} and iv ${iv}`);
+  assert.strictEqual(
+    txt,
+    plaintext,
+    `streaming cipher with key ${key} and iv ${iv}`
+  );
 }
 
-
 function testCipher2(key, iv) {
   // Test encryption and decryption with explicit key and iv
   const plaintext =
-          '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
-          'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
-          'jAfaFg**';
+    '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
+    'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJ' +
+    'jAfaFg**';
   const cipher = crypto.createCipheriv('des-ede3-cbc', key, iv);
   let ciph = cipher.update(plaintext, 'utf8', 'buffer');
   ciph = Buffer.concat([ciph, cipher.final('buffer')]);
@@ -54,11 +58,13 @@ function testCipher2(key, iv) {
   let txt = decipher.update(ciph, 'buffer', 'utf8');
   txt += decipher.final('utf8');
 
-  assert.strictEqual(txt, plaintext,
-                     `encryption/decryption with key ${key} and iv ${iv}`);
+  assert.strictEqual(
+    txt,
+    plaintext,
+    `encryption/decryption with key ${key} and iv ${iv}`
+  );
 }
 
-
 function testCipher3(key, iv) {
   // Test encryption and decryption with explicit key and iv.
   // AES Key Wrap test vector comes from RFC3394
@@ -67,15 +73,19 @@ function testCipher3(key, iv) {
   const cipher = crypto.createCipheriv('id-aes128-wrap', key, iv);
   let ciph = cipher.update(plaintext, 'utf8', 'buffer');
   ciph = Buffer.concat([ciph, cipher.final('buffer')]);
-  const ciph2 = Buffer.from('1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5',
-                            'hex');
+  const ciph2 = Buffer.from(
+    '1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5',
+    'hex'
+  );
   assert(ciph.equals(ciph2));
   const decipher = crypto.createDecipheriv('id-aes128-wrap', key, iv);
   let deciph = decipher.update(ciph, 'buffer');
   deciph = Buffer.concat([deciph, decipher.final()]);
 
-  assert(deciph.equals(plaintext),
-         `encryption/decryption with key ${key} and iv ${iv}`);
+  assert(
+    deciph.equals(plaintext),
+    `encryption/decryption with key ${key} and iv ${iv}`
+  );
 }
 
 {
@@ -84,35 +94,34 @@ function testCipher3(key, iv) {
   const iv = '12345678';
 
   const instance = Cipheriv('des-ede3-cbc', key, iv);
-  assert(instance instanceof Cipheriv, 'Cipheriv is expected to return a new ' +
-                                       'instance when called without `new`');
-
-  common.expectsError(
-    () => crypto.createCipheriv(null),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "cipher" argument must be of type string. ' +
-               'Received type object'
-    });
-
-  common.expectsError(
-    () => crypto.createCipheriv('des-ede3-cbc', null),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "key" argument must be one of type string, Buffer, ' +
-               'TypedArray, or DataView. Received type object'
-    });
-
-  common.expectsError(
-    () => crypto.createCipheriv('des-ede3-cbc', key, 10),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "iv" argument must be one of type string, Buffer, ' +
-               'TypedArray, or DataView. Received type number'
-    });
+  assert(
+    instance instanceof Cipheriv,
+    'Cipheriv is expected to return a new ' +
+      'instance when called without `new`'
+  );
+
+  common.expectsError(() => crypto.createCipheriv(null), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "cipher" argument must be of type string. ' + 'Received type object'
+  });
+
+  common.expectsError(() => crypto.createCipheriv('des-ede3-cbc', null), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "key" argument must be one of type string, Buffer, ' +
+      'TypedArray, or DataView. Received type object'
+  });
+
+  common.expectsError(() => crypto.createCipheriv('des-ede3-cbc', key, 10), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "iv" argument must be one of type string, Buffer, ' +
+      'TypedArray, or DataView. Received type number'
+  });
 }
 
 {
@@ -121,35 +130,34 @@ function testCipher3(key, iv) {
   const iv = '12345678';
 
   const instance = Decipheriv('des-ede3-cbc', key, iv);
-  assert(instance instanceof Decipheriv, 'Decipheriv expected to return a new' +
-                                         ' instance when called without `new`');
-
-  common.expectsError(
-    () => crypto.createDecipheriv(null),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "cipher" argument must be of type string. ' +
-               'Received type object'
-    });
-
-  common.expectsError(
-    () => crypto.createDecipheriv('des-ede3-cbc', null),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "key" argument must be one of type string, Buffer, ' +
-               'TypedArray, or DataView. Received type object'
-    });
-
-  common.expectsError(
-    () => crypto.createDecipheriv('des-ede3-cbc', key, 10),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "iv" argument must be one of type string, Buffer, ' +
-               'TypedArray, or DataView. Received type number'
-    });
+  assert(
+    instance instanceof Decipheriv,
+    'Decipheriv expected to return a new' +
+      ' instance when called without `new`'
+  );
+
+  common.expectsError(() => crypto.createDecipheriv(null), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "cipher" argument must be of type string. ' + 'Received type object'
+  });
+
+  common.expectsError(() => crypto.createDecipheriv('des-ede3-cbc', null), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "key" argument must be one of type string, Buffer, ' +
+      'TypedArray, or DataView. Received type object'
+  });
+
+  common.expectsError(() => crypto.createDecipheriv('des-ede3-cbc', key, 10), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "iv" argument must be one of type string, Buffer, ' +
+      'TypedArray, or DataView. Received type number'
+  });
 }
 
 testCipher1('0123456789abcd0123456789', '12345678');
@@ -159,8 +167,10 @@ testCipher1(Buffer.from('0123456789abcd0123456789'), Buffer.from('12345678'));
 testCipher2(Buffer.from('0123456789abcd0123456789'), Buffer.from('12345678'));
 
 if (!common.hasFipsCrypto) {
-  testCipher3(Buffer.from('000102030405060708090A0B0C0D0E0F', 'hex'),
-              Buffer.from('A6A6A6A6A6A6A6A6', 'hex'));
+  testCipher3(
+    Buffer.from('000102030405060708090A0B0C0D0E0F', 'hex'),
+    Buffer.from('A6A6A6A6A6A6A6A6', 'hex')
+  );
 }
 
 // Zero-sized IV or null should be accepted in ECB mode.
@@ -172,9 +182,10 @@ const errMessage = /Invalid IV length/;
 // But non-empty IVs should be rejected.
 for (let n = 1; n < 256; n += 1) {
   assert.throws(
-    () => crypto.createCipheriv('aes-128-ecb', Buffer.alloc(16),
-                                Buffer.alloc(n)),
-    errMessage);
+    () =>
+      crypto.createCipheriv('aes-128-ecb', Buffer.alloc(16), Buffer.alloc(n)),
+    errMessage
+  );
 }
 
 // Correctly sized IV should be accepted in CBC mode.
@@ -184,9 +195,10 @@ crypto.createCipheriv('aes-128-cbc', Buffer.alloc(16), Buffer.alloc(16));
 for (let n = 0; n < 256; n += 1) {
   if (n === 16) continue;
   assert.throws(
-    () => crypto.createCipheriv('aes-128-cbc', Buffer.alloc(16),
-                                Buffer.alloc(n)),
-    errMessage);
+    () =>
+      crypto.createCipheriv('aes-128-cbc', Buffer.alloc(16), Buffer.alloc(n)),
+    errMessage
+  );
 }
 
 // And so should null be.
@@ -196,9 +208,9 @@ assert.throws(() => {
 
 // Zero-sized IV should be rejected in GCM mode.
 assert.throws(
-  () => crypto.createCipheriv('aes-128-gcm', Buffer.alloc(16),
-                              Buffer.alloc(0)),
-  errMessage);
+  () => crypto.createCipheriv('aes-128-gcm', Buffer.alloc(16), Buffer.alloc(0)),
+  errMessage
+);
 
 // But all other IV lengths should be accepted.
 for (let n = 1; n < 256; n += 1) {
diff --git a/test/parallel/test-crypto-classes.js b/test/parallel/test-crypto-classes.js
index ce4e2922de8062..e44e8e7e09e708 100644
--- a/test/parallel/test-crypto-classes.js
+++ b/test/parallel/test-crypto-classes.js
@@ -10,15 +10,15 @@ const crypto = require('crypto');
 
 // 'ClassName' : ['args', 'for', 'constructor']
 const TEST_CASES = {
-  'Hash': ['sha1'],
-  'Hmac': ['sha1', 'Node'],
-  'Cipheriv': ['des-ede3-cbc', '0123456789abcd0123456789', '12345678'],
-  'Decipheriv': ['des-ede3-cbc', '0123456789abcd0123456789', '12345678'],
-  'Sign': ['RSA-SHA1'],
-  'Verify': ['RSA-SHA1'],
-  'DiffieHellman': [1024],
-  'DiffieHellmanGroup': ['modp5'],
-  'ECDH': ['prime256v1'],
+  Hash: ['sha1'],
+  Hmac: ['sha1', 'Node'],
+  Cipheriv: ['des-ede3-cbc', '0123456789abcd0123456789', '12345678'],
+  Decipheriv: ['des-ede3-cbc', '0123456789abcd0123456789', '12345678'],
+  Sign: ['RSA-SHA1'],
+  Verify: ['RSA-SHA1'],
+  DiffieHellman: [1024],
+  DiffieHellmanGroup: ['modp5'],
+  ECDH: ['prime256v1']
 };
 
 if (!common.hasFipsCrypto) {
diff --git a/test/parallel/test-crypto-des3-wrap.js b/test/parallel/test-crypto-des3-wrap.js
index 75c8cd574fd662..ec145af4c59ff0 100644
--- a/test/parallel/test-crypto-des3-wrap.js
+++ b/test/parallel/test-crypto-des3-wrap.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -11,7 +10,8 @@ const crypto = require('crypto');
 const test = {
   key: Buffer.from('3c08e25be22352910671cfe4ba3652b1220a8a7769b490ba', 'hex'),
   iv: Buffer.alloc(0),
-  plaintext: '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBG' +
+  plaintext:
+    '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBG' +
     'WWELweCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZU' +
     'JjAfaFg**'
 };
diff --git a/test/parallel/test-crypto-dh-leak.js b/test/parallel/test-crypto-dh-leak.js
index 9ba8d29e155dc6..ff6c02697fda6d 100644
--- a/test/parallel/test-crypto-dh-leak.js
+++ b/test/parallel/test-crypto-dh-leak.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
diff --git a/test/parallel/test-crypto-dh-odd-key.js b/test/parallel/test-crypto-dh-odd-key.js
index d5410daca6fb23..1b1d161d52c40c 100644
--- a/test/parallel/test-crypto-dh-odd-key.js
+++ b/test/parallel/test-crypto-dh-odd-key.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -39,5 +38,7 @@ function test() {
 if (!common.hasFipsCrypto) {
   test();
 } else {
-  assert.throws(function() { test(); }, /key size too small/);
+  assert.throws(function() {
+    test();
+  }, /key size too small/);
 }
diff --git a/test/parallel/test-crypto-dh-padding.js b/test/parallel/test-crypto-dh-padding.js
index 311b9d156ff174..255e3b5cbda53a 100644
--- a/test/parallel/test-crypto-dh-padding.js
+++ b/test/parallel/test-crypto-dh-padding.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('node compiled without OpenSSL.');
+if (!common.hasCrypto) common.skip('node compiled without OpenSSL.');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -65,7 +64,7 @@ const crypto = require('crypto');
  */
 
 const apub =
-'5484455905d3eff34c70980e871f27f05448e66f5a6efbb97cbcba4e927196c2bd9ea272cded91\
+  '5484455905d3eff34c70980e871f27f05448e66f5a6efbb97cbcba4e927196c2bd9ea272cded91\
 10a4977afa8d9b16c9139a444ed2d954a794650e5d7cb525204f385e1af81530518563822ecd0f9\
 524a958d02b3c269e79d6d69850f0968ad567a4404fbb0b19efc8bc73e267b6136b88cafb33299f\
 f7c7cace3ffab1a88c2c9ee841f88b4c3679b4efc465f5c93cca11d487be57373e4c5926f634c4e\
@@ -73,7 +72,7 @@ efee6721d01db91cd66321615b2522f96368dbc818875d422140d0edf30bdb97d9721feddcb9ff6\
 453741a4f687ee46fc54bf1198801f1210ac789879a5ee123f79e2d2ce1209df2445d32166bc9e4\
 8f89e944ec9c3b2e16c8066cd8eebd4e33eb941';
 const bpub =
-'3fca64510e36bc7da8a3a901c7b74c2eabfa25deaf7cbe1d0c50235866136ad677317279e1fb0\
+  '3fca64510e36bc7da8a3a901c7b74c2eabfa25deaf7cbe1d0c50235866136ad677317279e1fb0\
 06e9c0a07f63e14a3363c8e016fbbde2b2c7e79fed1cc3e08e95f7459f547a8cd0523ee9dc744d\
 e5a956d92b937db4448917e1f6829437f05e408ee7aea70c0362b37370c7c75d14449d8b2d2133\
 04ac972302d349975e2265ca7103cfebd019d9e91234d638611abd049014f7abf706c1c5da6c88\
@@ -81,7 +80,7 @@ e5a956d92b937db4448917e1f6829437f05e408ee7aea70c0362b37370c7c75d14449d8b2d2133\
 6e8ac97f5be1a5b68f20382f2a7dac189cf169325c4cf845b26a0cd616c31fec905c5d9035e5f7\
 8e9880c812374ac0f3ca3d365f06e4be526b5affd4b79';
 const apriv =
-'62411e34704637d99c6c958a7db32ac22fcafafbe1c33d2cfdb76e12ded41f38fc16b792b9041\
+  '62411e34704637d99c6c958a7db32ac22fcafafbe1c33d2cfdb76e12ded41f38fc16b792b9041\
 2e4c82755a3815ba52f780f0ee296ad46e348fc4d1dcd6b64f4eea1b231b2b7d95c5b1c2e26d34\
 83520558b9860a6eb668f01422a54e6604aa7702b4e67511397ef3ecb912bff1a83899c5a5bfb2\
 0ee29249a91b8a698e62486f7009a0e9eaebda69d77ecfa2ca6ba2db6c8aa81759c8c90c675979\
@@ -89,7 +88,7 @@ const apriv =
 7012f68255207722355634290acc7fddeefbba75650a85ece95b6a12de67eac016ba78960108dd\
 5dbadfaa43cc9fed515a1f307b7d90ae0623bc7b8cefb';
 const secret =
-'00c37b1e06a436d6717816a40e6d72907a6f255638b93032267dcb9a5f0b4a9aa0236f3dce63b\
+  '00c37b1e06a436d6717816a40e6d72907a6f255638b93032267dcb9a5f0b4a9aa0236f3dce63b\
 1c418c60978a00acd1617dfeecf1661d8a3fafb4d0d8824386750f4853313400e7e4afd22847e4\
 fa56bc9713872021265111906673b38db83d10cbfa1dea3b6b4c97c8655f4ae82125281af7f234\
 8916a15c6f95649367d169d587697480df4d10b381479e86d5518b520d9d8fb764084eab518224\
@@ -99,12 +98,10 @@ dc8fe984ddaf532fc1531ce43155fa0ab32532bf1ece5356b8a3447b5267798a904f16f3f4e635\
 
 /* FIPS-friendly 2048 bit prime */
 const p = crypto.createDiffieHellman(
-  crypto.getDiffieHellman('modp14').getPrime());
+  crypto.getDiffieHellman('modp14').getPrime()
+);
 
 p.setPublicKey(apub, 'hex');
 p.setPrivateKey(apriv, 'hex');
 
-assert.strictEqual(
-  p.computeSecret(bpub, 'hex', 'hex').toString('hex'),
-  secret
-);
+assert.strictEqual(p.computeSecret(bpub, 'hex', 'hex').toString('hex'), secret);
diff --git a/test/parallel/test-crypto-dh.js b/test/parallel/test-crypto-dh.js
index 8e584100d9913b..e469557f1d0844 100644
--- a/test/parallel/test-crypto-dh.js
+++ b/test/parallel/test-crypto-dh.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -25,40 +24,41 @@ assert.strictEqual(dh2.verifyError, 0);
 {
   const DiffieHellman = crypto.DiffieHellman;
   const dh = DiffieHellman(p1, 'buffer');
-  assert(dh instanceof DiffieHellman, 'DiffieHellman is expected to return a ' +
-                                      'new instance when called without `new`');
+  assert(
+    dh instanceof DiffieHellman,
+    'DiffieHellman is expected to return a ' +
+      'new instance when called without `new`'
+  );
 }
 
 {
   const DiffieHellmanGroup = crypto.DiffieHellmanGroup;
   const dhg = DiffieHellmanGroup('modp5');
-  assert(dhg instanceof DiffieHellmanGroup, 'DiffieHellmanGroup is expected ' +
-                                            'to return a new instance when ' +
-                                            'called without `new`');
+  assert(
+    dhg instanceof DiffieHellmanGroup,
+    'DiffieHellmanGroup is expected ' +
+      'to return a new instance when ' +
+      'called without `new`'
+  );
 }
 
 {
   const ECDH = crypto.ECDH;
   const ecdh = ECDH('prime256v1');
-  assert(ecdh instanceof ECDH, 'ECDH is expected to return a new instance ' +
-                               'when called without `new`');
+  assert(
+    ecdh instanceof ECDH,
+    'ECDH is expected to return a new instance ' + 'when called without `new`'
+  );
 }
 
-[
-  [0x1, 0x2],
-  () => { },
-  /abc/,
-  {}
-].forEach((input) => {
-  common.expectsError(
-    () => crypto.createDiffieHellman(input),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "sizeOrKey" argument must be one of type number, string, ' +
-               `Buffer, TypedArray, or DataView. Received type ${typeof input}`
-    }
-  );
+[[0x1, 0x2], () => {}, /abc/, {}].forEach((input) => {
+  common.expectsError(() => crypto.createDiffieHellman(input), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "sizeOrKey" argument must be one of type number, string, ' +
+      `Buffer, TypedArray, or DataView. Received type ${typeof input}`
+  });
 });
 
 // Create "another dh1" using generated keys from dh1,
@@ -91,8 +91,7 @@ const secret4 = dh4.computeSecret(key2, 'hex', 'base64');
 
 assert.strictEqual(secret1, secret4);
 
-const wrongBlockLength =
-  /^Error: error:0606506D:digital envelope routines:EVP_DecryptFinal_ex:wrong final block length$/;
+const wrongBlockLength = /^Error: error:0606506D:digital envelope routines:EVP_DecryptFinal_ex:wrong final block length$/;
 
 // Run this one twice to make sure that the dh3 clears its error properly
 {
@@ -129,29 +128,146 @@ assert.strictEqual(bob.verifyError, DH_NOT_SUITABLE_GENERATOR);
  * RFC 2412 E.2, see https://tools.ietf.org/html/rfc2412. */
 const modp2 = crypto.createDiffieHellmanGroup('modp2');
 const modp2buf = Buffer.from([
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f,
-  0xda, 0xa2, 0x21, 0x68, 0xc2, 0x34, 0xc4, 0xc6, 0x62, 0x8b,
-  0x80, 0xdc, 0x1c, 0xd1, 0x29, 0x02, 0x4e, 0x08, 0x8a, 0x67,
-  0xcc, 0x74, 0x02, 0x0b, 0xbe, 0xa6, 0x3b, 0x13, 0x9b, 0x22,
-  0x51, 0x4a, 0x08, 0x79, 0x8e, 0x34, 0x04, 0xdd, 0xef, 0x95,
-  0x19, 0xb3, 0xcd, 0x3a, 0x43, 0x1b, 0x30, 0x2b, 0x0a, 0x6d,
-  0xf2, 0x5f, 0x14, 0x37, 0x4f, 0xe1, 0x35, 0x6d, 0x6d, 0x51,
-  0xc2, 0x45, 0xe4, 0x85, 0xb5, 0x76, 0x62, 0x5e, 0x7e, 0xc6,
-  0xf4, 0x4c, 0x42, 0xe9, 0xa6, 0x37, 0xed, 0x6b, 0x0b, 0xff,
-  0x5c, 0xb6, 0xf4, 0x06, 0xb7, 0xed, 0xee, 0x38, 0x6b, 0xfb,
-  0x5a, 0x89, 0x9f, 0xa5, 0xae, 0x9f, 0x24, 0x11, 0x7c, 0x4b,
-  0x1f, 0xe6, 0x49, 0x28, 0x66, 0x51, 0xec, 0xe6, 0x53, 0x81,
-  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xc9,
+  0x0f,
+  0xda,
+  0xa2,
+  0x21,
+  0x68,
+  0xc2,
+  0x34,
+  0xc4,
+  0xc6,
+  0x62,
+  0x8b,
+  0x80,
+  0xdc,
+  0x1c,
+  0xd1,
+  0x29,
+  0x02,
+  0x4e,
+  0x08,
+  0x8a,
+  0x67,
+  0xcc,
+  0x74,
+  0x02,
+  0x0b,
+  0xbe,
+  0xa6,
+  0x3b,
+  0x13,
+  0x9b,
+  0x22,
+  0x51,
+  0x4a,
+  0x08,
+  0x79,
+  0x8e,
+  0x34,
+  0x04,
+  0xdd,
+  0xef,
+  0x95,
+  0x19,
+  0xb3,
+  0xcd,
+  0x3a,
+  0x43,
+  0x1b,
+  0x30,
+  0x2b,
+  0x0a,
+  0x6d,
+  0xf2,
+  0x5f,
+  0x14,
+  0x37,
+  0x4f,
+  0xe1,
+  0x35,
+  0x6d,
+  0x6d,
+  0x51,
+  0xc2,
+  0x45,
+  0xe4,
+  0x85,
+  0xb5,
+  0x76,
+  0x62,
+  0x5e,
+  0x7e,
+  0xc6,
+  0xf4,
+  0x4c,
+  0x42,
+  0xe9,
+  0xa6,
+  0x37,
+  0xed,
+  0x6b,
+  0x0b,
+  0xff,
+  0x5c,
+  0xb6,
+  0xf4,
+  0x06,
+  0xb7,
+  0xed,
+  0xee,
+  0x38,
+  0x6b,
+  0xfb,
+  0x5a,
+  0x89,
+  0x9f,
+  0xa5,
+  0xae,
+  0x9f,
+  0x24,
+  0x11,
+  0x7c,
+  0x4b,
+  0x1f,
+  0xe6,
+  0x49,
+  0x28,
+  0x66,
+  0x51,
+  0xec,
+  0xe6,
+  0x53,
+  0x81,
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xff,
+  0xff
 ]);
 
 {
   const exmodp2 = crypto.createDiffieHellman(modp2buf, Buffer.from([2]));
   modp2.generateKeys();
   exmodp2.generateKeys();
-  const modp2Secret = modp2.computeSecret(exmodp2.getPublicKey())
-      .toString('hex');
-  const exmodp2Secret = exmodp2.computeSecret(modp2.getPublicKey())
-      .toString('hex');
+  const modp2Secret = modp2
+    .computeSecret(exmodp2.getPublicKey())
+    .toString('hex');
+  const exmodp2Secret = exmodp2
+    .computeSecret(modp2.getPublicKey())
+    .toString('hex');
   assert.strictEqual(modp2Secret, exmodp2Secret);
   assert.strictEqual(modp2.verifyError, DH_NOT_SUITABLE_GENERATOR);
   assert.strictEqual(exmodp2.verifyError, DH_NOT_SUITABLE_GENERATOR);
@@ -162,10 +278,12 @@ for (const buf of [modp2buf, ...common.getArrayBufferViews(modp2buf)]) {
   // any ArrayBufferViews as the first argument to createDiffieHellman().
   const exmodp2 = crypto.createDiffieHellman(buf, '02', 'hex');
   exmodp2.generateKeys();
-  const modp2Secret = modp2.computeSecret(exmodp2.getPublicKey())
-      .toString('hex');
-  const exmodp2Secret = exmodp2.computeSecret(modp2.getPublicKey())
-      .toString('hex');
+  const modp2Secret = modp2
+    .computeSecret(exmodp2.getPublicKey())
+    .toString('hex');
+  const exmodp2Secret = exmodp2
+    .computeSecret(modp2.getPublicKey())
+    .toString('hex');
   assert.strictEqual(modp2Secret, exmodp2Secret);
   assert.strictEqual(exmodp2.verifyError, DH_NOT_SUITABLE_GENERATOR);
 }
@@ -174,10 +292,12 @@ for (const buf of [modp2buf, ...common.getArrayBufferViews(modp2buf)]) {
   // Ensure specific generator (string without encoding) works as expected.
   const exmodp2 = crypto.createDiffieHellman(modp2buf, '\x02');
   exmodp2.generateKeys();
-  const modp2Secret = modp2.computeSecret(exmodp2.getPublicKey())
-      .toString('hex');
-  const exmodp2Secret = exmodp2.computeSecret(modp2.getPublicKey())
-      .toString('hex');
+  const modp2Secret = modp2
+    .computeSecret(exmodp2.getPublicKey())
+    .toString('hex');
+  const exmodp2Secret = exmodp2
+    .computeSecret(modp2.getPublicKey())
+    .toString('hex');
   assert.strictEqual(modp2Secret, exmodp2Secret);
   assert.strictEqual(exmodp2.verifyError, DH_NOT_SUITABLE_GENERATOR);
 }
@@ -186,23 +306,24 @@ for (const buf of [modp2buf, ...common.getArrayBufferViews(modp2buf)]) {
   // Ensure specific generator (numeric) works as expected.
   const exmodp2 = crypto.createDiffieHellman(modp2buf, 2);
   exmodp2.generateKeys();
-  const modp2Secret = modp2.computeSecret(exmodp2.getPublicKey())
-      .toString('hex');
-  const exmodp2Secret = exmodp2.computeSecret(modp2.getPublicKey())
-      .toString('hex');
+  const modp2Secret = modp2
+    .computeSecret(exmodp2.getPublicKey())
+    .toString('hex');
+  const exmodp2Secret = exmodp2
+    .computeSecret(modp2.getPublicKey())
+    .toString('hex');
   assert.strictEqual(modp2Secret, exmodp2Secret);
   assert.strictEqual(exmodp2.verifyError, DH_NOT_SUITABLE_GENERATOR);
 }
 
-
-const p = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' +
-          '020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437' +
-          '4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' +
-          'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF';
+const p =
+  'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' +
+  '020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437' +
+  '4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' +
+  'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF';
 const bad_dh = crypto.createDiffieHellman(p, 'hex');
 assert.strictEqual(bad_dh.verifyError, DH_NOT_SUITABLE_GENERATOR);
 
-
 const availableCurves = new Set(crypto.getCurves());
 const availableHashes = new Set(crypto.getHashes());
 
@@ -232,25 +353,21 @@ if (availableCurves.has('prime256v1') && availableCurves.has('secp256k1')) {
   assert(firstByte === 6 || firstByte === 7);
   // format value should be string
 
-  common.expectsError(
-    () => ecdh1.getPublicKey('buffer', 10),
-    {
-      code: 'ERR_CRYPTO_ECDH_INVALID_FORMAT',
-      type: TypeError,
-      message: 'Invalid ECDH format: 10'
-    });
+  common.expectsError(() => ecdh1.getPublicKey('buffer', 10), {
+    code: 'ERR_CRYPTO_ECDH_INVALID_FORMAT',
+    type: TypeError,
+    message: 'Invalid ECDH format: 10'
+  });
 
   // ECDH should check that point is on curve
   const ecdh3 = crypto.createECDH('secp256k1');
   const key3 = ecdh3.generateKeys();
 
-  common.expectsError(
-    () => ecdh2.computeSecret(key3, 'latin1', 'buffer'),
-    {
-      code: 'ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY',
-      type: Error,
-      message: 'Public key is not valid for specified curve'
-    });
+  common.expectsError(() => ecdh2.computeSecret(key3, 'latin1', 'buffer'), {
+    code: 'ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY',
+    type: Error,
+    message: 'Public key is not valid for specified curve'
+  });
 
   // ECDH should allow .setPrivateKey()/.setPublicKey()
   const ecdh4 = crypto.createECDH('prime256v1');
@@ -278,10 +395,10 @@ if (availableCurves.has('prime256v1') && availableCurves.has('secp256k1')) {
   const cafebabeKey = 'cafebabe'.repeat(8);
   // Associated compressed and uncompressed public keys (points).
   const cafebabePubPtComp =
-  '03672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3';
+    '03672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3';
   const cafebabePubPtUnComp =
-  '04672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3' +
-  '2e02c7f93d13dc2732b760ca377a5897b9dd41a1c1b29dc0442fdce6d0a04d1d';
+    '04672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3' +
+    '2e02c7f93d13dc2732b760ca377a5897b9dd41a1c1b29dc0442fdce6d0a04d1d';
   ecdh5.setPrivateKey(cafebabeKey, 'hex');
   assert.strictEqual(ecdh5.getPrivateKey('hex'), cafebabeKey);
   // Show that the public point (key) is generated while setting the
@@ -292,18 +409,22 @@ if (availableCurves.has('prime256v1') && availableCurves.has('secp256k1')) {
   // private key.
   // 0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF
   const peerPubPtComp =
-  '02c6b754b20826eb925e052ee2c25285b162b51fdca732bcf67e39d647fb6830ae';
+    '02c6b754b20826eb925e052ee2c25285b162b51fdca732bcf67e39d647fb6830ae';
   const peerPubPtUnComp =
-  '04c6b754b20826eb925e052ee2c25285b162b51fdca732bcf67e39d647fb6830ae' +
-  'b651944a574a362082a77e3f2b5d9223eb54d7f2f76846522bf75f3bedb8178e';
+    '04c6b754b20826eb925e052ee2c25285b162b51fdca732bcf67e39d647fb6830ae' +
+    'b651944a574a362082a77e3f2b5d9223eb54d7f2f76846522bf75f3bedb8178e';
 
   const sharedSecret =
-  '1da220b5329bbe8bfd19ceef5a5898593f411a6f12ea40f2a8eead9a5cf59970';
+    '1da220b5329bbe8bfd19ceef5a5898593f411a6f12ea40f2a8eead9a5cf59970';
 
-  assert.strictEqual(ecdh5.computeSecret(peerPubPtComp, 'hex', 'hex'),
-                     sharedSecret);
-  assert.strictEqual(ecdh5.computeSecret(peerPubPtUnComp, 'hex', 'hex'),
-                     sharedSecret);
+  assert.strictEqual(
+    ecdh5.computeSecret(peerPubPtComp, 'hex', 'hex'),
+    sharedSecret
+  );
+  assert.strictEqual(
+    ecdh5.computeSecret(peerPubPtUnComp, 'hex', 'hex'),
+    sharedSecret
+  );
 
   // Verify that we still have the same key pair as before the computation.
   assert.strictEqual(ecdh5.getPrivateKey('hex'), cafebabeKey);
@@ -338,9 +459,10 @@ if (availableCurves.has('prime256v1') && availableCurves.has('secp256k1')) {
 
   // Some invalid private keys for the secp256k1 curve.
   const errMessage = /^Error: Private key is not valid for specified curve\.$/;
-  ['0000000000000000000000000000000000000000000000000000000000000000',
-   'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141',
-   'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
+  [
+    '0000000000000000000000000000000000000000000000000000000000000000',
+    'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141',
+    'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'
   ].forEach((element) => {
     assert.throws(() => {
       ecdh5.setPrivateKey(element, 'hex');
@@ -357,13 +479,11 @@ if (availableCurves.has('prime256v1') && availableHashes.has('sha256')) {
   const invalidKey = Buffer.alloc(65);
   invalidKey.fill('\0');
   curve.generateKeys();
-  common.expectsError(
-    () => curve.computeSecret(invalidKey),
-    {
-      code: 'ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY',
-      type: Error,
-      message: 'Public key is not valid for specified curve'
-    });
+  common.expectsError(() => curve.computeSecret(invalidKey), {
+    code: 'ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY',
+    type: Error,
+    message: 'Public key is not valid for specified curve'
+  });
   // Check that signing operations are not impacted by the above error.
   const ecPrivateKey =
     '-----BEGIN EC PRIVATE KEY-----\n' +
@@ -375,11 +495,9 @@ if (availableCurves.has('prime256v1') && availableHashes.has('sha256')) {
 }
 
 // invalid test: curve argument is undefined
-common.expectsError(
-  () => crypto.createECDH(),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "curve" argument must be of type string. ' +
-             'Received type undefined'
-  });
+common.expectsError(() => crypto.createECDH(), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "curve" argument must be of type string. ' + 'Received type undefined'
+});
diff --git a/test/parallel/test-crypto-domain.js b/test/parallel/test-crypto-domain.js
index 62e2be4c0f39c2..91d24769f8eeb0 100644
--- a/test/parallel/test-crypto-domain.js
+++ b/test/parallel/test-crypto-domain.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -31,9 +30,12 @@ const domain = require('domain');
 const test = (fn) => {
   const ex = new Error('BAM');
   const d = domain.create();
-  d.on('error', common.mustCall(function(err) {
-    assert.strictEqual(err, ex);
-  }));
+  d.on(
+    'error',
+    common.mustCall(function(err) {
+      assert.strictEqual(err, ex);
+    })
+  );
   const cb = common.mustCall(function() {
     throw ex;
   });
diff --git a/test/parallel/test-crypto-domains.js b/test/parallel/test-crypto-domains.js
index be87cad6ff6ff7..05e4a49d112622 100644
--- a/test/parallel/test-crypto-domains.js
+++ b/test/parallel/test-crypto-domains.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const domain = require('domain');
 const assert = require('assert');
@@ -31,9 +30,12 @@ const crypto = require('crypto');
 const d = domain.create();
 const expect = ['pbkdf2', 'randomBytes', 'pseudoRandomBytes'];
 
-d.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.message, expect.shift());
-}, 3));
+d.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.message, expect.shift());
+  }, 3)
+);
 
 d.run(function() {
   one();
diff --git a/test/parallel/test-crypto-ecb.js b/test/parallel/test-crypto-ecb.js
index c88ebaabb05e7f..ce5fc2403760c6 100644
--- a/test/parallel/test-crypto-ecb.js
+++ b/test/parallel/test-crypto-ecb.js
@@ -21,11 +21,9 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (common.hasFipsCrypto)
-  common.skip('BF-ECB is not FIPS 140-2 compatible');
+if (common.hasFipsCrypto) common.skip('BF-ECB is not FIPS 140-2 compatible');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -34,16 +32,22 @@ const crypto = require('crypto');
 // Reference: bug#1997
 
 {
-  const encrypt =
-    crypto.createCipheriv('BF-ECB', 'SomeRandomBlahz0c5GZVnR', '');
+  const encrypt = crypto.createCipheriv(
+    'BF-ECB',
+    'SomeRandomBlahz0c5GZVnR',
+    ''
+  );
   let hex = encrypt.update('Hello World!', 'ascii', 'hex');
   hex += encrypt.final('hex');
   assert.strictEqual(hex.toUpperCase(), '6D385F424AAB0CFBF0BB86E07FFB7D71');
 }
 
 {
-  const decrypt =
-    crypto.createDecipheriv('BF-ECB', 'SomeRandomBlahz0c5GZVnR', '');
+  const decrypt = crypto.createDecipheriv(
+    'BF-ECB',
+    'SomeRandomBlahz0c5GZVnR',
+    ''
+  );
   let msg = decrypt.update('6D385F424AAB0CFBF0BB86E07FFB7D71', 'hex', 'ascii');
   msg += decrypt.final('ascii');
   assert.strictEqual(msg, 'Hello World!');
diff --git a/test/parallel/test-crypto-ecdh-convert-key.js b/test/parallel/test-crypto-ecdh-convert-key.js
index 407178a1953250..fa17047ee75788 100644
--- a/test/parallel/test-crypto-ecdh-convert-key.js
+++ b/test/parallel/test-crypto-ecdh-convert-key.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 
@@ -11,34 +10,28 @@ const { ECDH, getCurves } = require('crypto');
 const cafebabeKey = 'cafebabe'.repeat(8);
 // Associated compressed and uncompressed public keys (points).
 const cafebabePubPtComp =
-    '03672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3';
+  '03672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3';
 const cafebabePubPtUnComp =
-    '04672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3' +
-    '2e02c7f93d13dc2732b760ca377a5897b9dd41a1c1b29dc0442fdce6d0a04d1d';
+  '04672a31bfc59d3f04548ec9b7daeeba2f61814e8ccc40448045007f5479f693a3' +
+  '2e02c7f93d13dc2732b760ca377a5897b9dd41a1c1b29dc0442fdce6d0a04d1d';
 
 // Invalid test: key argument is undefined.
-common.expectsError(
-  () => ECDH.convertKey(),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-  });
+common.expectsError(() => ECDH.convertKey(), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError
+});
 
 // Invalid test: curve argument is undefined.
-common.expectsError(
-  () => ECDH.convertKey(cafebabePubPtComp),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-  });
+common.expectsError(() => ECDH.convertKey(cafebabePubPtComp), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError
+});
 
 // Invalid test: curve argument is invalid.
-common.expectsError(
-  () => ECDH.convertKey(cafebabePubPtComp, 'badcurve'),
-  {
-    type: TypeError,
-    message: 'Invalid ECDH curve name'
-  });
+common.expectsError(() => ECDH.convertKey(cafebabePubPtComp, 'badcurve'), {
+  type: TypeError,
+  message: 'Invalid ECDH curve name'
+});
 
 if (getCurves().includes('secp256k1')) {
   // Invalid test: format argument is undefined.
@@ -48,24 +41,31 @@ if (getCurves().includes('secp256k1')) {
       code: 'ERR_CRYPTO_ECDH_INVALID_FORMAT',
       type: TypeError,
       message: 'Invalid ECDH format: 10'
-    });
+    }
+  );
 
   // Point formats.
-  let uncompressed = ECDH.convertKey(cafebabePubPtComp,
-                                     'secp256k1',
-                                     'hex',
-                                     'buffer',
-                                     'uncompressed');
-  let compressed = ECDH.convertKey(cafebabePubPtComp,
-                                   'secp256k1',
-                                   'hex',
-                                   'buffer',
-                                   'compressed');
-  let hybrid = ECDH.convertKey(cafebabePubPtComp,
-                               'secp256k1',
-                               'hex',
-                               'buffer',
-                               'hybrid');
+  let uncompressed = ECDH.convertKey(
+    cafebabePubPtComp,
+    'secp256k1',
+    'hex',
+    'buffer',
+    'uncompressed'
+  );
+  let compressed = ECDH.convertKey(
+    cafebabePubPtComp,
+    'secp256k1',
+    'hex',
+    'buffer',
+    'compressed'
+  );
+  let hybrid = ECDH.convertKey(
+    cafebabePubPtComp,
+    'secp256k1',
+    'hex',
+    'buffer',
+    'hybrid'
+  );
   assert.strictEqual(uncompressed[0], 4);
   let firstByte = compressed[0];
   assert(firstByte === 2 || firstByte === 3);
@@ -73,21 +73,27 @@ if (getCurves().includes('secp256k1')) {
   assert(firstByte === 6 || firstByte === 7);
 
   // Format conversion from hex to hex
-  uncompressed = ECDH.convertKey(cafebabePubPtComp,
-                                 'secp256k1',
-                                 'hex',
-                                 'hex',
-                                 'uncompressed');
-  compressed = ECDH.convertKey(cafebabePubPtComp,
-                               'secp256k1',
-                               'hex',
-                               'hex',
-                               'compressed');
-  hybrid = ECDH.convertKey(cafebabePubPtComp,
-                           'secp256k1',
-                           'hex',
-                           'hex',
-                           'hybrid');
+  uncompressed = ECDH.convertKey(
+    cafebabePubPtComp,
+    'secp256k1',
+    'hex',
+    'hex',
+    'uncompressed'
+  );
+  compressed = ECDH.convertKey(
+    cafebabePubPtComp,
+    'secp256k1',
+    'hex',
+    'hex',
+    'compressed'
+  );
+  hybrid = ECDH.convertKey(
+    cafebabePubPtComp,
+    'secp256k1',
+    'hex',
+    'hex',
+    'hybrid'
+  );
   assert.strictEqual(uncompressed, cafebabePubPtUnComp);
   assert.strictEqual(compressed, cafebabePubPtComp);
 
diff --git a/test/parallel/test-crypto-engine.js b/test/parallel/test-crypto-engine.js
index ca76672de8dc95..c9a0574b83b8ca 100644
--- a/test/parallel/test-crypto-engine.js
+++ b/test/parallel/test-crypto-engine.js
@@ -1,35 +1,28 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const crypto = require('crypto');
 const invalidEngineName = 'xxx';
 
-common.expectsError(
-  () => crypto.setEngine(true),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "id" argument must be of type string. Received type boolean'
-  });
+common.expectsError(() => crypto.setEngine(true), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'The "id" argument must be of type string. Received type boolean'
+});
 
-common.expectsError(
-  () => crypto.setEngine('/path/to/engine', 'notANumber'),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "flags" argument must be of type number. Received type string'
-  });
+common.expectsError(() => crypto.setEngine('/path/to/engine', 'notANumber'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'The "flags" argument must be of type number. Received type string'
+});
 
-common.expectsError(
-  () => crypto.setEngine(invalidEngineName),
-  {
-    code: 'ERR_CRYPTO_ENGINE_UNKNOWN',
-    type: Error,
-    message: `Engine "${invalidEngineName}" was not found`
-  });
+common.expectsError(() => crypto.setEngine(invalidEngineName), {
+  code: 'ERR_CRYPTO_ENGINE_UNKNOWN',
+  type: Error,
+  message: `Engine "${invalidEngineName}" was not found`
+});
 
 common.expectsError(
   () => crypto.setEngine(invalidEngineName, crypto.constants.ENGINE_METHOD_RSA),
@@ -37,4 +30,5 @@ common.expectsError(
     code: 'ERR_CRYPTO_ENGINE_UNKNOWN',
     type: Error,
     message: `Engine "${invalidEngineName}" was not found`
-  });
+  }
+);
diff --git a/test/parallel/test-crypto-fips.js b/test/parallel/test-crypto-fips.js
index 2003c390b94c5b..3bbc3fed48ac68 100644
--- a/test/parallel/test-crypto-fips.js
+++ b/test/parallel/test-crypto-fips.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const spawnSync = require('child_process').spawnSync;
@@ -39,8 +38,12 @@ function testHelper(stream, args, expectedOutput, cmd, env) {
   });
 
   console.error(
-    `Spawned child [pid:${child.pid}] with cmd '${cmd}' expect %j with args '${
-      args}' OPENSSL_CONF=%j`, expectedOutput, env.OPENSSL_CONF);
+    `Spawned child [pid:${
+      child.pid
+    }] with cmd '${cmd}' expect %j with args '${args}' OPENSSL_CONF=%j`,
+    expectedOutput,
+    env.OPENSSL_CONF
+  );
 
   function childOk(child) {
     console.error(`Child #${++num_children_ok} [pid:${child.pid}] OK.`);
@@ -68,7 +71,8 @@ testHelper(
   [],
   FIPS_DISABLED,
   'require("crypto").getFips()',
-  Object.assign({}, process.env, { 'OPENSSL_CONF': '' }));
+  Object.assign({}, process.env, { OPENSSL_CONF: '' })
+);
 
 // --enable-fips should turn FIPS mode on
 testHelper(
@@ -76,7 +80,8 @@ testHelper(
   ['--enable-fips'],
   compiledWithFips() ? FIPS_ENABLED : OPTION_ERROR_STRING,
   'require("crypto").getFips()',
-  process.env);
+  process.env
+);
 
 // --force-fips should turn FIPS mode on
 testHelper(
@@ -84,7 +89,8 @@ testHelper(
   ['--force-fips'],
   compiledWithFips() ? FIPS_ENABLED : OPTION_ERROR_STRING,
   'require("crypto").getFips()',
-  process.env);
+  process.env
+);
 
 // If Node was configured using --shared-openssl fips support might be
 // available depending on how OpenSSL was built. If fips support is
@@ -105,7 +111,8 @@ if (!sharedOpenSSL()) {
     [`--openssl-config=${CNF_FIPS_ON}`],
     compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
     'require("crypto").getFips()',
-    process.env);
+    process.env
+  );
 
   // OPENSSL_CONF should be able to turn on FIPS mode
   testHelper(
@@ -113,7 +120,8 @@ if (!sharedOpenSSL()) {
     [],
     compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
     'require("crypto").getFips()',
-    Object.assign({}, process.env, { 'OPENSSL_CONF': CNF_FIPS_ON }));
+    Object.assign({}, process.env, { OPENSSL_CONF: CNF_FIPS_ON })
+  );
 
   // --openssl-config option should override OPENSSL_CONF
   testHelper(
@@ -121,7 +129,8 @@ if (!sharedOpenSSL()) {
     [`--openssl-config=${CNF_FIPS_ON}`],
     compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
     'require("crypto").getFips()',
-    Object.assign({}, process.env, { 'OPENSSL_CONF': CNF_FIPS_OFF }));
+    Object.assign({}, process.env, { OPENSSL_CONF: CNF_FIPS_OFF })
+  );
 }
 
 testHelper(
@@ -129,7 +138,8 @@ testHelper(
   [`--openssl-config=${CNF_FIPS_OFF}`],
   FIPS_DISABLED,
   'require("crypto").getFips()',
-  Object.assign({}, process.env, { 'OPENSSL_CONF': CNF_FIPS_ON }));
+  Object.assign({}, process.env, { OPENSSL_CONF: CNF_FIPS_ON })
+);
 
 // --enable-fips should take precedence over OpenSSL config file
 testHelper(
@@ -137,7 +147,8 @@ testHelper(
   ['--enable-fips', `--openssl-config=${CNF_FIPS_OFF}`],
   compiledWithFips() ? FIPS_ENABLED : OPTION_ERROR_STRING,
   'require("crypto").getFips()',
-  process.env);
+  process.env
+);
 
 // OPENSSL_CONF should _not_ make a difference to --enable-fips
 testHelper(
@@ -145,7 +156,8 @@ testHelper(
   ['--enable-fips'],
   compiledWithFips() ? FIPS_ENABLED : OPTION_ERROR_STRING,
   'require("crypto").getFips()',
-  Object.assign({}, process.env, { 'OPENSSL_CONF': CNF_FIPS_OFF }));
+  Object.assign({}, process.env, { OPENSSL_CONF: CNF_FIPS_OFF })
+);
 
 // --force-fips should take precedence over OpenSSL config file
 testHelper(
@@ -153,7 +165,8 @@ testHelper(
   ['--force-fips', `--openssl-config=${CNF_FIPS_OFF}`],
   compiledWithFips() ? FIPS_ENABLED : OPTION_ERROR_STRING,
   'require("crypto").getFips()',
-  process.env);
+  process.env
+);
 
 // Using OPENSSL_CONF should not make a difference to --force-fips
 testHelper(
@@ -161,16 +174,17 @@ testHelper(
   ['--force-fips'],
   compiledWithFips() ? FIPS_ENABLED : OPTION_ERROR_STRING,
   'require("crypto").getFips()',
-  Object.assign({}, process.env, { 'OPENSSL_CONF': CNF_FIPS_OFF }));
+  Object.assign({}, process.env, { OPENSSL_CONF: CNF_FIPS_OFF })
+);
 
 // setFipsCrypto should be able to turn FIPS mode on
 testHelper(
   compiledWithFips() ? 'stdout' : 'stderr',
   [],
   compiledWithFips() ? FIPS_ENABLED : FIPS_ERROR_STRING,
-  '(require("crypto").setFips(true),' +
-  'require("crypto").getFips())',
-  process.env);
+  '(require("crypto").setFips(true),' + 'require("crypto").getFips())',
+  process.env
+);
 
 // setFipsCrypto should be able to turn FIPS mode on and off
 testHelper(
@@ -178,36 +192,37 @@ testHelper(
   [],
   compiledWithFips() ? FIPS_DISABLED : FIPS_ERROR_STRING,
   '(require("crypto").setFips(true),' +
-  'require("crypto").setFips(false),' +
-  'require("crypto").getFips())',
-  process.env);
+    'require("crypto").setFips(false),' +
+    'require("crypto").getFips())',
+  process.env
+);
 
 // setFipsCrypto takes precedence over OpenSSL config file, FIPS on
 testHelper(
   compiledWithFips() ? 'stdout' : 'stderr',
   [`--openssl-config=${CNF_FIPS_OFF}`],
   compiledWithFips() ? FIPS_ENABLED : FIPS_ERROR_STRING,
-  '(require("crypto").setFips(true),' +
-  'require("crypto").getFips())',
-  process.env);
+  '(require("crypto").setFips(true),' + 'require("crypto").getFips())',
+  process.env
+);
 
 // setFipsCrypto takes precedence over OpenSSL config file, FIPS off
 testHelper(
   compiledWithFips() ? 'stdout' : 'stderr',
   [`--openssl-config=${CNF_FIPS_ON}`],
   compiledWithFips() ? FIPS_DISABLED : FIPS_ERROR_STRING,
-  '(require("crypto").setFips(false),' +
-  'require("crypto").getFips())',
-  process.env);
+  '(require("crypto").setFips(false),' + 'require("crypto").getFips())',
+  process.env
+);
 
 // --enable-fips does not prevent use of setFipsCrypto API
 testHelper(
   compiledWithFips() ? 'stdout' : 'stderr',
   ['--enable-fips'],
   compiledWithFips() ? FIPS_DISABLED : OPTION_ERROR_STRING,
-  '(require("crypto").setFips(false),' +
-  'require("crypto").getFips())',
-  process.env);
+  '(require("crypto").setFips(false),' + 'require("crypto").getFips())',
+  process.env
+);
 
 // --force-fips prevents use of setFipsCrypto API
 testHelper(
@@ -215,16 +230,17 @@ testHelper(
   ['--force-fips'],
   compiledWithFips() ? FIPS_ERROR_STRING2 : OPTION_ERROR_STRING,
   'require("crypto").setFips(false)',
-  process.env);
+  process.env
+);
 
 // --force-fips makes setFipsCrypto enable a no-op (FIPS stays on)
 testHelper(
   compiledWithFips() ? 'stdout' : 'stderr',
   ['--force-fips'],
   compiledWithFips() ? FIPS_ENABLED : OPTION_ERROR_STRING,
-  '(require("crypto").setFips(true),' +
-  'require("crypto").getFips())',
-  process.env);
+  '(require("crypto").setFips(true),' + 'require("crypto").getFips())',
+  process.env
+);
 
 // --force-fips and --enable-fips order does not matter
 testHelper(
@@ -232,7 +248,8 @@ testHelper(
   ['--force-fips', '--enable-fips'],
   compiledWithFips() ? FIPS_ERROR_STRING2 : OPTION_ERROR_STRING,
   'require("crypto").setFips(false)',
-  process.env);
+  process.env
+);
 
 // --enable-fips and --force-fips order does not matter
 testHelper(
@@ -240,4 +257,5 @@ testHelper(
   ['--enable-fips', '--force-fips'],
   compiledWithFips() ? FIPS_ERROR_STRING2 : OPTION_ERROR_STRING,
   'require("crypto").setFips(false)',
-  process.env);
+  process.env
+);
diff --git a/test/parallel/test-crypto-from-binary.js b/test/parallel/test-crypto-from-binary.js
index 435e0d82da5396..a0b8691afc1e8c 100644
--- a/test/parallel/test-crypto-from-binary.js
+++ b/test/parallel/test-crypto-from-binary.js
@@ -23,15 +23,13 @@
 // This is the same as test/simple/test-crypto, but from before the shift
 // to use buffers by default.
 
-
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
 
-const EXTERN_APEX = 0xFBEE9;
+const EXTERN_APEX = 0xfbee9;
 
 // manually controlled string for checking binary output
 let ucs2_control = 'a\u0000';
@@ -41,7 +39,6 @@ while (ucs2_control.length <= EXTERN_APEX) {
   ucs2_control = ucs2_control.repeat(2);
 }
 
-
 // check resultant buffer and output string
 const b = Buffer.from(ucs2_control + ucs2_control, 'ucs2');
 
@@ -50,16 +47,24 @@ const b = Buffer.from(ucs2_control + ucs2_control, 'ucs2');
 //
 {
   const datum1 = b.slice(700000);
-  const hash1_converted = crypto.createHash('sha1')
+  const hash1_converted = crypto
+    .createHash('sha1')
     .update(datum1.toString('base64'), 'base64')
     .digest('hex');
-  const hash1_direct = crypto.createHash('sha1').update(datum1).digest('hex');
+  const hash1_direct = crypto
+    .createHash('sha1')
+    .update(datum1)
+    .digest('hex');
   assert.strictEqual(hash1_direct, hash1_converted);
 
   const datum2 = b;
-  const hash2_converted = crypto.createHash('sha1')
+  const hash2_converted = crypto
+    .createHash('sha1')
     .update(datum2.toString('base64'), 'base64')
     .digest('hex');
-  const hash2_direct = crypto.createHash('sha1').update(datum2).digest('hex');
+  const hash2_direct = crypto
+    .createHash('sha1')
+    .update(datum2)
+    .digest('hex');
   assert.strictEqual(hash2_direct, hash2_converted);
 }
diff --git a/test/parallel/test-crypto-hash-stream-pipe.js b/test/parallel/test-crypto-hash-stream-pipe.js
index 0a240a2abbc7ef..b82cb7c2c97712 100644
--- a/test/parallel/test-crypto-hash-stream-pipe.js
+++ b/test/parallel/test-crypto-hash-stream-pipe.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -33,8 +32,13 @@ const s = new stream.PassThrough();
 const h = crypto.createHash('sha1');
 const expect = '15987e60950cf22655b9323bc1e281f9c4aff47e';
 
-s.pipe(h).on('data', common.mustCall(function(c) {
-  assert.strictEqual(c, expect);
-})).setEncoding('hex');
+s.pipe(h)
+  .on(
+    'data',
+    common.mustCall(function(c) {
+      assert.strictEqual(c, expect);
+    })
+  )
+  .setEncoding('hex');
 
 s.end('aoeu');
diff --git a/test/parallel/test-crypto-hash.js b/test/parallel/test-crypto-hash.js
index ec35cad7e8960c..39307803196e2a 100644
--- a/test/parallel/test-crypto-hash.js
+++ b/test/parallel/test-crypto-hash.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -13,10 +12,22 @@ let cryptoType;
 let digest;
 
 // Test hashing
-const a1 = crypto.createHash('sha1').update('Test123').digest('hex');
-const a2 = crypto.createHash('sha256').update('Test123').digest('base64');
-const a3 = crypto.createHash('sha512').update('Test123').digest(); // buffer
-const a4 = crypto.createHash('sha1').update('Test123').digest('buffer');
+const a1 = crypto
+  .createHash('sha1')
+  .update('Test123')
+  .digest('hex');
+const a2 = crypto
+  .createHash('sha256')
+  .update('Test123')
+  .digest('base64');
+const a3 = crypto
+  .createHash('sha512')
+  .update('Test123')
+  .digest(); // buffer
+const a4 = crypto
+  .createHash('sha1')
+  .update('Test123')
+  .digest('buffer');
 
 // stream interface
 let a5 = crypto.createHash('sha512');
@@ -42,7 +53,10 @@ a8 = a8.read();
 if (!common.hasFipsCrypto) {
   cryptoType = 'md5';
   digest = 'latin1';
-  const a0 = crypto.createHash(cryptoType).update('Test123').digest(digest);
+  const a0 = crypto
+    .createHash(cryptoType)
+    .update('Test123')
+    .digest(digest);
   assert.strictEqual(
     a0,
     'h\u00ea\u00cb\u0097\u00d8o\fF!\u00fa+\u000e\u0017\u00ca\u00bd\u008c',
@@ -54,25 +68,29 @@ digest = 'hex';
 assert.strictEqual(
   a1,
   '8308651804facb7b9af8ffc53a33a22d6a1c8ac2',
-  `${cryptoType} with ${digest} digest failed to evaluate to expected hash`);
+  `${cryptoType} with ${digest} digest failed to evaluate to expected hash`
+);
 cryptoType = 'sha256';
 digest = 'base64';
 assert.strictEqual(
   a2,
   '2bX1jws4GYKTlxhloUB09Z66PoJZW+y+hq5R8dnx9l4=',
-  `${cryptoType} with ${digest} digest failed to evaluate to expected hash`);
+  `${cryptoType} with ${digest} digest failed to evaluate to expected hash`
+);
 cryptoType = 'sha512';
 digest = 'latin1';
 assert.deepStrictEqual(
   a3,
   Buffer.from(
-    '\u00c1(4\u00f1\u0003\u001fd\u0097!O\'\u00d4C/&Qz\u00d4' +
-    '\u0094\u0015l\u00b8\u008dQ+\u00db\u001d\u00c4\u00b5}\u00b2' +
-    '\u00d6\u0092\u00a3\u00df\u00a2i\u00a1\u009b\n\n*\u000f' +
-    '\u00d7\u00d6\u00a2\u00a8\u0085\u00e3<\u0083\u009c\u0093' +
-    '\u00c2\u0006\u00da0\u00a1\u00879(G\u00ed\'',
-    'latin1'),
-  `${cryptoType} with ${digest} digest failed to evaluate to expected hash`);
+    "\u00c1(4\u00f1\u0003\u001fd\u0097!O'\u00d4C/&Qz\u00d4" +
+      '\u0094\u0015l\u00b8\u008dQ+\u00db\u001d\u00c4\u00b5}\u00b2' +
+      '\u00d6\u0092\u00a3\u00df\u00a2i\u00a1\u009b\n\n*\u000f' +
+      '\u00d7\u00d6\u00a2\u00a8\u0085\u00e3<\u0083\u009c\u0093' +
+      "\u00c2\u0006\u00da0\u00a1\u00879(G\u00ed'",
+    'latin1'
+  ),
+  `${cryptoType} with ${digest} digest failed to evaluate to expected hash`
+);
 cryptoType = 'sha1';
 digest = 'hex';
 assert.deepStrictEqual(
@@ -88,8 +106,15 @@ assert.notStrictEqual(a7, undefined);
 assert.notStrictEqual(a8, undefined);
 
 // Test multiple updates to same hash
-const h1 = crypto.createHash('sha1').update('Test123').digest('hex');
-const h2 = crypto.createHash('sha1').update('Test').update('123').digest('hex');
+const h1 = crypto
+  .createHash('sha1')
+  .update('Test123')
+  .digest('hex');
+const h2 = crypto
+  .createHash('sha1')
+  .update('Test')
+  .update('123')
+  .digest('hex');
 assert.strictEqual(h1, h2);
 
 // Test hashing for binary files
@@ -99,11 +124,16 @@ const fileStream = fs.createReadStream(fn);
 fileStream.on('data', function(data) {
   sha1Hash.update(data);
 });
-fileStream.on('close', common.mustCall(function() {
-  // Test SHA1 of sample.png
-  assert.strictEqual(sha1Hash.digest('hex'),
-                     '22723e553129a336ad96e10f6aecdf0f45e4149e');
-}));
+fileStream.on(
+  'close',
+  common.mustCall(function() {
+    // Test SHA1 of sample.png
+    assert.strictEqual(
+      sha1Hash.digest('hex'),
+      '22723e553129a336ad96e10f6aecdf0f45e4149e'
+    );
+  })
+);
 
 // Issue https://github.com/nodejs/node-v0.x-archive/issues/2227: unknown digest
 // method should throw an error.
@@ -112,54 +142,55 @@ assert.throws(function() {
 }, /Digest method not supported/);
 
 // Default UTF-8 encoding
-const hutf8 = crypto.createHash('sha512').update('УТФ-8 text').digest('hex');
+const hutf8 = crypto
+  .createHash('sha512')
+  .update('УТФ-8 text')
+  .digest('hex');
 assert.strictEqual(
   hutf8,
   '4b21bbd1a68e690a730ddcb5a8bc94ead9879ffe82580767ad7ec6fa8ba2dea6' +
-        '43a821af66afa9a45b6a78c712fecf0e56dc7f43aef4bcfc8eb5b4d8dca6ea5b');
+    '43a821af66afa9a45b6a78c712fecf0e56dc7f43aef4bcfc8eb5b4d8dca6ea5b'
+);
 
 assert.notStrictEqual(
   hutf8,
-  crypto.createHash('sha512').update('УТФ-8 text', 'latin1').digest('hex'));
+  crypto
+    .createHash('sha512')
+    .update('УТФ-8 text', 'latin1')
+    .digest('hex')
+);
 
 const h3 = crypto.createHash('sha256');
 h3.digest();
 
-common.expectsError(
-  () => h3.digest(),
-  {
-    code: 'ERR_CRYPTO_HASH_FINALIZED',
-    type: Error
-  });
-
-common.expectsError(
-  () => h3.update('foo'),
-  {
-    code: 'ERR_CRYPTO_HASH_FINALIZED',
-    type: Error
-  });
-
-common.expectsError(
-  () => crypto.createHash('sha256').digest('ucs2'),
-  {
-    code: 'ERR_CRYPTO_HASH_DIGEST_NO_UTF16',
-    type: Error
-  }
-);
+common.expectsError(() => h3.digest(), {
+  code: 'ERR_CRYPTO_HASH_FINALIZED',
+  type: Error
+});
 
-common.expectsError(
-  () => crypto.createHash(),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "algorithm" argument must be of type string. ' +
-             'Received type undefined'
-  }
-);
+common.expectsError(() => h3.update('foo'), {
+  code: 'ERR_CRYPTO_HASH_FINALIZED',
+  type: Error
+});
+
+common.expectsError(() => crypto.createHash('sha256').digest('ucs2'), {
+  code: 'ERR_CRYPTO_HASH_DIGEST_NO_UTF16',
+  type: Error
+});
+
+common.expectsError(() => crypto.createHash(), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "algorithm" argument must be of type string. ' +
+    'Received type undefined'
+});
 
 {
   const Hash = crypto.Hash;
   const instance = crypto.Hash('sha256');
-  assert(instance instanceof Hash, 'Hash is expected to return a new instance' +
-                                   ' when called without `new`');
+  assert(
+    instance instanceof Hash,
+    'Hash is expected to return a new instance' + ' when called without `new`'
+  );
 }
diff --git a/test/parallel/test-crypto-hmac.js b/test/parallel/test-crypto-hmac.js
index 223b5c3c077251..bb6fe939a28f1c 100644
--- a/test/parallel/test-crypto-hmac.js
+++ b/test/parallel/test-crypto-hmac.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -9,92 +8,98 @@ const crypto = require('crypto');
 {
   const Hmac = crypto.Hmac;
   const instance = crypto.Hmac('sha256', 'Node');
-  assert(instance instanceof Hmac, 'Hmac is expected to return a new instance' +
-                                   ' when called without `new`');
+  assert(
+    instance instanceof Hmac,
+    'Hmac is expected to return a new instance' + ' when called without `new`'
+  );
 }
 
-common.expectsError(
-  () => crypto.createHmac(null),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "hmac" argument must be of type string. Received type object'
-  });
+common.expectsError(() => crypto.createHmac(null), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'The "hmac" argument must be of type string. Received type object'
+});
 
-common.expectsError(
-  () => crypto.createHmac('sha1', null),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "key" argument must be one of type string, TypedArray, or ' +
-             'DataView. Received type object'
-  });
+common.expectsError(() => crypto.createHmac('sha1', null), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "key" argument must be one of type string, TypedArray, or ' +
+    'DataView. Received type object'
+});
 
 {
   // Test HMAC
-  const actual = crypto.createHmac('sha1', 'Node')
+  const actual = crypto
+    .createHmac('sha1', 'Node')
     .update('some data')
     .update('to hmac')
     .digest('hex');
   const expected = '19fd6e1ba73d9ed2224dd5094a71babe85d9a892';
-  assert.strictEqual(actual,
-                     expected,
-                     `Test HMAC: ${actual} must be ${expected}`);
+  assert.strictEqual(
+    actual,
+    expected,
+    `Test HMAC: ${actual} must be ${expected}`
+  );
 }
 
 // Test HMAC (Wikipedia Test Cases)
 const wikipedia = [
   {
-    key: 'key', data: 'The quick brown fox jumps over the lazy dog',
-    hmac: {  // HMACs lifted from Wikipedia.
+    key: 'key',
+    data: 'The quick brown fox jumps over the lazy dog',
+    hmac: {
+      // HMACs lifted from Wikipedia.
       md5: '80070713463e7749b90c2dc24911e275',
       sha1: 'de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9',
       sha256:
-          'f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc' +
-          '2d1a3cd8'
+        'f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc' + '2d1a3cd8'
     }
   },
   {
-    key: 'key', data: '',
-    hmac: {  // Intermediate test to help debugging.
+    key: 'key',
+    data: '',
+    hmac: {
+      // Intermediate test to help debugging.
       md5: '63530468a04e386459855da0063b6596',
       sha1: 'f42bb0eeb018ebbd4597ae7213711ec60760843f',
       sha256:
-          '5d5d139563c95b5967b9bd9a8c9b233a9dedb45072794cd232dc1b74' +
-          '832607d0'
+        '5d5d139563c95b5967b9bd9a8c9b233a9dedb45072794cd232dc1b74' + '832607d0'
     }
   },
   {
-    key: '', data: 'The quick brown fox jumps over the lazy dog',
-    hmac: {  // Intermediate test to help debugging.
+    key: '',
+    data: 'The quick brown fox jumps over the lazy dog',
+    hmac: {
+      // Intermediate test to help debugging.
       md5: 'ad262969c53bc16032f160081c4a07a0',
       sha1: '2ba7f707ad5f187c412de3106583c3111d668de8',
       sha256:
-          'fb011e6154a19b9a4c767373c305275a5a69e8b68b0b4c9200c383dc' +
-          'ed19a416'
+        'fb011e6154a19b9a4c767373c305275a5a69e8b68b0b4c9200c383dc' + 'ed19a416'
     }
   },
   {
-    key: '', data: '',
-    hmac: {  // HMACs lifted from Wikipedia.
+    key: '',
+    data: '',
+    hmac: {
+      // HMACs lifted from Wikipedia.
       md5: '74e6f7298a9c2d168935f58c001bad88',
       sha1: 'fbdb1d1b18aa6c08324b7d64b71fb76370690e1d',
       sha256:
-          'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c71214' +
-          '4292c5ad'
+        'b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c71214' + '4292c5ad'
     }
-  },
+  }
 ];
 
 for (let i = 0, l = wikipedia.length; i < l; i++) {
   for (const hash in wikipedia[i].hmac) {
     // FIPS does not support MD5.
-    if (common.hasFipsCrypto && hash === 'md5')
-      continue;
+    if (common.hasFipsCrypto && hash === 'md5') continue;
     const expected = wikipedia[i].hmac[hash];
-    const actual = crypto.createHmac(hash, wikipedia[i].key)
-                         .update(wikipedia[i].data)
-                         .digest('hex');
+    const actual = crypto
+      .createHmac(hash, wikipedia[i].key)
+      .update(wikipedia[i].data)
+      .digest('hex');
     assert.strictEqual(
       actual,
       expected,
@@ -103,7 +108,6 @@ for (let i = 0, l = wikipedia.length; i < l; i++) {
   }
 }
 
-
 // Test HMAC-SHA-* (rfc 4231 Test Cases)
 const rfc4231 = [
   {
@@ -112,72 +116,76 @@ const rfc4231 = [
     hmac: {
       sha224: '896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22',
       sha256:
-          'b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c' +
-          '2e32cff7',
+        'b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c' + '2e32cff7',
       sha384:
-          'afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c' +
-          '7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6',
+        'afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c' +
+        '7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6',
       sha512:
-          '87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b305' +
-          '45e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f170' +
-          '2e696c203a126854'
+        '87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b305' +
+        '45e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f170' +
+        '2e696c203a126854'
     }
   },
   {
     key: Buffer.from('4a656665', 'hex'), // 'Jefe'
-    data: Buffer.from('7768617420646f2079612077616e7420666f72206e6f74686' +
-                     '96e673f', 'hex'), // 'what do ya want for nothing?'
+    data: Buffer.from(
+      '7768617420646f2079612077616e7420666f72206e6f74686' + '96e673f',
+      'hex'
+    ), // 'what do ya want for nothing?'
     hmac: {
       sha224: 'a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44',
       sha256:
-          '5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b9' +
-          '64ec3843',
+        '5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b9' + '64ec3843',
       sha384:
-          'af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec373' +
-          '6322445e8e2240ca5e69e2c78b3239ecfab21649',
+        'af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec373' +
+        '6322445e8e2240ca5e69e2c78b3239ecfab21649',
       sha512:
-          '164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7' +
-          'ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b' +
-          '636e070a38bce737'
+        '164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7' +
+        'ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b' +
+        '636e070a38bce737'
     }
   },
   {
     key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
-    data: Buffer.from('ddddddddddddddddddddddddddddddddddddddddddddddddd' +
-                     'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
-                      'hex'),
+    data: Buffer.from(
+      'ddddddddddddddddddddddddddddddddddddddddddddddddd' +
+        'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
+      'hex'
+    ),
     hmac: {
       sha224: '7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea',
       sha256:
-          '773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514' +
-          'ced565fe',
+        '773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514' + 'ced565fe',
       sha384:
-          '88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e5' +
-          '5966144b2a5ab39dc13814b94e3ab6e101a34f27',
+        '88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e5' +
+        '5966144b2a5ab39dc13814b94e3ab6e101a34f27',
       sha512:
-          'fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33' +
-          'b2279d39bf3e848279a722c806b485a47e67c807b946a337bee89426' +
-          '74278859e13292fb'
+        'fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33' +
+        'b2279d39bf3e848279a722c806b485a47e67c807b946a337bee89426' +
+        '74278859e13292fb'
     }
   },
   {
-    key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819',
-                     'hex'),
-    data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
-                     'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd',
-                      'hex'),
+    key: Buffer.from(
+      '0102030405060708090a0b0c0d0e0f10111213141516171819',
+      'hex'
+    ),
+    data: Buffer.from(
+      'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd',
+      'hex'
+    ),
     hmac: {
       sha224: '6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a',
       sha256:
-          '82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff4' +
-          '6729665b',
+        '82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff4' + '6729665b',
       sha384:
-          '3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e' +
-          '1f573b4e6801dd23c4a7d679ccf8a386c674cffb',
+        '3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e' +
+        '1f573b4e6801dd23c4a7d679ccf8a386c674cffb',
       sha512:
-          'b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050' +
-          '361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2d' +
-          'e2adebeb10a298dd'
+        'b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050' +
+        '361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2d' +
+        'e2adebeb10a298dd'
     }
   },
 
@@ -194,59 +202,69 @@ const rfc4231 = [
     truncate: true
   },
   {
-    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaa', 'hex'),
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaa',
+      'hex'
+    ),
     // 'Test Using Larger Than Block-Size Key - Hash Key First'
-    data: Buffer.from('54657374205573696e67204c6172676572205468616e20426' +
-                     'c6f636b2d53697a65204b6579202d2048617368204b657920' +
-                     '4669727374', 'hex'),
+    data: Buffer.from(
+      '54657374205573696e67204c6172676572205468616e20426' +
+        'c6f636b2d53697a65204b6579202d2048617368204b657920' +
+        '4669727374',
+      'hex'
+    ),
     hmac: {
       sha224: '95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e',
       sha256:
-          '60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f' +
-          '0ee37f54',
+        '60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f' + '0ee37f54',
       sha384:
-          '4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05' +
-          '033ac4c60c2ef6ab4030fe8296248df163f44952',
+        '4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05' +
+        '033ac4c60c2ef6ab4030fe8296248df163f44952',
       sha512:
-          '80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b0137' +
-          '83f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec' +
-          '8b915a985d786598'
+        '80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b0137' +
+        '83f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec' +
+        '8b915a985d786598'
     }
   },
   {
-    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaa', 'hex'),
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaa',
+      'hex'
+    ),
     // 'This is a test using a larger than block-size key and a larger ' +
     // 'than block-size data. The key needs to be hashed before being ' +
     // 'used by the HMAC algorithm.'
-    data: Buffer.from('5468697320697320612074657374207573696e672061206c6' +
-                     '172676572207468616e20626c6f636b2d73697a65206b6579' +
-                     '20616e642061206c6172676572207468616e20626c6f636b2' +
-                     'd73697a6520646174612e20546865206b6579206e65656473' +
-                     '20746f20626520686173686564206265666f7265206265696' +
-                     'e6720757365642062792074686520484d414320616c676f72' +
-                     '6974686d2e', 'hex'),
+    data: Buffer.from(
+      '5468697320697320612074657374207573696e672061206c6' +
+        '172676572207468616e20626c6f636b2d73697a65206b6579' +
+        '20616e642061206c6172676572207468616e20626c6f636b2' +
+        'd73697a6520646174612e20546865206b6579206e65656473' +
+        '20746f20626520686173686564206265666f7265206265696' +
+        'e6720757365642062792074686520484d414320616c676f72' +
+        '6974686d2e',
+      'hex'
+    ),
     hmac: {
       sha224: '3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1',
       sha256:
-          '9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f5153' +
-          '5c3a35e2',
+        '9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f5153' + '5c3a35e2',
       sha384:
-          '6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82' +
-          '461e99c5a678cc31e799176d3860e6110c46523e',
+        '6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82' +
+        '461e99c5a678cc31e799176d3860e6110c46523e',
       sha512:
-          'e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d' +
-          '20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de04460' +
-          '65c97440fa8c6a58'
+        'e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d' +
+        '20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de04460' +
+        '65c97440fa8c6a58'
     }
   }
 ];
@@ -256,9 +274,10 @@ for (let i = 0, l = rfc4231.length; i < l; i++) {
     const str = crypto.createHmac(hash, rfc4231[i].key);
     str.end(rfc4231[i].data);
     let strRes = str.read().toString('hex');
-    let actual = crypto.createHmac(hash, rfc4231[i].key)
-                       .update(rfc4231[i].data)
-                       .digest('hex');
+    let actual = crypto
+      .createHmac(hash, rfc4231[i].key)
+      .update(rfc4231[i].data)
+      .digest('hex');
     if (rfc4231[i].truncate) {
       actual = actual.substr(0, 32); // first 128 bits == 32 hex chars
       strRes = strRes.substr(0, 32);
@@ -273,7 +292,7 @@ for (let i = 0, l = rfc4231.length; i < l; i++) {
       actual,
       strRes,
       `Should get same result from stream (hash: ${hash} and case: ${i + 1})` +
-      ` => ${actual} must be ${strRes}`
+        ` => ${actual} must be ${strRes}`
     );
   }
 }
@@ -292,18 +311,24 @@ const rfc2202_md5 = [
   },
   {
     key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
-    data: Buffer.from('ddddddddddddddddddddddddddddddddddddddddddddddddd' +
-                     'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
-                      'hex'),
+    data: Buffer.from(
+      'ddddddddddddddddddddddddddddddddddddddddddddddddd' +
+        'ddddddddddddddddddddddddddddddddddddddddddddddddddd',
+      'hex'
+    ),
     hmac: '56be34521d144c88dbb8c733f0e8b3f6'
   },
   {
-    key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819',
-                     'hex'),
-    data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
-                     'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
-                     'cdcdcdcdcd',
-                      'hex'),
+    key: Buffer.from(
+      '0102030405060708090a0b0c0d0e0f10111213141516171819',
+      'hex'
+    ),
+    data: Buffer.from(
+      'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
+        'cdcdcdcdcd',
+      'hex'
+    ),
     hmac: '697eaf0aca3a3aea3a75164746ffaa79'
   },
   {
@@ -312,23 +337,27 @@ const rfc2202_md5 = [
     hmac: '56461ef2342edc00f9bab995690efd4c'
   },
   {
-    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaa',
-                     'hex'),
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaa',
+      'hex'
+    ),
     data: 'Test Using Larger Than Block-Size Key - Hash Key First',
     hmac: '6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd'
   },
   {
-    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaa',
-                     'hex'),
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaa',
+      'hex'
+    ),
     data:
-        'Test Using Larger Than Block-Size Key and Larger Than One ' +
-        'Block-Size Data',
+      'Test Using Larger Than Block-Size Key and Larger Than One ' +
+      'Block-Size Data',
     hmac: '6f630fad67cda0ee1fb1f562db3aa53e'
   }
 ];
@@ -345,19 +374,25 @@ const rfc2202_sha1 = [
   },
   {
     key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
-    data: Buffer.from('ddddddddddddddddddddddddddddddddddddddddddddd' +
-                     'ddddddddddddddddddddddddddddddddddddddddddddd' +
-                     'dddddddddd',
-                      'hex'),
+    data: Buffer.from(
+      'ddddddddddddddddddddddddddddddddddddddddddddd' +
+        'ddddddddddddddddddddddddddddddddddddddddddddd' +
+        'dddddddddd',
+      'hex'
+    ),
     hmac: '125d7342b9ac11cd91a39af48aa17b4f63f175d3'
   },
   {
-    key: Buffer.from('0102030405060708090a0b0c0d0e0f10111213141516171819',
-                     'hex'),
-    data: Buffer.from('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
-                     'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
-                     'cdcdcdcdcd',
-                      'hex'),
+    key: Buffer.from(
+      '0102030405060708090a0b0c0d0e0f10111213141516171819',
+      'hex'
+    ),
+    data: Buffer.from(
+      'cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc' +
+        'dcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd' +
+        'cdcdcdcdcd',
+      'hex'
+    ),
     hmac: '4c9007f4026250c6bc8414f9bf50c86c2d7235da'
   },
   {
@@ -366,30 +401,35 @@ const rfc2202_sha1 = [
     hmac: '4c1a03424b55e07fe7f27be1d58bb9324a9a5a04'
   },
   {
-    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaa',
-                     'hex'),
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaa',
+      'hex'
+    ),
     data: 'Test Using Larger Than Block-Size Key - Hash Key First',
     hmac: 'aa4ae5e15272d00e95705637ce8a3b55ed402112'
   },
   {
-    key: Buffer.from('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
-                    'aaaaaaaaaaaaaaaaaaaaaa',
-                     'hex'),
+    key: Buffer.from(
+      'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +
+        'aaaaaaaaaaaaaaaaaaaaaa',
+      'hex'
+    ),
     data:
-        'Test Using Larger Than Block-Size Key and Larger Than One ' +
-        'Block-Size Data',
+      'Test Using Larger Than Block-Size Key and Larger Than One ' +
+      'Block-Size Data',
     hmac: 'e8e99d0f45237d786d6bbaa7965c7808bbff1a91'
   }
 ];
 
 if (!common.hasFipsCrypto) {
   for (let i = 0, l = rfc2202_md5.length; i < l; i++) {
-    const actual = crypto.createHmac('md5', rfc2202_md5[i].key)
+    const actual = crypto
+      .createHmac('md5', rfc2202_md5[i].key)
       .update(rfc2202_md5[i].data)
       .digest('hex');
     const expected = rfc2202_md5[i].hmac;
@@ -401,7 +441,8 @@ if (!common.hasFipsCrypto) {
   }
 }
 for (let i = 0, l = rfc2202_sha1.length; i < l; i++) {
-  const actual = crypto.createHmac('sha1', rfc2202_sha1[i].key)
+  const actual = crypto
+    .createHmac('sha1', rfc2202_sha1[i].key)
     .update(rfc2202_sha1[i].data)
     .digest('hex');
   const expected = rfc2202_sha1[i].hmac;
@@ -412,18 +453,16 @@ for (let i = 0, l = rfc2202_sha1.length; i < l; i++) {
   );
 }
 
-common.expectsError(
-  () => crypto.createHmac('sha256', 'w00t').digest('ucs2'),
-  {
-    code: 'ERR_CRYPTO_HASH_DIGEST_NO_UTF16',
-    type: Error
-  });
+common.expectsError(() => crypto.createHmac('sha256', 'w00t').digest('ucs2'), {
+  code: 'ERR_CRYPTO_HASH_DIGEST_NO_UTF16',
+  type: Error
+});
 
 // Check initialized -> uninitialized state transition after calling digest().
 {
   const expected =
-      '\u0010\u0041\u0052\u00c5\u00bf\u00dc\u00a0\u007b\u00c6\u0033' +
-      '\u00ee\u00bd\u0046\u0019\u009f\u0002\u0055\u00c9\u00f4\u009d';
+    '\u0010\u0041\u0052\u00c5\u00bf\u00dc\u00a0\u007b\u00c6\u0033' +
+    '\u00ee\u00bd\u0046\u0019\u009f\u0002\u0055\u00c9\u00f4\u009d';
   {
     const h = crypto.createHmac('sha1', 'key').update('data');
     assert.deepStrictEqual(h.digest('buffer'), Buffer.from(expected, 'latin1'));
@@ -440,8 +479,8 @@ common.expectsError(
 // Calls to update() omitted intentionally.
 {
   const expected =
-      '\u00f4\u002b\u00b0\u00ee\u00b0\u0018\u00eb\u00bd\u0045\u0097' +
-      '\u00ae\u0072\u0013\u0071\u001e\u00c6\u0007\u0060\u0084\u003f';
+    '\u00f4\u002b\u00b0\u00ee\u00b0\u0018\u00eb\u00bd\u0045\u0097' +
+    '\u00ae\u0072\u0013\u0071\u001e\u00c6\u0007\u0060\u0084\u003f';
   {
     const h = crypto.createHmac('sha1', 'key');
     assert.deepStrictEqual(h.digest('buffer'), Buffer.from(expected, 'latin1'));
diff --git a/test/parallel/test-crypto-keygen.js b/test/parallel/test-crypto-keygen.js
index 072f69565af98e..0cfcd6753270e6 100644
--- a/test/parallel/test-crypto-keygen.js
+++ b/test/parallel/test-crypto-keygen.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const {
@@ -21,10 +20,14 @@ function assertApproximateSize(key, expectedSize) {
   const u = typeof key === 'string' ? 'chars' : 'bytes';
   const min = Math.floor(0.9 * expectedSize);
   const max = Math.ceil(1.1 * expectedSize);
-  assert(key.length >= min,
-         `Key (${key.length} ${u}) is shorter than expected (${min} ${u})`);
-  assert(key.length <= max,
-         `Key (${key.length} ${u}) is longer than expected (${max} ${u})`);
+  assert(
+    key.length >= min,
+    `Key (${key.length} ${u}) is shorter than expected (${min} ${u})`
+  );
+  assert(
+    key.length <= max,
+    `Key (${key.length} ${u}) is longer than expected (${max} ${u})`
+  );
 }
 
 // Tests that a key pair can be used for encryption / decryption.
@@ -39,18 +42,22 @@ function testEncryptDecrypt(publicKey, privateKey) {
 // Tests that a key pair can be used for signing / verification.
 function testSignVerify(publicKey, privateKey) {
   const message = 'Hello Node.js world!';
-  const signature = createSign('SHA256').update(message)
-                                        .sign(privateKey, 'hex');
-  const okay = createVerify('SHA256').update(message)
-                                     .verify(publicKey, signature, 'hex');
+  const signature = createSign('SHA256')
+    .update(message)
+    .sign(privateKey, 'hex');
+  const okay = createVerify('SHA256')
+    .update(message)
+    .verify(publicKey, signature, 'hex');
   assert(okay);
 }
 
 // Constructs a regular expression for a PEM-encoded key with the given label.
 function getRegExpForPEM(label, cipher) {
   const head = `\\-\\-\\-\\-\\-BEGIN ${label}\\-\\-\\-\\-\\-`;
-  const rfc1421Header = cipher == null ? '' :
-    `\nProc-Type: 4,ENCRYPTED\nDEK-Info: ${cipher},[^\n]+\n`;
+  const rfc1421Header =
+    cipher == null
+      ? ''
+      : `\nProc-Type: 4,ENCRYPTED\nDEK-Info: ${cipher},[^\n]+\n`;
   const body = '([a-zA-Z0-9\\+/=]{64}\n)*[a-zA-Z0-9\\+/=]{1,64}';
   const end = `\\-\\-\\-\\-\\-END ${label}\\-\\-\\-\\-\\-`;
   return new RegExp(`^${head}${rfc1421Header}\n${body}\n${end}\n$`);
@@ -114,201 +121,228 @@ function convertDERToPEM(label, der) {
 
 {
   // Test async RSA key generation.
-  generateKeyPair('rsa', {
-    publicExponent: 0x10001,
-    modulusLength: 512,
-    publicKeyEncoding: {
-      type: 'pkcs1',
-      format: 'der'
+  generateKeyPair(
+    'rsa',
+    {
+      publicExponent: 0x10001,
+      modulusLength: 512,
+      publicKeyEncoding: {
+        type: 'pkcs1',
+        format: 'der'
+      },
+      privateKeyEncoding: {
+        type: 'pkcs1',
+        format: 'pem'
+      }
     },
-    privateKeyEncoding: {
-      type: 'pkcs1',
-      format: 'pem'
-    }
-  }, common.mustCall((err, publicKeyDER, privateKey) => {
-    assert.ifError(err);
+    common.mustCall((err, publicKeyDER, privateKey) => {
+      assert.ifError(err);
 
-    // The public key is encoded as DER (which is binary) instead of PEM. We
-    // will still need to convert it to PEM for testing.
-    assert(Buffer.isBuffer(publicKeyDER));
-    const publicKey = convertDERToPEM('RSA PUBLIC KEY', publicKeyDER);
-    assertApproximateSize(publicKey, 180);
+      // The public key is encoded as DER (which is binary) instead of PEM. We
+      // will still need to convert it to PEM for testing.
+      assert(Buffer.isBuffer(publicKeyDER));
+      const publicKey = convertDERToPEM('RSA PUBLIC KEY', publicKeyDER);
+      assertApproximateSize(publicKey, 180);
 
-    assert.strictEqual(typeof privateKey, 'string');
-    assert(pkcs1PrivExp.test(privateKey));
-    assertApproximateSize(privateKey, 512);
+      assert.strictEqual(typeof privateKey, 'string');
+      assert(pkcs1PrivExp.test(privateKey));
+      assertApproximateSize(privateKey, 512);
 
-    testEncryptDecrypt(publicKey, privateKey);
-    testSignVerify(publicKey, privateKey);
-  }));
+      testEncryptDecrypt(publicKey, privateKey);
+      testSignVerify(publicKey, privateKey);
+    })
+  );
 
   // Now do the same with an encrypted private key.
-  generateKeyPair('rsa', {
-    publicExponent: 0x10001,
-    modulusLength: 512,
-    publicKeyEncoding: {
-      type: 'pkcs1',
-      format: 'der'
+  generateKeyPair(
+    'rsa',
+    {
+      publicExponent: 0x10001,
+      modulusLength: 512,
+      publicKeyEncoding: {
+        type: 'pkcs1',
+        format: 'der'
+      },
+      privateKeyEncoding: {
+        type: 'pkcs1',
+        format: 'pem',
+        cipher: 'aes-256-cbc',
+        passphrase: 'secret'
+      }
     },
-    privateKeyEncoding: {
-      type: 'pkcs1',
-      format: 'pem',
-      cipher: 'aes-256-cbc',
-      passphrase: 'secret'
-    }
-  }, common.mustCall((err, publicKeyDER, privateKey) => {
-    assert.ifError(err);
-
-    // The public key is encoded as DER (which is binary) instead of PEM. We
-    // will still need to convert it to PEM for testing.
-    assert(Buffer.isBuffer(publicKeyDER));
-    const publicKey = convertDERToPEM('RSA PUBLIC KEY', publicKeyDER);
-    assertApproximateSize(publicKey, 180);
-
-    assert.strictEqual(typeof privateKey, 'string');
-    assert(pkcs1EncExp('AES-256-CBC').test(privateKey));
-
-    // Since the private key is encrypted, signing shouldn't work anymore.
-    assert.throws(() => {
-      testSignVerify(publicKey, privateKey);
-    }, /bad decrypt|asn1 encoding routines/);
-
-    const key = { key: privateKey, passphrase: 'secret' };
-    testEncryptDecrypt(publicKey, key);
-    testSignVerify(publicKey, key);
-  }));
+    common.mustCall((err, publicKeyDER, privateKey) => {
+      assert.ifError(err);
+
+      // The public key is encoded as DER (which is binary) instead of PEM. We
+      // will still need to convert it to PEM for testing.
+      assert(Buffer.isBuffer(publicKeyDER));
+      const publicKey = convertDERToPEM('RSA PUBLIC KEY', publicKeyDER);
+      assertApproximateSize(publicKey, 180);
+
+      assert.strictEqual(typeof privateKey, 'string');
+      assert(pkcs1EncExp('AES-256-CBC').test(privateKey));
+
+      // Since the private key is encrypted, signing shouldn't work anymore.
+      assert.throws(() => {
+        testSignVerify(publicKey, privateKey);
+      }, /bad decrypt|asn1 encoding routines/);
+
+      const key = { key: privateKey, passphrase: 'secret' };
+      testEncryptDecrypt(publicKey, key);
+      testSignVerify(publicKey, key);
+    })
+  );
 }
 
 {
   // Test async DSA key generation.
-  generateKeyPair('dsa', {
-    modulusLength: 512,
-    divisorLength: 256,
-    publicKeyEncoding: {
-      type: 'spki',
-      format: 'pem'
+  generateKeyPair(
+    'dsa',
+    {
+      modulusLength: 512,
+      divisorLength: 256,
+      publicKeyEncoding: {
+        type: 'spki',
+        format: 'pem'
+      },
+      privateKeyEncoding: {
+        type: 'pkcs8',
+        format: 'der',
+        cipher: 'aes-128-cbc',
+        passphrase: 'secret'
+      }
     },
-    privateKeyEncoding: {
-      type: 'pkcs8',
-      format: 'der',
-      cipher: 'aes-128-cbc',
-      passphrase: 'secret'
-    }
-  }, common.mustCall((err, publicKey, privateKeyDER) => {
-    assert.ifError(err);
-
-    assert.strictEqual(typeof publicKey, 'string');
-    assert(spkiExp.test(publicKey));
-    // The private key is DER-encoded.
-    assert(Buffer.isBuffer(privateKeyDER));
-    const privateKey = convertDERToPEM('ENCRYPTED PRIVATE KEY', privateKeyDER);
-
-    assertApproximateSize(publicKey, 440);
-    assertApproximateSize(privateKey, 512);
-
-    // Since the private key is encrypted, signing shouldn't work anymore.
-    assert.throws(() => {
-      testSignVerify(publicKey, privateKey);
-    }, /bad decrypt|asn1 encoding routines/);
-
-    // Signing should work with the correct password.
-    testSignVerify(publicKey, {
-      key: privateKey,
-      passphrase: 'secret'
-    });
-  }));
+    common.mustCall((err, publicKey, privateKeyDER) => {
+      assert.ifError(err);
+
+      assert.strictEqual(typeof publicKey, 'string');
+      assert(spkiExp.test(publicKey));
+      // The private key is DER-encoded.
+      assert(Buffer.isBuffer(privateKeyDER));
+      const privateKey = convertDERToPEM(
+        'ENCRYPTED PRIVATE KEY',
+        privateKeyDER
+      );
+
+      assertApproximateSize(publicKey, 440);
+      assertApproximateSize(privateKey, 512);
+
+      // Since the private key is encrypted, signing shouldn't work anymore.
+      assert.throws(() => {
+        testSignVerify(publicKey, privateKey);
+      }, /bad decrypt|asn1 encoding routines/);
+
+      // Signing should work with the correct password.
+      testSignVerify(publicKey, {
+        key: privateKey,
+        passphrase: 'secret'
+      });
+    })
+  );
 }
 
 {
   // Test async elliptic curve key generation, e.g. for ECDSA, with a SEC1
   // private key.
-  generateKeyPair('ec', {
-    namedCurve: 'prime256v1',
-    paramEncoding: 'named',
-    publicKeyEncoding: {
-      type: 'spki',
-      format: 'pem'
+  generateKeyPair(
+    'ec',
+    {
+      namedCurve: 'prime256v1',
+      paramEncoding: 'named',
+      publicKeyEncoding: {
+        type: 'spki',
+        format: 'pem'
+      },
+      privateKeyEncoding: {
+        type: 'sec1',
+        format: 'pem'
+      }
     },
-    privateKeyEncoding: {
-      type: 'sec1',
-      format: 'pem'
-    }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
+    common.mustCall((err, publicKey, privateKey) => {
+      assert.ifError(err);
 
-    assert.strictEqual(typeof publicKey, 'string');
-    assert(spkiExp.test(publicKey));
-    assert.strictEqual(typeof privateKey, 'string');
-    assert(sec1Exp.test(privateKey));
+      assert.strictEqual(typeof publicKey, 'string');
+      assert(spkiExp.test(publicKey));
+      assert.strictEqual(typeof privateKey, 'string');
+      assert(sec1Exp.test(privateKey));
 
-    testSignVerify(publicKey, privateKey);
-  }));
+      testSignVerify(publicKey, privateKey);
+    })
+  );
 
   // Do the same with an encrypted private key.
-  generateKeyPair('ec', {
-    namedCurve: 'prime256v1',
-    paramEncoding: 'named',
-    publicKeyEncoding: {
-      type: 'spki',
-      format: 'pem'
+  generateKeyPair(
+    'ec',
+    {
+      namedCurve: 'prime256v1',
+      paramEncoding: 'named',
+      publicKeyEncoding: {
+        type: 'spki',
+        format: 'pem'
+      },
+      privateKeyEncoding: {
+        type: 'sec1',
+        format: 'pem',
+        cipher: 'aes-128-cbc',
+        passphrase: 'secret'
+      }
     },
-    privateKeyEncoding: {
-      type: 'sec1',
-      format: 'pem',
-      cipher: 'aes-128-cbc',
-      passphrase: 'secret'
-    }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
-    assert.strictEqual(typeof publicKey, 'string');
-    assert(spkiExp.test(publicKey));
-    assert.strictEqual(typeof privateKey, 'string');
-    assert(sec1EncExp('AES-128-CBC').test(privateKey));
-
-    // Since the private key is encrypted, signing shouldn't work anymore.
-    assert.throws(() => {
-      testSignVerify(publicKey, privateKey);
-    }, /bad decrypt|asn1 encoding routines/);
-
-    testSignVerify(publicKey, { key: privateKey, passphrase: 'secret' });
-  }));
+    common.mustCall((err, publicKey, privateKey) => {
+      assert.ifError(err);
+
+      assert.strictEqual(typeof publicKey, 'string');
+      assert(spkiExp.test(publicKey));
+      assert.strictEqual(typeof privateKey, 'string');
+      assert(sec1EncExp('AES-128-CBC').test(privateKey));
+
+      // Since the private key is encrypted, signing shouldn't work anymore.
+      assert.throws(() => {
+        testSignVerify(publicKey, privateKey);
+      }, /bad decrypt|asn1 encoding routines/);
+
+      testSignVerify(publicKey, { key: privateKey, passphrase: 'secret' });
+    })
+  );
 }
 
 {
   // Test async elliptic curve key generation, e.g. for ECDSA, with an encrypted
   // private key.
-  generateKeyPair('ec', {
-    namedCurve: 'P-192',
-    paramEncoding: 'named',
-    publicKeyEncoding: {
-      type: 'spki',
-      format: 'pem'
+  generateKeyPair(
+    'ec',
+    {
+      namedCurve: 'P-192',
+      paramEncoding: 'named',
+      publicKeyEncoding: {
+        type: 'spki',
+        format: 'pem'
+      },
+      privateKeyEncoding: {
+        type: 'pkcs8',
+        format: 'pem',
+        cipher: 'aes-128-cbc',
+        passphrase: 'top secret'
+      }
     },
-    privateKeyEncoding: {
-      type: 'pkcs8',
-      format: 'pem',
-      cipher: 'aes-128-cbc',
-      passphrase: 'top secret'
-    }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-
-    assert.strictEqual(typeof publicKey, 'string');
-    assert(spkiExp.test(publicKey));
-    assert.strictEqual(typeof privateKey, 'string');
-    assert(pkcs8EncExp.test(privateKey));
-
-    // Since the private key is encrypted, signing shouldn't work anymore.
-    assert.throws(() => {
-      testSignVerify(publicKey, privateKey);
-    }, /bad decrypt|asn1 encoding routines/);
-
-    testSignVerify(publicKey, {
-      key: privateKey,
-      passphrase: 'top secret'
-    });
-  }));
+    common.mustCall((err, publicKey, privateKey) => {
+      assert.ifError(err);
+
+      assert.strictEqual(typeof publicKey, 'string');
+      assert(spkiExp.test(publicKey));
+      assert.strictEqual(typeof privateKey, 'string');
+      assert(pkcs8EncExp.test(privateKey));
+
+      // Since the private key is encrypted, signing shouldn't work anymore.
+      assert.throws(() => {
+        testSignVerify(publicKey, privateKey);
+      }, /bad decrypt|asn1 encoding routines/);
+
+      testSignVerify(publicKey, {
+        key: privateKey,
+        passphrase: 'top secret'
+      });
+    })
+  );
 }
 
 {
@@ -324,19 +358,21 @@ function convertDERToPEM(label, der) {
       type: 'pkcs1',
       format: 'pem'
     }
-  }).then(common.mustCall((keys) => {
-    const { publicKey, privateKey } = keys;
-    assert.strictEqual(typeof publicKey, 'string');
-    assert(pkcs1PubExp.test(publicKey));
-    assertApproximateSize(publicKey, 180);
-
-    assert.strictEqual(typeof privateKey, 'string');
-    assert(pkcs1PrivExp.test(privateKey));
-    assertApproximateSize(privateKey, 512);
-
-    testEncryptDecrypt(publicKey, privateKey);
-    testSignVerify(publicKey, privateKey);
-  }));
+  }).then(
+    common.mustCall((keys) => {
+      const { publicKey, privateKey } = keys;
+      assert.strictEqual(typeof publicKey, 'string');
+      assert(pkcs1PubExp.test(publicKey));
+      assertApproximateSize(publicKey, 180);
+
+      assert.strictEqual(typeof privateKey, 'string');
+      assert(pkcs1PrivExp.test(privateKey));
+      assertApproximateSize(privateKey, 512);
+
+      testEncryptDecrypt(publicKey, privateKey);
+      testSignVerify(publicKey, privateKey);
+    })
+  );
 }
 
 {
@@ -345,16 +381,18 @@ function convertDERToPEM(label, der) {
     common.expectsError(() => generateKeyPairSync(type, {}), {
       type: TypeError,
       code: 'ERR_INVALID_ARG_TYPE',
-      message: 'The "type" argument must be of type string. Received type ' +
-               typeof type
+      message:
+        'The "type" argument must be of type string. Received type ' +
+        typeof type
     });
   }
 
   common.expectsError(() => generateKeyPairSync('rsa2', {}), {
     type: TypeError,
     code: 'ERR_INVALID_ARG_VALUE',
-    message: "The argument 'type' must be one of " +
-             "'rsa', 'dsa', 'ec'. Received 'rsa2'"
+    message:
+      "The argument 'type' must be one of " +
+      "'rsa', 'dsa', 'ec'. Received 'rsa2'"
   });
 }
 
@@ -363,7 +401,8 @@ function convertDERToPEM(label, der) {
   common.expectsError(() => generateKeyPair('rsa', common.mustNotCall()), {
     type: TypeError,
     code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "options" argument must be of ' +
+    message:
+      'The "options" argument must be of ' +
       'type object. Received type undefined'
   });
 }
@@ -371,187 +410,237 @@ function convertDERToPEM(label, der) {
 {
   // Missing / invalid publicKeyEncoding.
   for (const enc of [undefined, null, 0, 'a', true]) {
-    common.expectsError(() => generateKeyPairSync('rsa', {
-      modulusLength: 4096,
-      publicKeyEncoding: enc,
-      privateKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem'
+    common.expectsError(
+      () =>
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: enc,
+          privateKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          }
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message: `The value "${enc}" is invalid for option "publicKeyEncoding"`
       }
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${enc}" is invalid for option "publicKeyEncoding"`
-    });
+    );
   }
 
   // Missing publicKeyEncoding.type.
   for (const type of [undefined, null, 0, true, {}]) {
-    common.expectsError(() => generateKeyPairSync('rsa', {
-      modulusLength: 4096,
-      publicKeyEncoding: {
-        type,
-        format: 'pem'
-      },
-      privateKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem'
+    common.expectsError(
+      () =>
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: {
+            type,
+            format: 'pem'
+          },
+          privateKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          }
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${type}" is invalid for option ` +
+          '"publicKeyEncoding.type"'
       }
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${type}" is invalid for option ` +
-               '"publicKeyEncoding.type"'
-    });
+    );
   }
 
   // Missing / invalid publicKeyEncoding.format.
   for (const format of [undefined, null, 0, false, 'a', {}]) {
-    common.expectsError(() => generateKeyPairSync('rsa', {
-      modulusLength: 4096,
-      publicKeyEncoding: {
-        type: 'pkcs1',
-        format
-      },
-      privateKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem'
+    common.expectsError(
+      () =>
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: {
+            type: 'pkcs1',
+            format
+          },
+          privateKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          }
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${format}" is invalid for option ` +
+          '"publicKeyEncoding.format"'
       }
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${format}" is invalid for option ` +
-               '"publicKeyEncoding.format"'
-    });
+    );
   }
 
   // Missing / invalid privateKeyEncoding.
   for (const enc of [undefined, null, 0, 'a', true]) {
-    common.expectsError(() => generateKeyPairSync('rsa', {
-      modulusLength: 4096,
-      publicKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem'
-      },
-      privateKeyEncoding: enc
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${enc}" is invalid for option "privateKeyEncoding"`
-    });
+    common.expectsError(
+      () =>
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          },
+          privateKeyEncoding: enc
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message: `The value "${enc}" is invalid for option "privateKeyEncoding"`
+      }
+    );
   }
 
   // Missing / invalid privateKeyEncoding.type.
   for (const type of [undefined, null, 0, true, {}]) {
-    common.expectsError(() => generateKeyPairSync('rsa', {
-      modulusLength: 4096,
-      publicKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem'
-      },
-      privateKeyEncoding: {
-        type,
-        format: 'pem'
+    common.expectsError(
+      () =>
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          },
+          privateKeyEncoding: {
+            type,
+            format: 'pem'
+          }
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${type}" is invalid for option ` +
+          '"privateKeyEncoding.type"'
       }
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${type}" is invalid for option ` +
-               '"privateKeyEncoding.type"'
-    });
+    );
   }
 
   // Missing / invalid privateKeyEncoding.format.
   for (const format of [undefined, null, 0, false, 'a', {}]) {
-    common.expectsError(() => generateKeyPairSync('rsa', {
-      modulusLength: 4096,
-      publicKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem'
-      },
-      privateKeyEncoding: {
-        type: 'pkcs1',
-        format
+    common.expectsError(
+      () =>
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          },
+          privateKeyEncoding: {
+            type: 'pkcs1',
+            format
+          }
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${format}" is invalid for option ` +
+          '"privateKeyEncoding.format"'
       }
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${format}" is invalid for option ` +
-               '"privateKeyEncoding.format"'
-    });
+    );
   }
 
   // cipher of invalid type.
   for (const cipher of [0, true, {}]) {
-    common.expectsError(() => generateKeyPairSync('rsa', {
-      modulusLength: 4096,
-      publicKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem'
-      },
-      privateKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem',
-        cipher
+    common.expectsError(
+      () =>
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          },
+          privateKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem',
+            cipher
+          }
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${cipher}" is invalid for option ` +
+          '"privateKeyEncoding.cipher"'
       }
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${cipher}" is invalid for option ` +
-               '"privateKeyEncoding.cipher"'
-    });
+    );
   }
 
   // Invalid cipher.
-  common.expectsError(() => generateKeyPairSync('rsa', {
-    modulusLength: 4096,
-    publicKeyEncoding: {
-      type: 'pkcs1',
-      format: 'pem'
-    },
-    privateKeyEncoding: {
-      type: 'pkcs8',
-      format: 'pem',
-      cipher: 'foo',
-      passphrase: 'secret'
+  common.expectsError(
+    () =>
+      generateKeyPairSync('rsa', {
+        modulusLength: 4096,
+        publicKeyEncoding: {
+          type: 'pkcs1',
+          format: 'pem'
+        },
+        privateKeyEncoding: {
+          type: 'pkcs8',
+          format: 'pem',
+          cipher: 'foo',
+          passphrase: 'secret'
+        }
+      }),
+    {
+      type: Error,
+      message: 'Unknown cipher'
     }
-  }), {
-    type: Error,
-    message: 'Unknown cipher'
-  });
+  );
 
   // cipher, but no valid passphrase.
   for (const passphrase of [undefined, null, 5, false, true]) {
-    common.expectsError(() => generateKeyPairSync('rsa', {
-      modulusLength: 4096,
-      publicKeyEncoding: {
-        type: 'pkcs1',
-        format: 'pem'
-      },
-      privateKeyEncoding: {
-        type: 'pkcs8',
-        format: 'pem',
-        cipher: 'aes-128-cbc',
-        passphrase
+    common.expectsError(
+      () =>
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: {
+            type: 'pkcs1',
+            format: 'pem'
+          },
+          privateKeyEncoding: {
+            type: 'pkcs8',
+            format: 'pem',
+            cipher: 'aes-128-cbc',
+            passphrase
+          }
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${passphrase}" is invalid for option ` +
+          '"privateKeyEncoding.passphrase"'
       }
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${passphrase}" is invalid for option ` +
-               '"privateKeyEncoding.passphrase"'
-    });
+    );
   }
 
   // Test invalid callbacks.
   for (const cb of [undefined, null, 0, {}]) {
-    common.expectsError(() => generateKeyPair('rsa', {
-      modulusLength: 512,
-      publicKeyEncoding: { type: 'pkcs1', format: 'pem' },
-      privateKeyEncoding: { type: 'pkcs1', format: 'pem' }
-    }, cb), {
-      type: TypeError,
-      code: 'ERR_INVALID_CALLBACK'
-    });
+    common.expectsError(
+      () =>
+        generateKeyPair(
+          'rsa',
+          {
+            modulusLength: 512,
+            publicKeyEncoding: { type: 'pkcs1', format: 'pem' },
+            privateKeyEncoding: { type: 'pkcs1', format: 'pem' }
+          },
+          cb
+        ),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_CALLBACK'
+      }
+    );
   }
 }
 
@@ -559,27 +648,37 @@ function convertDERToPEM(label, der) {
 {
   // Test invalid modulus lengths.
   for (const modulusLength of [undefined, null, 'a', true, {}, [], 512.1, -1]) {
-    common.expectsError(() => generateKeyPair('rsa', {
-      modulusLength
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${modulusLength}" is invalid for option ` +
-               '"modulusLength"'
-    });
+    common.expectsError(
+      () =>
+        generateKeyPair('rsa', {
+          modulusLength
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${modulusLength}" is invalid for option ` +
+          '"modulusLength"'
+      }
+    );
   }
 
   // Test invalid exponents.
   for (const publicExponent of ['a', true, {}, [], 3.5, -1]) {
-    common.expectsError(() => generateKeyPair('rsa', {
-      modulusLength: 4096,
-      publicExponent
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${publicExponent}" is invalid for option ` +
-               '"publicExponent"'
-    });
+    common.expectsError(
+      () =>
+        generateKeyPair('rsa', {
+          modulusLength: 4096,
+          publicExponent
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${publicExponent}" is invalid for option ` +
+          '"publicExponent"'
+      }
+    );
   }
 }
 
@@ -587,157 +686,200 @@ function convertDERToPEM(label, der) {
 {
   // Test invalid modulus lengths.
   for (const modulusLength of [undefined, null, 'a', true, {}, [], 4096.1]) {
-    common.expectsError(() => generateKeyPair('dsa', {
-      modulusLength
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${modulusLength}" is invalid for option ` +
-               '"modulusLength"'
-    });
+    common.expectsError(
+      () =>
+        generateKeyPair('dsa', {
+          modulusLength
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${modulusLength}" is invalid for option ` +
+          '"modulusLength"'
+      }
+    );
   }
 
   // Test invalid divisor lengths.
   for (const divisorLength of ['a', true, {}, [], 4096.1]) {
-    common.expectsError(() => generateKeyPair('dsa', {
-      modulusLength: 2048,
-      divisorLength
-    }), {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${divisorLength}" is invalid for option ` +
-               '"divisorLength"'
-    });
+    common.expectsError(
+      () =>
+        generateKeyPair('dsa', {
+          modulusLength: 2048,
+          divisorLength
+        }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${divisorLength}" is invalid for option ` +
+          '"divisorLength"'
+      }
+    );
   }
 }
 
 // Test EC parameters.
 {
   // Test invalid curves.
-  common.expectsError(() => {
-    generateKeyPairSync('ec', {
-      namedCurve: 'abcdef',
-      publicKeyEncoding: { type: 'spki', format: 'pem' },
-      privateKeyEncoding: { type: 'sec1', format: 'pem' }
-    });
-  }, {
-    type: TypeError,
-    message: 'Invalid ECDH curve name'
-  });
+  common.expectsError(
+    () => {
+      generateKeyPairSync('ec', {
+        namedCurve: 'abcdef',
+        publicKeyEncoding: { type: 'spki', format: 'pem' },
+        privateKeyEncoding: { type: 'sec1', format: 'pem' }
+      });
+    },
+    {
+      type: TypeError,
+      message: 'Invalid ECDH curve name'
+    }
+  );
 
   // It should recognize both NIST and standard curve names.
-  generateKeyPair('ec', {
-    namedCurve: 'P-192',
-    publicKeyEncoding: { type: 'spki', format: 'pem' },
-    privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-  }));
-
-  generateKeyPair('ec', {
-    namedCurve: 'secp192k1',
-    publicKeyEncoding: { type: 'spki', format: 'pem' },
-    privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-  }, common.mustCall((err, publicKey, privateKey) => {
-    assert.ifError(err);
-  }));
+  generateKeyPair(
+    'ec',
+    {
+      namedCurve: 'P-192',
+      publicKeyEncoding: { type: 'spki', format: 'pem' },
+      privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+    },
+    common.mustCall((err, publicKey, privateKey) => {
+      assert.ifError(err);
+    })
+  );
+
+  generateKeyPair(
+    'ec',
+    {
+      namedCurve: 'secp192k1',
+      publicKeyEncoding: { type: 'spki', format: 'pem' },
+      privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+    },
+    common.mustCall((err, publicKey, privateKey) => {
+      assert.ifError(err);
+    })
+  );
 }
 
 // Test invalid key encoding types.
 {
   // Invalid public key type.
   for (const type of ['foo', 'pkcs8', 'sec1']) {
-    common.expectsError(() => {
-      generateKeyPairSync('rsa', {
-        modulusLength: 4096,
-        publicKeyEncoding: { type, format: 'pem' },
-        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-      });
-    }, {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${type}" is invalid for option ` +
-               '"publicKeyEncoding.type"'
-    });
+    common.expectsError(
+      () => {
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: { type, format: 'pem' },
+          privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+        });
+      },
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${type}" is invalid for option ` +
+          '"publicKeyEncoding.type"'
+      }
+    );
   }
 
   // Invalid private key type.
   for (const type of ['foo', 'spki']) {
-    common.expectsError(() => {
-      generateKeyPairSync('rsa', {
-        modulusLength: 4096,
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: { type, format: 'pem' }
-      });
-    }, {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE',
-      message: `The value "${type}" is invalid for option ` +
-               '"privateKeyEncoding.type"'
-    });
+    common.expectsError(
+      () => {
+        generateKeyPairSync('rsa', {
+          modulusLength: 4096,
+          publicKeyEncoding: { type: 'spki', format: 'pem' },
+          privateKeyEncoding: { type, format: 'pem' }
+        });
+      },
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message:
+          `The value "${type}" is invalid for option ` +
+          '"privateKeyEncoding.type"'
+      }
+    );
   }
 
   // Key encoding doesn't match key type.
   for (const type of ['dsa', 'ec']) {
-    common.expectsError(() => {
-      generateKeyPairSync(type, {
-        modulusLength: 4096,
-        namedCurve: 'P-256',
-        publicKeyEncoding: { type: 'pkcs1', format: 'pem' },
-        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-      });
-    }, {
-      type: Error,
-      code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS',
-      message: 'The selected key encoding pkcs1 can only be used for RSA keys.'
-    });
-
-    common.expectsError(() => {
-      generateKeyPairSync(type, {
-        modulusLength: 4096,
-        namedCurve: 'P-256',
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: { type: 'pkcs1', format: 'pem' }
-      });
-    }, {
-      type: Error,
-      code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS',
-      message: 'The selected key encoding pkcs1 can only be used for RSA keys.'
-    });
+    common.expectsError(
+      () => {
+        generateKeyPairSync(type, {
+          modulusLength: 4096,
+          namedCurve: 'P-256',
+          publicKeyEncoding: { type: 'pkcs1', format: 'pem' },
+          privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+        });
+      },
+      {
+        type: Error,
+        code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS',
+        message:
+          'The selected key encoding pkcs1 can only be used for RSA keys.'
+      }
+    );
+
+    common.expectsError(
+      () => {
+        generateKeyPairSync(type, {
+          modulusLength: 4096,
+          namedCurve: 'P-256',
+          publicKeyEncoding: { type: 'spki', format: 'pem' },
+          privateKeyEncoding: { type: 'pkcs1', format: 'pem' }
+        });
+      },
+      {
+        type: Error,
+        code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS',
+        message:
+          'The selected key encoding pkcs1 can only be used for RSA keys.'
+      }
+    );
   }
 
   for (const type of ['rsa', 'dsa']) {
-    common.expectsError(() => {
-      generateKeyPairSync(type, {
-        modulusLength: 4096,
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: { type: 'sec1', format: 'pem' }
-      });
-    }, {
-      type: Error,
-      code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS',
-      message: 'The selected key encoding sec1 can only be used for EC keys.'
-    });
+    common.expectsError(
+      () => {
+        generateKeyPairSync(type, {
+          modulusLength: 4096,
+          publicKeyEncoding: { type: 'spki', format: 'pem' },
+          privateKeyEncoding: { type: 'sec1', format: 'pem' }
+        });
+      },
+      {
+        type: Error,
+        code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS',
+        message: 'The selected key encoding sec1 can only be used for EC keys.'
+      }
+    );
   }
 
   // Attempting to encrypt a DER-encoded, non-PKCS#8 key.
   for (const type of ['pkcs1', 'sec1']) {
-    common.expectsError(() => {
-      generateKeyPairSync(type === 'pkcs1' ? 'rsa' : 'ec', {
-        modulusLength: 4096,
-        namedCurve: 'P-256',
-        publicKeyEncoding: { type: 'spki', format: 'pem' },
-        privateKeyEncoding: {
-          type,
-          format: 'der',
-          cipher: 'aes-128-cbc',
-          passphrase: 'hello'
-        }
-      });
-    }, {
-      type: Error,
-      code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS',
-      message: `The selected key encoding ${type} does not support encryption.`
-    });
+    common.expectsError(
+      () => {
+        generateKeyPairSync(type === 'pkcs1' ? 'rsa' : 'ec', {
+          modulusLength: 4096,
+          namedCurve: 'P-256',
+          publicKeyEncoding: { type: 'spki', format: 'pem' },
+          privateKeyEncoding: {
+            type,
+            format: 'der',
+            cipher: 'aes-128-cbc',
+            passphrase: 'hello'
+          }
+        });
+      },
+      {
+        type: Error,
+        code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS',
+        message: `The selected key encoding ${type} does not support encryption.`
+      }
+    );
   }
 }
diff --git a/test/parallel/test-crypto-lazy-transform-writable.js b/test/parallel/test-crypto-lazy-transform-writable.js
index 94240321bd755e..bf329430985566 100644
--- a/test/parallel/test-crypto-lazy-transform-writable.js
+++ b/test/parallel/test-crypto-lazy-transform-writable.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -26,10 +25,13 @@ class OldStream extends Stream {
 
 const stream = new OldStream();
 
-stream.pipe(hasher2).on('finish', common.mustCall(function() {
-  const hash = hasher2.read().toString('hex');
-  assert.strictEqual(expected, hash);
-}));
+stream.pipe(hasher2).on(
+  'finish',
+  common.mustCall(function() {
+    const hash = hasher2.read().toString('hex');
+    assert.strictEqual(expected, hash);
+  })
+);
 
 stream.emit('data', Buffer.from('hello'));
 stream.emit('data', Buffer.from(' world'));
diff --git a/test/parallel/test-crypto-padding-aes256.js b/test/parallel/test-crypto-padding-aes256.js
index d6c395f0a42d35..21e03135711e72 100644
--- a/test/parallel/test-crypto-padding-aes256.js
+++ b/test/parallel/test-crypto-padding-aes256.js
@@ -21,15 +21,16 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
 
 const iv = Buffer.from('00000000000000000000000000000000', 'hex');
-const key = Buffer.from('0123456789abcdef0123456789abcdef' +
-                        '0123456789abcdef0123456789abcdef', 'hex');
+const key = Buffer.from(
+  '0123456789abcdef0123456789abcdef' + '0123456789abcdef0123456789abcdef',
+  'hex'
+);
 
 function encrypt(val, pad) {
   const c = crypto.createCipheriv('aes256', key, iv);
diff --git a/test/parallel/test-crypto-padding.js b/test/parallel/test-crypto-padding.js
index d4a5b95cec9242..a9bf822578b19d 100644
--- a/test/parallel/test-crypto-padding.js
+++ b/test/parallel/test-crypto-padding.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -42,21 +41,20 @@ const CIPHER_NAME = 'aes-128-cbc';
 // openssl enc -aes-128-cbc -e -K 5333632e722e652e742e4b2e652e5921 \
 // -iv 626c616846697a7a3230313142757a7a | xxd -p -c256
 const ODD_LENGTH_ENCRYPTED =
-    '7f57859550d4d2fdb9806da2a750461a9fe77253cd1cbd4b07beee4e070d561f';
+  '7f57859550d4d2fdb9806da2a750461a9fe77253cd1cbd4b07beee4e070d561f';
 
 // echo -n 'Hello node world!AbC09876dDeFgHi' | \
 // openssl enc -aes-128-cbc -e -K 5333632e722e652e742e4b2e652e5921 \
 // -iv 626c616846697a7a3230313142757a7a | xxd -p -c256
 const EVEN_LENGTH_ENCRYPTED =
-    '7f57859550d4d2fdb9806da2a750461ab46e71b3d78ebe2d9684dfc87f7575b988' +
-    '6119866912cb8c7bcaf76c5ebc2378';
+  '7f57859550d4d2fdb9806da2a750461ab46e71b3d78ebe2d9684dfc87f7575b988' +
+  '6119866912cb8c7bcaf76c5ebc2378';
 
 // echo -n 'Hello node world!AbC09876dDeFgHi' | \
 // openssl enc -aes-128-cbc -e -K 5333632e722e652e742e4b2e652e5921 \
 // -iv 626c616846697a7a3230313142757a7a -nopad | xxd -p -c256
 const EVEN_LENGTH_ENCRYPTED_NOPAD =
-    '7f57859550d4d2fdb9806da2a750461ab46e71b3d78ebe2d9684dfc87f7575b9';
-
+  '7f57859550d4d2fdb9806da2a750461ab46e71b3d78ebe2d9684dfc87f7575b9';
 
 // Helper wrappers.
 function enc(plain, pad) {
@@ -84,9 +82,7 @@ assert.throws(function() {
   enc(ODD_LENGTH_PLAIN, false);
 }, /data not multiple of block length/);
 
-assert.strictEqual(
-  enc(EVEN_LENGTH_PLAIN, false), EVEN_LENGTH_ENCRYPTED_NOPAD
-);
+assert.strictEqual(enc(EVEN_LENGTH_PLAIN, false), EVEN_LENGTH_ENCRYPTED_NOPAD);
 
 // Test decryption.
 assert.strictEqual(dec(ODD_LENGTH_ENCRYPTED, true), ODD_LENGTH_PLAIN);
@@ -102,6 +98,4 @@ assert.throws(function() {
 }, /bad decrypt/);
 
 // No-pad encrypted string should return the same:
-assert.strictEqual(
-  dec(EVEN_LENGTH_ENCRYPTED_NOPAD, false), EVEN_LENGTH_PLAIN
-);
+assert.strictEqual(dec(EVEN_LENGTH_ENCRYPTED_NOPAD, false), EVEN_LENGTH_PLAIN);
diff --git a/test/parallel/test-crypto-pbkdf2.js b/test/parallel/test-crypto-pbkdf2.js
index db12cf14fcc168..293bf36ed18233 100644
--- a/test/parallel/test-crypto-pbkdf2.js
+++ b/test/parallel/test-crypto-pbkdf2.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -9,14 +8,20 @@ const crypto = require('crypto');
 common.expectWarning(
   'DeprecationWarning',
   'Calling pbkdf2 or pbkdf2Sync with "digest" set to null is deprecated.',
-  'DEP0009');
+  'DEP0009'
+);
 
 //
 // Test PBKDF2 with RFC 6070 test vectors (except #4)
 //
 function testPBKDF2(password, salt, iterations, keylen, expected) {
-  const actual =
-    crypto.pbkdf2Sync(password, salt, iterations, keylen, 'sha256');
+  const actual = crypto.pbkdf2Sync(
+    password,
+    salt,
+    iterations,
+    keylen,
+    'sha256'
+  );
   assert.strictEqual(actual.toString('latin1'), expected);
 
   crypto.pbkdf2(password, salt, iterations, keylen, 'sha256', (err, actual) => {
@@ -24,32 +29,52 @@ function testPBKDF2(password, salt, iterations, keylen, expected) {
   });
 }
 
+testPBKDF2(
+  'password',
+  'salt',
+  1,
+  20,
+  '\x12\x0f\xb6\xcf\xfc\xf8\xb3\x2c\x43\xe7\x22\x52' +
+    '\x56\xc4\xf8\x37\xa8\x65\x48\xc9'
+);
 
-testPBKDF2('password', 'salt', 1, 20,
-           '\x12\x0f\xb6\xcf\xfc\xf8\xb3\x2c\x43\xe7\x22\x52' +
-           '\x56\xc4\xf8\x37\xa8\x65\x48\xc9');
-
-testPBKDF2('password', 'salt', 2, 20,
-           '\xae\x4d\x0c\x95\xaf\x6b\x46\xd3\x2d\x0a\xdf\xf9' +
-           '\x28\xf0\x6d\xd0\x2a\x30\x3f\x8e');
+testPBKDF2(
+  'password',
+  'salt',
+  2,
+  20,
+  '\xae\x4d\x0c\x95\xaf\x6b\x46\xd3\x2d\x0a\xdf\xf9' +
+    '\x28\xf0\x6d\xd0\x2a\x30\x3f\x8e'
+);
 
-testPBKDF2('password', 'salt', 4096, 20,
-           '\xc5\xe4\x78\xd5\x92\x88\xc8\x41\xaa\x53\x0d\xb6' +
-           '\x84\x5c\x4c\x8d\x96\x28\x93\xa0');
+testPBKDF2(
+  'password',
+  'salt',
+  4096,
+  20,
+  '\xc5\xe4\x78\xd5\x92\x88\xc8\x41\xaa\x53\x0d\xb6' +
+    '\x84\x5c\x4c\x8d\x96\x28\x93\xa0'
+);
 
-testPBKDF2('passwordPASSWORDpassword',
-           'saltSALTsaltSALTsaltSALTsaltSALTsalt',
-           4096,
-           25,
-           '\x34\x8c\x89\xdb\xcb\xd3\x2b\x2f\x32\xd8\x14\xb8\x11' +
-           '\x6e\x84\xcf\x2b\x17\x34\x7e\xbc\x18\x00\x18\x1c');
+testPBKDF2(
+  'passwordPASSWORDpassword',
+  'saltSALTsaltSALTsaltSALTsaltSALTsalt',
+  4096,
+  25,
+  '\x34\x8c\x89\xdb\xcb\xd3\x2b\x2f\x32\xd8\x14\xb8\x11' +
+    '\x6e\x84\xcf\x2b\x17\x34\x7e\xbc\x18\x00\x18\x1c'
+);
 
-testPBKDF2('pass\0word', 'sa\0lt', 4096, 16,
-           '\x89\xb6\x9d\x05\x16\xf8\x29\x89\x3c\x69\x62\x26\x65' +
-           '\x0a\x86\x87');
+testPBKDF2(
+  'pass\0word',
+  'sa\0lt',
+  4096,
+  16,
+  '\x89\xb6\x9d\x05\x16\xf8\x29\x89\x3c\x69\x62\x26\x65' + '\x0a\x86\x87'
+);
 
 const expected =
-    '64c486c55d30d4c5a079b8823b7d7cb37ff0556f537da8410233bcec330ed956';
+  '64c486c55d30d4c5a079b8823b7d7cb37ff0556f537da8410233bcec330ed956';
 const key = crypto.pbkdf2Sync('password', 'salt', 32, 32, 'sha256');
 assert.strictEqual(key.toString('hex'), expected);
 
@@ -60,60 +85,76 @@ function ondone(err, key) {
 }
 
 // Error path should not leak memory (check with valgrind).
-assert.throws(
-  () => crypto.pbkdf2('password', 'salt', 1, 20, null),
-  {
-    code: 'ERR_INVALID_CALLBACK',
-    name: 'TypeError [ERR_INVALID_CALLBACK]'
-  }
-);
+assert.throws(() => crypto.pbkdf2('password', 'salt', 1, 20, null), {
+  code: 'ERR_INVALID_CALLBACK',
+  name: 'TypeError [ERR_INVALID_CALLBACK]'
+});
 
-assert.throws(
-  () => crypto.pbkdf2Sync('password', 'salt', -1, 20, 'sha1'),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "iterations" is out of range. ' +
-             'It must be >= 0 && < 4294967296. Received -1'
-  }
-);
+assert.throws(() => crypto.pbkdf2Sync('password', 'salt', -1, 20, 'sha1'), {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError [ERR_OUT_OF_RANGE]',
+  message:
+    'The value of "iterations" is out of range. ' +
+    'It must be >= 0 && < 4294967296. Received -1'
+});
 
 ['str', null, undefined, [], {}].forEach((notNumber) => {
   assert.throws(
     () => {
       crypto.pbkdf2Sync('password', 'salt', 1, notNumber, 'sha256');
-    }, {
+    },
+    {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "keylen" argument must be of type number. ' +
-               `Received type ${typeof notNumber}`
-    });
+      message:
+        'The "keylen" argument must be of type number. ' +
+        `Received type ${typeof notNumber}`
+    }
+  );
 });
 
 [Infinity, -Infinity, NaN].forEach((input) => {
   assert.throws(
     () => {
-      crypto.pbkdf2('password', 'salt', 1, input, 'sha256',
-                    common.mustNotCall());
-    }, {
+      crypto.pbkdf2(
+        'password',
+        'salt',
+        1,
+        input,
+        'sha256',
+        common.mustNotCall()
+      );
+    },
+    {
       code: 'ERR_OUT_OF_RANGE',
       name: 'RangeError [ERR_OUT_OF_RANGE]',
-      message: 'The value of "keylen" is out of range. It ' +
-               `must be an integer. Received ${input}`
-    });
+      message:
+        'The value of "keylen" is out of range. It ' +
+        `must be an integer. Received ${input}`
+    }
+  );
 });
 
 [-1, 4294967297].forEach((input) => {
   assert.throws(
     () => {
-      crypto.pbkdf2('password', 'salt', 1, input, 'sha256',
-                    common.mustNotCall());
-    }, {
+      crypto.pbkdf2(
+        'password',
+        'salt',
+        1,
+        input,
+        'sha256',
+        common.mustNotCall()
+      );
+    },
+    {
       code: 'ERR_OUT_OF_RANGE',
       name: 'RangeError [ERR_OUT_OF_RANGE]',
-      message: 'The value of "keylen" is out of range. It ' +
-               `must be >= 0 && < 4294967296. Received ${input}`
-    });
+      message:
+        'The value of "keylen" is out of range. It ' +
+        `must be >= 0 && < 4294967296. Received ${input}`
+    }
+  );
 });
 
 // Should not get FATAL ERROR with empty password and salt
@@ -125,22 +166,23 @@ assert.throws(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "digest" argument must be one of type string or null. ' +
-             'Received type undefined'
-  });
+    message:
+      'The "digest" argument must be one of type string or null. ' +
+      'Received type undefined'
+  }
+);
 
-assert.throws(
-  () => crypto.pbkdf2Sync('password', 'salt', 8, 8),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "digest" argument must be one of type string or null. ' +
-             'Received type undefined'
-  });
+assert.throws(() => crypto.pbkdf2Sync('password', 'salt', 8, 8), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+  message:
+    'The "digest" argument must be one of type string or null. ' +
+    'Received type undefined'
+});
 
 [1, {}, [], true, undefined, null].forEach((input) => {
-  const msgPart2 = 'Buffer, TypedArray, or DataView.' +
-                   ` Received type ${typeof input}`;
+  const msgPart2 =
+    'Buffer, TypedArray, or DataView.' + ` Received type ${typeof input}`;
   assert.throws(
     () => crypto.pbkdf2(input, 'salt', 8, 8, 'sha256', common.mustNotCall()),
     {
@@ -159,23 +201,17 @@ assert.throws(
     }
   );
 
-  assert.throws(
-    () => crypto.pbkdf2Sync(input, 'salt', 8, 8, 'sha256'),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: `The "password" argument must be one of type string, ${msgPart2}`
-    }
-  );
+  assert.throws(() => crypto.pbkdf2Sync(input, 'salt', 8, 8, 'sha256'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message: `The "password" argument must be one of type string, ${msgPart2}`
+  });
 
-  assert.throws(
-    () => crypto.pbkdf2Sync('pass', input, 8, 8, 'sha256'),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: `The "salt" argument must be one of type string, ${msgPart2}`
-    }
-  );
+  assert.throws(() => crypto.pbkdf2Sync('pass', input, 8, 8, 'sha256'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message: `The "salt" argument must be one of type string, ${msgPart2}`
+  });
 });
 
 ['test', {}, [], true, undefined, null].forEach((i) => {
@@ -189,14 +225,11 @@ assert.throws(
     }
   );
 
-  assert.throws(
-    () => crypto.pbkdf2Sync('pass', 'salt', i, 8, 'sha256'),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: `The "iterations" argument must be of type number. ${received}`
-    }
-  );
+  assert.throws(() => crypto.pbkdf2Sync('pass', 'salt', i, 8, 'sha256'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message: `The "iterations" argument must be of type number. ${received}`
+  });
 });
 
 // Any TypedArray should work for password and salt
@@ -231,11 +264,8 @@ assert.throws(
   }
 );
 
-assert.throws(
-  () => crypto.pbkdf2Sync('pass', 'salt', 8, 8, 'md55'),
-  {
-    code: 'ERR_CRYPTO_INVALID_DIGEST',
-    name: 'TypeError [ERR_CRYPTO_INVALID_DIGEST]',
-    message: 'Invalid digest: md55'
-  }
-);
+assert.throws(() => crypto.pbkdf2Sync('pass', 'salt', 8, 8, 'md55'), {
+  code: 'ERR_CRYPTO_INVALID_DIGEST',
+  name: 'TypeError [ERR_CRYPTO_INVALID_DIGEST]',
+  message: 'Invalid digest: md55'
+});
diff --git a/test/parallel/test-crypto-random.js b/test/parallel/test-crypto-random.js
index df06134e4326f9..210c40ff86bbd8 100644
--- a/test/parallel/test-crypto-random.js
+++ b/test/parallel/test-crypto-random.js
@@ -23,8 +23,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -36,8 +35,11 @@ const kMaxPossibleLength = Math.min(kMaxLength, kMaxUint32);
 // bump, we register a lot of exit listeners
 process.setMaxListeners(256);
 
-common.expectWarning('DeprecationWarning',
-                     'crypto.pseudoRandomBytes is deprecated.', 'DEP0115');
+common.expectWarning(
+  'DeprecationWarning',
+  'crypto.pseudoRandomBytes is deprecated.',
+  'DEP0115'
+);
 
 {
   [crypto.randomBytes, crypto.pseudoRandomBytes].forEach((f) => {
@@ -45,8 +47,9 @@ common.expectWarning('DeprecationWarning',
       const errObj = {
         code: 'ERR_INVALID_ARG_TYPE',
         name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-        message: 'The "size" argument must be of type number. ' +
-                `Received type ${typeof value}`
+        message:
+          'The "size" argument must be of type number. ' +
+          `Received type ${typeof value}`
       };
       assert.throws(() => f(value), errObj);
       assert.throws(() => f(value, common.mustNotCall()), errObj);
@@ -56,19 +59,23 @@ common.expectWarning('DeprecationWarning',
       const errObj = {
         code: 'ERR_OUT_OF_RANGE',
         name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "size" is out of range. It must be >= 0 && <= ' +
-                 `${kMaxPossibleLength}. Received ${value}`
+        message:
+          'The value of "size" is out of range. It must be >= 0 && <= ' +
+          `${kMaxPossibleLength}. Received ${value}`
       };
       assert.throws(() => f(value), errObj);
       assert.throws(() => f(value, common.mustNotCall()), errObj);
     });
 
     [0, 1, 2, 4, 16, 256, 1024, 101.2].forEach((len) => {
-      f(len, common.mustCall((ex, buf) => {
-        assert.strictEqual(ex, null);
-        assert.strictEqual(buf.length, Math.floor(len));
-        assert.ok(Buffer.isBuffer(buf));
-      }));
+      f(
+        len,
+        common.mustCall((ex, buf) => {
+          assert.strictEqual(ex, null);
+          assert.strictEqual(buf.length, Math.floor(len));
+          assert.ok(Buffer.isBuffer(buf));
+        })
+      );
     });
   });
 }
@@ -106,21 +113,27 @@ common.expectWarning('DeprecationWarning',
 {
   const buf = Buffer.alloc(10);
   const before = buf.toString('hex');
-  crypto.randomFill(buf, common.mustCall((err, buf) => {
-    assert.ifError(err);
-    const after = buf.toString('hex');
-    assert.notStrictEqual(before, after);
-  }));
+  crypto.randomFill(
+    buf,
+    common.mustCall((err, buf) => {
+      assert.ifError(err);
+      const after = buf.toString('hex');
+      assert.notStrictEqual(before, after);
+    })
+  );
 }
 
 {
   const buf = new Uint8Array(new Array(10).fill(0));
   const before = Buffer.from(buf).toString('hex');
-  crypto.randomFill(buf, common.mustCall((err, buf) => {
-    assert.ifError(err);
-    const after = Buffer.from(buf).toString('hex');
-    assert.notStrictEqual(before, after);
-  }));
+  crypto.randomFill(
+    buf,
+    common.mustCall((err, buf) => {
+      assert.ifError(err);
+      const after = Buffer.from(buf).toString('hex');
+      assert.notStrictEqual(before, after);
+    })
+  );
 }
 
 {
@@ -132,11 +145,14 @@ common.expectWarning('DeprecationWarning',
     new DataView(new ArrayBuffer(10))
   ].forEach((buf) => {
     const before = Buffer.from(buf.buffer).toString('hex');
-    crypto.randomFill(buf, common.mustCall((err, buf) => {
-      assert.ifError(err);
-      const after = Buffer.from(buf.buffer).toString('hex');
-      assert.notStrictEqual(before, after);
-    }));
+    crypto.randomFill(
+      buf,
+      common.mustCall((err, buf) => {
+        assert.ifError(err);
+        const after = Buffer.from(buf.buffer).toString('hex');
+        assert.notStrictEqual(before, after);
+      })
+    );
   });
 }
 
@@ -170,48 +186,57 @@ common.expectWarning('DeprecationWarning',
 {
   const buf = Buffer.alloc(10);
   const before = buf.toString('hex');
-  crypto.randomFill(buf, 5, 5, common.mustCall((err, buf) => {
-    assert.ifError(err);
-    const after = buf.toString('hex');
-    assert.notStrictEqual(before, after);
-    assert.deepStrictEqual(before.slice(0, 5), after.slice(0, 5));
-  }));
+  crypto.randomFill(
+    buf,
+    5,
+    5,
+    common.mustCall((err, buf) => {
+      assert.ifError(err);
+      const after = buf.toString('hex');
+      assert.notStrictEqual(before, after);
+      assert.deepStrictEqual(before.slice(0, 5), after.slice(0, 5));
+    })
+  );
 }
 
 {
   const buf = new Uint8Array(new Array(10).fill(0));
   const before = Buffer.from(buf).toString('hex');
-  crypto.randomFill(buf, 5, 5, common.mustCall((err, buf) => {
-    assert.ifError(err);
-    const after = Buffer.from(buf).toString('hex');
-    assert.notStrictEqual(before, after);
-    assert.deepStrictEqual(before.slice(0, 5), after.slice(0, 5));
-  }));
+  crypto.randomFill(
+    buf,
+    5,
+    5,
+    common.mustCall((err, buf) => {
+      assert.ifError(err);
+      const after = Buffer.from(buf).toString('hex');
+      assert.notStrictEqual(before, after);
+      assert.deepStrictEqual(before.slice(0, 5), after.slice(0, 5));
+    })
+  );
 }
 
 {
-  [
-    Buffer.alloc(10),
-    new Uint8Array(new Array(10).fill(0))
-  ].forEach((buf) => {
+  [Buffer.alloc(10), new Uint8Array(new Array(10).fill(0))].forEach((buf) => {
     const len = Buffer.byteLength(buf);
     assert.strictEqual(len, 10, `Expected byteLength of 10, got ${len}`);
 
     const typeErrObj = {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "offset" argument must be of type number. ' +
-               'Received type string'
+      message:
+        'The "offset" argument must be of type number. ' +
+        'Received type string'
     };
 
     assert.throws(() => crypto.randomFillSync(buf, 'test'), typeErrObj);
 
     assert.throws(
       () => crypto.randomFill(buf, 'test', common.mustNotCall()),
-      typeErrObj);
+      typeErrObj
+    );
 
-    typeErrObj.message = 'The "size" argument must be of type number. ' +
-                     'Received type string';
+    typeErrObj.message =
+      'The "size" argument must be of type number. ' + 'Received type string';
     assert.throws(() => crypto.randomFillSync(buf, 0, 'test'), typeErrObj);
 
     assert.throws(
@@ -223,18 +248,21 @@ common.expectWarning('DeprecationWarning',
       const errObj = {
         code: 'ERR_OUT_OF_RANGE',
         name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "offset" is out of range. ' +
-                 `It must be >= 0 && <= 10. Received ${offsetSize}`
+        message:
+          'The value of "offset" is out of range. ' +
+          `It must be >= 0 && <= 10. Received ${offsetSize}`
       };
 
       assert.throws(() => crypto.randomFillSync(buf, offsetSize), errObj);
 
       assert.throws(
         () => crypto.randomFill(buf, offsetSize, common.mustNotCall()),
-        errObj);
+        errObj
+      );
 
-      errObj.message = 'The value of "size" is out of range. It must be >= ' +
-                       `0 && <= ${kMaxPossibleLength}. Received ${offsetSize}`;
+      errObj.message =
+        'The value of "size" is out of range. It must be >= ' +
+        `0 && <= ${kMaxPossibleLength}. Received ${offsetSize}`;
       assert.throws(() => crypto.randomFillSync(buf, 1, offsetSize), errObj);
 
       assert.throws(
@@ -246,8 +274,9 @@ common.expectWarning('DeprecationWarning',
     const rangeErrObj = {
       code: 'ERR_OUT_OF_RANGE',
       name: 'RangeError [ERR_OUT_OF_RANGE]',
-      message: 'The value of "size + offset" is out of range. ' +
-               'It must be <= 10. Received 11'
+      message:
+        'The value of "size + offset" is out of range. ' +
+        'It must be <= 10. Received 11'
     };
     assert.throws(() => crypto.randomFillSync(buf, 1, 10), rangeErrObj);
 
@@ -261,48 +290,35 @@ common.expectWarning('DeprecationWarning',
 // https://github.com/nodejs/node-v0.x-archive/issues/5126,
 // "FATAL ERROR: v8::Object::SetIndexedPropertiesToExternalArrayData() length
 // exceeds max acceptable value"
-assert.throws(
-  () => crypto.randomBytes((-1 >>> 0) + 1),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "size" is out of range. ' +
-             `It must be >= 0 && <= ${kMaxPossibleLength}. Received 4294967296`
-  }
-);
+assert.throws(() => crypto.randomBytes((-1 >>> 0) + 1), {
+  code: 'ERR_OUT_OF_RANGE',
+  name: 'RangeError [ERR_OUT_OF_RANGE]',
+  message:
+    'The value of "size" is out of range. ' +
+    `It must be >= 0 && <= ${kMaxPossibleLength}. Received 4294967296`
+});
 
 [1, true, NaN, null, undefined, {}, []].forEach((i) => {
   const buf = Buffer.alloc(10);
-  common.expectsError(
-    () => crypto.randomFillSync(i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => crypto.randomFill(i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => crypto.randomFill(buf, 0, 10, i),
-    {
-      code: 'ERR_INVALID_CALLBACK',
-      type: TypeError,
-      message: 'Callback must be a function',
-    });
+  common.expectsError(() => crypto.randomFillSync(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => crypto.randomFill(i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => crypto.randomFill(buf, 0, 10, i), {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError,
+    message: 'Callback must be a function'
+  });
 });
 
 [1, true, NaN, null, {}, []].forEach((i) => {
-  common.expectsError(
-    () => crypto.randomBytes(1, i),
-    {
-      code: 'ERR_INVALID_CALLBACK',
-      type: TypeError,
-      message: 'Callback must be a function',
-    }
-  );
+  common.expectsError(() => crypto.randomBytes(1, i), {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError,
+    message: 'Callback must be a function'
+  });
 });
diff --git a/test/parallel/test-crypto-rsa-dsa.js b/test/parallel/test-crypto-rsa-dsa.js
index 744dc5657b089d..a0ac5733263929 100644
--- a/test/parallel/test-crypto-rsa-dsa.js
+++ b/test/parallel/test-crypto-rsa-dsa.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -15,15 +14,18 @@ const certPem = fixtures.readSync('test_cert.pem', 'ascii');
 const keyPem = fixtures.readSync('test_key.pem', 'ascii');
 const rsaPubPem = fixtures.readSync('test_rsa_pubkey.pem', 'ascii');
 const rsaKeyPem = fixtures.readSync('test_rsa_privkey.pem', 'ascii');
-const rsaKeyPemEncrypted = fixtures.readSync('test_rsa_privkey_encrypted.pem',
-                                             'ascii');
+const rsaKeyPemEncrypted = fixtures.readSync(
+  'test_rsa_privkey_encrypted.pem',
+  'ascii'
+);
 const dsaPubPem = fixtures.readSync('test_dsa_pubkey.pem', 'ascii');
 const dsaKeyPem = fixtures.readSync('test_dsa_privkey.pem', 'ascii');
-const dsaKeyPemEncrypted = fixtures.readSync('test_dsa_privkey_encrypted.pem',
-                                             'ascii');
+const dsaKeyPemEncrypted = fixtures.readSync(
+  'test_dsa_privkey_encrypted.pem',
+  'ascii'
+);
 
-const decryptError =
-  /^Error: error:06065064:digital envelope routines:EVP_DecryptFinal_ex:bad decrypt$/;
+const decryptError = /^Error: error:06065064:digital envelope routines:EVP_DecryptFinal_ex:bad decrypt$/;
 
 // Test RSA encryption/decryption
 {
@@ -35,32 +37,47 @@ const decryptError =
   let decryptedBuffer = crypto.privateDecrypt(rsaKeyPem, encryptedBuffer);
   assert.strictEqual(decryptedBuffer.toString(), input);
 
-  let decryptedBufferWithPassword = crypto.privateDecrypt({
-    key: rsaKeyPemEncrypted,
-    passphrase: 'password'
-  }, encryptedBuffer);
+  let decryptedBufferWithPassword = crypto.privateDecrypt(
+    {
+      key: rsaKeyPemEncrypted,
+      passphrase: 'password'
+    },
+    encryptedBuffer
+  );
   assert.strictEqual(decryptedBufferWithPassword.toString(), input);
 
-  encryptedBuffer = crypto.publicEncrypt({
-    key: rsaKeyPemEncrypted,
-    passphrase: 'password'
-  }, bufferToEncrypt);
+  encryptedBuffer = crypto.publicEncrypt(
+    {
+      key: rsaKeyPemEncrypted,
+      passphrase: 'password'
+    },
+    bufferToEncrypt
+  );
 
-  decryptedBufferWithPassword = crypto.privateDecrypt({
-    key: rsaKeyPemEncrypted,
-    passphrase: 'password'
-  }, encryptedBuffer);
+  decryptedBufferWithPassword = crypto.privateDecrypt(
+    {
+      key: rsaKeyPemEncrypted,
+      passphrase: 'password'
+    },
+    encryptedBuffer
+  );
   assert.strictEqual(decryptedBufferWithPassword.toString(), input);
 
-  encryptedBuffer = crypto.privateEncrypt({
-    key: rsaKeyPemEncrypted,
-    passphrase: Buffer.from('password')
-  }, bufferToEncrypt);
+  encryptedBuffer = crypto.privateEncrypt(
+    {
+      key: rsaKeyPemEncrypted,
+      passphrase: Buffer.from('password')
+    },
+    bufferToEncrypt
+  );
 
-  decryptedBufferWithPassword = crypto.publicDecrypt({
-    key: rsaKeyPemEncrypted,
-    passphrase: Buffer.from('password')
-  }, encryptedBuffer);
+  decryptedBufferWithPassword = crypto.publicDecrypt(
+    {
+      key: rsaKeyPemEncrypted,
+      passphrase: Buffer.from('password')
+    },
+    encryptedBuffer
+  );
   assert.strictEqual(decryptedBufferWithPassword.toString(), input);
 
   encryptedBuffer = crypto.publicEncrypt(certPem, bufferToEncrypt);
@@ -79,50 +96,67 @@ const decryptError =
   assert.strictEqual(decryptedBuffer.toString(), input);
 
   assert.throws(() => {
-    crypto.privateDecrypt({
-      key: rsaKeyPemEncrypted,
-      passphrase: 'wrong'
-    }, bufferToEncrypt);
+    crypto.privateDecrypt(
+      {
+        key: rsaKeyPemEncrypted,
+        passphrase: 'wrong'
+      },
+      bufferToEncrypt
+    );
   }, decryptError);
 
   assert.throws(() => {
-    crypto.publicEncrypt({
-      key: rsaKeyPemEncrypted,
-      passphrase: 'wrong'
-    }, encryptedBuffer);
+    crypto.publicEncrypt(
+      {
+        key: rsaKeyPemEncrypted,
+        passphrase: 'wrong'
+      },
+      encryptedBuffer
+    );
   }, decryptError);
 
-  encryptedBuffer = crypto.privateEncrypt({
-    key: rsaKeyPemEncrypted,
-    passphrase: Buffer.from('password')
-  }, bufferToEncrypt);
+  encryptedBuffer = crypto.privateEncrypt(
+    {
+      key: rsaKeyPemEncrypted,
+      passphrase: Buffer.from('password')
+    },
+    bufferToEncrypt
+  );
 
   assert.throws(() => {
-    crypto.publicDecrypt({
-      key: rsaKeyPemEncrypted,
-      passphrase: [].concat.apply([], Buffer.from('password'))
-    }, encryptedBuffer);
+    crypto.publicDecrypt(
+      {
+        key: rsaKeyPemEncrypted,
+        passphrase: [].concat.apply([], Buffer.from('password'))
+      },
+      encryptedBuffer
+    );
   }, decryptError);
 }
 
 function test_rsa(padding) {
-  const size = (padding === 'RSA_NO_PADDING') ? 1024 / 8 : 32;
+  const size = padding === 'RSA_NO_PADDING' ? 1024 / 8 : 32;
   const input = Buffer.allocUnsafe(size);
-  for (let i = 0; i < input.length; i++)
-    input[i] = (i * 7 + 11) & 0xff;
+  for (let i = 0; i < input.length; i++) input[i] = (i * 7 + 11) & 0xff;
   const bufferToEncrypt = Buffer.from(input);
 
   padding = constants[padding];
 
-  const encryptedBuffer = crypto.publicEncrypt({
-    key: rsaPubPem,
-    padding: padding
-  }, bufferToEncrypt);
-
-  const decryptedBuffer = crypto.privateDecrypt({
-    key: rsaKeyPem,
-    padding: padding
-  }, encryptedBuffer);
+  const encryptedBuffer = crypto.publicEncrypt(
+    {
+      key: rsaPubPem,
+      padding: padding
+    },
+    bufferToEncrypt
+  );
+
+  const decryptedBuffer = crypto.privateDecrypt(
+    {
+      key: rsaKeyPem,
+      padding: padding
+    },
+    encryptedBuffer
+  );
   assert.deepStrictEqual(decryptedBuffer, input);
 }
 
@@ -137,11 +171,11 @@ assert.ok(rsaSign);
 assert.ok(rsaVerify);
 
 const expectedSignature =
-      '5c50e3145c4e2497aadb0eabc83b342d0b0021ece0d4c4a064b7c' +
-      '8f020d7e2688b122bfb54c724ac9ee169f83f66d2fe90abeb95e8' +
-      'e1290e7e177152a4de3d944cf7d4883114a20ed0f78e70e25ef0f' +
-      '60f06b858e6af42a2f276ede95bbc6bc9a9bbdda15bd663186a6f' +
-      '40819a7af19e577bb2efa5e579a1f5ce8a0d4ca8b8f6';
+  '5c50e3145c4e2497aadb0eabc83b342d0b0021ece0d4c4a064b7c' +
+  '8f020d7e2688b122bfb54c724ac9ee169f83f66d2fe90abeb95e8' +
+  'e1290e7e177152a4de3d944cf7d4883114a20ed0f78e70e25ef0f' +
+  '60f06b858e6af42a2f276ede95bbc6bc9a9bbdda15bd663186a6f' +
+  '40819a7af19e577bb2efa5e579a1f5ce8a0d4ca8b8f6';
 
 rsaSign.update(rsaPubPem);
 let rsaSignature = rsaSign.sign(rsaKeyPem, 'hex');
@@ -178,11 +212,11 @@ assert.throws(() => {
   const input = 'I AM THE WALRUS';
 
   const signature =
-      '79d59d34f56d0e94aa6a3e306882b52ed4191f07521f25f505a078dc2f89' +
-      '396e0c8ac89e996fde5717f4cb89199d8fec249961fcb07b74cd3d2a4ffa' +
-      '235417b69618e4bcd76b97e29975b7ce862299410e1b522a328e44ac9bb2' +
-      '8195e0268da7eda23d9825ac43c724e86ceeee0d0d4465678652ccaf6501' +
-      '0ddfb299bedeb1ad';
+    '79d59d34f56d0e94aa6a3e306882b52ed4191f07521f25f505a078dc2f89' +
+    '396e0c8ac89e996fde5717f4cb89199d8fec249961fcb07b74cd3d2a4ffa' +
+    '235417b69618e4bcd76b97e29975b7ce862299410e1b522a328e44ac9bb2' +
+    '8195e0268da7eda23d9825ac43c724e86ceeee0d0d4465678652ccaf6501' +
+    '0ddfb299bedeb1ad';
 
   const sign = crypto.createSign('SHA256');
   sign.update(input);
@@ -208,7 +242,6 @@ assert.throws(() => {
   assert.strictEqual(verify2.verify(publicKey, signature, 'hex'), true);
 }
 
-
 //
 // Test DSA signing and verification
 //
@@ -237,7 +270,6 @@ assert.throws(() => {
   assert.strictEqual(verify2.verify(dsaPubPem, signature2, 'hex'), true);
 }
 
-
 //
 // Test DSA signing and verification with encrypted key
 //
diff --git a/test/parallel/test-crypto-scrypt.js b/test/parallel/test-crypto-scrypt.js
index 55b5aeaf8ff06b..f7c3d96919a75b 100644
--- a/test/parallel/test-crypto-scrypt.js
+++ b/test/parallel/test-crypto-scrypt.js
@@ -1,8 +1,7 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -20,7 +19,7 @@ const good = [
     N: 16,
     p: 1,
     r: 1,
-    expected: '',
+    expected: ''
   },
   // Test vectors from https://tools.ietf.org/html/rfc7914#page-13 that
   // should pass.  Note that the test vector with N=1048576 is omitted
@@ -33,8 +32,8 @@ const good = [
     p: 1,
     r: 1,
     expected:
-        '77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442' +
-        'fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906',
+      '77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442' +
+      'fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906'
   },
   {
     pass: 'password',
@@ -44,8 +43,8 @@ const good = [
     p: 16,
     r: 8,
     expected:
-        'fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b373162' +
-        '2eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640',
+      'fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b373162' +
+      '2eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640'
   },
   {
     pass: 'pleaseletmein',
@@ -55,8 +54,8 @@ const good = [
     p: 1,
     r: 8,
     expected:
-        '7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2' +
-        'd5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887',
+      '7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2' +
+      'd5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887'
   },
   {
     pass: '',
@@ -66,8 +65,8 @@ const good = [
     parallelization: 1,
     blockSize: 1,
     expected:
-        '77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442' +
-        'fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906',
+      '77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442' +
+      'fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906'
   },
   {
     pass: 'password',
@@ -77,8 +76,8 @@ const good = [
     parallelization: 16,
     blockSize: 8,
     expected:
-        'fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b373162' +
-        '2eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640',
+      'fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b373162' +
+      '2eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640'
   },
   {
     pass: 'pleaseletmein',
@@ -88,94 +87,108 @@ const good = [
     parallelization: 1,
     blockSize: 8,
     expected:
-        '7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2' +
-        'd5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887',
-  },
+      '7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2' +
+      'd5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887'
+  }
 ];
 
 // Test vectors that should fail.
 const bad = [
-  { N: 1, p: 1, r: 1 },         // N < 2
-  { N: 3, p: 1, r: 1 },         // Not power of 2.
-  { N: 1, cost: 1 },            // both N and cost
+  { N: 1, p: 1, r: 1 }, // N < 2
+  { N: 3, p: 1, r: 1 }, // Not power of 2.
+  { N: 1, cost: 1 }, // both N and cost
   { p: 1, parallelization: 1 }, // both p and parallelization
-  { r: 1, blockSize: 1 }        // both r and blocksize
+  { r: 1, blockSize: 1 } // both r and blocksize
 ];
 
 // Test vectors where 128*N*r exceeds maxmem.
 const toobig = [
-  { N: 2 ** 16, p: 1, r: 1 },   // N >= 2**(r*16)
-  { N: 2, p: 2 ** 30, r: 1 },   // p > (2**30-1)/r
+  { N: 2 ** 16, p: 1, r: 1 }, // N >= 2**(r*16)
+  { N: 2, p: 2 ** 30, r: 1 }, // p > (2**30-1)/r
   { N: 2 ** 20, p: 1, r: 8 },
-  { N: 2 ** 10, p: 1, r: 8, maxmem: 2 ** 20 },
+  { N: 2 ** 10, p: 1, r: 8, maxmem: 2 ** 20 }
 ];
 
 const badargs = [
   {
     args: [],
-    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"password"/ },
+    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"password"/ }
   },
   {
     args: [null],
-    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"password"/ },
+    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"password"/ }
   },
   {
     args: [''],
-    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"salt"/ },
+    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"salt"/ }
   },
   {
     args: ['', null],
-    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"salt"/ },
+    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"salt"/ }
   },
   {
     args: ['', ''],
-    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"keylen"/ },
+    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"keylen"/ }
   },
   {
     args: ['', '', null],
-    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"keylen"/ },
+    expected: { code: 'ERR_INVALID_ARG_TYPE', message: /"keylen"/ }
   },
   {
-    args: ['', '', .42],
-    expected: { code: 'ERR_OUT_OF_RANGE', message: /"keylen"/ },
+    args: ['', '', 0.42],
+    expected: { code: 'ERR_OUT_OF_RANGE', message: /"keylen"/ }
   },
   {
     args: ['', '', -42],
-    expected: { code: 'ERR_OUT_OF_RANGE', message: /"keylen"/ },
-  },
+    expected: { code: 'ERR_OUT_OF_RANGE', message: /"keylen"/ }
+  }
 ];
 
 for (const options of good) {
   const { pass, salt, keylen, expected } = options;
   const actual = crypto.scryptSync(pass, salt, keylen, options);
   assert.strictEqual(actual.toString('hex'), expected);
-  crypto.scrypt(pass, salt, keylen, options, common.mustCall((err, actual) => {
-    assert.ifError(err);
-    assert.strictEqual(actual.toString('hex'), expected);
-  }));
+  crypto.scrypt(
+    pass,
+    salt,
+    keylen,
+    options,
+    common.mustCall((err, actual) => {
+      assert.ifError(err);
+      assert.strictEqual(actual.toString('hex'), expected);
+    })
+  );
 }
 
 for (const options of bad) {
   const expected = {
     code: 'ERR_CRYPTO_SCRYPT_INVALID_PARAMETER',
     message: 'Invalid scrypt parameter',
-    type: Error,
+    type: Error
   };
-  common.expectsError(() => crypto.scrypt('pass', 'salt', 1, options, () => {}),
-                      expected);
-  common.expectsError(() => crypto.scryptSync('pass', 'salt', 1, options),
-                      expected);
+  common.expectsError(
+    () => crypto.scrypt('pass', 'salt', 1, options, () => {}),
+    expected
+  );
+  common.expectsError(
+    () => crypto.scryptSync('pass', 'salt', 1, options),
+    expected
+  );
 }
 
 for (const options of toobig) {
   const expected = {
     message: /error:[^:]+:digital envelope routines:EVP_PBE_scrypt:memory limit exceeded/,
-    type: Error,
+    type: Error
   };
-  common.expectsError(() => crypto.scrypt('pass', 'salt', 1, options, () => {}),
-                      expected);
-  common.expectsError(() => crypto.scryptSync('pass', 'salt', 1, options),
-                      expected);
+  common.expectsError(
+    () => crypto.scrypt('pass', 'salt', 1, options, () => {}),
+    expected
+  );
+  common.expectsError(
+    () => crypto.scryptSync('pass', 'salt', 1, options),
+    expected
+  );
 }
 
 {
@@ -183,10 +196,15 @@ for (const options of toobig) {
   const expected = crypto.scryptSync('pass', 'salt', 1, defaults);
   const actual = crypto.scryptSync('pass', 'salt', 1);
   assert.deepStrictEqual(actual.toString('hex'), expected.toString('hex'));
-  crypto.scrypt('pass', 'salt', 1, common.mustCall((err, actual) => {
-    assert.ifError(err);
-    assert.deepStrictEqual(actual.toString('hex'), expected.toString('hex'));
-  }));
+  crypto.scrypt(
+    'pass',
+    'salt',
+    1,
+    common.mustCall((err, actual) => {
+      assert.ifError(err);
+      assert.deepStrictEqual(actual.toString('hex'), expected.toString('hex'));
+    })
+  );
 }
 
 {
@@ -199,10 +217,15 @@ for (const options of toobig) {
   const actual = crypto.scryptSync('pass', 'salt', 1);
   assert.deepStrictEqual(actual, expected.toString(testEncoding));
 
-  crypto.scrypt('pass', 'salt', 1, common.mustCall((err, actual) => {
-    assert.ifError(err);
-    assert.deepStrictEqual(actual, expected.toString(testEncoding));
-  }));
+  crypto.scrypt(
+    'pass',
+    'salt',
+    1,
+    common.mustCall((err, actual) => {
+      assert.ifError(err);
+      assert.deepStrictEqual(actual, expected.toString(testEncoding));
+    })
+  );
 
   crypto.DEFAULT_ENCODING = defaultEncoding;
 }
diff --git a/test/parallel/test-crypto-sign-verify.js b/test/parallel/test-crypto-sign-verify.js
index eaf555ff57f9d8..22b548305953e0 100644
--- a/test/parallel/test-crypto-sign-verify.js
+++ b/test/parallel/test-crypto-sign-verify.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fs = require('fs');
@@ -18,69 +17,87 @@ const modSize = 1024;
 {
   const Sign = crypto.Sign;
   const instance = Sign('SHA256');
-  assert(instance instanceof Sign, 'Sign is expected to return a new ' +
-                                   'instance when called without `new`');
+  assert(
+    instance instanceof Sign,
+    'Sign is expected to return a new ' + 'instance when called without `new`'
+  );
 }
 
 {
   const Verify = crypto.Verify;
   const instance = Verify('SHA256');
-  assert(instance instanceof Verify, 'Verify is expected to return a new ' +
-                                     'instance when called without `new`');
+  assert(
+    instance instanceof Verify,
+    'Verify is expected to return a new ' + 'instance when called without `new`'
+  );
 }
 
 common.expectsError(
-  () => crypto.createVerify('SHA256').verify({
-    key: certPem,
-    padding: undefined,
-  }, ''),
+  () =>
+    crypto.createVerify('SHA256').verify(
+      {
+        key: certPem,
+        padding: undefined
+      },
+      ''
+    ),
   {
     code: 'ERR_INVALID_OPT_VALUE',
     type: TypeError,
     message: 'The value "undefined" is invalid for option "padding"'
-  });
+  }
+);
 
 common.expectsError(
-  () => crypto.createVerify('SHA256').verify({
-    key: certPem,
-    saltLength: undefined,
-  }, ''),
+  () =>
+    crypto.createVerify('SHA256').verify(
+      {
+        key: certPem,
+        saltLength: undefined
+      },
+      ''
+    ),
   {
     code: 'ERR_INVALID_OPT_VALUE',
     type: TypeError,
     message: 'The value "undefined" is invalid for option "saltLength"'
-  });
+  }
+);
 
 // Test signing and verifying
 {
-  const s1 = crypto.createSign('SHA1')
-                   .update('Test123')
-                   .sign(keyPem, 'base64');
+  const s1 = crypto
+    .createSign('SHA1')
+    .update('Test123')
+    .sign(keyPem, 'base64');
   let s1stream = crypto.createSign('SHA1');
   s1stream.end('Test123');
   s1stream = s1stream.sign(keyPem, 'base64');
   assert.strictEqual(s1, s1stream, `${s1} should equal ${s1stream}`);
 
-  const verified = crypto.createVerify('SHA1')
-                         .update('Test')
-                         .update('123')
-                         .verify(certPem, s1, 'base64');
+  const verified = crypto
+    .createVerify('SHA1')
+    .update('Test')
+    .update('123')
+    .verify(certPem, s1, 'base64');
   assert.strictEqual(verified, true);
 }
 
 {
-  const s2 = crypto.createSign('SHA256')
-                   .update('Test123')
-                   .sign(keyPem, 'latin1');
+  const s2 = crypto
+    .createSign('SHA256')
+    .update('Test123')
+    .sign(keyPem, 'latin1');
   let s2stream = crypto.createSign('SHA256');
   s2stream.end('Test123');
   s2stream = s2stream.sign(keyPem, 'latin1');
   assert.strictEqual(s2, s2stream, `${s2} should equal ${s2stream}`);
 
-  let verified = crypto.createVerify('SHA256')
-                       .update('Test')
-                       .update('123')
-                       .verify(certPem, s2, 'latin1');
+  let verified = crypto
+    .createVerify('SHA256')
+    .update('Test')
+    .update('123')
+    .verify(certPem, s2, 'latin1');
   assert.strictEqual(verified, true);
 
   const verStream = crypto.createVerify('SHA256');
@@ -92,13 +109,15 @@ common.expectsError(
 }
 
 {
-  const s3 = crypto.createSign('SHA1')
-                   .update('Test123')
-                   .sign(keyPem, 'buffer');
-  let verified = crypto.createVerify('SHA1')
-                       .update('Test')
-                       .update('123')
-                       .verify(certPem, s3);
+  const s3 = crypto
+    .createSign('SHA1')
+    .update('Test123')
+    .sign(keyPem, 'buffer');
+  let verified = crypto
+    .createVerify('SHA1')
+    .update('Test')
+    .update('123')
+    .verify(certPem, s3);
   assert.strictEqual(verified, true);
 
   const verStream = crypto.createVerify('SHA1');
@@ -131,14 +150,22 @@ common.expectsError(
       getEffectiveSaltLength(crypto.constants.RSA_PSS_SALTLEN_DIGEST),
       crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN,
       getEffectiveSaltLength(crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN),
-      0, 16, 32, 64, 128
+      0,
+      16,
+      32,
+      64,
+      128
     ];
 
     const verifySaltLengths = [
       crypto.constants.RSA_PSS_SALTLEN_DIGEST,
       getEffectiveSaltLength(crypto.constants.RSA_PSS_SALTLEN_DIGEST),
       getEffectiveSaltLength(crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN),
-      0, 16, 32, 64, 128
+      0,
+      16,
+      32,
+      64,
+      128
     ];
     const errMessage = /^Error:.*data too large for key size$/;
 
@@ -146,7 +173,8 @@ common.expectsError(
       if (signSaltLength > max) {
         // If the salt length is too big, an Error should be thrown
         assert.throws(() => {
-          crypto.createSign(algo)
+          crypto
+            .createSign(algo)
             .update('Test123')
             .sign({
               key: keyPem,
@@ -156,48 +184,62 @@ common.expectsError(
         }, errMessage);
       } else {
         // Otherwise, a valid signature should be generated
-        const s4 = crypto.createSign(algo)
-                         .update('Test123')
-                         .sign({
-                           key: keyPem,
-                           padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-                           saltLength: signSaltLength
-                         });
+        const s4 = crypto
+          .createSign(algo)
+          .update('Test123')
+          .sign({
+            key: keyPem,
+            padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+            saltLength: signSaltLength
+          });
 
         let verified;
         verifySaltLengths.forEach((verifySaltLength) => {
           // Verification should succeed if and only if the salt length is
           // correct
-          verified = crypto.createVerify(algo)
-                           .update('Test123')
-                           .verify({
-                             key: certPem,
-                             padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-                             saltLength: verifySaltLength
-                           }, s4);
-          const saltLengthCorrect = getEffectiveSaltLength(signSaltLength) ===
-                                    getEffectiveSaltLength(verifySaltLength);
+          verified = crypto
+            .createVerify(algo)
+            .update('Test123')
+            .verify(
+              {
+                key: certPem,
+                padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+                saltLength: verifySaltLength
+              },
+              s4
+            );
+          const saltLengthCorrect =
+            getEffectiveSaltLength(signSaltLength) ===
+            getEffectiveSaltLength(verifySaltLength);
           assert.strictEqual(verified, saltLengthCorrect);
         });
 
         // Verification using RSA_PSS_SALTLEN_AUTO should always work
-        verified = crypto.createVerify(algo)
-                         .update('Test123')
-                         .verify({
-                           key: certPem,
-                           padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-                           saltLength: crypto.constants.RSA_PSS_SALTLEN_AUTO
-                         }, s4);
+        verified = crypto
+          .createVerify(algo)
+          .update('Test123')
+          .verify(
+            {
+              key: certPem,
+              padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+              saltLength: crypto.constants.RSA_PSS_SALTLEN_AUTO
+            },
+            s4
+          );
         assert.strictEqual(verified, true);
 
         // Verifying an incorrect message should never work
-        verified = crypto.createVerify(algo)
-                         .update('Test1234')
-                         .verify({
-                           key: certPem,
-                           padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-                           saltLength: crypto.constants.RSA_PSS_SALTLEN_AUTO
-                         }, s4);
+        verified = crypto
+          .createVerify(algo)
+          .update('Test1234')
+          .verify(
+            {
+              key: certPem,
+              padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+              saltLength: crypto.constants.RSA_PSS_SALTLEN_AUTO
+            },
+            s4
+          );
         assert.strictEqual(verified, false);
       }
     });
@@ -212,13 +254,18 @@ common.expectsError(
 {
   // We only test verification as we cannot specify explicit salts when signing
   function testVerify(cert, vector) {
-    const verified = crypto.createVerify('SHA1')
-                          .update(Buffer.from(vector.message, 'hex'))
-                          .verify({
-                            key: cert,
-                            padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-                            saltLength: vector.salt.length / 2
-                          }, vector.signature, 'hex');
+    const verified = crypto
+      .createVerify('SHA1')
+      .update(Buffer.from(vector.message, 'hex'))
+      .verify(
+        {
+          key: cert,
+          padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+          saltLength: vector.salt.length / 2
+        },
+        vector.signature,
+        'hex'
+      );
     assert.strictEqual(verified, true);
   }
 
@@ -233,36 +280,46 @@ common.expectsError(
 
 // Test exceptions for invalid `padding` and `saltLength` values
 {
-  [null, undefined, NaN, 'boom', {}, [], true, false]
-    .forEach((invalidValue) => {
-      common.expectsError(() => {
-        crypto.createSign('SHA256')
-          .update('Test123')
-          .sign({
-            key: keyPem,
-            padding: invalidValue
-          });
-      }, {
-        code: 'ERR_INVALID_OPT_VALUE',
-        type: TypeError
-      });
-
-      common.expectsError(() => {
-        crypto.createSign('SHA256')
-          .update('Test123')
-          .sign({
-            key: keyPem,
-            padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-            saltLength: invalidValue
-          });
-      }, {
-        code: 'ERR_INVALID_OPT_VALUE',
-        type: TypeError
-      });
-    });
+  [null, undefined, NaN, 'boom', {}, [], true, false].forEach(
+    (invalidValue) => {
+      common.expectsError(
+        () => {
+          crypto
+            .createSign('SHA256')
+            .update('Test123')
+            .sign({
+              key: keyPem,
+              padding: invalidValue
+            });
+        },
+        {
+          code: 'ERR_INVALID_OPT_VALUE',
+          type: TypeError
+        }
+      );
+
+      common.expectsError(
+        () => {
+          crypto
+            .createSign('SHA256')
+            .update('Test123')
+            .sign({
+              key: keyPem,
+              padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+              saltLength: invalidValue
+            });
+        },
+        {
+          code: 'ERR_INVALID_OPT_VALUE',
+          type: TypeError
+        }
+      );
+    }
+  );
 
   assert.throws(() => {
-    crypto.createSign('SHA1')
+    crypto
+      .createSign('SHA1')
       .update('Test123')
       .sign({
         key: keyPem,
@@ -273,24 +330,30 @@ common.expectsError(
 
 // Test throws exception when key options is null
 {
-  common.expectsError(() => {
-    crypto.createSign('SHA1').update('Test123').sign(null, 'base64');
-  }, {
-    code: 'ERR_CRYPTO_SIGN_KEY_REQUIRED',
-    type: Error
-  });
+  common.expectsError(
+    () => {
+      crypto
+        .createSign('SHA1')
+        .update('Test123')
+        .sign(null, 'base64');
+    },
+    {
+      code: 'ERR_CRYPTO_SIGN_KEY_REQUIRED',
+      type: Error
+    }
+  );
 }
 
 // RSA-PSS Sign test by verifying with 'openssl dgst -verify'
 {
-  if (!common.opensslCli)
-    common.skip('node compiled without OpenSSL CLI.');
+  if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
   const pubfile = fixtures.path('keys', 'rsa_public_2048.pem');
   const privkey = fixtures.readKey('rsa_private_2048.pem');
 
   const msg = 'Test123';
-  const s5 = crypto.createSign('SHA256')
+  const s5 = crypto
+    .createSign('SHA256')
     .update(msg)
     .sign({
       key: privkey,
@@ -305,14 +368,16 @@ common.expectsError(
   const msgfile = path.join(tmpdir.path, 's5.msg');
   fs.writeFileSync(msgfile, msg);
 
-  const cmd =
-    `"${common.opensslCli}" dgst -sha256 -verify "${pubfile}" -signature "${
-      sigfile}" -sigopt rsa_padding_mode:pss -sigopt rsa_pss_saltlen:-2 "${
-      msgfile}"`;
+  const cmd = `"${
+    common.opensslCli
+  }" dgst -sha256 -verify "${pubfile}" -signature "${sigfile}" -sigopt rsa_padding_mode:pss -sigopt rsa_pss_saltlen:-2 "${msgfile}"`;
 
-  exec(cmd, common.mustCall((err, stdout, stderr) => {
-    assert(stdout.includes('Verified OK'));
-  }));
+  exec(
+    cmd,
+    common.mustCall((err, stdout, stderr) => {
+      assert(stdout.includes('Verified OK'));
+    })
+  );
 }
 
 {
@@ -324,42 +389,46 @@ common.expectsError(
     const errObj = {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "algorithm" argument must be of type string. ' +
-               `Received type ${type}`
+      message:
+        'The "algorithm" argument must be of type string. ' +
+        `Received type ${type}`
     };
     assert.throws(() => crypto.createSign(input), errObj);
     assert.throws(() => crypto.createVerify(input), errObj);
 
-    errObj.message = 'The "data" argument must be one of type string, ' +
-                     `Buffer, TypedArray, or DataView. Received type ${type}`;
+    errObj.message =
+      'The "data" argument must be one of type string, ' +
+      `Buffer, TypedArray, or DataView. Received type ${type}`;
     assert.throws(() => sign.update(input), errObj);
     assert.throws(() => verify.update(input), errObj);
     assert.throws(() => sign._write(input, 'utf8', () => {}), errObj);
     assert.throws(() => verify._write(input, 'utf8', () => {}), errObj);
   });
 
-  [
-    Uint8Array, Uint16Array, Uint32Array, Float32Array, Float64Array
-  ].forEach((clazz) => {
-    // These should all just work
-    sign.update(new clazz());
-    verify.update(new clazz());
-  });
+  [Uint8Array, Uint16Array, Uint32Array, Float32Array, Float64Array].forEach(
+    (clazz) => {
+      // These should all just work
+      sign.update(new clazz());
+      verify.update(new clazz());
+    }
+  );
 
   [1, {}, [], Infinity].forEach((input) => {
     const type = typeof input;
     const errObj = {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "key" argument must be one of type string, Buffer, ' +
-               `TypedArray, or DataView. Received type ${type}`
+      message:
+        'The "key" argument must be one of type string, Buffer, ' +
+        `TypedArray, or DataView. Received type ${type}`
     };
 
     assert.throws(() => sign.sign(input), errObj);
     assert.throws(() => verify.verify(input), errObj);
 
-    errObj.message = 'The "signature" argument must be one of type string, ' +
-                     `Buffer, TypedArray, or DataView. Received type ${type}`;
+    errObj.message =
+      'The "signature" argument must be one of type string, ' +
+      `Buffer, TypedArray, or DataView. Received type ${type}`;
     assert.throws(() => verify.verify('test', input), errObj);
   });
 }
diff --git a/test/parallel/test-crypto-stream.js b/test/parallel/test-crypto-stream.js
index 9430084bbee179..a62b2f43ea7bc3 100644
--- a/test/parallel/test-crypto-stream.js
+++ b/test/parallel/test-crypto-stream.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const stream = require('stream');
@@ -48,12 +47,17 @@ if (!common.hasFipsCrypto) {
 
   // Create an md5 hash of "Hallo world"
   const hasher1 = crypto.createHash('md5');
-  hasher1.pipe(new Stream2buffer(common.mustCall(function end(err, hash) {
-    assert.strictEqual(err, null);
-    assert.strictEqual(
-      hash.toString('hex'), '06460dadb35d3d503047ce750ceb2d07'
-    );
-  })));
+  hasher1.pipe(
+    new Stream2buffer(
+      common.mustCall(function end(err, hash) {
+        assert.strictEqual(err, null);
+        assert.strictEqual(
+          hash.toString('hex'),
+          '06460dadb35d3d503047ce750ceb2d07'
+        );
+      })
+    )
+  );
   hasher1.end('Hallo world');
 
   // Simpler check for unpipe, setEncoding, pause and resume
@@ -70,9 +74,11 @@ const iv = Buffer.from('6d358219d1f488f5f4eb12820a66d146', 'hex');
 const cipher = crypto.createCipheriv('aes-128-cbc', key, iv);
 const decipher = crypto.createDecipheriv('aes-128-cbc', badkey, iv);
 
-cipher.pipe(decipher)
-  .on('error', common.mustCall(function end(err) {
+cipher.pipe(decipher).on(
+  'error',
+  common.mustCall(function end(err) {
     assert(/bad decrypt/.test(err));
-  }));
+  })
+);
 
-cipher.end('Papaya!');  // Should not cause an unhandled exception.
+cipher.end('Papaya!'); // Should not cause an unhandled exception.
diff --git a/test/parallel/test-crypto-tostring-segfault.js b/test/parallel/test-crypto-tostring-segfault.js
index b2c95117d3b1f8..60c264756730a1 100644
--- a/test/parallel/test-crypto-tostring-segfault.js
+++ b/test/parallel/test-crypto-tostring-segfault.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // This test ensures that node doesn't SEGFAULT when either of
 // `crypto.createHash` or `crypto.createHmac` are given an object that defines
@@ -21,7 +20,11 @@ const scripts = [
 scripts.forEach((script) => {
   const node = process.execPath;
   const code = `${setup};${script}`;
-  execFile(node, [ '-e', code ], common.mustCall((err, stdout, stderr) => {
-    assert(stderr.includes('Error: xyz'), 'digest crashes');
-  }));
+  execFile(
+    node,
+    ['-e', code],
+    common.mustCall((err, stdout, stderr) => {
+      assert(stderr.includes('Error: xyz'), 'digest crashes');
+    })
+  );
 });
diff --git a/test/parallel/test-crypto-verify-failure.js b/test/parallel/test-crypto-verify-failure.js
index 7e9fda9f6791f6..274e2c2a17de39 100644
--- a/test/parallel/test-crypto-verify-failure.js
+++ b/test/parallel/test-crypto-verify-failure.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const crypto = require('crypto');
 const tls = require('tls');
@@ -46,22 +45,34 @@ const server = tls.Server(options, (socket) => {
 });
 
 function verify() {
-  crypto.createVerify('SHA1')
+  crypto
+    .createVerify('SHA1')
     .update('Test')
     .verify(certPem, 'asdfasdfas', 'base64');
 }
 
-server.listen(0, common.mustCall(() => {
-  tls.connect({
-    port: server.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(() => {
-    verify();
-  }))
-    .on('error', common.mustNotCall())
-    .on('close', common.mustCall(() => {
-      server.close();
-    })).resume();
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    tls
+      .connect(
+        {
+          port: server.address().port,
+          rejectUnauthorized: false
+        },
+        common.mustCall(() => {
+          verify();
+        })
+      )
+      .on('error', common.mustNotCall())
+      .on(
+        'close',
+        common.mustCall(() => {
+          server.close();
+        })
+      )
+      .resume();
+  })
+);
 
 server.unref();
diff --git a/test/parallel/test-crypto.js b/test/parallel/test-crypto.js
index 21e2cca5bd3329..5825a9c8480424 100644
--- a/test/parallel/test-crypto.js
+++ b/test/parallel/test-crypto.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 common.expectWarning({
   DeprecationWarning: [
@@ -42,69 +41,85 @@ const certPfx = fixtures.readSync('test_cert.pfx');
 
 // 'this' safety
 // https://github.com/joyent/node/issues/6690
-assert.throws(function() {
-  const credentials = tls.createSecureContext();
-  const context = credentials.context;
-  const notcontext = { setOptions: context.setOptions };
-
-  // Methods of native objects should not segfault when reassigned to a new
-  // object and called illegally. This core dumped in 0.10 and was fixed in
-  // 0.11.
-  notcontext.setOptions();
-}, (err) => {
-  // Throws TypeError, so there is no opensslErrorStack property.
-  if ((err instanceof Error) &&
+assert.throws(
+  function() {
+    const credentials = tls.createSecureContext();
+    const context = credentials.context;
+    const notcontext = { setOptions: context.setOptions };
+
+    // Methods of native objects should not segfault when reassigned to a new
+    // object and called illegally. This core dumped in 0.10 and was fixed in
+    // 0.11.
+    notcontext.setOptions();
+  },
+  (err) => {
+    // Throws TypeError, so there is no opensslErrorStack property.
+    if (
+      err instanceof Error &&
       /^TypeError: Illegal invocation$/.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
+);
 
 // PFX tests
 tls.createSecureContext({ pfx: certPfx, passphrase: 'sample' });
 
-assert.throws(function() {
-  tls.createSecureContext({ pfx: certPfx });
-}, (err) => {
-  // Throws general Error, so there is no opensslErrorStack property.
-  if ((err instanceof Error) &&
+assert.throws(
+  function() {
+    tls.createSecureContext({ pfx: certPfx });
+  },
+  (err) => {
+    // Throws general Error, so there is no opensslErrorStack property.
+    if (
+      err instanceof Error &&
       /^Error: mac verify failure$/.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
-
-assert.throws(function() {
-  tls.createSecureContext({ pfx: certPfx, passphrase: 'test' });
-}, (err) => {
-  // Throws general Error, so there is no opensslErrorStack property.
-  if ((err instanceof Error) &&
+);
+
+assert.throws(
+  function() {
+    tls.createSecureContext({ pfx: certPfx, passphrase: 'test' });
+  },
+  (err) => {
+    // Throws general Error, so there is no opensslErrorStack property.
+    if (
+      err instanceof Error &&
       /^Error: mac verify failure$/.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
-
-assert.throws(function() {
-  tls.createSecureContext({ pfx: 'sample', passphrase: 'test' });
-}, (err) => {
-  // Throws general Error, so there is no opensslErrorStack property.
-  if ((err instanceof Error) &&
+);
+
+assert.throws(
+  function() {
+    tls.createSecureContext({ pfx: 'sample', passphrase: 'test' });
+  },
+  (err) => {
+    // Throws general Error, so there is no opensslErrorStack property.
+    if (
+      err instanceof Error &&
       /^Error: not enough data$/.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
-
+);
 
 // update() should only take buffers / strings
-common.expectsError(
-  () => crypto.createHash('sha1').update({ foo: 'bar' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError
-  });
-
+common.expectsError(() => crypto.createHash('sha1').update({ foo: 'bar' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError
+});
 
 function validateList(list) {
   // The list must not be empty
@@ -167,101 +182,138 @@ testImmutability(crypto.getCurves);
 
 // Regression tests for https://github.com/nodejs/node-v0.x-archive/pull/5725:
 // hex input that's not a power of two should throw, not assert in C++ land.
-assert.throws(function() {
-  crypto.createCipher('aes192', 'test').update('0', 'hex');
-}, (err) => {
-  const errorMessage =
-    common.hasFipsCrypto ? /not supported in FIPS mode/ : /Bad input string/;
-  // Throws general Error, so there is no opensslErrorStack property.
-  if ((err instanceof Error) &&
+assert.throws(
+  function() {
+    crypto.createCipher('aes192', 'test').update('0', 'hex');
+  },
+  (err) => {
+    const errorMessage = common.hasFipsCrypto
+      ? /not supported in FIPS mode/
+      : /Bad input string/;
+    // Throws general Error, so there is no opensslErrorStack property.
+    if (
+      err instanceof Error &&
       errorMessage.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
-
-assert.throws(function() {
-  crypto.createDecipher('aes192', 'test').update('0', 'hex');
-}, (err) => {
-  const errorMessage =
-    common.hasFipsCrypto ? /not supported in FIPS mode/ : /Bad input string/;
-  // Throws general Error, so there is no opensslErrorStack property.
-  if ((err instanceof Error) &&
+);
+
+assert.throws(
+  function() {
+    crypto.createDecipher('aes192', 'test').update('0', 'hex');
+  },
+  (err) => {
+    const errorMessage = common.hasFipsCrypto
+      ? /not supported in FIPS mode/
+      : /Bad input string/;
+    // Throws general Error, so there is no opensslErrorStack property.
+    if (
+      err instanceof Error &&
       errorMessage.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
-
-assert.throws(function() {
-  crypto.createHash('sha1').update('0', 'hex');
-}, (err) => {
-  // Throws TypeError, so there is no opensslErrorStack property.
-  if ((err instanceof Error) &&
+);
+
+assert.throws(
+  function() {
+    crypto.createHash('sha1').update('0', 'hex');
+  },
+  (err) => {
+    // Throws TypeError, so there is no opensslErrorStack property.
+    if (
+      err instanceof Error &&
       /^TypeError: Bad input string$/.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
-
-assert.throws(function() {
-  const priv = [
-    '-----BEGIN RSA PRIVATE KEY-----',
-    'MIGrAgEAAiEA+3z+1QNF2/unumadiwEr+C5vfhezsb3hp4jAnCNRpPcCAwEAAQIgQNriSQK4',
-    'EFwczDhMZp2dvbcz7OUUyt36z3S4usFPHSECEQD/41K7SujrstBfoCPzwC1xAhEA+5kt4BJy',
-    'eKN7LggbF3Dk5wIQN6SL+fQ5H/+7NgARsVBp0QIRANxYRukavs4QvuyNhMx+vrkCEQCbf6j/',
-    'Ig6/HueCK/0Jkmp+',
-    '-----END RSA PRIVATE KEY-----',
-    ''
-  ].join('\n');
-  crypto.createSign('SHA256').update('test').sign(priv);
-}, (err) => {
-  if ((err instanceof Error) &&
+);
+
+assert.throws(
+  function() {
+    const priv = [
+      '-----BEGIN RSA PRIVATE KEY-----',
+      'MIGrAgEAAiEA+3z+1QNF2/unumadiwEr+C5vfhezsb3hp4jAnCNRpPcCAwEAAQIgQNriSQK4',
+      'EFwczDhMZp2dvbcz7OUUyt36z3S4usFPHSECEQD/41K7SujrstBfoCPzwC1xAhEA+5kt4BJy',
+      'eKN7LggbF3Dk5wIQN6SL+fQ5H/+7NgARsVBp0QIRANxYRukavs4QvuyNhMx+vrkCEQCbf6j/',
+      'Ig6/HueCK/0Jkmp+',
+      '-----END RSA PRIVATE KEY-----',
+      ''
+    ].join('\n');
+    crypto
+      .createSign('SHA256')
+      .update('test')
+      .sign(priv);
+  },
+  (err) => {
+    if (
+      err instanceof Error &&
       /digest too big for rsa key$/.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
-
-assert.throws(function() {
-  // The correct header inside `test_bad_rsa_privkey.pem` should have been
-  // -----BEGIN PRIVATE KEY----- and -----END PRIVATE KEY-----
-  // instead of
-  // -----BEGIN RSA PRIVATE KEY----- and -----END RSA PRIVATE KEY-----
-  // It is generated in this way:
-  //   $ openssl genrsa -out mykey.pem 512;
-  //   $ openssl pkcs8 -topk8 -inform PEM -outform PEM -in mykey.pem \
-  //     -out private_key.pem -nocrypt;
-  //   Then open private_key.pem and change its header and footer.
-  const sha1_privateKey = fixtures.readSync('test_bad_rsa_privkey.pem',
-                                            'ascii');
-  // this would inject errors onto OpenSSL's error stack
-  crypto.createSign('sha1').sign(sha1_privateKey);
-}, (err) => {
-  // Throws crypto error, so there is an opensslErrorStack property.
-  // The openSSL stack should have content.
-  if ((err instanceof Error) &&
+);
+
+assert.throws(
+  function() {
+    // The correct header inside `test_bad_rsa_privkey.pem` should have been
+    // -----BEGIN PRIVATE KEY----- and -----END PRIVATE KEY-----
+    // instead of
+    // -----BEGIN RSA PRIVATE KEY----- and -----END RSA PRIVATE KEY-----
+    // It is generated in this way:
+    //   $ openssl genrsa -out mykey.pem 512;
+    //   $ openssl pkcs8 -topk8 -inform PEM -outform PEM -in mykey.pem \
+    //     -out private_key.pem -nocrypt;
+    //   Then open private_key.pem and change its header and footer.
+    const sha1_privateKey = fixtures.readSync(
+      'test_bad_rsa_privkey.pem',
+      'ascii'
+    );
+    // this would inject errors onto OpenSSL's error stack
+    crypto.createSign('sha1').sign(sha1_privateKey);
+  },
+  (err) => {
+    // Throws crypto error, so there is an opensslErrorStack property.
+    // The openSSL stack should have content.
+    if (
+      err instanceof Error &&
       /asn1 encoding routines:[^:]*:wrong tag/.test(err) &&
       err.opensslErrorStack !== undefined &&
       Array.isArray(err.opensslErrorStack) &&
-      err.opensslErrorStack.length > 0) {
-    return true;
+      err.opensslErrorStack.length > 0
+    ) {
+      return true;
+    }
   }
-});
+);
 
 // Make sure memory isn't released before being returned
 console.log(crypto.randomBytes(16));
 
-assert.throws(function() {
-  tls.createSecureContext({ crl: 'not a CRL' });
-}, (err) => {
-  // Throws general error, so there is no opensslErrorStack property.
-  if ((err instanceof Error) &&
+assert.throws(
+  function() {
+    tls.createSecureContext({ crl: 'not a CRL' });
+  },
+  (err) => {
+    // Throws general error, so there is no opensslErrorStack property.
+    if (
+      err instanceof Error &&
       /^Error: Failed to parse CRL$/.test(err) &&
-      err.opensslErrorStack === undefined) {
-    return true;
+      err.opensslErrorStack === undefined
+    ) {
+      return true;
+    }
   }
-});
+);
 
 /**
  * Check if the stream function uses utf8 as a default encoding.
@@ -275,9 +327,12 @@ function testEncoding(options, assertionHash) {
     hashValue += data.toString('hex');
   });
 
-  hash.on('end', common.mustCall(() => {
-    assert.strictEqual(hashValue, assertionHash);
-  }));
+  hash.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(hashValue, assertionHash);
+    })
+  );
 
   hash.write('öäü');
   hash.end();
@@ -294,13 +349,19 @@ const assertionHashLatin1 =
 testEncoding(undefined, assertionHashUtf8);
 testEncoding({}, assertionHashUtf8);
 
-testEncoding({
-  defaultEncoding: 'utf8'
-}, assertionHashUtf8);
+testEncoding(
+  {
+    defaultEncoding: 'utf8'
+  },
+  assertionHashUtf8
+);
 
-testEncoding({
-  defaultEncoding: 'latin1'
-}, assertionHashLatin1);
+testEncoding(
+  {
+    defaultEncoding: 'latin1'
+  },
+  assertionHashLatin1
+);
 
 {
   // Test that the exported _toBuf function is deprecated.
diff --git a/test/parallel/test-cwd-enoent-preload.js b/test/parallel/test-cwd-enoent-preload.js
index 2077d9c1478335..8278a3aac4bfce 100644
--- a/test/parallel/test-cwd-enoent-preload.js
+++ b/test/parallel/test-cwd-enoent-preload.js
@@ -19,12 +19,14 @@ fs.mkdirSync(dirname);
 process.chdir(dirname);
 fs.rmdirSync(dirname);
 
-
 const proc = spawn(process.execPath, ['-r', abspathFile, '-e', '0']);
 proc.stdout.pipe(process.stdout);
 proc.stderr.pipe(process.stderr);
 
-proc.once('exit', common.mustCall(function(exitCode, signalCode) {
-  assert.strictEqual(exitCode, 0);
-  assert.strictEqual(signalCode, null);
-}));
+proc.once(
+  'exit',
+  common.mustCall(function(exitCode, signalCode) {
+    assert.strictEqual(exitCode, 0);
+    assert.strictEqual(signalCode, null);
+  })
+);
diff --git a/test/parallel/test-cwd-enoent-repl.js b/test/parallel/test-cwd-enoent-repl.js
index 5ea8abc7e42b52..0c38c3e2a783a9 100644
--- a/test/parallel/test-cwd-enoent-repl.js
+++ b/test/parallel/test-cwd-enoent-repl.js
@@ -24,7 +24,10 @@ proc.stderr.pipe(process.stderr);
 proc.stdin.write('require("path");\n');
 proc.stdin.write('process.exit(42);\n');
 
-proc.once('exit', common.mustCall(function(exitCode, signalCode) {
-  assert.strictEqual(exitCode, 42);
-  assert.strictEqual(signalCode, null);
-}));
+proc.once(
+  'exit',
+  common.mustCall(function(exitCode, signalCode) {
+    assert.strictEqual(exitCode, 42);
+    assert.strictEqual(signalCode, null);
+  })
+);
diff --git a/test/parallel/test-cwd-enoent.js b/test/parallel/test-cwd-enoent.js
index 8beb1e3fbe0a05..4842ab5499fd33 100644
--- a/test/parallel/test-cwd-enoent.js
+++ b/test/parallel/test-cwd-enoent.js
@@ -22,7 +22,10 @@ const proc = spawn(process.execPath, ['-e', '0']);
 proc.stdout.pipe(process.stdout);
 proc.stderr.pipe(process.stderr);
 
-proc.once('exit', common.mustCall(function(exitCode, signalCode) {
-  assert.strictEqual(exitCode, 0);
-  assert.strictEqual(signalCode, null);
-}));
+proc.once(
+  'exit',
+  common.mustCall(function(exitCode, signalCode) {
+    assert.strictEqual(exitCode, 0);
+    assert.strictEqual(signalCode, null);
+  })
+);
diff --git a/test/parallel/test-debug-args.js b/test/parallel/test-debug-args.js
index bb7ec5582401a6..cd1019901524f6 100644
--- a/test/parallel/test-debug-args.js
+++ b/test/parallel/test-debug-args.js
@@ -4,7 +4,6 @@
 const common = require('../common');
 const assert = require('assert');
 
-if (!common.isMainThread)
-  common.skip('execArgv does not affect Workers');
+if (!common.isMainThread) common.skip('execArgv does not affect Workers');
 
 assert(process.execArgv.includes('--debug-code'));
diff --git a/test/parallel/test-debug-usage.js b/test/parallel/test-debug-usage.js
index a264029f434a5a..d5e83e3d6350b6 100644
--- a/test/parallel/test-debug-usage.js
+++ b/test/parallel/test-debug-usage.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
@@ -20,9 +19,12 @@ child.stderr.on('data', function(data) {
   actualUsageMessage += data.toString();
 });
 
-child.on('exit', common.mustCall(function(code) {
-  const outputLines = actualUsageMessage.split('\n');
-  assert.strictEqual(code, 1);
-  for (let i = 0; i < expectedLines.length; i++)
-    assert(expectedLines[i].test(outputLines[i]));
-}));
+child.on(
+  'exit',
+  common.mustCall(function(code) {
+    const outputLines = actualUsageMessage.split('\n');
+    assert.strictEqual(code, 1);
+    for (let i = 0; i < expectedLines.length; i++)
+      assert(expectedLines[i].test(outputLines[i]));
+  })
+);
diff --git a/test/parallel/test-debugger-pid.js b/test/parallel/test-debugger-pid.js
index e11d23152f7057..82719e0f1351d7 100644
--- a/test/parallel/test-debugger-pid.js
+++ b/test/parallel/test-debugger-pid.js
@@ -27,8 +27,9 @@ interfacer.on('line', function(line) {
   const pid = interfacer.pid;
   switch (++lineCount) {
     case 1:
-      expected =
-        new RegExp(`^\\(node:${pid}\\) \\[DEP0068\\] DeprecationWarning: `);
+      expected = new RegExp(
+        `^\\(node:${pid}\\) \\[DEP0068\\] DeprecationWarning: `
+      );
       assert.ok(expected.test(line), `expected regexp match for ${line}`);
       break;
     case 2:
@@ -40,8 +41,7 @@ interfacer.on('line', function(line) {
       break;
 
     default:
-      if (!common.isWindows)
-        assert.fail(`unexpected line received: ${line}`);
+      if (!common.isWindows) assert.fail(`unexpected line received: ${line}`);
   }
 });
 
diff --git a/test/parallel/test-delayed-require.js b/test/parallel/test-delayed-require.js
index 355d503d2650d2..71097b814026bf 100644
--- a/test/parallel/test-delayed-require.js
+++ b/test/parallel/test-delayed-require.js
@@ -24,9 +24,12 @@ const common = require('../common');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 
-setTimeout(common.mustCall(function() {
-  const a = require(fixtures.path('a'));
-  assert.strictEqual('A' in a, true);
-  assert.strictEqual(a.A(), 'A');
-  assert.strictEqual(a.D(), 'D');
-}), 50);
+setTimeout(
+  common.mustCall(function() {
+    const a = require(fixtures.path('a'));
+    assert.strictEqual('A' in a, true);
+    assert.strictEqual(a.A(), 'A');
+    assert.strictEqual(a.D(), 'D');
+  }),
+  50
+);
diff --git a/test/parallel/test-dgram-address.js b/test/parallel/test-dgram-address.js
index f14b910fc27a2b..b6414e84eeab0b 100644
--- a/test/parallel/test-dgram-address.js
+++ b/test/parallel/test-dgram-address.js
@@ -28,16 +28,19 @@ const dgram = require('dgram');
   // IPv4 Test
   const socket = dgram.createSocket('udp4');
 
-  socket.on('listening', common.mustCall(() => {
-    const address = socket.address();
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      const address = socket.address();
 
-    assert.strictEqual(address.address, common.localhostIPv4);
-    assert.strictEqual(typeof address.port, 'number');
-    assert.ok(isFinite(address.port));
-    assert.ok(address.port > 0);
-    assert.strictEqual(address.family, 'IPv4');
-    socket.close();
-  }));
+      assert.strictEqual(address.address, common.localhostIPv4);
+      assert.strictEqual(typeof address.port, 'number');
+      assert.ok(isFinite(address.port));
+      assert.ok(address.port > 0);
+      assert.strictEqual(address.family, 'IPv4');
+      socket.close();
+    })
+  );
 
   socket.on('error', (err) => {
     socket.close();
@@ -52,16 +55,19 @@ if (common.hasIPv6) {
   const socket = dgram.createSocket('udp6');
   const localhost = '::1';
 
-  socket.on('listening', common.mustCall(() => {
-    const address = socket.address();
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      const address = socket.address();
 
-    assert.strictEqual(address.address, localhost);
-    assert.strictEqual(typeof address.port, 'number');
-    assert.ok(isFinite(address.port));
-    assert.ok(address.port > 0);
-    assert.strictEqual(address.family, 'IPv6');
-    socket.close();
-  }));
+      assert.strictEqual(address.address, localhost);
+      assert.strictEqual(typeof address.port, 'number');
+      assert.ok(isFinite(address.port));
+      assert.ok(address.port > 0);
+      assert.strictEqual(address.family, 'IPv6');
+      socket.close();
+    })
+  );
 
   socket.on('error', (err) => {
     socket.close();
diff --git a/test/parallel/test-dgram-bind-default-address.js b/test/parallel/test-dgram-bind-default-address.js
index 762ead7c869e8d..c0ca5daf0dd3f4 100644
--- a/test/parallel/test-dgram-bind-default-address.js
+++ b/test/parallel/test-dgram-bind-default-address.js
@@ -22,32 +22,36 @@
 'use strict';
 const common = require('../common');
 // skip test in FreeBSD jails since 0.0.0.0 will resolve to default interface
-if (common.inFreeBSDJail)
-  common.skip('In a FreeBSD jail');
+if (common.inFreeBSDJail) common.skip('In a FreeBSD jail');
 
 const assert = require('assert');
 const dgram = require('dgram');
 
-dgram.createSocket('udp4').bind(0, common.mustCall(function() {
-  assert.strictEqual(typeof this.address().port, 'number');
-  assert.ok(isFinite(this.address().port));
-  assert.ok(this.address().port > 0);
-  assert.strictEqual(this.address().address, '0.0.0.0');
-  this.close();
-}));
+dgram.createSocket('udp4').bind(
+  0,
+  common.mustCall(function() {
+    assert.strictEqual(typeof this.address().port, 'number');
+    assert.ok(isFinite(this.address().port));
+    assert.ok(this.address().port > 0);
+    assert.strictEqual(this.address().address, '0.0.0.0');
+    this.close();
+  })
+);
 
 if (!common.hasIPv6) {
   common.printSkipMessage('udp6 part of test, because no IPv6 support');
   return;
 }
 
-dgram.createSocket('udp6').bind(0, common.mustCall(function() {
-  assert.strictEqual(typeof this.address().port, 'number');
-  assert.ok(isFinite(this.address().port));
-  assert.ok(this.address().port > 0);
-  let address = this.address().address;
-  if (address === '::ffff:0.0.0.0')
-    address = '::';
-  assert.strictEqual(address, '::');
-  this.close();
-}));
+dgram.createSocket('udp6').bind(
+  0,
+  common.mustCall(function() {
+    assert.strictEqual(typeof this.address().port, 'number');
+    assert.ok(isFinite(this.address().port));
+    assert.ok(this.address().port > 0);
+    let address = this.address().address;
+    if (address === '::ffff:0.0.0.0') address = '::';
+    assert.strictEqual(address, '::');
+    this.close();
+  })
+);
diff --git a/test/parallel/test-dgram-bind-fd-error.js b/test/parallel/test-dgram-bind-fd-error.js
index 519855bacc4861..d86ba91c7000e0 100644
--- a/test/parallel/test-dgram-bind-fd-error.js
+++ b/test/parallel/test-dgram-bind-fd-error.js
@@ -1,8 +1,7 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('Does not support binding fd on Windows');
+if (common.isWindows) common.skip('Does not support binding fd on Windows');
 
 const dgram = require('dgram');
 const assert = require('assert');
@@ -15,22 +14,27 @@ const TYPE = 'udp4';
 {
   const socket = dgram.createSocket(TYPE);
 
-  socket.bind(common.mustCall(() => {
-    const anotherSocket = dgram.createSocket(TYPE);
-    const { handle } = socket[kStateSymbol];
-
-    common.expectsError(() => {
-      anotherSocket.bind({
-        fd: handle.fd,
-      });
-    }, {
-      code: 'EEXIST',
-      type: Error,
-      message: /^open EEXIST$/
-    });
-
-    socket.close();
-  }));
+  socket.bind(
+    common.mustCall(() => {
+      const anotherSocket = dgram.createSocket(TYPE);
+      const { handle } = socket[kStateSymbol];
+
+      common.expectsError(
+        () => {
+          anotherSocket.bind({
+            fd: handle.fd
+          });
+        },
+        {
+          code: 'EEXIST',
+          type: Error,
+          message: /^open EEXIST$/
+        }
+      );
+
+      socket.close();
+    })
+  );
 }
 
 // Throw when the type of fd is not "UDP".
@@ -42,15 +46,18 @@ const TYPE = 'udp4';
   assert.notStrictEqual(fd, -1);
 
   const socket = new dgram.createSocket(TYPE);
-  common.expectsError(() => {
-    socket.bind({
-      fd,
-    });
-  }, {
-    code: 'ERR_INVALID_FD_TYPE',
-    type: TypeError,
-    message: /^Unsupported fd type: TCP$/
-  });
+  common.expectsError(
+    () => {
+      socket.bind({
+        fd
+      });
+    },
+    {
+      code: 'ERR_INVALID_FD_TYPE',
+      type: TypeError,
+      message: /^Unsupported fd type: TCP$/
+    }
+  );
 
   handle.close();
 }
diff --git a/test/parallel/test-dgram-bind-fd.js b/test/parallel/test-dgram-bind-fd.js
index 8c81cb118c1001..2cd8c21c0ac11c 100644
--- a/test/parallel/test-dgram-bind-fd.js
+++ b/test/parallel/test-dgram-bind-fd.js
@@ -1,8 +1,7 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('Does not support binding fd on Windows');
+if (common.isWindows) common.skip('Does not support binding fd on Windows');
 
 const assert = require('assert');
 const dgram = require('dgram');
@@ -16,8 +15,7 @@ const BUFFER_SIZE = 4096;
 {
   function createHandle(reuseAddr, udp4, bindAddress) {
     let flags = 0;
-    if (reuseAddr)
-      flags |= UV_UDP_REUSEADDR;
+    if (reuseAddr) flags |= UV_UDP_REUSEADDR;
 
     const handle = new UDP();
     let err = 0;
@@ -39,70 +37,83 @@ const BUFFER_SIZE = 4096;
     let fd;
 
     const receiver = dgram.createSocket({
-      type,
+      type
     });
 
-    receiver.bind({
-      port: 0,
-      address: bindAddress,
-    }, common.mustCall(() => {
-      const { port, address } = receiver.address();
-      // Create a handle to reuse its fd.
-      const handle = createHandle(reuseAddr, udp4, bindAddress);
-
-      fd = handle.fd;
-      assert.notStrictEqual(handle.fd, -1);
-
-      const socket = dgram.createSocket({
-        type,
-        recvBufferSize: BUFFER_SIZE,
-        sendBufferSize: BUFFER_SIZE,
-      });
-
-      socket.bind({
+    receiver.bind(
+      {
         port: 0,
-        address: bindAddress,
-        fd,
-      }, common.mustCall(() => {
-        // Test address().
-        const rinfo = {};
-        const err = handle.getsockname(rinfo);
-        assert.strictEqual(err, 0);
-        const socketRInfo = socket.address();
-        assert.strictEqual(rinfo.address, socketRInfo.address);
-        assert.strictEqual(rinfo.port, socketRInfo.port);
-
-        // Test buffer size.
-        const recvBufferSize = socket.getRecvBufferSize();
-        const sendBufferSize = socket.getSendBufferSize();
-
-        // note: linux will double the buffer size
-        const expectedBufferSize = common.isLinux ?
-          BUFFER_SIZE * 2 : BUFFER_SIZE;
-        assert.strictEqual(recvBufferSize, expectedBufferSize);
-        assert.strictEqual(sendBufferSize, expectedBufferSize);
-
-        socket.send(String(fd), port, address);
-      }));
-
-      socket.on('message', common.mustCall((data) => {
+        address: bindAddress
+      },
+      common.mustCall(() => {
+        const { port, address } = receiver.address();
+        // Create a handle to reuse its fd.
+        const handle = createHandle(reuseAddr, udp4, bindAddress);
+
+        fd = handle.fd;
+        assert.notStrictEqual(handle.fd, -1);
+
+        const socket = dgram.createSocket({
+          type,
+          recvBufferSize: BUFFER_SIZE,
+          sendBufferSize: BUFFER_SIZE
+        });
+
+        socket.bind(
+          {
+            port: 0,
+            address: bindAddress,
+            fd
+          },
+          common.mustCall(() => {
+            // Test address().
+            const rinfo = {};
+            const err = handle.getsockname(rinfo);
+            assert.strictEqual(err, 0);
+            const socketRInfo = socket.address();
+            assert.strictEqual(rinfo.address, socketRInfo.address);
+            assert.strictEqual(rinfo.port, socketRInfo.port);
+
+            // Test buffer size.
+            const recvBufferSize = socket.getRecvBufferSize();
+            const sendBufferSize = socket.getSendBufferSize();
+
+            // note: linux will double the buffer size
+            const expectedBufferSize = common.isLinux
+              ? BUFFER_SIZE * 2
+              : BUFFER_SIZE;
+            assert.strictEqual(recvBufferSize, expectedBufferSize);
+            assert.strictEqual(sendBufferSize, expectedBufferSize);
+
+            socket.send(String(fd), port, address);
+          })
+        );
+
+        socket.on(
+          'message',
+          common.mustCall((data) => {
+            assert.strictEqual(data.toString('utf8'), String(fd));
+            socket.close();
+          })
+        );
+
+        socket.on('error', (err) => {
+          console.error(err.message);
+          assert.fail(err.message);
+        });
+
+        socket.on('close', common.mustCall(() => {}));
+      })
+    );
+
+    receiver.on(
+      'message',
+      common.mustCall((data, { address, port }) => {
         assert.strictEqual(data.toString('utf8'), String(fd));
-        socket.close();
-      }));
-
-      socket.on('error', (err) => {
-        console.error(err.message);
-        assert.fail(err.message);
-      });
-
-      socket.on('close', common.mustCall(() => {}));
-    }));
-
-    receiver.on('message', common.mustCall((data, { address, port }) => {
-      assert.strictEqual(data.toString('utf8'), String(fd));
-      receiver.send(String(fd), port, address);
-      process.nextTick(() => receiver.close());
-    }));
+        receiver.send(String(fd), port, address);
+        process.nextTick(() => receiver.close());
+      })
+    );
 
     receiver.on('error', (err) => {
       console.error(err.message);
diff --git a/test/parallel/test-dgram-bind.js b/test/parallel/test-dgram-bind.js
index 0b8447c3115da1..e707969bf6cb05 100644
--- a/test/parallel/test-dgram-bind.js
+++ b/test/parallel/test-dgram-bind.js
@@ -26,17 +26,23 @@ const dgram = require('dgram');
 
 const socket = dgram.createSocket('udp4');
 
-socket.on('listening', common.mustCall(() => {
-  common.expectsError(() => {
-    socket.bind();
-  }, {
-    code: 'ERR_SOCKET_ALREADY_BOUND',
-    type: Error,
-    message: /^Socket is already bound$/
-  });
+socket.on(
+  'listening',
+  common.mustCall(() => {
+    common.expectsError(
+      () => {
+        socket.bind();
+      },
+      {
+        code: 'ERR_SOCKET_ALREADY_BOUND',
+        type: Error,
+        message: /^Socket is already bound$/
+      }
+    );
 
-  socket.close();
-}));
+    socket.close();
+  })
+);
 
 const result = socket.bind(); // should not throw
 
diff --git a/test/parallel/test-dgram-bytes-length.js b/test/parallel/test-dgram-bytes-length.js
index abf8209b112f91..67da16fa887f14 100644
--- a/test/parallel/test-dgram-bytes-length.js
+++ b/test/parallel/test-dgram-bytes-length.js
@@ -26,14 +26,10 @@ const dgram = require('dgram');
 
 const message = Buffer.from('Some bytes');
 const client = dgram.createSocket('udp4');
-client.send(
-  message,
-  0,
-  message.length,
-  41234,
-  'localhost',
-  function(err, bytes) {
-    assert.strictEqual(bytes, message.length);
-    client.close();
-  }
-);
+client.send(message, 0, message.length, 41234, 'localhost', function(
+  err,
+  bytes
+) {
+  assert.strictEqual(bytes, message.length);
+  client.close();
+});
diff --git a/test/parallel/test-dgram-close-during-bind.js b/test/parallel/test-dgram-close-during-bind.js
index 4b04610e4141dc..20db08295eb820 100644
--- a/test/parallel/test-dgram-close-during-bind.js
+++ b/test/parallel/test-dgram-close-during-bind.js
@@ -11,9 +11,11 @@ const lookup = handle.lookup;
 handle.bind = common.mustNotCall('bind() should not be called.');
 
 handle.lookup = common.mustCall(function(address, callback) {
-  socket.close(common.mustCall(() => {
-    lookup.call(this, address, callback);
-  }));
+  socket.close(
+    common.mustCall(() => {
+      lookup.call(this, address, callback);
+    })
+  );
 });
 
 socket.bind(common.mustNotCall('Socket should not bind.'));
diff --git a/test/parallel/test-dgram-close-in-listening.js b/test/parallel/test-dgram-close-in-listening.js
index 902384e7e082d0..f6db3fc52ff6f5 100644
--- a/test/parallel/test-dgram-close-in-listening.js
+++ b/test/parallel/test-dgram-close-in-listening.js
@@ -14,13 +14,20 @@ socket.on('listening', function() {
 });
 
 // get a random port for send
-const portGetter = dgram.createSocket('udp4')
-  .bind(0, 'localhost', common.mustCall(() => {
+const portGetter = dgram.createSocket('udp4').bind(
+  0,
+  'localhost',
+  common.mustCall(() => {
     // adds a listener to 'listening' to send the data when
     // the socket is available
-    socket.send(buf, 0, buf.length,
-                portGetter.address().port,
-                portGetter.address().address);
+    socket.send(
+      buf,
+      0,
+      buf.length,
+      portGetter.address().port,
+      portGetter.address().address
+    );
 
     portGetter.close();
-  }));
+  })
+);
diff --git a/test/parallel/test-dgram-close-is-not-callback.js b/test/parallel/test-dgram-close-is-not-callback.js
index 70700a16c6a798..fc7a9b9bdf8d86 100644
--- a/test/parallel/test-dgram-close-is-not-callback.js
+++ b/test/parallel/test-dgram-close-is-not-callback.js
@@ -7,15 +7,22 @@ const buf = Buffer.alloc(1024, 42);
 const socket = dgram.createSocket('udp4');
 
 // get a random port for send
-const portGetter = dgram.createSocket('udp4')
-  .bind(0, 'localhost', common.mustCall(() => {
-    socket.send(buf, 0, buf.length,
-                portGetter.address().port,
-                portGetter.address().address);
+const portGetter = dgram.createSocket('udp4').bind(
+  0,
+  'localhost',
+  common.mustCall(() => {
+    socket.send(
+      buf,
+      0,
+      buf.length,
+      portGetter.address().port,
+      portGetter.address().address
+    );
 
     // if close callback is not function, ignore the argument.
     socket.close('bad argument');
     portGetter.close();
 
     socket.on('close', common.mustCall());
-  }));
+  })
+);
diff --git a/test/parallel/test-dgram-close.js b/test/parallel/test-dgram-close.js
index 7b49cee73bed6a..b41eb0f8e05f03 100644
--- a/test/parallel/test-dgram-close.js
+++ b/test/parallel/test-dgram-close.js
@@ -35,11 +35,17 @@ let socket = dgram.createSocket('udp4');
 const { handle } = socket[kStateSymbol];
 
 // get a random port for send
-const portGetter = dgram.createSocket('udp4')
-  .bind(0, 'localhost', common.mustCall(() => {
-    socket.send(buf, 0, buf.length,
-                portGetter.address().port,
-                portGetter.address().address);
+const portGetter = dgram.createSocket('udp4').bind(
+  0,
+  'localhost',
+  common.mustCall(() => {
+    socket.send(
+      buf,
+      0,
+      buf.length,
+      portGetter.address().port,
+      portGetter.address().address
+    );
 
     assert.strictEqual(socket.close(common.mustCall()), socket);
     socket.on('close', common.mustCall());
@@ -53,4 +59,5 @@ const portGetter = dgram.createSocket('udp4')
     });
 
     portGetter.close();
-  }));
+  })
+);
diff --git a/test/parallel/test-dgram-cluster-bind-error.js b/test/parallel/test-dgram-cluster-bind-error.js
index fb338da9727123..94dd9f8ac34fe4 100644
--- a/test/parallel/test-dgram-cluster-bind-error.js
+++ b/test/parallel/test-dgram-cluster-bind-error.js
@@ -18,14 +18,19 @@ if (cluster.isMaster) {
 
   const socket = dgram.createSocket('udp4');
 
-  socket.on('error', common.mustCall((err) => {
-    assert(/^Error: bind UNKNOWN 0\.0\.0\.0$/.test(err.toString()));
-    process.nextTick(common.mustCall(() => {
-      assert.strictEqual(socket._bindState, 0); // BIND_STATE_UNBOUND
-      socket.close();
-      cluster.worker.disconnect();
-    }));
-  }));
+  socket.on(
+    'error',
+    common.mustCall((err) => {
+      assert(/^Error: bind UNKNOWN 0\.0\.0\.0$/.test(err.toString()));
+      process.nextTick(
+        common.mustCall(() => {
+          assert.strictEqual(socket._bindState, 0); // BIND_STATE_UNBOUND
+          socket.close();
+          cluster.worker.disconnect();
+        })
+      );
+    })
+  );
 
   socket.bind(common.mustNotCall('Socket should not bind.'));
 }
diff --git a/test/parallel/test-dgram-cluster-close-during-bind.js b/test/parallel/test-dgram-cluster-close-during-bind.js
index 4e8cdbf9d35cbb..a40042ec540d55 100644
--- a/test/parallel/test-dgram-cluster-close-during-bind.js
+++ b/test/parallel/test-dgram-cluster-close-during-bind.js
@@ -16,22 +16,29 @@ if (cluster.isMaster) {
   const _getServer = cluster._getServer;
 
   cluster._getServer = common.mustCall(function(self, options, callback) {
-    socket.close(common.mustCall(() => {
-      _getServer.call(this, self, options, common.mustCall((err, handle) => {
-        assert.strictEqual(err, 0);
+    socket.close(
+      common.mustCall(() => {
+        _getServer.call(
+          this,
+          self,
+          options,
+          common.mustCall((err, handle) => {
+            assert.strictEqual(err, 0);
 
-        // When the socket determines that it was already closed, it will
-        // close the handle. Use handle.close() to terminate the test.
-        const close = handle.close;
+            // When the socket determines that it was already closed, it will
+            // close the handle. Use handle.close() to terminate the test.
+            const close = handle.close;
 
-        handle.close = common.mustCall(function() {
-          setImmediate(() => cluster.worker.disconnect());
-          return close.call(this);
-        });
+            handle.close = common.mustCall(function() {
+              setImmediate(() => cluster.worker.disconnect());
+              return close.call(this);
+            });
 
-        callback(err, handle);
-      }));
-    }));
+            callback(err, handle);
+          })
+        );
+      })
+    );
   });
 
   socket.bind(common.mustNotCall('Socket should not bind.'));
diff --git a/test/parallel/test-dgram-create-socket-handle-fd.js b/test/parallel/test-dgram-create-socket-handle-fd.js
index 93175859c196ea..9a4d2833566c64 100644
--- a/test/parallel/test-dgram-create-socket-handle-fd.js
+++ b/test/parallel/test-dgram-create-socket-handle-fd.js
@@ -1,8 +1,7 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('Does not support binding fd on Windows');
+if (common.isWindows) common.skip('Does not support binding fd on Windows');
 
 const assert = require('assert');
 const dgram = require('dgram');
diff --git a/test/parallel/test-dgram-create-socket-handle.js b/test/parallel/test-dgram-create-socket-handle.js
index 6875448474ab8f..af5b785af4f141 100644
--- a/test/parallel/test-dgram-create-socket-handle.js
+++ b/test/parallel/test-dgram-create-socket-handle.js
@@ -22,8 +22,7 @@ const UDP = internalBinding('udp_wrap').UDP;
   assert(handle instanceof UDP);
   assert.strictEqual(typeof handle.fd, 'number');
 
-  if (!common.isWindows)
-    assert(handle.fd > 0);
+  if (!common.isWindows) assert(handle.fd > 0);
 }
 
 {
diff --git a/test/parallel/test-dgram-createSocket-type.js b/test/parallel/test-dgram-createSocket-type.js
index 9c5a20eaab3191..fef490e5d600fc 100644
--- a/test/parallel/test-dgram-createSocket-type.js
+++ b/test/parallel/test-dgram-createSocket-type.js
@@ -13,23 +13,21 @@ const invalidTypes = [
   null,
   undefined
 ];
-const validTypes = [
-  'udp4',
-  'udp6',
-  { type: 'udp4' },
-  { type: 'udp6' }
-];
+const validTypes = ['udp4', 'udp6', { type: 'udp4' }, { type: 'udp6' }];
 const errMessage = /^Bad socket type specified\. Valid types are: udp4, udp6$/;
 
 // Error must be thrown with invalid types
 invalidTypes.forEach((invalidType) => {
-  common.expectsError(() => {
-    dgram.createSocket(invalidType);
-  }, {
-    code: 'ERR_SOCKET_BAD_TYPE',
-    type: TypeError,
-    message: errMessage
-  });
+  common.expectsError(
+    () => {
+      dgram.createSocket(invalidType);
+    },
+    {
+      code: 'ERR_SOCKET_BAD_TYPE',
+      type: TypeError,
+      message: errMessage
+    }
+  );
 });
 
 // Error must not be thrown with valid types
@@ -46,16 +44,20 @@ validTypes.forEach((validType) => {
     sendBufferSize: 15000
   });
 
-  socket.bind(common.mustCall(() => {
-    // note: linux will double the buffer size
-    assert.ok(socket.getRecvBufferSize() === 10000 ||
-              socket.getRecvBufferSize() === 20000,
-              'SO_RCVBUF not 10000 or 20000, ' +
-                `was ${socket.getRecvBufferSize()}`);
-    assert.ok(socket.getSendBufferSize() === 15000 ||
-              socket.getSendBufferSize() === 30000,
-              'SO_SNDBUF not 15000 or 30000, ' +
-                `was ${socket.getRecvBufferSize()}`);
-    socket.close();
-  }));
+  socket.bind(
+    common.mustCall(() => {
+      // note: linux will double the buffer size
+      assert.ok(
+        socket.getRecvBufferSize() === 10000 ||
+          socket.getRecvBufferSize() === 20000,
+        'SO_RCVBUF not 10000 or 20000, ' + `was ${socket.getRecvBufferSize()}`
+      );
+      assert.ok(
+        socket.getSendBufferSize() === 15000 ||
+          socket.getSendBufferSize() === 30000,
+        'SO_SNDBUF not 15000 or 30000, ' + `was ${socket.getRecvBufferSize()}`
+      );
+      socket.close();
+    })
+  );
 }
diff --git a/test/parallel/test-dgram-custom-lookup.js b/test/parallel/test-dgram-custom-lookup.js
index ae623283644606..c2ffd79bd38c44 100644
--- a/test/parallel/test-dgram-custom-lookup.js
+++ b/test/parallel/test-dgram-custom-lookup.js
@@ -11,9 +11,11 @@ const dns = require('dns');
 
   const socket = dgram.createSocket({ type: 'udp4', lookup });
 
-  socket.bind(common.mustCall(() => {
-    socket.close();
-  }));
+  socket.bind(
+    common.mustCall(() => {
+      socket.close();
+    })
+  );
 }
 
 {
@@ -27,21 +29,27 @@ const dns = require('dns');
 
   const socket = dgram.createSocket({ type: 'udp4' });
 
-  socket.bind(common.mustCall(() => {
-    socket.close();
-  }));
+  socket.bind(
+    common.mustCall(() => {
+      socket.close();
+    })
+  );
 }
 
 {
   // Verify that non-functions throw.
   [null, true, false, 0, 1, NaN, '', 'foo', {}, Symbol()].forEach((value) => {
-    common.expectsError(() => {
-      dgram.createSocket({ type: 'udp4', lookup: value });
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "lookup" argument must be of type Function. ' +
-               `Received type ${typeof value}`
-    });
+    common.expectsError(
+      () => {
+        dgram.createSocket({ type: 'udp4', lookup: value });
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "lookup" argument must be of type Function. ' +
+          `Received type ${typeof value}`
+      }
+    );
   });
 }
diff --git a/test/parallel/test-dgram-deprecation-error.js b/test/parallel/test-dgram-deprecation-error.js
index 89cde12fd37cf1..777faea0817f65 100644
--- a/test/parallel/test-dgram-deprecation-error.js
+++ b/test/parallel/test-dgram-deprecation-error.js
@@ -17,10 +17,7 @@ const propertiesToTest = [
   '_reuseAddr'
 ];
 
-const methodsToTest = [
-  '_healthCheck',
-  '_stopReceiving'
-];
+const methodsToTest = ['_healthCheck', '_stopReceiving'];
 
 const propertyCases = propertiesToTest.map((propName) => {
   return [
@@ -56,16 +53,12 @@ const methodCases = methodsToTest.map((propName) => {
   };
 });
 
-const cases = [].concat(
-  ...propertyCases,
-  ...methodCases
-);
+const cases = [].concat(...propertyCases, ...methodCases);
 
 // If we weren't passed a test ID then we need to spawn all of the cases.
 // We run the cases in child processes since deprecations print once.
 if (Number.isNaN(testNumber)) {
-  const children = cases.map((_case, i) =>
-    fork(process.argv[1], [ String(i) ]));
+  const children = cases.map((_case, i) => fork(process.argv[1], [String(i)]));
 
   children.forEach((child) => {
     child.on('close', (code) => {
diff --git a/test/parallel/test-dgram-error-message-address.js b/test/parallel/test-dgram-error-message-address.js
index 859ee560c34c01..37bb05372ae863 100644
--- a/test/parallel/test-dgram-error-message-address.js
+++ b/test/parallel/test-dgram-error-message-address.js
@@ -29,13 +29,16 @@ const socket_ipv4 = dgram.createSocket('udp4');
 
 socket_ipv4.on('listening', common.mustNotCall());
 
-socket_ipv4.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.port, undefined);
-  assert.strictEqual(e.message, 'bind EADDRNOTAVAIL 1.1.1.1');
-  assert.strictEqual(e.address, '1.1.1.1');
-  assert.strictEqual(e.code, 'EADDRNOTAVAIL');
-  socket_ipv4.close();
-}));
+socket_ipv4.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.port, undefined);
+    assert.strictEqual(e.message, 'bind EADDRNOTAVAIL 1.1.1.1');
+    assert.strictEqual(e.address, '1.1.1.1');
+    assert.strictEqual(e.code, 'EADDRNOTAVAIL');
+    socket_ipv4.close();
+  })
+);
 
 socket_ipv4.bind(0, '1.1.1.1');
 
@@ -44,14 +47,17 @@ const socket_ipv6 = dgram.createSocket('udp6');
 
 socket_ipv6.on('listening', common.mustNotCall());
 
-socket_ipv6.on('error', common.mustCall(function(e) {
-  // EAFNOSUPPORT or EPROTONOSUPPORT means IPv6 is disabled on this system.
-  const allowed = ['EADDRNOTAVAIL', 'EAFNOSUPPORT', 'EPROTONOSUPPORT'];
-  assert(allowed.includes(e.code));
-  assert.strictEqual(e.port, undefined);
-  assert.strictEqual(e.message, `bind ${e.code} 111::1`);
-  assert.strictEqual(e.address, '111::1');
-  socket_ipv6.close();
-}));
+socket_ipv6.on(
+  'error',
+  common.mustCall(function(e) {
+    // EAFNOSUPPORT or EPROTONOSUPPORT means IPv6 is disabled on this system.
+    const allowed = ['EADDRNOTAVAIL', 'EAFNOSUPPORT', 'EPROTONOSUPPORT'];
+    assert(allowed.includes(e.code));
+    assert.strictEqual(e.port, undefined);
+    assert.strictEqual(e.message, `bind ${e.code} 111::1`);
+    assert.strictEqual(e.address, '111::1');
+    socket_ipv6.close();
+  })
+);
 
 socket_ipv6.bind(0, '111::1');
diff --git a/test/parallel/test-dgram-exclusive-implicit-bind.js b/test/parallel/test-dgram-exclusive-implicit-bind.js
index 171b221ee2982c..88918790a7ed6a 100644
--- a/test/parallel/test-dgram-exclusive-implicit-bind.js
+++ b/test/parallel/test-dgram-exclusive-implicit-bind.js
@@ -52,8 +52,7 @@ if (cluster.isMaster) {
   });
 
   target.on('message', function(buf, rinfo) {
-    if (pids.includes(buf.toString()))
-      return;
+    if (pids.includes(buf.toString())) return;
     pids.push(buf.toString());
     messages++;
     ports[rinfo.port] = true;
diff --git a/test/parallel/test-dgram-implicit-bind.js b/test/parallel/test-dgram-implicit-bind.js
index 70e29c1f3ab95f..7c25d0cd442886 100644
--- a/test/parallel/test-dgram-implicit-bind.js
+++ b/test/parallel/test-dgram-implicit-bind.js
@@ -27,14 +27,17 @@ const source = dgram.createSocket('udp4');
 const target = dgram.createSocket('udp4');
 let messages = 0;
 
-target.on('message', common.mustCall(function(buf) {
-  if (buf.toString() === 'abc') ++messages;
-  if (buf.toString() === 'def') ++messages;
-  if (messages === 2) {
-    source.close();
-    target.close();
-  }
-}, 2));
+target.on(
+  'message',
+  common.mustCall(function(buf) {
+    if (buf.toString() === 'abc') ++messages;
+    if (buf.toString() === 'def') ++messages;
+    if (messages === 2) {
+      source.close();
+      target.close();
+    }
+  }, 2)
+);
 
 target.on('listening', function() {
   // Second .send() call should not throw a bind error.
diff --git a/test/parallel/test-dgram-membership.js b/test/parallel/test-dgram-membership.js
index 47704e90b7ce13..0fe28c0efd59d3 100644
--- a/test/parallel/test-dgram-membership.js
+++ b/test/parallel/test-dgram-membership.js
@@ -10,69 +10,87 @@ const setup = dgram.createSocket.bind(dgram, { type: 'udp4', reuseAddr: true });
 // addMembership() on closed socket should throw
 {
   const socket = setup();
-  socket.close(common.mustCall(() => {
-    common.expectsError(() => {
-      socket.addMembership(multicastAddress);
-    }, {
-      code: 'ERR_SOCKET_DGRAM_NOT_RUNNING',
-      type: Error,
-      message: /^Not running$/
-    });
-  }));
+  socket.close(
+    common.mustCall(() => {
+      common.expectsError(
+        () => {
+          socket.addMembership(multicastAddress);
+        },
+        {
+          code: 'ERR_SOCKET_DGRAM_NOT_RUNNING',
+          type: Error,
+          message: /^Not running$/
+        }
+      );
+    })
+  );
 }
 
 // dropMembership() on closed socket should throw
 {
   const socket = setup();
-  socket.close(common.mustCall(() => {
-    common.expectsError(() => {
-      socket.dropMembership(multicastAddress);
-    }, {
-      code: 'ERR_SOCKET_DGRAM_NOT_RUNNING',
-      type: Error,
-      message: /^Not running$/
-    });
-  }));
+  socket.close(
+    common.mustCall(() => {
+      common.expectsError(
+        () => {
+          socket.dropMembership(multicastAddress);
+        },
+        {
+          code: 'ERR_SOCKET_DGRAM_NOT_RUNNING',
+          type: Error,
+          message: /^Not running$/
+        }
+      );
+    })
+  );
 }
 
 // addMembership() with no argument should throw
 {
   const socket = setup();
-  common.expectsError(() => {
-    socket.addMembership();
-  }, {
-    code: 'ERR_MISSING_ARGS',
-    type: TypeError,
-    message: /^The "multicastAddress" argument must be specified$/
-  });
+  common.expectsError(
+    () => {
+      socket.addMembership();
+    },
+    {
+      code: 'ERR_MISSING_ARGS',
+      type: TypeError,
+      message: /^The "multicastAddress" argument must be specified$/
+    }
+  );
   socket.close();
 }
 
 // dropMembership() with no argument should throw
 {
   const socket = setup();
-  common.expectsError(() => {
-    socket.dropMembership();
-  }, {
-    code: 'ERR_MISSING_ARGS',
-    type: TypeError,
-    message: /^The "multicastAddress" argument must be specified$/
-  });
+  common.expectsError(
+    () => {
+      socket.dropMembership();
+    },
+    {
+      code: 'ERR_MISSING_ARGS',
+      type: TypeError,
+      message: /^The "multicastAddress" argument must be specified$/
+    }
+  );
   socket.close();
 }
 
 // addMembership() with invalid multicast address should throw
 {
   const socket = setup();
-  assert.throws(() => { socket.addMembership('256.256.256.256'); },
-                /^Error: addMembership EINVAL$/);
+  assert.throws(() => {
+    socket.addMembership('256.256.256.256');
+  }, /^Error: addMembership EINVAL$/);
   socket.close();
 }
 
 // dropMembership() with invalid multicast address should throw
 {
   const socket = setup();
-  assert.throws(() => { socket.dropMembership('256.256.256.256'); },
-                /^Error: dropMembership EINVAL$/);
+  assert.throws(() => {
+    socket.dropMembership('256.256.256.256');
+  }, /^Error: dropMembership EINVAL$/);
   socket.close();
 }
diff --git a/test/parallel/test-dgram-multicast-loopback.js b/test/parallel/test-dgram-multicast-loopback.js
index c1eedcd1c98900..b6cb9b6c9d875b 100644
--- a/test/parallel/test-dgram-multicast-loopback.js
+++ b/test/parallel/test-dgram-multicast-loopback.js
@@ -15,9 +15,12 @@ const dgram = require('dgram');
   const socket = dgram.createSocket('udp4');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    assert.strictEqual(socket.setMulticastLoopback(16), 16);
-    assert.strictEqual(socket.setMulticastLoopback(0), 0);
-    socket.close();
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      assert.strictEqual(socket.setMulticastLoopback(16), 16);
+      assert.strictEqual(socket.setMulticastLoopback(0), 0);
+      socket.close();
+    })
+  );
 }
diff --git a/test/parallel/test-dgram-multicast-set-interface.js b/test/parallel/test-dgram-multicast-set-interface.js
index 2900cb89738e82..659abc75736280 100644
--- a/test/parallel/test-dgram-multicast-set-interface.js
+++ b/test/parallel/test-dgram-multicast-set-interface.js
@@ -7,117 +7,143 @@ const dgram = require('dgram');
   const socket = dgram.createSocket('udp4');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    // Explicitly request default system selection
-    socket.setMulticastInterface('0.0.0.0');
-
-    socket.close();
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      // Explicitly request default system selection
+      socket.setMulticastInterface('0.0.0.0');
+
+      socket.close();
+    })
+  );
 }
 
 {
   const socket = dgram.createSocket('udp4');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    socket.close(common.mustCall(() => {
-      assert.throws(() => { socket.setMulticastInterface('0.0.0.0'); },
-                    /Not running/);
-    }));
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      socket.close(
+        common.mustCall(() => {
+          assert.throws(() => {
+            socket.setMulticastInterface('0.0.0.0');
+          }, /Not running/);
+        })
+      );
+    })
+  );
 }
 
 {
   const socket = dgram.createSocket('udp4');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    // Try to set with an invalid interfaceAddress (wrong address class)
-    //
-    // This operation succeeds on some platforms, throws `EINVAL` on some
-    // platforms, and throws `ENOPROTOOPT` on others. This is unpleasant, but
-    // we should at least test for it.
-    try {
-      socket.setMulticastInterface('::');
-    } catch (e) {
-      assert(e.code === 'EINVAL' || e.code === 'ENOPROTOOPT');
-    }
-
-    socket.close();
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      // Try to set with an invalid interfaceAddress (wrong address class)
+      //
+      // This operation succeeds on some platforms, throws `EINVAL` on some
+      // platforms, and throws `ENOPROTOOPT` on others. This is unpleasant, but
+      // we should at least test for it.
+      try {
+        socket.setMulticastInterface('::');
+      } catch (e) {
+        assert(e.code === 'EINVAL' || e.code === 'ENOPROTOOPT');
+      }
+
+      socket.close();
+    })
+  );
 }
 
 {
   const socket = dgram.createSocket('udp4');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    // Try to set with an invalid interfaceAddress (wrong Type)
-    assert.throws(() => {
-      socket.setMulticastInterface(1);
-    }, /TypeError/);
-
-    socket.close();
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      // Try to set with an invalid interfaceAddress (wrong Type)
+      assert.throws(() => {
+        socket.setMulticastInterface(1);
+      }, /TypeError/);
+
+      socket.close();
+    })
+  );
 }
 
 {
   const socket = dgram.createSocket('udp4');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    // Try to set with an invalid interfaceAddress (non-unicast)
-    assert.throws(() => {
-      socket.setMulticastInterface('224.0.0.2');
-    }, /Error/);
-
-    socket.close();
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      // Try to set with an invalid interfaceAddress (non-unicast)
+      assert.throws(() => {
+        socket.setMulticastInterface('224.0.0.2');
+      }, /Error/);
+
+      socket.close();
+    })
+  );
 }
 
 // If IPv6 is not supported, skip the rest of the test. However, don't call
 // common.skip(), which calls process.exit() while there is outstanding
 // common.mustCall() activity.
-if (!common.hasIPv6)
-  return;
+if (!common.hasIPv6) return;
 
 {
   const socket = dgram.createSocket('udp6');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    // Try to set with an invalid interfaceAddress ('undefined')
-    assert.throws(() => {
-      socket.setMulticastInterface(String(undefined));
-    }, /EINVAL/);
-
-    socket.close();
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      // Try to set with an invalid interfaceAddress ('undefined')
+      assert.throws(() => {
+        socket.setMulticastInterface(String(undefined));
+      }, /EINVAL/);
+
+      socket.close();
+    })
+  );
 }
 
 {
   const socket = dgram.createSocket('udp6');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    // Try to set with an invalid interfaceAddress ('')
-    assert.throws(() => {
-      socket.setMulticastInterface('');
-    }, /EINVAL/);
-
-    socket.close();
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      // Try to set with an invalid interfaceAddress ('')
+      assert.throws(() => {
+        socket.setMulticastInterface('');
+      }, /EINVAL/);
+
+      socket.close();
+    })
+  );
 }
 
 {
   const socket = dgram.createSocket('udp6');
 
   socket.bind(0);
-  socket.on('listening', common.mustCall(() => {
-    // Using lo0 for OsX, on all other OSes, an invalid Scope gets
-    // turned into #0 (default selection) which is also acceptable.
-    socket.setMulticastInterface('::%lo0');
-
-    socket.close();
-  }));
+  socket.on(
+    'listening',
+    common.mustCall(() => {
+      // Using lo0 for OsX, on all other OSes, an invalid Scope gets
+      // turned into #0 (default selection) which is also acceptable.
+      socket.setMulticastInterface('::%lo0');
+
+      socket.close();
+    })
+  );
 }
diff --git a/test/parallel/test-dgram-multicast-setTTL.js b/test/parallel/test-dgram-multicast-setTTL.js
index 2e3aad63fe3012..2690eef39bc47c 100644
--- a/test/parallel/test-dgram-multicast-setTTL.js
+++ b/test/parallel/test-dgram-multicast-setTTL.js
@@ -26,23 +26,30 @@ const dgram = require('dgram');
 const socket = dgram.createSocket('udp4');
 
 socket.bind(0);
-socket.on('listening', common.mustCall(() => {
-  const result = socket.setMulticastTTL(16);
-  assert.strictEqual(result, 16);
+socket.on(
+  'listening',
+  common.mustCall(() => {
+    const result = socket.setMulticastTTL(16);
+    assert.strictEqual(result, 16);
 
-  // Try to set an invalid TTL (valid ttl is > 0 and < 256)
-  assert.throws(() => {
-    socket.setMulticastTTL(1000);
-  }, /^Error: setMulticastTTL EINVAL$/);
+    // Try to set an invalid TTL (valid ttl is > 0 and < 256)
+    assert.throws(() => {
+      socket.setMulticastTTL(1000);
+    }, /^Error: setMulticastTTL EINVAL$/);
 
-  common.expectsError(() => {
-    socket.setMulticastTTL('foo');
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "ttl" argument must be of type number. Received type string'
-  });
+    common.expectsError(
+      () => {
+        socket.setMulticastTTL('foo');
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "ttl" argument must be of type number. Received type string'
+      }
+    );
 
-  // Close the socket
-  socket.close();
-}));
+    // Close the socket
+    socket.close();
+  })
+);
diff --git a/test/parallel/test-dgram-oob-buffer.js b/test/parallel/test-dgram-oob-buffer.js
index 1e71815927baca..3454701f225269 100644
--- a/test/parallel/test-dgram-oob-buffer.js
+++ b/test/parallel/test-dgram-oob-buffer.js
@@ -29,17 +29,22 @@ const dgram = require('dgram');
 
 const socket = dgram.createSocket('udp4');
 const buf = Buffer.from([1, 2, 3, 4]);
-const portGetter = dgram.createSocket('udp4')
-  .bind(0, 'localhost', common.mustCall(() => {
+const portGetter = dgram.createSocket('udp4').bind(
+  0,
+  'localhost',
+  common.mustCall(() => {
     const { address, port } = portGetter.address();
-    portGetter.close(common.mustCall(() => {
-      socket.send(buf, 0, 0, port, address, common.mustNotCall());
-      socket.send(buf, 0, 4, port, address, common.mustNotCall());
-      socket.send(buf, 1, 3, port, address, common.mustNotCall());
-      socket.send(buf, 3, 1, port, address, common.mustNotCall());
-      // Since length of zero means nothing, don't error despite OOB.
-      socket.send(buf, 4, 0, port, address, common.mustNotCall());
+    portGetter.close(
+      common.mustCall(() => {
+        socket.send(buf, 0, 0, port, address, common.mustNotCall());
+        socket.send(buf, 0, 4, port, address, common.mustNotCall());
+        socket.send(buf, 1, 3, port, address, common.mustNotCall());
+        socket.send(buf, 3, 1, port, address, common.mustNotCall());
+        // Since length of zero means nothing, don't error despite OOB.
+        socket.send(buf, 4, 0, port, address, common.mustNotCall());
 
-      socket.close();
-    }));
-  }));
+        socket.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-dgram-recv-error.js b/test/parallel/test-dgram-recv-error.js
index 9850d944ce1011..4b74bd135fb6aa 100644
--- a/test/parallel/test-dgram-recv-error.js
+++ b/test/parallel/test-dgram-recv-error.js
@@ -7,13 +7,16 @@ const { kStateSymbol } = require('internal/dgram');
 const s = dgram.createSocket('udp4');
 const { handle } = s[kStateSymbol];
 
-s.on('error', common.mustCall((err) => {
-  s.close();
+s.on(
+  'error',
+  common.mustCall((err) => {
+    s.close();
 
-  // Don't check the full error message, as the errno is not important here.
-  assert(/^Error: recvmsg/.test(err));
-  assert.strictEqual(err.syscall, 'recvmsg');
-}));
+    // Don't check the full error message, as the errno is not important here.
+    assert(/^Error: recvmsg/.test(err));
+    assert.strictEqual(err.syscall, 'recvmsg');
+  })
+);
 
 s.on('message', common.mustNotCall('no message should be received.'));
 s.bind(common.mustCall(() => handle.onmessage(-1, handle, null, null)));
diff --git a/test/parallel/test-dgram-send-address-types.js b/test/parallel/test-dgram-send-address-types.js
index 0d208cfdc8461b..8550cb8feced8c 100644
--- a/test/parallel/test-dgram-send-address-types.js
+++ b/test/parallel/test-dgram-send-address-types.js
@@ -26,8 +26,9 @@ const client = dgram.createSocket('udp4').bind(0, () => {
     const expectedError = {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "address" argument must be one of type string or falsy. ' +
-               `Received type ${typeof invalidInput}`
+      message:
+        'The "address" argument must be one of type string or falsy. ' +
+        `Received type ${typeof invalidInput}`
     };
     assert.throws(() => client.send(buf, port, invalidInput), expectedError);
   });
diff --git a/test/parallel/test-dgram-send-bad-arguments.js b/test/parallel/test-dgram-send-bad-arguments.js
index 20356ba50c477a..93f5a7f45929cb 100644
--- a/test/parallel/test-dgram-send-bad-arguments.js
+++ b/test/parallel/test-dgram-send-bad-arguments.js
@@ -30,38 +30,53 @@ const sock = dgram.createSocket('udp4');
 
 // First argument should be a buffer.
 common.expectsError(
-  () => { sock.send(); },
+  () => {
+    sock.send();
+  },
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "buffer" argument must be one of type ' +
-    'Buffer, Uint8Array, or string. Received type undefined'
+    message:
+      'The "buffer" argument must be one of type ' +
+      'Buffer, Uint8Array, or string. Received type undefined'
   }
 );
 
 // send(buf, offset, length, port, host)
-assert.throws(() => { sock.send(buf, 1, 1, -1, host); }, RangeError);
-assert.throws(() => { sock.send(buf, 1, 1, 0, host); }, RangeError);
-assert.throws(() => { sock.send(buf, 1, 1, 65536, host); }, RangeError);
+assert.throws(() => {
+  sock.send(buf, 1, 1, -1, host);
+}, RangeError);
+assert.throws(() => {
+  sock.send(buf, 1, 1, 0, host);
+}, RangeError);
+assert.throws(() => {
+  sock.send(buf, 1, 1, 65536, host);
+}, RangeError);
 
 // send(buf, port, host)
 common.expectsError(
-  () => { sock.send(23, 12345, host); },
+  () => {
+    sock.send(23, 12345, host);
+  },
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "buffer" argument must be one of type ' +
-    'Buffer, Uint8Array, or string. Received type number'
+    message:
+      'The "buffer" argument must be one of type ' +
+      'Buffer, Uint8Array, or string. Received type number'
   }
 );
 
 // send([buf1, ..], port, host)
 common.expectsError(
-  () => { sock.send([buf, 23], 12345, host); },
+  () => {
+    sock.send([buf, 23], 12345, host);
+  },
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "buffer list arguments" argument must be one of type ' +
-    'Buffer or string. Received type object'
+    message:
+      'The "buffer list arguments" argument must be one of type ' +
+      'Buffer or string. Received type object'
   }
 );
diff --git a/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js b/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js
index 544f66702494da..09f60a24e211b7 100644
--- a/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js
+++ b/test/parallel/test-dgram-send-callback-buffer-length-empty-address.js
@@ -17,6 +17,6 @@ const onMessage = common.mustCall(function messageSent(err, bytes) {
   client.close();
 });
 
-client.bind(0, () => client.send(buf, offset, len,
-                                 client.address().port,
-                                 onMessage));
+client.bind(0, () =>
+  client.send(buf, offset, len, client.address().port, onMessage)
+);
diff --git a/test/parallel/test-dgram-send-callback-buffer-length.js b/test/parallel/test-dgram-send-callback-buffer-length.js
index bf1b351df33e7b..15f12e14dbea43 100644
--- a/test/parallel/test-dgram-send-callback-buffer-length.js
+++ b/test/parallel/test-dgram-send-callback-buffer-length.js
@@ -38,7 +38,6 @@ const messageSent = common.mustCall(function messageSent(err, bytes) {
   client.close();
 });
 
-client.bind(0, () => client.send(buf, offset, len,
-                                 client.address().port,
-                                 '127.0.0.1',
-                                 messageSent));
+client.bind(0, () =>
+  client.send(buf, offset, len, client.address().port, '127.0.0.1', messageSent)
+);
diff --git a/test/parallel/test-dgram-send-callback-buffer.js b/test/parallel/test-dgram-send-callback-buffer.js
index c174e585d61282..ee33540d0fc0c2 100644
--- a/test/parallel/test-dgram-send-callback-buffer.js
+++ b/test/parallel/test-dgram-send-callback-buffer.js
@@ -14,7 +14,6 @@ const onMessage = common.mustCall(function(err, bytes) {
   client.close();
 });
 
-client.bind(0, () => client.send(buf,
-                                 client.address().port,
-                                 common.localhostIPv4,
-                                 onMessage));
+client.bind(0, () =>
+  client.send(buf, client.address().port, common.localhostIPv4, onMessage)
+);
diff --git a/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js b/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js
index cef71083c71a36..3827c95c8217f1 100644
--- a/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js
+++ b/test/parallel/test-dgram-send-callback-multi-buffer-empty-address.js
@@ -19,10 +19,13 @@ client.on('listening', function() {
   client.send([buf1, buf2], port, messageSent);
 });
 
-client.on('message', common.mustCall(function onMessage(buf) {
-  const expected = Buffer.concat([buf1, buf2]);
-  assert.ok(buf.equals(expected), 'message was received correctly');
-  client.close();
-}));
+client.on(
+  'message',
+  common.mustCall(function onMessage(buf) {
+    const expected = Buffer.concat([buf1, buf2]);
+    assert.ok(buf.equals(expected), 'message was received correctly');
+    client.close();
+  })
+);
 
 client.bind(0);
diff --git a/test/parallel/test-dgram-send-callback-multi-buffer.js b/test/parallel/test-dgram-send-callback-multi-buffer.js
index 09f01f6e8adccc..5874ab0d6b97ad 100644
--- a/test/parallel/test-dgram-send-callback-multi-buffer.js
+++ b/test/parallel/test-dgram-send-callback-multi-buffer.js
@@ -18,10 +18,13 @@ client.on('listening', () => {
   client.send([buf1, buf2], port, common.localhostIPv4, messageSent);
 });
 
-client.on('message', common.mustCall((buf, info) => {
-  const expected = Buffer.concat([buf1, buf2]);
-  assert.ok(buf.equals(expected), 'message was received correctly');
-  client.close();
-}));
+client.on(
+  'message',
+  common.mustCall((buf, info) => {
+    const expected = Buffer.concat([buf1, buf2]);
+    assert.ok(buf.equals(expected), 'message was received correctly');
+    client.close();
+  })
+);
 
 client.bind(0);
diff --git a/test/parallel/test-dgram-send-callback-recursive.js b/test/parallel/test-dgram-send-callback-recursive.js
index ce9d95dce7fe33..424a08e3ef46e4 100644
--- a/test/parallel/test-dgram-send-callback-recursive.js
+++ b/test/parallel/test-dgram-send-callback-recursive.js
@@ -36,8 +36,11 @@ client.on('message', function(buf, info) {
   }
 });
 
-client.on('close', common.mustCall(function() {
-  assert.strictEqual(received, limit);
-}));
+client.on(
+  'close',
+  common.mustCall(function() {
+    assert.strictEqual(received, limit);
+  })
+);
 
 client.bind(0);
diff --git a/test/parallel/test-dgram-send-default-host.js b/test/parallel/test-dgram-send-default-host.js
index 4e2541783d2c34..3ff59a58655a5d 100644
--- a/test/parallel/test-dgram-send-default-host.js
+++ b/test/parallel/test-dgram-send-default-host.js
@@ -6,39 +6,54 @@ const dgram = require('dgram');
 
 const client = dgram.createSocket('udp4');
 
-const toSend = [Buffer.alloc(256, 'x'),
-                Buffer.alloc(256, 'y'),
-                Buffer.alloc(256, 'z'),
-                'hello'];
+const toSend = [
+  Buffer.alloc(256, 'x'),
+  Buffer.alloc(256, 'y'),
+  Buffer.alloc(256, 'z'),
+  'hello'
+];
 
 const received = [];
 
-client.on('listening', common.mustCall(() => {
-  const port = client.address().port;
-
-  client.send(toSend[0], 0, toSend[0].length, port);
-  client.send(toSend[1], port);
-  client.send([toSend[2]], port);
-  client.send(toSend[3], 0, toSend[3].length, port);
-
-  client.send(new Uint8Array(toSend[0]), 0, toSend[0].length, port);
-  client.send(new Uint8Array(toSend[1]), port);
-  client.send([new Uint8Array(toSend[2])], port);
-  client.send(new Uint8Array(Buffer.from(toSend[3])),
-              0, toSend[3].length, port);
-}));
-
-client.on('message', common.mustCall((buf, info) => {
-  received.push(buf.toString());
-
-  if (received.length === toSend.length * 2) {
-    // The replies may arrive out of order -> sort them before checking.
-    received.sort();
-
-    const expected = toSend.concat(toSend).map(String).sort();
-    assert.deepStrictEqual(received, expected);
-    client.close();
-  }
-}, toSend.length * 2));
+client.on(
+  'listening',
+  common.mustCall(() => {
+    const port = client.address().port;
+
+    client.send(toSend[0], 0, toSend[0].length, port);
+    client.send(toSend[1], port);
+    client.send([toSend[2]], port);
+    client.send(toSend[3], 0, toSend[3].length, port);
+
+    client.send(new Uint8Array(toSend[0]), 0, toSend[0].length, port);
+    client.send(new Uint8Array(toSend[1]), port);
+    client.send([new Uint8Array(toSend[2])], port);
+    client.send(
+      new Uint8Array(Buffer.from(toSend[3])),
+      0,
+      toSend[3].length,
+      port
+    );
+  })
+);
+
+client.on(
+  'message',
+  common.mustCall((buf, info) => {
+    received.push(buf.toString());
+
+    if (received.length === toSend.length * 2) {
+      // The replies may arrive out of order -> sort them before checking.
+      received.sort();
+
+      const expected = toSend
+        .concat(toSend)
+        .map(String)
+        .sort();
+      assert.deepStrictEqual(received, expected);
+      client.close();
+    }
+  }, toSend.length * 2)
+);
 
 client.bind(0);
diff --git a/test/parallel/test-dgram-send-empty-array.js b/test/parallel/test-dgram-send-empty-array.js
index 178b72bb1272dd..15b0fa4d4b9330 100644
--- a/test/parallel/test-dgram-send-empty-array.js
+++ b/test/parallel/test-dgram-send-empty-array.js
@@ -9,17 +9,23 @@ const client = dgram.createSocket('udp4');
 
 let interval;
 
-client.on('message', common.mustCall(function onMessage(buf, info) {
-  const expected = Buffer.alloc(0);
-  assert.ok(buf.equals(expected), `Expected empty message but got ${buf}`);
-  clearInterval(interval);
-  client.close();
-}));
+client.on(
+  'message',
+  common.mustCall(function onMessage(buf, info) {
+    const expected = Buffer.alloc(0);
+    assert.ok(buf.equals(expected), `Expected empty message but got ${buf}`);
+    clearInterval(interval);
+    client.close();
+  })
+);
 
-client.on('listening', common.mustCall(function() {
-  interval = setInterval(function() {
-    client.send([], client.address().port, common.localhostIPv4);
-  }, 10);
-}));
+client.on(
+  'listening',
+  common.mustCall(function() {
+    interval = setInterval(function() {
+      client.send([], client.address().port, common.localhostIPv4);
+    }, 10);
+  })
+);
 
 client.bind(0);
diff --git a/test/parallel/test-dgram-send-empty-buffer.js b/test/parallel/test-dgram-send-empty-buffer.js
index 76b014b8934c33..bf9e5ceaf53fe1 100644
--- a/test/parallel/test-dgram-send-empty-buffer.js
+++ b/test/parallel/test-dgram-send-empty-buffer.js
@@ -27,17 +27,23 @@ const dgram = require('dgram');
 
 const client = dgram.createSocket('udp4');
 
-client.bind(0, common.mustCall(function() {
-  const port = this.address().port;
+client.bind(
+  0,
+  common.mustCall(function() {
+    const port = this.address().port;
 
-  client.on('message', common.mustCall(function onMessage(buffer) {
-    assert.strictEqual(buffer.length, 0);
-    clearInterval(interval);
-    client.close();
-  }));
+    client.on(
+      'message',
+      common.mustCall(function onMessage(buffer) {
+        assert.strictEqual(buffer.length, 0);
+        clearInterval(interval);
+        client.close();
+      })
+    );
 
-  const buf = Buffer.alloc(0);
-  const interval = setInterval(function() {
-    client.send(buf, 0, 0, port, '127.0.0.1', common.mustCall());
-  }, 10);
-}));
+    const buf = Buffer.alloc(0);
+    const interval = setInterval(function() {
+      client.send(buf, 0, 0, port, '127.0.0.1', common.mustCall());
+    }, 10);
+  })
+);
diff --git a/test/parallel/test-dgram-send-empty-packet.js b/test/parallel/test-dgram-send-empty-packet.js
index eb4f79e8aafb41..66e5b0006437c9 100644
--- a/test/parallel/test-dgram-send-empty-packet.js
+++ b/test/parallel/test-dgram-send-empty-packet.js
@@ -6,24 +6,26 @@ const dgram = require('dgram');
 
 const client = dgram.createSocket('udp4');
 
-client.bind(0, common.mustCall(function() {
+client.bind(
+  0,
+  common.mustCall(function() {
+    client.on('message', common.mustCall(callback));
 
-  client.on('message', common.mustCall(callback));
+    const port = this.address().port;
+    const buf = Buffer.alloc(1);
 
-  const port = this.address().port;
-  const buf = Buffer.alloc(1);
+    const interval = setInterval(function() {
+      client.send(buf, 0, 0, port, '127.0.0.1', common.mustCall(callback));
+    }, 10);
 
-  const interval = setInterval(function() {
-    client.send(buf, 0, 0, port, '127.0.0.1', common.mustCall(callback));
-  }, 10);
-
-  function callback(firstArg) {
-    // If client.send() callback, firstArg should be null.
-    // If client.on('message') listener, firstArg should be a 0-length buffer.
-    if (firstArg instanceof Buffer) {
-      assert.strictEqual(firstArg.length, 0);
-      clearInterval(interval);
-      client.close();
+    function callback(firstArg) {
+      // If client.send() callback, firstArg should be null.
+      // If client.on('message') listener, firstArg should be a 0-length buffer.
+      if (firstArg instanceof Buffer) {
+        assert.strictEqual(firstArg.length, 0);
+        clearInterval(interval);
+        client.close();
+      }
     }
-  }
-}));
+  })
+);
diff --git a/test/parallel/test-dgram-send-error.js b/test/parallel/test-dgram-send-error.js
index f6d37f2c818112..601f83ea56c647 100644
--- a/test/parallel/test-dgram-send-error.js
+++ b/test/parallel/test-dgram-send-error.js
@@ -12,21 +12,26 @@ function getSocket(callback) {
   const socket = dgram.createSocket('udp4');
 
   socket.on('message', common.mustNotCall('Should not receive any messages.'));
-  socket.bind(common.mustCall(() => {
-    socket[kStateSymbol].handle.lookup = function(address, callback) {
-      process.nextTick(callback, mockError);
-    };
+  socket.bind(
+    common.mustCall(() => {
+      socket[kStateSymbol].handle.lookup = function(address, callback) {
+        process.nextTick(callback, mockError);
+      };
 
-    callback(socket);
-  }));
+      callback(socket);
+    })
+  );
   return socket;
 }
 
 getSocket((socket) => {
-  socket.on('error', common.mustCall((err) => {
-    socket.close();
-    assert.strictEqual(err, mockError);
-  }));
+  socket.on(
+    'error',
+    common.mustCall((err) => {
+      socket.close();
+      assert.strictEqual(err, mockError);
+    })
+  );
 
   socket.send('foo', socket.address().port, 'localhost');
 });
@@ -45,25 +50,27 @@ getSocket((socket) => {
 
   socket.on('message', common.mustNotCall('Should not receive any messages.'));
 
-  socket.bind(common.mustCall(() => {
-    const port = socket.address().port;
-    const callback = common.mustCall((err) => {
-      socket.close();
-      assert.strictEqual(err.code, 'UNKNOWN');
-      assert.strictEqual(err.errno, 'UNKNOWN');
-      assert.strictEqual(err.syscall, 'send');
-      assert.strictEqual(err.address, common.localhostIPv4);
-      assert.strictEqual(err.port, port);
-      assert.strictEqual(
-        err.message,
-        `${err.syscall} ${err.code} ${err.address}:${err.port}`
-      );
-    });
+  socket.bind(
+    common.mustCall(() => {
+      const port = socket.address().port;
+      const callback = common.mustCall((err) => {
+        socket.close();
+        assert.strictEqual(err.code, 'UNKNOWN');
+        assert.strictEqual(err.errno, 'UNKNOWN');
+        assert.strictEqual(err.syscall, 'send');
+        assert.strictEqual(err.address, common.localhostIPv4);
+        assert.strictEqual(err.port, port);
+        assert.strictEqual(
+          err.message,
+          `${err.syscall} ${err.code} ${err.address}:${err.port}`
+        );
+      });
 
-    socket[kStateSymbol].handle.send = function() {
-      return UV_UNKNOWN;
-    };
+      socket[kStateSymbol].handle.send = function() {
+        return UV_UNKNOWN;
+      };
 
-    socket.send('foo', port, common.localhostIPv4, callback);
-  }));
+      socket.send('foo', port, common.localhostIPv4, callback);
+    })
+  );
 }
diff --git a/test/parallel/test-dgram-send-invalid-msg-type.js b/test/parallel/test-dgram-send-invalid-msg-type.js
index 7a85455ce96464..9318302d1f6193 100644
--- a/test/parallel/test-dgram-send-invalid-msg-type.js
+++ b/test/parallel/test-dgram-send-invalid-msg-type.js
@@ -31,6 +31,10 @@ const dgram = require('dgram');
 
 // Should throw but not crash.
 const socket = dgram.createSocket('udp4');
-assert.throws(function() { socket.send(true, 0, 1, 1, 'host'); }, TypeError);
-assert.throws(function() { socket.sendto(5, 0, 1, 1, 'host'); }, TypeError);
+assert.throws(function() {
+  socket.send(true, 0, 1, 1, 'host');
+}, TypeError);
+assert.throws(function() {
+  socket.sendto(5, 0, 1, 1, 'host');
+}, TypeError);
 socket.close();
diff --git a/test/parallel/test-dgram-send-multi-buffer-copy.js b/test/parallel/test-dgram-send-multi-buffer-copy.js
index 2ee87494b02836..79e0f18a422c6c 100644
--- a/test/parallel/test-dgram-send-multi-buffer-copy.js
+++ b/test/parallel/test-dgram-send-multi-buffer-copy.js
@@ -19,10 +19,13 @@ client.on('listening', function() {
   toSend.splice(0, 2);
 });
 
-client.on('message', common.mustCall(function onMessage(buf, info) {
-  const expected = Buffer.concat([buf1, buf2]);
-  assert.ok(buf.equals(expected), 'message was received correctly');
-  client.close();
-}));
+client.on(
+  'message',
+  common.mustCall(function onMessage(buf, info) {
+    const expected = Buffer.concat([buf1, buf2]);
+    assert.ok(buf.equals(expected), 'message was received correctly');
+    client.close();
+  })
+);
 
 client.bind(0);
diff --git a/test/parallel/test-dgram-send-multi-string-array.js b/test/parallel/test-dgram-send-multi-string-array.js
index 8d73a6d1839fcb..0a0995b340bc02 100644
--- a/test/parallel/test-dgram-send-multi-string-array.js
+++ b/test/parallel/test-dgram-send-multi-string-array.js
@@ -5,9 +5,12 @@ const dgram = require('dgram');
 const socket = dgram.createSocket('udp4');
 const data = ['foo', 'bar', 'baz'];
 
-socket.on('message', common.mustCall((msg, rinfo) => {
-  socket.close();
-  assert.deepStrictEqual(msg.toString(), data.join(''));
-}));
+socket.on(
+  'message',
+  common.mustCall((msg, rinfo) => {
+    socket.close();
+    assert.deepStrictEqual(msg.toString(), data.join(''));
+  })
+);
 
 socket.bind(() => socket.send(data, socket.address().port, 'localhost'));
diff --git a/test/parallel/test-dgram-sendto.js b/test/parallel/test-dgram-sendto.js
index 3922ccbb646594..22af7e1ad9e3bd 100644
--- a/test/parallel/test-dgram-sendto.js
+++ b/test/parallel/test-dgram-sendto.js
@@ -7,31 +7,32 @@ const socket = dgram.createSocket('udp4');
 const errObj = {
   code: 'ERR_INVALID_ARG_TYPE',
   name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-  message: 'The "offset" argument must be of type number. Received type ' +
-           'undefined'
+  message:
+    'The "offset" argument must be of type number. Received type ' + 'undefined'
 };
 assert.throws(() => socket.sendto(), errObj);
 
-errObj.message = 'The "length" argument must be of type number. Received ' +
-                 'type string';
+errObj.message =
+  'The "length" argument must be of type number. Received ' + 'type string';
 assert.throws(
   () => socket.sendto('buffer', 1, 'offset', 'port', 'address', 'cb'),
-  errObj);
+  errObj
+);
 
-errObj.message = 'The "offset" argument must be of type number. Received ' +
-                 'type string';
+errObj.message =
+  'The "offset" argument must be of type number. Received ' + 'type string';
 assert.throws(
   () => socket.sendto('buffer', 'offset', 1, 'port', 'address', 'cb'),
-  errObj);
+  errObj
+);
 
-errObj.message = 'The "address" argument must be of type string. Received ' +
-                 'type boolean';
-assert.throws(
-  () => socket.sendto('buffer', 1, 1, 10, false, 'cb'),
-  errObj);
+errObj.message =
+  'The "address" argument must be of type string. Received ' + 'type boolean';
+assert.throws(() => socket.sendto('buffer', 1, 1, 10, false, 'cb'), errObj);
 
-errObj.message = 'The "port" argument must be of type number. Received ' +
-                 'type boolean';
+errObj.message =
+  'The "port" argument must be of type number. Received ' + 'type boolean';
 assert.throws(
   () => socket.sendto('buffer', 1, 1, false, 'address', 'cb'),
-  errObj);
+  errObj
+);
diff --git a/test/parallel/test-dgram-setBroadcast.js b/test/parallel/test-dgram-setBroadcast.js
index f4ce7ff06adbe4..30171c9b608331 100644
--- a/test/parallel/test-dgram-setBroadcast.js
+++ b/test/parallel/test-dgram-setBroadcast.js
@@ -17,9 +17,12 @@ const dgram = require('dgram');
   // Can call setBroadcast() after binding the socket.
   const socket = dgram.createSocket('udp4');
 
-  socket.bind(0, common.mustCall(() => {
-    socket.setBroadcast(true);
-    socket.setBroadcast(false);
-    socket.close();
-  }));
+  socket.bind(
+    0,
+    common.mustCall(() => {
+      socket.setBroadcast(true);
+      socket.setBroadcast(false);
+      socket.close();
+    })
+  );
 }
diff --git a/test/parallel/test-dgram-setTTL.js b/test/parallel/test-dgram-setTTL.js
index c6e8cb3c66923c..551c98440bcae8 100644
--- a/test/parallel/test-dgram-setTTL.js
+++ b/test/parallel/test-dgram-setTTL.js
@@ -5,22 +5,29 @@ const dgram = require('dgram');
 const socket = dgram.createSocket('udp4');
 
 socket.bind(0);
-socket.on('listening', common.mustCall(() => {
-  const result = socket.setTTL(16);
-  assert.strictEqual(result, 16);
+socket.on(
+  'listening',
+  common.mustCall(() => {
+    const result = socket.setTTL(16);
+    assert.strictEqual(result, 16);
 
-  common.expectsError(() => {
-    socket.setTTL('foo');
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "ttl" argument must be of type number. Received type string'
-  });
+    common.expectsError(
+      () => {
+        socket.setTTL('foo');
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "ttl" argument must be of type number. Received type string'
+      }
+    );
 
-  // TTL must be a number from > 0 to < 256
-  assert.throws(() => {
-    socket.setTTL(1000);
-  }, /^Error: setTTL EINVAL$/);
+    // TTL must be a number from > 0 to < 256
+    assert.throws(() => {
+      socket.setTTL(1000);
+    }, /^Error: setTTL EINVAL$/);
 
-  socket.close();
-}));
+    socket.close();
+  })
+);
diff --git a/test/parallel/test-dgram-socket-buffer-size.js b/test/parallel/test-dgram-socket-buffer-size.js
index c2936ba8fd91b0..78a937aac1bde3 100644
--- a/test/parallel/test-dgram-socket-buffer-size.js
+++ b/test/parallel/test-dgram-socket-buffer-size.js
@@ -6,20 +6,18 @@ const assert = require('assert');
 const dgram = require('dgram');
 const { SystemError } = require('internal/errors');
 const { internalBinding } = require('internal/test/binding');
-const {
-  UV_EBADF,
-  UV_EINVAL,
-  UV_ENOTSOCK
-} = internalBinding('uv');
+const { UV_EBADF, UV_EINVAL, UV_ENOTSOCK } = internalBinding('uv');
 
 function getExpectedError(type) {
   const code = common.isWindows ? 'ENOTSOCK' : 'EBADF';
-  const message = common.isWindows ?
-    'socket operation on non-socket' : 'bad file descriptor';
+  const message = common.isWindows
+    ? 'socket operation on non-socket'
+    : 'bad file descriptor';
   const errno = common.isWindows ? UV_ENOTSOCK : UV_EBADF;
   const syscall = `uv_${type}_buffer_size`;
-  const suffix = common.isWindows ?
-    'ENOTSOCK (socket operation on non-socket)' : 'EBADF (bad file descriptor)';
+  const suffix = common.isWindows
+    ? 'ENOTSOCK (socket operation on non-socket)'
+    : 'EBADF (bad file descriptor)';
   const error = {
     code: 'ERR_SOCKET_BUFFER_SIZE',
     type: SystemError,
@@ -76,34 +74,38 @@ function getExpectedError(type) {
 
   const socket = dgram.createSocket('udp4');
 
-  socket.bind(common.mustCall(() => {
-    badBufferSizes.forEach((badBufferSize) => {
-      common.expectsError(() => {
-        socket.setRecvBufferSize(badBufferSize);
-      }, errorObj);
-
-      common.expectsError(() => {
-        socket.setSendBufferSize(badBufferSize);
-      }, errorObj);
-    });
-    socket.close();
-  }));
+  socket.bind(
+    common.mustCall(() => {
+      badBufferSizes.forEach((badBufferSize) => {
+        common.expectsError(() => {
+          socket.setRecvBufferSize(badBufferSize);
+        }, errorObj);
+
+        common.expectsError(() => {
+          socket.setSendBufferSize(badBufferSize);
+        }, errorObj);
+      });
+      socket.close();
+    })
+  );
 }
 
 {
   // Can set and get buffer sizes after binding the socket.
   const socket = dgram.createSocket('udp4');
 
-  socket.bind(common.mustCall(() => {
-    socket.setRecvBufferSize(10000);
-    socket.setSendBufferSize(10000);
-
-    // note: linux will double the buffer size
-    const expectedBufferSize = common.isLinux ? 20000 : 10000;
-    assert.strictEqual(socket.getRecvBufferSize(), expectedBufferSize);
-    assert.strictEqual(socket.getSendBufferSize(), expectedBufferSize);
-    socket.close();
-  }));
+  socket.bind(
+    common.mustCall(() => {
+      socket.setRecvBufferSize(10000);
+      socket.setSendBufferSize(10000);
+
+      // note: linux will double the buffer size
+      const expectedBufferSize = common.isLinux ? 20000 : 10000;
+      assert.strictEqual(socket.getRecvBufferSize(), expectedBufferSize);
+      assert.strictEqual(socket.getSendBufferSize(), expectedBufferSize);
+      socket.close();
+    })
+  );
 }
 
 {
@@ -116,17 +118,20 @@ function getExpectedError(type) {
   const errorObj = {
     code: 'ERR_SOCKET_BUFFER_SIZE',
     type: SystemError,
-    message: 'Could not get or set buffer size: uv_recv_buffer_size ' +
-             'returned EINVAL (invalid argument)',
+    message:
+      'Could not get or set buffer size: uv_recv_buffer_size ' +
+      'returned EINVAL (invalid argument)',
     info
   };
   const socket = dgram.createSocket('udp4');
-  socket.bind(common.mustCall(() => {
-    common.expectsError(() => {
-      socket.setRecvBufferSize(2147483648);
-    }, errorObj);
-    socket.close();
-  }));
+  socket.bind(
+    common.mustCall(() => {
+      common.expectsError(() => {
+        socket.setRecvBufferSize(2147483648);
+      }, errorObj);
+      socket.close();
+    })
+  );
 }
 
 {
@@ -139,15 +144,18 @@ function getExpectedError(type) {
   const errorObj = {
     code: 'ERR_SOCKET_BUFFER_SIZE',
     type: SystemError,
-    message: 'Could not get or set buffer size: uv_send_buffer_size ' +
-             'returned EINVAL (invalid argument)',
+    message:
+      'Could not get or set buffer size: uv_send_buffer_size ' +
+      'returned EINVAL (invalid argument)',
     info
   };
   const socket = dgram.createSocket('udp4');
-  socket.bind(common.mustCall(() => {
-    common.expectsError(() => {
-      socket.setSendBufferSize(2147483648);
-    }, errorObj);
-    socket.close();
-  }));
+  socket.bind(
+    common.mustCall(() => {
+      common.expectsError(() => {
+        socket.setSendBufferSize(2147483648);
+      }, errorObj);
+      socket.close();
+    })
+  );
 }
diff --git a/test/parallel/test-dgram-udp4.js b/test/parallel/test-dgram-udp4.js
index c7ee34b2c1085b..3a840becd0fd4e 100644
--- a/test/parallel/test-dgram-udp4.js
+++ b/test/parallel/test-dgram-udp4.js
@@ -26,27 +26,32 @@ const dgram = require('dgram');
 const message_to_send = 'A message to send';
 
 const server = dgram.createSocket('udp4');
-server.on('message', common.mustCall((msg, rinfo) => {
-  assert.strictEqual(rinfo.address, common.localhostIPv4);
-  assert.strictEqual(msg.toString(), message_to_send.toString());
-  server.send(msg, 0, msg.length, rinfo.port, rinfo.address);
-}));
-server.on('listening', common.mustCall(() => {
-  const client = dgram.createSocket('udp4');
-  const port = server.address().port;
-  client.on('message', common.mustCall((msg, rinfo) => {
+server.on(
+  'message',
+  common.mustCall((msg, rinfo) => {
     assert.strictEqual(rinfo.address, common.localhostIPv4);
-    assert.strictEqual(rinfo.port, port);
     assert.strictEqual(msg.toString(), message_to_send.toString());
-    client.close();
-    server.close();
-  }));
-  client.send(message_to_send,
-              0,
-              message_to_send.length,
-              port,
-              'localhost');
-  client.on('close', common.mustCall());
-}));
+    server.send(msg, 0, msg.length, rinfo.port, rinfo.address);
+  })
+);
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = dgram.createSocket('udp4');
+    const port = server.address().port;
+    client.on(
+      'message',
+      common.mustCall((msg, rinfo) => {
+        assert.strictEqual(rinfo.address, common.localhostIPv4);
+        assert.strictEqual(rinfo.port, port);
+        assert.strictEqual(msg.toString(), message_to_send.toString());
+        client.close();
+        server.close();
+      })
+    );
+    client.send(message_to_send, 0, message_to_send.length, port, 'localhost');
+    client.on('close', common.mustCall());
+  })
+);
 server.on('close', common.mustCall());
 server.bind(0);
diff --git a/test/parallel/test-dgram-udp6-send-default-host.js b/test/parallel/test-dgram-udp6-send-default-host.js
index d801ca7e8dcd08..2d83ec2bc4f383 100644
--- a/test/parallel/test-dgram-udp6-send-default-host.js
+++ b/test/parallel/test-dgram-udp6-send-default-host.js
@@ -1,40 +1,47 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasIPv6)
-  common.skip('no IPv6 support');
+if (!common.hasIPv6) common.skip('no IPv6 support');
 
 const assert = require('assert');
 const dgram = require('dgram');
 
 const client = dgram.createSocket('udp6');
 
-const toSend = [Buffer.alloc(256, 'x'),
-                Buffer.alloc(256, 'y'),
-                Buffer.alloc(256, 'z'),
-                'hello'];
+const toSend = [
+  Buffer.alloc(256, 'x'),
+  Buffer.alloc(256, 'y'),
+  Buffer.alloc(256, 'z'),
+  'hello'
+];
 
 const received = [];
 
-client.on('listening', common.mustCall(() => {
-  const port = client.address().port;
-  client.send(toSend[0], 0, toSend[0].length, port);
-  client.send(toSend[1], port);
-  client.send([toSend[2]], port);
-  client.send(toSend[3], 0, toSend[3].length, port);
-}));
-
-client.on('message', common.mustCall((buf, info) => {
-  received.push(buf.toString());
-
-  if (received.length === toSend.length) {
-    // The replies may arrive out of order -> sort them before checking.
-    received.sort();
-
-    const expected = toSend.map(String).sort();
-    assert.deepStrictEqual(received, expected);
-    client.close();
-  }
-}, toSend.length));
+client.on(
+  'listening',
+  common.mustCall(() => {
+    const port = client.address().port;
+    client.send(toSend[0], 0, toSend[0].length, port);
+    client.send(toSend[1], port);
+    client.send([toSend[2]], port);
+    client.send(toSend[3], 0, toSend[3].length, port);
+  })
+);
+
+client.on(
+  'message',
+  common.mustCall((buf, info) => {
+    received.push(buf.toString());
+
+    if (received.length === toSend.length) {
+      // The replies may arrive out of order -> sort them before checking.
+      received.sort();
+
+      const expected = toSend.map(String).sort();
+      assert.deepStrictEqual(received, expected);
+      client.close();
+    }
+  }, toSend.length)
+);
 
 client.bind(0);
diff --git a/test/parallel/test-dns-cancel-reverse-lookup.js b/test/parallel/test-dns-cancel-reverse-lookup.js
index 0918178e1257ba..cbaa204b9590af 100644
--- a/test/parallel/test-dns-cancel-reverse-lookup.js
+++ b/test/parallel/test-dns-cancel-reverse-lookup.js
@@ -8,22 +8,31 @@ const dgram = require('dgram');
 const server = dgram.createSocket('udp4');
 const resolver = new Resolver();
 
-server.bind(0, common.mustCall(() => {
-  resolver.setServers([`127.0.0.1:${server.address().port}`]);
-  resolver.reverse('123.45.67.89', common.mustCall((err, res) => {
-    assert.strictEqual(err.code, 'ECANCELLED');
-    assert.strictEqual(err.errno, 'ECANCELLED');
-    assert.strictEqual(err.syscall, 'getHostByAddr');
-    assert.strictEqual(err.hostname, '123.45.67.89');
-    server.close();
-  }));
-}));
+server.bind(
+  0,
+  common.mustCall(() => {
+    resolver.setServers([`127.0.0.1:${server.address().port}`]);
+    resolver.reverse(
+      '123.45.67.89',
+      common.mustCall((err, res) => {
+        assert.strictEqual(err.code, 'ECANCELLED');
+        assert.strictEqual(err.errno, 'ECANCELLED');
+        assert.strictEqual(err.syscall, 'getHostByAddr');
+        assert.strictEqual(err.hostname, '123.45.67.89');
+        server.close();
+      })
+    );
+  })
+);
 
-server.on('message', common.mustCall((msg, { address, port }) => {
-  const parsed = dnstools.parseDNSPacket(msg);
-  const domain = parsed.questions[0].domain;
-  assert.strictEqual(domain, '89.67.45.123.in-addr.arpa');
+server.on(
+  'message',
+  common.mustCall((msg, { address, port }) => {
+    const parsed = dnstools.parseDNSPacket(msg);
+    const domain = parsed.questions[0].domain;
+    assert.strictEqual(domain, '89.67.45.123.in-addr.arpa');
 
-  // Do not send a reply.
-  resolver.cancel();
-}));
+    // Do not send a reply.
+    resolver.cancel();
+  })
+);
diff --git a/test/parallel/test-dns-channel-cancel.js b/test/parallel/test-dns-channel-cancel.js
index 797d61efb40653..b1453e0875a176 100644
--- a/test/parallel/test-dns-channel-cancel.js
+++ b/test/parallel/test-dns-channel-cancel.js
@@ -8,22 +8,31 @@ const dgram = require('dgram');
 const server = dgram.createSocket('udp4');
 const resolver = new Resolver();
 
-server.bind(0, common.mustCall(() => {
-  resolver.setServers([`127.0.0.1:${server.address().port}`]);
-  resolver.resolve4('example.org', common.mustCall((err, res) => {
-    assert.strictEqual(err.code, 'ECANCELLED');
-    assert.strictEqual(err.errno, 'ECANCELLED');
-    assert.strictEqual(err.syscall, 'queryA');
-    assert.strictEqual(err.hostname, 'example.org');
-    server.close();
-  }));
-}));
+server.bind(
+  0,
+  common.mustCall(() => {
+    resolver.setServers([`127.0.0.1:${server.address().port}`]);
+    resolver.resolve4(
+      'example.org',
+      common.mustCall((err, res) => {
+        assert.strictEqual(err.code, 'ECANCELLED');
+        assert.strictEqual(err.errno, 'ECANCELLED');
+        assert.strictEqual(err.syscall, 'queryA');
+        assert.strictEqual(err.hostname, 'example.org');
+        server.close();
+      })
+    );
+  })
+);
 
-server.on('message', common.mustCall((msg, { address, port }) => {
-  const parsed = dnstools.parseDNSPacket(msg);
-  const domain = parsed.questions[0].domain;
-  assert.strictEqual(domain, 'example.org');
+server.on(
+  'message',
+  common.mustCall((msg, { address, port }) => {
+    const parsed = dnstools.parseDNSPacket(msg);
+    const domain = parsed.questions[0].domain;
+    assert.strictEqual(domain, 'example.org');
 
-  // Do not send a reply.
-  resolver.cancel();
-}));
+    // Do not send a reply.
+    resolver.cancel();
+  })
+);
diff --git a/test/parallel/test-dns-lookup.js b/test/parallel/test-dns-lookup.js
index b30c5795feb31a..34a24da5609951 100644
--- a/test/parallel/test-dns-lookup.js
+++ b/test/parallel/test-dns-lookup.js
@@ -25,33 +25,37 @@ common.expectWarning({
   // For 'internal/test/binding' module.
   'internal/test/binding': [
     'These APIs are exposed only for testing and are not ' +
-    'tracked by any versioning system or deprecation process.'
+      'tracked by any versioning system or deprecation process.'
   ],
   // For dns.promises.
-  'ExperimentalWarning': [
-    'The dns.promises API is experimental'
-  ],
+  ExperimentalWarning: ['The dns.promises API is experimental'],
   // For calling `dns.lookup` with falsy `hostname`.
-  'DeprecationWarning': [
+  DeprecationWarning: [
     'The provided hostname "false" is not a valid ' +
-    'hostname, and is supported in the dns module solely for compatibility.',
-    'DEP0118',
-  ],
+      'hostname, and is supported in the dns module solely for compatibility.',
+    'DEP0118'
+  ]
 });
 
-common.expectsError(() => {
-  dns.lookup(false, 'cb');
-}, {
-  code: 'ERR_INVALID_CALLBACK',
-  type: TypeError
-});
-
-common.expectsError(() => {
-  dns.lookup(false, 'options', 'cb');
-}, {
-  code: 'ERR_INVALID_CALLBACK',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    dns.lookup(false, 'cb');
+  },
+  {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError
+  }
+);
+
+common.expectsError(
+  () => {
+    dns.lookup(false, 'options', 'cb');
+  },
+  {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError
+  }
+);
 
 {
   const err = {
@@ -65,7 +69,9 @@ common.expectsError(() => {
     all: false
   };
 
-  common.expectsError(() => { dnsPromises.lookup(false, options); }, err);
+  common.expectsError(() => {
+    dnsPromises.lookup(false, options);
+  }, err);
   common.expectsError(() => {
     dns.lookup(false, options, common.mustNotCall());
   }, err);
@@ -83,7 +89,9 @@ common.expectsError(() => {
     all: false
   };
 
-  common.expectsError(() => { dnsPromises.lookup(false, options); }, err);
+  common.expectsError(() => {
+    dnsPromises.lookup(false, options);
+  }, err);
   common.expectsError(() => {
     dns.lookup(false, options, common.mustNotCall());
   }, err);
@@ -114,49 +122,66 @@ common.expectsError(() => {
   assert.deepStrictEqual(res, { address: '127.0.0.1', family: 4 });
 })();
 
-dns.lookup(false, {
-  hints: 0,
-  family: 0,
-  all: true
-}, common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
-  assert.deepStrictEqual(result, []);
-  assert.strictEqual(addressType, undefined);
-}));
-
-dns.lookup('127.0.0.1', {
-  hints: 0,
-  family: 4,
-  all: true
-}, common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
-  assert.deepStrictEqual(result, [{
-    address: '127.0.0.1',
-    family: 4
-  }]);
-  assert.strictEqual(addressType, undefined);
-}));
-
-dns.lookup('127.0.0.1', {
-  hints: 0,
-  family: 4,
-  all: false
-}, common.mustCall((error, result, addressType) => {
-  assert.ifError(error);
-  assert.deepStrictEqual(result, '127.0.0.1');
-  assert.strictEqual(addressType, 4);
-}));
+dns.lookup(
+  false,
+  {
+    hints: 0,
+    family: 0,
+    all: true
+  },
+  common.mustCall((error, result, addressType) => {
+    assert.ifError(error);
+    assert.deepStrictEqual(result, []);
+    assert.strictEqual(addressType, undefined);
+  })
+);
+
+dns.lookup(
+  '127.0.0.1',
+  {
+    hints: 0,
+    family: 4,
+    all: true
+  },
+  common.mustCall((error, result, addressType) => {
+    assert.ifError(error);
+    assert.deepStrictEqual(result, [
+      {
+        address: '127.0.0.1',
+        family: 4
+      }
+    ]);
+    assert.strictEqual(addressType, undefined);
+  })
+);
+
+dns.lookup(
+  '127.0.0.1',
+  {
+    hints: 0,
+    family: 4,
+    all: false
+  },
+  common.mustCall((error, result, addressType) => {
+    assert.ifError(error);
+    assert.deepStrictEqual(result, '127.0.0.1');
+    assert.strictEqual(addressType, 4);
+  })
+);
 
 let tickValue = 0;
 
-dns.lookup('example.com', common.mustCall((error, result, addressType) => {
-  assert(error);
-  assert.strictEqual(tickValue, 1);
-  assert.strictEqual(error.code, 'ENOENT');
-  const descriptor = Object.getOwnPropertyDescriptor(error, 'message');
-  // The error message should be non-enumerable.
-  assert.strictEqual(descriptor.enumerable, false);
-}));
+dns.lookup(
+  'example.com',
+  common.mustCall((error, result, addressType) => {
+    assert(error);
+    assert.strictEqual(tickValue, 1);
+    assert.strictEqual(error.code, 'ENOENT');
+    const descriptor = Object.getOwnPropertyDescriptor(error, 'message');
+    // The error message should be non-enumerable.
+    assert.strictEqual(descriptor.enumerable, false);
+  })
+);
 
 // Make sure that the error callback is called
 // on next tick.
diff --git a/test/parallel/test-dns-lookupService.js b/test/parallel/test-dns-lookupService.js
index 92fce6cbd3f189..6ba4602350e184 100644
--- a/test/parallel/test-dns-lookupService.js
+++ b/test/parallel/test-dns-lookupService.js
@@ -10,11 +10,8 @@ const dns = require('dns');
 // Stub `getnameinfo` to *always* error.
 cares.getnameinfo = () => UV_ENOENT;
 
-assert.throws(
-  () => dns.lookupService('127.0.0.1', 80, common.mustNotCall()),
-  {
-    code: 'ENOENT',
-    message: 'getnameinfo ENOENT 127.0.0.1',
-    syscall: 'getnameinfo'
-  }
-);
+assert.throws(() => dns.lookupService('127.0.0.1', 80, common.mustNotCall()), {
+  code: 'ENOENT',
+  message: 'getnameinfo ENOENT 127.0.0.1',
+  syscall: 'getnameinfo'
+});
diff --git a/test/parallel/test-dns-multi-channel.js b/test/parallel/test-dns-multi-channel.js
index bd88fe0b24fc75..f4c5878491033f 100644
--- a/test/parallel/test-dns-multi-channel.js
+++ b/test/parallel/test-dns-multi-channel.js
@@ -18,36 +18,51 @@ const servers = [
 
 let waiting = servers.length;
 for (const { socket, reply } of servers) {
-  socket.on('message', common.mustCall((msg, { address, port }) => {
-    const parsed = dnstools.parseDNSPacket(msg);
-    const domain = parsed.questions[0].domain;
-    assert.strictEqual(domain, 'example.org');
+  socket.on(
+    'message',
+    common.mustCall((msg, { address, port }) => {
+      const parsed = dnstools.parseDNSPacket(msg);
+      const domain = parsed.questions[0].domain;
+      assert.strictEqual(domain, 'example.org');
 
-    socket.send(dnstools.writeDNSPacket({
-      id: parsed.id,
-      questions: parsed.questions,
-      answers: [reply],
-    }), port, address);
-  }));
+      socket.send(
+        dnstools.writeDNSPacket({
+          id: parsed.id,
+          questions: parsed.questions,
+          answers: [reply]
+        }),
+        port,
+        address
+      );
+    })
+  );
 
-  socket.bind(0, common.mustCall(() => {
-    if (--waiting === 0) ready();
-  }));
+  socket.bind(
+    0,
+    common.mustCall(() => {
+      if (--waiting === 0) ready();
+    })
+  );
 }
 
-
 function ready() {
   const resolvers = servers.map((server) => ({
     server,
     resolver: new Resolver()
   }));
 
-  for (const { server: { socket, reply }, resolver } of resolvers) {
+  for (const {
+    server: { socket, reply },
+    resolver
+  } of resolvers) {
     resolver.setServers([`127.0.0.1:${socket.address().port}`]);
-    resolver.resolve4('example.org', common.mustCall((err, res) => {
-      assert.ifError(err);
-      assert.deepStrictEqual(res, [reply.address]);
-      socket.close();
-    }));
+    resolver.resolve4(
+      'example.org',
+      common.mustCall((err, res) => {
+        assert.ifError(err);
+        assert.deepStrictEqual(res, [reply.address]);
+        socket.close();
+      })
+    );
   }
 }
diff --git a/test/parallel/test-dns-resolveany-bad-ancount.js b/test/parallel/test-dns-resolveany-bad-ancount.js
index 71fcbe03cd58f1..b5fef4f3746c91 100644
--- a/test/parallel/test-dns-resolveany-bad-ancount.js
+++ b/test/parallel/test-dns-resolveany-bad-ancount.js
@@ -8,40 +8,52 @@ const dnsPromises = dns.promises;
 
 const server = dgram.createSocket('udp4');
 
-server.on('message', common.mustCall((msg, { address, port }) => {
-  const parsed = dnstools.parseDNSPacket(msg);
-  const domain = parsed.questions[0].domain;
-  assert.strictEqual(domain, 'example.org');
+server.on(
+  'message',
+  common.mustCall((msg, { address, port }) => {
+    const parsed = dnstools.parseDNSPacket(msg);
+    const domain = parsed.questions[0].domain;
+    assert.strictEqual(domain, 'example.org');
 
-  const buf = dnstools.writeDNSPacket({
-    id: parsed.id,
-    questions: parsed.questions,
-    answers: { type: 'A', address: '1.2.3.4', ttl: 123, domain },
-  });
-  // Overwrite the # of answers with 2, which is incorrect.
-  buf.writeUInt16LE(2, 6);
-  server.send(buf, port, address);
-}, 2));
+    const buf = dnstools.writeDNSPacket({
+      id: parsed.id,
+      questions: parsed.questions,
+      answers: { type: 'A', address: '1.2.3.4', ttl: 123, domain }
+    });
+    // Overwrite the # of answers with 2, which is incorrect.
+    buf.writeUInt16LE(2, 6);
+    server.send(buf, port, address);
+  }, 2)
+);
 
-server.bind(0, common.mustCall(async () => {
-  const address = server.address();
-  dns.setServers([`127.0.0.1:${address.port}`]);
+server.bind(
+  0,
+  common.mustCall(async () => {
+    const address = server.address();
+    dns.setServers([`127.0.0.1:${address.port}`]);
 
-  dnsPromises.resolveAny('example.org')
-    .then(common.mustNotCall())
-    .catch(common.expectsError({
-      code: 'EBADRESP',
-      syscall: 'queryAny',
-      hostname: 'example.org'
-    }));
+    dnsPromises
+      .resolveAny('example.org')
+      .then(common.mustNotCall())
+      .catch(
+        common.expectsError({
+          code: 'EBADRESP',
+          syscall: 'queryAny',
+          hostname: 'example.org'
+        })
+      );
 
-  dns.resolveAny('example.org', common.mustCall((err) => {
-    assert.strictEqual(err.code, 'EBADRESP');
-    assert.strictEqual(err.syscall, 'queryAny');
-    assert.strictEqual(err.hostname, 'example.org');
-    const descriptor = Object.getOwnPropertyDescriptor(err, 'message');
-    // The error message should be non-enumerable.
-    assert.strictEqual(descriptor.enumerable, false);
-    server.close();
-  }));
-}));
+    dns.resolveAny(
+      'example.org',
+      common.mustCall((err) => {
+        assert.strictEqual(err.code, 'EBADRESP');
+        assert.strictEqual(err.syscall, 'queryAny');
+        assert.strictEqual(err.hostname, 'example.org');
+        const descriptor = Object.getOwnPropertyDescriptor(err, 'message');
+        // The error message should be non-enumerable.
+        assert.strictEqual(descriptor.enumerable, false);
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-dns-resolveany.js b/test/parallel/test-dns-resolveany.js
index 46694f240336cf..656469e480d7d7 100644
--- a/test/parallel/test-dns-resolveany.js
+++ b/test/parallel/test-dns-resolveany.js
@@ -11,7 +11,7 @@ const answers = [
   { type: 'AAAA', address: '::42', ttl: 123 },
   { type: 'MX', priority: 42, exchange: 'foobar.com', ttl: 124 },
   { type: 'NS', value: 'foobar.org', ttl: 457 },
-  { type: 'TXT', entries: [ 'v=spf1 ~all', 'xyz' ] },
+  { type: 'TXT', entries: ['v=spf1 ~all', 'xyz'] },
   { type: 'PTR', value: 'baz.org', ttl: 987 },
   {
     type: 'SOA',
@@ -22,39 +22,53 @@ const answers = [
     retry: 900,
     expire: 1800,
     minttl: 60
-  },
+  }
 ];
 
 const server = dgram.createSocket('udp4');
 
-server.on('message', common.mustCall((msg, { address, port }) => {
-  const parsed = dnstools.parseDNSPacket(msg);
-  const domain = parsed.questions[0].domain;
-  assert.strictEqual(domain, 'example.org');
+server.on(
+  'message',
+  common.mustCall((msg, { address, port }) => {
+    const parsed = dnstools.parseDNSPacket(msg);
+    const domain = parsed.questions[0].domain;
+    assert.strictEqual(domain, 'example.org');
 
-  server.send(dnstools.writeDNSPacket({
-    id: parsed.id,
-    questions: parsed.questions,
-    answers: answers.map((answer) => Object.assign({ domain }, answer)),
-  }), port, address);
-}, 2));
+    server.send(
+      dnstools.writeDNSPacket({
+        id: parsed.id,
+        questions: parsed.questions,
+        answers: answers.map((answer) => Object.assign({ domain }, answer))
+      }),
+      port,
+      address
+    );
+  }, 2)
+);
 
-server.bind(0, common.mustCall(async () => {
-  const address = server.address();
-  dns.setServers([`127.0.0.1:${address.port}`]);
+server.bind(
+  0,
+  common.mustCall(async () => {
+    const address = server.address();
+    dns.setServers([`127.0.0.1:${address.port}`]);
 
-  validateResults(await dnsPromises.resolveAny('example.org'));
+    validateResults(await dnsPromises.resolveAny('example.org'));
 
-  dns.resolveAny('example.org', common.mustCall((err, res) => {
-    assert.ifError(err);
-    validateResults(res);
-    server.close();
-  }));
-}));
+    dns.resolveAny(
+      'example.org',
+      common.mustCall((err, res) => {
+        assert.ifError(err);
+        validateResults(res);
+        server.close();
+      })
+    );
+  })
+);
 
 function validateResults(res) {
   // Compare copies with ttl removed, c-ares fiddles with that value.
   assert.deepStrictEqual(
     res.map((r) => Object.assign({}, r, { ttl: null })),
-    answers.map((r) => Object.assign({}, r, { ttl: null })));
+    answers.map((r) => Object.assign({}, r, { ttl: null }))
+  );
 }
diff --git a/test/parallel/test-dns-setserver-when-querying.js b/test/parallel/test-dns-setserver-when-querying.js
index 205a5b6c8585d0..45637ab6f2d38e 100644
--- a/test/parallel/test-dns-setserver-when-querying.js
+++ b/test/parallel/test-dns-setserver-when-querying.js
@@ -4,10 +4,7 @@ const common = require('../common');
 
 const dns = require('dns');
 
-const goog = [
-  '8.8.8.8',
-  '8.8.4.4',
-];
+const goog = ['8.8.8.8', '8.8.4.4'];
 
 {
   // Fix https://github.com/nodejs/node/issues/14734
diff --git a/test/parallel/test-dns-setservers-type-check.js b/test/parallel/test-dns-setservers-type-check.js
index 256c029427b86a..dc64e4e6fb4305 100644
--- a/test/parallel/test-dns-setservers-type-check.js
+++ b/test/parallel/test-dns-setservers-type-check.js
@@ -20,29 +20,22 @@ const promiseResolver = new dns.promises.Resolver();
     const errObj = {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "servers" argument must be of type Array. Received type ' +
-      typeof val
+      message:
+        'The "servers" argument must be of type Array. Received type ' +
+        typeof val
     };
-    assert.throws(
-      () => {
-        dns.setServers(val);
-      }, errObj
-    );
-    assert.throws(
-      () => {
-        resolver.setServers(val);
-      }, errObj
-    );
-    assert.throws(
-      () => {
-        dnsPromises.setServers(val);
-      }, errObj
-    );
-    assert.throws(
-      () => {
-        promiseResolver.setServers(val);
-      }, errObj
-    );
+    assert.throws(() => {
+      dns.setServers(val);
+    }, errObj);
+    assert.throws(() => {
+      resolver.setServers(val);
+    }, errObj);
+    assert.throws(() => {
+      dnsPromises.setServers(val);
+    }, errObj);
+    assert.throws(() => {
+      promiseResolver.setServers(val);
+    }, errObj);
   });
 }
 
@@ -60,28 +53,21 @@ const promiseResolver = new dns.promises.Resolver();
     const errObj = {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "servers[0]" argument must be of type string. ' +
-               `Received type ${typeof val[0]}`
+      message:
+        'The "servers[0]" argument must be of type string. ' +
+        `Received type ${typeof val[0]}`
     };
-    assert.throws(
-      () => {
-        dns.setServers(val);
-      }, errObj
-    );
-    assert.throws(
-      () => {
-        resolver.setServers(val);
-      }, errObj
-    );
-    assert.throws(
-      () => {
-        dnsPromises.setServers(val);
-      }, errObj
-    );
-    assert.throws(
-      () => {
-        promiseResolver.setServers(val);
-      }, errObj
-    );
+    assert.throws(() => {
+      dns.setServers(val);
+    }, errObj);
+    assert.throws(() => {
+      resolver.setServers(val);
+    }, errObj);
+    assert.throws(() => {
+      dnsPromises.setServers(val);
+    }, errObj);
+    assert.throws(() => {
+      promiseResolver.setServers(val);
+    }, errObj);
   });
 }
diff --git a/test/parallel/test-dns.js b/test/parallel/test-dns.js
index 200b5d3cb4758e..688b4fd7b17a1d 100644
--- a/test/parallel/test-dns.js
+++ b/test/parallel/test-dns.js
@@ -88,10 +88,7 @@ assert(existing.length > 0);
   });
 }
 
-const goog = [
-  '8.8.8.8',
-  '8.8.4.4',
-];
+const goog = ['8.8.8.8', '8.8.4.4'];
 dns.setServers(goog);
 assert.deepStrictEqual(dns.getServers(), goog);
 common.expectsError(() => dns.setServers(['foobar']), {
@@ -106,10 +103,7 @@ common.expectsError(() => dns.setServers(['127.0.0.1:va']), {
 });
 assert.deepStrictEqual(dns.getServers(), goog);
 
-const goog6 = [
-  '2001:4860:4860::8888',
-  '2001:4860:4860::8844',
-];
+const goog6 = ['2001:4860:4860::8888', '2001:4860:4860::8844'];
 dns.setServers(goog6);
 assert.deepStrictEqual(dns.getServers(), goog6);
 
@@ -139,8 +133,8 @@ assert.deepStrictEqual(dns.getServers(), []);
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "rrtype" argument must be of type string. ' +
-             'Received type object'
+    message:
+      'The "rrtype" argument must be of type string. ' + 'Received type object'
   };
   common.expectsError(() => {
     dns.resolve('example.com', [], common.mustNotCall());
@@ -153,8 +147,8 @@ assert.deepStrictEqual(dns.getServers(), []);
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "name" argument must be of type string. ' +
-             'Received type undefined'
+    message:
+      'The "name" argument must be of type string. ' + 'Received type undefined'
   };
   common.expectsError(() => {
     dnsPromises.resolve();
@@ -163,11 +157,14 @@ assert.deepStrictEqual(dns.getServers(), []);
 
 // dns.lookup should accept only falsey and string values
 {
-  const errorReg = common.expectsError({
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: /^The "hostname" argument must be of type string\. Received type .*/
-  }, 10);
+  const errorReg = common.expectsError(
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: /^The "hostname" argument must be of type string\. Received type .*/
+    },
+    10
+  );
 
   assert.throws(() => dns.lookup({}, common.mustNotCall()), errorReg);
 
@@ -177,8 +174,10 @@ assert.deepStrictEqual(dns.getServers(), []);
 
   assert.throws(() => dns.lookup(1, common.mustNotCall()), errorReg);
 
-  assert.throws(() => dns.lookup(common.mustNotCall(), common.mustNotCall()),
-                errorReg);
+  assert.throws(
+    () => dns.lookup(common.mustNotCall(), common.mustNotCall()),
+    errorReg
+  );
 
   assert.throws(() => dnsPromises.lookup({}), errorReg);
   assert.throws(() => dnsPromises.lookup([]), errorReg);
@@ -204,14 +203,14 @@ assert.deepStrictEqual(dns.getServers(), []);
 
 {
   /*
-  * Make sure that dns.lookup throws if hints does not represent a valid flag.
-  * (dns.V4MAPPED | dns.ADDRCONFIG) + 1 is invalid because:
-  * - it's different from dns.V4MAPPED and dns.ADDRCONFIG.
-  * - it's different from them bitwise ored.
-  * - it's different from 0.
-  * - it's an odd number different than 1, and thus is invalid, because
-  * flags are either === 1 or even.
-  */
+   * Make sure that dns.lookup throws if hints does not represent a valid flag.
+   * (dns.V4MAPPED | dns.ADDRCONFIG) + 1 is invalid because:
+   * - it's different from dns.V4MAPPED and dns.ADDRCONFIG.
+   * - it's different from them bitwise ored.
+   * - it's different from 0.
+   * - it's an odd number different than 1, and thus is invalid, because
+   * flags are either === 1 or even.
+   */
   const hints = (dns.V4MAPPED | dns.ADDRCONFIG) + 1;
   const err = {
     code: 'ERR_INVALID_OPT_VALUE',
@@ -239,16 +238,24 @@ common.expectsError(() => dns.lookup('nodejs.org', 4), {
 
 dns.lookup('', { family: 4, hints: 0 }, common.mustCall());
 
-dns.lookup('', {
-  family: 6,
-  hints: dns.ADDRCONFIG
-}, common.mustCall());
+dns.lookup(
+  '',
+  {
+    family: 6,
+    hints: dns.ADDRCONFIG
+  },
+  common.mustCall()
+);
 
 dns.lookup('', { hints: dns.V4MAPPED }, common.mustCall());
 
-dns.lookup('', {
-  hints: dns.ADDRCONFIG | dns.V4MAPPED
-}, common.mustCall());
+dns.lookup(
+  '',
+  {
+    hints: dns.ADDRCONFIG | dns.V4MAPPED
+  },
+  common.mustCall()
+);
 
 (async function() {
   await dnsPromises.lookup('', { family: 4, hints: 0 });
@@ -261,8 +268,8 @@ dns.lookup('', {
   const err = {
     code: 'ERR_MISSING_ARGS',
     type: TypeError,
-    message: 'The "hostname", "port", and "callback" arguments must be ' +
-    'specified'
+    message:
+      'The "hostname", "port", and "callback" arguments must be ' + 'specified'
   };
 
   common.expectsError(() => dns.lookupService('0.0.0.0'), err);
@@ -290,8 +297,7 @@ dns.lookup('', {
 const portErr = (port) => {
   const err = {
     code: 'ERR_SOCKET_BAD_PORT',
-    message:
-      `Port should be >= 0 and < 65536. Received ${port}.`,
+    message: `Port should be >= 0 and < 65536. Received ${port}.`,
     type: RangeError
   };
 
@@ -308,9 +314,12 @@ portErr(undefined);
 portErr(65538);
 portErr('test');
 
-common.expectsError(() => {
-  dns.lookupService('0.0.0.0', 80, null);
-}, {
-  code: 'ERR_INVALID_CALLBACK',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    dns.lookupService('0.0.0.0', 80, null);
+  },
+  {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError
+  }
+);
diff --git a/test/parallel/test-domain-abort-on-uncaught.js b/test/parallel/test-domain-abort-on-uncaught.js
index e74fb436bf18e0..ac73ca139cd4c5 100644
--- a/test/parallel/test-domain-abort-on-uncaught.js
+++ b/test/parallel/test-domain-abort-on-uncaught.js
@@ -95,7 +95,10 @@ const tests = [
         conn.pipe(conn);
       });
       server.listen(0, common.localhostIPv4, function() {
-        const conn = net.connect(this.address().port, common.localhostIPv4);
+        const conn = net.connect(
+          this.address().port,
+          common.localhostIPv4
+        );
         conn.once('data', function() {
           throw new Error('ok');
         });
@@ -198,9 +201,7 @@ if (process.argv[2] === 'child') {
   const testIndex = +process.argv[3];
 
   tests[testIndex]();
-
 } else {
-
   tests.forEach(function(test, testIndex) {
     let testCmd = '';
     if (!common.isWindows) {
@@ -209,8 +210,9 @@ if (process.argv[2] === 'child') {
       testCmd += 'ulimit -c 0 && ';
     }
 
-    testCmd += `"${process.argv[0]}" --abort-on-uncaught-exception ` +
-               `"${process.argv[1]}" child ${testIndex}`;
+    testCmd +=
+      `"${process.argv[0]}" --abort-on-uncaught-exception ` +
+      `"${process.argv[1]}" child ${testIndex}`;
 
     try {
       child_process.execSync(testCmd);
diff --git a/test/parallel/test-domain-bind-timeout.js b/test/parallel/test-domain-bind-timeout.js
index f04f85bc58b22d..cb3a4454a6c56f 100644
--- a/test/parallel/test-domain-bind-timeout.js
+++ b/test/parallel/test-domain-bind-timeout.js
@@ -6,12 +6,20 @@ const domain = require('domain');
 
 const d = new domain.Domain();
 
-d.on('error', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'foobar');
-  assert.strictEqual(err.domain, d);
-  assert.strictEqual(err.domainEmitter, undefined);
-  assert.strictEqual(err.domainBound, undefined);
-  assert.strictEqual(err.domainThrown, true);
-}));
+d.on(
+  'error',
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foobar');
+    assert.strictEqual(err.domain, d);
+    assert.strictEqual(err.domainEmitter, undefined);
+    assert.strictEqual(err.domainBound, undefined);
+    assert.strictEqual(err.domainThrown, true);
+  })
+);
 
-setTimeout(d.bind(() => { throw new Error('foobar'); }), 1);
+setTimeout(
+  d.bind(() => {
+    throw new Error('foobar');
+  }),
+  1
+);
diff --git a/test/parallel/test-domain-crypto.js b/test/parallel/test-domain-crypto.js
index 26ee6b888efb2d..b9a2e559f60e32 100644
--- a/test/parallel/test-domain-crypto.js
+++ b/test/parallel/test-domain-crypto.js
@@ -23,8 +23,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('node compiled without OpenSSL.');
+if (!common.hasCrypto) common.skip('node compiled without OpenSSL.');
 
 const crypto = require('crypto');
 
diff --git a/test/parallel/test-domain-ee-error-listener.js b/test/parallel/test-domain-ee-error-listener.js
index 69041c7523b142..c2b034e7718cb3 100644
--- a/test/parallel/test-domain-ee-error-listener.js
+++ b/test/parallel/test-domain-ee-error-listener.js
@@ -10,9 +10,12 @@ domain.on('error', common.mustNotCall());
 const ee = new EventEmitter();
 
 const plainObject = { justAn: 'object' };
-ee.once('error', common.mustCall((err) => {
-  assert.deepStrictEqual(err, plainObject);
-}));
+ee.once(
+  'error',
+  common.mustCall((err) => {
+    assert.deepStrictEqual(err, plainObject);
+  })
+);
 ee.emit('error', plainObject);
 
 const err = new Error('test error');
diff --git a/test/parallel/test-domain-ee-implicit.js b/test/parallel/test-domain-ee-implicit.js
index 7634dd0bff86f1..416a184e8180d4 100644
--- a/test/parallel/test-domain-ee-implicit.js
+++ b/test/parallel/test-domain-ee-implicit.js
@@ -8,21 +8,29 @@ const EventEmitter = require('events');
 const d = new domain.Domain();
 let implicit;
 
-d.on('error', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'foobar');
-  assert.strictEqual(err.domain, d);
-  assert.strictEqual(err.domainEmitter, implicit);
-  assert.strictEqual(err.domainBound, undefined);
-  assert.strictEqual(err.domainThrown, false);
-}));
+d.on(
+  'error',
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foobar');
+    assert.strictEqual(err.domain, d);
+    assert.strictEqual(err.domainEmitter, implicit);
+    assert.strictEqual(err.domainBound, undefined);
+    assert.strictEqual(err.domainThrown, false);
+  })
+);
 
 // Implicit addition of the EventEmitter by being created within a domain-bound
 // context.
-d.run(common.mustCall(() => {
-  implicit = new EventEmitter();
-}));
+d.run(
+  common.mustCall(() => {
+    implicit = new EventEmitter();
+  })
+);
 
-setTimeout(common.mustCall(() => {
-  // escape from the domain, but implicit is still bound to it.
-  implicit.emit('error', new Error('foobar'));
-}), 1);
+setTimeout(
+  common.mustCall(() => {
+    // escape from the domain, but implicit is still bound to it.
+    implicit.emit('error', new Error('foobar'));
+  }),
+  1
+);
diff --git a/test/parallel/test-domain-ee.js b/test/parallel/test-domain-ee.js
index bc53f78445d7ac..fe0f944ec2fcea 100644
--- a/test/parallel/test-domain-ee.js
+++ b/test/parallel/test-domain-ee.js
@@ -8,13 +8,16 @@ const EventEmitter = require('events');
 const d = new domain.Domain();
 const e = new EventEmitter();
 
-d.on('error', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'foobar');
-  assert.strictEqual(err.domain, d);
-  assert.strictEqual(err.domainEmitter, e);
-  assert.strictEqual(err.domainBound, undefined);
-  assert.strictEqual(err.domainThrown, false);
-}));
+d.on(
+  'error',
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foobar');
+    assert.strictEqual(err.domain, d);
+    assert.strictEqual(err.domainEmitter, e);
+    assert.strictEqual(err.domainBound, undefined);
+    assert.strictEqual(err.domainThrown, false);
+  })
+);
 
 d.add(e);
 e.emit('error', new Error('foobar'));
diff --git a/test/parallel/test-domain-enter-exit.js b/test/parallel/test-domain-enter-exit.js
index e9458409ffae0a..a745376be738f7 100644
--- a/test/parallel/test-domain-enter-exit.js
+++ b/test/parallel/test-domain-enter-exit.js
@@ -27,9 +27,11 @@ const assert = require('assert');
 const domain = require('domain');
 
 function names(array) {
-  return array.map(function(d) {
-    return d.name;
-  }).join(', ');
+  return array
+    .map(function(d) {
+      return d.name;
+    })
+    .join(', ');
 }
 
 const a = domain.create();
@@ -40,21 +42,36 @@ const c = domain.create();
 c.name = 'c';
 
 a.enter(); // push
-assert.deepStrictEqual(domain._stack, [a],
-                       `a not pushed: ${names(domain._stack)}`);
+assert.deepStrictEqual(
+  domain._stack,
+  [a],
+  `a not pushed: ${names(domain._stack)}`
+);
 
 b.enter(); // push
-assert.deepStrictEqual(domain._stack, [a, b],
-                       `b not pushed: ${names(domain._stack)}`);
+assert.deepStrictEqual(
+  domain._stack,
+  [a, b],
+  `b not pushed: ${names(domain._stack)}`
+);
 
 c.enter(); // push
-assert.deepStrictEqual(domain._stack, [a, b, c],
-                       `c not pushed: ${names(domain._stack)}`);
+assert.deepStrictEqual(
+  domain._stack,
+  [a, b, c],
+  `c not pushed: ${names(domain._stack)}`
+);
 
 b.exit(); // pop
-assert.deepStrictEqual(domain._stack, [a],
-                       `b and c not popped: ${names(domain._stack)}`);
+assert.deepStrictEqual(
+  domain._stack,
+  [a],
+  `b and c not popped: ${names(domain._stack)}`
+);
 
 b.enter(); // push
-assert.deepStrictEqual(domain._stack, [a, b],
-                       `b not pushed: ${names(domain._stack)}`);
+assert.deepStrictEqual(
+  domain._stack,
+  [a, b],
+  `b not pushed: ${names(domain._stack)}`
+);
diff --git a/test/parallel/test-domain-error-types.js b/test/parallel/test-domain-error-types.js
index 6569c6de4bf1e1..5b1f06d1a0feb5 100644
--- a/test/parallel/test-domain-error-types.js
+++ b/test/parallel/test-domain-error-types.js
@@ -8,16 +8,29 @@ const domain = require('domain');
 // for each errors.
 
 for (const something of [
-  42, null, undefined, false, () => {}, 'string', Symbol('foo')
+  42,
+  null,
+  undefined,
+  false,
+  () => {},
+  'string',
+  Symbol('foo')
 ]) {
   const d = new domain.Domain();
-  d.run(common.mustCall(() => {
-    process.nextTick(common.mustCall(() => {
-      throw something;
-    }));
-  }));
+  d.run(
+    common.mustCall(() => {
+      process.nextTick(
+        common.mustCall(() => {
+          throw something;
+        })
+      );
+    })
+  );
 
-  d.on('error', common.mustCall((err) => {
-    assert.strictEqual(something, err);
-  }));
+  d.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(something, err);
+    })
+  );
 }
diff --git a/test/parallel/test-domain-fs-enoent-stream.js b/test/parallel/test-domain-fs-enoent-stream.js
index 9d28f3a1db4f83..468a7f349067e1 100644
--- a/test/parallel/test-domain-fs-enoent-stream.js
+++ b/test/parallel/test-domain-fs-enoent-stream.js
@@ -9,12 +9,15 @@ const d = new domain.Domain();
 
 const fst = fs.createReadStream('stream for nonexistent file');
 
-d.on('error', common.mustCall((err) => {
-  assert.ok(err.message.match(/^ENOENT: no such file or directory, open '/));
-  assert.strictEqual(err.domain, d);
-  assert.strictEqual(err.domainEmitter, fst);
-  assert.strictEqual(err.domainBound, undefined);
-  assert.strictEqual(err.domainThrown, false);
-}));
+d.on(
+  'error',
+  common.mustCall((err) => {
+    assert.ok(err.message.match(/^ENOENT: no such file or directory, open '/));
+    assert.strictEqual(err.domain, d);
+    assert.strictEqual(err.domainEmitter, fst);
+    assert.strictEqual(err.domainBound, undefined);
+    assert.strictEqual(err.domainThrown, false);
+  })
+);
 
 d.add(fst);
diff --git a/test/parallel/test-domain-implicit-binding.js b/test/parallel/test-domain-implicit-binding.js
index 13c146e4d7b332..1fb07c277df180 100644
--- a/test/parallel/test-domain-implicit-binding.js
+++ b/test/parallel/test-domain-implicit-binding.js
@@ -8,24 +8,40 @@ const fs = require('fs');
 {
   const d = new domain.Domain();
 
-  d.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.message, 'foobar');
-    assert.strictEqual(err.domain, d);
-    assert.strictEqual(err.domainEmitter, undefined);
-    assert.strictEqual(err.domainBound, undefined);
-    assert.strictEqual(err.domainThrown, true);
-  }));
+  d.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.message, 'foobar');
+      assert.strictEqual(err.domain, d);
+      assert.strictEqual(err.domainEmitter, undefined);
+      assert.strictEqual(err.domainBound, undefined);
+      assert.strictEqual(err.domainThrown, true);
+    })
+  );
 
-  d.run(common.mustCall(() => {
-    process.nextTick(common.mustCall(() => {
-      const i = setInterval(common.mustCall(() => {
-        clearInterval(i);
-        setTimeout(common.mustCall(() => {
-          fs.stat('this file does not exist', common.mustCall((er, stat) => {
-            throw new Error('foobar');
-          }));
-        }), 1);
-      }), 1);
-    }));
-  }));
+  d.run(
+    common.mustCall(() => {
+      process.nextTick(
+        common.mustCall(() => {
+          const i = setInterval(
+            common.mustCall(() => {
+              clearInterval(i);
+              setTimeout(
+                common.mustCall(() => {
+                  fs.stat(
+                    'this file does not exist',
+                    common.mustCall((er, stat) => {
+                      throw new Error('foobar');
+                    })
+                  );
+                }),
+                1
+              );
+            }),
+            1
+          );
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-domain-implicit-fs.js b/test/parallel/test-domain-implicit-fs.js
index f3695989502a77..4ba2b13b5a0cf9 100644
--- a/test/parallel/test-domain-implicit-fs.js
+++ b/test/parallel/test-domain-implicit-fs.js
@@ -28,17 +28,19 @@ const domain = require('domain');
 
 const d = new domain.Domain();
 
-d.on('error', common.mustCall(function(er) {
-  console.error('caught', er);
-
-  assert.strictEqual(er.domain, d);
-  assert.strictEqual(er.domainThrown, true);
-  assert.ok(!er.domainEmitter);
-  assert.strictEqual(er.actual.code, 'ENOENT');
-  assert.ok(/\bthis file does not exist\b/i.test(er.actual.path));
-  assert.strictEqual(typeof er.actual.errno, 'number');
-}));
+d.on(
+  'error',
+  common.mustCall(function(er) {
+    console.error('caught', er);
 
+    assert.strictEqual(er.domain, d);
+    assert.strictEqual(er.domainThrown, true);
+    assert.ok(!er.domainEmitter);
+    assert.strictEqual(er.actual.code, 'ENOENT');
+    assert.ok(/\bthis file does not exist\b/i.test(er.actual.path));
+    assert.strictEqual(typeof er.actual.errno, 'number');
+  })
+);
 
 // implicit handling of thrown errors while in a domain, via the
 // single entry points of ReqWrap and MakeCallback.  Even if
diff --git a/test/parallel/test-domain-intercept.js b/test/parallel/test-domain-intercept.js
index 41de22af202973..7f4c0ce73ee774 100644
--- a/test/parallel/test-domain-intercept.js
+++ b/test/parallel/test-domain-intercept.js
@@ -9,13 +9,16 @@ const domain = require('domain');
 
   const mustNotCall = common.mustNotCall();
 
-  d.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.message, 'foobar');
-    assert.strictEqual(err.domain, d);
-    assert.strictEqual(err.domainEmitter, undefined);
-    assert.strictEqual(err.domainBound, mustNotCall);
-    assert.strictEqual(err.domainThrown, false);
-  }));
+  d.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.message, 'foobar');
+      assert.strictEqual(err.domain, d);
+      assert.strictEqual(err.domainEmitter, undefined);
+      assert.strictEqual(err.domainBound, mustNotCall);
+      assert.strictEqual(err.domainThrown, false);
+    })
+  );
 
   const bound = d.intercept(mustNotCall);
   bound(new Error('foobar'));
@@ -24,9 +27,11 @@ const domain = require('domain');
 {
   const d = new domain.Domain();
 
-  const bound = d.intercept(common.mustCall((data) => {
-    assert.strictEqual(data, 'data');
-  }));
+  const bound = d.intercept(
+    common.mustCall((data) => {
+      assert.strictEqual(data, 'data');
+    })
+  );
 
   bound(null, 'data');
 }
@@ -34,10 +39,12 @@ const domain = require('domain');
 {
   const d = new domain.Domain();
 
-  const bound = d.intercept(common.mustCall((data, data2) => {
-    assert.strictEqual(data, 'data');
-    assert.strictEqual(data2, 'data2');
-  }));
+  const bound = d.intercept(
+    common.mustCall((data, data2) => {
+      assert.strictEqual(data, 'data');
+      assert.strictEqual(data2, 'data2');
+    })
+  );
 
   bound(null, 'data', 'data2');
 }
diff --git a/test/parallel/test-domain-load-after-set-uncaught-exception-capture.js b/test/parallel/test-domain-load-after-set-uncaught-exception-capture.js
index 697d4d30806ee7..823f0cd856f190 100644
--- a/test/parallel/test-domain-load-after-set-uncaught-exception-capture.js
+++ b/test/parallel/test-domain-load-after-set-uncaught-exception-capture.js
@@ -3,14 +3,11 @@ const common = require('../common');
 
 process.setUncaughtExceptionCaptureCallback(common.mustNotCall());
 
-common.expectsError(
-  () => require('domain'),
-  {
-    code: 'ERR_DOMAIN_CALLBACK_NOT_AVAILABLE',
-    type: Error,
-    message: /^A callback was registered.*with using the `domain` module/
-  }
-);
+common.expectsError(() => require('domain'), {
+  code: 'ERR_DOMAIN_CALLBACK_NOT_AVAILABLE',
+  type: Error,
+  message: /^A callback was registered.*with using the `domain` module/
+});
 
 process.setUncaughtExceptionCaptureCallback(null);
 require('domain'); // Should not throw.
diff --git a/test/parallel/test-domain-multi.js b/test/parallel/test-domain-multi.js
index 016e9cd12805ed..3bed62ce3d8bc6 100644
--- a/test/parallel/test-domain-multi.js
+++ b/test/parallel/test-domain-multi.js
@@ -31,45 +31,52 @@ a.enter(); // this will be our "root" domain
 
 a.on('error', common.mustNotCall());
 
-const server = http.createServer((req, res) => {
-  // child domain of a.
-  const b = domain.create();
-  a.add(b);
+const server = http
+  .createServer((req, res) => {
+    // child domain of a.
+    const b = domain.create();
+    a.add(b);
 
-  // treat these EE objects as if they are a part of the b domain
-  // so, an 'error' event on them propagates to the domain, rather
-  // than being thrown.
-  b.add(req);
-  b.add(res);
+    // treat these EE objects as if they are a part of the b domain
+    // so, an 'error' event on them propagates to the domain, rather
+    // than being thrown.
+    b.add(req);
+    b.add(res);
 
-  b.on('error', common.mustCall((er) => {
-    if (res) {
-      res.writeHead(500);
-      res.end('An error occurred');
-    }
-    // res.writeHead(500), res.destroy, etc.
-    server.close();
-  }));
+    b.on(
+      'error',
+      common.mustCall((er) => {
+        if (res) {
+          res.writeHead(500);
+          res.end('An error occurred');
+        }
+        // res.writeHead(500), res.destroy, etc.
+        server.close();
+      })
+    );
 
-  // XXX this bind should not be necessary.
-  // the write cb behavior in http/net should use an
-  // event so that it picks up the domain handling.
-  res.write('HELLO\n', b.bind(() => {
-    throw new Error('this kills domain B, not A');
-  }));
+    // XXX this bind should not be necessary.
+    // the write cb behavior in http/net should use an
+    // event so that it picks up the domain handling.
+    res.write(
+      'HELLO\n',
+      b.bind(() => {
+        throw new Error('this kills domain B, not A');
+      })
+    );
+  })
+  .listen(0, () => {
+    const c = domain.create();
+    const req = http.get({ host: 'localhost', port: server.address().port });
 
-}).listen(0, () => {
-  const c = domain.create();
-  const req = http.get({ host: 'localhost', port: server.address().port });
+    // add the request to the C domain
+    c.add(req);
 
-  // add the request to the C domain
-  c.add(req);
+    req.on('response', (res) => {
+      // add the response object to the C domain
+      c.add(res);
+      res.pipe(process.stdout);
+    });
 
-  req.on('response', (res) => {
-    // add the response object to the C domain
-    c.add(res);
-    res.pipe(process.stdout);
+    c.on('error', common.mustCall((er) => {}));
   });
-
-  c.on('error', common.mustCall((er) => { }));
-});
diff --git a/test/parallel/test-domain-multiple-errors.js b/test/parallel/test-domain-multiple-errors.js
index 5b031eb1b44bc4..2df00da24ddfd2 100644
--- a/test/parallel/test-domain-multiple-errors.js
+++ b/test/parallel/test-domain-multiple-errors.js
@@ -9,18 +9,23 @@ const domain = require('domain');
 
 const d = new domain.Domain();
 
-const values = [
-  42, null, undefined, false, () => {}, 'string', Symbol('foo')
-];
+const values = [42, null, undefined, false, () => {}, 'string', Symbol('foo')];
 
-d.on('error', common.mustCall((err) => {
-  assert(values.includes(err));
-}, values.length));
+d.on(
+  'error',
+  common.mustCall((err) => {
+    assert(values.includes(err));
+  }, values.length)
+);
 
 for (const something of values) {
-  d.run(common.mustCall(() => {
-    process.nextTick(common.mustCall(() => {
-      throw something;
-    }));
-  }));
+  d.run(
+    common.mustCall(() => {
+      process.nextTick(
+        common.mustCall(() => {
+          throw something;
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-domain-nested.js b/test/parallel/test-domain-nested.js
index a7483f6dfce7b6..f44f88809dc481 100644
--- a/test/parallel/test-domain-nested.js
+++ b/test/parallel/test-domain-nested.js
@@ -33,11 +33,14 @@ process.on('exit', function(c) {
 domain.create().run(function() {
   domain.create().run(function() {
     domain.create().run(function() {
-      domain.create().on('error', function(e) {
-        // Don't need to do anything here
-      }).run(function() {
-        throw new Error('died');
-      });
+      domain
+        .create()
+        .on('error', function(e) {
+          // Don't need to do anything here
+        })
+        .run(function() {
+          throw new Error('died');
+        });
     });
   });
 });
diff --git a/test/parallel/test-domain-nexttick.js b/test/parallel/test-domain-nexttick.js
index 76cefd519d0bd3..25fd3aa9790a39 100644
--- a/test/parallel/test-domain-nexttick.js
+++ b/test/parallel/test-domain-nexttick.js
@@ -6,16 +6,23 @@ const domain = require('domain');
 
 const d = new domain.Domain();
 
-d.on('error', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'foobar');
-  assert.strictEqual(err.domain, d);
-  assert.strictEqual(err.domainEmitter, undefined);
-  assert.strictEqual(err.domainBound, undefined);
-  assert.strictEqual(err.domainThrown, true);
-}));
+d.on(
+  'error',
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foobar');
+    assert.strictEqual(err.domain, d);
+    assert.strictEqual(err.domainEmitter, undefined);
+    assert.strictEqual(err.domainBound, undefined);
+    assert.strictEqual(err.domainThrown, true);
+  })
+);
 
-d.run(common.mustCall(() => {
-  process.nextTick(common.mustCall(() => {
-    throw new Error('foobar');
-  }));
-}));
+d.run(
+  common.mustCall(() => {
+    process.nextTick(
+      common.mustCall(() => {
+        throw new Error('foobar');
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-domain-no-error-handler-abort-on-uncaught-6.js b/test/parallel/test-domain-no-error-handler-abort-on-uncaught-6.js
index c3a91379319db5..bcb17baf90b2eb 100644
--- a/test/parallel/test-domain-no-error-handler-abort-on-uncaught-6.js
+++ b/test/parallel/test-domain-no-error-handler-abort-on-uncaught-6.js
@@ -7,8 +7,7 @@ function test() {
   const d = domain.create();
   const d2 = domain.create();
 
-  d.on('error', function errorHandler() {
-  });
+  d.on('error', function errorHandler() {});
 
   d.run(function() {
     d2.run(function() {
diff --git a/test/parallel/test-domain-no-error-handler-abort-on-uncaught-7.js b/test/parallel/test-domain-no-error-handler-abort-on-uncaught-7.js
index 9debc754cea3d1..937c3414761b3a 100644
--- a/test/parallel/test-domain-no-error-handler-abort-on-uncaught-7.js
+++ b/test/parallel/test-domain-no-error-handler-abort-on-uncaught-7.js
@@ -7,8 +7,7 @@ function test() {
   const d = domain.create();
   const d2 = domain.create();
 
-  d.on('error', function errorHandler() {
-  });
+  d.on('error', function errorHandler() {});
 
   d.run(function() {
     d2.run(function() {
diff --git a/test/parallel/test-domain-no-error-handler-abort-on-uncaught-8.js b/test/parallel/test-domain-no-error-handler-abort-on-uncaught-8.js
index f1670cbd300bdf..bb316f702e136d 100644
--- a/test/parallel/test-domain-no-error-handler-abort-on-uncaught-8.js
+++ b/test/parallel/test-domain-no-error-handler-abort-on-uncaught-8.js
@@ -7,8 +7,7 @@ function test() {
   const d = domain.create();
   const d2 = domain.create();
 
-  d.on('error', function errorHandler() {
-  });
+  d.on('error', function errorHandler() {});
 
   d.run(function() {
     d2.run(function() {
diff --git a/test/parallel/test-domain-no-error-handler-abort-on-uncaught-9.js b/test/parallel/test-domain-no-error-handler-abort-on-uncaught-9.js
index ae30a1dea68b0b..763ea7fc9b6da4 100644
--- a/test/parallel/test-domain-no-error-handler-abort-on-uncaught-9.js
+++ b/test/parallel/test-domain-no-error-handler-abort-on-uncaught-9.js
@@ -7,8 +7,7 @@ function test() {
   const d = domain.create();
   const d2 = domain.create();
 
-  d.on('error', function errorHandler() {
-  });
+  d.on('error', function errorHandler() {});
 
   d.run(() => {
     d2.run(() => {
diff --git a/test/parallel/test-domain-promise.js b/test/parallel/test-domain-promise.js
index 704092522357fd..cede50388b686f 100644
--- a/test/parallel/test-domain-promise.js
+++ b/test/parallel/test-domain-promise.js
@@ -8,119 +8,177 @@ const vm = require('vm');
 {
   const d = domain.create();
 
-  d.run(common.mustCall(() => {
-    Promise.resolve().then(common.mustCall(() => {
-      assert.strictEqual(process.domain, d);
-    }));
-  }));
+  d.run(
+    common.mustCall(() => {
+      Promise.resolve().then(
+        common.mustCall(() => {
+          assert.strictEqual(process.domain, d);
+        })
+      );
+    })
+  );
 }
 
 {
   const d = domain.create();
 
-  d.run(common.mustCall(() => {
-    Promise.resolve().then(() => {}).then(() => {}).then(common.mustCall(() => {
-      assert.strictEqual(process.domain, d);
-    }));
-  }));
+  d.run(
+    common.mustCall(() => {
+      Promise.resolve()
+        .then(() => {})
+        .then(() => {})
+        .then(
+          common.mustCall(() => {
+            assert.strictEqual(process.domain, d);
+          })
+        );
+    })
+  );
 }
 
 {
   const d = domain.create();
 
-  d.run(common.mustCall(() => {
-    vm.runInNewContext(`
+  d.run(
+    common.mustCall(() => {
+      vm.runInNewContext(
+        `
       const promise = Promise.resolve();
       assert.strictEqual(promise.domain, undefined);
       promise.then(common.mustCall(() => {
         assert.strictEqual(process.domain, d);
       }));
-    `, { common, assert, process, d });
-  }));
+    `,
+        { common, assert, process, d }
+      );
+    })
+  );
 }
 
 {
   const d1 = domain.create();
   const d2 = domain.create();
   let p;
-  d1.run(common.mustCall(() => {
-    p = Promise.resolve(42);
-  }));
-
-  d2.run(common.mustCall(() => {
-    p.then(common.mustCall((v) => {
-      assert.strictEqual(process.domain, d2);
-    }));
-  }));
+  d1.run(
+    common.mustCall(() => {
+      p = Promise.resolve(42);
+    })
+  );
+
+  d2.run(
+    common.mustCall(() => {
+      p.then(
+        common.mustCall((v) => {
+          assert.strictEqual(process.domain, d2);
+        })
+      );
+    })
+  );
 }
 
 {
   const d1 = domain.create();
   const d2 = domain.create();
   let p;
-  d1.run(common.mustCall(() => {
-    p = Promise.resolve(42);
-  }));
-
-  d2.run(common.mustCall(() => {
-    p.then(d1.bind(common.mustCall((v) => {
-      assert.strictEqual(process.domain, d1);
-    })));
-  }));
+  d1.run(
+    common.mustCall(() => {
+      p = Promise.resolve(42);
+    })
+  );
+
+  d2.run(
+    common.mustCall(() => {
+      p.then(
+        d1.bind(
+          common.mustCall((v) => {
+            assert.strictEqual(process.domain, d1);
+          })
+        )
+      );
+    })
+  );
 }
 
 {
   const d1 = domain.create();
   const d2 = domain.create();
   let p;
-  d1.run(common.mustCall(() => {
-    p = Promise.resolve(42);
-  }));
-
-  d1.run(common.mustCall(() => {
-    d2.run(common.mustCall(() => {
-      p.then(common.mustCall((v) => {
-        assert.strictEqual(process.domain, d2);
-      }));
-    }));
-  }));
+  d1.run(
+    common.mustCall(() => {
+      p = Promise.resolve(42);
+    })
+  );
+
+  d1.run(
+    common.mustCall(() => {
+      d2.run(
+        common.mustCall(() => {
+          p.then(
+            common.mustCall((v) => {
+              assert.strictEqual(process.domain, d2);
+            })
+          );
+        })
+      );
+    })
+  );
 }
 
 {
   const d1 = domain.create();
   const d2 = domain.create();
   let p;
-  d1.run(common.mustCall(() => {
-    p = Promise.reject(new Error('foobar'));
-  }));
-
-  d2.run(common.mustCall(() => {
-    p.catch(common.mustCall((v) => {
-      assert.strictEqual(process.domain, d2);
-    }));
-  }));
+  d1.run(
+    common.mustCall(() => {
+      p = Promise.reject(new Error('foobar'));
+    })
+  );
+
+  d2.run(
+    common.mustCall(() => {
+      p.catch(
+        common.mustCall((v) => {
+          assert.strictEqual(process.domain, d2);
+        })
+      );
+    })
+  );
 }
 
 {
   const d = domain.create();
 
-  d.run(common.mustCall(() => {
-    Promise.resolve().then(common.mustCall(() => {
-      setTimeout(common.mustCall(() => {
-        assert.strictEqual(process.domain, d);
-      }), 0);
-    }));
-  }));
+  d.run(
+    common.mustCall(() => {
+      Promise.resolve().then(
+        common.mustCall(() => {
+          setTimeout(
+            common.mustCall(() => {
+              assert.strictEqual(process.domain, d);
+            }),
+            0
+          );
+        })
+      );
+    })
+  );
 }
 
 {
   const d = domain.create();
 
-  d.run(common.mustCall(() => {
-    Promise.resolve().then(common.mustCall(() => {
-      fs.readFile(__filename, common.mustCall(() => {
-        assert.strictEqual(process.domain, d);
-      }));
-    }));
-  }));
+  d.run(
+    common.mustCall(() => {
+      Promise.resolve().then(
+        common.mustCall(() => {
+          fs.readFile(
+            __filename,
+            common.mustCall(() => {
+              assert.strictEqual(process.domain, d);
+            })
+          );
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-domain-run.js b/test/parallel/test-domain-run.js
index 684d06204a2d9d..88a83c144d5f2c 100644
--- a/test/parallel/test-domain-run.js
+++ b/test/parallel/test-domain-run.js
@@ -6,8 +6,9 @@ const domain = require('domain');
 
 const d = new domain.Domain();
 
-assert.strictEqual(d.run(() => 'return value'),
-                   'return value');
+assert.strictEqual(d.run(() => 'return value'), 'return value');
 
-assert.strictEqual(d.run((a, b) => `${a} ${b}`, 'return', 'value'),
-                   'return value');
+assert.strictEqual(
+  d.run((a, b) => `${a} ${b}`, 'return', 'value'),
+  'return value'
+);
diff --git a/test/parallel/test-domain-safe-exit.js b/test/parallel/test-domain-safe-exit.js
index 3a111107869665..19dfb822c1b1cd 100644
--- a/test/parallel/test-domain-safe-exit.js
+++ b/test/parallel/test-domain-safe-exit.js
@@ -32,9 +32,15 @@ const b = domain.create();
 
 a.enter(); // push
 b.enter(); // push
-assert.deepStrictEqual(domain._stack, [a, b], 'Unexpected stack shape ' +
-                       `(domain._stack = ${util.inspect(domain._stack)})`);
+assert.deepStrictEqual(
+  domain._stack,
+  [a, b],
+  'Unexpected stack shape ' + `(domain._stack = ${util.inspect(domain._stack)})`
+);
 
 domain.create().exit(); // no-op
-assert.deepStrictEqual(domain._stack, [a, b], 'Unexpected stack shape ' +
-                       `(domain._stack = ${util.inspect(domain._stack)})`);
+assert.deepStrictEqual(
+  domain._stack,
+  [a, b],
+  'Unexpected stack shape ' + `(domain._stack = ${util.inspect(domain._stack)})`
+);
diff --git a/test/parallel/test-domain-set-uncaught-exception-capture-after-load.js b/test/parallel/test-domain-set-uncaught-exception-capture-after-load.js
index e7cbffd00758e2..8ab42e025cf572 100644
--- a/test/parallel/test-domain-set-uncaught-exception-capture-after-load.js
+++ b/test/parallel/test-domain-set-uncaught-exception-capture-after-load.js
@@ -9,20 +9,22 @@ const assert = require('assert');
 assert.throws(
   () => process.setUncaughtExceptionCaptureCallback(common.mustNotCall()),
   (err) => {
-    common.expectsError(
-      {
-        code: 'ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE',
-        type: Error,
-        message: /^The `domain` module is in use, which is mutually/
-      }
-    )(err);
+    common.expectsError({
+      code: 'ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE',
+      type: Error,
+      message: /^The `domain` module is in use, which is mutually/
+    })(err);
 
-    assert(err.stack.includes('-'.repeat(40)),
-           `expected ${err.stack} to contain dashes`);
+    assert(
+      err.stack.includes('-'.repeat(40)),
+      `expected ${err.stack} to contain dashes`
+    );
 
     const location = `at foobar (${__filename}:`;
-    assert(err.stack.includes(location),
-           `expected ${err.stack} to contain ${location}`);
+    assert(
+      err.stack.includes(location),
+      `expected ${err.stack} to contain ${location}`
+    );
     return true;
   }
 );
diff --git a/test/parallel/test-domain-stack-empty-in-process-uncaughtexception.js b/test/parallel/test-domain-stack-empty-in-process-uncaughtexception.js
index e9e8ab12d59d2c..0f1e56c9469907 100644
--- a/test/parallel/test-domain-stack-empty-in-process-uncaughtexception.js
+++ b/test/parallel/test-domain-stack-empty-in-process-uncaughtexception.js
@@ -6,19 +6,29 @@ const assert = require('assert');
 
 const d = domain.create();
 
-process.once('uncaughtException', common.mustCall(function onUncaught() {
-  assert.strictEqual(
-    process.domain, null,
-    'Domains stack should be empty in uncaughtException handler ' +
-    `but the value of process.domain is ${JSON.stringify(process.domain)}`);
-}));
+process.once(
+  'uncaughtException',
+  common.mustCall(function onUncaught() {
+    assert.strictEqual(
+      process.domain,
+      null,
+      'Domains stack should be empty in uncaughtException handler ' +
+        `but the value of process.domain is ${JSON.stringify(process.domain)}`
+    );
+  })
+);
 
-process.on('beforeExit', common.mustCall(function onBeforeExit() {
-  assert.strictEqual(
-    process.domain, null,
-    'Domains stack should be empty in beforeExit handler ' +
-    `but the value of process.domain is ${JSON.stringify(process.domain)}`);
-}));
+process.on(
+  'beforeExit',
+  common.mustCall(function onBeforeExit() {
+    assert.strictEqual(
+      process.domain,
+      null,
+      'Domains stack should be empty in beforeExit handler ' +
+        `but the value of process.domain is ${JSON.stringify(process.domain)}`
+    );
+  })
+);
 
 d.run(function() {
   throw new Error('boom');
diff --git a/test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js b/test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js
index a2afebd838f410..887f9fa9bfdd09 100644
--- a/test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js
+++ b/test/parallel/test-domain-throw-error-then-throw-from-uncaught-exception-handler.js
@@ -16,69 +16,90 @@ const domainErrMsg = 'boom from domain';
 const RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE = 42;
 
 if (process.argv[2] === 'child') {
-  process.on('uncaughtException', common.mustCall(function onUncaught() {
-    if (process.execArgv.includes('--abort-on-uncaught-exception')) {
-      // When passing --abort-on-uncaught-exception to the child process,
-      // we want to make sure that this handler (the process' uncaughtException
-      // event handler) wasn't called. Unfortunately we can't parse the child
-      // process' output to do that, since on Windows the standard error output
-      // is not properly flushed in V8's Isolate::Throw right before the
-      // process aborts due to an uncaught exception, and thus the error
-      // message representing the error that was thrown cannot be read by the
-      // parent process. So instead of parsing the child process' standard
-      // error, the parent process will check that in the case
-      // --abort-on-uncaught-exception was passed, the process did not exit
-      // with exit code RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE.
-      process.exit(RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE);
-    } else {
-      // On the other hand, when not passing --abort-on-uncaught-exception to
-      // the node process, we want to throw in this event handler to make sure
-      // that the proper error message, exit code and signal are the ones we
-      // expect.
-      throw new Error(uncaughtExceptionHandlerErrMsg);
-    }
-  }));
+  process.on(
+    'uncaughtException',
+    common.mustCall(function onUncaught() {
+      if (process.execArgv.includes('--abort-on-uncaught-exception')) {
+        // When passing --abort-on-uncaught-exception to the child process,
+        // we want to make sure that this handler (the process' uncaughtException
+        // event handler) wasn't called. Unfortunately we can't parse the child
+        // process' output to do that, since on Windows the standard error output
+        // is not properly flushed in V8's Isolate::Throw right before the
+        // process aborts due to an uncaught exception, and thus the error
+        // message representing the error that was thrown cannot be read by the
+        // parent process. So instead of parsing the child process' standard
+        // error, the parent process will check that in the case
+        // --abort-on-uncaught-exception was passed, the process did not exit
+        // with exit code RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE.
+        process.exit(RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE);
+      } else {
+        // On the other hand, when not passing --abort-on-uncaught-exception to
+        // the node process, we want to throw in this event handler to make sure
+        // that the proper error message, exit code and signal are the ones we
+        // expect.
+        throw new Error(uncaughtExceptionHandlerErrMsg);
+      }
+    })
+  );
 
   const d = domain.create();
-  d.run(common.mustCall(function() {
-    throw new Error(domainErrMsg);
-  }));
+  d.run(
+    common.mustCall(function() {
+      throw new Error(domainErrMsg);
+    })
+  );
 } else {
   runTestWithoutAbortOnUncaughtException();
   runTestWithAbortOnUncaughtException();
 }
 
 function runTestWithoutAbortOnUncaughtException() {
-  child_process.exec(
-    createTestCmdLine(),
-    function onTestDone(err, stdout, stderr) {
-      // When _not_ passing --abort-on-uncaught-exception, the process'
-      // uncaughtException handler _must_ be called, and thus the error
-      // message must include only the message of the error thrown from the
-      // process' uncaughtException handler.
-      assert(stderr.includes(uncaughtExceptionHandlerErrMsg),
-             'stderr output must include proper uncaughtException ' +
-             'handler\'s error\'s message');
-      assert(!stderr.includes(domainErrMsg),
-             'stderr output must not include domain\'s error\'s message');
+  child_process.exec(createTestCmdLine(), function onTestDone(
+    err,
+    stdout,
+    stderr
+  ) {
+    // When _not_ passing --abort-on-uncaught-exception, the process'
+    // uncaughtException handler _must_ be called, and thus the error
+    // message must include only the message of the error thrown from the
+    // process' uncaughtException handler.
+    assert(
+      stderr.includes(uncaughtExceptionHandlerErrMsg),
+      'stderr output must include proper uncaughtException ' +
+        "handler's error's message"
+    );
+    assert(
+      !stderr.includes(domainErrMsg),
+      "stderr output must not include domain's error's message"
+    );
 
-      assert.notStrictEqual(err.code, 0,
-                            'child process should have exited with a ' +
-                            'non-zero exit code, but did not');
-    }
-  );
+    assert.notStrictEqual(
+      err.code,
+      0,
+      'child process should have exited with a ' +
+        'non-zero exit code, but did not'
+    );
+  });
 }
 
 function runTestWithAbortOnUncaughtException() {
-  child_process.exec(createTestCmdLine({
-    withAbortOnUncaughtException: true
-  }), function onTestDone(err, stdout, stderr) {
-    assert.notStrictEqual(err.code, RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE,
-                          'child process should not have run its ' +
-                          'uncaughtException event handler');
-    assert(common.nodeProcessAborted(err.code, err.signal),
-           'process should have aborted, but did not');
-  });
+  child_process.exec(
+    createTestCmdLine({
+      withAbortOnUncaughtException: true
+    }),
+    function onTestDone(err, stdout, stderr) {
+      assert.notStrictEqual(
+        err.code,
+        RAN_UNCAUGHT_EXCEPTION_HANDLER_EXIT_CODE,
+        'child process should not have run its ' +
+          'uncaughtException event handler'
+      );
+      assert(
+        common.nodeProcessAborted(err.code, err.signal),
+        'process should have aborted, but did not'
+      );
+    }
+  );
 }
 
 function createTestCmdLine(options) {
diff --git a/test/parallel/test-domain-timer.js b/test/parallel/test-domain-timer.js
index 67910e3d5b1934..fd8e18782e36c1 100644
--- a/test/parallel/test-domain-timer.js
+++ b/test/parallel/test-domain-timer.js
@@ -6,16 +6,24 @@ const domain = require('domain');
 
 const d = new domain.Domain();
 
-d.on('error', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'foobar');
-  assert.strictEqual(err.domain, d);
-  assert.strictEqual(err.domainEmitter, undefined);
-  assert.strictEqual(err.domainBound, undefined);
-  assert.strictEqual(err.domainThrown, true);
-}));
+d.on(
+  'error',
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foobar');
+    assert.strictEqual(err.domain, d);
+    assert.strictEqual(err.domainEmitter, undefined);
+    assert.strictEqual(err.domainBound, undefined);
+    assert.strictEqual(err.domainThrown, true);
+  })
+);
 
-d.run(common.mustCall(() => {
-  setTimeout(common.mustCall(() => {
-    throw new Error('foobar');
-  }), 1);
-}));
+d.run(
+  common.mustCall(() => {
+    setTimeout(
+      common.mustCall(() => {
+        throw new Error('foobar');
+      }),
+      1
+    );
+  })
+);
diff --git a/test/parallel/test-domain-timers-uncaught-exception.js b/test/parallel/test-domain-timers-uncaught-exception.js
index d564d853ac935f..d9e43a064f5b9f 100644
--- a/test/parallel/test-domain-timers-uncaught-exception.js
+++ b/test/parallel/test-domain-timers-uncaught-exception.js
@@ -10,16 +10,25 @@ const assert = require('assert');
 let first = false;
 
 domain.run(function() {
-  setTimeout(() => { throw new Error('FAIL'); }, 1);
-  setTimeout(() => { first = true; }, 1);
-  setTimeout(() => { assert.strictEqual(first, true); }, 2);
+  setTimeout(() => {
+    throw new Error('FAIL');
+  }, 1);
+  setTimeout(() => {
+    first = true;
+  }, 1);
+  setTimeout(() => {
+    assert.strictEqual(first, true);
+  }, 2);
 
   // Ensure that 2 ms have really passed
   let i = 1e6;
   while (i--);
 });
 
-domain.once('error', common.mustCall((err) => {
-  assert(err);
-  assert.strictEqual(err.message, 'FAIL');
-}));
+domain.once(
+  'error',
+  common.mustCall((err) => {
+    assert(err);
+    assert.strictEqual(err.message, 'FAIL');
+  })
+);
diff --git a/test/parallel/test-domain-timers.js b/test/parallel/test-domain-timers.js
index 83d535938964be..ce0c93c4ff55db 100644
--- a/test/parallel/test-domain-timers.js
+++ b/test/parallel/test-domain-timers.js
@@ -26,9 +26,12 @@ const assert = require('assert');
 
 const timeoutd = domain.create();
 
-timeoutd.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.message, 'Timeout UNREFd');
-}, 2));
+timeoutd.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.message, 'Timeout UNREFd');
+  }, 2)
+);
 
 let t;
 timeoutd.run(function() {
@@ -45,9 +48,12 @@ t.unref();
 
 const immediated = domain.create();
 
-immediated.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.message, 'Immediate Error');
-}));
+immediated.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.message, 'Immediate Error');
+  })
+);
 
 immediated.run(function() {
   setImmediate(function() {
diff --git a/test/parallel/test-domain-top-level-error-handler-clears-stack.js b/test/parallel/test-domain-top-level-error-handler-clears-stack.js
index 05d5fca4671826..c45b1c69e623db 100644
--- a/test/parallel/test-domain-top-level-error-handler-clears-stack.js
+++ b/test/parallel/test-domain-top-level-error-handler-clears-stack.js
@@ -9,25 +9,30 @@ const domain = require('domain');
  */
 const d = domain.create();
 
-d.on('error', common.mustCall(() => {
-  process.nextTick(() => {
-    // Scheduling a callback with process.nextTick will enter a _new_ domain,
-    // and the callback will be called after the domain that handled the error
-    // was exited. So there should be only one domain on the domains stack if
-    // the domains stack was cleared properly when the domain error handler
-    // returned.
-    if (domain._stack.length !== 1) {
-      // Do not use assert to perform this test: this callback runs in a
-      // different callstack as the original process._fatalException that
-      // handled the original error, thus throwing here would trigger another
-      // call to process._fatalException, and so on recursively and
-      // indefinitely.
-      console.error('domains stack length should be 1, but instead is:',
-                    domain._stack.length);
-      process.exit(1);
-    }
-  });
-}));
+d.on(
+  'error',
+  common.mustCall(() => {
+    process.nextTick(() => {
+      // Scheduling a callback with process.nextTick will enter a _new_ domain,
+      // and the callback will be called after the domain that handled the error
+      // was exited. So there should be only one domain on the domains stack if
+      // the domains stack was cleared properly when the domain error handler
+      // returned.
+      if (domain._stack.length !== 1) {
+        // Do not use assert to perform this test: this callback runs in a
+        // different callstack as the original process._fatalException that
+        // handled the original error, thus throwing here would trigger another
+        // call to process._fatalException, and so on recursively and
+        // indefinitely.
+        console.error(
+          'domains stack length should be 1, but instead is:',
+          domain._stack.length
+        );
+        process.exit(1);
+      }
+    });
+  })
+);
 
 d.run(() => {
   throw new Error('Error from domain');
diff --git a/test/parallel/test-domain-uncaught-exception.js b/test/parallel/test-domain-uncaught-exception.js
index 0d6465fbf3f42f..ecdcbfa2b17c97 100644
--- a/test/parallel/test-domain-uncaught-exception.js
+++ b/test/parallel/test-domain-uncaught-exception.js
@@ -172,31 +172,39 @@ if (process.argv[2] === 'child') {
     const testProcess = child_process.fork(__filename, ['child', testIndex]);
 
     testProcess.on('message', function onMsg(msg) {
-      if (test.messagesReceived === undefined)
-        test.messagesReceived = [];
+      if (test.messagesReceived === undefined) test.messagesReceived = [];
 
       test.messagesReceived.push(msg);
     });
 
-    testProcess.on('disconnect', common.mustCall(function onExit() {
-      // Make sure that all expected messages were sent from the
-      // child process
-      test.expectedMessages.forEach(function(expectedMessage) {
-        const msgs = test.messagesReceived;
-        if (msgs === undefined || !msgs.includes(expectedMessage)) {
-          assert.fail(`test ${test.fn.name} should have sent message: ${
-            expectedMessage} but didn't`);
-        }
-      });
-
-      if (test.messagesReceived) {
-        test.messagesReceived.forEach(function(receivedMessage) {
-          if (!test.expectedMessages.includes(receivedMessage)) {
-            assert.fail(`test ${test.fn.name} should not have sent message: ${
-              receivedMessage} but did`);
+    testProcess.on(
+      'disconnect',
+      common.mustCall(function onExit() {
+        // Make sure that all expected messages were sent from the
+        // child process
+        test.expectedMessages.forEach(function(expectedMessage) {
+          const msgs = test.messagesReceived;
+          if (msgs === undefined || !msgs.includes(expectedMessage)) {
+            assert.fail(
+              `test ${
+                test.fn.name
+              } should have sent message: ${expectedMessage} but didn't`
+            );
           }
         });
-      }
-    }));
+
+        if (test.messagesReceived) {
+          test.messagesReceived.forEach(function(receivedMessage) {
+            if (!test.expectedMessages.includes(receivedMessage)) {
+              assert.fail(
+                `test ${
+                  test.fn.name
+                } should not have sent message: ${receivedMessage} but did`
+              );
+            }
+          });
+        }
+      })
+    );
   });
 }
diff --git a/test/parallel/test-domain-with-abort-on-uncaught-exception.js b/test/parallel/test-domain-with-abort-on-uncaught-exception.js
index 0707f123b8c3a1..0b292ab550f1fe 100644
--- a/test/parallel/test-domain-with-abort-on-uncaught-exception.js
+++ b/test/parallel/test-domain-with-abort-on-uncaught-exception.js
@@ -50,8 +50,7 @@ if (process.argv[2] === 'child') {
       if (process.argv.includes('useTryCatch')) {
         try {
           throw new Error(domainErrHandlerExMessage);
-        } catch {
-        }
+        } catch {}
       } else {
         throw new Error(domainErrHandlerExMessage);
       }
@@ -100,11 +99,11 @@ if (process.argv[2] === 'child') {
     }
 
     let useTryCatchOpt;
-    if (options.useTryCatch)
-      useTryCatchOpt = 'useTryCatch';
+    if (options.useTryCatch) useTryCatchOpt = 'useTryCatch';
 
     cmdToExec += `"${process.argv[0]}" ${cmdLineOption ? cmdLineOption : ''} "${
-      process.argv[1]}" child ${throwInDomainErrHandlerOpt} ${useTryCatchOpt}`;
+      process.argv[1]
+    }" child ${throwInDomainErrHandlerOpt} ${useTryCatchOpt}`;
 
     const child = exec(cmdToExec);
 
@@ -114,8 +113,10 @@ if (process.argv[2] === 'child') {
         // outside of a try/catch block, the process should not exit gracefully
         if (!options.useTryCatch && options.throwInDomainErrHandler) {
           if (cmdLineOption === '--abort_on_uncaught_exception') {
-            assert(common.nodeProcessAborted(exitCode, signal),
-                   'process should have aborted, but did not');
+            assert(
+              common.nodeProcessAborted(exitCode, signal),
+              'process should have aborted, but did not'
+            );
           } else {
             // By default, uncaught exceptions make node exit with an exit
             // code of 7.
diff --git a/test/parallel/test-dsa-fips-invalid-key.js b/test/parallel/test-dsa-fips-invalid-key.js
index 05cc1d143aca6e..b9074e7ad3b8bc 100644
--- a/test/parallel/test-dsa-fips-invalid-key.js
+++ b/test/parallel/test-dsa-fips-invalid-key.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasFipsCrypto)
-  common.skip('node compiled without FIPS OpenSSL.');
+if (!common.hasFipsCrypto) common.skip('node compiled without FIPS OpenSSL.');
 
 const assert = require('assert');
 const crypto = require('crypto');
diff --git a/test/parallel/test-emit-after-uncaught-exception-runInAsyncScope.js b/test/parallel/test-emit-after-uncaught-exception-runInAsyncScope.js
index 5003972e9984aa..3ddca898bc5e96 100644
--- a/test/parallel/test-emit-after-uncaught-exception-runInAsyncScope.js
+++ b/test/parallel/test-emit-after-uncaught-exception-runInAsyncScope.js
@@ -7,34 +7,47 @@ const async_hooks = require('async_hooks');
 const id_obj = {};
 let collect = true;
 
-const hook = async_hooks.createHook({
-  before(id) { if (collect) id_obj[id] = true; },
-  after(id) { delete id_obj[id]; },
-}).enable();
+const hook = async_hooks
+  .createHook({
+    before(id) {
+      if (collect) id_obj[id] = true;
+    },
+    after(id) {
+      delete id_obj[id];
+    }
+  })
+  .enable();
 
-process.once('uncaughtException', common.mustCall((er) => {
-  assert.strictEqual(er.message, 'bye');
-  collect = false;
-}));
+process.once(
+  'uncaughtException',
+  common.mustCall((er) => {
+    assert.strictEqual(er.message, 'bye');
+    collect = false;
+  })
+);
 
-setImmediate(common.mustCall(() => {
-  process.nextTick(common.mustCall(() => {
-    assert.strictEqual(Object.keys(id_obj).length, 0);
-    hook.disable();
-  }));
+setImmediate(
+  common.mustCall(() => {
+    process.nextTick(
+      common.mustCall(() => {
+        assert.strictEqual(Object.keys(id_obj).length, 0);
+        hook.disable();
+      })
+    );
 
-  // Create a stack of async ids that will need to be emitted in the case of
-  // an uncaught exception.
-  const ar1 = new async_hooks.AsyncResource('Mine');
-  ar1.runInAsyncScope(() => {
-    const ar2 = new async_hooks.AsyncResource('Mine');
-    ar2.runInAsyncScope(() => {
-      throw new Error('bye');
+    // Create a stack of async ids that will need to be emitted in the case of
+    // an uncaught exception.
+    const ar1 = new async_hooks.AsyncResource('Mine');
+    ar1.runInAsyncScope(() => {
+      const ar2 = new async_hooks.AsyncResource('Mine');
+      ar2.runInAsyncScope(() => {
+        throw new Error('bye');
+      });
     });
-  });
 
-  // TODO(trevnorris): This test shows that the after() hooks are always called
-  // correctly, but it doesn't solve where the emitDestroy() is missed because
-  // of the uncaught exception. Simple solution is to always call emitDestroy()
-  // before the emitAfter(), but how to codify this?
-}));
+    // TODO(trevnorris): This test shows that the after() hooks are always called
+    // correctly, but it doesn't solve where the emitDestroy() is missed because
+    // of the uncaught exception. Simple solution is to always call emitDestroy()
+    // before the emitAfter(), but how to codify this?
+  })
+);
diff --git a/test/parallel/test-emit-after-uncaught-exception.js b/test/parallel/test-emit-after-uncaught-exception.js
index 368099d48355be..bd6238224a8f1e 100644
--- a/test/parallel/test-emit-after-uncaught-exception.js
+++ b/test/parallel/test-emit-after-uncaught-exception.js
@@ -7,34 +7,47 @@ const async_hooks = require('async_hooks');
 const id_obj = {};
 let collect = true;
 
-const hook = async_hooks.createHook({
-  before(id) { if (collect) id_obj[id] = true; },
-  after(id) { delete id_obj[id]; },
-}).enable();
-
-process.once('uncaughtException', common.mustCall((er) => {
-  assert.strictEqual(er.message, 'bye');
-  collect = false;
-}));
-
-setImmediate(common.mustCall(() => {
-  process.nextTick(common.mustCall(() => {
-    assert.strictEqual(Object.keys(id_obj).length, 0);
-    hook.disable();
-  }));
-
-  // Create a stack of async ids that will need to be emitted in the case of
-  // an uncaught exception.
-  const ar1 = new async_hooks.AsyncResource('Mine');
-  ar1.emitBefore();
-
-  const ar2 = new async_hooks.AsyncResource('Mine');
-  ar2.emitBefore();
-
-  throw new Error('bye');
-
-  // TODO(trevnorris): This test shows that the after() hooks are always called
-  // correctly, but it doesn't solve where the emitDestroy() is missed because
-  // of the uncaught exception. Simple solution is to always call emitDestroy()
-  // before the emitAfter(), but how to codify this?
-}));
+const hook = async_hooks
+  .createHook({
+    before(id) {
+      if (collect) id_obj[id] = true;
+    },
+    after(id) {
+      delete id_obj[id];
+    }
+  })
+  .enable();
+
+process.once(
+  'uncaughtException',
+  common.mustCall((er) => {
+    assert.strictEqual(er.message, 'bye');
+    collect = false;
+  })
+);
+
+setImmediate(
+  common.mustCall(() => {
+    process.nextTick(
+      common.mustCall(() => {
+        assert.strictEqual(Object.keys(id_obj).length, 0);
+        hook.disable();
+      })
+    );
+
+    // Create a stack of async ids that will need to be emitted in the case of
+    // an uncaught exception.
+    const ar1 = new async_hooks.AsyncResource('Mine');
+    ar1.emitBefore();
+
+    const ar2 = new async_hooks.AsyncResource('Mine');
+    ar2.emitBefore();
+
+    throw new Error('bye');
+
+    // TODO(trevnorris): This test shows that the after() hooks are always called
+    // correctly, but it doesn't solve where the emitDestroy() is missed because
+    // of the uncaught exception. Simple solution is to always call emitDestroy()
+    // before the emitAfter(), but how to codify this?
+  })
+);
diff --git a/test/parallel/test-env-var-no-warnings.js b/test/parallel/test-env-var-no-warnings.js
index e2a11656f33df2..826dea8ac1d591 100644
--- a/test/parallel/test-env-var-no-warnings.js
+++ b/test/parallel/test-env-var-no-warnings.js
@@ -10,15 +10,17 @@ if (process.argv[2] === 'child') {
     const env = Object.assign({}, process.env, newEnv);
     const cmd = `"${process.execPath}" "${__filename}" child`;
 
-    cp.exec(cmd, { env }, common.mustCall((err, stdout, stderr) => {
-      assert.strictEqual(err, null);
-      assert.strictEqual(stdout, '');
+    cp.exec(
+      cmd,
+      { env },
+      common.mustCall((err, stdout, stderr) => {
+        assert.strictEqual(err, null);
+        assert.strictEqual(stdout, '');
 
-      if (env.NODE_NO_WARNINGS === '1')
-        assert.strictEqual(stderr, '');
-      else
-        assert(/Warning: foo$/.test(stderr.trim()));
-    }));
+        if (env.NODE_NO_WARNINGS === '1') assert.strictEqual(stderr, '');
+        else assert(/Warning: foo$/.test(stderr.trim()));
+      })
+    );
   }
 
   test({});
diff --git a/test/parallel/test-err-name-deprecation.js b/test/parallel/test-err-name-deprecation.js
index d9af7e3804ec4a..21c88c969e906b 100644
--- a/test/parallel/test-err-name-deprecation.js
+++ b/test/parallel/test-err-name-deprecation.js
@@ -5,8 +5,8 @@ const common = require('../common');
 
 common.expectWarning(
   'DeprecationWarning',
-  'Directly calling process.binding(\'uv\').errname(<val>) is being ' +
-  'deprecated. Please make sure to use util.getSystemErrorName() instead.',
+  "Directly calling process.binding('uv').errname(<val>) is being " +
+    'deprecated. Please make sure to use util.getSystemErrorName() instead.',
   'DEP0119'
 );
 
diff --git a/test/parallel/test-error-reporting.js b/test/parallel/test-error-reporting.js
index b9d78b181aef47..cdd0d797633fce 100644
--- a/test/parallel/test-error-reporting.js
+++ b/test/parallel/test-error-reporting.js
@@ -41,41 +41,58 @@ function errExec(script, callback) {
 
 const syntaxErrorMessage = /\bSyntaxError\b/;
 
-
 // Simple throw error
-errExec('throws_error.js', common.mustCall(function(err, stdout, stderr) {
-  assert.ok(/blah/.test(stderr));
-}));
-
+errExec(
+  'throws_error.js',
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ok(/blah/.test(stderr));
+  })
+);
 
 // Trying to JSON.parse(undefined)
-errExec('throws_error2.js', common.mustCall(function(err, stdout, stderr) {
-  assert.ok(syntaxErrorMessage.test(stderr));
-}));
-
+errExec(
+  'throws_error2.js',
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ok(syntaxErrorMessage.test(stderr));
+  })
+);
 
 // Trying to JSON.parse(undefined) in nextTick
-errExec('throws_error3.js', common.mustCall(function(err, stdout, stderr) {
-  assert.ok(syntaxErrorMessage.test(stderr));
-}));
-
+errExec(
+  'throws_error3.js',
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ok(syntaxErrorMessage.test(stderr));
+  })
+);
 
 // throw ILLEGAL error
-errExec('throws_error4.js', common.mustCall(function(err, stdout, stderr) {
-  assert.ok(syntaxErrorMessage.test(stderr));
-}));
+errExec(
+  'throws_error4.js',
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ok(syntaxErrorMessage.test(stderr));
+  })
+);
 
 // Specific long exception line doesn't result in stack overflow
-errExec('throws_error5.js', common.mustCall(function(err, stdout, stderr) {
-  assert.ok(syntaxErrorMessage.test(stderr));
-}));
+errExec(
+  'throws_error5.js',
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ok(syntaxErrorMessage.test(stderr));
+  })
+);
 
 // Long exception line with length > errorBuffer doesn't result in assertion
-errExec('throws_error6.js', common.mustCall(function(err, stdout, stderr) {
-  assert.ok(syntaxErrorMessage.test(stderr));
-}));
+errExec(
+  'throws_error6.js',
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ok(syntaxErrorMessage.test(stderr));
+  })
+);
 
 // Object that throws in toString() doesn't print garbage
-errExec('throws_error7.js', common.mustCall(function(err, stdout, stderr) {
-  assert.ok(/<toString\(\) threw exception/.test(stderr));
-}));
+errExec(
+  'throws_error7.js',
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ok(/<toString\(\) threw exception/.test(stderr));
+  })
+);
diff --git a/test/parallel/test-errors-systemerror.js b/test/parallel/test-errors-systemerror.js
index 0b5f9b9a107d59..80c318745840e7 100644
--- a/test/parallel/test-errors-systemerror.js
+++ b/test/parallel/test-errors-systemerror.js
@@ -6,10 +6,12 @@ const assert = require('assert');
 const { E, SystemError, codes } = require('internal/errors');
 
 assert.throws(
-  () => { throw new SystemError(); },
+  () => {
+    throw new SystemError();
+  },
   {
     name: 'TypeError',
-    message: 'Cannot read property \'match\' of undefined'
+    message: "Cannot read property 'match' of undefined"
   }
 );
 
@@ -26,12 +28,15 @@ const { ERR_TEST } = codes;
   };
 
   assert.throws(
-    () => { throw new ERR_TEST(ctx); },
+    () => {
+      throw new ERR_TEST(ctx);
+    },
     {
       code: 'ERR_TEST',
       name: 'SystemError [ERR_TEST]',
-      message: 'custom message: syscall_test returned ETEST (code message)' +
-               ' /str => /str2',
+      message:
+        'custom message: syscall_test returned ETEST (code message)' +
+        ' /str => /str2',
       info: ctx
     }
   );
@@ -46,12 +51,15 @@ const { ERR_TEST } = codes;
     dest: '/str2'
   };
   assert.throws(
-    () => { throw new ERR_TEST(ctx); },
+    () => {
+      throw new ERR_TEST(ctx);
+    },
     {
       code: 'ERR_TEST',
       name: 'SystemError [ERR_TEST]',
-      message: 'custom message: syscall_test returned ETEST (code message)' +
-               ' /buf => /str2',
+      message:
+        'custom message: syscall_test returned ETEST (code message)' +
+        ' /buf => /str2',
       info: ctx
     }
   );
@@ -66,12 +74,15 @@ const { ERR_TEST } = codes;
     dest: Buffer.from('/buf2')
   };
   assert.throws(
-    () => { throw new ERR_TEST(ctx); },
+    () => {
+      throw new ERR_TEST(ctx);
+    },
     {
       code: 'ERR_TEST',
       name: 'SystemError [ERR_TEST]',
-      message: 'custom message: syscall_test returned ETEST (code message)' +
-               ' /buf => /buf2',
+      message:
+        'custom message: syscall_test returned ETEST (code message)' +
+        ' /buf => /buf2',
       info: ctx
     }
   );
@@ -127,8 +138,8 @@ const { ERR_TEST } = codes;
     {
       code: 'ERR_TEST',
       name: 'SystemError [CUSTOM_ERR_TEST]',
-      message: 'custom message: syscall_test returned ERR_TEST ' +
-               '(Error occurred)',
+      message:
+        'custom message: syscall_test returned ERR_TEST ' + '(Error occurred)',
       info: ctx
     }
   );
diff --git a/test/parallel/test-eslint-buffer-constructor.js b/test/parallel/test-eslint-buffer-constructor.js
index daa1a527673c1a..59f3798a8b5ab8 100644
--- a/test/parallel/test-eslint-buffer-constructor.js
+++ b/test/parallel/test-eslint-buffer-constructor.js
@@ -6,14 +6,13 @@ common.skipIfEslintMissing();
 const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
 const rule = require('../../tools/eslint-rules/buffer-constructor');
 
-const message = 'Use of the Buffer() constructor has been deprecated. ' +
-                'Please use either Buffer.alloc(), Buffer.allocUnsafe(), ' +
-                'or Buffer.from()';
+const message =
+  'Use of the Buffer() constructor has been deprecated. ' +
+  'Please use either Buffer.alloc(), Buffer.allocUnsafe(), ' +
+  'or Buffer.from()';
 
 new RuleTester().run('buffer-constructor', rule, {
-  valid: [
-    'Buffer.from(foo)'
-  ],
+  valid: ['Buffer.from(foo)'],
   invalid: [
     {
       code: 'Buffer(foo)',
diff --git a/test/parallel/test-eslint-crypto-check.js b/test/parallel/test-eslint-crypto-check.js
index 86c28d21218154..96b3885a4e7a5d 100644
--- a/test/parallel/test-eslint-crypto-check.js
+++ b/test/parallel/test-eslint-crypto-check.js
@@ -7,8 +7,9 @@ common.skipIfEslintMissing();
 const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
 const rule = require('../../tools/eslint-rules/crypto-check');
 
-const message = 'Please add a hasCrypto check to allow this test to be ' +
-                'skipped when Node is built "--without-ssl".';
+const message =
+  'Please add a hasCrypto check to allow this test to be ' +
+  'skipped when Node is built "--without-ssl".';
 
 new RuleTester().run('crypto-check', rule, {
   valid: [
@@ -23,26 +24,26 @@ new RuleTester().run('crypto-check', rule, {
   ],
   invalid: [
     {
-      code: 'require("common")\n' +
-            'require("crypto")',
+      code: 'require("common")\n' + 'require("crypto")',
       errors: [{ message }],
-      output: 'require("common")\n' +
-              'if (!common.hasCrypto) {' +
-              ' common.skip("missing crypto");' +
-              '}\n' +
-              'require("crypto")'
+      output:
+        'require("common")\n' +
+        'if (!common.hasCrypto) {' +
+        ' common.skip("missing crypto");' +
+        '}\n' +
+        'require("crypto")'
     },
     {
-      code: 'require("common")\n' +
-            'if (common.foo) {}\n' +
-            'require("crypto")',
+      code:
+        'require("common")\n' + 'if (common.foo) {}\n' + 'require("crypto")',
       errors: [{ message }],
-      output: 'require("common")\n' +
-              'if (!common.hasCrypto) {' +
-              ' common.skip("missing crypto");' +
-              '}\n' +
-              'if (common.foo) {}\n' +
-              'require("crypto")'
+      output:
+        'require("common")\n' +
+        'if (!common.hasCrypto) {' +
+        ' common.skip("missing crypto");' +
+        '}\n' +
+        'if (common.foo) {}\n' +
+        'require("crypto")'
     }
   ]
 });
diff --git a/test/parallel/test-eslint-documented-errors.js b/test/parallel/test-eslint-documented-errors.js
index 533b829e78a298..4456f1b921db57 100644
--- a/test/parallel/test-eslint-documented-errors.js
+++ b/test/parallel/test-eslint-documented-errors.js
@@ -25,8 +25,7 @@ new RuleTester().run('documented-errors', rule, {
           line: 2
         },
         {
-          message:
-            `doc/api/errors.md does not have an anchor for "${invalidCode}"`,
+          message: `doc/api/errors.md does not have an anchor for "${invalidCode}"`,
           line: 2
         }
       ]
diff --git a/test/parallel/test-eslint-duplicate-requires.js b/test/parallel/test-eslint-duplicate-requires.js
index c7edaeed2b6b6e..d05933e45400d0 100644
--- a/test/parallel/test-eslint-duplicate-requires.js
+++ b/test/parallel/test-eslint-duplicate-requires.js
@@ -10,16 +10,16 @@ const rule = require('../../tools/eslint-rules/no-duplicate-requires');
 new RuleTester().run('no-duplicate-requires', rule, {
   valid: [
     {
-      code: 'require("a"); require("b"); (function() { require("a"); });',
+      code: 'require("a"); require("b"); (function() { require("a"); });'
     },
     {
-      code: 'require(a); require(a);',
-    },
+      code: 'require(a); require(a);'
+    }
   ],
   invalid: [
     {
       code: 'require("a"); require("a");',
-      errors: [{ message: '\'a\' require is duplicated.' }],
-    },
-  ],
+      errors: [{ message: "'a' require is duplicated." }]
+    }
+  ]
 });
diff --git a/test/parallel/test-eslint-eslint-check.js b/test/parallel/test-eslint-eslint-check.js
index 46e2a6a4a2ce47..9d9e1179178bb4 100644
--- a/test/parallel/test-eslint-eslint-check.js
+++ b/test/parallel/test-eslint-eslint-check.js
@@ -7,9 +7,10 @@ common.skipIfEslintMissing();
 const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
 const rule = require('../../tools/eslint-rules/eslint-check');
 
-const message = 'Please add a skipIfEslintMissing() call to allow this ' +
-                'test to be skipped when Node.js is built ' +
-                'from a source tarball.';
+const message =
+  'Please add a skipIfEslintMissing() call to allow this ' +
+  'test to be skipped when Node.js is built ' +
+  'from a source tarball.';
 
 new RuleTester().run('eslint-check', rule, {
   valid: [
@@ -20,12 +21,14 @@ new RuleTester().run('eslint-check', rule, {
   ],
   invalid: [
     {
-      code: 'require("common")\n' +
-            'require("../../tools/node_modules/eslint").RuleTester',
+      code:
+        'require("common")\n' +
+        'require("../../tools/node_modules/eslint").RuleTester',
       errors: [{ message }],
-      output: 'require("common")\n' +
-              'common.skipIfEslintMissing();\n' +
-              'require("../../tools/node_modules/eslint").RuleTester'
+      output:
+        'require("common")\n' +
+        'common.skipIfEslintMissing();\n' +
+        'require("../../tools/node_modules/eslint").RuleTester'
     }
   ]
 });
diff --git a/test/parallel/test-eslint-inspector-check.js b/test/parallel/test-eslint-inspector-check.js
index ae71c004029771..701def79724df2 100644
--- a/test/parallel/test-eslint-inspector-check.js
+++ b/test/parallel/test-eslint-inspector-check.js
@@ -6,9 +6,10 @@ common.skipIfEslintMissing();
 const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
 const rule = require('../../tools/eslint-rules/inspector-check');
 
-const message = 'Please add a skipIfInspectorDisabled() call to allow this ' +
-                'test to be skipped when Node is built ' +
-                '\'--without-inspector\'.';
+const message =
+  'Please add a skipIfInspectorDisabled() call to allow this ' +
+  'test to be skipped when Node is built ' +
+  "'--without-inspector'.";
 
 new RuleTester().run('inspector-check', rule, {
   valid: [
@@ -19,12 +20,12 @@ new RuleTester().run('inspector-check', rule, {
   ],
   invalid: [
     {
-      code: 'require("common")\n' +
-            'require("inspector")',
+      code: 'require("common")\n' + 'require("inspector")',
       errors: [{ message }],
-      output: 'require("common")\n' +
-              'common.skipIfInspectorDisabled();\n' +
-              'require("inspector")'
+      output:
+        'require("common")\n' +
+        'common.skipIfInspectorDisabled();\n' +
+        'require("inspector")'
     }
   ]
 });
diff --git a/test/parallel/test-eslint-lowercase-name-for-primitive.js b/test/parallel/test-eslint-lowercase-name-for-primitive.js
index f196f3f45ce82a..a0f7f008000dfa 100644
--- a/test/parallel/test-eslint-lowercase-name-for-primitive.js
+++ b/test/parallel/test-eslint-lowercase-name-for-primitive.js
@@ -14,26 +14,26 @@ new RuleTester().run('lowercase-name-for-primitive', rule, {
     'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "number")',
     'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "boolean")',
     'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "null")',
-    'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "undefined")',
+    'new errors.TypeError("ERR_INVALID_ARG_TYPE", "name", "undefined")'
   ],
   invalid: [
     {
       code: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'Number')",
       errors: [{ message: 'primitive should use lowercase: Number' }],
-      output: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'number')",
+      output: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'number')"
     },
     {
       code: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'STRING')",
       errors: [{ message: 'primitive should use lowercase: STRING' }],
-      output: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'string')",
+      output: "new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a', 'string')"
     },
     {
       code: "new e.TypeError('ERR_INVALID_ARG_TYPE', a, ['String','Number'])",
       errors: [
         { message: 'primitive should use lowercase: String' },
-        { message: 'primitive should use lowercase: Number' },
+        { message: 'primitive should use lowercase: Number' }
       ],
-      output: "new e.TypeError('ERR_INVALID_ARG_TYPE', a, ['string','number'])",
-    },
+      output: "new e.TypeError('ERR_INVALID_ARG_TYPE', a, ['string','number'])"
+    }
   ]
 });
diff --git a/test/parallel/test-eslint-no-let-in-for-declaration.js b/test/parallel/test-eslint-no-let-in-for-declaration.js
index ed8f306eea8ad5..7cc943e162635f 100644
--- a/test/parallel/test-eslint-no-let-in-for-declaration.js
+++ b/test/parallel/test-eslint-no-let-in-for-declaration.js
@@ -9,8 +9,9 @@ const rule = require('../../tools/eslint-rules/no-let-in-for-declaration');
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
-const message = 'Use of `let` as the loop variable in a for-loop is ' +
-                'not recommended. Please use `var` instead.';
+const message =
+  'Use of `let` as the loop variable in a for-loop is ' +
+  'not recommended. Please use `var` instead.';
 
 ruleTester.run('no-let-in-for-declaration', rule, {
   valid: [
diff --git a/test/parallel/test-eslint-number-isnan.js b/test/parallel/test-eslint-number-isnan.js
index b290a48a8957e7..3b9f9753e91b79 100644
--- a/test/parallel/test-eslint-number-isnan.js
+++ b/test/parallel/test-eslint-number-isnan.js
@@ -10,9 +10,7 @@ const rule = require('../../tools/eslint-rules/number-isnan');
 const message = 'Please use Number.isNaN instead of the global isNaN function';
 
 new RuleTester().run('number-isnan', rule, {
-  valid: [
-    'Number.isNaN()'
-  ],
+  valid: ['Number.isNaN()'],
   invalid: [
     {
       code: 'isNaN()',
diff --git a/test/parallel/test-eslint-prefer-assert-iferror.js b/test/parallel/test-eslint-prefer-assert-iferror.js
index 7dc3bbe7bcda4d..4ba182a65df03b 100644
--- a/test/parallel/test-eslint-prefer-assert-iferror.js
+++ b/test/parallel/test-eslint-prefer-assert-iferror.js
@@ -16,18 +16,14 @@ new RuleTester().run('prefer-assert-iferror', rule, {
   ],
   invalid: [
     {
-      code: 'require("assert");\n' +
-            'if (err) throw err;',
+      code: 'require("assert");\n' + 'if (err) throw err;',
       errors: [{ message: 'Use assert.ifError(err) instead.' }],
-      output: 'require("assert");\n' +
-              'assert.ifError(err);'
+      output: 'require("assert");\n' + 'assert.ifError(err);'
     },
     {
-      code: 'require("assert");\n' +
-            'if (error) { throw error; }',
+      code: 'require("assert");\n' + 'if (error) { throw error; }',
       errors: [{ message: 'Use assert.ifError(error) instead.' }],
-      output: 'require("assert");\n' +
-              'assert.ifError(error);'
+      output: 'require("assert");\n' + 'assert.ifError(error);'
     }
   ]
 });
diff --git a/test/parallel/test-eslint-prefer-assert-methods.js b/test/parallel/test-eslint-prefer-assert-methods.js
index 3ad1cd5c376e9b..3265921abc6225 100644
--- a/test/parallel/test-eslint-prefer-assert-methods.js
+++ b/test/parallel/test-eslint-prefer-assert-methods.js
@@ -24,30 +24,38 @@ new RuleTester().run('prefer-assert-methods', rule, {
   invalid: [
     {
       code: 'assert(foo == bar);',
-      errors: [{
-        message: "'assert.equal' should be used instead of '=='"
-      }],
+      errors: [
+        {
+          message: "'assert.equal' should be used instead of '=='"
+        }
+      ],
       output: 'assert.equal(foo, bar);'
     },
     {
       code: 'assert(foo === bar);',
-      errors: [{
-        message: "'assert.strictEqual' should be used instead of '==='"
-      }],
+      errors: [
+        {
+          message: "'assert.strictEqual' should be used instead of '==='"
+        }
+      ],
       output: 'assert.strictEqual(foo, bar);'
     },
     {
       code: 'assert(foo != bar);',
-      errors: [{
-        message: "'assert.notEqual' should be used instead of '!='"
-      }],
+      errors: [
+        {
+          message: "'assert.notEqual' should be used instead of '!='"
+        }
+      ],
       output: 'assert.notEqual(foo, bar);'
     },
     {
       code: 'assert(foo !== bar);',
-      errors: [{
-        message: "'assert.notStrictEqual' should be used instead of '!=='"
-      }],
+      errors: [
+        {
+          message: "'assert.notStrictEqual' should be used instead of '!=='"
+        }
+      ],
       output: 'assert.notStrictEqual(foo, bar);'
     }
   ]
diff --git a/test/parallel/test-eslint-prefer-common-expectserror.js b/test/parallel/test-eslint-prefer-common-expectserror.js
index e0d208b68bb743..3ece33b7b1d36d 100644
--- a/test/parallel/test-eslint-prefer-common-expectserror.js
+++ b/test/parallel/test-eslint-prefer-common-expectserror.js
@@ -7,8 +7,9 @@ common.skipIfEslintMissing();
 const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
 const rule = require('../../tools/eslint-rules/prefer-common-expectserror');
 
-const message = 'Please use common.expectsError(fn, err) instead of ' +
-                'assert.throws(fn, common.expectsError(err)).';
+const message =
+  'Please use common.expectsError(fn, err) instead of ' +
+  'assert.throws(fn, common.expectsError(err)).';
 
 new RuleTester().run('prefer-common-expectserror', rule, {
   valid: [
diff --git a/test/parallel/test-eslint-prefer-common-mustnotcall.js b/test/parallel/test-eslint-prefer-common-mustnotcall.js
index e6e9d1d2f88332..7294c5e2ac6743 100644
--- a/test/parallel/test-eslint-prefer-common-mustnotcall.js
+++ b/test/parallel/test-eslint-prefer-common-mustnotcall.js
@@ -7,8 +7,9 @@ common.skipIfEslintMissing();
 const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
 const rule = require('../../tools/eslint-rules/prefer-common-mustnotcall');
 
-const message = 'Please use common.mustNotCall(msg) instead of ' +
-                'common.mustCall(fn, 0) or common.mustCall(0).';
+const message =
+  'Please use common.mustNotCall(msg) instead of ' +
+  'common.mustCall(fn, 0) or common.mustCall(0).';
 
 new RuleTester().run('prefer-common-mustnotcall', rule, {
   valid: [
diff --git a/test/parallel/test-eslint-prefer-util-format-errors.js b/test/parallel/test-eslint-prefer-util-format-errors.js
index 560222438b9aee..28df87ca50edc7 100644
--- a/test/parallel/test-eslint-prefer-util-format-errors.js
+++ b/test/parallel/test-eslint-prefer-util-format-errors.js
@@ -9,21 +9,27 @@ common.skipIfEslintMissing();
 const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
 const rule = require('../../tools/eslint-rules/prefer-util-format-errors');
 
-new RuleTester({ parserOptions: { ecmaVersion: 6 } })
-  .run('prefer-util-format-errors', rule, {
+new RuleTester({ parserOptions: { ecmaVersion: 6 } }).run(
+  'prefer-util-format-errors',
+  rule,
+  {
     valid: [
-      'E(\'ABC\', \'abc\');',
-      'E(\'ABC\', (arg1, arg2) => `${arg2}${arg1}`);',
-      'E(\'ABC\', (arg1, arg2) => `${arg1}{arg2.something}`);',
-      'E(\'ABC\', (arg1, arg2) => fn(arg1, arg2));'
+      "E('ABC', 'abc');",
+      "E('ABC', (arg1, arg2) => `${arg2}${arg1}`);",
+      "E('ABC', (arg1, arg2) => `${arg1}{arg2.something}`);",
+      "E('ABC', (arg1, arg2) => fn(arg1, arg2));"
     ],
     invalid: [
       {
-        code: 'E(\'ABC\', (arg1, arg2) => `${arg1}${arg2}`);',
-        errors: [{
-          message: 'Please use a printf-like formatted string that ' +
-                   'util.format can consume.'
-        }]
+        code: "E('ABC', (arg1, arg2) => `${arg1}${arg2}`);",
+        errors: [
+          {
+            message:
+              'Please use a printf-like formatted string that ' +
+              'util.format can consume.'
+          }
+        ]
       }
     ]
-  });
+  }
+);
diff --git a/test/parallel/test-eslint-require-buffer.js b/test/parallel/test-eslint-require-buffer.js
index d928c435480e5e..e9f0bd27eaeae1 100644
--- a/test/parallel/test-eslint-require-buffer.js
+++ b/test/parallel/test-eslint-require-buffer.js
@@ -11,39 +11,40 @@ const ruleTester = new RuleTester({
   env: { node: true }
 });
 
-const message = "Use const { Buffer } = require('buffer'); " +
-                'at the beginning of this file';
+const message =
+  "Use const { Buffer } = require('buffer'); " +
+  'at the beginning of this file';
 
-const useStrict = '\'use strict\';\n\n';
-const bufferModule = 'const { Buffer } = require(\'buffer\');\n';
+const useStrict = "'use strict';\n\n";
+const bufferModule = "const { Buffer } = require('buffer');\n";
 const mockComment = '// Some Comment\n//\n// Another Comment\n\n';
 const useBuffer = 'Buffer;';
 ruleTester.run('require-globals', rule, {
   valid: [
     'foo',
     'const Buffer = require("Buffer"); Buffer;',
-    'const { Buffer } = require(\'buffer\'); Buffer;',
+    "const { Buffer } = require('buffer'); Buffer;"
   ],
   invalid: [
     {
       code: useBuffer,
       errors: [{ message }],
-      output: bufferModule + useBuffer,
+      output: bufferModule + useBuffer
     },
     {
       code: useStrict + useBuffer,
       errors: [{ message }],
-      output: useStrict + bufferModule + useBuffer,
+      output: useStrict + bufferModule + useBuffer
     },
     {
       code: mockComment + useBuffer,
       errors: [{ message }],
-      output: mockComment + bufferModule + useBuffer,
+      output: mockComment + bufferModule + useBuffer
     },
     {
       code: mockComment + useStrict + useBuffer,
       errors: [{ message }],
-      output: mockComment + useStrict + bufferModule + useBuffer,
-    },
+      output: mockComment + useStrict + bufferModule + useBuffer
+    }
   ]
 });
diff --git a/test/parallel/test-eslint-required-modules.js b/test/parallel/test-eslint-required-modules.js
index dbdc135ccf633f..80f1e1f7363e43 100644
--- a/test/parallel/test-eslint-required-modules.js
+++ b/test/parallel/test-eslint-required-modules.js
@@ -16,7 +16,7 @@ new RuleTester().run('required-modules', rule, {
     {
       code: 'foo',
       options: []
-    },
+    }
   ],
   invalid: [
     {
diff --git a/test/parallel/test-eval-strict-referenceerror.js b/test/parallel/test-eval-strict-referenceerror.js
index a96478a1bedaae..bb50b923f20679 100644
--- a/test/parallel/test-eval-strict-referenceerror.js
+++ b/test/parallel/test-eval-strict-referenceerror.js
@@ -8,20 +8,18 @@ require('../common');
 const assert = require('assert');
 
 function test() {
-
   const code = [
     'var foo = {m: 1};',
     '',
     'function bar() {',
-    '\'use strict\';',
-    'return foo; // foo isn\'t captured in 0.10',
+    "'use strict';",
+    "return foo; // foo isn't captured in 0.10",
     '};'
   ].join('\n');
 
   eval(code);
 
   return bar(); // eslint-disable-line no-undef
-
 }
 
 assert.deepStrictEqual(test(), { m: 1 });
diff --git a/test/parallel/test-event-emitter-add-listeners.js b/test/parallel/test-event-emitter-add-listeners.js
index 6ef39522183d4f..e0c2816ada8e33 100644
--- a/test/parallel/test-event-emitter-add-listeners.js
+++ b/test/parallel/test-event-emitter-add-listeners.js
@@ -34,8 +34,7 @@ const EventEmitter = require('events');
 
   ee.on('newListener', function(event, listener) {
     // Don't track newListener listeners.
-    if (event === 'newListener')
-      return;
+    if (event === 'newListener') return;
 
     events_new_listener_emitted.push(event);
     listeners_new_listener_emitted.push(listener);
@@ -86,12 +85,16 @@ const EventEmitter = require('events');
 }
 
 // Verify that the listener must be a function
-common.expectsError(() => {
-  const ee = new EventEmitter();
-  ee.on('foo', null);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "listener" argument must be of type Function. ' +
-           'Received type object'
-});
+common.expectsError(
+  () => {
+    const ee = new EventEmitter();
+    ee.on('foo', null);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "listener" argument must be of type Function. ' +
+      'Received type object'
+  }
+);
diff --git a/test/parallel/test-event-emitter-errors.js b/test/parallel/test-event-emitter-errors.js
index ef2bbee93f8bfd..19dbf7b92b639d 100644
--- a/test/parallel/test-event-emitter-errors.js
+++ b/test/parallel/test-event-emitter-errors.js
@@ -4,20 +4,14 @@ const EventEmitter = require('events');
 
 const EE = new EventEmitter();
 
-common.expectsError(
-  () => EE.emit('error', 'Accepts a string'),
-  {
-    code: 'ERR_UNHANDLED_ERROR',
-    type: Error,
-    message: 'Unhandled error. (Accepts a string)'
-  }
-);
+common.expectsError(() => EE.emit('error', 'Accepts a string'), {
+  code: 'ERR_UNHANDLED_ERROR',
+  type: Error,
+  message: 'Unhandled error. (Accepts a string)'
+});
 
-common.expectsError(
-  () => EE.emit('error', { message: 'Error!' }),
-  {
-    code: 'ERR_UNHANDLED_ERROR',
-    type: Error,
-    message: 'Unhandled error. ([object Object])'
-  }
-);
+common.expectsError(() => EE.emit('error', { message: 'Error!' }), {
+  code: 'ERR_UNHANDLED_ERROR',
+  type: Error,
+  message: 'Unhandled error. ([object Object])'
+});
diff --git a/test/parallel/test-event-emitter-listeners-side-effects.js b/test/parallel/test-event-emitter-listeners-side-effects.js
index 3e427c4c284ea2..d31f8dc4528c3c 100644
--- a/test/parallel/test-event-emitter-listeners-side-effects.js
+++ b/test/parallel/test-event-emitter-listeners-side-effects.js
@@ -27,7 +27,7 @@ const assert = require('assert');
 const EventEmitter = require('events').EventEmitter;
 
 const e = new EventEmitter();
-let fl;  // foo listeners
+let fl; // foo listeners
 
 fl = e.listeners('foo');
 assert(Array.isArray(fl));
diff --git a/test/parallel/test-event-emitter-max-listeners-warning-for-null.js b/test/parallel/test-event-emitter-max-listeners-warning-for-null.js
index 2929e1c709328f..94f4e3280f2700 100644
--- a/test/parallel/test-event-emitter-max-listeners-warning-for-null.js
+++ b/test/parallel/test-event-emitter-max-listeners-warning-for-null.js
@@ -9,14 +9,17 @@ const assert = require('assert');
 const e = new events.EventEmitter();
 e.setMaxListeners(1);
 
-process.on('warning', common.mustCall((warning) => {
-  assert.ok(warning instanceof Error);
-  assert.strictEqual(warning.name, 'MaxListenersExceededWarning');
-  assert.strictEqual(warning.emitter, e);
-  assert.strictEqual(warning.count, 2);
-  assert.strictEqual(warning.type, null);
-  assert.ok(warning.message.includes('2 null listeners added.'));
-}));
+process.on(
+  'warning',
+  common.mustCall((warning) => {
+    assert.ok(warning instanceof Error);
+    assert.strictEqual(warning.name, 'MaxListenersExceededWarning');
+    assert.strictEqual(warning.emitter, e);
+    assert.strictEqual(warning.count, 2);
+    assert.strictEqual(warning.type, null);
+    assert.ok(warning.message.includes('2 null listeners added.'));
+  })
+);
 
 e.on(null, () => {});
 e.on(null, () => {});
diff --git a/test/parallel/test-event-emitter-max-listeners-warning-for-symbol.js b/test/parallel/test-event-emitter-max-listeners-warning-for-symbol.js
index 51c31ba0cf2f31..9ed2b99194630f 100644
--- a/test/parallel/test-event-emitter-max-listeners-warning-for-symbol.js
+++ b/test/parallel/test-event-emitter-max-listeners-warning-for-symbol.js
@@ -11,14 +11,17 @@ const symbol = Symbol('symbol');
 const e = new events.EventEmitter();
 e.setMaxListeners(1);
 
-process.on('warning', common.mustCall((warning) => {
-  assert.ok(warning instanceof Error);
-  assert.strictEqual(warning.name, 'MaxListenersExceededWarning');
-  assert.strictEqual(warning.emitter, e);
-  assert.strictEqual(warning.count, 2);
-  assert.strictEqual(warning.type, symbol);
-  assert.ok(warning.message.includes('2 Symbol(symbol) listeners added.'));
-}));
+process.on(
+  'warning',
+  common.mustCall((warning) => {
+    assert.ok(warning instanceof Error);
+    assert.strictEqual(warning.name, 'MaxListenersExceededWarning');
+    assert.strictEqual(warning.emitter, e);
+    assert.strictEqual(warning.count, 2);
+    assert.strictEqual(warning.type, symbol);
+    assert.ok(warning.message.includes('2 Symbol(symbol) listeners added.'));
+  })
+);
 
 e.on(symbol, () => {});
 e.on(symbol, () => {});
diff --git a/test/parallel/test-event-emitter-max-listeners-warning.js b/test/parallel/test-event-emitter-max-listeners-warning.js
index 0be7fc84bce17b..686e92d80d8edc 100644
--- a/test/parallel/test-event-emitter-max-listeners-warning.js
+++ b/test/parallel/test-event-emitter-max-listeners-warning.js
@@ -9,15 +9,18 @@ const assert = require('assert');
 const e = new events.EventEmitter();
 e.setMaxListeners(1);
 
-process.on('warning', common.mustCall((warning) => {
-  assert.ok(warning instanceof Error);
-  assert.strictEqual(warning.name, 'MaxListenersExceededWarning');
-  assert.strictEqual(warning.emitter, e);
-  assert.strictEqual(warning.count, 2);
-  assert.strictEqual(warning.type, 'event-type');
-  assert.ok(warning.message.includes('2 event-type listeners added.'));
-}));
+process.on(
+  'warning',
+  common.mustCall((warning) => {
+    assert.ok(warning instanceof Error);
+    assert.strictEqual(warning.name, 'MaxListenersExceededWarning');
+    assert.strictEqual(warning.emitter, e);
+    assert.strictEqual(warning.count, 2);
+    assert.strictEqual(warning.type, 'event-type');
+    assert.ok(warning.message.includes('2 event-type listeners added.'));
+  })
+);
 
 e.on('event-type', () => {});
-e.on('event-type', () => {});  // Trigger warning.
-e.on('event-type', () => {});  // Verify that warning is emitted only once.
+e.on('event-type', () => {}); // Trigger warning.
+e.on('event-type', () => {}); // Verify that warning is emitted only once.
diff --git a/test/parallel/test-event-emitter-max-listeners.js b/test/parallel/test-event-emitter-max-listeners.js
index a906000477f7da..e3c3c958d44f1d 100644
--- a/test/parallel/test-event-emitter-max-listeners.js
+++ b/test/parallel/test-event-emitter-max-listeners.js
@@ -32,25 +32,21 @@ e.setMaxListeners(42);
 const throwsObjs = [NaN, -1, 'and even this'];
 
 for (const obj of throwsObjs) {
-  common.expectsError(
-    () => e.setMaxListeners(obj),
-    {
-      code: 'ERR_OUT_OF_RANGE',
-      type: RangeError,
-      message: 'The value of "n" is out of range. ' +
-               `It must be a non-negative number. Received ${obj}`
-    }
-  );
+  common.expectsError(() => e.setMaxListeners(obj), {
+    code: 'ERR_OUT_OF_RANGE',
+    type: RangeError,
+    message:
+      'The value of "n" is out of range. ' +
+      `It must be a non-negative number. Received ${obj}`
+  });
 
-  common.expectsError(
-    () => events.defaultMaxListeners = obj,
-    {
-      code: 'ERR_OUT_OF_RANGE',
-      type: RangeError,
-      message: 'The value of "defaultMaxListeners" is out of range. ' +
-               `It must be a non-negative number. Received ${obj}`
-    }
-  );
+  common.expectsError(() => (events.defaultMaxListeners = obj), {
+    code: 'ERR_OUT_OF_RANGE',
+    type: RangeError,
+    message:
+      'The value of "defaultMaxListeners" is out of range. ' +
+      `It must be a non-negative number. Received ${obj}`
+  });
 }
 
 e.emit('maxListeners');
diff --git a/test/parallel/test-event-emitter-method-names.js b/test/parallel/test-event-emitter-method-names.js
index 684024d0276261..d206612b5a4c44 100644
--- a/test/parallel/test-event-emitter-method-names.js
+++ b/test/parallel/test-event-emitter-method-names.js
@@ -26,8 +26,8 @@ const events = require('events');
 
 const E = events.EventEmitter.prototype;
 assert.strictEqual(E.constructor.name, 'EventEmitter');
-assert.strictEqual(E.on, E.addListener);  // Same method.
-assert.strictEqual(E.off, E.removeListener);  // Same method.
+assert.strictEqual(E.on, E.addListener); // Same method.
+assert.strictEqual(E.off, E.removeListener); // Same method.
 Object.getOwnPropertyNames(E).forEach(function(name) {
   if (name === 'constructor' || name === 'on' || name === 'off') return;
   if (typeof E[name] !== 'function') return;
diff --git a/test/parallel/test-event-emitter-modify-in-emit.js b/test/parallel/test-event-emitter-modify-in-emit.js
index 995fa01d11a1a8..97a1b8a443f500 100644
--- a/test/parallel/test-event-emitter-modify-in-emit.js
+++ b/test/parallel/test-event-emitter-modify-in-emit.js
@@ -54,13 +54,17 @@ assert.deepStrictEqual(['callback1'], callbacks_called);
 
 e.emit('foo');
 assert.strictEqual(e.listeners('foo').length, 0);
-assert.deepStrictEqual(['callback1', 'callback2', 'callback3'],
-                       callbacks_called);
+assert.deepStrictEqual(
+  ['callback1', 'callback2', 'callback3'],
+  callbacks_called
+);
 
 e.emit('foo');
 assert.strictEqual(e.listeners('foo').length, 0);
-assert.deepStrictEqual(['callback1', 'callback2', 'callback3'],
-                       callbacks_called);
+assert.deepStrictEqual(
+  ['callback1', 'callback2', 'callback3'],
+  callbacks_called
+);
 
 e.on('foo', callback1);
 e.on('foo', callback2);
diff --git a/test/parallel/test-event-emitter-no-error-provided-to-error-event.js b/test/parallel/test-event-emitter-no-error-provided-to-error-event.js
index 5c30b54533133d..9e7b639614b60b 100644
--- a/test/parallel/test-event-emitter-no-error-provided-to-error-event.js
+++ b/test/parallel/test-event-emitter-no-error-provided-to-error-event.js
@@ -29,9 +29,12 @@ const domain = require('domain');
   const e = new events.EventEmitter();
   const d = domain.create();
   d.add(e);
-  d.on('error', common.mustCall((er) => {
-    assert(er instanceof Error, 'error created');
-  }));
+  d.on(
+    'error',
+    common.mustCall((er) => {
+      assert(er instanceof Error, 'error created');
+    })
+  );
   e.emit('error');
 }
 
@@ -39,9 +42,12 @@ for (const arg of [false, null, undefined]) {
   const e = new events.EventEmitter();
   const d = domain.create();
   d.add(e);
-  d.on('error', common.mustCall((er) => {
-    assert(er instanceof Error, 'error created');
-  }));
+  d.on(
+    'error',
+    common.mustCall((er) => {
+      assert(er instanceof Error, 'error created');
+    })
+  );
   e.emit('error', arg);
 }
 
@@ -49,8 +55,11 @@ for (const arg of [42, 'fortytwo', true]) {
   const e = new events.EventEmitter();
   const d = domain.create();
   d.add(e);
-  d.on('error', common.mustCall((er) => {
-    assert.strictEqual(er, arg);
-  }));
+  d.on(
+    'error',
+    common.mustCall((er) => {
+      assert.strictEqual(er, arg);
+    })
+  );
   e.emit('error', arg);
 }
diff --git a/test/parallel/test-event-emitter-once.js b/test/parallel/test-event-emitter-once.js
index 1bdf0cbf126aaf..9a2015a49a358e 100644
--- a/test/parallel/test-event-emitter-once.js
+++ b/test/parallel/test-event-emitter-once.js
@@ -41,24 +41,31 @@ e.once('foo', remove);
 e.removeListener('foo', remove);
 e.emit('foo');
 
-e.once('e', common.mustCall(function() {
-  e.emit('e');
-}));
+e.once(
+  'e',
+  common.mustCall(function() {
+    e.emit('e');
+  })
+);
 
 e.once('e', common.mustCall());
 
 e.emit('e');
 
 // Verify that the listener must be a function
-common.expectsError(() => {
-  const ee = new EventEmitter();
-  ee.once('foo', null);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "listener" argument must be of type Function. ' +
-           'Received type object'
-});
+common.expectsError(
+  () => {
+    const ee = new EventEmitter();
+    ee.once('foo', null);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "listener" argument must be of type Function. ' +
+      'Received type object'
+  }
+);
 
 {
   // once() has different code paths based on the number of arguments being
@@ -69,12 +76,14 @@ common.expectsError(() => {
     const ee = new EventEmitter();
     const args = ['foo'];
 
-    for (let j = 0; j < i; ++j)
-      args.push(j);
+    for (let j = 0; j < i; ++j) args.push(j);
 
-    ee.once('foo', common.mustCall((...params) => {
-      assert.deepStrictEqual(params, args.slice(1));
-    }));
+    ee.once(
+      'foo',
+      common.mustCall((...params) => {
+        assert.deepStrictEqual(params, args.slice(1));
+      })
+    );
 
     EventEmitter.prototype.emit.apply(ee, args);
   }
diff --git a/test/parallel/test-event-emitter-prepend.js b/test/parallel/test-event-emitter-prepend.js
index 3259ea47f945a3..c37d18661aeb1e 100644
--- a/test/parallel/test-event-emitter-prepend.js
+++ b/test/parallel/test-event-emitter-prepend.js
@@ -13,21 +13,27 @@ myEE.on('foo', common.mustCall(() => assert.strictEqual(m, 2)));
 myEE.prependListener('foo', common.mustCall(() => assert.strictEqual(m++, 1)));
 
 // This one comes first.
-myEE.prependOnceListener('foo',
-                         common.mustCall(() => assert.strictEqual(m++, 0)));
+myEE.prependOnceListener(
+  'foo',
+  common.mustCall(() => assert.strictEqual(m++, 0))
+);
 
 myEE.emit('foo');
 
 // Verify that the listener must be a function
-common.expectsError(() => {
-  const ee = new EventEmitter();
-  ee.prependOnceListener('foo', null);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "listener" argument must be of type Function. ' +
-           'Received type object'
-});
+common.expectsError(
+  () => {
+    const ee = new EventEmitter();
+    ee.prependOnceListener('foo', null);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "listener" argument must be of type Function. ' +
+      'Received type object'
+  }
+);
 
 // Test fallback if prependListener is undefined.
 const stream = require('stream');
diff --git a/test/parallel/test-event-emitter-remove-all-listeners.js b/test/parallel/test-event-emitter-remove-all-listeners.js
index 3dfe65a8b4bfd0..6929ea61e54fb6 100644
--- a/test/parallel/test-event-emitter-remove-all-listeners.js
+++ b/test/parallel/test-event-emitter-remove-all-listeners.js
@@ -24,7 +24,6 @@ const common = require('../common');
 const assert = require('assert');
 const events = require('events');
 
-
 function expect(expected) {
   const actual = [];
   process.on('exit', function() {
diff --git a/test/parallel/test-event-emitter-remove-listeners.js b/test/parallel/test-event-emitter-remove-listeners.js
index 925f828f93da36..dc67b1556a5678 100644
--- a/test/parallel/test-event-emitter-remove-listeners.js
+++ b/test/parallel/test-event-emitter-remove-listeners.js
@@ -30,10 +30,13 @@ function listener2() {}
 {
   const ee = new EventEmitter();
   ee.on('hello', listener1);
-  ee.on('removeListener', common.mustCall((name, cb) => {
-    assert.strictEqual(name, 'hello');
-    assert.strictEqual(cb, listener1);
-  }));
+  ee.on(
+    'removeListener',
+    common.mustCall((name, cb) => {
+      assert.strictEqual(name, 'hello');
+      assert.strictEqual(cb, listener1);
+    })
+  );
   ee.removeListener('hello', listener1);
   assert.deepStrictEqual([], ee.listeners('hello'));
 }
@@ -50,18 +53,24 @@ function listener2() {}
   const ee = new EventEmitter();
   ee.on('hello', listener1);
   ee.on('hello', listener2);
-  ee.once('removeListener', common.mustCall((name, cb) => {
-    assert.strictEqual(name, 'hello');
-    assert.strictEqual(cb, listener1);
-    assert.deepStrictEqual([listener2], ee.listeners('hello'));
-  }));
+  ee.once(
+    'removeListener',
+    common.mustCall((name, cb) => {
+      assert.strictEqual(name, 'hello');
+      assert.strictEqual(cb, listener1);
+      assert.deepStrictEqual([listener2], ee.listeners('hello'));
+    })
+  );
   ee.removeListener('hello', listener1);
   assert.deepStrictEqual([listener2], ee.listeners('hello'));
-  ee.once('removeListener', common.mustCall((name, cb) => {
-    assert.strictEqual(name, 'hello');
-    assert.strictEqual(cb, listener2);
-    assert.deepStrictEqual([], ee.listeners('hello'));
-  }));
+  ee.once(
+    'removeListener',
+    common.mustCall((name, cb) => {
+      assert.strictEqual(name, 'hello');
+      assert.strictEqual(cb, listener2);
+      assert.deepStrictEqual([], ee.listeners('hello'));
+    })
+  );
   ee.removeListener('hello', listener2);
   assert.deepStrictEqual([], ee.listeners('hello'));
 }
@@ -77,11 +86,14 @@ function listener2() {}
     assert.fail('remove2 should not have been called');
   }
 
-  ee.on('removeListener', common.mustCall(function(name, cb) {
-    if (cb !== remove1) return;
-    this.removeListener('quux', remove2);
-    this.emit('quux');
-  }, 2));
+  ee.on(
+    'removeListener',
+    common.mustCall(function(name, cb) {
+      if (cb !== remove1) return;
+      this.removeListener('quux', remove2);
+      this.emit('quux');
+    }, 2)
+  );
   ee.on('quux', remove1);
   ee.on('quux', remove2);
   ee.removeListener('quux', remove1);
@@ -91,18 +103,24 @@ function listener2() {}
   const ee = new EventEmitter();
   ee.on('hello', listener1);
   ee.on('hello', listener2);
-  ee.once('removeListener', common.mustCall((name, cb) => {
-    assert.strictEqual(name, 'hello');
-    assert.strictEqual(cb, listener1);
-    assert.deepStrictEqual([listener2], ee.listeners('hello'));
-    ee.once('removeListener', common.mustCall((name, cb) => {
+  ee.once(
+    'removeListener',
+    common.mustCall((name, cb) => {
       assert.strictEqual(name, 'hello');
-      assert.strictEqual(cb, listener2);
+      assert.strictEqual(cb, listener1);
+      assert.deepStrictEqual([listener2], ee.listeners('hello'));
+      ee.once(
+        'removeListener',
+        common.mustCall((name, cb) => {
+          assert.strictEqual(name, 'hello');
+          assert.strictEqual(cb, listener2);
+          assert.deepStrictEqual([], ee.listeners('hello'));
+        })
+      );
+      ee.removeListener('hello', listener2);
       assert.deepStrictEqual([], ee.listeners('hello'));
-    }));
-    ee.removeListener('hello', listener2);
-    assert.deepStrictEqual([], ee.listeners('hello'));
-  }));
+    })
+  );
   ee.removeListener('hello', listener1);
   assert.deepStrictEqual([], ee.listeners('hello'));
 }
@@ -130,10 +148,13 @@ function listener2() {}
   const ee = new EventEmitter();
 
   ee.once('hello', listener1);
-  ee.on('removeListener', common.mustCall((eventName, listener) => {
-    assert.strictEqual(eventName, 'hello');
-    assert.strictEqual(listener, listener1);
-  }));
+  ee.on(
+    'removeListener',
+    common.mustCall((eventName, listener) => {
+      assert.strictEqual(eventName, 'hello');
+      assert.strictEqual(listener, listener1);
+    })
+  );
   ee.emit('hello');
 }
 
@@ -144,15 +165,19 @@ function listener2() {}
 }
 
 // Verify that the removed listener must be a function
-common.expectsError(() => {
-  const ee = new EventEmitter();
-  ee.removeListener('foo', null);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "listener" argument must be of type Function. ' +
-           'Received type object'
-});
+common.expectsError(
+  () => {
+    const ee = new EventEmitter();
+    ee.removeListener('foo', null);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "listener" argument must be of type Function. ' +
+      'Received type object'
+  }
+);
 
 {
   const ee = new EventEmitter();
diff --git a/test/parallel/test-event-emitter-special-event-names.js b/test/parallel/test-event-emitter-special-event-names.js
index 7ff781f0f90c5a..d903d6c9e025d4 100644
--- a/test/parallel/test-event-emitter-special-event-names.js
+++ b/test/parallel/test-event-emitter-special-event-names.js
@@ -26,12 +26,18 @@ assert.deepStrictEqual(ee.listeners('__proto__'), [handler]);
 assert.deepStrictEqual(ee.listeners('__defineGetter__'), [handler]);
 assert.deepStrictEqual(ee.listeners('toString'), [handler]);
 
-ee.on('__proto__', common.mustCall(function(val) {
-  assert.strictEqual(val, 1);
-}));
+ee.on(
+  '__proto__',
+  common.mustCall(function(val) {
+    assert.strictEqual(val, 1);
+  })
+);
 ee.emit('__proto__', 1);
 
-process.on('__proto__', common.mustCall(function(val) {
-  assert.strictEqual(val, 1);
-}));
+process.on(
+  '__proto__',
+  common.mustCall(function(val) {
+    assert.strictEqual(val, 1);
+  })
+);
 process.emit('__proto__', 1);
diff --git a/test/parallel/test-event-emitter-subclass.js b/test/parallel/test-event-emitter-subclass.js
index 094565197bd740..8bc0843e948159 100644
--- a/test/parallel/test-event-emitter-subclass.js
+++ b/test/parallel/test-event-emitter-subclass.js
@@ -53,7 +53,6 @@ process.on('exit', function() {
   console.log('ok');
 });
 
-
 function MyEE2() {
   EventEmitter.call(this);
 }
diff --git a/test/parallel/test-events-uncaught-exception-stack.js b/test/parallel/test-events-uncaught-exception-stack.js
index c55322a5aa56c4..4544f8768b57eb 100644
--- a/test/parallel/test-events-uncaught-exception-stack.js
+++ b/test/parallel/test-events-uncaught-exception-stack.js
@@ -5,12 +5,15 @@ const EventEmitter = require('events');
 
 // Tests that the error stack where the exception was thrown is *not* appended.
 
-process.on('uncaughtException', common.mustCall((err) => {
-  const lines = err.stack.split('\n');
-  assert.strictEqual(lines[0], 'Error');
-  lines.slice(1).forEach((line) => {
-    assert(/^    at/.test(line), `${line} has an unexpected format`);
-  });
-}));
+process.on(
+  'uncaughtException',
+  common.mustCall((err) => {
+    const lines = err.stack.split('\n');
+    assert.strictEqual(lines[0], 'Error');
+    lines.slice(1).forEach((line) => {
+      assert(/^    at/.test(line), `${line} has an unexpected format`);
+    });
+  })
+);
 
 new EventEmitter().emit('error', new Error());
diff --git a/test/parallel/test-exception-handler.js b/test/parallel/test-exception-handler.js
index ca25ccd6effcaa..17a63fbf13cbc6 100644
--- a/test/parallel/test-exception-handler.js
+++ b/test/parallel/test-exception-handler.js
@@ -25,15 +25,21 @@ const assert = require('assert');
 
 const MESSAGE = 'catch me if you can';
 
-process.on('uncaughtException', common.mustCall((e) => {
-  console.log('uncaught exception! 1');
-  assert.strictEqual(MESSAGE, e.message);
-}));
+process.on(
+  'uncaughtException',
+  common.mustCall((e) => {
+    console.log('uncaught exception! 1');
+    assert.strictEqual(MESSAGE, e.message);
+  })
+);
 
-process.on('uncaughtException', common.mustCall((e) => {
-  console.log('uncaught exception! 2');
-  assert.strictEqual(MESSAGE, e.message);
-}));
+process.on(
+  'uncaughtException',
+  common.mustCall((e) => {
+    console.log('uncaught exception! 2');
+    assert.strictEqual(MESSAGE, e.message);
+  })
+);
 
 setTimeout(() => {
   throw new Error(MESSAGE);
diff --git a/test/parallel/test-exception-handler2.js b/test/parallel/test-exception-handler2.js
index ae95d4524577c8..7e4926aaaa936f 100644
--- a/test/parallel/test-exception-handler2.js
+++ b/test/parallel/test-exception-handler2.js
@@ -27,9 +27,12 @@ process.on('uncaughtException', function(err) {
   console.log(`Caught exception: ${err}`);
 });
 
-setTimeout(common.mustCall(function() {
-  console.log('This will still run.');
-}), 50);
+setTimeout(
+  common.mustCall(function() {
+    console.log('This will still run.');
+  }),
+  50
+);
 
 // Intentionally cause an exception, but don't catch it.
 nonexistentFunc(); // eslint-disable-line no-undef
diff --git a/test/parallel/test-file-read-noexist.js b/test/parallel/test-file-read-noexist.js
index 7293113f22a1a0..69086b60e05ab9 100644
--- a/test/parallel/test-file-read-noexist.js
+++ b/test/parallel/test-file-read-noexist.js
@@ -26,7 +26,11 @@ const assert = require('assert');
 const fs = require('fs');
 
 const filename = fixtures.path('does_not_exist.txt');
-fs.readFile(filename, 'latin1', common.mustCall(function(err, content) {
-  assert.ok(err);
-  assert.strictEqual(err.code, 'ENOENT');
-}));
+fs.readFile(
+  filename,
+  'latin1',
+  common.mustCall(function(err, content) {
+    assert.ok(err);
+    assert.strictEqual(err.code, 'ENOENT');
+  })
+);
diff --git a/test/parallel/test-file-write-stream2.js b/test/parallel/test-file-write-stream2.js
index e29bd80ebf792c..a53c2422acc8cb 100644
--- a/test/parallel/test-file-write-stream2.js
+++ b/test/parallel/test-file-write-stream2.js
@@ -28,7 +28,6 @@ const fs = require('fs');
 
 const tmpdir = require('../common/tmpdir');
 
-
 const filepath = path.join(tmpdir.path, 'write.txt');
 
 const EXPECTED = '012345678910';
@@ -38,7 +37,6 @@ let cb_occurred = '';
 
 let countDrains = 0;
 
-
 process.on('exit', function() {
   removeTestFile();
   if (cb_occurred !== cb_expected) {
@@ -46,8 +44,10 @@ process.on('exit', function() {
     console.log(`    expected: ${cb_expected}`);
     console.log(`    occurred: ${cb_occurred}`);
     assert.strictEqual(
-      cb_occurred, cb_expected,
-      `events missing or out of order: "${cb_occurred}" !== "${cb_expected}"`);
+      cb_occurred,
+      cb_expected,
+      `events missing or out of order: "${cb_occurred}" !== "${cb_expected}"`
+    );
   } else {
     console.log('ok');
   }
@@ -59,7 +59,6 @@ function removeTestFile() {
   } catch {}
 }
 
-
 tmpdir.refresh();
 
 // drain at 0, return false at 10.
@@ -95,13 +94,11 @@ file.on('close', function() {
   file.write('should not work anymore');
 });
 
-
 file.on('error', function(err) {
   cb_occurred += 'error ';
   assert.ok(err.message.includes('write after end'));
 });
 
-
 for (let i = 0; i < 11; i++) {
   const ret = file.write(String(i));
   console.error(`${i} ${ret}`);
diff --git a/test/parallel/test-file-write-stream3.js b/test/parallel/test-file-write-stream3.js
index db16318a5cde0e..439d6d3cfebefd 100644
--- a/test/parallel/test-file-write-stream3.js
+++ b/test/parallel/test-file-write-stream3.js
@@ -27,10 +27,8 @@ const fs = require('fs');
 
 const tmpdir = require('../common/tmpdir');
 
-
 const filepath = path.join(tmpdir.path, 'write_pos.txt');
 
-
 const cb_expected = 'write open close write open close write open close ';
 let cb_occurred = '';
 
@@ -40,22 +38,21 @@ const fileDataExpected_1 = 'abcdefghijklmnopqrstuvwxyz';
 const fileDataExpected_2 = 'abcdefghij123456qrstuvwxyz';
 const fileDataExpected_3 = 'abcdefghij\u2026\u2026qrstuvwxyz';
 
-
 process.on('exit', function() {
   if (cb_occurred !== cb_expected) {
     console.log('  Test callback events missing or out of order:');
     console.log(`    expected: ${cb_expected}`);
     console.log(`    occurred: ${cb_occurred}`);
     assert.strictEqual(
-      cb_occurred, cb_expected,
-      `events missing or out of order: "${cb_occurred}" !== "${cb_expected}"`);
+      cb_occurred,
+      cb_expected,
+      `events missing or out of order: "${cb_occurred}" !== "${cb_expected}"`
+    );
   }
 });
 
-
 tmpdir.refresh();
 
-
 function run_test_1() {
   const options = {};
   const file = fs.createWriteStream(filepath, options);
@@ -93,13 +90,10 @@ function run_test_1() {
   file.end();
 }
 
-
 function run_test_2() {
-
   const buffer = Buffer.from('123456');
 
-  const options = { start: 10,
-                    flags: 'r+' };
+  const options = { start: 10, flags: 'r+' };
   const file = fs.createWriteStream(filepath, options);
   console.log('    (debug: start         ', file.start);
   console.log('    (debug: pos           ', file.pos);
@@ -134,13 +128,10 @@ function run_test_2() {
   file.end();
 }
 
-
 function run_test_3() {
+  const data = '\u2026\u2026'; // 3 bytes * 2 = 6 bytes in UTF-8
 
-  const data = '\u2026\u2026';    // 3 bytes * 2 = 6 bytes in UTF-8
-
-  const options = { start: 10,
-                    flags: 'r+' };
+  const options = { start: 10, flags: 'r+' };
   const file = fs.createWriteStream(filepath, options);
   console.log('    (debug: start         ', file.start);
   console.log('    (debug: pos           ', file.pos);
@@ -175,7 +166,6 @@ function run_test_3() {
   file.end();
 }
 
-
 const run_test_4 = common.mustCall(function() {
   //  Error: start must be >= zero
   const fn = () => {
@@ -183,8 +173,9 @@ const run_test_4 = common.mustCall(function() {
   };
   const err = {
     code: 'ERR_OUT_OF_RANGE',
-    message: 'The value of "start" is out of range. ' +
-             'It must be >= 0. Received {start: -5}',
+    message:
+      'The value of "start" is out of range. ' +
+      'It must be >= 0. Received {start: -5}',
     type: RangeError
   };
   common.expectsError(fn, err);
diff --git a/test/parallel/test-fixed-queue.js b/test/parallel/test-fixed-queue.js
index a50be1309a5ea8..6369973d493155 100644
--- a/test/parallel/test-fixed-queue.js
+++ b/test/parallel/test-fixed-queue.js
@@ -18,15 +18,13 @@ const FixedQueue = require('internal/fixed_queue');
 
 {
   const queue = new FixedQueue();
-  for (let i = 0; i < 2047; i++)
-    queue.push('a');
+  for (let i = 0; i < 2047; i++) queue.push('a');
   assert(queue.head.isFull());
   queue.push('a');
   assert(!queue.head.isFull());
 
   assert.notStrictEqual(queue.head, queue.tail);
-  for (let i = 0; i < 2047; i++)
-    assert.strictEqual(queue.shift(), 'a');
+  for (let i = 0; i < 2047; i++) assert.strictEqual(queue.shift(), 'a');
   assert.strictEqual(queue.head, queue.tail);
   assert(!queue.isEmpty());
   assert.strictEqual(queue.shift(), 'a');
diff --git a/test/parallel/test-force-repl.js b/test/parallel/test-force-repl.js
index 15475a7e30ed8d..b871c90805c1c8 100644
--- a/test/parallel/test-force-repl.js
+++ b/test/parallel/test-force-repl.js
@@ -9,7 +9,10 @@ const cp = spawn(process.execPath, ['-i']);
 
 cp.stdout.setEncoding('utf8');
 
-cp.stdout.once('data', common.mustCall(function(b) {
-  assert.strictEqual(b, '> ');
-  cp.kill();
-}));
+cp.stdout.once(
+  'data',
+  common.mustCall(function(b) {
+    assert.strictEqual(b, '> ');
+    cp.kill();
+  })
+);
diff --git a/test/parallel/test-fs-access.js b/test/parallel/test-fs-access.js
index d0f730f25e12dd..302a68f0bd7725 100644
--- a/test/parallel/test-fs-access.js
+++ b/test/parallel/test-fs-access.js
@@ -55,8 +55,7 @@ if (!common.isWindows && process.getuid() === 0) {
   try {
     process.setuid('nobody');
     hasWriteAccessForReadonlyFile = false;
-  } catch {
-  }
+  } catch {}
 }
 
 assert.strictEqual(typeof fs.F_OK, 'number');
@@ -64,24 +63,42 @@ assert.strictEqual(typeof fs.R_OK, 'number');
 assert.strictEqual(typeof fs.W_OK, 'number');
 assert.strictEqual(typeof fs.X_OK, 'number');
 
-const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
+const throwNextTick = (e) => {
+  process.nextTick(() => {
+    throw e;
+  });
+};
 
-fs.access(__filename, common.mustCall(function(...args) {
-  assert.deepStrictEqual(args, [null]);
-}));
-fs.promises.access(__filename)
+fs.access(
+  __filename,
+  common.mustCall(function(...args) {
+    assert.deepStrictEqual(args, [null]);
+  })
+);
+fs.promises
+  .access(__filename)
   .then(common.mustCall())
   .catch(throwNextTick);
-fs.access(__filename, fs.R_OK, common.mustCall(function(...args) {
-  assert.deepStrictEqual(args, [null]);
-}));
-fs.promises.access(__filename, fs.R_OK)
+fs.access(
+  __filename,
+  fs.R_OK,
+  common.mustCall(function(...args) {
+    assert.deepStrictEqual(args, [null]);
+  })
+);
+fs.promises
+  .access(__filename, fs.R_OK)
   .then(common.mustCall())
   .catch(throwNextTick);
-fs.access(readOnlyFile, fs.F_OK | fs.R_OK, common.mustCall(function(...args) {
-  assert.deepStrictEqual(args, [null]);
-}));
-fs.promises.access(readOnlyFile, fs.F_OK | fs.R_OK)
+fs.access(
+  readOnlyFile,
+  fs.F_OK | fs.R_OK,
+  common.mustCall(function(...args) {
+    assert.deepStrictEqual(args, [null]);
+  })
+);
+fs.promises
+  .access(readOnlyFile, fs.F_OK | fs.R_OK)
   .then(common.mustCall())
   .catch(throwNextTick);
 
@@ -92,7 +109,8 @@ fs.promises.access(readOnlyFile, fs.F_OK | fs.R_OK)
     assert.strictEqual(err.path, doesNotExist);
   };
   fs.access(doesNotExist, common.mustCall(expectedError));
-  fs.promises.access(doesNotExist)
+  fs.promises
+    .access(doesNotExist)
     .then(common.mustNotCall(), common.mustCall(expectedError))
     .catch(throwNextTick);
 }
@@ -108,7 +126,8 @@ fs.promises.access(readOnlyFile, fs.F_OK | fs.R_OK)
     }
   }
   fs.access(readOnlyFile, fs.W_OK, common.mustCall(expectedError));
-  fs.promises.access(readOnlyFile, fs.W_OK)
+  fs.promises
+    .access(readOnlyFile, fs.W_OK)
     .then(common.mustNotCall(), common.mustCall(expectedError))
     .catch(throwNextTick);
 }
@@ -119,12 +138,12 @@ fs.promises.access(readOnlyFile, fs.F_OK | fs.R_OK)
     assert.ok(err instanceof TypeError);
     return true;
   };
-  assert.throws(
-    () => { fs.access(100, fs.F_OK, common.mustNotCall()); },
-    expectedError
-  );
+  assert.throws(() => {
+    fs.access(100, fs.F_OK, common.mustNotCall());
+  }, expectedError);
 
-  fs.promises.access(100, fs.F_OK)
+  fs.promises
+    .access(100, fs.F_OK)
     .then(common.mustNotCall(), common.mustCall(expectedError))
     .catch(throwNextTick);
 }
@@ -136,7 +155,8 @@ common.expectsError(
   {
     code: 'ERR_INVALID_CALLBACK',
     type: TypeError
-  });
+  }
+);
 
 common.expectsError(
   () => {
@@ -145,7 +165,8 @@ common.expectsError(
   {
     code: 'ERR_INVALID_CALLBACK',
     type: TypeError
-  });
+  }
+);
 
 // Regular access should not throw.
 fs.accessSync(__filename);
@@ -153,7 +174,9 @@ const mode = fs.F_OK | fs.R_OK | fs.W_OK;
 fs.accessSync(readWriteFile, mode);
 
 assert.throws(
-  () => { fs.accessSync(doesNotExist); },
+  () => {
+    fs.accessSync(doesNotExist);
+  },
   (err) => {
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.path, doesNotExist);
@@ -169,7 +192,9 @@ assert.throws(
 );
 
 assert.throws(
-  () => { fs.accessSync(Buffer.from(doesNotExist)); },
+  () => {
+    fs.accessSync(Buffer.from(doesNotExist));
+  },
   (err) => {
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.path, doesNotExist);
diff --git a/test/parallel/test-fs-append-file-sync.js b/test/parallel/test-fs-append-file-sync.js
index 90e3f97d8cf252..50d6c12d5fbd6e 100644
--- a/test/parallel/test-fs-append-file-sync.js
+++ b/test/parallel/test-fs-append-file-sync.js
@@ -28,13 +28,14 @@ const fs = require('fs');
 const currentFileData = 'ABCD';
 const m = 0o600;
 const num = 220;
-const data = '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
-             '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
-             '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
-             '前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
-             '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
-             '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
-             '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
+const data =
+  '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
+  '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
+  '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
+  '前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
+  '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
+  '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
+  '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
@@ -56,8 +57,10 @@ fs.appendFileSync(filename2, data);
 
 const fileData2 = fs.readFileSync(filename2);
 
-assert.strictEqual(Buffer.byteLength(data) + currentFileData.length,
-                   fileData2.length);
+assert.strictEqual(
+  Buffer.byteLength(data) + currentFileData.length,
+  fileData2.length
+);
 
 // test that appendFileSync accepts buffers
 const filename3 = join(tmpdir.path, 'append-sync3.txt');
@@ -84,8 +87,10 @@ if (!common.isWindows) {
 
 const fileData4 = fs.readFileSync(filename4);
 
-assert.strictEqual(Buffer.byteLength(String(num)) + currentFileData.length,
-                   fileData4.length);
+assert.strictEqual(
+  Buffer.byteLength(String(num)) + currentFileData.length,
+  fileData4.length
+);
 
 // test that appendFile accepts file descriptors
 const filename5 = join(tmpdir.path, 'append-sync5.txt');
@@ -97,8 +102,10 @@ fs.closeSync(filename5fd);
 
 const fileData5 = fs.readFileSync(filename5);
 
-assert.strictEqual(Buffer.byteLength(data) + currentFileData.length,
-                   fileData5.length);
+assert.strictEqual(
+  Buffer.byteLength(data) + currentFileData.length,
+  fileData5.length
+);
 
 // Exit logic for cleanup
 
diff --git a/test/parallel/test-fs-append-file.js b/test/parallel/test-fs-append-file.js
index 4d8f66682ed634..c7d4a990ae3f41 100644
--- a/test/parallel/test-fs-append-file.js
+++ b/test/parallel/test-fs-append-file.js
@@ -30,37 +30,50 @@ const tmpdir = require('../common/tmpdir');
 const currentFileData = 'ABCD';
 
 const n = 220;
-const s = '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
-          '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
-          '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
-          '前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
-          '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
-          '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
-          '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
+const s =
+  '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
+  '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
+  '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
+  '前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
+  '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
+  '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
+  '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
 
 tmpdir.refresh();
 
-const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
+const throwNextTick = (e) => {
+  process.nextTick(() => {
+    throw e;
+  });
+};
 
 // test that empty file will be created and have content added (callback API)
 {
   const filename = join(tmpdir.path, 'append.txt');
 
-  fs.appendFile(filename, s, common.mustCall(function(e) {
-    assert.ifError(e);
-
-    fs.readFile(filename, common.mustCall(function(e, buffer) {
+  fs.appendFile(
+    filename,
+    s,
+    common.mustCall(function(e) {
       assert.ifError(e);
-      assert.strictEqual(Buffer.byteLength(s), buffer.length);
-    }));
-  }));
+
+      fs.readFile(
+        filename,
+        common.mustCall(function(e, buffer) {
+          assert.ifError(e);
+          assert.strictEqual(Buffer.byteLength(s), buffer.length);
+        })
+      );
+    })
+  );
 }
 
 // test that empty file will be created and have content added (promise API)
 {
   const filename = join(tmpdir.path, 'append-promise.txt');
 
-  fs.promises.appendFile(filename, s)
+  fs.promises
+    .appendFile(filename, s)
     .then(common.mustCall(() => fs.promises.readFile(filename)))
     .then((buffer) => {
       assert.strictEqual(Buffer.byteLength(s), buffer.length);
@@ -73,15 +86,24 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
   const filename = join(tmpdir.path, 'append-non-empty.txt');
   fs.writeFileSync(filename, currentFileData);
 
-  fs.appendFile(filename, s, common.mustCall(function(e) {
-    assert.ifError(e);
-
-    fs.readFile(filename, common.mustCall(function(e, buffer) {
+  fs.appendFile(
+    filename,
+    s,
+    common.mustCall(function(e) {
       assert.ifError(e);
-      assert.strictEqual(Buffer.byteLength(s) + currentFileData.length,
-                         buffer.length);
-    }));
-  }));
+
+      fs.readFile(
+        filename,
+        common.mustCall(function(e, buffer) {
+          assert.ifError(e);
+          assert.strictEqual(
+            Buffer.byteLength(s) + currentFileData.length,
+            buffer.length
+          );
+        })
+      );
+    })
+  );
 }
 
 // test that appends data to a non-empty file (promise API)
@@ -89,11 +111,14 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
   const filename = join(tmpdir.path, 'append-non-empty-promise.txt');
   fs.writeFileSync(filename, currentFileData);
 
-  fs.promises.appendFile(filename, s)
+  fs.promises
+    .appendFile(filename, s)
     .then(common.mustCall(() => fs.promises.readFile(filename)))
     .then((buffer) => {
-      assert.strictEqual(Buffer.byteLength(s) + currentFileData.length,
-                         buffer.length);
+      assert.strictEqual(
+        Buffer.byteLength(s) + currentFileData.length,
+        buffer.length
+      );
     })
     .catch(throwNextTick);
 }
@@ -105,14 +130,24 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
 
   const buf = Buffer.from(s, 'utf8');
 
-  fs.appendFile(filename, buf, common.mustCall((e) => {
-    assert.ifError(e);
-
-    fs.readFile(filename, common.mustCall((e, buffer) => {
+  fs.appendFile(
+    filename,
+    buf,
+    common.mustCall((e) => {
       assert.ifError(e);
-      assert.strictEqual(buf.length + currentFileData.length, buffer.length);
-    }));
-  }));
+
+      fs.readFile(
+        filename,
+        common.mustCall((e, buffer) => {
+          assert.ifError(e);
+          assert.strictEqual(
+            buf.length + currentFileData.length,
+            buffer.length
+          );
+        })
+      );
+    })
+  );
 }
 
 // test that appendFile accepts buffers (promises API)
@@ -122,7 +157,8 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
 
   const buf = Buffer.from(s, 'utf8');
 
-  fs.promises.appendFile(filename, buf)
+  fs.promises
+    .appendFile(filename, buf)
     .then(common.mustCall(() => fs.promises.readFile(filename)))
     .then((buffer) => {
       assert.strictEqual(buf.length + currentFileData.length, buffer.length);
@@ -136,21 +172,31 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
   fs.writeFileSync(filename, currentFileData);
 
   const m = 0o600;
-  fs.appendFile(filename, n, { mode: m }, common.mustCall((e) => {
-    assert.ifError(e);
+  fs.appendFile(
+    filename,
+    n,
+    { mode: m },
+    common.mustCall((e) => {
+      assert.ifError(e);
 
-    // windows permissions aren't unix
-    if (!common.isWindows) {
-      const st = fs.statSync(filename);
-      assert.strictEqual(st.mode & 0o700, m);
-    }
+      // windows permissions aren't unix
+      if (!common.isWindows) {
+        const st = fs.statSync(filename);
+        assert.strictEqual(st.mode & 0o700, m);
+      }
 
-    fs.readFile(filename, common.mustCall((e, buffer) => {
-      assert.ifError(e);
-      assert.strictEqual(Buffer.byteLength(String(n)) + currentFileData.length,
-                         buffer.length);
-    }));
-  }));
+      fs.readFile(
+        filename,
+        common.mustCall((e, buffer) => {
+          assert.ifError(e);
+          assert.strictEqual(
+            Buffer.byteLength(String(n)) + currentFileData.length,
+            buffer.length
+          );
+        })
+      );
+    })
+  );
 }
 
 // test that appendFile accepts numbers (promises API)
@@ -159,19 +205,24 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
   fs.writeFileSync(filename, currentFileData);
 
   const m = 0o600;
-  fs.promises.appendFile(filename, n, { mode: m })
-    .then(common.mustCall(() => {
-      // windows permissions aren't unix
-      if (!common.isWindows) {
-        const st = fs.statSync(filename);
-        assert.strictEqual(st.mode & 0o700, m);
-      }
-
-      return fs.promises.readFile(filename);
-    }))
+  fs.promises
+    .appendFile(filename, n, { mode: m })
+    .then(
+      common.mustCall(() => {
+        // windows permissions aren't unix
+        if (!common.isWindows) {
+          const st = fs.statSync(filename);
+          assert.strictEqual(st.mode & 0o700, m);
+        }
+
+        return fs.promises.readFile(filename);
+      })
+    )
     .then((buffer) => {
-      assert.strictEqual(Buffer.byteLength(String(n)) + currentFileData.length,
-                         buffer.length);
+      assert.strictEqual(
+        Buffer.byteLength(String(n)) + currentFileData.length,
+        buffer.length
+      );
     })
     .catch(throwNextTick);
 }
@@ -181,23 +232,39 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
   const filename = join(tmpdir.path, 'append-descriptors.txt');
   fs.writeFileSync(filename, currentFileData);
 
-  fs.open(filename, 'a+', common.mustCall((e, fd) => {
-    assert.ifError(e);
-
-    fs.appendFile(fd, s, common.mustCall((e) => {
+  fs.open(
+    filename,
+    'a+',
+    common.mustCall((e, fd) => {
       assert.ifError(e);
 
-      fs.close(fd, common.mustCall((e) => {
-        assert.ifError(e);
-
-        fs.readFile(filename, common.mustCall((e, buffer) => {
+      fs.appendFile(
+        fd,
+        s,
+        common.mustCall((e) => {
           assert.ifError(e);
-          assert.strictEqual(Buffer.byteLength(s) + currentFileData.length,
-                             buffer.length);
-        }));
-      }));
-    }));
-  }));
+
+          fs.close(
+            fd,
+            common.mustCall((e) => {
+              assert.ifError(e);
+
+              fs.readFile(
+                filename,
+                common.mustCall((e, buffer) => {
+                  assert.ifError(e);
+                  assert.strictEqual(
+                    Buffer.byteLength(s) + currentFileData.length,
+                    buffer.length
+                  );
+                })
+              );
+            })
+          );
+        })
+      );
+    })
+  );
 }
 
 // test that appendFile accepts file descriptors (promises API)
@@ -206,20 +273,28 @@ const throwNextTick = (e) => { process.nextTick(() => { throw e; }); };
   fs.writeFileSync(filename, currentFileData);
 
   let fd;
-  fs.promises.open(filename, 'a+')
-    .then(common.mustCall((fileDescriptor) => {
-      fd = fileDescriptor;
-      return fs.promises.appendFile(fd, s);
-    }))
+  fs.promises
+    .open(filename, 'a+')
+    .then(
+      common.mustCall((fileDescriptor) => {
+        fd = fileDescriptor;
+        return fs.promises.appendFile(fd, s);
+      })
+    )
     .then(common.mustCall(() => fd.close()))
     .then(common.mustCall(() => fs.promises.readFile(filename)))
-    .then(common.mustCall((buffer) => {
-      assert.strictEqual(Buffer.byteLength(s) + currentFileData.length,
-                         buffer.length);
-    }))
+    .then(
+      common.mustCall((buffer) => {
+        assert.strictEqual(
+          Buffer.byteLength(s) + currentFileData.length,
+          buffer.length
+        );
+      })
+    )
     .catch(throwNextTick);
 }
 
 assert.throws(
   () => fs.appendFile(join(tmpdir.path, 'append6.txt'), console.log),
-  { code: 'ERR_INVALID_CALLBACK' });
+  { code: 'ERR_INVALID_CALLBACK' }
+);
diff --git a/test/parallel/test-fs-assert-encoding-error.js b/test/parallel/test-fs-assert-encoding-error.js
index e50a99d751ef62..741edea93956ea 100644
--- a/test/parallel/test-fs-assert-encoding-error.js
+++ b/test/parallel/test-fs-assert-encoding-error.js
@@ -4,10 +4,13 @@ const assert = require('assert');
 const fs = require('fs');
 
 const options = 'test';
-const expectedError = common.expectsError({
-  code: 'ERR_INVALID_OPT_VALUE_ENCODING',
-  type: TypeError,
-}, 17);
+const expectedError = common.expectsError(
+  {
+    code: 'ERR_INVALID_OPT_VALUE_ENCODING',
+    type: TypeError
+  },
+  17
+);
 
 assert.throws(() => {
   fs.readFile('path', options, common.mustNotCall());
diff --git a/test/parallel/test-fs-buffer.js b/test/parallel/test-fs-buffer.js
index 1e898d3891339a..9d701a5c401042 100644
--- a/test/parallel/test-fs-buffer.js
+++ b/test/parallel/test-fs-buffer.js
@@ -12,11 +12,15 @@ tmpdir.refresh();
 fs.access(Buffer.from(tmpdir.path), common.mustCall(assert.ifError));
 
 const buf = Buffer.from(path.join(tmpdir.path, 'a.txt'));
-fs.open(buf, 'w+', common.mustCall((err, fd) => {
-  assert.ifError(err);
-  assert(fd);
-  fs.close(fd, common.mustCall(assert.ifError));
-}));
+fs.open(
+  buf,
+  'w+',
+  common.mustCall((err, fd) => {
+    assert.ifError(err);
+    assert(fd);
+    fs.close(fd, common.mustCall(assert.ifError));
+  })
+);
 
 common.expectsError(
   () => {
@@ -25,23 +29,33 @@ common.expectsError(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "path" argument must be one of type string, Buffer, or URL.' +
-             ' Received type boolean'
+    message:
+      'The "path" argument must be one of type string, Buffer, or URL.' +
+      ' Received type boolean'
   }
 );
 
 const dir = Buffer.from(fixtures.fixturesDir);
-fs.readdir(dir, 'hex', common.mustCall((err, hexList) => {
-  assert.ifError(err);
-  fs.readdir(dir, common.mustCall((err, stringList) => {
+fs.readdir(
+  dir,
+  'hex',
+  common.mustCall((err, hexList) => {
     assert.ifError(err);
-    stringList.forEach((val, idx) => {
-      const fromHexList = Buffer.from(hexList[idx], 'hex').toString();
-      assert.strictEqual(
-        fromHexList,
-        val,
-        `expected ${val}, got ${fromHexList} by hex decoding ${hexList[idx]}`
-      );
-    });
-  }));
-}));
+    fs.readdir(
+      dir,
+      common.mustCall((err, stringList) => {
+        assert.ifError(err);
+        stringList.forEach((val, idx) => {
+          const fromHexList = Buffer.from(hexList[idx], 'hex').toString();
+          assert.strictEqual(
+            fromHexList,
+            val,
+            `expected ${val}, got ${fromHexList} by hex decoding ${
+              hexList[idx]
+            }`
+          );
+        });
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-fs-chmod-mask.js b/test/parallel/test-fs-chmod-mask.js
index 9564ca142bd643..2c63d8ddb41997 100644
--- a/test/parallel/test-fs-chmod-mask.js
+++ b/test/parallel/test-fs-chmod-mask.js
@@ -10,7 +10,7 @@ const fs = require('fs');
 let mode;
 // On Windows chmod is only able to manipulate write permission
 if (common.isWindows) {
-  mode = 0o444;  // read-only
+  mode = 0o444; // read-only
 } else {
   mode = 0o777;
 }
@@ -22,17 +22,22 @@ tmpdir.refresh();
 
 function test(mode, asString) {
   const suffix = asString ? 'str' : 'num';
-  const input = asString ?
-    (mode | maskToIgnore).toString(8) : (mode | maskToIgnore);
+  const input = asString
+    ? (mode | maskToIgnore).toString(8)
+    : mode | maskToIgnore;
 
   {
     const file = path.join(tmpdir.path, `chmod-async-${suffix}.txt`);
     fs.writeFileSync(file, 'test', 'utf-8');
 
-    fs.chmod(file, input, common.mustCall((err) => {
-      assert.ifError(err);
-      assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
-    }));
+    fs.chmod(
+      file,
+      input,
+      common.mustCall((err) => {
+        assert.ifError(err);
+        assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
+      })
+    );
   }
 
   {
@@ -46,15 +51,23 @@ function test(mode, asString) {
   {
     const file = path.join(tmpdir.path, `fchmod-async-${suffix}.txt`);
     fs.writeFileSync(file, 'test', 'utf-8');
-    fs.open(file, 'w', common.mustCall((err, fd) => {
-      assert.ifError(err);
-
-      fs.fchmod(fd, input, common.mustCall((err) => {
+    fs.open(
+      file,
+      'w',
+      common.mustCall((err, fd) => {
         assert.ifError(err);
-        assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
-        fs.close(fd, assert.ifError);
-      }));
-    }));
+
+        fs.fchmod(
+          fd,
+          input,
+          common.mustCall((err) => {
+            assert.ifError(err);
+            assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
+            fs.close(fd, assert.ifError);
+          })
+        );
+      })
+    );
   }
 
   {
@@ -74,10 +87,14 @@ function test(mode, asString) {
     fs.writeFileSync(file, 'test', 'utf-8');
     fs.symlinkSync(file, link);
 
-    fs.lchmod(link, input, common.mustCall((err) => {
-      assert.ifError(err);
-      assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode);
-    }));
+    fs.lchmod(
+      link,
+      input,
+      common.mustCall((err) => {
+        assert.ifError(err);
+        assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode);
+      })
+    );
   }
 
   if (fs.lchmodSync) {
diff --git a/test/parallel/test-fs-chmod.js b/test/parallel/test-fs-chmod.js
index c3b3dc2fc9c151..75b174abd86bd2 100644
--- a/test/parallel/test-fs-chmod.js
+++ b/test/parallel/test-fs-chmod.js
@@ -61,11 +61,10 @@ function closeSync() {
   return fs._closeSync.apply(fs, arguments);
 }
 
-
 // On Windows chmod is only able to manipulate write permission
 if (common.isWindows) {
-  mode_async = 0o400;   // read-only
-  mode_sync = 0o600;    // read-write
+  mode_async = 0o400; // read-only
+  mode_sync = 0o600; // read-write
 } else {
   mode_async = 0o777;
   mode_sync = 0o644;
@@ -80,55 +79,65 @@ const file2 = path.join(tmpdir.path, 'a1.js');
 // Create file1.
 fs.closeSync(fs.openSync(file1, 'w'));
 
-fs.chmod(file1, mode_async.toString(8), common.mustCall((err) => {
-  assert.ifError(err);
-
-  if (common.isWindows) {
-    assert.ok((fs.statSync(file1).mode & 0o777) & mode_async);
-  } else {
-    assert.strictEqual(fs.statSync(file1).mode & 0o777, mode_async);
-  }
-
-  fs.chmodSync(file1, mode_sync);
-  if (common.isWindows) {
-    assert.ok((fs.statSync(file1).mode & 0o777) & mode_sync);
-  } else {
-    assert.strictEqual(fs.statSync(file1).mode & 0o777, mode_sync);
-  }
-}));
-
-fs.open(file2, 'w', common.mustCall((err, fd) => {
-  assert.ifError(err);
-
-  fs.fchmod(fd, mode_async.toString(8), common.mustCall((err) => {
+fs.chmod(
+  file1,
+  mode_async.toString(8),
+  common.mustCall((err) => {
     assert.ifError(err);
 
     if (common.isWindows) {
-      assert.ok((fs.fstatSync(fd).mode & 0o777) & mode_async);
+      assert.ok(fs.statSync(file1).mode & 0o777 & mode_async);
     } else {
-      assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode_async);
+      assert.strictEqual(fs.statSync(file1).mode & 0o777, mode_async);
     }
 
-    common.expectsError(
-      () => fs.fchmod(fd, {}),
-      {
-        code: 'ERR_INVALID_ARG_VALUE',
-        type: TypeError,
-        message: 'The argument \'mode\' must be a 32-bit unsigned integer ' +
-                 'or an octal string. Received {}'
-      }
-    );
-
-    fs.fchmodSync(fd, mode_sync);
+    fs.chmodSync(file1, mode_sync);
     if (common.isWindows) {
-      assert.ok((fs.fstatSync(fd).mode & 0o777) & mode_sync);
+      assert.ok(fs.statSync(file1).mode & 0o777 & mode_sync);
     } else {
-      assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode_sync);
+      assert.strictEqual(fs.statSync(file1).mode & 0o777, mode_sync);
     }
+  })
+);
+
+fs.open(
+  file2,
+  'w',
+  common.mustCall((err, fd) => {
+    assert.ifError(err);
 
-    fs.close(fd, assert.ifError);
-  }));
-}));
+    fs.fchmod(
+      fd,
+      mode_async.toString(8),
+      common.mustCall((err) => {
+        assert.ifError(err);
+
+        if (common.isWindows) {
+          assert.ok(fs.fstatSync(fd).mode & 0o777 & mode_async);
+        } else {
+          assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode_async);
+        }
+
+        common.expectsError(() => fs.fchmod(fd, {}), {
+          code: 'ERR_INVALID_ARG_VALUE',
+          type: TypeError,
+          message:
+            "The argument 'mode' must be a 32-bit unsigned integer " +
+            'or an octal string. Received {}'
+        });
+
+        fs.fchmodSync(fd, mode_sync);
+        if (common.isWindows) {
+          assert.ok(fs.fstatSync(fd).mode & 0o777 & mode_sync);
+        } else {
+          assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode_sync);
+        }
+
+        fs.close(fd, assert.ifError);
+      })
+    );
+  })
+);
 
 // lchmod
 if (fs.lchmod) {
@@ -136,23 +145,27 @@ if (fs.lchmod) {
 
   fs.symlinkSync(file2, link);
 
-  fs.lchmod(link, mode_async, common.mustCall((err) => {
-    assert.ifError(err);
-
-    assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode_async);
+  fs.lchmod(
+    link,
+    mode_async,
+    common.mustCall((err) => {
+      assert.ifError(err);
 
-    fs.lchmodSync(link, mode_sync);
-    assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode_sync);
+      assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode_async);
 
-  }));
+      fs.lchmodSync(link, mode_sync);
+      assert.strictEqual(fs.lstatSync(link).mode & 0o777, mode_sync);
+    })
+  );
 }
 
 ['', false, null, undefined, {}, []].forEach((input) => {
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "fd" argument must be of type number. ' +
-             `Received type ${typeof input}`
+    message:
+      'The "fd" argument must be of type number. ' +
+      `Received type ${typeof input}`
   };
   assert.throws(() => fs.fchmod(input, 0o000), errObj);
   assert.throws(() => fs.fchmodSync(input, 0o000), errObj);
@@ -162,8 +175,9 @@ if (fs.lchmod) {
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "path" argument must be one of type string, Buffer, or URL.' +
-             ` Received type ${typeof input}`
+    message:
+      'The "path" argument must be one of type string, Buffer, or URL.' +
+      ` Received type ${typeof input}`
   };
   assert.throws(() => fs.chmod(input, 1, common.mustNotCall()), errObj);
   assert.throws(() => fs.chmodSync(input, 1), errObj);
diff --git a/test/parallel/test-fs-chown-type-check.js b/test/parallel/test-fs-chown-type-check.js
index 897c3e1de2d7e2..6049acc45c6fe8 100644
--- a/test/parallel/test-fs-chown-type-check.js
+++ b/test/parallel/test-fs-chown-type-check.js
@@ -4,20 +4,14 @@ const common = require('../common');
 const fs = require('fs');
 
 [false, 1, {}, [], null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.chown(i, 1, 1, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.chownSync(i, 1, 1),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.chown(i, 1, 1, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.chownSync(i, 1, 1), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
 
 [false, 'test', {}, [], null, undefined].forEach((i) => {
@@ -35,18 +29,12 @@ const fs = require('fs');
       type: TypeError
     }
   );
-  common.expectsError(
-    () => fs.chownSync('not_a_file_that_exists', i, 1),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.chownSync('not_a_file_that_exists', 1, i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.chownSync('not_a_file_that_exists', i, 1), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.chownSync('not_a_file_that_exists', 1, i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-fs-close-errors.js b/test/parallel/test-fs-close-errors.js
index 48af5eb4856d5f..5ee045f106b017 100644
--- a/test/parallel/test-fs-close-errors.js
+++ b/test/parallel/test-fs-close-errors.js
@@ -11,8 +11,9 @@ const fs = require('fs');
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "fd" argument must be of type number. ' +
-             `Received type ${typeof input}`
+    message:
+      'The "fd" argument must be of type number. ' +
+      `Received type ${typeof input}`
   };
   assert.throws(() => fs.close(input), errObj);
   assert.throws(() => fs.closeSync(input), errObj);
diff --git a/test/parallel/test-fs-close.js b/test/parallel/test-fs-close.js
index da0d0dfdc832d8..94685160273f95 100644
--- a/test/parallel/test-fs-close.js
+++ b/test/parallel/test-fs-close.js
@@ -7,6 +7,9 @@ const fs = require('fs');
 
 const fd = fs.openSync(__filename, 'r');
 
-fs.close(fd, common.mustCall(function(...args) {
-  assert.deepStrictEqual(args, [null]);
-}));
+fs.close(
+  fd,
+  common.mustCall(function(...args) {
+    assert.deepStrictEqual(args, [null]);
+  })
+);
diff --git a/test/parallel/test-fs-copyfile.js b/test/parallel/test-fs-copyfile.js
index 90e7c7009d1680..26d2739811d1f9 100644
--- a/test/parallel/test-fs-copyfile.js
+++ b/test/parallel/test-fs-copyfile.js
@@ -6,10 +6,7 @@ const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
 const fs = require('fs');
 const { internalBinding } = require('internal/test/binding');
-const {
-  UV_ENOENT,
-  UV_EEXIST
-} = internalBinding('uv');
+const { UV_ENOENT, UV_EEXIST } = internalBinding('uv');
 const path = require('path');
 const src = fixtures.path('a.js');
 const dest = path.join(tmpdir.path, 'copyfile.out');
@@ -68,74 +65,82 @@ try {
   verify(src, dest);
 } catch (err) {
   assert.strictEqual(err.syscall, 'copyfile');
-  assert(err.code === 'ENOTSUP' || err.code === 'ENOTTY' ||
-    err.code === 'ENOSYS' || err.code === 'EXDEV');
+  assert(
+    err.code === 'ENOTSUP' ||
+      err.code === 'ENOTTY' ||
+      err.code === 'ENOSYS' ||
+      err.code === 'EXDEV'
+  );
   assert.strictEqual(err.path, src);
   assert.strictEqual(err.dest, dest);
 }
 
 // Copies asynchronously.
 tmpdir.refresh(); // Don't use unlinkSync() since the last test may fail.
-fs.copyFile(src, dest, common.mustCall((err) => {
-  assert.ifError(err);
-  verify(src, dest);
+fs.copyFile(
+  src,
+  dest,
+  common.mustCall((err) => {
+    assert.ifError(err);
+    verify(src, dest);
 
-  // Copy asynchronously with flags.
-  fs.copyFile(src, dest, COPYFILE_EXCL, common.mustCall((err) => {
-    if (err.code === 'ENOENT') {  // Could be ENOENT or EEXIST
-      assert.strictEqual(err.message,
-                         'ENOENT: no such file or directory, copyfile ' +
-                         `'${src}' -> '${dest}'`);
-      assert.strictEqual(err.errno, UV_ENOENT);
-      assert.strictEqual(err.code, 'ENOENT');
-      assert.strictEqual(err.syscall, 'copyfile');
-    } else {
-      assert.strictEqual(err.message,
-                         'EEXIST: file already exists, copyfile ' +
-                         `'${src}' -> '${dest}'`);
-      assert.strictEqual(err.errno, UV_EEXIST);
-      assert.strictEqual(err.code, 'EEXIST');
-      assert.strictEqual(err.syscall, 'copyfile');
-    }
-  }));
-}));
+    // Copy asynchronously with flags.
+    fs.copyFile(
+      src,
+      dest,
+      COPYFILE_EXCL,
+      common.mustCall((err) => {
+        if (err.code === 'ENOENT') {
+          // Could be ENOENT or EEXIST
+          assert.strictEqual(
+            err.message,
+            'ENOENT: no such file or directory, copyfile ' +
+              `'${src}' -> '${dest}'`
+          );
+          assert.strictEqual(err.errno, UV_ENOENT);
+          assert.strictEqual(err.code, 'ENOENT');
+          assert.strictEqual(err.syscall, 'copyfile');
+        } else {
+          assert.strictEqual(
+            err.message,
+            'EEXIST: file already exists, copyfile ' + `'${src}' -> '${dest}'`
+          );
+          assert.strictEqual(err.errno, UV_EEXIST);
+          assert.strictEqual(err.code, 'EEXIST');
+          assert.strictEqual(err.syscall, 'copyfile');
+        }
+      })
+    );
+  })
+);
 
 // Throws if callback is not a function.
-common.expectsError(() => {
-  fs.copyFile(src, dest, 0, 0);
-}, {
-  code: 'ERR_INVALID_CALLBACK',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    fs.copyFile(src, dest, 0, 0);
+  },
+  {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError
+  }
+);
 
 // Throws if the source path is not a string.
 [false, 1, {}, [], null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.copyFile(i, dest, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.copyFile(src, i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.copyFileSync(i, dest),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.copyFileSync(src, i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.copyFile(i, dest, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.copyFile(src, i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.copyFileSync(i, dest), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.copyFileSync(src, i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-fs-empty-readStream.js b/test/parallel/test-fs-empty-readStream.js
index a5de2ab80bcf10..41a642a2021a93 100644
--- a/test/parallel/test-fs-empty-readStream.js
+++ b/test/parallel/test-fs-empty-readStream.js
@@ -27,30 +27,39 @@ const fixtures = require('../common/fixtures');
 
 const emptyFile = fixtures.path('empty.txt');
 
-fs.open(emptyFile, 'r', common.mustCall((error, fd) => {
+fs.open(
+  emptyFile,
+  'r',
+  common.mustCall((error, fd) => {
+    assert.ifError(error);
 
-  assert.ifError(error);
+    const read = fs.createReadStream(emptyFile, { fd });
 
-  const read = fs.createReadStream(emptyFile, { fd });
+    read.once('data', common.mustNotCall('data event should not emit'));
 
-  read.once('data', common.mustNotCall('data event should not emit'));
+    read.once('end', common.mustCall());
+  })
+);
 
-  read.once('end', common.mustCall());
-}));
+fs.open(
+  emptyFile,
+  'r',
+  common.mustCall((error, fd) => {
+    assert.ifError(error);
 
-fs.open(emptyFile, 'r', common.mustCall((error, fd) => {
+    const read = fs.createReadStream(emptyFile, { fd });
 
-  assert.ifError(error);
+    read.pause();
 
-  const read = fs.createReadStream(emptyFile, { fd });
+    read.once('data', common.mustNotCall('data event should not emit'));
 
-  read.pause();
+    read.once('end', common.mustNotCall('end event should not emit'));
 
-  read.once('data', common.mustNotCall('data event should not emit'));
-
-  read.once('end', common.mustNotCall('end event should not emit'));
-
-  setTimeout(common.mustCall(() => {
-    assert.strictEqual(read.isPaused(), true);
-  }), common.platformTimeout(50));
-}));
+    setTimeout(
+      common.mustCall(() => {
+        assert.strictEqual(read.isPaused(), true);
+      }),
+      common.platformTimeout(50)
+    );
+  })
+);
diff --git a/test/parallel/test-fs-error-messages.js b/test/parallel/test-fs-error-messages.js
index 96ff606cccec4e..dafc480cdc3a6a 100644
--- a/test/parallel/test-fs-error-messages.js
+++ b/test/parallel/test-fs-error-messages.js
@@ -30,7 +30,6 @@ const path = require('path');
 
 tmpdir.refresh();
 
-
 const nonexistentFile = path.join(tmpdir.path, 'non-existent');
 const nonexistentDir = path.join(tmpdir.path, 'non-existent', 'foo', 'bar');
 const existingFile = path.join(tmpdir.path, 'existingFile.js');
@@ -41,7 +40,6 @@ fs.mkdirSync(existingDir);
 fs.writeFileSync(existingFile, 'test', 'utf-8');
 fs.writeFileSync(existingFile2, 'test', 'utf-8');
 
-
 const { COPYFILE_EXCL } = fs.constants;
 const { internalBinding } = require('internal/test/binding');
 const {
@@ -72,7 +70,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, stat '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, stat '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'stat');
@@ -81,10 +80,7 @@ function re(literals, ...values) {
 
   fs.stat(nonexistentFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.statSync(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.statSync(nonexistentFile), validateError);
 }
 
 // lstat
@@ -93,7 +89,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, lstat '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, lstat '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'lstat');
@@ -101,10 +98,7 @@ function re(literals, ...values) {
   };
 
   fs.lstat(nonexistentFile, common.mustCall(validateError));
-  assert.throws(
-    () => fs.lstatSync(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.lstatSync(nonexistentFile), validateError);
 }
 
 // fstat
@@ -120,10 +114,7 @@ function re(literals, ...values) {
   common.runWithInvalidFD((fd) => {
     fs.fstat(fd, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.fstatSync(fd),
-      validateError
-    );
+    assert.throws(() => fs.fstatSync(fd), validateError);
   });
 }
 
@@ -133,7 +124,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, lstat '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, lstat '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'lstat');
@@ -142,10 +134,7 @@ function re(literals, ...values) {
 
   fs.realpath(nonexistentFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.realpathSync(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.realpathSync(nonexistentFile), validateError);
 }
 
 // native realpath
@@ -154,7 +143,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, realpath '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, realpath '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'realpath');
@@ -163,10 +153,7 @@ function re(literals, ...values) {
 
   fs.realpath.native(nonexistentFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.realpathSync.native(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.realpathSync.native(nonexistentFile), validateError);
 }
 
 // readlink
@@ -175,7 +162,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, readlink '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, readlink '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'readlink');
@@ -184,10 +172,7 @@ function re(literals, ...values) {
 
   fs.readlink(nonexistentFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.readlinkSync(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.readlinkSync(nonexistentFile), validateError);
 }
 
 // link nonexistent file
@@ -195,12 +180,16 @@ function re(literals, ...values) {
   const validateError = (err) => {
     assert.strictEqual(nonexistentFile, err.path);
     // Could be resolved to an absolute path
-    assert.ok(err.dest.endsWith('foo'),
-              `expect ${err.dest} to end with 'foo'`);
-    const regexp = new RegExp('^ENOENT: no such file or directory, link ' +
-                              re`'${nonexistentFile}' -> ` + '\'.*foo\'');
-    assert.ok(regexp.test(err.message),
-              `Expect ${err.message} to match ${regexp}`);
+    assert.ok(err.dest.endsWith('foo'), `expect ${err.dest} to end with 'foo'`);
+    const regexp = new RegExp(
+      '^ENOENT: no such file or directory, link ' +
+        re`'${nonexistentFile}' -> ` +
+        "'.*foo'"
+    );
+    assert.ok(
+      regexp.test(err.message),
+      `Expect ${err.message} to match ${regexp}`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'link');
@@ -209,10 +198,7 @@ function re(literals, ...values) {
 
   fs.link(nonexistentFile, 'foo', common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.linkSync(nonexistentFile, 'foo'),
-    validateError
-  );
+  assert.throws(() => fs.linkSync(nonexistentFile, 'foo'), validateError);
 }
 
 // link existing file
@@ -223,7 +209,8 @@ function re(literals, ...values) {
     assert.strictEqual(
       err.message,
       `EEXIST: file already exists, link '${existingFile}' -> ` +
-      `'${existingFile2}'`);
+        `'${existingFile2}'`
+    );
     assert.strictEqual(err.errno, UV_EEXIST);
     assert.strictEqual(err.code, 'EEXIST');
     assert.strictEqual(err.syscall, 'link');
@@ -232,10 +219,7 @@ function re(literals, ...values) {
 
   fs.link(existingFile, existingFile2, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.linkSync(existingFile, existingFile2),
-    validateError
-  );
+  assert.throws(() => fs.linkSync(existingFile, existingFile2), validateError);
 }
 
 // symlink
@@ -246,7 +230,8 @@ function re(literals, ...values) {
     assert.strictEqual(
       err.message,
       `EEXIST: file already exists, symlink '${existingFile}' -> ` +
-      `'${existingFile2}'`);
+        `'${existingFile2}'`
+    );
     assert.strictEqual(err.errno, UV_EEXIST);
     assert.strictEqual(err.code, 'EEXIST');
     assert.strictEqual(err.syscall, 'symlink');
@@ -267,7 +252,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, unlink '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, unlink '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'unlink');
@@ -276,10 +262,7 @@ function re(literals, ...values) {
 
   fs.unlink(nonexistentFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.unlinkSync(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.unlinkSync(nonexistentFile), validateError);
 }
 
 // rename
@@ -287,12 +270,16 @@ function re(literals, ...values) {
   const validateError = (err) => {
     assert.strictEqual(nonexistentFile, err.path);
     // Could be resolved to an absolute path
-    assert.ok(err.dest.endsWith('foo'),
-              `expect ${err.dest} to end with 'foo'`);
-    const regexp = new RegExp('ENOENT: no such file or directory, rename ' +
-                              re`'${nonexistentFile}' -> ` + '\'.*foo\'');
-    assert.ok(regexp.test(err.message),
-              `Expect ${err.message} to match ${regexp}`);
+    assert.ok(err.dest.endsWith('foo'), `expect ${err.dest} to end with 'foo'`);
+    const regexp = new RegExp(
+      'ENOENT: no such file or directory, rename ' +
+        re`'${nonexistentFile}' -> ` +
+        "'.*foo'"
+    );
+    assert.ok(
+      regexp.test(err.message),
+      `Expect ${err.message} to match ${regexp}`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'rename');
@@ -301,10 +288,7 @@ function re(literals, ...values) {
 
   fs.rename(nonexistentFile, 'foo', common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.renameSync(nonexistentFile, 'foo'),
-    validateError
-  );
+  assert.throws(() => fs.renameSync(nonexistentFile, 'foo'), validateError);
 }
 
 // rename non-empty directory
@@ -318,24 +302,31 @@ function re(literals, ...values) {
       assert.strictEqual(
         err.message,
         `ENOTEMPTY: directory not empty, rename '${existingDir}' -> ` +
-        `'${existingDir2}'`);
+          `'${existingDir2}'`
+      );
       assert.strictEqual(err.errno, UV_ENOTEMPTY);
-    } else if (err.code === 'EXDEV') {  // not on the same mounted filesystem
+    } else if (err.code === 'EXDEV') {
+      // not on the same mounted filesystem
       assert.strictEqual(
         err.message,
         `EXDEV: cross-device link not permitted, rename '${existingDir}' -> ` +
-            `'${existingDir2}'`);
-    } else if (err.code === 'EEXIST') {  // smartos and aix
+          `'${existingDir2}'`
+      );
+    } else if (err.code === 'EEXIST') {
+      // smartos and aix
       assert.strictEqual(
         err.message,
         `EEXIST: file already exists, rename '${existingDir}' -> ` +
-        `'${existingDir2}'`);
+          `'${existingDir2}'`
+      );
       assert.strictEqual(err.errno, UV_EEXIST);
-    } else {  // windows
+    } else {
+      // windows
       assert.strictEqual(
         err.message,
         `EPERM: operation not permitted, rename '${existingDir}' -> ` +
-        `'${existingDir2}'`);
+          `'${existingDir2}'`
+      );
       assert.strictEqual(err.errno, UV_EPERM);
       assert.strictEqual(err.code, 'EPERM');
     }
@@ -344,10 +335,7 @@ function re(literals, ...values) {
 
   fs.rename(existingDir, existingDir2, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.renameSync(existingDir, existingDir2),
-    validateError
-  );
+  assert.throws(() => fs.renameSync(existingDir, existingDir2), validateError);
 }
 
 // rmdir
@@ -356,7 +344,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, rmdir '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, rmdir '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'rmdir');
@@ -365,10 +354,7 @@ function re(literals, ...values) {
 
   fs.rmdir(nonexistentFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.rmdirSync(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.rmdirSync(nonexistentFile), validateError);
 }
 
 // rmdir a file
@@ -379,12 +365,15 @@ function re(literals, ...values) {
     if (err.code === 'ENOTDIR') {
       assert.strictEqual(
         err.message,
-        `ENOTDIR: not a directory, rmdir '${existingFile}'`);
+        `ENOTDIR: not a directory, rmdir '${existingFile}'`
+      );
       assert.strictEqual(err.errno, UV_ENOTDIR);
-    } else {  // windows
+    } else {
+      // windows
       assert.strictEqual(
         err.message,
-        `ENOENT: no such file or directory, rmdir '${existingFile}'`);
+        `ENOENT: no such file or directory, rmdir '${existingFile}'`
+      );
       assert.strictEqual(err.errno, UV_ENOENT);
       assert.strictEqual(err.code, 'ENOENT');
     }
@@ -393,10 +382,7 @@ function re(literals, ...values) {
 
   fs.rmdir(existingFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.rmdirSync(existingFile),
-    validateError
-  );
+  assert.throws(() => fs.rmdirSync(existingFile), validateError);
 }
 
 // mkdir
@@ -405,7 +391,8 @@ function re(literals, ...values) {
     assert.strictEqual(existingFile, err.path);
     assert.strictEqual(
       err.message,
-      `EEXIST: file already exists, mkdir '${existingFile}'`);
+      `EEXIST: file already exists, mkdir '${existingFile}'`
+    );
     assert.strictEqual(err.errno, UV_EEXIST);
     assert.strictEqual(err.code, 'EEXIST');
     assert.strictEqual(err.syscall, 'mkdir');
@@ -414,10 +401,7 @@ function re(literals, ...values) {
 
   fs.mkdir(existingFile, 0o666, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.mkdirSync(existingFile, 0o666),
-    validateError
-  );
+  assert.throws(() => fs.mkdirSync(existingFile, 0o666), validateError);
 }
 
 // chmod
@@ -426,7 +410,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, chmod '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, chmod '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'chmod');
@@ -435,10 +420,7 @@ function re(literals, ...values) {
 
   fs.chmod(nonexistentFile, 0o666, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.chmodSync(nonexistentFile, 0o666),
-    validateError
-  );
+  assert.throws(() => fs.chmodSync(nonexistentFile, 0o666), validateError);
 }
 
 // open
@@ -447,7 +429,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, open '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, open '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'open');
@@ -456,13 +439,9 @@ function re(literals, ...values) {
 
   fs.open(nonexistentFile, 'r', 0o666, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.openSync(nonexistentFile, 'r', 0o666),
-    validateError
-  );
+  assert.throws(() => fs.openSync(nonexistentFile, 'r', 0o666), validateError);
 }
 
-
 // close
 {
   const validateError = (err) => {
@@ -476,10 +455,7 @@ function re(literals, ...values) {
   common.runWithInvalidFD((fd) => {
     fs.close(fd, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.closeSync(fd),
-      validateError
-    );
+    assert.throws(() => fs.closeSync(fd), validateError);
   });
 }
 
@@ -489,7 +465,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, open '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, open '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'open');
@@ -498,10 +475,7 @@ function re(literals, ...values) {
 
   fs.readFile(nonexistentFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.readFileSync(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.readFileSync(nonexistentFile), validateError);
 }
 
 // readdir
@@ -510,7 +484,8 @@ function re(literals, ...values) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, scandir '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, scandir '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'scandir');
@@ -519,10 +494,7 @@ function re(literals, ...values) {
 
   fs.readdir(nonexistentFile, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.readdirSync(nonexistentFile),
-    validateError
-  );
+  assert.throws(() => fs.readdirSync(nonexistentFile), validateError);
 }
 
 // ftruncate
@@ -544,10 +516,7 @@ function re(literals, ...values) {
   common.runWithInvalidFD((fd) => {
     fs.ftruncate(fd, 4, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.ftruncateSync(fd, 4),
-      validateError
-    );
+    assert.throws(() => fs.ftruncateSync(fd, 4), validateError);
   });
 }
 
@@ -564,10 +533,7 @@ function re(literals, ...values) {
   common.runWithInvalidFD((fd) => {
     fs.fdatasync(fd, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.fdatasyncSync(fd),
-      validateError
-    );
+    assert.throws(() => fs.fdatasyncSync(fd), validateError);
   });
 }
 
@@ -584,10 +550,7 @@ function re(literals, ...values) {
   common.runWithInvalidFD((fd) => {
     fs.fsync(fd, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.fsyncSync(fd),
-      validateError
-    );
+    assert.throws(() => fs.fsyncSync(fd), validateError);
   });
 }
 
@@ -597,19 +560,23 @@ if (!common.isWindows) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, chown '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, chown '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'chown');
     return true;
   };
 
-  fs.chown(nonexistentFile, process.getuid(), process.getgid(),
-           common.mustCall(validateError));
+  fs.chown(
+    nonexistentFile,
+    process.getuid(),
+    process.getgid(),
+    common.mustCall(validateError)
+  );
 
   assert.throws(
-    () => fs.chownSync(nonexistentFile,
-                       process.getuid(), process.getgid()),
+    () => fs.chownSync(nonexistentFile, process.getuid(), process.getgid()),
     validateError
   );
 }
@@ -620,15 +587,20 @@ if (!common.isAIX) {
     assert.strictEqual(nonexistentFile, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, utime '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, utime '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'utime');
     return true;
   };
 
-  fs.utimes(nonexistentFile, new Date(), new Date(),
-            common.mustCall(validateError));
+  fs.utimes(
+    nonexistentFile,
+    new Date(),
+    new Date(),
+    common.mustCall(validateError)
+  );
 
   assert.throws(
     () => fs.utimesSync(nonexistentFile, new Date(), new Date()),
@@ -640,13 +612,18 @@ if (!common.isAIX) {
 {
   const validateError = (err) => {
     const pathPrefix = new RegExp('^' + re`${nonexistentDir}`);
-    assert(pathPrefix.test(err.path),
-           `Expect ${err.path} to match ${pathPrefix}`);
+    assert(
+      pathPrefix.test(err.path),
+      `Expect ${err.path} to match ${pathPrefix}`
+    );
 
-    const prefix = new RegExp('^ENOENT: no such file or directory, mkdtemp ' +
-                              re`'${nonexistentDir}`);
-    assert(prefix.test(err.message),
-           `Expect ${err.message} to match ${prefix}`);
+    const prefix = new RegExp(
+      '^ENOENT: no such file or directory, mkdtemp ' + re`'${nonexistentDir}`
+    );
+    assert(
+      prefix.test(err.message),
+      `Expect ${err.message} to match ${prefix}`
+    );
 
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
@@ -656,10 +633,7 @@ if (!common.isAIX) {
 
   fs.mkdtemp(nonexistentDir, common.mustCall(validateError));
 
-  assert.throws(
-    () => fs.mkdtempSync(nonexistentDir),
-    validateError
-  );
+  assert.throws(() => fs.mkdtempSync(nonexistentDir), validateError);
 }
 
 // Check copyFile with invalid flags.
@@ -672,11 +646,16 @@ if (!common.isAIX) {
     syscall: 'copyfile'
   };
 
-  fs.copyFile(existingFile, nonexistentFile, -1,
-              common.expectsError(validateError));
+  fs.copyFile(
+    existingFile,
+    nonexistentFile,
+    -1,
+    common.expectsError(validateError)
+  );
 
-  validateError.message = 'EINVAL: invalid argument, copyfile ' +
-                          `'${existingFile}' -> '${nonexistentFile}'`;
+  validateError.message =
+    'EINVAL: invalid argument, copyfile ' +
+    `'${existingFile}' -> '${nonexistentFile}'`;
   assert.throws(
     () => fs.copyFileSync(existingFile, nonexistentFile, -1),
     validateError
@@ -686,17 +665,22 @@ if (!common.isAIX) {
 // copyFile: destination exists but the COPYFILE_EXCL flag is provided.
 {
   const validateError = (err) => {
-    if (err.code === 'ENOENT') {  // Could be ENOENT or EEXIST
-      assert.strictEqual(err.message,
-                         'ENOENT: no such file or directory, copyfile ' +
-                         `'${existingFile}' -> '${existingFile2}'`);
+    if (err.code === 'ENOENT') {
+      // Could be ENOENT or EEXIST
+      assert.strictEqual(
+        err.message,
+        'ENOENT: no such file or directory, copyfile ' +
+          `'${existingFile}' -> '${existingFile2}'`
+      );
       assert.strictEqual(err.errno, UV_ENOENT);
       assert.strictEqual(err.code, 'ENOENT');
       assert.strictEqual(err.syscall, 'copyfile');
     } else {
-      assert.strictEqual(err.message,
-                         'EEXIST: file already exists, copyfile ' +
-                         `'${existingFile}' -> '${existingFile2}'`);
+      assert.strictEqual(
+        err.message,
+        'EEXIST: file already exists, copyfile ' +
+          `'${existingFile}' -> '${existingFile2}'`
+      );
       assert.strictEqual(err.errno, UV_EEXIST);
       assert.strictEqual(err.code, 'EEXIST');
       assert.strictEqual(err.syscall, 'copyfile');
@@ -704,8 +688,12 @@ if (!common.isAIX) {
     return true;
   };
 
-  fs.copyFile(existingFile, existingFile2, COPYFILE_EXCL,
-              common.mustCall(validateError));
+  fs.copyFile(
+    existingFile,
+    existingFile2,
+    COPYFILE_EXCL,
+    common.mustCall(validateError)
+  );
 
   assert.throws(
     () => fs.copyFileSync(existingFile, existingFile2, COPYFILE_EXCL),
@@ -716,17 +704,23 @@ if (!common.isAIX) {
 // copyFile: the source does not exist.
 {
   const validateError = (err) => {
-    assert.strictEqual(err.message,
-                       'ENOENT: no such file or directory, copyfile ' +
-                       `'${nonexistentFile}' -> '${existingFile2}'`);
+    assert.strictEqual(
+      err.message,
+      'ENOENT: no such file or directory, copyfile ' +
+        `'${nonexistentFile}' -> '${existingFile2}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'copyfile');
     return true;
   };
 
-  fs.copyFile(nonexistentFile, existingFile2, COPYFILE_EXCL,
-              common.mustCall(validateError));
+  fs.copyFile(
+    nonexistentFile,
+    existingFile2,
+    COPYFILE_EXCL,
+    common.mustCall(validateError)
+  );
 
   assert.throws(
     () => fs.copyFileSync(nonexistentFile, existingFile2, COPYFILE_EXCL),
@@ -748,10 +742,7 @@ if (!common.isAIX) {
     const buf = Buffer.alloc(5);
     fs.read(fd, buf, 0, 1, 1, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.readSync(fd, buf, 0, 1, 1),
-      validateError
-    );
+    assert.throws(() => fs.readSync(fd, buf, 0, 1, 1), validateError);
   });
 }
 
@@ -768,10 +759,7 @@ if (!common.isAIX) {
   common.runWithInvalidFD((fd) => {
     fs.fchmod(fd, 0o666, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.fchmodSync(fd, 0o666),
-      validateError
-    );
+    assert.throws(() => fs.fchmodSync(fd, 0o666), validateError);
   });
 }
 
@@ -786,8 +774,12 @@ if (!common.isWindows) {
   };
 
   common.runWithInvalidFD((fd) => {
-    fs.fchown(fd, process.getuid(), process.getgid(),
-              common.mustCall(validateError));
+    fs.fchown(
+      fd,
+      process.getuid(),
+      process.getgid(),
+      common.mustCall(validateError)
+    );
 
     assert.throws(
       () => fs.fchownSync(fd, process.getuid(), process.getgid()),
@@ -810,10 +802,7 @@ if (!common.isWindows) {
     const buf = Buffer.alloc(5);
     fs.write(fd, buf, 0, 1, 1, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.writeSync(fd, buf, 0, 1, 1),
-      validateError
-    );
+    assert.throws(() => fs.writeSync(fd, buf, 0, 1, 1), validateError);
   });
 }
 
@@ -830,14 +819,10 @@ if (!common.isWindows) {
   common.runWithInvalidFD((fd) => {
     fs.write(fd, 'test', 1, common.mustCall(validateError));
 
-    assert.throws(
-      () => fs.writeSync(fd, 'test', 1),
-      validateError
-    );
+    assert.throws(() => fs.writeSync(fd, 'test', 1), validateError);
   });
 }
 
-
 // futimes
 if (!common.isAIX) {
   const validateError = (err) => {
diff --git a/test/parallel/test-fs-exists.js b/test/parallel/test-fs-exists.js
index cd2d9a712f3f58..647158587a37f9 100644
--- a/test/parallel/test-fs-exists.js
+++ b/test/parallel/test-fs-exists.js
@@ -30,23 +30,35 @@ assert.throws(() => fs.exists(f), { code: 'ERR_INVALID_CALLBACK' });
 assert.throws(() => fs.exists(), { code: 'ERR_INVALID_CALLBACK' });
 assert.throws(() => fs.exists(f, {}), { code: 'ERR_INVALID_CALLBACK' });
 
-fs.exists(f, common.mustCall(function(y) {
-  assert.strictEqual(y, true);
-}));
+fs.exists(
+  f,
+  common.mustCall(function(y) {
+    assert.strictEqual(y, true);
+  })
+);
 
-fs.exists(`${f}-NO`, common.mustCall(function(y) {
-  assert.strictEqual(y, false);
-}));
+fs.exists(
+  `${f}-NO`,
+  common.mustCall(function(y) {
+    assert.strictEqual(y, false);
+  })
+);
 
 // If the path is invalid, fs.exists will still invoke the callback with false
 // instead of throwing errors
-fs.exists(new URL('https://foo'), common.mustCall(function(y) {
-  assert.strictEqual(y, false);
-}));
+fs.exists(
+  new URL('https://foo'),
+  common.mustCall(function(y) {
+    assert.strictEqual(y, false);
+  })
+);
 
-fs.exists({}, common.mustCall(function(y) {
-  assert.strictEqual(y, false);
-}));
+fs.exists(
+  {},
+  common.mustCall(function(y) {
+    assert.strictEqual(y, false);
+  })
+);
 
 assert(fs.existsSync(f));
 assert(!fs.existsSync(`${f}-NO`));
diff --git a/test/parallel/test-fs-fchmod.js b/test/parallel/test-fs-fchmod.js
index 4f6350e63c241a..b711c12ac997fe 100644
--- a/test/parallel/test-fs-fchmod.js
+++ b/test/parallel/test-fs-fchmod.js
@@ -12,20 +12,20 @@ const fs = require('fs');
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "fd" argument must be of type number. Received type ' +
-             typeof input
+    message:
+      'The "fd" argument must be of type number. Received type ' + typeof input
   };
   assert.throws(() => fs.fchmod(input), errObj);
   assert.throws(() => fs.fchmodSync(input), errObj);
 });
 
-
 [false, null, undefined, {}, [], '', '123x'].forEach((input) => {
   const errObj = {
     code: 'ERR_INVALID_ARG_VALUE',
     name: 'TypeError [ERR_INVALID_ARG_VALUE]',
-    message: 'The argument \'mode\' must be a 32-bit unsigned integer or an ' +
-             `octal string. Received ${util.inspect(input)}`
+    message:
+      "The argument 'mode' must be a 32-bit unsigned integer or an " +
+      `octal string. Received ${util.inspect(input)}`
   };
   assert.throws(() => fs.fchmod(1, input), errObj);
   assert.throws(() => fs.fchmodSync(1, input), errObj);
@@ -35,8 +35,9 @@ const fs = require('fs');
   const errObj = {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "fd" is out of range. It must be >= 0 && <= ' +
-             `2147483647. Received ${input}`
+    message:
+      'The value of "fd" is out of range. It must be >= 0 && <= ' +
+      `2147483647. Received ${input}`
   };
   assert.throws(() => fs.fchmod(input), errObj);
   assert.throws(() => fs.fchmodSync(input), errObj);
@@ -46,8 +47,9 @@ const fs = require('fs');
   const errObj = {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "mode" is out of range. It must be >= 0 && < ' +
-             `4294967296. Received ${input}`
+    message:
+      'The value of "mode" is out of range. It must be >= 0 && < ' +
+      `4294967296. Received ${input}`
   };
 
   assert.throws(() => fs.fchmod(1, input), errObj);
@@ -58,8 +60,9 @@ const fs = require('fs');
   const errObj = {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "fd" is out of range. It must be an integer. ' +
-             `Received ${input}`
+    message:
+      'The value of "fd" is out of range. It must be an integer. ' +
+      `Received ${input}`
   };
   assert.throws(() => fs.fchmod(input), errObj);
   assert.throws(() => fs.fchmodSync(input), errObj);
@@ -72,8 +75,9 @@ const fs = require('fs');
   const errObj = {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "fd" is out of range. It must be an integer. ' +
-             `Received ${input}`
+    message:
+      'The value of "fd" is out of range. It must be an integer. ' +
+      `Received ${input}`
   };
   assert.throws(() => fs.fchmod(input), errObj);
   assert.throws(() => fs.fchmodSync(input), errObj);
diff --git a/test/parallel/test-fs-fchown.js b/test/parallel/test-fs-fchown.js
index 500c06a47ca09c..eda6ed57c9823c 100644
--- a/test/parallel/test-fs-fchown.js
+++ b/test/parallel/test-fs-fchown.js
@@ -19,8 +19,8 @@ function test(input, errObj) {
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "fd" argument must be of type number. Received type ' +
-             typeof input
+    message:
+      'The "fd" argument must be of type number. Received type ' + typeof input
   };
   test(input, errObj);
 });
@@ -29,8 +29,9 @@ function test(input, errObj) {
   const errObj = {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "fd" is out of range. It must be an integer. ' +
-             `Received ${input}`
+    message:
+      'The value of "fd" is out of range. It must be an integer. ' +
+      `Received ${input}`
   };
   test(input, errObj);
 });
@@ -39,8 +40,9 @@ function test(input, errObj) {
   const errObj = {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "fd" is out of range. It must be ' +
-             `>= 0 && < 4294967296. Received ${input}`
+    message:
+      'The value of "fd" is out of range. It must be ' +
+      `>= 0 && < 4294967296. Received ${input}`
   };
   test(input, errObj);
 });
diff --git a/test/parallel/test-fs-filehandle.js b/test/parallel/test-fs-filehandle.js
index 6b069ddc51b722..b3786a7f85d855 100644
--- a/test/parallel/test-fs-filehandle.js
+++ b/test/parallel/test-fs-filehandle.js
@@ -14,23 +14,28 @@ const { stringToFlags } = require('internal/fs/utils');
 let fdnum;
 {
   const ctx = {};
-  fdnum = fs.openFileHandle(path.toNamespacedPath(__filename),
-                            stringToFlags('r'), 0o666, undefined, ctx).fd;
+  fdnum = fs.openFileHandle(
+    path.toNamespacedPath(__filename),
+    stringToFlags('r'),
+    0o666,
+    undefined,
+    ctx
+  ).fd;
   assert.strictEqual(ctx.errno, undefined);
 }
 
 common.expectWarning({
   'internal/test/binding': [
     'These APIs are exposed only for testing ' +
-    'and are not tracked by any versioning system or deprecation process.',
+      'and are not tracked by any versioning system or deprecation process.',
     common.noWarnCode
   ],
-  'Warning': [
+  Warning: [
     `Closing file descriptor ${fdnum} on garbage collection`,
     common.noWarnCode
   ]
 });
 
-gc();  // eslint-disable-line no-undef
+gc(); // eslint-disable-line no-undef
 
 setTimeout(() => {}, 10);
diff --git a/test/parallel/test-fs-fsync.js b/test/parallel/test-fs-fsync.js
index 4d96091f346501..9633d56367c7af 100644
--- a/test/parallel/test-fs-fsync.js
+++ b/test/parallel/test-fs-fsync.js
@@ -35,27 +35,38 @@ const fileTemp = path.join(tmpdir.path, 'a.js');
 tmpdir.refresh();
 fs.copyFileSync(fileFixture, fileTemp);
 
-fs.open(fileTemp, 'a', 0o777, common.mustCall(function(err, fd) {
-  assert.ifError(err);
+fs.open(
+  fileTemp,
+  'a',
+  0o777,
+  common.mustCall(function(err, fd) {
+    assert.ifError(err);
 
-  fs.fdatasyncSync(fd);
+    fs.fdatasyncSync(fd);
 
-  fs.fsyncSync(fd);
+    fs.fsyncSync(fd);
 
-  fs.fdatasync(fd, common.mustCall(function(err) {
-    assert.ifError(err);
-    fs.fsync(fd, common.mustCall(function(err) {
-      assert.ifError(err);
-    }));
-  }));
-}));
+    fs.fdatasync(
+      fd,
+      common.mustCall(function(err) {
+        assert.ifError(err);
+        fs.fsync(
+          fd,
+          common.mustCall(function(err) {
+            assert.ifError(err);
+          })
+        );
+      })
+    );
+  })
+);
 
 ['', false, null, undefined, {}, []].forEach((input) => {
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "fd" argument must be of type number. Received type ' +
-             typeof input
+    message:
+      'The "fd" argument must be of type number. Received type ' + typeof input
   };
   assert.throws(() => fs.fdatasync(input), errObj);
   assert.throws(() => fs.fdatasyncSync(input), errObj);
diff --git a/test/parallel/test-fs-lchown.js b/test/parallel/test-fs-lchown.js
index bf8673c0718769..e8d4b4f9ed9837 100644
--- a/test/parallel/test-fs-lchown.js
+++ b/test/parallel/test-fs-lchown.js
@@ -13,7 +13,8 @@ const { promises } = fs;
 
   common.expectsError(() => fs.lchown(i, 1, 1, common.mustNotCall()), err);
   common.expectsError(() => fs.lchownSync(i, 1, 1), err);
-  promises.lchown(false, 1, 1)
+  promises
+    .lchown(false, 1, 1)
     .then(common.mustNotCall())
     .catch(common.expectsError(err));
 });
@@ -33,11 +34,13 @@ const { promises } = fs;
   common.expectsError(() => fs.lchownSync('not_a_file_that_exists', i, 1), err);
   common.expectsError(() => fs.lchownSync('not_a_file_that_exists', 1, i), err);
 
-  promises.lchown('not_a_file_that_exists', i, 1)
+  promises
+    .lchown('not_a_file_that_exists', i, 1)
     .then(common.mustNotCall())
     .catch(common.expectsError(err));
 
-  promises.lchown('not_a_file_that_exists', 1, i)
+  promises
+    .lchown('not_a_file_that_exists', 1, i)
     .then(common.mustNotCall())
     .catch(common.expectsError(err));
 });
@@ -58,8 +61,13 @@ if (!common.isWindows) {
   tmpdir.refresh();
   fs.copyFileSync(__filename, testFile);
   fs.lchownSync(testFile, uid, gid);
-  fs.lchown(testFile, uid, gid, common.mustCall(async (err) => {
-    assert.ifError(err);
-    await promises.lchown(testFile, uid, gid);
-  }));
+  fs.lchown(
+    testFile,
+    uid,
+    gid,
+    common.mustCall(async (err) => {
+      assert.ifError(err);
+      await promises.lchown(testFile, uid, gid);
+    })
+  );
 }
diff --git a/test/parallel/test-fs-link.js b/test/parallel/test-fs-link.js
index 9b95fc3e026140..109581bce0c1cc 100644
--- a/test/parallel/test-fs-link.js
+++ b/test/parallel/test-fs-link.js
@@ -23,32 +23,20 @@ fs.link(srcPath, dstPath, common.mustCall(callback));
 // test error outputs
 
 [false, 1, [], {}, null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.link(i, '', common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.link('', i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.linkSync(i, ''),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.linkSync('', i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.link(i, '', common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.link('', i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.linkSync(i, ''), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.linkSync('', i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-fs-long-path.js b/test/parallel/test-fs-long-path.js
index 74f63868b81054..90fa63bec64560 100644
--- a/test/parallel/test-fs-long-path.js
+++ b/test/parallel/test-fs-long-path.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.isWindows)
-  common.skip('this test is Windows-specific.');
+if (!common.isWindows) common.skip('this test is Windows-specific.');
 
 const fs = require('fs');
 const path = require('path');
@@ -42,13 +41,20 @@ console.log({
   fullPathLength: fullPath.length
 });
 
-fs.writeFile(fullPath, 'ok', common.mustCall(function(err) {
-  assert.ifError(err);
-
-  fs.stat(fullPath, common.mustCall(function(err, stats) {
+fs.writeFile(
+  fullPath,
+  'ok',
+  common.mustCall(function(err) {
     assert.ifError(err);
-  }));
-}));
+
+    fs.stat(
+      fullPath,
+      common.mustCall(function(err, stats) {
+        assert.ifError(err);
+      })
+    );
+  })
+);
 
 process.on('exit', function() {
   fs.unlinkSync(fullPath);
diff --git a/test/parallel/test-fs-mkdir-mode-mask.js b/test/parallel/test-fs-mkdir-mode-mask.js
index 515b982054b82b..e01e712754d87f 100644
--- a/test/parallel/test-fs-mkdir-mode-mask.js
+++ b/test/parallel/test-fs-mkdir-mode-mask.js
@@ -23,8 +23,9 @@ tmpdir.refresh();
 
 function test(mode, asString) {
   const suffix = asString ? 'str' : 'num';
-  const input = asString ?
-    (mode | maskToIgnore).toString(8) : (mode | maskToIgnore);
+  const input = asString
+    ? (mode | maskToIgnore).toString(8)
+    : mode | maskToIgnore;
 
   {
     const dir = path.join(tmpdir.path, `mkdirSync-${suffix}`);
@@ -34,10 +35,14 @@ function test(mode, asString) {
 
   {
     const dir = path.join(tmpdir.path, `mkdir-${suffix}`);
-    fs.mkdir(dir, input, common.mustCall((err) => {
-      assert.ifError(err);
-      assert.strictEqual(fs.statSync(dir).mode & 0o777, mode);
-    }));
+    fs.mkdir(
+      dir,
+      input,
+      common.mustCall((err) => {
+        assert.ifError(err);
+        assert.strictEqual(fs.statSync(dir).mode & 0o777, mode);
+      })
+    );
   }
 }
 
diff --git a/test/parallel/test-fs-mkdir-rmdir.js b/test/parallel/test-fs-mkdir-rmdir.js
index 5e4982ba8576bf..c304daf5c9b54e 100644
--- a/test/parallel/test-fs-mkdir-rmdir.js
+++ b/test/parallel/test-fs-mkdir-rmdir.js
@@ -25,16 +25,24 @@ fs.rmdirSync(d);
 assert(!fs.existsSync(d));
 
 // Similarly test the Async version
-fs.mkdir(d, 0o666, common.mustCall(function(err) {
-  assert.ifError(err);
+fs.mkdir(
+  d,
+  0o666,
+  common.mustCall(function(err) {
+    assert.ifError(err);
 
-  fs.mkdir(d, 0o666, common.mustCall(function(err) {
-    assert.strictEqual(this, undefined);
-    assert.ok(err, 'got no error');
-    assert.ok(/^EEXIST/.test(err.message), 'got no EEXIST message');
-    assert.strictEqual(err.code, 'EEXIST');
-    assert.strictEqual(err.path, d);
+    fs.mkdir(
+      d,
+      0o666,
+      common.mustCall(function(err) {
+        assert.strictEqual(this, undefined);
+        assert.ok(err, 'got no error');
+        assert.ok(/^EEXIST/.test(err.message), 'got no EEXIST message');
+        assert.strictEqual(err.code, 'EEXIST');
+        assert.strictEqual(err.path, d);
 
-    fs.rmdir(d, assert.ifError);
-  }));
-}));
+        fs.rmdir(d, assert.ifError);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-fs-mkdir.js b/test/parallel/test-fs-mkdir.js
index d07aab53769299..a62abfa996e40d 100644
--- a/test/parallel/test-fs-mkdir.js
+++ b/test/parallel/test-fs-mkdir.js
@@ -37,20 +37,27 @@ function nextdir() {
 {
   const pathname = path.join(tmpdir.path, nextdir());
 
-  fs.mkdir(pathname, common.mustCall(function(err) {
-    assert.strictEqual(err, null);
-    assert.strictEqual(fs.existsSync(pathname), true);
-  }));
+  fs.mkdir(
+    pathname,
+    common.mustCall(function(err) {
+      assert.strictEqual(err, null);
+      assert.strictEqual(fs.existsSync(pathname), true);
+    })
+  );
 }
 
 // mkdir creates directory with assigned mode value
 {
   const pathname = path.join(tmpdir.path, nextdir());
 
-  fs.mkdir(pathname, 0o777, common.mustCall(function(err) {
-    assert.strictEqual(err, null);
-    assert.strictEqual(fs.existsSync(pathname), true);
-  }));
+  fs.mkdir(
+    pathname,
+    0o777,
+    common.mustCall(function(err) {
+      assert.strictEqual(err, null);
+      assert.strictEqual(fs.existsSync(pathname), true);
+    })
+  );
 }
 
 // mkdirSync successfully creates directory from given path
@@ -66,20 +73,14 @@ function nextdir() {
 // mkdirSync and mkdir require path to be a string, buffer or url.
 // Anything else generates an error.
 [false, 1, {}, [], null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.mkdir(i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.mkdirSync(i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.mkdir(i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.mkdirSync(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
 
 // mkdirpSync when both top-level, and sub-folders do not exist.
@@ -136,11 +137,15 @@ function nextdir() {
 {
   const pathname = path.join(tmpdir.path, nextdir(), nextdir());
 
-  fs.mkdir(pathname, { recursive: true }, common.mustCall(function(err) {
-    assert.strictEqual(err, null);
-    assert.strictEqual(fs.existsSync(pathname), true);
-    assert.strictEqual(fs.statSync(pathname).isDirectory(), true);
-  }));
+  fs.mkdir(
+    pathname,
+    { recursive: true },
+    common.mustCall(function(err) {
+      assert.strictEqual(err, null);
+      assert.strictEqual(fs.existsSync(pathname), true);
+      assert.strictEqual(fs.statSync(pathname).isDirectory(), true);
+    })
+  );
 }
 
 // mkdirp when path is a file.
@@ -187,19 +192,18 @@ if (common.isMainThread && (common.isLinux || common.isOSX)) {
       {
         code: 'ERR_INVALID_ARG_TYPE',
         type: TypeError,
-        message: 'The "recursive" argument must be of type boolean. Received ' +
-          `type ${typeof recursive}`
-      }
-    );
-    common.expectsError(
-      () => fs.mkdirSync(pathname, { recursive }),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        type: TypeError,
-        message: 'The "recursive" argument must be of type boolean. Received ' +
+        message:
+          'The "recursive" argument must be of type boolean. Received ' +
           `type ${typeof recursive}`
       }
     );
+    common.expectsError(() => fs.mkdirSync(pathname, { recursive }), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "recursive" argument must be of type boolean. Received ' +
+        `type ${typeof recursive}`
+    });
   });
 }
 
diff --git a/test/parallel/test-fs-mkdtemp-prefix-check.js b/test/parallel/test-fs-mkdtemp-prefix-check.js
index 4573dbbaae8435..221ad284f2a437 100644
--- a/test/parallel/test-fs-mkdtemp-prefix-check.js
+++ b/test/parallel/test-fs-mkdtemp-prefix-check.js
@@ -12,7 +12,8 @@ function fail(value) {
     {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError
-    });
+    }
+  );
 }
 
 function failAsync(value) {
@@ -23,7 +24,8 @@ function failAsync(value) {
     {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError
-    });
+    }
+  );
 }
 
 prefixValues.forEach((prefixValue) => {
diff --git a/test/parallel/test-fs-mkdtemp.js b/test/parallel/test-fs-mkdtemp.js
index 98b62aa315e0a4..2c0d4eb830af2d 100644
--- a/test/parallel/test-fs-mkdtemp.js
+++ b/test/parallel/test-fs-mkdtemp.js
@@ -14,8 +14,10 @@ assert.strictEqual(path.basename(tmpFolder).length, 'foo.XXXXXX'.length);
 assert(fs.existsSync(tmpFolder));
 
 const utf8 = fs.mkdtempSync(path.join(tmpdir.path, '\u0222abc.'));
-assert.strictEqual(Buffer.byteLength(path.basename(utf8)),
-                   Buffer.byteLength('\u0222abc.XXXXXX'));
+assert.strictEqual(
+  Buffer.byteLength(path.basename(utf8)),
+  Buffer.byteLength('\u0222abc.XXXXXX')
+);
 assert(fs.existsSync(utf8));
 
 function handler(err, folder) {
diff --git a/test/parallel/test-fs-non-number-arguments-throw.js b/test/parallel/test-fs-non-number-arguments-throw.js
index 61ed3f6c285dd0..e24b17006dbb54 100644
--- a/test/parallel/test-fs-non-number-arguments-throw.js
+++ b/test/parallel/test-fs-non-number-arguments-throw.js
@@ -21,7 +21,8 @@ common.expectsError(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError
-  });
+  }
+);
 
 common.expectsError(
   () => {
@@ -30,7 +31,8 @@ common.expectsError(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError
-  });
+  }
+);
 
 common.expectsError(
   () => {
@@ -39,10 +41,16 @@ common.expectsError(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError
-  });
+  }
+);
 
-saneEmitter.on('data', common.mustCall(function(data) {
-  assert.strictEqual(
-    sanity, data.toString('utf8'),
-    `read ${data.toString('utf8')} instead of ${sanity}`);
-}));
+saneEmitter.on(
+  'data',
+  common.mustCall(function(data) {
+    assert.strictEqual(
+      sanity,
+      data.toString('utf8'),
+      `read ${data.toString('utf8')} instead of ${sanity}`
+    );
+  })
+);
diff --git a/test/parallel/test-fs-null-bytes.js b/test/parallel/test-fs-null-bytes.js
index f5a56b01d5f883..311eff6ca845ba 100644
--- a/test/parallel/test-fs-null-bytes.js
+++ b/test/parallel/test-fs-null-bytes.js
@@ -36,8 +36,9 @@ function check(async, sync) {
       },
       {
         code: 'ERR_INVALID_ARG_VALUE',
-        type: TypeError,
-      });
+        type: TypeError
+      }
+    );
   }
 
   if (async) {
@@ -48,7 +49,8 @@ function check(async, sync) {
       {
         code: 'ERR_INVALID_ARG_VALUE',
         type: TypeError
-      });
+      }
+    );
   }
 }
 
@@ -150,7 +152,10 @@ check(fs.writeFile, fs.writeFileSync, fileUrl2, 'abc');
 
 // an 'error' for exists means that it doesn't exist.
 // one of many reasons why this file is the absolute worst.
-fs.exists('foo\u0000bar', common.mustCall((exists) => {
-  assert(!exists);
-}));
+fs.exists(
+  'foo\u0000bar',
+  common.mustCall((exists) => {
+    assert(!exists);
+  })
+);
 assert(!fs.existsSync('foo\u0000bar'));
diff --git a/test/parallel/test-fs-open-flags.js b/test/parallel/test-fs-open-flags.js
index 546d68e31274f4..182b03067f96b7 100644
--- a/test/parallel/test-fs-open-flags.js
+++ b/test/parallel/test-fs-open-flags.js
@@ -63,29 +63,29 @@ assert.strictEqual(stringToFlags('xa+'), O_APPEND | O_CREAT | O_RDWR | O_EXCL);
 assert.strictEqual(stringToFlags('as+'), O_APPEND | O_CREAT | O_RDWR | O_SYNC);
 assert.strictEqual(stringToFlags('sa+'), O_APPEND | O_CREAT | O_RDWR | O_SYNC);
 
-('+ +a +r +w rw wa war raw r++ a++ w++ x +x x+ rx rx+ wxx wax xwx xxx')
+'+ +a +r +w rw wa war raw r++ a++ w++ x +x x+ rx rx+ wxx wax xwx xxx'
   .split(' ')
   .forEach(function(flags) {
-    common.expectsError(
-      () => stringToFlags(flags),
-      { code: 'ERR_INVALID_OPT_VALUE', type: TypeError }
-    );
+    common.expectsError(() => stringToFlags(flags), {
+      code: 'ERR_INVALID_OPT_VALUE',
+      type: TypeError
+    });
   });
 
-common.expectsError(
-  () => stringToFlags({}),
-  { code: 'ERR_INVALID_OPT_VALUE', type: TypeError }
-);
+common.expectsError(() => stringToFlags({}), {
+  code: 'ERR_INVALID_OPT_VALUE',
+  type: TypeError
+});
 
-common.expectsError(
-  () => stringToFlags(true),
-  { code: 'ERR_INVALID_OPT_VALUE', type: TypeError }
-);
+common.expectsError(() => stringToFlags(true), {
+  code: 'ERR_INVALID_OPT_VALUE',
+  type: TypeError
+});
 
-common.expectsError(
-  () => stringToFlags(null),
-  { code: 'ERR_INVALID_OPT_VALUE', type: TypeError }
-);
+common.expectsError(() => stringToFlags(null), {
+  code: 'ERR_INVALID_OPT_VALUE',
+  type: TypeError
+});
 
 if (common.isLinux || common.isOSX) {
   const tmpdir = require('../common/tmpdir');
diff --git a/test/parallel/test-fs-open-mode-mask.js b/test/parallel/test-fs-open-mode-mask.js
index 0cd9a2c5923a71..eda38a81ba773a 100644
--- a/test/parallel/test-fs-open-mode-mask.js
+++ b/test/parallel/test-fs-open-mode-mask.js
@@ -22,8 +22,9 @@ tmpdir.refresh();
 
 function test(mode, asString) {
   const suffix = asString ? 'str' : 'num';
-  const input = asString ?
-    (mode | maskToIgnore).toString(8) : (mode | maskToIgnore);
+  const input = asString
+    ? (mode | maskToIgnore).toString(8)
+    : mode | maskToIgnore;
 
   {
     const file = path.join(tmpdir.path, `openSync-${suffix}.txt`);
@@ -35,12 +36,17 @@ function test(mode, asString) {
 
   {
     const file = path.join(tmpdir.path, `open-${suffix}.txt`);
-    fs.open(file, 'w+', input, common.mustCall((err, fd) => {
-      assert.ifError(err);
-      assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
-      fs.closeSync(fd);
-      assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
-    }));
+    fs.open(
+      file,
+      'w+',
+      input,
+      common.mustCall((err, fd) => {
+        assert.ifError(err);
+        assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
+        fs.closeSync(fd);
+        assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
+      })
+    );
   }
 }
 
diff --git a/test/parallel/test-fs-open.js b/test/parallel/test-fs-open.js
index 788124825249ca..f37cb033322a10 100644
--- a/test/parallel/test-fs-open.js
+++ b/test/parallel/test-fs-open.js
@@ -38,32 +38,55 @@ assert.strictEqual(caughtException, true);
 
 fs.openSync(__filename);
 
-fs.open(__filename, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(
+  __filename,
+  common.mustCall((err) => {
+    assert.ifError(err);
+  })
+);
 
-fs.open(__filename, 'r', common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(
+  __filename,
+  'r',
+  common.mustCall((err) => {
+    assert.ifError(err);
+  })
+);
 
-fs.open(__filename, 'rs', common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(
+  __filename,
+  'rs',
+  common.mustCall((err) => {
+    assert.ifError(err);
+  })
+);
 
-fs.open(__filename, 'r', 0, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(
+  __filename,
+  'r',
+  0,
+  common.mustCall((err) => {
+    assert.ifError(err);
+  })
+);
 
-fs.open(__filename, 'r', null, common.mustCall((err) => {
-  assert.ifError(err);
-}));
+fs.open(
+  __filename,
+  'r',
+  null,
+  common.mustCall((err) => {
+    assert.ifError(err);
+  })
+);
 
 async function promise() {
   await fs.promises.open(__filename);
   await fs.promises.open(__filename, 'r');
 }
 
-promise().then(common.mustCall()).catch(common.mustNotCall());
+promise()
+  .then(common.mustCall())
+  .catch(common.mustNotCall());
 
 common.expectsError(
   () => fs.open(__filename, 'r', 'boom', common.mustNotCall()),
@@ -74,39 +97,35 @@ common.expectsError(
 );
 
 for (const extra of [[], ['r'], ['r', 0], ['r', 0, 'bad callback']]) {
-  common.expectsError(
-    () => fs.open(__filename, ...extra),
-    {
-      code: 'ERR_INVALID_CALLBACK',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.open(__filename, ...extra), {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError
+  });
 }
 
 [false, 1, [], {}, null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.open(i, 'r', common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.openSync(i, 'r', common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  fs.promises.open(i, 'r')
+  common.expectsError(() => fs.open(i, 'r', common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.openSync(i, 'r', common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  fs.promises
+    .open(i, 'r')
     .then(common.mustNotCall())
-    .catch(common.mustCall((err) => {
-      common.expectsError(
-        () => { throw err; },
-        {
-          code: 'ERR_INVALID_ARG_TYPE',
-          type: TypeError
-        }
-      );
-    }));
+    .catch(
+      common.mustCall((err) => {
+        common.expectsError(
+          () => {
+            throw err;
+          },
+          {
+            code: 'ERR_INVALID_ARG_TYPE',
+            type: TypeError
+          }
+        );
+      })
+    );
 });
diff --git a/test/parallel/test-fs-options-immutable.js b/test/parallel/test-fs-options-immutable.js
index 3555c82f1962f3..5492a35e29eb80 100644
--- a/test/parallel/test-fs-options-immutable.js
+++ b/test/parallel/test-fs-options-immutable.js
@@ -69,7 +69,10 @@ if (common.canCreateSymLink()) {
 
 {
   const fileName = path.resolve(tmpdir.path, 'streams');
-  fs.WriteStream(fileName, options).once('open', common.mustCall(() => {
-    fs.ReadStream(fileName, options);
-  }));
+  fs.WriteStream(fileName, options).once(
+    'open',
+    common.mustCall(() => {
+      fs.ReadStream(fileName, options);
+    })
+  );
 }
diff --git a/test/parallel/test-fs-promises-file-handle-readFile.js b/test/parallel/test-fs-promises-file-handle-readFile.js
index c31e175019a3fb..212a3a6e5f82cd 100644
--- a/test/parallel/test-fs-promises-file-handle-readFile.js
+++ b/test/parallel/test-fs-promises-file-handle-readFile.js
@@ -35,8 +35,7 @@ async function validateReadFileProc() {
   // - https://github.com/nodejs/node/issues/21331
 
   // Test is Linux-specific.
-  if (!common.isLinux)
-    return;
+  if (!common.isLinux) return;
 
   const fileHandle = await open('/proc/sys/kernel/hostname', 'r');
   const hostname = await fileHandle.readFile();
diff --git a/test/parallel/test-fs-promises-file-handle-stat.js b/test/parallel/test-fs-promises-file-handle-stat.js
index 19ee365213d302..a8f35621ca35e3 100644
--- a/test/parallel/test-fs-promises-file-handle-stat.js
+++ b/test/parallel/test-fs-promises-file-handle-stat.js
@@ -19,5 +19,4 @@ async function validateStat() {
   assert.ok(stats.mtime instanceof Date);
 }
 
-validateStat()
-  .then(common.mustCall());
+validateStat().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-file-handle-writeFile.js b/test/parallel/test-fs-promises-file-handle-writeFile.js
index e39c59f5cae80c..079f9205078468 100644
--- a/test/parallel/test-fs-promises-file-handle-writeFile.js
+++ b/test/parallel/test-fs-promises-file-handle-writeFile.js
@@ -24,5 +24,4 @@ async function validateWriteFile() {
   assert.deepStrictEqual(buffer, readFileData);
 }
 
-validateWriteFile()
-  .then(common.mustCall());
+validateWriteFile().then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-readfile-empty.js b/test/parallel/test-fs-promises-readfile-empty.js
index ef15a2681123c6..b21bd3c4f978b8 100644
--- a/test/parallel/test-fs-promises-readfile-empty.js
+++ b/test/parallel/test-fs-promises-readfile-empty.js
@@ -7,11 +7,8 @@ const fixtures = require('../common/fixtures');
 
 const fn = fixtures.path('empty.txt');
 
-fs.readFile(fn)
-  .then(assert.ok);
+fs.readFile(fn).then(assert.ok);
 
-fs.readFile(fn, 'utf8')
-  .then(assert.strictEqual.bind(this, ''));
+fs.readFile(fn, 'utf8').then(assert.strictEqual.bind(this, ''));
 
-fs.readFile(fn, { encoding: 'utf8' })
-  .then(assert.strictEqual.bind(this, ''));
+fs.readFile(fn, { encoding: 'utf8' }).then(assert.strictEqual.bind(this, ''));
diff --git a/test/parallel/test-fs-promises-readfile.js b/test/parallel/test-fs-promises-readfile.js
index ff25be75b84ff0..6710d30d1c4978 100644
--- a/test/parallel/test-fs-promises-readfile.js
+++ b/test/parallel/test-fs-promises-readfile.js
@@ -15,7 +15,7 @@ async function validateReadFile() {
   const buffer = Buffer.from(
     Array.apply(null, { length: 16834 * 2 })
       .map(Math.random)
-      .map((number) => (number * (1 << 8)))
+      .map((number) => number * (1 << 8))
   );
 
   // Writing buffer to a file then try to read it
@@ -32,8 +32,7 @@ async function validateReadFileProc() {
   // - https://github.com/nodejs/node/issues/21331
 
   // Test is Linux-specific.
-  if (!common.isLinux)
-    return;
+  if (!common.isLinux) return;
 
   const hostname = await readFile('/proc/sys/kernel/hostname');
   assert.ok(hostname.length > 0);
diff --git a/test/parallel/test-fs-promises.js b/test/parallel/test-fs-promises.js
index 6b8fe3bb250899..b56bad5c3e03fd 100644
--- a/test/parallel/test-fs-promises.js
+++ b/test/parallel/test-fs-promises.js
@@ -45,17 +45,17 @@ function nextdir() {
 assert.strictEqual(Object.keys(fs).includes('promises'), false);
 
 {
-  access(__filename, 'r')
-    .then(common.mustCall());
+  access(__filename, 'r').then(common.mustCall());
 
   access('this file does not exist', 'r')
     .then(common.mustNotCall())
-    .catch(common.expectsError({
-      code: 'ENOENT',
-      type: Error,
-      message:
-        /^ENOENT: no such file or directory, access/
-    }));
+    .catch(
+      common.expectsError({
+        code: 'ENOENT',
+        type: Error,
+        message: /^ENOENT: no such file or directory, access/
+      })
+    );
 }
 
 function verifyStatObject(stat) {
@@ -150,7 +150,7 @@ async function getHandle(dest) {
       await chmod(dest, 0o666);
       await handle.chmod(0o666);
 
-      await chmod(dest, (0o10777));
+      await chmod(dest, 0o10777);
       await handle.chmod(0o10777);
 
       if (!common.isWindows) {
@@ -165,9 +165,11 @@ async function getHandle(dest) {
         {
           code: 'ERR_OUT_OF_RANGE',
           name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "gid" is out of range. ' +
-                  'It must be >= 0 && < 4294967296. Received -1'
-        });
+          message:
+            'The value of "gid" is out of range. ' +
+            'It must be >= 0 && < 4294967296. Received -1'
+        }
+      );
 
       assert.rejects(
         async () => {
@@ -176,9 +178,11 @@ async function getHandle(dest) {
         {
           code: 'ERR_OUT_OF_RANGE',
           name: 'RangeError [ERR_OUT_OF_RANGE]',
-          message: 'The value of "gid" is out of range. ' +
-                    'It must be >= 0 && < 4294967296. Received -1'
-        });
+          message:
+            'The value of "gid" is out of range. ' +
+            'It must be >= 0 && < 4294967296. Received -1'
+        }
+      );
     }
 
     // set modification times
@@ -217,10 +221,14 @@ async function getHandle(dest) {
         stats = await lstat(newLink);
         verifyStatObject(stats);
 
-        assert.strictEqual(newPath.toLowerCase(),
-                           (await realpath(newLink)).toLowerCase());
-        assert.strictEqual(newPath.toLowerCase(),
-                           (await readlink(newLink)).toLowerCase());
+        assert.strictEqual(
+          newPath.toLowerCase(),
+          (await realpath(newLink)).toLowerCase()
+        );
+        assert.strictEqual(
+          newPath.toLowerCase(),
+          (await readlink(newLink)).toLowerCase()
+        );
 
         const newMode = 0o666;
         if (common.isOSX) {
@@ -337,7 +345,8 @@ async function getHandle(dest) {
           {
             code: 'ERR_INVALID_ARG_TYPE',
             name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-            message: 'The "recursive" argument must be of type boolean. ' +
+            message:
+              'The "recursive" argument must be of type boolean. ' +
               `Received type ${typeof recursive}`
           }
         );
@@ -356,7 +365,6 @@ async function getHandle(dest) {
         }
       );
     }
-
   }
 
   doTest().then(common.mustCall());
diff --git a/test/parallel/test-fs-promisified.js b/test/parallel/test-fs-promisified.js
index 0744f62fd17fa5..fdf7fb46b3dbbe 100644
--- a/test/parallel/test-fs-promisified.js
+++ b/test/parallel/test-fs-promisified.js
@@ -11,11 +11,13 @@ const exists = promisify(fs.exists);
 
 {
   const fd = fs.openSync(__filename, 'r');
-  read(fd, Buffer.alloc(1024), 0, 1024, null).then(common.mustCall((obj) => {
-    assert.strictEqual(typeof obj.bytesRead, 'number');
-    assert(obj.buffer instanceof Buffer);
-    fs.closeSync(fd);
-  }));
+  read(fd, Buffer.alloc(1024), 0, 1024, null).then(
+    common.mustCall((obj) => {
+      assert.strictEqual(typeof obj.bytesRead, 'number');
+      assert(obj.buffer instanceof Buffer);
+      fs.closeSync(fd);
+    })
+  );
 }
 
 const tmpdir = require('../common/tmpdir');
@@ -23,15 +25,19 @@ tmpdir.refresh();
 {
   const filename = path.join(tmpdir.path, 'write-promise.txt');
   const fd = fs.openSync(filename, 'w');
-  write(fd, Buffer.from('foobar')).then(common.mustCall((obj) => {
-    assert.strictEqual(typeof obj.bytesWritten, 'number');
-    assert.strictEqual(obj.buffer.toString(), 'foobar');
-    fs.closeSync(fd);
-  }));
+  write(fd, Buffer.from('foobar')).then(
+    common.mustCall((obj) => {
+      assert.strictEqual(typeof obj.bytesWritten, 'number');
+      assert.strictEqual(obj.buffer.toString(), 'foobar');
+      fs.closeSync(fd);
+    })
+  );
 }
 
 {
-  exists(__filename).then(common.mustCall((x) => {
-    assert.strictEqual(x, true);
-  }));
+  exists(__filename).then(
+    common.mustCall((x) => {
+      assert.strictEqual(x, true);
+    })
+  );
 }
diff --git a/test/parallel/test-fs-read-empty-buffer.js b/test/parallel/test-fs-read-empty-buffer.js
index 2f44b9a1843a6b..03c99f4b1575af 100644
--- a/test/parallel/test-fs-read-empty-buffer.js
+++ b/test/parallel/test-fs-read-empty-buffer.js
@@ -10,32 +10,26 @@ const fsPromises = fs.promises;
 
 const buffer = new Uint8Array();
 
-assert.throws(
-  () => fs.readSync(fd, buffer, 0, 10, 0),
-  {
-    code: 'ERR_INVALID_ARG_VALUE',
-    message: 'The argument \'buffer\' is empty and cannot be written. ' +
+assert.throws(() => fs.readSync(fd, buffer, 0, 10, 0), {
+  code: 'ERR_INVALID_ARG_VALUE',
+  message:
+    "The argument 'buffer' is empty and cannot be written. " +
     'Received Uint8Array []'
-  }
-);
+});
 
-assert.throws(
-  () => fs.read(fd, buffer, 0, 1, 0, common.mustNotCall()),
-  {
-    code: 'ERR_INVALID_ARG_VALUE',
-    message: 'The argument \'buffer\' is empty and cannot be written. ' +
+assert.throws(() => fs.read(fd, buffer, 0, 1, 0, common.mustNotCall()), {
+  code: 'ERR_INVALID_ARG_VALUE',
+  message:
+    "The argument 'buffer' is empty and cannot be written. " +
     'Received Uint8Array []'
-  }
-);
+});
 
 (async () => {
   const filehandle = await fsPromises.open(filepath, 'r');
-  assert.rejects(
-    () => filehandle.read(buffer, 0, 1, 0),
-    {
-      code: 'ERR_INVALID_ARG_VALUE',
-      message: 'The argument \'buffer\' is empty and cannot be written. ' +
-               'Received Uint8Array []'
-    }
-  );
+  assert.rejects(() => filehandle.read(buffer, 0, 1, 0), {
+    code: 'ERR_INVALID_ARG_VALUE',
+    message:
+      "The argument 'buffer' is empty and cannot be written. " +
+      'Received Uint8Array []'
+  });
 })();
diff --git a/test/parallel/test-fs-read-file-sync-hostname.js b/test/parallel/test-fs-read-file-sync-hostname.js
index 599f48b6ccfcfe..9f90449175883a 100644
--- a/test/parallel/test-fs-read-file-sync-hostname.js
+++ b/test/parallel/test-fs-read-file-sync-hostname.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.isLinux)
-  common.skip('Test is linux specific.');
+if (!common.isLinux) common.skip('Test is linux specific.');
 
 const assert = require('assert');
 const fs = require('fs');
diff --git a/test/parallel/test-fs-read-stream-concurrent-reads.js b/test/parallel/test-fs-read-stream-concurrent-reads.js
index 32a6cd62363f05..7d867cf94949c9 100644
--- a/test/parallel/test-fs-read-stream-concurrent-reads.js
+++ b/test/parallel/test-fs-read-stream-concurrent-reads.js
@@ -10,7 +10,7 @@ const fs = require('fs');
 
 // Refs: https://github.com/nodejs/node/issues/21967
 
-const filename = fixtures.path('loop.js');  // Some small non-homogeneous file.
+const filename = fixtures.path('loop.js'); // Some small non-homogeneous file.
 const content = fs.readFileSync(filename);
 
 const N = 1000;
@@ -26,22 +26,26 @@ function startRead() {
     .on('data', (chunk) => {
       chunks.push(chunk);
       arrayBuffers.add(chunk.buffer);
-      if (started < N)
-        startRead();
+      if (started < N) startRead();
     })
-    .on('end', common.mustCall(() => {
-      assert.deepStrictEqual(Buffer.concat(chunks), content);
-      if (++done === N) {
-        const retainedMemory =
-          [...arrayBuffers].map((ab) => ab.byteLength).reduce((a, b) => a + b);
-        assert(retainedMemory / (N * content.length) <= 3,
-               `Retaining ${retainedMemory} bytes in ABs for ${N} ` +
-               `chunks of size ${content.length}`);
-      }
-    }));
+    .on(
+      'end',
+      common.mustCall(() => {
+        assert.deepStrictEqual(Buffer.concat(chunks), content);
+        if (++done === N) {
+          const retainedMemory = [...arrayBuffers]
+            .map((ab) => ab.byteLength)
+            .reduce((a, b) => a + b);
+          assert(
+            retainedMemory / (N * content.length) <= 3,
+            `Retaining ${retainedMemory} bytes in ABs for ${N} ` +
+              `chunks of size ${content.length}`
+          );
+        }
+      })
+    );
 }
 
 // Don’t start the reads all at once – that way we would have to allocate
 // a large amount of memory upfront.
-for (let i = 0; i < 4; ++i)
-  startRead();
+for (let i = 0; i < 4; ++i) startRead();
diff --git a/test/parallel/test-fs-read-stream-err.js b/test/parallel/test-fs-read-stream-err.js
index a9b4838cf1834f..aa4adb1fa46d97 100644
--- a/test/parallel/test-fs-read-stream-err.js
+++ b/test/parallel/test-fs-read-stream-err.js
@@ -29,12 +29,17 @@ const stream = fs.createReadStream(__filename, {
 });
 const err = new Error('BAM');
 
-stream.on('error', common.mustCall((err_) => {
-  process.nextTick(common.mustCall(() => {
-    assert.strictEqual(stream.fd, null);
-    assert.strictEqual(err_, err);
-  }));
-}));
+stream.on(
+  'error',
+  common.mustCall((err_) => {
+    process.nextTick(
+      common.mustCall(() => {
+        assert.strictEqual(stream.fd, null);
+        assert.strictEqual(err_, err);
+      })
+    );
+  })
+);
 
 fs.close = common.mustCall((fd_, cb) => {
   assert.strictEqual(fd_, stream.fd);
diff --git a/test/parallel/test-fs-read-stream-inherit.js b/test/parallel/test-fs-read-stream-inherit.js
index a081302cc5a0f1..ea236557265ef5 100644
--- a/test/parallel/test-fs-read-stream-inherit.js
+++ b/test/parallel/test-fs-read-stream-inherit.js
@@ -14,17 +14,20 @@ const rangeFile = fixtures.path('x.txt');
 
   const file = fs.ReadStream(fn);
 
-  file.on('open', common.mustCall(function(fd) {
-    file.length = 0;
-    assert.strictEqual(typeof fd, 'number');
-    assert.ok(file.readable);
-
-    // GH-535
-    file.pause();
-    file.resume();
-    file.pause();
-    file.resume();
-  }));
+  file.on(
+    'open',
+    common.mustCall(function(fd) {
+      file.length = 0;
+      assert.strictEqual(typeof fd, 'number');
+      assert.ok(file.readable);
+
+      // GH-535
+      file.pause();
+      file.resume();
+      file.pause();
+      file.resume();
+    })
+  );
 
   file.on('data', function(data) {
     assert.ok(data instanceof Buffer);
@@ -40,13 +43,14 @@ const rangeFile = fixtures.path('x.txt');
     }, 10);
   });
 
-
   file.on('end', common.mustCall());
 
-
-  file.on('close', common.mustCall(function() {
-    assert.strictEqual(file.length, 30000);
-  }));
+  file.on(
+    'close',
+    common.mustCall(function() {
+      assert.strictEqual(file.length, 30000);
+    })
+  );
 }
 
 {
@@ -62,9 +66,12 @@ const rangeFile = fixtures.path('x.txt');
     }
   });
 
-  file.on('close', common.mustCall(function() {
-    assert.strictEqual(file.length, 10000);
-  }));
+  file.on(
+    'close',
+    common.mustCall(function() {
+      assert.strictEqual(file.length, 10000);
+    })
+  );
 }
 
 {
@@ -76,9 +83,12 @@ const rangeFile = fixtures.path('x.txt');
   file.on('data', function(data) {
     contentRead += data.toString('utf-8');
   });
-  file.on('end', common.mustCall(function() {
-    assert.strictEqual(contentRead, 'yz');
-  }));
+  file.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(contentRead, 'yz');
+    })
+  );
 }
 
 {
@@ -89,9 +99,12 @@ const rangeFile = fixtures.path('x.txt');
   file.on('data', function(data) {
     file.data += data.toString('utf-8');
   });
-  file.on('end', common.mustCall(function() {
-    assert.strictEqual(file.data, 'yz\n');
-  }));
+  file.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(file.data, 'yz\n');
+    })
+  );
 }
 
 // https://github.com/joyent/node/issues/2320
@@ -103,9 +116,12 @@ const rangeFile = fixtures.path('x.txt');
   file.on('data', function(data) {
     file.data += data.toString('utf-8');
   });
-  file.on('end', common.mustCall(function() {
-    assert.strictEqual(file.data, 'yz\n');
-  }));
+  file.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(file.data, 'yz\n');
+    })
+  );
 }
 
 {
@@ -121,7 +137,8 @@ const rangeFile = fixtures.path('x.txt');
       code: 'ERR_OUT_OF_RANGE',
       message,
       type: RangeError
-    });
+    }
+  );
 }
 
 {
@@ -135,9 +152,12 @@ const rangeFile = fixtures.path('x.txt');
     stream.data += chunk;
   });
 
-  stream.on('end', common.mustCall(function() {
-    assert.strictEqual(stream.data, 'x');
-  }));
+  stream.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(stream.data, 'x');
+    })
+  );
 }
 
 // pause and then resume immediately.
@@ -149,18 +169,27 @@ const rangeFile = fixtures.path('x.txt');
 
 {
   let data = '';
-  let file =
-    fs.createReadStream(rangeFile, Object.create({ autoClose: false }));
+  let file = fs.createReadStream(
+    rangeFile,
+    Object.create({ autoClose: false })
+  );
   assert.strictEqual(file.autoClose, false);
-  file.on('data', (chunk) => { data += chunk; });
-  file.on('end', common.mustCall(function() {
-    process.nextTick(common.mustCall(function() {
-      assert(!file.closed);
-      assert(!file.destroyed);
-      assert.strictEqual(data, 'xyz\n');
-      fileNext();
-    }));
-  }));
+  file.on('data', (chunk) => {
+    data += chunk;
+  });
+  file.on(
+    'end',
+    common.mustCall(function() {
+      process.nextTick(
+        common.mustCall(function() {
+          assert(!file.closed);
+          assert(!file.destroyed);
+          assert.strictEqual(data, 'xyz\n');
+          fileNext();
+        })
+      );
+    })
+  );
 
   function fileNext() {
     // This will tell us if the fd is usable again or not.
@@ -169,9 +198,12 @@ const rangeFile = fixtures.path('x.txt');
     file.on('data', function(data) {
       file.data += data;
     });
-    file.on('end', common.mustCall(function() {
-      assert.strictEqual(file.data, 'xyz\n');
-    }));
+    file.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(file.data, 'xyz\n');
+      })
+    );
   }
   process.on('exit', function() {
     assert(file.closed);
diff --git a/test/parallel/test-fs-read-stream-throw-type-error.js b/test/parallel/test-fs-read-stream-throw-type-error.js
index 458df4d347efc4..78ccc7f799ba9e 100644
--- a/test/parallel/test-fs-read-stream-throw-type-error.js
+++ b/test/parallel/test-fs-read-stream-throw-type-error.js
@@ -71,6 +71,4 @@ const NOT_SAFE_INTEGER = 2 ** 53;
 [
   { start: NOT_SAFE_INTEGER, end: Infinity },
   { start: 0, end: NOT_SAFE_INTEGER }
-].forEach((opts) =>
-  createReadStreamErr(example, opts, rangeError)
-);
+].forEach((opts) => createReadStreamErr(example, opts, rangeError));
diff --git a/test/parallel/test-fs-read-stream.js b/test/parallel/test-fs-read-stream.js
index 2a07a09c976574..ed2466c5e46d6c 100644
--- a/test/parallel/test-fs-read-stream.js
+++ b/test/parallel/test-fs-read-stream.js
@@ -40,18 +40,21 @@ const rangeFile = fixtures.path('x.txt');
 
   assert.strictEqual(file.bytesRead, 0);
 
-  file.on('open', common.mustCall(function(fd) {
-    file.length = 0;
-    assert.strictEqual(typeof fd, 'number');
-    assert.strictEqual(file.bytesRead, 0);
-    assert.ok(file.readable);
-
-    // GH-535
-    file.pause();
-    file.resume();
-    file.pause();
-    file.resume();
-  }));
+  file.on(
+    'open',
+    common.mustCall(function(fd) {
+      file.length = 0;
+      assert.strictEqual(typeof fd, 'number');
+      assert.strictEqual(file.bytesRead, 0);
+      assert.ok(file.readable);
+
+      // GH-535
+      file.pause();
+      file.resume();
+      file.pause();
+      file.resume();
+    })
+  );
 
   file.on('data', function(data) {
     assert.ok(data instanceof Buffer);
@@ -70,17 +73,21 @@ const rangeFile = fixtures.path('x.txt');
     }, 10);
   });
 
-
-  file.on('end', common.mustCall(function(chunk) {
-    assert.strictEqual(bytesRead, fileSize);
-    assert.strictEqual(file.bytesRead, fileSize);
-  }));
-
-
-  file.on('close', common.mustCall(function() {
-    assert.strictEqual(bytesRead, fileSize);
-    assert.strictEqual(file.bytesRead, fileSize);
-  }));
+  file.on(
+    'end',
+    common.mustCall(function(chunk) {
+      assert.strictEqual(bytesRead, fileSize);
+      assert.strictEqual(file.bytesRead, fileSize);
+    })
+  );
+
+  file.on(
+    'close',
+    common.mustCall(function() {
+      assert.strictEqual(bytesRead, fileSize);
+      assert.strictEqual(file.bytesRead, fileSize);
+    })
+  );
 
   process.on('exit', function() {
     assert.strictEqual(file.length, 30000);
@@ -108,15 +115,21 @@ const rangeFile = fixtures.path('x.txt');
 }
 
 {
-  const file =
-    fs.createReadStream(rangeFile, { bufferSize: 1, start: 1, end: 2 });
+  const file = fs.createReadStream(rangeFile, {
+    bufferSize: 1,
+    start: 1,
+    end: 2
+  });
   let contentRead = '';
   file.on('data', function(data) {
     contentRead += data.toString('utf-8');
   });
-  file.on('end', common.mustCall(function(data) {
-    assert.strictEqual(contentRead, 'yz');
-  }));
+  file.on(
+    'end',
+    common.mustCall(function(data) {
+      assert.strictEqual(contentRead, 'yz');
+    })
+  );
 }
 
 {
@@ -125,9 +138,12 @@ const rangeFile = fixtures.path('x.txt');
   file.on('data', function(data) {
     file.data += data.toString('utf-8');
   });
-  file.on('end', common.mustCall(function() {
-    assert.strictEqual(file.data, 'yz\n');
-  }));
+  file.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(file.data, 'yz\n');
+    })
+  );
 }
 
 {
@@ -137,9 +153,12 @@ const rangeFile = fixtures.path('x.txt');
   file.on('data', function(data) {
     file.data += data.toString('utf-8');
   });
-  file.on('end', common.mustCall(function() {
-    assert.strictEqual(file.data, 'yz\n');
-  }));
+  file.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(file.data, 'yz\n');
+    })
+  );
 }
 
 common.expectsError(
@@ -148,10 +167,12 @@ common.expectsError(
   },
   {
     code: 'ERR_OUT_OF_RANGE',
-    message: 'The value of "start" is out of range. It must be <= "end"' +
-             ' (here: 2). Received 10',
+    message:
+      'The value of "start" is out of range. It must be <= "end"' +
+      ' (here: 2). Received 10',
     type: RangeError
-  });
+  }
+);
 
 {
   const stream = fs.createReadStream(rangeFile, { start: 0, end: 0 });
@@ -161,9 +182,12 @@ common.expectsError(
     stream.data += chunk;
   });
 
-  stream.on('end', common.mustCall(function() {
-    assert.strictEqual(stream.data, 'x');
-  }));
+  stream.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(stream.data, 'x');
+    })
+  );
 }
 
 {
@@ -175,9 +199,12 @@ common.expectsError(
     stream.data += chunk;
   });
 
-  stream.on('end', common.mustCall(function() {
-    assert.strictEqual(stream.data, 'xy');
-  }));
+  stream.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(stream.data, 'xy');
+    })
+  );
 }
 
 if (!common.isWindows) {
@@ -196,10 +223,13 @@ if (!common.isWindows) {
       stream.data += chunk;
     });
 
-    stream.on('end', common.mustCall(function() {
-      assert.strictEqual(stream.data, 'xy');
-      fs.unlinkSync(filename);
-    }));
+    stream.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(stream.data, 'xy');
+        fs.unlinkSync(filename);
+      })
+    );
   } else {
     common.printSkipMessage('mkfifo not available');
   }
@@ -215,15 +245,20 @@ if (!common.isWindows) {
 {
   let file = fs.createReadStream(rangeFile, { autoClose: false });
   let data = '';
-  file.on('data', function(chunk) { data += chunk; });
-  file.on('end', common.mustCall(function() {
-    assert.strictEqual(data, 'xyz\n');
-    process.nextTick(function() {
-      assert(!file.closed);
-      assert(!file.destroyed);
-      fileNext();
-    });
-  }));
+  file.on('data', function(chunk) {
+    data += chunk;
+  });
+  file.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(data, 'xyz\n');
+      process.nextTick(function() {
+        assert(!file.closed);
+        assert(!file.destroyed);
+        fileNext();
+      });
+    })
+  );
 
   function fileNext() {
     // This will tell us if the fd is usable again or not.
@@ -232,9 +267,12 @@ if (!common.isWindows) {
     file.on('data', function(data) {
       file.data += data;
     });
-    file.on('end', common.mustCall(function(err) {
-      assert.strictEqual(file.data, 'xyz\n');
-    }));
+    file.on(
+      'end',
+      common.mustCall(function(err) {
+        assert.strictEqual(file.data, 'xyz\n');
+      })
+    );
     process.on('exit', function() {
       assert(file.closed);
       assert(file.destroyed);
diff --git a/test/parallel/test-fs-read-type.js b/test/parallel/test-fs-read-type.js
index d75464ce0ab1f3..0580eb8917f489 100644
--- a/test/parallel/test-fs-read-type.js
+++ b/test/parallel/test-fs-read-type.js
@@ -8,110 +8,137 @@ const filepath = fixtures.path('x.txt');
 const fd = fs.openSync(filepath, 'r');
 const expected = 'xyz\n';
 
-
 // Error must be thrown with string
 assert.throws(
   () => fs.read(fd, expected.length, 0, 'utf-8', common.mustNotCall()),
   {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "buffer" argument must be one of type Buffer, TypedArray, ' +
-             'or DataView. Received type number'
+    message:
+      'The "buffer" argument must be one of type Buffer, TypedArray, ' +
+      'or DataView. Received type number'
   }
 );
 
 [true, null, undefined, () => {}, {}].forEach((value) => {
-  assert.throws(() => {
-    fs.read(value,
-            Buffer.allocUnsafe(expected.length),
-            0,
-            expected.length,
-            0,
-            common.mustNotCall());
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "fd" argument must be of type number. ' +
-             `Received type ${typeof value}`
-  });
-});
-
-assert.throws(() => {
-  fs.read(fd,
-          Buffer.allocUnsafe(expected.length),
-          -1,
-          expected.length,
-          0,
-          common.mustNotCall());
-}, {
-  code: 'ERR_OUT_OF_RANGE',
-  name: 'RangeError [ERR_OUT_OF_RANGE]',
-  message: 'The value of "offset" is out of range. It must be >= 0 && <= 4. ' +
-           'Received -1'
-});
-
-assert.throws(() => {
-  fs.read(fd,
-          Buffer.allocUnsafe(expected.length),
-          0,
-          -1,
-          0,
-          common.mustNotCall());
-}, {
-  code: 'ERR_OUT_OF_RANGE',
-  name: 'RangeError [ERR_OUT_OF_RANGE]',
-  message: 'The value of "length" is out of range. ' +
-           'It must be >= 0 && <= 4. Received -1'
+  assert.throws(
+    () => {
+      fs.read(
+        value,
+        Buffer.allocUnsafe(expected.length),
+        0,
+        expected.length,
+        0,
+        common.mustNotCall()
+      );
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "fd" argument must be of type number. ' +
+        `Received type ${typeof value}`
+    }
+  );
 });
 
+assert.throws(
+  () => {
+    fs.read(
+      fd,
+      Buffer.allocUnsafe(expected.length),
+      -1,
+      expected.length,
+      0,
+      common.mustNotCall()
+    );
+  },
+  {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError [ERR_OUT_OF_RANGE]',
+    message:
+      'The value of "offset" is out of range. It must be >= 0 && <= 4. ' +
+      'Received -1'
+  }
+);
 
 assert.throws(
-  () => fs.readSync(fd, expected.length, 0, 'utf-8'),
+  () => {
+    fs.read(
+      fd,
+      Buffer.allocUnsafe(expected.length),
+      0,
+      -1,
+      0,
+      common.mustNotCall()
+    );
+  },
   {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "buffer" argument must be one of type Buffer, TypedArray, ' +
-             'or DataView. Received type number'
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError [ERR_OUT_OF_RANGE]',
+    message:
+      'The value of "length" is out of range. ' +
+      'It must be >= 0 && <= 4. Received -1'
   }
 );
 
-[true, null, undefined, () => {}, {}].forEach((value) => {
-  assert.throws(() => {
-    fs.readSync(value,
-                Buffer.allocUnsafe(expected.length),
-                0,
-                expected.length,
-                0);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "fd" argument must be of type number. ' +
-             `Received type ${typeof value}`
-  });
+assert.throws(() => fs.readSync(fd, expected.length, 0, 'utf-8'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+  message:
+    'The "buffer" argument must be one of type Buffer, TypedArray, ' +
+    'or DataView. Received type number'
 });
 
-assert.throws(() => {
-  fs.readSync(fd,
-              Buffer.allocUnsafe(expected.length),
-              -1,
-              expected.length,
-              0);
-}, {
-  code: 'ERR_OUT_OF_RANGE',
-  name: 'RangeError [ERR_OUT_OF_RANGE]',
-  message: 'The value of "offset" is out of range. ' +
-           'It must be >= 0 && <= 4. Received -1'
+[true, null, undefined, () => {}, {}].forEach((value) => {
+  assert.throws(
+    () => {
+      fs.readSync(
+        value,
+        Buffer.allocUnsafe(expected.length),
+        0,
+        expected.length,
+        0
+      );
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "fd" argument must be of type number. ' +
+        `Received type ${typeof value}`
+    }
+  );
 });
 
-assert.throws(() => {
-  fs.readSync(fd,
-              Buffer.allocUnsafe(expected.length),
-              0,
-              -1,
-              0);
-}, {
-  code: 'ERR_OUT_OF_RANGE',
-  name: 'RangeError [ERR_OUT_OF_RANGE]',
-  message: 'The value of "length" is out of range. ' +
-           'It must be >= 0 && <= 4. Received -1'
-});
+assert.throws(
+  () => {
+    fs.readSync(
+      fd,
+      Buffer.allocUnsafe(expected.length),
+      -1,
+      expected.length,
+      0
+    );
+  },
+  {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError [ERR_OUT_OF_RANGE]',
+    message:
+      'The value of "offset" is out of range. ' +
+      'It must be >= 0 && <= 4. Received -1'
+  }
+);
+
+assert.throws(
+  () => {
+    fs.readSync(fd, Buffer.allocUnsafe(expected.length), 0, -1, 0);
+  },
+  {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError [ERR_OUT_OF_RANGE]',
+    message:
+      'The value of "length" is out of range. ' +
+      'It must be >= 0 && <= 4. Received -1'
+  }
+);
diff --git a/test/parallel/test-fs-read-zero-length.js b/test/parallel/test-fs-read-zero-length.js
index ac2efc73f5107b..860d784ff4df33 100644
--- a/test/parallel/test-fs-read-zero-length.js
+++ b/test/parallel/test-fs-read-zero-length.js
@@ -8,10 +8,17 @@ const fd = fs.openSync(filepath, 'r');
 const bufferAsync = Buffer.alloc(0);
 const bufferSync = Buffer.alloc(0);
 
-fs.read(fd, bufferAsync, 0, 0, 0, common.mustCall((err, bytesRead) => {
-  assert.strictEqual(bytesRead, 0);
-  assert.deepStrictEqual(bufferAsync, Buffer.alloc(0));
-}));
+fs.read(
+  fd,
+  bufferAsync,
+  0,
+  0,
+  0,
+  common.mustCall((err, bytesRead) => {
+    assert.strictEqual(bytesRead, 0);
+    assert.deepStrictEqual(bufferAsync, Buffer.alloc(0));
+  })
+);
 
 const r = fs.readSync(fd, bufferSync, 0, 0, 0);
 assert.deepStrictEqual(bufferSync, Buffer.alloc(0));
diff --git a/test/parallel/test-fs-read.js b/test/parallel/test-fs-read.js
index d3de036b67e6e4..dab8b7e045dc23 100644
--- a/test/parallel/test-fs-read.js
+++ b/test/parallel/test-fs-read.js
@@ -30,29 +30,35 @@ const fd = fs.openSync(filepath, 'r');
 const expected = Buffer.from('xyz\n');
 
 function test(bufferAsync, bufferSync, expected) {
-  fs.read(fd,
-          bufferAsync,
-          0,
-          expected.length,
-          0,
-          common.mustCall((err, bytesRead) => {
-            assert.ifError(err);
-            assert.strictEqual(bytesRead, expected.length);
-            assert.deepStrictEqual(bufferAsync, expected);
-          }));
+  fs.read(
+    fd,
+    bufferAsync,
+    0,
+    expected.length,
+    0,
+    common.mustCall((err, bytesRead) => {
+      assert.ifError(err);
+      assert.strictEqual(bytesRead, expected.length);
+      assert.deepStrictEqual(bufferAsync, expected);
+    })
+  );
 
   const r = fs.readSync(fd, bufferSync, 0, expected.length, 0);
   assert.deepStrictEqual(bufferSync, expected);
   assert.strictEqual(r, expected.length);
 }
 
-test(Buffer.allocUnsafe(expected.length),
-     Buffer.allocUnsafe(expected.length),
-     expected);
+test(
+  Buffer.allocUnsafe(expected.length),
+  Buffer.allocUnsafe(expected.length),
+  expected
+);
 
-test(new Uint8Array(expected.length),
-     new Uint8Array(expected.length),
-     Uint8Array.from(expected));
+test(
+  new Uint8Array(expected.length),
+  new Uint8Array(expected.length),
+  Uint8Array.from(expected)
+);
 
 {
   // Reading beyond file length (3 in this case) should return no data.
@@ -62,24 +68,25 @@ test(new Uint8Array(expected.length),
   const nRead = fs.readSync(fd, Buffer.alloc(1), 0, 1, pos);
   assert.strictEqual(nRead, 0);
 
-  fs.read(fd, Buffer.alloc(1), 0, 1, pos, common.mustCall((err, nRead) => {
-    assert.ifError(err);
-    assert.strictEqual(nRead, 0);
-  }));
+  fs.read(
+    fd,
+    Buffer.alloc(1),
+    0,
+    1,
+    pos,
+    common.mustCall((err, nRead) => {
+      assert.ifError(err);
+      assert.strictEqual(nRead, 0);
+    })
+  );
 }
 
-assert.throws(
-  () => fs.read(fd, Buffer.alloc(1), 0, 1, 0),
-  {
-    message: 'Callback must be a function',
-    code: 'ERR_INVALID_CALLBACK',
-  }
-);
+assert.throws(() => fs.read(fd, Buffer.alloc(1), 0, 1, 0), {
+  message: 'Callback must be a function',
+  code: 'ERR_INVALID_CALLBACK'
+});
 
-assert.throws(
-  () => fs.read(null, Buffer.alloc(1), 0, 1, 0),
-  {
-    message: 'The "fd" argument must be of type number. Received type object',
-    code: 'ERR_INVALID_ARG_TYPE',
-  }
-);
+assert.throws(() => fs.read(null, Buffer.alloc(1), 0, 1, 0), {
+  message: 'The "fd" argument must be of type number. Received type object',
+  code: 'ERR_INVALID_ARG_TYPE'
+});
diff --git a/test/parallel/test-fs-readdir-stack-overflow.js b/test/parallel/test-fs-readdir-stack-overflow.js
index b7dea52cc37ec5..2a53016af0cbe2 100644
--- a/test/parallel/test-fs-readdir-stack-overflow.js
+++ b/test/parallel/test-fs-readdir-stack-overflow.js
@@ -9,10 +9,7 @@ function recurse() {
   recurse();
 }
 
-common.expectsError(
-  () => recurse(),
-  {
-    type: RangeError,
-    message: 'Maximum call stack size exceeded'
-  }
-);
+common.expectsError(() => recurse(), {
+  type: RangeError,
+  message: 'Maximum call stack size exceeded'
+});
diff --git a/test/parallel/test-fs-readdir-types.js b/test/parallel/test-fs-readdir-types.js
index fa179eccfe26eb..0cab682cc31714 100644
--- a/test/parallel/test-fs-readdir-types.js
+++ b/test/parallel/test-fs-readdir-types.js
@@ -30,7 +30,6 @@ files.forEach(function(currentFile) {
   fs.closeSync(fs.openSync(`${readdirDir}/${currentFile}`, 'w'));
 });
 
-
 function assertDirents(dirents) {
   assert.strictEqual(files.length, dirents.length);
   for (const [i, dirent] of dirents.entries()) {
@@ -49,26 +48,36 @@ function assertDirents(dirents) {
 // Check the readdir Sync version
 assertDirents(fs.readdirSync(readdirDir, { withFileTypes: true }));
 
-fs.readdir(__filename, {
-  withFileTypes: true
-}, common.mustCall((err) => {
-  assert.throws(
-    () => { throw err; },
-    {
-      code: 'ENOTDIR',
-      name: 'Error',
-      message: `ENOTDIR: not a directory, scandir '${__filename}'`
-    }
-  );
-}));
+fs.readdir(
+  __filename,
+  {
+    withFileTypes: true
+  },
+  common.mustCall((err) => {
+    assert.throws(
+      () => {
+        throw err;
+      },
+      {
+        code: 'ENOTDIR',
+        name: 'Error',
+        message: `ENOTDIR: not a directory, scandir '${__filename}'`
+      }
+    );
+  })
+);
 
 // Check the readdir async version
-fs.readdir(readdirDir, {
-  withFileTypes: true
-}, common.mustCall((err, dirents) => {
-  assert.ifError(err);
-  assertDirents(dirents);
-}));
+fs.readdir(
+  readdirDir,
+  {
+    withFileTypes: true
+  },
+  common.mustCall((err, dirents) => {
+    assert.ifError(err);
+    assertDirents(dirents);
+  })
+);
 
 // Check the promisified version
 assert.doesNotReject(async () => {
@@ -100,12 +109,16 @@ binding.readdir = common.mustCall((path, encoding, types, req, ctx) => {
   }
 }, 2);
 assertDirents(fs.readdirSync(readdirDir, { withFileTypes: true }));
-fs.readdir(readdirDir, {
-  withFileTypes: true
-}, common.mustCall((err, dirents) => {
-  assert.ifError(err);
-  assertDirents(dirents);
-}));
+fs.readdir(
+  readdirDir,
+  {
+    withFileTypes: true
+  },
+  common.mustCall((err, dirents) => {
+    assert.ifError(err);
+    assertDirents(dirents);
+  })
+);
 
 // Dirent types
 for (const method of typeMethods) {
diff --git a/test/parallel/test-fs-readdir-ucs2.js b/test/parallel/test-fs-readdir-ucs2.js
index e5b85665932a7c..29be43faba556a 100644
--- a/test/parallel/test-fs-readdir-ucs2.js
+++ b/test/parallel/test-fs-readdir-ucs2.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.isLinux)
-  common.skip('Test is linux specific.');
+if (!common.isLinux) common.skip('Test is linux specific.');
 
 const path = require('path');
 const fs = require('fs');
@@ -23,10 +22,14 @@ try {
   throw e;
 }
 
-fs.readdir(tmpdir.path, 'ucs2', common.mustCall((err, list) => {
-  assert.ifError(err);
-  assert.strictEqual(list.length, 1);
-  const fn = list[0];
-  assert.deepStrictEqual(Buffer.from(fn, 'ucs2'), filebuff);
-  assert.strictEqual(fn, filename);
-}));
+fs.readdir(
+  tmpdir.path,
+  'ucs2',
+  common.mustCall((err, list) => {
+    assert.ifError(err);
+    assert.strictEqual(list.length, 1);
+    const fn = list[0];
+    assert.deepStrictEqual(Buffer.from(fn, 'ucs2'), filebuff);
+    assert.strictEqual(fn, filename);
+  })
+);
diff --git a/test/parallel/test-fs-readdir.js b/test/parallel/test-fs-readdir.js
index a24def6f12db9e..a156aef55753df 100644
--- a/test/parallel/test-fs-readdir.js
+++ b/test/parallel/test-fs-readdir.js
@@ -21,10 +21,13 @@ files.forEach(function(currentFile) {
 assert.deepStrictEqual(files, fs.readdirSync(readdirDir).sort());
 
 // Check the readdir async version
-fs.readdir(readdirDir, common.mustCall(function(err, f) {
-  assert.ifError(err);
-  assert.deepStrictEqual(files, f.sort());
-}));
+fs.readdir(
+  readdirDir,
+  common.mustCall(function(err, f) {
+    assert.ifError(err);
+    assert.deepStrictEqual(files, f.sort());
+  })
+);
 
 // readdir() on file should throw ENOTDIR
 // https://github.com/joyent/node/issues/1869
@@ -32,23 +35,20 @@ assert.throws(function() {
   fs.readdirSync(__filename);
 }, /Error: ENOTDIR: not a directory/);
 
-fs.readdir(__filename, common.mustCall(function(e) {
-  assert.strictEqual(e.code, 'ENOTDIR');
-}));
+fs.readdir(
+  __filename,
+  common.mustCall(function(e) {
+    assert.strictEqual(e.code, 'ENOTDIR');
+  })
+);
 
 [false, 1, [], {}, null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.readdir(i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.readdirSync(i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.readdir(i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.readdirSync(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-fs-readfile-error.js b/test/parallel/test-fs-readfile-error.js
index 719c0061c4e39e..379d79b46a78b9 100644
--- a/test/parallel/test-fs-readfile-error.js
+++ b/test/parallel/test-fs-readfile-error.js
@@ -27,8 +27,7 @@ const fs = require('fs');
 
 // `fs.readFile('/')` does not fail on AIX and FreeBSD because you can open
 // and read the directory there.
-if (common.isAIX || common.isFreeBSD)
-  common.skip('platform not supported.');
+if (common.isAIX || common.isFreeBSD) common.skip('platform not supported.');
 
 const assert = require('assert');
 const exec = require('child_process').exec;
@@ -38,30 +37,43 @@ function test(env, cb) {
   const filename = fixtures.path('test-fs-readfile-error.js');
   const execPath = `"${process.execPath}" "${filename}"`;
   const options = { env: Object.assign({}, process.env, env) };
-  exec(execPath, options, common.mustCall((err, stdout, stderr) => {
-    assert(err);
-    assert.strictEqual(stdout, '');
-    assert.notStrictEqual(stderr, '');
-    cb(String(stderr));
-  }));
+  exec(
+    execPath,
+    options,
+    common.mustCall((err, stdout, stderr) => {
+      assert(err);
+      assert.strictEqual(stdout, '');
+      assert.notStrictEqual(stderr, '');
+      cb(String(stderr));
+    })
+  );
 }
 
-test({ NODE_DEBUG: '' }, common.mustCall((data) => {
-  assert(/EISDIR/.test(data));
-  assert(/test-fs-readfile-error/.test(data));
-}));
+test(
+  { NODE_DEBUG: '' },
+  common.mustCall((data) => {
+    assert(/EISDIR/.test(data));
+    assert(/test-fs-readfile-error/.test(data));
+  })
+);
 
-test({ NODE_DEBUG: 'fs' }, common.mustCall((data) => {
-  assert(/EISDIR/.test(data));
-  assert(/test-fs-readfile-error/.test(data));
-}));
+test(
+  { NODE_DEBUG: 'fs' },
+  common.mustCall((data) => {
+    assert(/EISDIR/.test(data));
+    assert(/test-fs-readfile-error/.test(data));
+  })
+);
 
 common.expectsError(
-  () => { fs.readFile(() => {}, common.mustNotCall()); },
+  () => {
+    fs.readFile(() => {}, common.mustNotCall());
+  },
   {
     code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "path" argument must be one of type string, Buffer, or URL.' +
-             ' Received type function',
+    message:
+      'The "path" argument must be one of type string, Buffer, or URL.' +
+      ' Received type function',
     type: TypeError
   }
 );
diff --git a/test/parallel/test-fs-readfile-pipe.js b/test/parallel/test-fs-readfile-pipe.js
index c9f7144c11a6f6..0f5188d73b45f1 100644
--- a/test/parallel/test-fs-readfile-pipe.js
+++ b/test/parallel/test-fs-readfile-pipe.js
@@ -52,10 +52,12 @@ exec(cmd, function(err, stdout, stderr) {
   assert.strictEqual(
     stdout,
     dataExpected,
-    `expected to read: '${dataExpected}' but got: '${stdout}'`);
+    `expected to read: '${dataExpected}' but got: '${stdout}'`
+  );
   assert.strictEqual(
     stderr,
     '',
-    `expected not to read anything from stderr but got: '${stderr}'`);
+    `expected not to read anything from stderr but got: '${stderr}'`
+  );
   console.log('ok');
 });
diff --git a/test/parallel/test-fs-readfile-zero-byte-liar.js b/test/parallel/test-fs-readfile-zero-byte-liar.js
index ec0b9cf6922c8c..35ea67756496ef 100644
--- a/test/parallel/test-fs-readfile-zero-byte-liar.js
+++ b/test/parallel/test-fs-readfile-zero-byte-liar.js
@@ -50,6 +50,10 @@ fs.fstatSync = (fd) => {
 const d = fs.readFileSync(__filename, 'utf8');
 assert.strictEqual(d, dataExpected);
 
-fs.readFile(__filename, 'utf8', common.mustCall((er, d) => {
-  assert.strictEqual(d, dataExpected);
-}));
+fs.readFile(
+  __filename,
+  'utf8',
+  common.mustCall((er, d) => {
+    assert.strictEqual(d, dataExpected);
+  })
+);
diff --git a/test/parallel/test-fs-readfile.js b/test/parallel/test-fs-readfile.js
index 648bf692d1dcc8..442713af6e60c1 100644
--- a/test/parallel/test-fs-readfile.js
+++ b/test/parallel/test-fs-readfile.js
@@ -14,21 +14,17 @@ const prefix = `.removeme-fs-readfile-${process.pid}`;
 tmpdir.refresh();
 
 const fileInfo = [
-  { name: path.join(tmpdir.path, `${prefix}-1K.txt`),
-    len: 1024,
-  },
-  { name: path.join(tmpdir.path, `${prefix}-64K.txt`),
-    len: 64 * 1024,
-  },
-  { name: path.join(tmpdir.path, `${prefix}-64KLessOne.txt`),
-    len: (64 * 1024) - 1,
-  },
-  { name: path.join(tmpdir.path, `${prefix}-1M.txt`),
-    len: 1 * 1024 * 1024,
-  },
-  { name: path.join(tmpdir.path, `${prefix}-1MPlusOne.txt`),
-    len: (1 * 1024 * 1024) + 1,
+  { name: path.join(tmpdir.path, `${prefix}-1K.txt`), len: 1024 },
+  { name: path.join(tmpdir.path, `${prefix}-64K.txt`), len: 64 * 1024 },
+  {
+    name: path.join(tmpdir.path, `${prefix}-64KLessOne.txt`),
+    len: 64 * 1024 - 1
   },
+  { name: path.join(tmpdir.path, `${prefix}-1M.txt`), len: 1 * 1024 * 1024 },
+  {
+    name: path.join(tmpdir.path, `${prefix}-1MPlusOne.txt`),
+    len: 1 * 1024 * 1024 + 1
+  }
 ];
 
 // Populate each fileInfo (and file) with unique fill.
@@ -51,9 +47,12 @@ for (const e of fileInfo) {
 
 // Test readFile on each size.
 for (const e of fileInfo) {
-  fs.readFile(e.name, common.mustCall((err, buf) => {
-    console.log(`Validating readFile on file ${e.name} of length ${e.len}`);
-    assert.ifError(err);
-    assert.deepStrictEqual(buf, e.contents);
-  }));
+  fs.readFile(
+    e.name,
+    common.mustCall((err, buf) => {
+      console.log(`Validating readFile on file ${e.name} of length ${e.len}`);
+      assert.ifError(err);
+      assert.deepStrictEqual(buf, e.contents);
+    })
+  );
 }
diff --git a/test/parallel/test-fs-readfilesync-enoent.js b/test/parallel/test-fs-readfilesync-enoent.js
index 0369f358770383..77e1e9fa233999 100644
--- a/test/parallel/test-fs-readfilesync-enoent.js
+++ b/test/parallel/test-fs-readfilesync-enoent.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 
 // This test is only relevant on Windows.
-if (!common.isWindows)
-  common.skip('Windows specific test.');
+if (!common.isWindows) common.skip('Windows specific test.');
 
 // This test ensures fs.realpathSync works on properly on Windows without
 // throwing ENOENT when the path involves a fileserver.
@@ -18,10 +17,13 @@ function test(p) {
   const result = fs.realpathSync(p);
   assert.strictEqual(result.toLowerCase(), path.resolve(p).toLowerCase());
 
-  fs.realpath(p, common.mustCall(function(err, result) {
-    assert.ok(!err);
-    assert.strictEqual(result.toLowerCase(), path.resolve(p).toLowerCase());
-  }));
+  fs.realpath(
+    p,
+    common.mustCall(function(err, result) {
+      assert.ok(!err);
+      assert.strictEqual(result.toLowerCase(), path.resolve(p).toLowerCase());
+    })
+  );
 }
 
 test(`//${os.hostname()}/c$/Windows/System32`);
diff --git a/test/parallel/test-fs-readlink-type-check.js b/test/parallel/test-fs-readlink-type-check.js
index 914c1e55af5b2e..4ac8dc34e18daf 100644
--- a/test/parallel/test-fs-readlink-type-check.js
+++ b/test/parallel/test-fs-readlink-type-check.js
@@ -4,18 +4,12 @@ const common = require('../common');
 const fs = require('fs');
 
 [false, 1, {}, [], null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.readlink(i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.readlinkSync(i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.readlink(i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.readlinkSync(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-fs-ready-event-stream.js b/test/parallel/test-fs-ready-event-stream.js
index f6b380cf26d42c..b6c4e8541328ee 100644
--- a/test/parallel/test-fs-ready-event-stream.js
+++ b/test/parallel/test-fs-ready-event-stream.js
@@ -7,14 +7,20 @@ const tmpdir = require('../common/tmpdir');
 
 const readStream = fs.createReadStream(__filename);
 assert.strictEqual(readStream.pending, true);
-readStream.on('ready', common.mustCall(() => {
-  assert.strictEqual(readStream.pending, false);
-}));
+readStream.on(
+  'ready',
+  common.mustCall(() => {
+    assert.strictEqual(readStream.pending, false);
+  })
+);
 
 const writeFile = path.join(tmpdir.path, 'write-fsreadyevent.txt');
 tmpdir.refresh();
 const writeStream = fs.createWriteStream(writeFile, { autoClose: true });
 assert.strictEqual(writeStream.pending, true);
-writeStream.on('ready', common.mustCall(() => {
-  assert.strictEqual(writeStream.pending, false);
-}));
+writeStream.on(
+  'ready',
+  common.mustCall(() => {
+    assert.strictEqual(writeStream.pending, false);
+  })
+);
diff --git a/test/parallel/test-fs-realpath-buffer-encoding.js b/test/parallel/test-fs-realpath-buffer-encoding.js
index 6952e0c46c689e..323121b2d3d7a6 100644
--- a/test/parallel/test-fs-realpath-buffer-encoding.js
+++ b/test/parallel/test-fs-realpath-buffer-encoding.js
@@ -7,14 +7,20 @@ const fs = require('fs');
 const string_dir = fs.realpathSync(fixtures.fixturesDir);
 const buffer_dir = Buffer.from(string_dir);
 
-const encodings = ['ascii', 'utf8', 'utf16le', 'ucs2',
-                   'base64', 'binary', 'hex'];
+const encodings = [
+  'ascii',
+  'utf8',
+  'utf16le',
+  'ucs2',
+  'base64',
+  'binary',
+  'hex'
+];
 const expected = {};
 encodings.forEach((encoding) => {
   expected[encoding] = buffer_dir.toString(encoding);
 });
 
-
 // test sync version
 let encoding;
 for (encoding in expected) {
@@ -59,10 +65,14 @@ for (encoding in expected) {
       assert.strictEqual(res, expected_value);
     })
   );
-  fs.realpath(string_dir, encoding, common.mustCall((err, res) => {
-    assert.ifError(err);
-    assert.strictEqual(res, expected_value);
-  }));
+  fs.realpath(
+    string_dir,
+    encoding,
+    common.mustCall((err, res) => {
+      assert.ifError(err);
+      assert.strictEqual(res, expected_value);
+    })
+  );
   fs.realpath(
     buffer_dir,
     { encoding },
@@ -71,28 +81,48 @@ for (encoding in expected) {
       assert.strictEqual(res, expected_value);
     })
   );
-  fs.realpath(buffer_dir, encoding, common.mustCall((err, res) => {
-    assert.ifError(err);
-    assert.strictEqual(res, expected_value);
-  }));
+  fs.realpath(
+    buffer_dir,
+    encoding,
+    common.mustCall((err, res) => {
+      assert.ifError(err);
+      assert.strictEqual(res, expected_value);
+    })
+  );
 }
 
-fs.realpath(string_dir, { encoding: 'buffer' }, common.mustCall((err, res) => {
-  assert.ifError(err);
-  assert.deepStrictEqual(res, buffer_dir);
-}));
-
-fs.realpath(string_dir, 'buffer', common.mustCall((err, res) => {
-  assert.ifError(err);
-  assert.deepStrictEqual(res, buffer_dir);
-}));
-
-fs.realpath(buffer_dir, { encoding: 'buffer' }, common.mustCall((err, res) => {
-  assert.ifError(err);
-  assert.deepStrictEqual(res, buffer_dir);
-}));
-
-fs.realpath(buffer_dir, 'buffer', common.mustCall((err, res) => {
-  assert.ifError(err);
-  assert.deepStrictEqual(res, buffer_dir);
-}));
+fs.realpath(
+  string_dir,
+  { encoding: 'buffer' },
+  common.mustCall((err, res) => {
+    assert.ifError(err);
+    assert.deepStrictEqual(res, buffer_dir);
+  })
+);
+
+fs.realpath(
+  string_dir,
+  'buffer',
+  common.mustCall((err, res) => {
+    assert.ifError(err);
+    assert.deepStrictEqual(res, buffer_dir);
+  })
+);
+
+fs.realpath(
+  buffer_dir,
+  { encoding: 'buffer' },
+  common.mustCall((err, res) => {
+    assert.ifError(err);
+    assert.deepStrictEqual(res, buffer_dir);
+  })
+);
+
+fs.realpath(
+  buffer_dir,
+  'buffer',
+  common.mustCall((err, res) => {
+    assert.ifError(err);
+    assert.deepStrictEqual(res, buffer_dir);
+  })
+);
diff --git a/test/parallel/test-fs-realpath-native.js b/test/parallel/test-fs-realpath-native.js
index 089572442d62f5..097cd12a58cebc 100644
--- a/test/parallel/test-fs-realpath-native.js
+++ b/test/parallel/test-fs-realpath-native.js
@@ -6,9 +6,11 @@ const fs = require('fs');
 const filename = __filename.toLowerCase();
 
 assert.strictEqual(
-  fs.realpathSync.native('./test/parallel/test-fs-realpath-native.js')
+  fs.realpathSync
+    .native('./test/parallel/test-fs-realpath-native.js')
     .toLowerCase(),
-  filename);
+  filename
+);
 
 fs.realpath.native(
   './test/parallel/test-fs-realpath-native.js',
@@ -16,4 +18,5 @@ fs.realpath.native(
     assert.ifError(err);
     assert.strictEqual(res.toLowerCase(), filename);
     assert.strictEqual(this, undefined);
-  }));
+  })
+);
diff --git a/test/parallel/test-fs-realpath-on-substed-drive.js b/test/parallel/test-fs-realpath-on-substed-drive.js
index 4f4181a4aee1be..52d7d40f9f0461 100644
--- a/test/parallel/test-fs-realpath-on-substed-drive.js
+++ b/test/parallel/test-fs-realpath-on-substed-drive.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.isWindows)
-  common.skip('Test for Windows only');
+if (!common.isWindows) common.skip('Test for Windows only');
 
 const fixtures = require('../common/fixtures');
 
@@ -19,11 +18,9 @@ let i;
 for (i = 0; i < driveLetters.length; ++i) {
   drive = `${driveLetters[i]}:`;
   result = spawnSync('subst', [drive, fixtures.fixturesDir]);
-  if (result.status === 0)
-    break;
+  if (result.status === 0) break;
 }
-if (i === driveLetters.length)
-  common.skip('Cannot create subst drive');
+if (i === driveLetters.length) common.skip('Cannot create subst drive');
 
 // schedule cleanup (and check if all callbacks where called)
 process.on('exit', function() {
@@ -41,13 +38,20 @@ result = fs.realpathSync(filename, 'buffer');
 assert(Buffer.isBuffer(result));
 assert(result.equals(filenameBuffer));
 
-fs.realpath(filename, common.mustCall(function(err, result) {
-  assert.ifError(err);
-  assert.strictEqual(result, filename);
-}));
-
-fs.realpath(filename, 'buffer', common.mustCall(function(err, result) {
-  assert.ifError(err);
-  assert(Buffer.isBuffer(result));
-  assert(result.equals(filenameBuffer));
-}));
+fs.realpath(
+  filename,
+  common.mustCall(function(err, result) {
+    assert.ifError(err);
+    assert.strictEqual(result, filename);
+  })
+);
+
+fs.realpath(
+  filename,
+  'buffer',
+  common.mustCall(function(err, result) {
+    assert.ifError(err);
+    assert(Buffer.isBuffer(result));
+    assert(result.equals(filenameBuffer));
+  })
+);
diff --git a/test/parallel/test-fs-realpath-pipe.js b/test/parallel/test-fs-realpath-pipe.js
index 7104e93ff123ed..5f2da89c4db6d5 100644
--- a/test/parallel/test-fs-realpath-pipe.js
+++ b/test/parallel/test-fs-realpath-pipe.js
@@ -26,7 +26,10 @@ for (const code of [
     process.exit(1);
   }`
 ]) {
-  assert.strictEqual(spawnSync(process.execPath, ['-e', code], {
-    stdio: 'pipe'
-  }).status, 2);
+  assert.strictEqual(
+    spawnSync(process.execPath, ['-e', code], {
+      stdio: 'pipe'
+    }).status,
+    2
+  );
 }
diff --git a/test/parallel/test-fs-realpath.js b/test/parallel/test-fs-realpath.js
index 18b9de471bc3a8..2beb8d13ea89ca 100644
--- a/test/parallel/test-fs-realpath.js
+++ b/test/parallel/test-fs-realpath.js
@@ -44,8 +44,11 @@ if (common.isWindows) {
   // something like "C:\\"
   root = process.cwd().substr(0, 3);
   assertEqualPath = function(path_left, path_right, message) {
-    assert
-      .strictEqual(path_left.toLowerCase(), path_right.toLowerCase(), message);
+    assert.strictEqual(
+      path_left.toLowerCase(),
+      path_right.toLowerCase(),
+      message
+    );
   };
 }
 
@@ -66,27 +69,33 @@ fs.mkdirSync(path.join(targetsAbsDir, 'nested-index', 'two'));
 
 function asynctest(testBlock, args, callback, assertBlock) {
   async_expected++;
-  testBlock.apply(testBlock, args.concat(function(err) {
-    let ignoreError = false;
-    if (assertBlock) {
-      try {
-        ignoreError = assertBlock.apply(assertBlock, arguments);
-      } catch (e) {
-        err = e;
+  testBlock.apply(
+    testBlock,
+    args.concat(function(err) {
+      let ignoreError = false;
+      if (assertBlock) {
+        try {
+          ignoreError = assertBlock.apply(assertBlock, arguments);
+        } catch (e) {
+          err = e;
+        }
       }
-    }
-    async_completed++;
-    callback(ignoreError ? null : err);
-  }));
+      async_completed++;
+      callback(ignoreError ? null : err);
+    })
+  );
 }
 
 // sub-tests:
 function test_simple_error_callback(realpath, realpathSync, cb) {
-  realpath('/this/path/does/not/exist', common.mustCall(function(err, s) {
-    assert(err);
-    assert(!s);
-    cb();
-  }));
+  realpath(
+    '/this/path/does/not/exist',
+    common.mustCall(function(err, s) {
+      assert(err);
+      assert(!s);
+      cb();
+    })
+  );
 }
 
 function test_simple_relative_symlink(realpath, realpathSync, callback) {
@@ -97,10 +106,10 @@ function test_simple_relative_symlink(realpath, realpathSync, callback) {
   }
   const entry = `${tmpDir}/symlink`;
   const expected = `${tmpDir}/cycles/root.js`;
-  [
-    [entry, `../${path.basename(tmpDir)}/cycles/root.js`]
-  ].forEach(function(t) {
-    try { fs.unlinkSync(t[0]); } catch {}
+  [[entry, `../${path.basename(tmpDir)}/cycles/root.js`]].forEach(function(t) {
+    try {
+      fs.unlinkSync(t[0]);
+    } catch {}
     console.log('fs.symlinkSync(%j, %j, %j)', t[1], t[0], 'file');
     fs.symlinkSync(t[1], t[0], 'file');
     unlink.push(t[0]);
@@ -123,10 +132,10 @@ function test_simple_absolute_symlink(realpath, realpathSync, callback) {
 
   const entry = `${tmpAbsDir}/symlink`;
   const expected = fixtures.path('nested-index', 'one');
-  [
-    [entry, expected]
-  ].forEach(function(t) {
-    try { fs.unlinkSync(t[0]); } catch {}
+  [[entry, expected]].forEach(function(t) {
+    try {
+      fs.unlinkSync(t[0]);
+    } catch {}
     console.error('fs.symlinkSync(%j, %j, %j)', t[1], t[0], type);
     fs.symlinkSync(t[1], t[0], type);
     unlink.push(t[0]);
@@ -146,18 +155,31 @@ function test_deep_relative_file_symlink(realpath, realpathSync, callback) {
   }
 
   const expected = fixtures.path('cycles', 'root.js');
-  const linkData1 = path
-                      .relative(path.join(targetsAbsDir, 'nested-index', 'one'),
-                                expected);
-  const linkPath1 = path.join(targetsAbsDir,
-                              'nested-index', 'one', 'symlink1.js');
-  try { fs.unlinkSync(linkPath1); } catch {}
+  const linkData1 = path.relative(
+    path.join(targetsAbsDir, 'nested-index', 'one'),
+    expected
+  );
+  const linkPath1 = path.join(
+    targetsAbsDir,
+    'nested-index',
+    'one',
+    'symlink1.js'
+  );
+  try {
+    fs.unlinkSync(linkPath1);
+  } catch {}
   fs.symlinkSync(linkData1, linkPath1, 'file');
 
   const linkData2 = '../one/symlink1.js';
-  const entry = path.join(targetsAbsDir,
-                          'nested-index', 'two', 'symlink1-b.js');
-  try { fs.unlinkSync(entry); } catch {}
+  const entry = path.join(
+    targetsAbsDir,
+    'nested-index',
+    'two',
+    'symlink1-b.js'
+  );
+  try {
+    fs.unlinkSync(entry);
+  } catch {}
   fs.symlinkSync(linkData2, entry, 'file');
   unlink.push(linkPath1);
   unlink.push(entry);
@@ -178,13 +200,21 @@ function test_deep_relative_dir_symlink(realpath, realpathSync, callback) {
   const path1b = path.join(targetsAbsDir, 'nested-index', 'one');
   const linkPath1b = path.join(path1b, 'symlink1-dir');
   const linkData1b = path.relative(path1b, expected);
-  try { fs.unlinkSync(linkPath1b); } catch {}
+  try {
+    fs.unlinkSync(linkPath1b);
+  } catch {}
   fs.symlinkSync(linkData1b, linkPath1b, 'dir');
 
   const linkData2b = '../one/symlink1-dir';
-  const entry = path.join(targetsAbsDir,
-                          'nested-index', 'two', 'symlink12-dir');
-  try { fs.unlinkSync(entry); } catch {}
+  const entry = path.join(
+    targetsAbsDir,
+    'nested-index',
+    'two',
+    'symlink12-dir'
+  );
+  try {
+    fs.unlinkSync(entry);
+  } catch {}
   fs.symlinkSync(linkData2b, entry, 'dir');
   unlink.push(linkPath1b);
   unlink.push(entry);
@@ -208,19 +238,28 @@ function test_cyclic_link_protection(realpath, realpathSync, callback) {
     [path.join(tmpDir, '/cycles/realpath-3b'), '../cycles/realpath-3c'],
     [path.join(tmpDir, '/cycles/realpath-3c'), '../cycles/realpath-3a']
   ].forEach(function(t) {
-    try { fs.unlinkSync(t[0]); } catch {}
+    try {
+      fs.unlinkSync(t[0]);
+    } catch {}
     fs.symlinkSync(t[1], t[0], 'dir');
     unlink.push(t[0]);
   });
-  common.expectsError(() => {
-    realpathSync(entry);
-  }, { code: 'ELOOP', type: Error });
+  common.expectsError(
+    () => {
+      realpathSync(entry);
+    },
+    { code: 'ELOOP', type: Error }
+  );
   asynctest(
-    realpath, [entry], callback, common.mustCall(function(err, result) {
+    realpath,
+    [entry],
+    callback,
+    common.mustCall(function(err, result) {
       assert.strictEqual(err.path, entry);
       assert.strictEqual(result, undefined);
       return true;
-    }));
+    })
+  );
 }
 
 function test_cyclic_link_overprotection(realpath, realpathSync, callback) {
@@ -235,7 +274,9 @@ function test_cyclic_link_overprotection(realpath, realpathSync, callback) {
   const link = `${folder}/cycles`;
   let testPath = cycles;
   testPath += '/folder/cycles'.repeat(10);
-  try { fs.unlinkSync(link); } catch {}
+  try {
+    fs.unlinkSync(link);
+  } catch {}
   fs.symlinkSync(cycles, link, 'dir');
   unlink.push(link);
   assertEqualPath(realpathSync(testPath), path.resolve(expected));
@@ -253,8 +294,10 @@ function test_relative_input_cwd(realpath, realpathSync, callback) {
 
   // we need to calculate the relative path to the tmp dir from cwd
   const entrydir = process.cwd();
-  const entry = path.relative(entrydir,
-                              path.join(`${tmpDir}/cycles/realpath-3a`));
+  const entry = path.relative(
+    entrydir,
+    path.join(`${tmpDir}/cycles/realpath-3a`)
+  );
   const expected = `${tmpDir}/cycles/root.js`;
   [
     [entry, '../cycles/realpath-3b'],
@@ -263,9 +306,11 @@ function test_relative_input_cwd(realpath, realpathSync, callback) {
   ].forEach(function(t) {
     const fn = t[0];
     console.error('fn=%j', fn);
-    try { fs.unlinkSync(fn); } catch {}
+    try {
+      fs.unlinkSync(fn);
+    } catch {}
     const b = path.basename(t[1]);
-    const type = (b === 'root.js' ? 'file' : 'dir');
+    const type = b === 'root.js' ? 'file' : 'dir';
     console.log('fs.symlinkSync(%j, %j, %j)', t[1], fn, type);
     fs.symlinkSync(t[1], fn, 'file');
     unlink.push(fn);
@@ -302,23 +347,34 @@ function test_deep_symlink_mix(realpath, realpathSync, callback) {
   $tmpDir/targets/cycles/root.js (hard)
   */
   const entry = tmp('node-test-realpath-f1');
-  try { fs.unlinkSync(tmp('node-test-realpath-d2/foo')); } catch {}
-  try { fs.rmdirSync(tmp('node-test-realpath-d2')); } catch {}
+  try {
+    fs.unlinkSync(tmp('node-test-realpath-d2/foo'));
+  } catch {}
+  try {
+    fs.rmdirSync(tmp('node-test-realpath-d2'));
+  } catch {}
   fs.mkdirSync(tmp('node-test-realpath-d2'), 0o700);
   try {
     [
       [entry, `${tmpDir}/node-test-realpath-d1/foo`],
-      [tmp('node-test-realpath-d1'),
-       `${tmpDir}/node-test-realpath-d2`],
+      [tmp('node-test-realpath-d1'), `${tmpDir}/node-test-realpath-d2`],
       [tmp('node-test-realpath-d2/foo'), '../node-test-realpath-f2'],
-      [tmp('node-test-realpath-f2'),
-       `${targetsAbsDir}/nested-index/one/realpath-c`],
-      [`${targetsAbsDir}/nested-index/one/realpath-c`,
-       `${targetsAbsDir}/nested-index/two/realpath-c`],
-      [`${targetsAbsDir}/nested-index/two/realpath-c`,
-       `${tmpDir}/cycles/root.js`]
+      [
+        tmp('node-test-realpath-f2'),
+        `${targetsAbsDir}/nested-index/one/realpath-c`
+      ],
+      [
+        `${targetsAbsDir}/nested-index/one/realpath-c`,
+        `${targetsAbsDir}/nested-index/two/realpath-c`
+      ],
+      [
+        `${targetsAbsDir}/nested-index/two/realpath-c`,
+        `${tmpDir}/cycles/root.js`
+      ]
     ].forEach(function(t) {
-      try { fs.unlinkSync(t[0]); } catch {}
+      try {
+        fs.unlinkSync(t[0]);
+      } catch {}
       fs.symlinkSync(t[1], t[0]);
       unlink.push(t[0]);
     });
@@ -353,8 +409,10 @@ function test_escape_cwd(realpath, realpathSync, cb) {
   console.log('test_escape_cwd');
   asynctest(realpath, ['..'], cb, function(er, uponeActual) {
     assertEqualPath(
-      upone, uponeActual,
-      `realpath("..") expected: ${path.resolve(upone)} actual:${uponeActual}`);
+      upone,
+      uponeActual,
+      `realpath("..") expected: ${path.resolve(upone)} actual:${uponeActual}`
+    );
   });
 }
 
@@ -406,7 +464,6 @@ function test_up_multiple(realpath, realpathSync, cb) {
   });
 }
 
-
 // absolute symlinks with children.
 // .
 // `-- a/
@@ -426,26 +483,20 @@ function test_abs_with_kids(realpath, realpathSync, cb) {
 
   const root = `${tmpAbsDir}/node-test-realpath-abs-kids`;
   function cleanup() {
-    ['/a/b/c/x.txt',
-     '/a/link'
-    ].forEach(function(file) {
-      try { fs.unlinkSync(root + file); } catch {}
+    ['/a/b/c/x.txt', '/a/link'].forEach(function(file) {
+      try {
+        fs.unlinkSync(root + file);
+      } catch {}
     });
-    ['/a/b/c',
-     '/a/b',
-     '/a',
-     ''
-    ].forEach(function(folder) {
-      try { fs.rmdirSync(root + folder); } catch {}
+    ['/a/b/c', '/a/b', '/a', ''].forEach(function(folder) {
+      try {
+        fs.rmdirSync(root + folder);
+      } catch {}
     });
   }
   function setup() {
     cleanup();
-    ['',
-     '/a',
-     '/a/b',
-     '/a/b/c'
-    ].forEach(function(folder) {
+    ['', '/a', '/a/b', '/a/b/c'].forEach(function(folder) {
       console.log(`mkdir ${root}${folder}`);
       fs.mkdirSync(root + folder, 0o700);
     });
@@ -491,7 +542,7 @@ const tests = [
   test_upone_actual,
   test_abs_with_kids,
   test_up_multiple,
-  test_root,
+  test_root
 ];
 const numtests = tests.length;
 let testsRun = 0;
@@ -502,13 +553,19 @@ function runNextTest(err) {
     return console.log(`${numtests} subtests completed OK for fs.realpath`);
   }
   testsRun++;
-  test(fs.realpath, fs.realpathSync, common.mustCall((err) => {
-    assert.ifError(err);
-    testsRun++;
-    test(fs.realpath.native,
-         fs.realpathSync.native,
-         common.mustCall(runNextTest));
-  }));
+  test(
+    fs.realpath,
+    fs.realpathSync,
+    common.mustCall((err) => {
+      assert.ifError(err);
+      testsRun++;
+      test(
+        fs.realpath.native,
+        fs.realpathSync.native,
+        common.mustCall(runNextTest)
+      );
+    })
+  );
 }
 
 function runTest() {
@@ -522,7 +579,6 @@ function runTest() {
   runNextTest();
 }
 
-
 process.on('exit', function() {
   assert.strictEqual(2 * numtests, testsRun);
   assert.strictEqual(async_completed, async_expected);
diff --git a/test/parallel/test-fs-rename-type-check.js b/test/parallel/test-fs-rename-type-check.js
index b8f0549f0c3b67..f3d13bb747455c 100644
--- a/test/parallel/test-fs-rename-type-check.js
+++ b/test/parallel/test-fs-rename-type-check.js
@@ -22,20 +22,14 @@ const fs = require('fs');
       message: `The "newPath" argument must be one ${type}`
     }
   );
-  assert.throws(
-    () => fs.renameSync(input, 'does-not-exist'),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: `The "oldPath" argument must be one ${type}`
-    }
-  );
-  assert.throws(
-    () => fs.renameSync('does-not-exist', input),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: `The "newPath" argument must be one ${type}`
-    }
-  );
+  assert.throws(() => fs.renameSync(input, 'does-not-exist'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message: `The "oldPath" argument must be one ${type}`
+  });
+  assert.throws(() => fs.renameSync('does-not-exist', input), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message: `The "newPath" argument must be one ${type}`
+  });
 });
diff --git a/test/parallel/test-fs-rmdir-type-check.js b/test/parallel/test-fs-rmdir-type-check.js
index fc2106b8cabee7..46f53e85ff52e9 100644
--- a/test/parallel/test-fs-rmdir-type-check.js
+++ b/test/parallel/test-fs-rmdir-type-check.js
@@ -4,18 +4,12 @@ const common = require('../common');
 const fs = require('fs');
 
 [false, 1, [], {}, null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.rmdir(i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.rmdirSync(i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.rmdir(i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.rmdirSync(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-fs-stat-bigint.js b/test/parallel/test-fs-stat-bigint.js
index 4691b2dd9d267e..62266fb0f6583e 100644
--- a/test/parallel/test-fs-stat-bigint.js
+++ b/test/parallel/test-fs-stat-bigint.js
@@ -27,33 +27,19 @@ function verifyStats(bigintStats, numStats) {
       assert(
         Math.abs(time - time2) < 2,
         `difference of ${key}.getTime() should < 2.\n` +
-        `Number version ${time}, BigInt version ${time2}n`);
+          `Number version ${time}, BigInt version ${time2}n`
+      );
     } else if (key === 'mode') {
       assert.strictEqual(bigintStats[key], BigInt(val));
-      assert.strictEqual(
-        bigintStats.isBlockDevice(),
-        numStats.isBlockDevice()
-      );
+      assert.strictEqual(bigintStats.isBlockDevice(), numStats.isBlockDevice());
       assert.strictEqual(
         bigintStats.isCharacterDevice(),
         numStats.isCharacterDevice()
       );
-      assert.strictEqual(
-        bigintStats.isDirectory(),
-        numStats.isDirectory()
-      );
-      assert.strictEqual(
-        bigintStats.isFIFO(),
-        numStats.isFIFO()
-      );
-      assert.strictEqual(
-        bigintStats.isFile(),
-        numStats.isFile()
-      );
-      assert.strictEqual(
-        bigintStats.isSocket(),
-        numStats.isSocket()
-      );
+      assert.strictEqual(bigintStats.isDirectory(), numStats.isDirectory());
+      assert.strictEqual(bigintStats.isFIFO(), numStats.isFIFO());
+      assert.strictEqual(bigintStats.isFile(), numStats.isFile());
+      assert.strictEqual(bigintStats.isSocket(), numStats.isSocket());
       assert.strictEqual(
         bigintStats.isSymbolicLink(),
         numStats.isSymbolicLink()
@@ -67,7 +53,8 @@ function verifyStats(bigintStats, numStats) {
       assert(
         Math.abs(Number(bigintStats[key]) - val) < 1,
         `${key} is not a safe integer, difference should < 1.\n` +
-        `Number version ${val}, BigInt version ${bigintStats[key]}n`);
+          `Number version ${val}, BigInt version ${bigintStats[key]}n`
+      );
     }
   }
 }
diff --git a/test/parallel/test-fs-stat.js b/test/parallel/test-fs-stat.js
index 1003890bb8f459..6c5e8a72b9f462 100644
--- a/test/parallel/test-fs-stat.js
+++ b/test/parallel/test-fs-stat.js
@@ -25,153 +25,190 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
-fs.stat('.', common.mustCall(function(err, stats) {
-  assert.ifError(err);
-  assert.ok(stats.mtime instanceof Date);
-  // Confirm that we are not running in the context of the internal binding
-  // layer.
-  // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
-  assert.strictEqual(this, undefined);
-}));
-
-fs.stat('.', common.mustCall(function(err, stats) {
-  assert.ok(stats.hasOwnProperty('blksize'));
-  assert.ok(stats.hasOwnProperty('blocks'));
-}));
-
-fs.lstat('.', common.mustCall(function(err, stats) {
-  assert.ifError(err);
-  assert.ok(stats.mtime instanceof Date);
-  // Confirm that we are not running in the context of the internal binding
-  // layer.
-  // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
-  assert.strictEqual(this, undefined);
-}));
+fs.stat(
+  '.',
+  common.mustCall(function(err, stats) {
+    assert.ifError(err);
+    assert.ok(stats.mtime instanceof Date);
+    // Confirm that we are not running in the context of the internal binding
+    // layer.
+    // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
+    assert.strictEqual(this, undefined);
+  })
+);
 
-// fstat
-fs.open('.', 'r', undefined, common.mustCall(function(err, fd) {
-  assert.ifError(err);
-  assert.ok(fd);
+fs.stat(
+  '.',
+  common.mustCall(function(err, stats) {
+    assert.ok(stats.hasOwnProperty('blksize'));
+    assert.ok(stats.hasOwnProperty('blocks'));
+  })
+);
 
-  fs.fstat(fd, common.mustCall(function(err, stats) {
+fs.lstat(
+  '.',
+  common.mustCall(function(err, stats) {
     assert.ifError(err);
     assert.ok(stats.mtime instanceof Date);
-    fs.close(fd, assert.ifError);
     // Confirm that we are not running in the context of the internal binding
     // layer.
     // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
     assert.strictEqual(this, undefined);
-  }));
+  })
+);
 
-  // Confirm that we are not running in the context of the internal binding
-  // layer.
-  // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
-  assert.strictEqual(this, undefined);
-}));
+// fstat
+fs.open(
+  '.',
+  'r',
+  undefined,
+  common.mustCall(function(err, fd) {
+    assert.ifError(err);
+    assert.ok(fd);
+
+    fs.fstat(
+      fd,
+      common.mustCall(function(err, stats) {
+        assert.ifError(err);
+        assert.ok(stats.mtime instanceof Date);
+        fs.close(fd, assert.ifError);
+        // Confirm that we are not running in the context of the internal binding
+        // layer.
+        // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
+        assert.strictEqual(this, undefined);
+      })
+    );
+
+    // Confirm that we are not running in the context of the internal binding
+    // layer.
+    // Ref: https://github.com/nodejs/node/commit/463d6bac8b349acc462d345a6e298a76f7d06fb1
+    assert.strictEqual(this, undefined);
+  })
+);
 
 // fstatSync
-fs.open('.', 'r', undefined, common.mustCall(function(err, fd) {
-  let stats;
-  try {
-    stats = fs.fstatSync(fd);
-  } catch (err) {
-    assert.fail(err);
-  }
-  if (stats) {
-    assert.ok(stats.mtime instanceof Date);
-  }
-  fs.close(fd, assert.ifError);
-}));
+fs.open(
+  '.',
+  'r',
+  undefined,
+  common.mustCall(function(err, fd) {
+    let stats;
+    try {
+      stats = fs.fstatSync(fd);
+    } catch (err) {
+      assert.fail(err);
+    }
+    if (stats) {
+      assert.ok(stats.mtime instanceof Date);
+    }
+    fs.close(fd, assert.ifError);
+  })
+);
 
-fs.stat(__filename, common.mustCall(function(err, s) {
-  assert.ifError(err);
-  assert.strictEqual(s.isDirectory(), false);
-  assert.strictEqual(s.isFile(), true);
-  assert.strictEqual(s.isSocket(), false);
-  assert.strictEqual(s.isBlockDevice(), false);
-  assert.strictEqual(s.isCharacterDevice(), false);
-  assert.strictEqual(s.isFIFO(), false);
-  assert.strictEqual(s.isSymbolicLink(), false);
-  const keys = [
-    'dev', 'mode', 'nlink', 'uid',
-    'gid', 'rdev', 'ino', 'size',
-    'atime', 'mtime', 'ctime', 'birthtime',
-    'atimeMs', 'mtimeMs', 'ctimeMs', 'birthtimeMs'
-  ];
-  if (!common.isWindows) {
-    keys.push('blocks', 'blksize');
-  }
-  const numberFields = [
-    'dev', 'mode', 'nlink', 'uid', 'gid', 'rdev', 'ino', 'size',
-    'atimeMs', 'mtimeMs', 'ctimeMs', 'birthtimeMs'
-  ];
-  const dateFields = ['atime', 'mtime', 'ctime', 'birthtime'];
-  keys.forEach(function(k) {
-    assert.ok(k in s, `${k} should be in Stats`);
-    assert.notStrictEqual(s[k], undefined, `${k} should not be undefined`);
-    assert.notStrictEqual(s[k], null, `${k} should not be null`);
-  });
-  numberFields.forEach((k) => {
-    assert.strictEqual(typeof s[k], 'number', `${k} should be a number`);
-  });
-  dateFields.forEach((k) => {
-    assert.ok(s[k] instanceof Date, `${k} should be a Date`);
-  });
-  const jsonString = JSON.stringify(s);
-  const parsed = JSON.parse(jsonString);
-  keys.forEach(function(k) {
-    assert.notStrictEqual(parsed[k], undefined, `${k} should not be undefined`);
-    assert.notStrictEqual(parsed[k], null, `${k} should not be null`);
-  });
-  numberFields.forEach((k) => {
-    assert.strictEqual(typeof parsed[k], 'number', `${k} should be a number`);
-  });
-  dateFields.forEach((k) => {
-    assert.strictEqual(typeof parsed[k], 'string', `${k} should be a string`);
-  });
-}));
+fs.stat(
+  __filename,
+  common.mustCall(function(err, s) {
+    assert.ifError(err);
+    assert.strictEqual(s.isDirectory(), false);
+    assert.strictEqual(s.isFile(), true);
+    assert.strictEqual(s.isSocket(), false);
+    assert.strictEqual(s.isBlockDevice(), false);
+    assert.strictEqual(s.isCharacterDevice(), false);
+    assert.strictEqual(s.isFIFO(), false);
+    assert.strictEqual(s.isSymbolicLink(), false);
+    const keys = [
+      'dev',
+      'mode',
+      'nlink',
+      'uid',
+      'gid',
+      'rdev',
+      'ino',
+      'size',
+      'atime',
+      'mtime',
+      'ctime',
+      'birthtime',
+      'atimeMs',
+      'mtimeMs',
+      'ctimeMs',
+      'birthtimeMs'
+    ];
+    if (!common.isWindows) {
+      keys.push('blocks', 'blksize');
+    }
+    const numberFields = [
+      'dev',
+      'mode',
+      'nlink',
+      'uid',
+      'gid',
+      'rdev',
+      'ino',
+      'size',
+      'atimeMs',
+      'mtimeMs',
+      'ctimeMs',
+      'birthtimeMs'
+    ];
+    const dateFields = ['atime', 'mtime', 'ctime', 'birthtime'];
+    keys.forEach(function(k) {
+      assert.ok(k in s, `${k} should be in Stats`);
+      assert.notStrictEqual(s[k], undefined, `${k} should not be undefined`);
+      assert.notStrictEqual(s[k], null, `${k} should not be null`);
+    });
+    numberFields.forEach((k) => {
+      assert.strictEqual(typeof s[k], 'number', `${k} should be a number`);
+    });
+    dateFields.forEach((k) => {
+      assert.ok(s[k] instanceof Date, `${k} should be a Date`);
+    });
+    const jsonString = JSON.stringify(s);
+    const parsed = JSON.parse(jsonString);
+    keys.forEach(function(k) {
+      assert.notStrictEqual(
+        parsed[k],
+        undefined,
+        `${k} should not be undefined`
+      );
+      assert.notStrictEqual(parsed[k], null, `${k} should not be null`);
+    });
+    numberFields.forEach((k) => {
+      assert.strictEqual(typeof parsed[k], 'number', `${k} should be a number`);
+    });
+    dateFields.forEach((k) => {
+      assert.strictEqual(typeof parsed[k], 'string', `${k} should be a string`);
+    });
+  })
+);
 
 ['', false, null, undefined, {}, []].forEach((input) => {
   ['fstat', 'fstatSync'].forEach((fnName) => {
-    assert.throws(
-      () => fs[fnName](input),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-        message: 'The "fd" argument must be of type number. ' +
-                 `Received type ${typeof input}`
-      }
-    );
+    assert.throws(() => fs[fnName](input), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "fd" argument must be of type number. ' +
+        `Received type ${typeof input}`
+    });
   });
 });
 
 [false, 1, {}, [], null, undefined].forEach((input) => {
-  assert.throws(
-    () => fs.lstat(input, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-    }
-  );
-  assert.throws(
-    () => fs.lstatSync(input),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-    }
-  );
-  assert.throws(
-    () => fs.stat(input, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-    }
-  );
-  assert.throws(
-    () => fs.statSync(input),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-    }
-  );
+  assert.throws(() => fs.lstat(input, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+  });
+  assert.throws(() => fs.lstatSync(input), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+  });
+  assert.throws(() => fs.stat(input, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+  });
+  assert.throws(() => fs.statSync(input), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+  });
 });
diff --git a/test/parallel/test-fs-stream-destroy-emit-error.js b/test/parallel/test-fs-stream-destroy-emit-error.js
index c0405ce5f154f0..ff7fb51316ccf7 100644
--- a/test/parallel/test-fs-stream-destroy-emit-error.js
+++ b/test/parallel/test-fs-stream-destroy-emit-error.js
@@ -14,7 +14,10 @@ function test(stream) {
   stream.on('open', function() {
     stream.destroy(err);
   });
-  stream.on('error', common.mustCall(function(err_) {
-    assert.strictEqual(err_, err);
-  }));
+  stream.on(
+    'error',
+    common.mustCall(function(err_) {
+      assert.strictEqual(err_, err);
+    })
+  );
 }
diff --git a/test/parallel/test-fs-stream-double-close.js b/test/parallel/test-fs-stream-double-close.js
index 8c0037b24312ff..b2cb68d666da4a 100644
--- a/test/parallel/test-fs-stream-double-close.js
+++ b/test/parallel/test-fs-stream-double-close.js
@@ -41,14 +41,20 @@ function test1(stream) {
 
 function test2(stream) {
   stream.destroy();
-  stream.on('open', common.mustCall(function(fd) {
-    stream.destroy();
-  }));
+  stream.on(
+    'open',
+    common.mustCall(function(fd) {
+      stream.destroy();
+    })
+  );
 }
 
 function test3(stream) {
-  stream.on('open', common.mustCall(function(fd) {
-    stream.destroy();
-    stream.destroy();
-  }));
+  stream.on(
+    'open',
+    common.mustCall(function(fd) {
+      stream.destroy();
+      stream.destroy();
+    })
+  );
 }
diff --git a/test/parallel/test-fs-symlink-dir-junction-relative.js b/test/parallel/test-fs-symlink-dir-junction-relative.js
index 308ab040488471..860fbb6304b632 100644
--- a/test/parallel/test-fs-symlink-dir-junction-relative.js
+++ b/test/parallel/test-fs-symlink-dir-junction-relative.js
@@ -38,10 +38,15 @@ const linkData = fixtures.fixturesDir;
 tmpdir.refresh();
 
 // Test fs.symlink()
-fs.symlink(linkData, linkPath1, 'junction', common.mustCall(function(err) {
-  assert.ifError(err);
-  verifyLink(linkPath1);
-}));
+fs.symlink(
+  linkData,
+  linkPath1,
+  'junction',
+  common.mustCall(function(err) {
+    assert.ifError(err);
+    verifyLink(linkPath1);
+  })
+);
 
 // Test fs.symlinkSync()
 fs.symlinkSync(linkData, linkPath2, 'junction');
diff --git a/test/parallel/test-fs-symlink-dir-junction.js b/test/parallel/test-fs-symlink-dir-junction.js
index 5bd7a8dcc4ecc3..96330e26bcac2c 100644
--- a/test/parallel/test-fs-symlink-dir-junction.js
+++ b/test/parallel/test-fs-symlink-dir-junction.js
@@ -34,22 +34,36 @@ const linkPath = path.join(tmpdir.path, 'cycles_link');
 
 tmpdir.refresh();
 
-fs.symlink(linkData, linkPath, 'junction', common.mustCall(function(err) {
-  assert.ifError(err);
-
-  fs.lstat(linkPath, common.mustCall(function(err, stats) {
+fs.symlink(
+  linkData,
+  linkPath,
+  'junction',
+  common.mustCall(function(err) {
     assert.ifError(err);
-    assert.ok(stats.isSymbolicLink());
-
-    fs.readlink(linkPath, common.mustCall(function(err, destination) {
-      assert.ifError(err);
-      assert.strictEqual(destination, linkData);
 
-      fs.unlink(linkPath, common.mustCall(function(err) {
+    fs.lstat(
+      linkPath,
+      common.mustCall(function(err, stats) {
         assert.ifError(err);
-        assert(!fs.existsSync(linkPath));
-        assert(fs.existsSync(linkData));
-      }));
-    }));
-  }));
-}));
+        assert.ok(stats.isSymbolicLink());
+
+        fs.readlink(
+          linkPath,
+          common.mustCall(function(err, destination) {
+            assert.ifError(err);
+            assert.strictEqual(destination, linkData);
+
+            fs.unlink(
+              linkPath,
+              common.mustCall(function(err) {
+                assert.ifError(err);
+                assert(!fs.existsSync(linkPath));
+                assert(fs.existsSync(linkData));
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-fs-symlink.js b/test/parallel/test-fs-symlink.js
index ddcf7a63ffbe18..ed5df053bbee9a 100644
--- a/test/parallel/test-fs-symlink.js
+++ b/test/parallel/test-fs-symlink.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 const fixtures = require('../common/fixtures');
-if (!common.canCreateSymLink())
-  common.skip('insufficient privileges');
+if (!common.canCreateSymLink()) common.skip('insufficient privileges');
 
 const assert = require('assert');
 const path = require('path');
@@ -39,31 +38,45 @@ tmpdir.refresh();
 const linkData = fixtures.path('/cycles/root.js');
 const linkPath = path.join(tmpdir.path, 'symlink1.js');
 
-fs.symlink(linkData, linkPath, common.mustCall(function(err) {
-  assert.ifError(err);
-
-  fs.lstat(linkPath, common.mustCall(function(err, stats) {
+fs.symlink(
+  linkData,
+  linkPath,
+  common.mustCall(function(err) {
     assert.ifError(err);
-    linkTime = stats.mtime.getTime();
-  }));
 
-  fs.stat(linkPath, common.mustCall(function(err, stats) {
-    assert.ifError(err);
-    fileTime = stats.mtime.getTime();
-  }));
+    fs.lstat(
+      linkPath,
+      common.mustCall(function(err, stats) {
+        assert.ifError(err);
+        linkTime = stats.mtime.getTime();
+      })
+    );
 
-  fs.readlink(linkPath, common.mustCall(function(err, destination) {
-    assert.ifError(err);
-    assert.strictEqual(destination, linkData);
-  }));
-}));
+    fs.stat(
+      linkPath,
+      common.mustCall(function(err, stats) {
+        assert.ifError(err);
+        fileTime = stats.mtime.getTime();
+      })
+    );
+
+    fs.readlink(
+      linkPath,
+      common.mustCall(function(err, destination) {
+        assert.ifError(err);
+        assert.strictEqual(destination, linkData);
+      })
+    );
+  })
+);
 
 [false, 1, {}, [], null, undefined].forEach((input) => {
   const errObj = {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "target" argument must be one of type string, Buffer, or ' +
-             `URL. Received type ${typeof input}`
+    message:
+      'The "target" argument must be one of type string, Buffer, or ' +
+      `URL. Received type ${typeof input}`
   };
   assert.throws(() => fs.symlink(input, '', common.mustNotCall()), errObj);
   assert.throws(() => fs.symlinkSync(input, ''), errObj);
diff --git a/test/parallel/test-fs-syncwritestream.js b/test/parallel/test-fs-syncwritestream.js
index 8fbe665a4047d0..4b1fc2291d4e79 100644
--- a/test/parallel/test-fs-syncwritestream.js
+++ b/test/parallel/test-fs-syncwritestream.js
@@ -12,11 +12,15 @@ const path = require('path');
 if (process.argv[2] === 'child') {
   // Note: Calling console.log() is part of this test as it exercises the
   // SyncWriteStream#_write() code path.
-  console.log(JSON.stringify([process.stdout, process.stderr].map((stdio) => ({
-    instance: stdio instanceof stream.Writable,
-    readable: stdio.readable,
-    writable: stdio.writable,
-  }))));
+  console.log(
+    JSON.stringify(
+      [process.stdout, process.stderr].map((stdio) => ({
+        instance: stdio instanceof stream.Writable,
+        readable: stdio.readable,
+        writable: stdio.writable
+      }))
+    )
+  );
 
   return;
 }
@@ -28,14 +32,17 @@ const filename = path.join(tmpdir.path, 'stdout');
 const stdoutFd = fs.openSync(filename, 'w');
 
 const proc = spawn(process.execPath, [__filename, 'child'], {
-  stdio: ['inherit', stdoutFd, stdoutFd ]
+  stdio: ['inherit', stdoutFd, stdoutFd]
 });
 
-proc.on('close', common.mustCall(() => {
-  fs.closeSync(stdoutFd);
-
-  assert.deepStrictEqual(JSON.parse(fs.readFileSync(filename, 'utf8')), [
-    { instance: true, readable: false, writable: true },
-    { instance: true, readable: false, writable: true }
-  ]);
-}));
+proc.on(
+  'close',
+  common.mustCall(() => {
+    fs.closeSync(stdoutFd);
+
+    assert.deepStrictEqual(JSON.parse(fs.readFileSync(filename, 'utf8')), [
+      { instance: true, readable: false, writable: true },
+      { instance: true, readable: false, writable: true }
+    ]);
+  })
+);
diff --git a/test/parallel/test-fs-timestamp-parsing-error.js b/test/parallel/test-fs-timestamp-parsing-error.js
index 4456a86830f43f..df7877283f8703 100644
--- a/test/parallel/test-fs-timestamp-parsing-error.js
+++ b/test/parallel/test-fs-timestamp-parsing-error.js
@@ -10,7 +10,8 @@ const fs = require('fs');
     {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError
-    });
+    }
+  );
 });
 
 common.expectsError(
@@ -20,7 +21,8 @@ common.expectsError(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError
-  });
+  }
+);
 
 const okInputs = [1, -1, '1', '-1', Date.now()];
 okInputs.forEach((input) => {
diff --git a/test/parallel/test-fs-truncate-fd.js b/test/parallel/test-fs-truncate-fd.js
index 62634aed1d91a7..18259f2a2b9421 100644
--- a/test/parallel/test-fs-truncate-fd.js
+++ b/test/parallel/test-fs-truncate-fd.js
@@ -11,15 +11,19 @@ const filename = path.resolve(tmp, 'truncate-file.txt');
 fs.writeFileSync(filename, 'hello world', 'utf8');
 const fd = fs.openSync(filename, 'r+');
 
-const msg = 'Using fs.truncate with a file descriptor is deprecated.' +
-' Please use fs.ftruncate with a file descriptor instead.';
-
+const msg =
+  'Using fs.truncate with a file descriptor is deprecated.' +
+  ' Please use fs.ftruncate with a file descriptor instead.';
 
 common.expectWarning('DeprecationWarning', msg, 'DEP0081');
-fs.truncate(fd, 5, common.mustCall(function(err) {
-  assert.ok(!err);
-  assert.strictEqual(fs.readFileSync(filename, 'utf8'), 'hello');
-}));
+fs.truncate(
+  fd,
+  5,
+  common.mustCall(function(err) {
+    assert.ok(!err);
+    assert.strictEqual(fs.readFileSync(filename, 'utf8'), 'hello');
+  })
+);
 
 process.on('exit', function() {
   fs.closeSync(fd);
diff --git a/test/parallel/test-fs-truncate.js b/test/parallel/test-fs-truncate.js
index d1d743eb57f0fd..f1251a85921d93 100644
--- a/test/parallel/test-fs-truncate.js
+++ b/test/parallel/test-fs-truncate.js
@@ -33,8 +33,9 @@ tmpdir.refresh();
 
 let stat;
 
-const msg = 'Using fs.truncate with a file descriptor is deprecated.' +
-            ' Please use fs.ftruncate with a file descriptor instead.';
+const msg =
+  'Using fs.truncate with a file descriptor is deprecated.' +
+  ' Please use fs.ftruncate with a file descriptor instead.';
 
 // Check truncateSync
 fs.writeFileSync(filename, data);
@@ -71,10 +72,12 @@ fs.truncateSync(fd);
 fs.closeSync(fd);
 
 // Async tests
-testTruncate(common.mustCall(function(er) {
-  assert.ifError(er);
-  testFtruncate(common.mustCall(assert.ifError));
-}));
+testTruncate(
+  common.mustCall(function(er) {
+    assert.ifError(er);
+    testFtruncate(common.mustCall(assert.ifError));
+  })
+);
 
 function testTruncate(cb) {
   fs.writeFile(filename, data, function(er) {
@@ -155,10 +158,14 @@ function testFtruncate(cb) {
 {
   const file3 = path.resolve(tmp, 'truncate-file-3.txt');
   fs.writeFileSync(file3, 'Hi');
-  fs.truncate(file3, 4, common.mustCall(function(err) {
-    assert.ifError(err);
-    assert(fs.readFileSync(file3).equals(Buffer.from('Hi\u0000\u0000')));
-  }));
+  fs.truncate(
+    file3,
+    4,
+    common.mustCall(function(err) {
+      assert.ifError(err);
+      assert(fs.readFileSync(file3).equals(Buffer.from('Hi\u0000\u0000')));
+    })
+  );
 }
 
 {
@@ -166,10 +173,14 @@ function testFtruncate(cb) {
   fs.writeFileSync(file4, 'Hi');
   const fd = fs.openSync(file4, 'r+');
   process.on('exit', () => fs.closeSync(fd));
-  fs.ftruncate(fd, 4, common.mustCall(function(err) {
-    assert.ifError(err);
-    assert(fs.readFileSync(file4).equals(Buffer.from('Hi\u0000\u0000')));
-  }));
+  fs.ftruncate(
+    fd,
+    4,
+    common.mustCall(function(err) {
+      assert.ifError(err);
+      assert(fs.readFileSync(file4).equals(Buffer.from('Hi\u0000\u0000')));
+    })
+  );
 }
 
 {
@@ -179,53 +190,49 @@ function testFtruncate(cb) {
   process.on('exit', () => fs.closeSync(fd));
 
   ['', false, null, {}, []].forEach((input) => {
-    assert.throws(
-      () => fs.truncate(file5, input, common.mustNotCall()),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-        message: 'The "len" argument must be of type number. ' +
-                 `Received type ${typeof input}`
-      }
-    );
+    assert.throws(() => fs.truncate(file5, input, common.mustNotCall()), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "len" argument must be of type number. ' +
+        `Received type ${typeof input}`
+    });
 
-    assert.throws(
-      () => fs.ftruncate(fd, input),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-        message: 'The "len" argument must be of type number. ' +
-                 `Received type ${typeof input}`
-      }
-    );
+    assert.throws(() => fs.ftruncate(fd, input), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "len" argument must be of type number. ' +
+        `Received type ${typeof input}`
+    });
   });
 
   [-1.5, 1.5].forEach((input) => {
-    assert.throws(
-      () => fs.truncate(file5, input),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "len" is out of range. It must be ' +
-                  `an integer. Received ${input}`
-      }
-    );
+    assert.throws(() => fs.truncate(file5, input), {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError [ERR_OUT_OF_RANGE]',
+      message:
+        'The value of "len" is out of range. It must be ' +
+        `an integer. Received ${input}`
+    });
 
-    assert.throws(
-      () => fs.ftruncate(fd, input),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "len" is out of range. It must be ' +
-                  `an integer. Received ${input}`
-      }
-    );
+    assert.throws(() => fs.ftruncate(fd, input), {
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError [ERR_OUT_OF_RANGE]',
+      message:
+        'The value of "len" is out of range. It must be ' +
+        `an integer. Received ${input}`
+    });
   });
 
-  fs.ftruncate(fd, undefined, common.mustCall(function(err) {
-    assert.ifError(err);
-    assert(fs.readFileSync(file5).equals(Buffer.from('')));
-  }));
+  fs.ftruncate(
+    fd,
+    undefined,
+    common.mustCall(function(err) {
+      assert.ifError(err);
+      assert(fs.readFileSync(file5).equals(Buffer.from('')));
+    })
+  );
 }
 
 {
@@ -233,19 +240,27 @@ function testFtruncate(cb) {
   fs.writeFileSync(file6, 'Hi');
   const fd = fs.openSync(file6, 'r+');
   process.on('exit', () => fs.closeSync(fd));
-  fs.ftruncate(fd, -1, common.mustCall(function(err) {
-    assert.ifError(err);
-    assert(fs.readFileSync(file6).equals(Buffer.from('')));
-  }));
+  fs.ftruncate(
+    fd,
+    -1,
+    common.mustCall(function(err) {
+      assert.ifError(err);
+      assert(fs.readFileSync(file6).equals(Buffer.from('')));
+    })
+  );
 }
 
 {
   const file7 = path.resolve(tmp, 'truncate-file-7.txt');
   fs.writeFileSync(file7, 'Hi');
-  fs.truncate(file7, undefined, common.mustCall(function(err) {
-    assert.ifError(err);
-    assert(fs.readFileSync(file7).equals(Buffer.from('')));
-  }));
+  fs.truncate(
+    file7,
+    undefined,
+    common.mustCall(function(err) {
+      assert.ifError(err);
+      assert(fs.readFileSync(file7).equals(Buffer.from('')));
+    })
+  );
 }
 
 {
@@ -254,7 +269,8 @@ function testFtruncate(cb) {
     assert.strictEqual(file8, err.path);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, open '${file8}'`);
+      `ENOENT: no such file or directory, open '${file8}'`
+    );
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'open');
     return true;
@@ -263,27 +279,23 @@ function testFtruncate(cb) {
 }
 
 ['', false, null, {}, []].forEach((input) => {
-  assert.throws(
-    () => fs.truncate('/foo/bar', input),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "len" argument must be of type number. ' +
-               `Received type ${typeof input}`
-    }
-  );
+  assert.throws(() => fs.truncate('/foo/bar', input), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message:
+      'The "len" argument must be of type number. ' +
+      `Received type ${typeof input}`
+  });
 });
 
 ['', false, null, undefined, {}, []].forEach((input) => {
   ['ftruncate', 'ftruncateSync'].forEach((fnName) => {
-    assert.throws(
-      () => fs[fnName](input),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-        message: 'The "fd" argument must be of type number. ' +
-                 `Received type ${typeof input}`
-      }
-    );
+    assert.throws(() => fs[fnName](input), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "fd" argument must be of type number. ' +
+        `Received type ${typeof input}`
+    });
   });
 });
diff --git a/test/parallel/test-fs-unlink-type-check.js b/test/parallel/test-fs-unlink-type-check.js
index 7fe3ce946c89d5..c4df1694dd8cf3 100644
--- a/test/parallel/test-fs-unlink-type-check.js
+++ b/test/parallel/test-fs-unlink-type-check.js
@@ -4,18 +4,12 @@ const common = require('../common');
 const fs = require('fs');
 
 [false, 1, {}, [], null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.unlink(i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.unlinkSync(i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.unlink(i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.unlinkSync(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-fs-util-validateoffsetlengthwrite.js b/test/parallel/test-fs-util-validateoffsetlengthwrite.js
index 9aca956bd505bf..d9f3d968b33c9a 100644
--- a/test/parallel/test-fs-util-validateoffsetlengthwrite.js
+++ b/test/parallel/test-fs-util-validateoffsetlengthwrite.js
@@ -16,8 +16,9 @@ const { kMaxLength } = require('buffer');
     {
       code: 'ERR_OUT_OF_RANGE',
       type: RangeError,
-      message: 'The value of "offset" is out of range. ' +
-               `It must be <= ${byteLength}. Received ${offset}`
+      message:
+        'The value of "offset" is out of range. ' +
+        `It must be <= ${byteLength}. Received ${offset}`
     }
   );
 }
@@ -32,8 +33,9 @@ const { kMaxLength } = require('buffer');
     {
       code: 'ERR_OUT_OF_RANGE',
       type: RangeError,
-      message: 'The value of "length" is out of range. ' +
-               `It must be <= ${kMaxLength - offset}. Received ${length}`
+      message:
+        'The value of "length" is out of range. ' +
+        `It must be <= ${kMaxLength - offset}. Received ${length}`
     }
   );
 }
@@ -48,8 +50,9 @@ const { kMaxLength } = require('buffer');
     {
       code: 'ERR_OUT_OF_RANGE',
       type: RangeError,
-      message: 'The value of "length" is out of range. ' +
-               `It must be <= ${byteLength - offset}. Received ${length}`
+      message:
+        'The value of "length" is out of range. ' +
+        `It must be <= ${byteLength - offset}. Received ${length}`
     }
   );
 }
diff --git a/test/parallel/test-fs-utimes.js b/test/parallel/test-fs-utimes.js
index 92558eef149040..2f65b039e781cb 100644
--- a/test/parallel/test-fs-utimes.js
+++ b/test/parallel/test-fs-utimes.js
@@ -38,8 +38,7 @@ function stat_resource(resource) {
     const stats = fs.fstatSync(resource);
     // ensure mtime has been written to disk
     // except for directories on AIX where it cannot be synced
-    if (common.isAIX && stats.isDirectory())
-      return stats;
+    if (common.isAIX && stats.isDirectory()) return stats;
     fs.fsyncSync(resource);
     return fs.fstatSync(resource);
   }
@@ -63,8 +62,10 @@ function expect_errno(syscall, resource, err, errno) {
 }
 
 function expect_ok(syscall, resource, err, atime, mtime) {
-  if (!err && check_mtime(resource, mtime) ||
-      err && err.code === 'ENOSYS') {
+  if (
+    (!err && check_mtime(resource, mtime)) ||
+    (err && err.code === 'ENOSYS')
+  ) {
     tests_ok++;
   } else {
     console.log('FAILED:', 'expect_ok', util.inspect(arguments));
@@ -72,7 +73,6 @@ function expect_ok(syscall, resource, err, atime, mtime) {
 }
 
 function testIt(atime, mtime, callback) {
-
   let fd;
   //
   // test synchronized code paths, these functions throw on failure
@@ -102,55 +102,69 @@ function testIt(atime, mtime, callback) {
     tests_run++;
 
     err = undefined;
-    common.expectsError(
-      () => fs.futimesSync(-1, atime, mtime),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        type: RangeError,
-        message: 'The value of "fd" is out of range. ' +
-                'It must be >= 0 && < 4294967296. Received -1'
-      }
-    );
+    common.expectsError(() => fs.futimesSync(-1, atime, mtime), {
+      code: 'ERR_OUT_OF_RANGE',
+      type: RangeError,
+      message:
+        'The value of "fd" is out of range. ' +
+        'It must be >= 0 && < 4294967296. Received -1'
+    });
     tests_run++;
   }
 
   //
   // test async code paths
   //
-  fs.utimes(tmpdir.path, atime, mtime, common.mustCall((err) => {
-    expect_ok('utimes', tmpdir.path, err, atime, mtime);
-
-    fs.utimes('foobarbaz', atime, mtime, common.mustCall((err) => {
-      expect_errno('utimes', 'foobarbaz', err, 'ENOENT');
-
-      // don't close this fd
-      if (common.isWindows) {
-        fd = fs.openSync(tmpdir.path, 'r+');
-      } else {
-        fd = fs.openSync(tmpdir.path, 'r');
-      }
-
-      fs.futimes(fd, atime, mtime, common.mustCall((err) => {
-        expect_ok('futimes', fd, err, atime, mtime);
-
-        common.expectsError(
-          () => fs.futimes(-1, atime, mtime, common.mustNotCall()),
-          {
-            code: 'ERR_OUT_OF_RANGE',
-            type: RangeError,
-            message: 'The value of "fd" is out of range. ' +
-                    'It must be >= 0 && < 4294967296. Received -1'
+  fs.utimes(
+    tmpdir.path,
+    atime,
+    mtime,
+    common.mustCall((err) => {
+      expect_ok('utimes', tmpdir.path, err, atime, mtime);
+
+      fs.utimes(
+        'foobarbaz',
+        atime,
+        mtime,
+        common.mustCall((err) => {
+          expect_errno('utimes', 'foobarbaz', err, 'ENOENT');
+
+          // don't close this fd
+          if (common.isWindows) {
+            fd = fs.openSync(tmpdir.path, 'r+');
+          } else {
+            fd = fs.openSync(tmpdir.path, 'r');
           }
-        );
 
-        syncTests();
+          fs.futimes(
+            fd,
+            atime,
+            mtime,
+            common.mustCall((err) => {
+              expect_ok('futimes', fd, err, atime, mtime);
+
+              common.expectsError(
+                () => fs.futimes(-1, atime, mtime, common.mustNotCall()),
+                {
+                  code: 'ERR_OUT_OF_RANGE',
+                  type: RangeError,
+                  message:
+                    'The value of "fd" is out of range. ' +
+                    'It must be >= 0 && < 4294967296. Received -1'
+                }
+              );
+
+              syncTests();
 
-        tests_run++;
-      }));
+              tests_run++;
+            })
+          );
+          tests_run++;
+        })
+      );
       tests_run++;
-    }));
-    tests_run++;
-  }));
+    })
+  );
   tests_run++;
 }
 
@@ -181,7 +195,6 @@ process.on('exit', () => {
   assert.strictEqual(tests_ok, tests_run - 2);
 });
 
-
 // Ref: https://github.com/nodejs/node/issues/13255
 const path = `${tmpdir.path}/test-utimes-precision`;
 fs.writeFileSync(path, '');
@@ -190,7 +203,7 @@ fs.writeFileSync(path, '');
 if (!process.arch.includes('arm') && !common.isOpenBSD && !common.isSunOS) {
   // because 2 ** 31 doesn't look right
   // eslint-disable-next-line space-infix-ops
-  const Y2K38_mtime = 2**31;
+  const Y2K38_mtime = 2 ** 31;
   fs.utimesSync(path, Y2K38_mtime, Y2K38_mtime);
   const Y2K38_stats = fs.statSync(path);
   assert.strictEqual(Y2K38_mtime, Y2K38_stats.mtime.getTime() / 1000);
@@ -222,11 +235,8 @@ if (common.isWindows) {
       type: TypeError
     }
   );
-  common.expectsError(
-    () => fs.utimesSync(i, new Date(), new Date()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.utimesSync(i, new Date(), new Date()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-fs-watch-close-when-destroyed.js b/test/parallel/test-fs-watch-close-when-destroyed.js
index fb5239bc446eff..c376f697f16d69 100644
--- a/test/parallel/test-fs-watch-close-when-destroyed.js
+++ b/test/parallel/test-fs-watch-close-when-destroyed.js
@@ -18,21 +18,19 @@ const watcher = fs.watch(root, { persistent: false, recursive: false });
 
 watcher.addListener('error', () => {
   setTimeout(
-    () => { watcher.close(); },  // Should not crash if it's invoked
+    () => {
+      watcher.close();
+    }, // Should not crash if it's invoked
     common.platformTimeout(10)
   );
 });
 
 watcher.addListener('change', () => {
-  setTimeout(
-    () => { watcher.close(); },
-    common.platformTimeout(10)
-  );
+  setTimeout(() => {
+    watcher.close();
+  }, common.platformTimeout(10));
 });
 
 fs.rmdirSync(root);
 // Wait for the listener to hit
-setTimeout(
-  common.mustCall(() => {}),
-  common.platformTimeout(100)
-);
+setTimeout(common.mustCall(() => {}), common.platformTimeout(100));
diff --git a/test/parallel/test-fs-watch-encoding.js b/test/parallel/test-fs-watch-encoding.js
index 1cea6255098360..f95afed3db4835 100644
--- a/test/parallel/test-fs-watch-encoding.js
+++ b/test/parallel/test-fs-watch-encoding.js
@@ -16,8 +16,7 @@ const common = require('../common');
 // The testcase makes use of folder watching, and causes
 // hang. This behavior is documented. Skip this for AIX.
 
-if (common.isAIX)
-  common.skip('folder watch capability is limited in AIX.');
+if (common.isAIX) common.skip('folder watch capability is limited in AIX.');
 
 const fs = require('fs');
 const path = require('path');
@@ -52,13 +51,9 @@ const watcher1 = fs.watch(
 );
 registerWatcher(watcher1);
 
-const watcher2 = fs.watch(
-  tmpdir.path,
-  (event, filename) => {
-    if ([fn, null].includes(filename))
-      done(watcher2);
-  }
-);
+const watcher2 = fs.watch(tmpdir.path, (event, filename) => {
+  if ([fn, null].includes(filename)) done(watcher2);
+});
 registerWatcher(watcher2);
 
 const watcher3 = fs.watch(
@@ -67,8 +62,7 @@ const watcher3 = fs.watch(
   (event, filename) => {
     if (filename instanceof Buffer && filename.toString('utf8') === fn)
       done(watcher3);
-    else if (filename === null)
-      done(watcher3);
+    else if (filename === null) done(watcher3);
   }
 );
 registerWatcher(watcher3);
diff --git a/test/parallel/test-fs-watch-enoent.js b/test/parallel/test-fs-watch-enoent.js
index 1ed9f2ed641f19..5322063d98f005 100644
--- a/test/parallel/test-fs-watch-enoent.js
+++ b/test/parallel/test-fs-watch-enoent.js
@@ -10,10 +10,7 @@ const tmpdir = require('../common/tmpdir');
 const path = require('path');
 const nonexistentFile = path.join(tmpdir.path, 'non-existent');
 const { internalBinding } = require('internal/test/binding');
-const {
-  UV_ENODEV,
-  UV_ENOENT
-} = internalBinding('uv');
+const { UV_ENODEV, UV_ENOENT } = internalBinding('uv');
 
 tmpdir.refresh();
 
@@ -25,13 +22,16 @@ tmpdir.refresh();
     if (err.code === 'ENOENT') {
       assert.strictEqual(
         err.message,
-        `ENOENT: no such file or directory, watch '${nonexistentFile}'`);
+        `ENOENT: no such file or directory, watch '${nonexistentFile}'`
+      );
       assert.strictEqual(err.errno, UV_ENOENT);
       assert.strictEqual(err.code, 'ENOENT');
-    } else {  // AIX
+    } else {
+      // AIX
       assert.strictEqual(
         err.message,
-        `ENODEV: no such device, watch '${nonexistentFile}'`);
+        `ENODEV: no such device, watch '${nonexistentFile}'`
+      );
       assert.strictEqual(err.errno, UV_ENODEV);
       assert.strictEqual(err.code, 'ENODEV');
     }
@@ -54,7 +54,8 @@ tmpdir.refresh();
     assert.strictEqual(err.filename, nonexistentFile);
     assert.strictEqual(
       err.message,
-      `ENOENT: no such file or directory, watch '${nonexistentFile}'`);
+      `ENOENT: no such file or directory, watch '${nonexistentFile}'`
+    );
     assert.strictEqual(err.errno, UV_ENOENT);
     assert.strictEqual(err.code, 'ENOENT');
     assert.strictEqual(err.syscall, 'watch');
diff --git a/test/parallel/test-fs-watch-file-enoent-after-deletion.js b/test/parallel/test-fs-watch-file-enoent-after-deletion.js
index 6eaa4c68c58bc8..42b82f6393be48 100644
--- a/test/parallel/test-fs-watch-file-enoent-after-deletion.js
+++ b/test/parallel/test-fs-watch-file-enoent-after-deletion.js
@@ -41,8 +41,12 @@ tmpdir.refresh();
 const filename = path.join(tmpdir.path, 'watched');
 fs.writeFileSync(filename, 'quis custodiet ipsos custodes');
 
-fs.watchFile(filename, { interval: 50 }, common.mustCall(function(curr, prev) {
-  fs.unwatchFile(filename);
-}));
+fs.watchFile(
+  filename,
+  { interval: 50 },
+  common.mustCall(function(curr, prev) {
+    fs.unwatchFile(filename);
+  })
+);
 
 fs.unlinkSync(filename);
diff --git a/test/parallel/test-fs-watch-recursive.js b/test/parallel/test-fs-watch-recursive.js
index 4985ece0e0ec15..b5469f8185b732 100644
--- a/test/parallel/test-fs-watch-recursive.js
+++ b/test/parallel/test-fs-watch-recursive.js
@@ -27,8 +27,7 @@ watcher.on('change', function(event, filename) {
   assert.ok(event === 'change' || event === 'rename');
 
   // Ignore stale events generated by mkdir and other tests
-  if (filename !== relativePathOne)
-    return;
+  if (filename !== relativePathOne) return;
 
   if (common.isOSX) {
     clearInterval(interval);
diff --git a/test/parallel/test-fs-watch-stop-async.js b/test/parallel/test-fs-watch-stop-async.js
index 61db2a300f983b..3c891c2aeca798 100644
--- a/test/parallel/test-fs-watch-stop-async.js
+++ b/test/parallel/test-fs-watch-stop-async.js
@@ -11,7 +11,7 @@ const listener = common.mustCall(() => {
 });
 
 triggered = false;
-watch.once('stop', listener);  // Should trigger.
+watch.once('stop', listener); // Should trigger.
 watch.stop();
 assert.strictEqual(triggered, false);
 setImmediate(() => {
diff --git a/test/parallel/test-fs-watch.js b/test/parallel/test-fs-watch.js
index e596f32a766926..cac24b4940d358 100644
--- a/test/parallel/test-fs-watch.js
+++ b/test/parallel/test-fs-watch.js
@@ -14,8 +14,12 @@ class WatchTestCase {
     this.field = field;
     this.shouldSkip = !shouldInclude;
   }
-  get dirPath() { return join(tmpdir.path, this.dirName); }
-  get filePath() { return join(this.dirPath, this.fileName); }
+  get dirPath() {
+    return join(tmpdir.path, this.dirName);
+  }
+  get filePath() {
+    return join(this.dirPath, this.fileName);
+  }
 }
 
 const cases = [
@@ -55,33 +59,38 @@ for (const testCase of cases) {
     }
     assert.fail(err);
   });
-  watcher.on('close', common.mustCall(() => {
-    watcher.close(); // Closing a closed watcher should be a noop
-    // Starting a closed watcher should be a noop
-    watcher.start();
-  }));
-  watcher.on('change', common.mustCall(function(eventType, argFilename) {
-    if (interval) {
-      clearInterval(interval);
-      interval = null;
-    }
-    if (common.isOSX)
-      assert.strictEqual(['rename', 'change'].includes(eventType), true);
-    else
-      assert.strictEqual(eventType, 'change');
-    assert.strictEqual(argFilename, testCase.fileName);
+  watcher.on(
+    'close',
+    common.mustCall(() => {
+      watcher.close(); // Closing a closed watcher should be a noop
+      // Starting a closed watcher should be a noop
+      watcher.start();
+    })
+  );
+  watcher.on(
+    'change',
+    common.mustCall(function(eventType, argFilename) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      if (common.isOSX)
+        assert.strictEqual(['rename', 'change'].includes(eventType), true);
+      else assert.strictEqual(eventType, 'change');
+      assert.strictEqual(argFilename, testCase.fileName);
 
-    // Starting a started watcher should be a noop
-    watcher.start();
-    watcher.start(pathToWatch);
+      // Starting a started watcher should be a noop
+      watcher.start();
+      watcher.start(pathToWatch);
 
-    watcher.close();
+      watcher.close();
 
-    // We document that watchers cannot be used anymore when it's closed,
-    // here we turn the methods into noops instead of throwing
-    watcher.close(); // Closing a closed watcher should be a noop
-    watcher.start();  // Starting a closed watcher should be a noop
-  }));
+      // We document that watchers cannot be used anymore when it's closed,
+      // here we turn the methods into noops instead of throwing
+      watcher.close(); // Closing a closed watcher should be a noop
+      watcher.start(); // Starting a closed watcher should be a noop
+    })
+  );
 
   // Long content so it's actually flushed. toUpperCase so there's real change.
   const content2 = Date.now() + testCase.fileName.toUpperCase().repeat(1e4);
@@ -92,13 +101,11 @@ for (const testCase of cases) {
 }
 
 [false, 1, {}, [], null, undefined].forEach((input) => {
-  common.expectsError(
-    () => fs.watch(input, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "filename" argument must be one of type string, Buffer, ' +
-               `or URL. Received type ${typeof input}`
-    }
-  );
+  common.expectsError(() => fs.watch(input, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "filename" argument must be one of type string, Buffer, ' +
+      `or URL. Received type ${typeof input}`
+  });
 });
diff --git a/test/parallel/test-fs-watchfile-bigint.js b/test/parallel/test-fs-watchfile-bigint.js
index 89cefd12e0443f..49bdfb4af0fdb7 100644
--- a/test/parallel/test-fs-watchfile-bigint.js
+++ b/test/parallel/test-fs-watchfile-bigint.js
@@ -9,20 +9,20 @@ const tmpdir = require('../common/tmpdir');
 
 const enoentFile = path.join(tmpdir.path, 'non-existent-file');
 const expectedStatObject = new fs.Stats(
-  0n,                                        // dev
-  0n,                                        // mode
-  0n,                                        // nlink
-  0n,                                        // uid
-  0n,                                        // gid
-  0n,                                        // rdev
-  common.isWindows ? undefined : 0n,         // blksize
-  0n,                                        // ino
-  0n,                                        // size
-  common.isWindows ? undefined : 0n,         // blocks
-  0n,                                        // atim_msec
-  0n,                                        // mtim_msec
-  0n,                                        // ctim_msec
-  0n                                         // birthtim_msec
+  0n, // dev
+  0n, // mode
+  0n, // nlink
+  0n, // uid
+  0n, // gid
+  0n, // rdev
+  common.isWindows ? undefined : 0n, // blksize
+  0n, // ino
+  0n, // size
+  common.isWindows ? undefined : 0n, // blocks
+  0n, // atim_msec
+  0n, // mtim_msec
+  0n, // ctim_msec
+  0n // birthtim_msec
 );
 
 tmpdir.refresh();
@@ -32,8 +32,10 @@ tmpdir.refresh();
 let fileExists = false;
 const options = { interval: 0, bigint: true };
 
-const watcher =
-  fs.watchFile(enoentFile, options, common.mustCall((curr, prev) => {
+const watcher = fs.watchFile(
+  enoentFile,
+  options,
+  common.mustCall((curr, prev) => {
     if (!fileExists) {
       // If the file does not exist, all the fields should be zero and the date
       // fields should be UNIX EPOCH time
@@ -52,12 +54,13 @@ const watcher =
       assert(prev.ino <= 0n);
       // Stop watching the file
       fs.unwatchFile(enoentFile);
-      watcher.stop();  // stopping a stopped watcher should be a noop
+      watcher.stop(); // stopping a stopped watcher should be a noop
     }
-  }, 2));
+  }, 2)
+);
 
 // 'stop' should only be emitted once - stopping a stopped watcher should
 // not trigger a 'stop' event.
 watcher.on('stop', common.mustCall(function onStop() {}));
 
-watcher.start();  // starting a started watcher should be a noop
+watcher.start(); // starting a started watcher should be a noop
diff --git a/test/parallel/test-fs-watchfile.js b/test/parallel/test-fs-watchfile.js
index ba4becb2627c87..acf0c997908681 100644
--- a/test/parallel/test-fs-watchfile.js
+++ b/test/parallel/test-fs-watchfile.js
@@ -15,7 +15,8 @@ common.expectsError(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError
-  });
+  }
+);
 
 common.expectsError(
   () => {
@@ -24,28 +25,32 @@ common.expectsError(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError
-  });
+  }
+);
 
-common.expectsError(function() {
-  fs.watchFile(new Object(), common.mustNotCall());
-}, { code: 'ERR_INVALID_ARG_TYPE', type: TypeError });
+common.expectsError(
+  function() {
+    fs.watchFile(new Object(), common.mustNotCall());
+  },
+  { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
+);
 
 const enoentFile = path.join(tmpdir.path, 'non-existent-file');
 const expectedStatObject = new fs.Stats(
-  0,                                        // dev
-  0,                                        // mode
-  0,                                        // nlink
-  0,                                        // uid
-  0,                                        // gid
-  0,                                        // rdev
-  common.isWindows ? undefined : 0,         // blksize
-  0,                                        // ino
-  0,                                        // size
-  common.isWindows ? undefined : 0,         // blocks
-  Date.UTC(1970, 0, 1, 0, 0, 0),            // atime
-  Date.UTC(1970, 0, 1, 0, 0, 0),            // mtime
-  Date.UTC(1970, 0, 1, 0, 0, 0),            // ctime
-  Date.UTC(1970, 0, 1, 0, 0, 0)             // birthtime
+  0, // dev
+  0, // mode
+  0, // nlink
+  0, // uid
+  0, // gid
+  0, // rdev
+  common.isWindows ? undefined : 0, // blksize
+  0, // ino
+  0, // size
+  common.isWindows ? undefined : 0, // blocks
+  Date.UTC(1970, 0, 1, 0, 0, 0), // atime
+  Date.UTC(1970, 0, 1, 0, 0, 0), // mtime
+  Date.UTC(1970, 0, 1, 0, 0, 0), // ctime
+  Date.UTC(1970, 0, 1, 0, 0, 0) // birthtime
 );
 
 tmpdir.refresh();
@@ -54,8 +59,10 @@ tmpdir.refresh();
 // time, the callback should be invoked again with proper values in stat object
 let fileExists = false;
 
-const watcher =
-  fs.watchFile(enoentFile, { interval: 0 }, common.mustCall((curr, prev) => {
+const watcher = fs.watchFile(
+  enoentFile,
+  { interval: 0 },
+  common.mustCall((curr, prev) => {
     if (!fileExists) {
       // If the file does not exist, all the fields should be zero and the date
       // fields should be UNIX EPOCH time
@@ -74,34 +81,45 @@ const watcher =
       assert(prev.ino <= 0);
       // Stop watching the file
       fs.unwatchFile(enoentFile);
-      watcher.stop();  // stopping a stopped watcher should be a noop
+      watcher.stop(); // stopping a stopped watcher should be a noop
     }
-  }, 2));
+  }, 2)
+);
 
 // 'stop' should only be emitted once - stopping a stopped watcher should
 // not trigger a 'stop' event.
 watcher.on('stop', common.mustCall(function onStop() {}));
 
-watcher.start();  // starting a started watcher should be a noop
+watcher.start(); // starting a started watcher should be a noop
 
 // Watch events should callback with a filename on supported systems.
 // Omitting AIX. It works but not reliably.
 if (common.isLinux || common.isOSX || common.isWindows) {
   const dir = path.join(tmpdir.path, 'watch');
 
-  fs.mkdir(dir, common.mustCall(function(err) {
-    if (err) assert.fail(err);
+  fs.mkdir(
+    dir,
+    common.mustCall(function(err) {
+      if (err) assert.fail(err);
 
-    fs.watch(dir, common.mustCall(function(eventType, filename) {
-      clearInterval(interval);
-      this._handle.close();
-      assert.strictEqual(filename, 'foo.txt');
-    }));
+      fs.watch(
+        dir,
+        common.mustCall(function(eventType, filename) {
+          clearInterval(interval);
+          this._handle.close();
+          assert.strictEqual(filename, 'foo.txt');
+        })
+      );
 
-    const interval = setInterval(() => {
-      fs.writeFile(path.join(dir, 'foo.txt'), 'foo', common.mustCall((err) => {
-        if (err) assert.fail(err);
-      }));
-    }, 1);
-  }));
+      const interval = setInterval(() => {
+        fs.writeFile(
+          path.join(dir, 'foo.txt'),
+          'foo',
+          common.mustCall((err) => {
+            if (err) assert.fail(err);
+          })
+        );
+      }, 1);
+    })
+  );
 }
diff --git a/test/parallel/test-fs-whatwg-url.js b/test/parallel/test-fs-whatwg-url.js
index 159fc0cc1b31ea..cca41e47816796 100644
--- a/test/parallel/test-fs-whatwg-url.js
+++ b/test/parallel/test-fs-whatwg-url.js
@@ -9,10 +9,8 @@ const os = require('os');
 const URL = require('url').URL;
 
 function pathToFileURL(p) {
-  if (!path.isAbsolute(p))
-    throw new Error('Path must be absolute');
-  if (common.isWindows && p.startsWith('\\\\'))
-    p = p.slice(2);
+  if (!path.isAbsolute(p)) throw new Error('Path must be absolute');
+  if (common.isWindows && p.startsWith('\\\\')) p = p.slice(2);
   return new URL(`file://${p}`);
 }
 
@@ -22,10 +20,13 @@ const url = pathToFileURL(p);
 assert(url instanceof URL);
 
 // Check that we can pass in a URL object successfully
-fs.readFile(url, common.mustCall((err, data) => {
-  assert.ifError(err);
-  assert(Buffer.isBuffer(data));
-}));
+fs.readFile(
+  url,
+  common.mustCall((err, data) => {
+    assert.ifError(err);
+    assert(Buffer.isBuffer(data));
+  })
+);
 
 // Check that using a non file:// URL reports an error
 const httpUrl = new URL('http://example.org');
@@ -38,7 +39,8 @@ common.expectsError(
     code: 'ERR_INVALID_URL_SCHEME',
     type: TypeError,
     message: 'The URL must be of scheme file'
-  });
+  }
+);
 
 // pct-encoded characters in the path will be decoded and checked
 if (common.isWindows) {
@@ -62,8 +64,9 @@ if (common.isWindows) {
     {
       code: 'ERR_INVALID_ARG_VALUE',
       type: TypeError,
-      message: 'The argument \'path\' must be a string or Uint8Array without ' +
-               'null bytes. Received \'c:/tmp/\\u0000test\''
+      message:
+        "The argument 'path' must be a string or Uint8Array without " +
+        "null bytes. Received 'c:/tmp/\\u0000test'"
     }
   );
 } else {
@@ -77,7 +80,8 @@ if (common.isWindows) {
         code: 'ERR_INVALID_FILE_URL_PATH',
         type: TypeError,
         message: 'File URL path must not include encoded / characters'
-      });
+      }
+    );
   });
   common.expectsError(
     () => {
@@ -96,8 +100,9 @@ if (common.isWindows) {
     {
       code: 'ERR_INVALID_ARG_VALUE',
       type: TypeError,
-      message: 'The argument \'path\' must be a string or Uint8Array without ' +
-               'null bytes. Received \'/tmp/\\u0000test\''
+      message:
+        "The argument 'path' must be a string or Uint8Array without " +
+        "null bytes. Received '/tmp/\\u0000test'"
     }
   );
 }
diff --git a/test/parallel/test-fs-write-buffer.js b/test/parallel/test-fs-write-buffer.js
index 0ff9fd69a82a3a..3af372c35c096e 100644
--- a/test/parallel/test-fs-write-buffer.js
+++ b/test/parallel/test-fs-write-buffer.js
@@ -32,119 +32,149 @@ tmpdir.refresh();
 // fs.write with all parameters provided:
 {
   const filename = path.join(tmpdir.path, 'write1.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall((err, fd) => {
-    assert.ifError(err);
-
-    const cb = common.mustCall((err, written) => {
+  fs.open(
+    filename,
+    'w',
+    0o644,
+    common.mustCall((err, fd) => {
       assert.ifError(err);
 
-      assert.strictEqual(expected.length, written);
-      fs.closeSync(fd);
+      const cb = common.mustCall((err, written) => {
+        assert.ifError(err);
+
+        assert.strictEqual(expected.length, written);
+        fs.closeSync(fd);
 
-      const found = fs.readFileSync(filename, 'utf8');
-      assert.strictEqual(expected.toString(), found);
-    });
+        const found = fs.readFileSync(filename, 'utf8');
+        assert.strictEqual(expected.toString(), found);
+      });
 
-    fs.write(fd, expected, 0, expected.length, null, cb);
-  }));
+      fs.write(fd, expected, 0, expected.length, null, cb);
+    })
+  );
 }
 
 // fs.write with a buffer, without the length parameter:
 {
   const filename = path.join(tmpdir.path, 'write2.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall((err, fd) => {
-    assert.ifError(err);
-
-    const cb = common.mustCall((err, written) => {
+  fs.open(
+    filename,
+    'w',
+    0o644,
+    common.mustCall((err, fd) => {
       assert.ifError(err);
 
-      assert.strictEqual(written, 2);
-      fs.closeSync(fd);
+      const cb = common.mustCall((err, written) => {
+        assert.ifError(err);
 
-      const found = fs.readFileSync(filename, 'utf8');
-      assert.strictEqual(found, 'lo');
-    });
+        assert.strictEqual(written, 2);
+        fs.closeSync(fd);
 
-    fs.write(fd, Buffer.from('hello'), 3, cb);
-  }));
+        const found = fs.readFileSync(filename, 'utf8');
+        assert.strictEqual(found, 'lo');
+      });
+
+      fs.write(fd, Buffer.from('hello'), 3, cb);
+    })
+  );
 }
 
 // fs.write with a buffer, without the offset and length parameters:
 {
   const filename = path.join(tmpdir.path, 'write3.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall(function(err, fd) {
-    assert.ifError(err);
-
-    const cb = common.mustCall(function(err, written) {
+  fs.open(
+    filename,
+    'w',
+    0o644,
+    common.mustCall(function(err, fd) {
       assert.ifError(err);
 
-      assert.strictEqual(expected.length, written);
-      fs.closeSync(fd);
+      const cb = common.mustCall(function(err, written) {
+        assert.ifError(err);
+
+        assert.strictEqual(expected.length, written);
+        fs.closeSync(fd);
 
-      const found = fs.readFileSync(filename, 'utf8');
-      assert.deepStrictEqual(expected.toString(), found);
-    });
+        const found = fs.readFileSync(filename, 'utf8');
+        assert.deepStrictEqual(expected.toString(), found);
+      });
 
-    fs.write(fd, expected, cb);
-  }));
+      fs.write(fd, expected, cb);
+    })
+  );
 }
 
 // fs.write with the offset passed as undefined followed by the callback:
 {
   const filename = path.join(tmpdir.path, 'write4.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall(function(err, fd) {
-    assert.ifError(err);
-
-    const cb = common.mustCall(function(err, written) {
+  fs.open(
+    filename,
+    'w',
+    0o644,
+    common.mustCall(function(err, fd) {
       assert.ifError(err);
 
-      assert.strictEqual(expected.length, written);
-      fs.closeSync(fd);
+      const cb = common.mustCall(function(err, written) {
+        assert.ifError(err);
+
+        assert.strictEqual(expected.length, written);
+        fs.closeSync(fd);
 
-      const found = fs.readFileSync(filename, 'utf8');
-      assert.deepStrictEqual(expected.toString(), found);
-    });
+        const found = fs.readFileSync(filename, 'utf8');
+        assert.deepStrictEqual(expected.toString(), found);
+      });
 
-    fs.write(fd, expected, undefined, cb);
-  }));
+      fs.write(fd, expected, undefined, cb);
+    })
+  );
 }
 
 // fs.write with offset and length passed as undefined followed by the callback:
 {
   const filename = path.join(tmpdir.path, 'write5.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall((err, fd) => {
-    assert.ifError(err);
-
-    const cb = common.mustCall((err, written) => {
+  fs.open(
+    filename,
+    'w',
+    0o644,
+    common.mustCall((err, fd) => {
       assert.ifError(err);
 
-      assert.strictEqual(expected.length, written);
-      fs.closeSync(fd);
+      const cb = common.mustCall((err, written) => {
+        assert.ifError(err);
 
-      const found = fs.readFileSync(filename, 'utf8');
-      assert.strictEqual(expected.toString(), found);
-    });
+        assert.strictEqual(expected.length, written);
+        fs.closeSync(fd);
 
-    fs.write(fd, expected, undefined, undefined, cb);
-  }));
+        const found = fs.readFileSync(filename, 'utf8');
+        assert.strictEqual(expected.toString(), found);
+      });
+
+      fs.write(fd, expected, undefined, undefined, cb);
+    })
+  );
 }
 
 // fs.write with a Uint8Array, without the offset and length parameters:
 {
   const filename = path.join(tmpdir.path, 'write6.txt');
-  fs.open(filename, 'w', 0o644, common.mustCall((err, fd) => {
-    assert.ifError(err);
-
-    const cb = common.mustCall((err, written) => {
+  fs.open(
+    filename,
+    'w',
+    0o644,
+    common.mustCall((err, fd) => {
       assert.ifError(err);
 
-      assert.strictEqual(expected.length, written);
-      fs.closeSync(fd);
+      const cb = common.mustCall((err, written) => {
+        assert.ifError(err);
+
+        assert.strictEqual(expected.length, written);
+        fs.closeSync(fd);
 
-      const found = fs.readFileSync(filename, 'utf8');
-      assert.strictEqual(expected.toString(), found);
-    });
+        const found = fs.readFileSync(filename, 'utf8');
+        assert.strictEqual(expected.toString(), found);
+      });
 
-    fs.write(fd, Uint8Array.from(expected), cb);
-  }));
+      fs.write(fd, Uint8Array.from(expected), cb);
+    })
+  );
 }
diff --git a/test/parallel/test-fs-write-file-buffer.js b/test/parallel/test-fs-write-file-buffer.js
index 82fb7ad69a443b..a0f1ffca68ec65 100644
--- a/test/parallel/test-fs-write-file-buffer.js
+++ b/test/parallel/test-fs-write-file-buffer.js
@@ -42,7 +42,8 @@ let data = [
   '1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDhfBUFl/wk',
   'OmPqKJJZw3aiZFBw4z93jnkkc9u9dj8XLfSI/EBt7DTo7ea2Ox5YXVo5FC7g',
   'Tjq24nJPXNVtO0KATRvNHCIg3zoWJWQHqp+o4pun+EtJ0zxBq8mnLJa2d1L5',
-  '0NvnKRjJBUE5PAx3NYxxUY0pRtvYHSc5Ka2X9d7H/9k='];
+  '0NvnKRjJBUE5PAx3NYxxUY0pRtvYHSc5Ka2X9d7H/9k='
+];
 
 data = data.join('\n');
 
diff --git a/test/parallel/test-fs-write-file-invalid-path.js b/test/parallel/test-fs-write-file-invalid-path.js
index a4c8ff5bf73a03..9532f76b4ce698 100644
--- a/test/parallel/test-fs-write-file-invalid-path.js
+++ b/test/parallel/test-fs-write-file-invalid-path.js
@@ -5,8 +5,7 @@ const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
 
-if (!common.isWindows)
-  common.skip('This test is for Windows only.');
+if (!common.isWindows) common.skip('This test is for Windows only.');
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
@@ -24,7 +23,8 @@ const RESERVED_CHARACTERS = '<>"|?*';
       fs.writeFileSync(pathname, DATA_VALUE);
     },
     /^Error: ENOENT: no such file or directory, open '.*'$/,
-    `failed with '${ch}'`);
+    `failed with '${ch}'`
+  );
 });
 
 // Test for ':' (NTFS data streams).
@@ -41,6 +41,9 @@ fileDataStream.on('data', (data) => {
   content += data;
 });
 
-fileDataStream.on('end', common.mustCall(() => {
-  assert.strictEqual(content, DATA_VALUE);
-}));
+fileDataStream.on(
+  'end',
+  common.mustCall(() => {
+    assert.strictEqual(content, DATA_VALUE);
+  })
+);
diff --git a/test/parallel/test-fs-write-file-typedarrays.js b/test/parallel/test-fs-write-file-typedarrays.js
index eca22750f6f903..0e063ad3e8a875 100644
--- a/test/parallel/test-fs-write-file-typedarrays.js
+++ b/test/parallel/test-fs-write-file-typedarrays.js
@@ -9,13 +9,14 @@ tmpdir.refresh();
 
 const filename = join(tmpdir.path, 'test.txt');
 
-const s = '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
-          '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
-          '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
-          '前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
-          '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
-          '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
-          '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
+const s =
+  '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
+  '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
+  '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
+  '前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
+  '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
+  '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
+  '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
 
 // The length of the buffer should be a multiple of 8
 // as required by common.getArrayBufferViews()
@@ -33,12 +34,20 @@ for (const expectView of common.getArrayBufferViews(inputBuffer)) {
 for (const expectView of common.getArrayBufferViews(inputBuffer)) {
   console.log('Async test for ', expectView[Symbol.toStringTag]);
   const file = `${filename}-${expectView[Symbol.toStringTag]}`;
-  fs.writeFile(file, expectView, common.mustCall((e) => {
-    assert.ifError(e);
+  fs.writeFile(
+    file,
+    expectView,
+    common.mustCall((e) => {
+      assert.ifError(e);
 
-    fs.readFile(file, 'utf8', common.mustCall((err, data) => {
-      assert.ifError(err);
-      assert.strictEqual(data, inputBuffer.toString('utf8'));
-    }));
-  }));
+      fs.readFile(
+        file,
+        'utf8',
+        common.mustCall((err, data) => {
+          assert.ifError(err);
+          assert.strictEqual(data, inputBuffer.toString('utf8'));
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-fs-write-file.js b/test/parallel/test-fs-write-file.js
index b137e55547201e..11daad474e8c61 100644
--- a/test/parallel/test-fs-write-file.js
+++ b/test/parallel/test-fs-write-file.js
@@ -31,77 +31,114 @@ tmpdir.refresh();
 const filename = join(tmpdir.path, 'test.txt');
 
 const n = 220;
-const s = '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
-          '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
-          '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
-          '前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
-          '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
-          '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
-          '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
-
-fs.writeFile(filename, s, common.mustCall(function(e) {
-  assert.ifError(e);
-
-  fs.readFile(filename, common.mustCall(function(e, buffer) {
+const s =
+  '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、' +
+  '广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。' +
+  '南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。' +
+  '前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
+  '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
+  '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，' +
+  '它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、##济现状。\n';
+
+fs.writeFile(
+  filename,
+  s,
+  common.mustCall(function(e) {
     assert.ifError(e);
-    assert.strictEqual(Buffer.byteLength(s), buffer.length);
-  }));
-}));
+
+    fs.readFile(
+      filename,
+      common.mustCall(function(e, buffer) {
+        assert.ifError(e);
+        assert.strictEqual(Buffer.byteLength(s), buffer.length);
+      })
+    );
+  })
+);
 
 // test that writeFile accepts buffers
 const filename2 = join(tmpdir.path, 'test2.txt');
 const buf = Buffer.from(s, 'utf8');
 
-fs.writeFile(filename2, buf, common.mustCall(function(e) {
-  assert.ifError(e);
-
-  fs.readFile(filename2, common.mustCall(function(e, buffer) {
+fs.writeFile(
+  filename2,
+  buf,
+  common.mustCall(function(e) {
     assert.ifError(e);
 
-    assert.strictEqual(buf.length, buffer.length);
-  }));
-}));
+    fs.readFile(
+      filename2,
+      common.mustCall(function(e, buffer) {
+        assert.ifError(e);
+
+        assert.strictEqual(buf.length, buffer.length);
+      })
+    );
+  })
+);
 
 // test that writeFile accepts numbers.
 const filename3 = join(tmpdir.path, 'test3.txt');
 
 const m = 0o600;
-fs.writeFile(filename3, n, { mode: m }, common.mustCall(function(e) {
-  assert.ifError(e);
+fs.writeFile(
+  filename3,
+  n,
+  { mode: m },
+  common.mustCall(function(e) {
+    assert.ifError(e);
 
-  // windows permissions aren't unix
-  if (!common.isWindows) {
-    const st = fs.statSync(filename3);
-    assert.strictEqual(st.mode & 0o700, m);
-  }
+    // windows permissions aren't unix
+    if (!common.isWindows) {
+      const st = fs.statSync(filename3);
+      assert.strictEqual(st.mode & 0o700, m);
+    }
 
-  fs.readFile(filename3, common.mustCall(function(e, buffer) {
-    assert.ifError(e);
+    fs.readFile(
+      filename3,
+      common.mustCall(function(e, buffer) {
+        assert.ifError(e);
 
-    assert.strictEqual(Buffer.byteLength(String(n)), buffer.length);
-  }));
-}));
+        assert.strictEqual(Buffer.byteLength(String(n)), buffer.length);
+      })
+    );
+  })
+);
 
 // test that writeFile accepts file descriptors
 const filename4 = join(tmpdir.path, 'test4.txt');
 
-fs.open(filename4, 'w+', common.mustCall(function(e, fd) {
-  assert.ifError(e);
-
-  fs.writeFile(fd, s, common.mustCall(function(e) {
+fs.open(
+  filename4,
+  'w+',
+  common.mustCall(function(e, fd) {
     assert.ifError(e);
 
-    fs.close(fd, common.mustCall(function(e) {
-      assert.ifError(e);
-
-      fs.readFile(filename4, common.mustCall(function(e, buffer) {
+    fs.writeFile(
+      fd,
+      s,
+      common.mustCall(function(e) {
         assert.ifError(e);
 
-        assert.strictEqual(Buffer.byteLength(s), buffer.length);
-      }));
-    }));
-  }));
-}));
+        fs.close(
+          fd,
+          common.mustCall(function(e) {
+            assert.ifError(e);
+
+            fs.readFile(
+              filename4,
+              common.mustCall(function(e, buffer) {
+                assert.ifError(e);
+
+                assert.strictEqual(Buffer.byteLength(s), buffer.length);
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
 
 process.on('exit', function() {
   fs.unlinkSync(filename);
diff --git a/test/parallel/test-fs-write-stream-autoclose-option.js b/test/parallel/test-fs-write-stream-autoclose-option.js
index e39f4d615ab7e0..f6c31a32bd2e03 100644
--- a/test/parallel/test-fs-write-stream-autoclose-option.js
+++ b/test/parallel/test-fs-write-stream-autoclose-option.js
@@ -11,28 +11,39 @@ tmpdir.refresh();
 let stream = fs.createWriteStream(file, { flags: 'w+', autoClose: false });
 stream.write('Test1');
 stream.end();
-stream.on('finish', common.mustCall(function() {
-  stream.on('close', common.mustNotCall());
-  process.nextTick(common.mustCall(function() {
-    assert.strictEqual(stream.closed, false);
-    assert.notStrictEqual(stream.fd, null);
-    next();
-  }));
-}));
+stream.on(
+  'finish',
+  common.mustCall(function() {
+    stream.on('close', common.mustNotCall());
+    process.nextTick(
+      common.mustCall(function() {
+        assert.strictEqual(stream.closed, false);
+        assert.notStrictEqual(stream.fd, null);
+        next();
+      })
+    );
+  })
+);
 
 function next() {
   // This will tell us if the fd is usable again or not
   stream = fs.createWriteStream(null, { fd: stream.fd, start: 0 });
   stream.write('Test2');
   stream.end();
-  stream.on('finish', common.mustCall(function() {
-    assert.strictEqual(stream.closed, false);
-    assert.strictEqual(stream.fd, null);
-    stream.on('close', common.mustCall(function() {
-      assert.strictEqual(stream.closed, true);
-      process.nextTick(next2);
-    }));
-  }));
+  stream.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(stream.closed, false);
+      assert.strictEqual(stream.fd, null);
+      stream.on(
+        'close',
+        common.mustCall(function() {
+          assert.strictEqual(stream.closed, true);
+          process.nextTick(next2);
+        })
+      );
+    })
+  );
 }
 
 function next2() {
@@ -49,11 +60,17 @@ function next3() {
   const stream = fs.createWriteStream(file, { autoClose: true });
   stream.write('Test3');
   stream.end();
-  stream.on('finish', common.mustCall(function() {
-    assert.strictEqual(stream.closed, false);
-    assert.strictEqual(stream.fd, null);
-    stream.on('close', common.mustCall(function() {
-      assert.strictEqual(stream.closed, true);
-    }));
-  }));
+  stream.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(stream.closed, false);
+      assert.strictEqual(stream.fd, null);
+      stream.on(
+        'close',
+        common.mustCall(function() {
+          assert.strictEqual(stream.closed, true);
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-fs-write-stream-double-close.js b/test/parallel/test-fs-write-stream-double-close.js
index 28e53061f74c3b..16f1faa2ac6e15 100644
--- a/test/parallel/test-fs-write-stream-double-close.js
+++ b/test/parallel/test-fs-write-stream-double-close.js
@@ -23,17 +23,23 @@ tmpdir.refresh();
     emits++;
   });
 
-  s.close(common.mustCall(() => {
-    assert.strictEqual(emits, 1);
-    s.close(common.mustCall(() => {
+  s.close(
+    common.mustCall(() => {
       assert.strictEqual(emits, 1);
-    }));
-    process.nextTick(() => {
-      s.close(common.mustCall(() => {
-        assert.strictEqual(emits, 1);
-      }));
-    });
-  }));
+      s.close(
+        common.mustCall(() => {
+          assert.strictEqual(emits, 1);
+        })
+      );
+      process.nextTick(() => {
+        s.close(
+          common.mustCall(() => {
+            assert.strictEqual(emits, 1);
+          })
+        );
+      });
+    })
+  );
 }
 
 {
diff --git a/test/parallel/test-fs-write-stream-end.js b/test/parallel/test-fs-write-stream-end.js
index 36e7cb5504cab0..0eadc4f092cd5c 100644
--- a/test/parallel/test-fs-write-stream-end.js
+++ b/test/parallel/test-fs-write-stream-end.js
@@ -39,8 +39,11 @@ tmpdir.refresh();
   const file = path.join(tmpdir.path, 'write-end-test1.txt');
   const stream = fs.createWriteStream(file);
   stream.end('a\n', 'utf8');
-  stream.on('close', common.mustCall(function() {
-    const content = fs.readFileSync(file, 'utf8');
-    assert.strictEqual(content, 'a\n');
-  }));
+  stream.on(
+    'close',
+    common.mustCall(function() {
+      const content = fs.readFileSync(file, 'utf8');
+      assert.strictEqual(content, 'a\n');
+    })
+  );
 }
diff --git a/test/parallel/test-fs-write-stream-err.js b/test/parallel/test-fs-write-stream-err.js
index 36bf9dbcfb068e..17f10ce04c6403 100644
--- a/test/parallel/test-fs-write-stream-err.js
+++ b/test/parallel/test-fs-write-stream-err.js
@@ -59,17 +59,22 @@ fs.close = common.mustCall(function(fd_, cb) {
   process.nextTick(cb);
 });
 
-stream.on('error', common.mustCall(function(err_) {
-  console.error('error handler');
-  assert.strictEqual(stream.fd, null);
-  assert.strictEqual(err_, err);
-}));
-
+stream.on(
+  'error',
+  common.mustCall(function(err_) {
+    console.error('error handler');
+    assert.strictEqual(stream.fd, null);
+    assert.strictEqual(err_, err);
+  })
+);
 
 stream.write(Buffer.allocUnsafe(256), function() {
   console.error('first cb');
-  stream.write(Buffer.allocUnsafe(256), common.mustCall(function(err_) {
-    console.error('second cb');
-    assert.strictEqual(err_, err);
-  }));
+  stream.write(
+    Buffer.allocUnsafe(256),
+    common.mustCall(function(err_) {
+      console.error('second cb');
+      assert.strictEqual(err_, err);
+    })
+  );
 });
diff --git a/test/parallel/test-fs-write-stream-throw-type-error.js b/test/parallel/test-fs-write-stream-throw-type-error.js
index c80f647b3d622e..c2c8f95f807820 100644
--- a/test/parallel/test-fs-write-stream-throw-type-error.js
+++ b/test/parallel/test-fs-write-stream-throw-type-error.js
@@ -22,7 +22,8 @@ const createWriteStreamErr = (path, opt) => {
     {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError
-    });
+    }
+  );
 };
 
 createWriteStreamErr(example, 123);
diff --git a/test/parallel/test-fs-write-stream.js b/test/parallel/test-fs-write-stream.js
index e93f65e604c20b..b353e22cb8adbf 100644
--- a/test/parallel/test-fs-write-stream.js
+++ b/test/parallel/test-fs-write-stream.js
@@ -46,8 +46,10 @@ tmpdir.refresh();
   const stream = fs.createWriteStream(file);
 
   stream.on('drain', function() {
-    assert.fail('\'drain\' event must not be emitted before ' +
-                'stream.write() has been called at least once.');
+    assert.fail(
+      "'drain' event must not be emitted before " +
+        'stream.write() has been called at least once.'
+    );
   });
   stream.destroy();
 }
@@ -55,12 +57,16 @@ tmpdir.refresh();
 // Throws if data is not of type Buffer.
 {
   const stream = fs.createWriteStream(file);
-  common.expectsError(() => {
-    stream._write(42, null, function() {});
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "data" argument must be of type Buffer. Received type number'
-  });
+  common.expectsError(
+    () => {
+      stream._write(42, null, function() {});
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "data" argument must be of type Buffer. Received type number'
+    }
+  );
   stream.destroy();
 }
diff --git a/test/parallel/test-fs-write-string-coerce.js b/test/parallel/test-fs-write-string-coerce.js
index 4581c319277a78..d3be8e82b988ab 100644
--- a/test/parallel/test-fs-write-string-coerce.js
+++ b/test/parallel/test-fs-write-string-coerce.js
@@ -11,18 +11,29 @@ const fn = path.join(tmpdir.path, 'write-string-coerce.txt');
 const data = true;
 const expected = String(data);
 
-fs.open(fn, 'w', 0o644, common.mustCall(function(err, fd) {
-  assert.ifError(err);
-  console.log('open done');
-  fs.write(fd, data, 0, 'utf8', common.mustCall(function(err, written) {
-    console.log('write done');
+fs.open(
+  fn,
+  'w',
+  0o644,
+  common.mustCall(function(err, fd) {
     assert.ifError(err);
-    assert.strictEqual(Buffer.byteLength(expected), written);
-    fs.closeSync(fd);
-    const found = fs.readFileSync(fn, 'utf8');
-    console.log(`expected: "${expected}"`);
-    console.log(`found: "${found}"`);
-    fs.unlinkSync(fn);
-    assert.strictEqual(expected, found);
-  }));
-}));
+    console.log('open done');
+    fs.write(
+      fd,
+      data,
+      0,
+      'utf8',
+      common.mustCall(function(err, written) {
+        console.log('write done');
+        assert.ifError(err);
+        assert.strictEqual(Buffer.byteLength(expected), written);
+        fs.closeSync(fd);
+        const found = fs.readFileSync(fn, 'utf8');
+        console.log(`expected: "${expected}"`);
+        console.log(`found: "${found}"`);
+        fs.unlinkSync(fn);
+        assert.strictEqual(expected, found);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-fs-write.js b/test/parallel/test-fs-write.js
index d75974b58d33cf..e3c44a870906ba 100644
--- a/test/parallel/test-fs-write.js
+++ b/test/parallel/test-fs-write.js
@@ -39,7 +39,7 @@ const constants = fs.constants;
 common.allowGlobals(externalizeString, isOneByteString, x);
 
 {
-  const expected = 'ümlaut eins';  // Must be a unique string.
+  const expected = 'ümlaut eins'; // Must be a unique string.
   externalizeString(expected);
   assert.strictEqual(isOneByteString(expected), true);
   const fd = fs.openSync(fn, 'w');
@@ -49,7 +49,7 @@ common.allowGlobals(externalizeString, isOneByteString, x);
 }
 
 {
-  const expected = 'ümlaut zwei';  // Must be a unique string.
+  const expected = 'ümlaut zwei'; // Must be a unique string.
   externalizeString(expected);
   assert.strictEqual(isOneByteString(expected), true);
   const fd = fs.openSync(fn, 'w');
@@ -59,7 +59,7 @@ common.allowGlobals(externalizeString, isOneByteString, x);
 }
 
 {
-  const expected = '中文 1';  // Must be a unique string.
+  const expected = '中文 1'; // Must be a unique string.
   externalizeString(expected);
   assert.strictEqual(isOneByteString(expected), false);
   const fd = fs.openSync(fn, 'w');
@@ -69,7 +69,7 @@ common.allowGlobals(externalizeString, isOneByteString, x);
 }
 
 {
-  const expected = '中文 2';  // Must be a unique string.
+  const expected = '中文 2'; // Must be a unique string.
   externalizeString(expected);
   assert.strictEqual(isOneByteString(expected), false);
   const fd = fs.openSync(fn, 'w');
@@ -79,74 +79,83 @@ common.allowGlobals(externalizeString, isOneByteString, x);
 }
 /* eslint-enable no-undef */
 
-fs.open(fn, 'w', 0o644, common.mustCall((err, fd) => {
-  assert.ifError(err);
-
-  const done = common.mustCall((err, written) => {
+fs.open(
+  fn,
+  'w',
+  0o644,
+  common.mustCall((err, fd) => {
     assert.ifError(err);
-    assert.strictEqual(written, Buffer.byteLength(expected));
-    fs.closeSync(fd);
-    const found = fs.readFileSync(fn, 'utf8');
-    fs.unlinkSync(fn);
-    assert.strictEqual(found, expected);
-  });
 
-  const written = common.mustCall((err, written) => {
-    assert.ifError(err);
-    assert.strictEqual(written, 0);
-    fs.write(fd, expected, 0, 'utf8', done);
-  });
-
-  fs.write(fd, '', 0, 'utf8', written);
-}));
+    const done = common.mustCall((err, written) => {
+      assert.ifError(err);
+      assert.strictEqual(written, Buffer.byteLength(expected));
+      fs.closeSync(fd);
+      const found = fs.readFileSync(fn, 'utf8');
+      fs.unlinkSync(fn);
+      assert.strictEqual(found, expected);
+    });
+
+    const written = common.mustCall((err, written) => {
+      assert.ifError(err);
+      assert.strictEqual(written, 0);
+      fs.write(fd, expected, 0, 'utf8', done);
+    });
+
+    fs.write(fd, '', 0, 'utf8', written);
+  })
+);
 
 const args = constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC;
-fs.open(fn2, args, 0o644, common.mustCall((err, fd) => {
-  assert.ifError(err);
-
-  const done = common.mustCall((err, written) => {
+fs.open(
+  fn2,
+  args,
+  0o644,
+  common.mustCall((err, fd) => {
     assert.ifError(err);
-    assert.strictEqual(written, Buffer.byteLength(expected));
-    fs.closeSync(fd);
-    const found = fs.readFileSync(fn2, 'utf8');
-    fs.unlinkSync(fn2);
-    assert.strictEqual(found, expected);
-  });
 
-  const written = common.mustCall((err, written) => {
+    const done = common.mustCall((err, written) => {
+      assert.ifError(err);
+      assert.strictEqual(written, Buffer.byteLength(expected));
+      fs.closeSync(fd);
+      const found = fs.readFileSync(fn2, 'utf8');
+      fs.unlinkSync(fn2);
+      assert.strictEqual(found, expected);
+    });
+
+    const written = common.mustCall((err, written) => {
+      assert.ifError(err);
+      assert.strictEqual(written, 0);
+      fs.write(fd, expected, 0, 'utf8', done);
+    });
+
+    fs.write(fd, '', 0, 'utf8', written);
+  })
+);
+
+fs.open(
+  fn3,
+  'w',
+  0o644,
+  common.mustCall((err, fd) => {
     assert.ifError(err);
-    assert.strictEqual(written, 0);
-    fs.write(fd, expected, 0, 'utf8', done);
-  });
-
-  fs.write(fd, '', 0, 'utf8', written);
-}));
 
-fs.open(fn3, 'w', 0o644, common.mustCall((err, fd) => {
-  assert.ifError(err);
+    const done = common.mustCall((err, written) => {
+      assert.ifError(err);
+      assert.strictEqual(written, Buffer.byteLength(expected));
+      fs.closeSync(fd);
+    });
 
-  const done = common.mustCall((err, written) => {
-    assert.ifError(err);
-    assert.strictEqual(written, Buffer.byteLength(expected));
-    fs.closeSync(fd);
-  });
-
-  fs.write(fd, expected, done);
-}));
+    fs.write(fd, expected, done);
+  })
+);
 
 [false, 'test', {}, [], null, undefined].forEach((i) => {
-  common.expectsError(
-    () => fs.write(i, common.mustNotCall()),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
-  common.expectsError(
-    () => fs.writeSync(i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+  common.expectsError(() => fs.write(i, common.mustNotCall()), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
+  common.expectsError(() => fs.writeSync(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-gc-http-client-connaborted.js b/test/parallel/test-gc-http-client-connaborted.js
index fa6bf20c176560..9937bf8bd60310 100644
--- a/test/parallel/test-gc-http-client-connaborted.js
+++ b/test/parallel/test-gc-http-client-connaborted.js
@@ -19,20 +19,26 @@ function serverHandler(req, res) {
 }
 
 const server = http.createServer(serverHandler);
-server.listen(0, common.mustCall(() => {
-  for (let i = 0; i < 10; i++)
-    getall();
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    for (let i = 0; i < 10; i++) getall();
+  })
+);
 
 function getall() {
-  if (count >= todo)
-    return;
-
-  const req = http.get({
-    hostname: 'localhost',
-    pathname: '/',
-    port: server.address().port
-  }, cb).on('error', cb);
+  if (count >= todo) return;
+
+  const req = http
+    .get(
+      {
+        hostname: 'localhost',
+        pathname: '/',
+        port: server.address().port
+      },
+      cb
+    )
+    .on('error', cb);
 
   count++;
   onGC(req, { ongc });
diff --git a/test/parallel/test-gc-http-client-onerror.js b/test/parallel/test-gc-http-client-onerror.js
index 28a8aecd27e794..17f76de4f75570 100644
--- a/test/parallel/test-gc-http-client-onerror.js
+++ b/test/parallel/test-gc-http-client-onerror.js
@@ -21,20 +21,26 @@ let countGC = 0;
 console.log(`We should do ${todo} requests`);
 
 const server = http.createServer(serverHandler);
-server.listen(0, common.mustCall(() => {
-  for (let i = 0; i < 10; i++)
-    getall();
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    for (let i = 0; i < 10; i++) getall();
+  })
+);
 
 function getall() {
-  if (count >= todo)
-    return;
+  if (count >= todo) return;
 
-  const req = http.get({
-    hostname: 'localhost',
-    pathname: '/',
-    port: server.address().port
-  }, cb).on('error', onerror);
+  const req = http
+    .get(
+      {
+        hostname: 'localhost',
+        pathname: '/',
+        port: server.address().port
+      },
+      cb
+    )
+    .on('error', onerror);
 
   count++;
   onGC(req, { ongc });
diff --git a/test/parallel/test-gc-http-client-timeout.js b/test/parallel/test-gc-http-client-timeout.js
index 359f890dc3944e..4de6dbd7ea33da 100644
--- a/test/parallel/test-gc-http-client-timeout.js
+++ b/test/parallel/test-gc-http-client-timeout.js
@@ -26,14 +26,16 @@ const server = http.createServer(serverHandler);
 server.listen(0, common.mustCall(getall));
 
 function getall() {
-  if (count >= todo)
-    return;
+  if (count >= todo) return;
 
-  const req = http.get({
-    hostname: 'localhost',
-    pathname: '/',
-    port: server.address().port
-  }, cb);
+  const req = http.get(
+    {
+      hostname: 'localhost',
+      pathname: '/',
+      port: server.address().port
+    },
+    cb
+  );
 
   req.setTimeout(10, function() {
     console.log('timeout (expected)');
@@ -45,8 +47,7 @@ function getall() {
   setImmediate(getall);
 }
 
-for (let i = 0; i < 10; i++)
-  getall();
+for (let i = 0; i < 10; i++) getall();
 
 function cb(res) {
   res.resume();
diff --git a/test/parallel/test-gc-net-timeout.js b/test/parallel/test-gc-net-timeout.js
index 51d9b8ca09bbbc..7aac1f4fad4b7c 100644
--- a/test/parallel/test-gc-net-timeout.js
+++ b/test/parallel/test-gc-net-timeout.js
@@ -33,8 +33,7 @@ const server = net.createServer(serverHandler);
 server.listen(0, getall);
 
 function getall() {
-  if (count >= todo)
-    return;
+  if (count >= todo) return;
 
   const req = net.connect(server.address().port);
   req.resume();
@@ -49,8 +48,7 @@ function getall() {
   setImmediate(getall);
 }
 
-for (let i = 0; i < 10; i++)
-  getall();
+for (let i = 0; i < 10; i++) getall();
 
 function ongc() {
   countGC++;
diff --git a/test/parallel/test-gc-tls-external-memory.js b/test/parallel/test-gc-tls-external-memory.js
index 2b584dd93dcf5b..ff3eb26124fdc2 100644
--- a/test/parallel/test-gc-tls-external-memory.js
+++ b/test/parallel/test-gc-tls-external-memory.js
@@ -5,8 +5,7 @@
 // when a lot tls connections are opened and closed
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const makeDuplexPair = require('../common/duplexpair');
 const onGC = require('../common/ongc');
@@ -21,13 +20,14 @@ let runs = 0;
 
 // Count garbage-collected TLS sockets.
 let gced = 0;
-function ongc() { gced++; }
+function ongc() {
+  gced++;
+}
 
 connect();
 
 function connect() {
-  if (runs % 64 === 0)
-    global.gc();
+  if (runs % 64 === 0) global.gc();
   const externalMemoryUsage = process.memoryUsage().external;
   assert(externalMemoryUsage >= 0, `${externalMemoryUsage} < 0`);
   if (runs++ === 512) {
diff --git a/test/parallel/test-global-console-exists.js b/test/parallel/test-global-console-exists.js
index f2e7ba5a9aa3a0..216df60bd13d8f 100644
--- a/test/parallel/test-global-console-exists.js
+++ b/test/parallel/test-global-console-exists.js
@@ -27,10 +27,8 @@ process.on('exit', () => {
 });
 
 process.stderr.write = (data) => {
-  if (writeTimes === 0)
-    assert.ok(leakWarning.test(data));
-  else
-    assert.fail('stderr.write should be called only once');
+  if (writeTimes === 0) assert.ok(leakWarning.test(data));
+  else assert.fail('stderr.write should be called only once');
 
   writeTimes++;
 };
diff --git a/test/parallel/test-global.js b/test/parallel/test-global.js
index b139a6287488d2..4da1e4640cb854 100644
--- a/test/parallel/test-global.js
+++ b/test/parallel/test-global.js
@@ -33,13 +33,18 @@ common.allowGlobals('bar', 'foo');
 baseFoo = 'foo'; // eslint-disable-line no-undef
 global.baseBar = 'bar';
 
-assert.strictEqual(global.baseFoo, 'foo',
-                   `x -> global.x failed: global.baseFoo = ${global.baseFoo}`);
-
-assert.strictEqual(baseBar, // eslint-disable-line no-undef
-                   'bar',
-                   // eslint-disable-next-line no-undef
-                   `global.x -> x failed: baseBar = ${baseBar}`);
+assert.strictEqual(
+  global.baseFoo,
+  'foo',
+  `x -> global.x failed: global.baseFoo = ${global.baseFoo}`
+);
+
+assert.strictEqual(
+  baseBar, // eslint-disable-line no-undef
+  'bar',
+  // eslint-disable-next-line no-undef
+  `global.x -> x failed: baseBar = ${baseBar}`
+);
 
 const mod = require(fixtures.path('global', 'plain'));
 const fooBar = mod.fooBar;
diff --git a/test/parallel/test-handle-wrap-isrefed.js b/test/parallel/test-handle-wrap-isrefed.js
index 421bf696b11148..f03ab64ebfb7f3 100644
--- a/test/parallel/test-handle-wrap-isrefed.js
+++ b/test/parallel/test-handle-wrap-isrefed.js
@@ -10,20 +10,22 @@ const { internalBinding } = require('internal/test/binding');
   const spawn = require('child_process').spawn;
   const cmd = common.isWindows ? 'rundll32' : 'ls';
   const cp = spawn(cmd);
-  strictEqual(cp._handle.hasRef(),
-              true, 'process_wrap: not initially refed');
+  strictEqual(cp._handle.hasRef(), true, 'process_wrap: not initially refed');
   cp.unref();
-  strictEqual(cp._handle.hasRef(),
-              false, 'process_wrap: unref() ineffective');
+  strictEqual(cp._handle.hasRef(), false, 'process_wrap: unref() ineffective');
   cp.ref();
-  strictEqual(cp._handle.hasRef(),
-              true, 'process_wrap: ref() ineffective');
-  cp._handle.close(common.mustCall(() =>
-    strictEqual(cp._handle.hasRef(),
-                false, 'process_wrap: not unrefed on close')));
+  strictEqual(cp._handle.hasRef(), true, 'process_wrap: ref() ineffective');
+  cp._handle.close(
+    common.mustCall(() =>
+      strictEqual(
+        cp._handle.hasRef(),
+        false,
+        'process_wrap: not unrefed on close'
+      )
+    )
+  );
 }
 
-
 const dgram = require('dgram');
 const { kStateSymbol } = require('internal/dgram');
 
@@ -32,79 +34,80 @@ const { kStateSymbol } = require('internal/dgram');
   const sock4 = dgram.createSocket('udp4');
   const handle = sock4[kStateSymbol].handle;
 
-  strictEqual(handle.hasRef(),
-              true, 'udp_wrap: ipv4: not initially refed');
+  strictEqual(handle.hasRef(), true, 'udp_wrap: ipv4: not initially refed');
   sock4.unref();
-  strictEqual(handle.hasRef(),
-              false, 'udp_wrap: ipv4: unref() ineffective');
+  strictEqual(handle.hasRef(), false, 'udp_wrap: ipv4: unref() ineffective');
   sock4.ref();
-  strictEqual(handle.hasRef(),
-              true, 'udp_wrap: ipv4: ref() ineffective');
-  handle.close(common.mustCall(() =>
-    strictEqual(handle.hasRef(),
-                false, 'udp_wrap: ipv4: not unrefed on close')));
+  strictEqual(handle.hasRef(), true, 'udp_wrap: ipv4: ref() ineffective');
+  handle.close(
+    common.mustCall(() =>
+      strictEqual(
+        handle.hasRef(),
+        false,
+        'udp_wrap: ipv4: not unrefed on close'
+      )
+    )
+  );
 }
 
-
 // dgram ipv6
 {
   const sock6 = dgram.createSocket('udp6');
   const handle = sock6[kStateSymbol].handle;
 
-  strictEqual(handle.hasRef(),
-              true, 'udp_wrap: ipv6: not initially refed');
+  strictEqual(handle.hasRef(), true, 'udp_wrap: ipv6: not initially refed');
   sock6.unref();
-  strictEqual(handle.hasRef(),
-              false, 'udp_wrap: ipv6: unref() ineffective');
+  strictEqual(handle.hasRef(), false, 'udp_wrap: ipv6: unref() ineffective');
   sock6.ref();
-  strictEqual(handle.hasRef(),
-              true, 'udp_wrap: ipv6: ref() ineffective');
-  handle.close(common.mustCall(() =>
-    strictEqual(handle.hasRef(),
-                false, 'udp_wrap: ipv6: not unrefed on close')));
+  strictEqual(handle.hasRef(), true, 'udp_wrap: ipv6: ref() ineffective');
+  handle.close(
+    common.mustCall(() =>
+      strictEqual(
+        handle.hasRef(),
+        false,
+        'udp_wrap: ipv6: not unrefed on close'
+      )
+    )
+  );
 }
 
-
 // pipe
 {
   const { Pipe, constants: PipeConstants } = internalBinding('pipe_wrap');
   const handle = new Pipe(PipeConstants.SOCKET);
-  strictEqual(handle.hasRef(),
-              true, 'pipe_wrap: not initially refed');
+  strictEqual(handle.hasRef(), true, 'pipe_wrap: not initially refed');
   handle.unref();
-  strictEqual(handle.hasRef(),
-              false, 'pipe_wrap: unref() ineffective');
+  strictEqual(handle.hasRef(), false, 'pipe_wrap: unref() ineffective');
   handle.ref();
-  strictEqual(handle.hasRef(),
-              true, 'pipe_wrap: ref() ineffective');
-  handle.close(common.mustCall(() =>
-    strictEqual(handle.hasRef(),
-                false, 'pipe_wrap: not unrefed on close')));
+  strictEqual(handle.hasRef(), true, 'pipe_wrap: ref() ineffective');
+  handle.close(
+    common.mustCall(() =>
+      strictEqual(handle.hasRef(), false, 'pipe_wrap: not unrefed on close')
+    )
+  );
 }
 
-
 // tcp
 {
   const net = require('net');
   const server = net.createServer(() => {}).listen(0);
-  strictEqual(server._handle.hasRef(),
-              true, 'tcp_wrap: not initially refed');
-  strictEqual(server._unref,
-              false, 'tcp_wrap: _unref initially incorrect');
+  strictEqual(server._handle.hasRef(), true, 'tcp_wrap: not initially refed');
+  strictEqual(server._unref, false, 'tcp_wrap: _unref initially incorrect');
   server.unref();
-  strictEqual(server._handle.hasRef(),
-              false, 'tcp_wrap: unref() ineffective');
-  strictEqual(server._unref,
-              true, 'tcp_wrap: _unref not updated on unref()');
+  strictEqual(server._handle.hasRef(), false, 'tcp_wrap: unref() ineffective');
+  strictEqual(server._unref, true, 'tcp_wrap: _unref not updated on unref()');
   server.ref();
-  strictEqual(server._handle.hasRef(),
-              true, 'tcp_wrap: ref() ineffective');
-  strictEqual(server._unref,
-              false, 'tcp_wrap: _unref not updated on ref()');
-  server._handle.close(common.mustCall(() =>
-    strictEqual(server._handle.hasRef(),
-                false, 'tcp_wrap: not unrefed on close')));
+  strictEqual(server._handle.hasRef(), true, 'tcp_wrap: ref() ineffective');
+  strictEqual(server._unref, false, 'tcp_wrap: _unref not updated on ref()');
+  server._handle.close(
+    common.mustCall(() =>
+      strictEqual(
+        server._handle.hasRef(),
+        false,
+        'tcp_wrap: not unrefed on close'
+      )
+    )
+  );
 }
 
-
 // see also test/pseudo-tty/test-handle-wrap-isrefed-tty.js
diff --git a/test/parallel/test-heapdump-http2.js b/test/parallel/test-heapdump-http2.js
index caece96d01cc72..afd621b877cabc 100644
--- a/test/parallel/test-heapdump-http2.js
+++ b/test/parallel/test-heapdump-http2.js
@@ -2,8 +2,7 @@
 'use strict';
 const common = require('../common');
 const { recordState } = require('../common/heap');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 {
@@ -20,69 +19,90 @@ server.listen(0, () => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
-  req.on('response', common.mustCall(() => {
-    const state = recordState();
+  req.on(
+    'response',
+    common.mustCall(() => {
+      const state = recordState();
 
-    // `Node / Http2Stream` (C++) -> Http2Stream (JS)
-    state.validateSnapshotNodes('Node / Http2Stream', [
-      {
-        children: [
-          // current_headers and/or queue could be empty
-          { node_name: 'Http2Stream', edge_name: 'wrapped' }
-        ]
-      },
-    ], { loose: true });
+      // `Node / Http2Stream` (C++) -> Http2Stream (JS)
+      state.validateSnapshotNodes(
+        'Node / Http2Stream',
+        [
+          {
+            children: [
+              // current_headers and/or queue could be empty
+              { node_name: 'Http2Stream', edge_name: 'wrapped' }
+            ]
+          }
+        ],
+        { loose: true }
+      );
 
-    // `Node / FileHandle` (C++) -> FileHandle (JS)
-    state.validateSnapshotNodes('Node / FileHandle', [
-      {
-        children: [
-          { node_name: 'FileHandle', edge_name: 'wrapped' }
-          // current_headers could be empty
-        ]
-      }
-    ], { loose: true });
-    state.validateSnapshotNodes('Node / TCPSocketWrap', [
-      {
-        children: [
-          { node_name: 'TCP', edge_name: 'wrapped' }
-        ]
-      }
-    ], { loose: true });
-    state.validateSnapshotNodes('Node / TCPServerWrap', [
-      {
-        children: [
-          { node_name: 'TCP', edge_name: 'wrapped' }
-        ]
-      }
-    ], { loose: true });
-    // `Node / StreamPipe` (C++) -> StreamPipe (JS)
-    state.validateSnapshotNodes('Node / StreamPipe', [
-      {
-        children: [
-          { node_name: 'StreamPipe', edge_name: 'wrapped' }
-        ]
-      }
-    ]);
-    // `Node / Http2Session` (C++) -> Http2Session (JS)
-    state.validateSnapshotNodes('Node / Http2Session', [
-      {
-        children: [
-          { node_name: 'Http2Session', edge_name: 'wrapped' },
+      // `Node / FileHandle` (C++) -> FileHandle (JS)
+      state.validateSnapshotNodes(
+        'Node / FileHandle',
+        [
+          {
+            children: [
+              { node_name: 'FileHandle', edge_name: 'wrapped' }
+              // current_headers could be empty
+            ]
+          }
+        ],
+        { loose: true }
+      );
+      state.validateSnapshotNodes(
+        'Node / TCPSocketWrap',
+        [
+          {
+            children: [{ node_name: 'TCP', edge_name: 'wrapped' }]
+          }
+        ],
+        { loose: true }
+      );
+      state.validateSnapshotNodes(
+        'Node / TCPServerWrap',
+        [
+          {
+            children: [{ node_name: 'TCP', edge_name: 'wrapped' }]
+          }
+        ],
+        { loose: true }
+      );
+      // `Node / StreamPipe` (C++) -> StreamPipe (JS)
+      state.validateSnapshotNodes('Node / StreamPipe', [
+        {
+          children: [{ node_name: 'StreamPipe', edge_name: 'wrapped' }]
+        }
+      ]);
+      // `Node / Http2Session` (C++) -> Http2Session (JS)
+      state.validateSnapshotNodes(
+        'Node / Http2Session',
+        [
           {
-            node_name: 'Node / streams', edge_name: 'streams'
+            children: [
+              { node_name: 'Http2Session', edge_name: 'wrapped' },
+              {
+                node_name: 'Node / streams',
+                edge_name: 'streams'
+              }
+              // outstanding_pings, outgoing_buffers, outgoing_storage,
+              // pending_rst_streams could be empty
+            ]
           }
-          // outstanding_pings, outgoing_buffers, outgoing_storage,
-          // pending_rst_streams could be empty
-        ]
-      }
-    ], { loose: true });
-  }));
+        ],
+        { loose: true }
+      );
+    })
+  );
 
   req.resume();
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
diff --git a/test/parallel/test-heapdump-inspector.js b/test/parallel/test-heapdump-inspector.js
index 963b85ac3a029a..a774b6714d71da 100644
--- a/test/parallel/test-heapdump-inspector.js
+++ b/test/parallel/test-heapdump-inspector.js
@@ -8,9 +8,7 @@ const { validateSnapshotNodes } = require('../common/heap');
 const inspector = require('inspector');
 
 const snapshotNode = {
-  children: [
-    { node_name: 'Node / InspectorSession', edge_name: 'session' }
-  ]
+  children: [{ node_name: 'Node / InspectorSession', edge_name: 'session' }]
 };
 
 // starts with no JSBindingsConnection (or 1 if coverage enabled).
@@ -31,9 +29,10 @@ const snapshotNode = {
       children: [
         { node_name: 'Node / InspectorSession', edge_name: 'session' },
         { node_name: 'Connection', edge_name: 'wrapped' },
-        (edge) => edge.name === 'callback' &&
+        (edge) =>
+          edge.name === 'callback' &&
           (edge.to.type === undefined || // embedded graph
-           edge.to.type === 'closure') // snapshot
+            edge.to.type === 'closure') // snapshot
       ]
     }
   ];
diff --git a/test/parallel/test-heapdump-tls.js b/test/parallel/test-heapdump-tls.js
index fee19bf67625b2..1b12088545261c 100644
--- a/test/parallel/test-heapdump-tls.js
+++ b/test/parallel/test-heapdump-tls.js
@@ -2,8 +2,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const { validateSnapshotNodes } = require('../common/heap');
 const net = require('net');
@@ -11,25 +10,35 @@ const tls = require('tls');
 
 validateSnapshotNodes('Node / TLSWrap', []);
 
-const server = net.createServer(common.mustCall((c) => {
-  c.end();
-})).listen(0, common.mustCall(() => {
-  const c = tls.connect({ port: server.address().port });
+const server = net
+  .createServer(
+    common.mustCall((c) => {
+      c.end();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const c = tls.connect({ port: server.address().port });
 
-  c.on('error', common.mustCall(() => {
-    server.close();
-  }));
-  c.write('hello');
+      c.on(
+        'error',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+      c.write('hello');
 
-  validateSnapshotNodes('Node / TLSWrap', [
-    {
-      children: [
-        { node_name: 'Node / NodeBIO', edge_name: 'enc_out' },
-        { node_name: 'Node / NodeBIO', edge_name: 'enc_in' },
-        // `Node / TLSWrap` (C++) -> `TLSWrap` (JS)
-        { node_name: 'TLSWrap', edge_name: 'wrapped' }
-        // pending_cleartext_input could be empty
-      ]
-    }
-  ]);
-}));
+      validateSnapshotNodes('Node / TLSWrap', [
+        {
+          children: [
+            { node_name: 'Node / NodeBIO', edge_name: 'enc_out' },
+            { node_name: 'Node / NodeBIO', edge_name: 'enc_in' },
+            // `Node / TLSWrap` (C++) -> `TLSWrap` (JS)
+            { node_name: 'TLSWrap', edge_name: 'wrapped' }
+            // pending_cleartext_input could be empty
+          ]
+        }
+      ]);
+    })
+  );
diff --git a/test/parallel/test-heapdump-worker.js b/test/parallel/test-heapdump-worker.js
index 02b989c6b324dd..81c5651434ccf5 100644
--- a/test/parallel/test-heapdump-worker.js
+++ b/test/parallel/test-heapdump-worker.js
@@ -16,11 +16,13 @@ validateSnapshotNodes('Node / Worker', [
     ]
   }
 ]);
-validateSnapshotNodes('Node / MessagePort', [
-  {
-    children: [
-      { node_name: 'Node / MessagePortData', edge_name: 'data' }
-    ]
-  }
-], { loose: true });
+validateSnapshotNodes(
+  'Node / MessagePort',
+  [
+    {
+      children: [{ node_name: 'Node / MessagePortData', edge_name: 'data' }]
+    }
+  ],
+  { loose: true }
+);
 worker.terminate();
diff --git a/test/parallel/test-http-1.0-keep-alive.js b/test/parallel/test-http-1.0-keep-alive.js
index 6d117035a5c727..1df0fa819e009a 100644
--- a/test/parallel/test-http-1.0-keep-alive.js
+++ b/test/parallel/test-http-1.0-keep-alive.js
@@ -25,83 +25,100 @@ const http = require('http');
 const net = require('net');
 
 // Check that our HTTP server correctly handles HTTP/1.0 keep-alive requests.
-check([{
-  name: 'keep-alive, no TE header',
-  requests: [{
-    expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
-          'Connection: keep-alive\r\n' +
-          '\r\n'
-  }, {
-    expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
-          'Connection: keep-alive\r\n' +
-          '\r\n'
-  }],
-  responses: [{
-    headers: { 'Connection': 'keep-alive' },
-    chunks: ['OK']
-  }, {
-    chunks: []
-  }]
-}, {
-  name: 'keep-alive, with TE: chunked',
-  requests: [{
-    expectClose: false,
-    data: 'POST / HTTP/1.0\r\n' +
+check([
+  {
+    name: 'keep-alive, no TE header',
+    requests: [
+      {
+        expectClose: true,
+        data: 'POST / HTTP/1.0\r\n' + 'Connection: keep-alive\r\n' + '\r\n'
+      },
+      {
+        expectClose: true,
+        data: 'POST / HTTP/1.0\r\n' + 'Connection: keep-alive\r\n' + '\r\n'
+      }
+    ],
+    responses: [
+      {
+        headers: { Connection: 'keep-alive' },
+        chunks: ['OK']
+      },
+      {
+        chunks: []
+      }
+    ]
+  },
+  {
+    name: 'keep-alive, with TE: chunked',
+    requests: [
+      {
+        expectClose: false,
+        data:
+          'POST / HTTP/1.0\r\n' +
           'Connection: keep-alive\r\n' +
           'TE: chunked\r\n' +
           '\r\n'
-  }, {
-    expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
-          '\r\n'
-  }],
-  responses: [{
-    headers: { 'Connection': 'keep-alive' },
-    chunks: ['OK']
-  }, {
-    chunks: []
-  }]
-}, {
-  name: 'keep-alive, with Transfer-Encoding: chunked',
-  requests: [{
-    expectClose: false,
-    data: 'POST / HTTP/1.0\r\n' +
-          'Connection: keep-alive\r\n' +
-          '\r\n'
-  }, {
-    expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
-          '\r\n'
-  }],
-  responses: [{
-    headers: { 'Connection': 'keep-alive',
-               'Transfer-Encoding': 'chunked' },
-    chunks: ['OK']
-  }, {
-    chunks: []
-  }]
-}, {
-  name: 'keep-alive, with Content-Length',
-  requests: [{
-    expectClose: false,
-    data: 'POST / HTTP/1.0\r\n' +
-          'Connection: keep-alive\r\n' +
-          '\r\n'
-  }, {
-    expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
-          '\r\n'
-  }],
-  responses: [{
-    headers: { 'Connection': 'keep-alive',
-               'Content-Length': '2' },
-    chunks: ['OK']
-  }, {
-    chunks: []
-  }]
-}]);
+      },
+      {
+        expectClose: true,
+        data: 'POST / HTTP/1.0\r\n' + '\r\n'
+      }
+    ],
+    responses: [
+      {
+        headers: { Connection: 'keep-alive' },
+        chunks: ['OK']
+      },
+      {
+        chunks: []
+      }
+    ]
+  },
+  {
+    name: 'keep-alive, with Transfer-Encoding: chunked',
+    requests: [
+      {
+        expectClose: false,
+        data: 'POST / HTTP/1.0\r\n' + 'Connection: keep-alive\r\n' + '\r\n'
+      },
+      {
+        expectClose: true,
+        data: 'POST / HTTP/1.0\r\n' + '\r\n'
+      }
+    ],
+    responses: [
+      {
+        headers: { Connection: 'keep-alive', 'Transfer-Encoding': 'chunked' },
+        chunks: ['OK']
+      },
+      {
+        chunks: []
+      }
+    ]
+  },
+  {
+    name: 'keep-alive, with Content-Length',
+    requests: [
+      {
+        expectClose: false,
+        data: 'POST / HTTP/1.0\r\n' + 'Connection: keep-alive\r\n' + '\r\n'
+      },
+      {
+        expectClose: true,
+        data: 'POST / HTTP/1.0\r\n' + '\r\n'
+      }
+    ],
+    responses: [
+      {
+        headers: { Connection: 'keep-alive', 'Content-Length': '2' },
+        chunks: ['OK']
+      },
+      {
+        chunks: []
+      }
+    ]
+  }
+]);
 
 function check(tests) {
   const test = tests[0];
@@ -120,7 +137,9 @@ function check(tests) {
     const ctx = test.responses[current];
     console.error('<  SERVER SENDING RESPONSE', ctx);
     res.writeHead(200, ctx.headers);
-    ctx.chunks.slice(0, -1).forEach(function(chunk) { res.write(chunk); });
+    ctx.chunks.slice(0, -1).forEach(function(chunk) {
+      res.write(chunk);
+    });
     res.end(ctx.chunks[ctx.chunks.length - 1]);
   }
 
diff --git a/test/parallel/test-http-1.0.js b/test/parallel/test-http-1.0.js
index 134a5bb9853102..bfa6dec20f756a 100644
--- a/test/parallel/test-http-1.0.js
+++ b/test/parallel/test-http-1.0.js
@@ -47,12 +47,15 @@ function test(handler, request_generator, response_validator) {
       server_response += chunk;
     });
 
-    c.on('end', common.mustCall(function() {
-      client_got_eof = true;
-      c.end();
-      server.close();
-      response_validator(server_response, client_got_eof, false);
-    }));
+    c.on(
+      'end',
+      common.mustCall(function() {
+        client_got_eof = true;
+        c.end();
+        server.close();
+        response_validator(server_response, client_got_eof, false);
+      })
+    );
   });
 }
 
@@ -91,26 +94,31 @@ function test(handler, request_generator, response_validator) {
     assert.strictEqual(req.httpVersionMinor, 0);
     res.sendDate = false;
     res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write('Hello, '); res._send('');
-    res.write('world!'); res._send('');
+    res.write('Hello, ');
+    res._send('');
+    res.write('world!');
+    res._send('');
     res.end();
   }
 
   function request_generator() {
-    return ('GET / HTTP/1.0\r\n' +
-        'User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 ' +
-        'OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n' +
-        'Host: 127.0.0.1:1337\r\n' +
-        'Accept: */*\r\n' +
-        '\r\n');
+    return (
+      'GET / HTTP/1.0\r\n' +
+      'User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 ' +
+      'OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n' +
+      'Host: 127.0.0.1:1337\r\n' +
+      'Accept: */*\r\n' +
+      '\r\n'
+    );
   }
 
   function response_validator(server_response, client_got_eof, timed_out) {
-    const expected_response = 'HTTP/1.1 200 OK\r\n' +
-                              'Content-Type: text/plain\r\n' +
-                              'Connection: close\r\n' +
-                              '\r\n' +
-                              'Hello, world!';
+    const expected_response =
+      'HTTP/1.1 200 OK\r\n' +
+      'Content-Type: text/plain\r\n' +
+      'Connection: close\r\n' +
+      '\r\n' +
+      'Hello, world!';
 
     assert.strictEqual(server_response, expected_response);
     assert.strictEqual(client_got_eof, true);
@@ -127,33 +135,38 @@ function test(handler, request_generator, response_validator) {
     assert.strictEqual(req.httpVersionMinor, 1);
     res.sendDate = false;
     res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write('Hello, '); res._send('');
-    res.write('world!'); res._send('');
+    res.write('Hello, ');
+    res._send('');
+    res.write('world!');
+    res._send('');
     res.end();
   }
 
   function request_generator() {
-    return 'GET / HTTP/1.1\r\n' +
-        'User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 ' +
-        'OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n' +
-        'Connection: close\r\n' +
-        'Host: 127.0.0.1:1337\r\n' +
-        'Accept: */*\r\n' +
-        '\r\n';
+    return (
+      'GET / HTTP/1.1\r\n' +
+      'User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 ' +
+      'OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n' +
+      'Connection: close\r\n' +
+      'Host: 127.0.0.1:1337\r\n' +
+      'Accept: */*\r\n' +
+      '\r\n'
+    );
   }
 
   function response_validator(server_response, client_got_eof, timed_out) {
-    const expected_response = 'HTTP/1.1 200 OK\r\n' +
-                              'Content-Type: text/plain\r\n' +
-                              'Connection: close\r\n' +
-                              'Transfer-Encoding: chunked\r\n' +
-                              '\r\n' +
-                              '7\r\n' +
-                              'Hello, \r\n' +
-                              '6\r\n' +
-                              'world!\r\n' +
-                              '0\r\n' +
-                              '\r\n';
+    const expected_response =
+      'HTTP/1.1 200 OK\r\n' +
+      'Content-Type: text/plain\r\n' +
+      'Connection: close\r\n' +
+      'Transfer-Encoding: chunked\r\n' +
+      '\r\n' +
+      '7\r\n' +
+      'Hello, \r\n' +
+      '6\r\n' +
+      'world!\r\n' +
+      '0\r\n' +
+      '\r\n';
 
     assert.strictEqual(server_response, expected_response);
     assert.strictEqual(client_got_eof, true);
diff --git a/test/parallel/test-http-abort-before-end.js b/test/parallel/test-http-abort-before-end.js
index 5577f256ca2ec9..6832fb11acbf20 100644
--- a/test/parallel/test-http-abort-before-end.js
+++ b/test/parallel/test-http-abort-before-end.js
@@ -25,19 +25,25 @@ const http = require('http');
 
 const server = http.createServer(common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const req = http.request({
-    method: 'GET',
-    host: '127.0.0.1',
-    port: server.address().port
-  });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.request({
+      method: 'GET',
+      host: '127.0.0.1',
+      port: server.address().port
+    });
 
-  req.on('abort', common.mustCall(() => {
-    server.close();
-  }));
+    req.on(
+      'abort',
+      common.mustCall(() => {
+        server.close();
+      })
+    );
 
-  req.on('error', common.mustNotCall());
+    req.on('error', common.mustNotCall());
 
-  req.abort();
-  req.end();
-}));
+    req.abort();
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http-abort-client.js b/test/parallel/test-http-abort-client.js
index eda08ced97c55c..da97c0e80eab28 100644
--- a/test/parallel/test-http-abort-client.js
+++ b/test/parallel/test-http-abort-client.js
@@ -30,18 +30,24 @@ const server = http.Server((req, res) => {
   res.write('Part of my res.');
 });
 
-server.listen(0, common.mustCall(() => {
-  http.get({
-    port: server.address().port,
-    headers: { connection: 'keep-alive' }
-  }, common.mustCall((res) => {
-    server.close();
-    serverRes.destroy();
+server.listen(
+  0,
+  common.mustCall(() => {
+    http.get(
+      {
+        port: server.address().port,
+        headers: { connection: 'keep-alive' }
+      },
+      common.mustCall((res) => {
+        server.close();
+        serverRes.destroy();
 
-    res.resume();
-    res.on('end', common.mustCall());
-    res.on('aborted', common.mustCall());
-    res.on('close', common.mustCall());
-    res.socket.on('close', common.mustCall());
-  }));
-}));
+        res.resume();
+        res.on('end', common.mustCall());
+        res.on('aborted', common.mustCall());
+        res.on('close', common.mustCall());
+        res.socket.on('close', common.mustCall());
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-abort-queued.js b/test/parallel/test-http-abort-queued.js
index 224d0b606ea744..55e37a672ca1e8 100644
--- a/test/parallel/test-http-abort-queued.js
+++ b/test/parallel/test-http-abort-queued.js
@@ -34,12 +34,13 @@ const server = http.createServer((req, res) => {
   res.writeHead(200);
   res.write('foo');
 
-  complete = complete || function() {
-    res.end();
-  };
+  complete =
+    complete ||
+    function() {
+      res.end();
+    };
 });
 
-
 server.listen(0, () => {
   const agent = new http.Agent({ maxSockets: 1 });
   assert.strictEqual(Object.keys(agent.sockets).length, 0);
@@ -82,14 +83,20 @@ server.listen(0, () => {
 
     res1.on('data', (chunk) => complete());
 
-    res1.on('end', common.mustCall(() => {
-      setTimeout(common.mustCall(() => {
-        assert.strictEqual(Object.keys(agent.sockets).length, 0);
-        assert.strictEqual(Object.keys(agent.requests).length, 0);
-
-        server.close();
-      }), 100);
-    }));
+    res1.on(
+      'end',
+      common.mustCall(() => {
+        setTimeout(
+          common.mustCall(() => {
+            assert.strictEqual(Object.keys(agent.sockets).length, 0);
+            assert.strictEqual(Object.keys(agent.requests).length, 0);
+
+            server.close();
+          }),
+          100
+        );
+      })
+    );
   });
 
   req1.end();
diff --git a/test/parallel/test-http-abort-stream-end.js b/test/parallel/test-http-abort-stream-end.js
index 04c4062faa2ea9..40f3862918382a 100644
--- a/test/parallel/test-http-abort-stream-end.js
+++ b/test/parallel/test-http-abort-stream-end.js
@@ -28,15 +28,17 @@ const http = require('http');
 const maxSize = 1024;
 let size = 0;
 
-const server = http.createServer(common.mustCall((req, res) => {
-  server.close();
-
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  for (let i = 0; i < maxSize; i++) {
-    res.write(`x${i}`);
-  }
-  res.end();
-}));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    server.close();
+
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    for (let i = 0; i < maxSize; i++) {
+      res.write(`x${i}`);
+    }
+    res.end();
+  })
+);
 
 server.listen(0, () => {
   const res = common.mustCall((res) => {
diff --git a/test/parallel/test-http-aborted.js b/test/parallel/test-http-aborted.js
index c3d7e4641f4501..91ad5c6c28bce5 100644
--- a/test/parallel/test-http-aborted.js
+++ b/test/parallel/test-http-aborted.js
@@ -4,23 +4,37 @@ const common = require('../common');
 const http = require('http');
 const assert = require('assert');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  req.on('aborted', common.mustCall(function() {
-    assert.strictEqual(this.aborted, true);
-    server.close();
-  }));
-  assert.strictEqual(req.aborted, false);
-  res.write('hello');
-}));
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    req.on(
+      'aborted',
+      common.mustCall(function() {
+        assert.strictEqual(this.aborted, true);
+        server.close();
+      })
+    );
+    assert.strictEqual(req.aborted, false);
+    res.write('hello');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const req = http.get({
-    port: server.address().port,
-    headers: { connection: 'keep-alive' }
-  }, common.mustCall((res) => {
-    res.on('aborted', common.mustCall(() => {
-      assert.strictEqual(res.aborted, true);
-    }));
-    req.abort();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.get(
+      {
+        port: server.address().port,
+        headers: { connection: 'keep-alive' }
+      },
+      common.mustCall((res) => {
+        res.on(
+          'aborted',
+          common.mustCall(() => {
+            assert.strictEqual(res.aborted, true);
+          })
+        );
+        req.abort();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-addrequest-localaddress.js b/test/parallel/test-http-addrequest-localaddress.js
index fce53c88af3690..3eb84c6896d969 100644
--- a/test/parallel/test-http-addrequest-localaddress.js
+++ b/test/parallel/test-http-addrequest-localaddress.js
@@ -20,9 +20,7 @@ agent.maxSockets = 0;
 // port 8080 is hardcoded since this does not create a network connection
 agent.addRequest(req, 'localhost', 8080, '127.0.0.1');
 assert.strictEqual(Object.keys(agent.requests).length, 1);
-assert.strictEqual(
-  Object.keys(agent.requests)[0],
-  'localhost:8080:127.0.0.1');
+assert.strictEqual(Object.keys(agent.requests)[0], 'localhost:8080:127.0.0.1');
 
 // path is *not* used when naming requests / sockets
 // port 8080 is hardcoded since this does not create a network connection
@@ -33,6 +31,4 @@ agent.addRequest(req, {
   path: '/foo'
 });
 assert.strictEqual(Object.keys(agent.requests).length, 1);
-assert.strictEqual(
-  Object.keys(agent.requests)[0],
-  'localhost:8080:127.0.0.1');
+assert.strictEqual(Object.keys(agent.requests)[0], 'localhost:8080:127.0.0.1');
diff --git a/test/parallel/test-http-after-connect.js b/test/parallel/test-http-after-connect.js
index d209c82083e639..470dd783680567 100644
--- a/test/parallel/test-http-after-connect.js
+++ b/test/parallel/test-http-after-connect.js
@@ -25,49 +25,69 @@ const assert = require('assert');
 const http = require('http');
 const Countdown = require('../common/countdown');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  req.resume();
-  res.writeHead(200);
-  res.write('');
-  setTimeout(() => res.end(req.url), 50);
-}, 2));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    req.resume();
+    res.writeHead(200);
+    res.write('');
+    setTimeout(() => res.end(req.url), 50);
+  }, 2)
+);
 
 const countdown = new Countdown(2, () => server.close());
 
-server.on('connect', common.mustCall((req, socket) => {
-  socket.write('HTTP/1.1 200 Connection established\r\n\r\n');
-  socket.resume();
-  socket.on('end', () => socket.end());
-}));
-
-server.listen(0, common.mustCall(() => {
-  const req = http.request({
-    port: server.address().port,
-    method: 'CONNECT',
-    path: 'google.com:80'
-  });
-  req.on('connect', common.mustCall((res, socket) => {
-    socket.end();
-    socket.on('end', common.mustCall(() => {
-      doRequest(0);
-      doRequest(1);
-    }));
+server.on(
+  'connect',
+  common.mustCall((req, socket) => {
+    socket.write('HTTP/1.1 200 Connection established\r\n\r\n');
     socket.resume();
-  }));
-  req.end();
-}));
+    socket.on('end', () => socket.end());
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.request({
+      port: server.address().port,
+      method: 'CONNECT',
+      path: 'google.com:80'
+    });
+    req.on(
+      'connect',
+      common.mustCall((res, socket) => {
+        socket.end();
+        socket.on(
+          'end',
+          common.mustCall(() => {
+            doRequest(0);
+            doRequest(1);
+          })
+        );
+        socket.resume();
+      })
+    );
+    req.end();
+  })
+);
 
 function doRequest(i) {
-  http.get({
-    port: server.address().port,
-    path: `/request${i}`
-  }, common.mustCall((res) => {
-    let data = '';
-    res.setEncoding('utf8');
-    res.on('data', (chunk) => data += chunk);
-    res.on('end', common.mustCall(() => {
-      assert.strictEqual(data, `/request${i}`);
-      countdown.dec();
-    }));
-  }));
+  http.get(
+    {
+      port: server.address().port,
+      path: `/request${i}`
+    },
+    common.mustCall((res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => (data += chunk));
+      res.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(data, `/request${i}`);
+          countdown.dec();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http-agent-destroyed-socket.js b/test/parallel/test-http-agent-destroyed-socket.js
index af63a676f62fd9..2c94995e9b399d 100644
--- a/test/parallel/test-http-agent-destroyed-socket.js
+++ b/test/parallel/test-http-agent-destroyed-socket.js
@@ -25,50 +25,72 @@ const assert = require('assert');
 const http = require('http');
 const Countdown = require('../common/countdown');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.end('Hello World\n');
-}, 2)).listen(0, common.mustCall(() => {
-  const agent = new http.Agent({ maxSockets: 1 });
+const server = http
+  .createServer(
+    common.mustCall((req, res) => {
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('Hello World\n');
+    }, 2)
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const agent = new http.Agent({ maxSockets: 1 });
 
-  agent.on('free', common.mustCall(3));
+      agent.on('free', common.mustCall(3));
 
-  const requestOptions = {
-    agent: agent,
-    host: 'localhost',
-    port: server.address().port,
-    path: '/'
-  };
+      const requestOptions = {
+        agent: agent,
+        host: 'localhost',
+        port: server.address().port,
+        path: '/'
+      };
 
-  const request1 = http.get(requestOptions, common.mustCall((response) => {
-    // assert request2 is queued in the agent
-    const key = agent.getName(requestOptions);
-    assert.strictEqual(agent.requests[key].length, 1);
-    response.resume();
-    response.on('end', common.mustCall(() => {
-      request1.socket.destroy();
+      const request1 = http.get(
+        requestOptions,
+        common.mustCall((response) => {
+          // assert request2 is queued in the agent
+          const key = agent.getName(requestOptions);
+          assert.strictEqual(agent.requests[key].length, 1);
+          response.resume();
+          response.on(
+            'end',
+            common.mustCall(() => {
+              request1.socket.destroy();
 
-      response.socket.once('close', common.mustCall(() => {
-        // assert request2 was removed from the queue
-        assert(!agent.requests[key]);
-        process.nextTick(() => {
-          // assert that the same socket was not assigned to request2,
-          // since it was destroyed.
-          assert.notStrictEqual(request1.socket, request2.socket);
-          assert(!request2.socket.destroyed, 'the socket is destroyed');
-        });
-      }));
-    }));
-  }));
+              response.socket.once(
+                'close',
+                common.mustCall(() => {
+                  // assert request2 was removed from the queue
+                  assert(!agent.requests[key]);
+                  process.nextTick(() => {
+                    // assert that the same socket was not assigned to request2,
+                    // since it was destroyed.
+                    assert.notStrictEqual(request1.socket, request2.socket);
+                    assert(
+                      !request2.socket.destroyed,
+                      'the socket is destroyed'
+                    );
+                  });
+                })
+              );
+            })
+          );
+        })
+      );
 
-  const request2 = http.get(requestOptions, common.mustCall((response) => {
-    assert(!request2.socket.destroyed);
-    assert(request1.socket.destroyed);
-    // assert not reusing the same socket, since it was destroyed.
-    assert.notStrictEqual(request1.socket, request2.socket);
-    const countdown = new Countdown(2, () => server.close());
-    request2.socket.on('close', common.mustCall(() => countdown.dec()));
-    response.on('end', common.mustCall(() => countdown.dec()));
-    response.resume();
-  }));
-}));
+      const request2 = http.get(
+        requestOptions,
+        common.mustCall((response) => {
+          assert(!request2.socket.destroyed);
+          assert(request1.socket.destroyed);
+          // assert not reusing the same socket, since it was destroyed.
+          assert.notStrictEqual(request1.socket, request2.socket);
+          const countdown = new Countdown(2, () => server.close());
+          request2.socket.on('close', common.mustCall(() => countdown.dec()));
+          response.on('end', common.mustCall(() => countdown.dec()));
+          response.resume();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-http-agent-error-on-idle.js b/test/parallel/test-http-agent-error-on-idle.js
index 8edfa24811417a..151d58fbe10d4b 100644
--- a/test/parallel/test-http-agent-error-on-idle.js
+++ b/test/parallel/test-http-agent-error-on-idle.js
@@ -5,9 +5,11 @@ const assert = require('assert');
 const http = require('http');
 const Agent = http.Agent;
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end('hello world');
-}, 2));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.end('hello world');
+  }, 2)
+);
 
 server.listen(0, () => {
   const agent = new Agent({ keepAlive: true });
@@ -21,23 +23,31 @@ server.listen(0, () => {
 
   const socketKey = agent.getName(requestParams);
 
-  http.get(requestParams, common.mustCall((res) => {
-    assert.strictEqual(res.statusCode, 200);
-    res.resume();
-    res.on('end', common.mustCall(() => {
-      process.nextTick(common.mustCall(() => {
-        const freeSockets = agent.freeSockets[socketKey];
-        // Expect a free socket on socketKey
-        assert.strictEqual(freeSockets.length, 1);
-
-        // Generate a random error on the free socket
-        const freeSocket = freeSockets[0];
-        freeSocket.emit('error', new Error('ECONNRESET: test'));
-
-        http.get(requestParams, done);
-      }));
-    }));
-  }));
+  http.get(
+    requestParams,
+    common.mustCall((res) => {
+      assert.strictEqual(res.statusCode, 200);
+      res.resume();
+      res.on(
+        'end',
+        common.mustCall(() => {
+          process.nextTick(
+            common.mustCall(() => {
+              const freeSockets = agent.freeSockets[socketKey];
+              // Expect a free socket on socketKey
+              assert.strictEqual(freeSockets.length, 1);
+
+              // Generate a random error on the free socket
+              const freeSocket = freeSockets[0];
+              freeSocket.emit('error', new Error('ECONNRESET: test'));
+
+              http.get(requestParams, done);
+            })
+          );
+        })
+      );
+    })
+  );
 
   function done() {
     // Expect the freeSockets pool to be empty
diff --git a/test/parallel/test-http-agent-getname.js b/test/parallel/test-http-agent-getname.js
index 31dc255ba558db..959e80d5db52a0 100644
--- a/test/parallel/test-http-agent-getname.js
+++ b/test/parallel/test-http-agent-getname.js
@@ -19,10 +19,7 @@ assert.strictEqual(
 );
 
 // empty
-assert.strictEqual(
-  agent.getName({}),
-  'localhost::'
-);
+assert.strictEqual(agent.getName({}), 'localhost::');
 
 // pass all arguments
 assert.strictEqual(
diff --git a/test/parallel/test-http-agent-keepalive.js b/test/parallel/test-http-agent-keepalive.js
index 917c4ee8101f9e..aa4c0ce0753ebe 100644
--- a/test/parallel/test-http-agent-keepalive.js
+++ b/test/parallel/test-http-agent-keepalive.js
@@ -34,25 +34,30 @@ const agent = new Agent({
   maxFreeSockets: 5
 });
 
-const server = http.createServer(common.mustCall((req, res) => {
-  if (req.url === '/error') {
-    res.destroy();
-    return;
-  } else if (req.url === '/remote_close') {
-    // cache the socket, close it after a short delay
-    const socket = res.connection;
-    setImmediate(common.mustCall(() => socket.end()));
-  }
-  res.end('hello world');
-}, 4));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    if (req.url === '/error') {
+      res.destroy();
+      return;
+    } else if (req.url === '/remote_close') {
+      // cache the socket, close it after a short delay
+      const socket = res.connection;
+      setImmediate(common.mustCall(() => socket.end()));
+    }
+    res.end('hello world');
+  }, 4)
+);
 
 function get(path, callback) {
-  return http.get({
-    host: 'localhost',
-    port: server.address().port,
-    agent: agent,
-    path: path
-  }, callback);
+  return http.get(
+    {
+      host: 'localhost',
+      port: server.address().port,
+      agent: agent,
+      path: path
+    },
+    callback
+  );
 }
 
 function checkDataAndSockets(body) {
@@ -63,74 +68,110 @@ function checkDataAndSockets(body) {
 
 function second() {
   // request second, use the same socket
-  get('/second', common.mustCall((res) => {
-    assert.strictEqual(res.statusCode, 200);
-    res.on('data', checkDataAndSockets);
-    res.on('end', common.mustCall(() => {
-      assert.strictEqual(agent.sockets[name].length, 1);
-      assert.strictEqual(agent.freeSockets[name], undefined);
-      process.nextTick(common.mustCall(() => {
-        assert.strictEqual(agent.sockets[name], undefined);
-        assert.strictEqual(agent.freeSockets[name].length, 1);
-        remoteClose();
-      }));
-    }));
-  }));
+  get(
+    '/second',
+    common.mustCall((res) => {
+      assert.strictEqual(res.statusCode, 200);
+      res.on('data', checkDataAndSockets);
+      res.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(agent.sockets[name].length, 1);
+          assert.strictEqual(agent.freeSockets[name], undefined);
+          process.nextTick(
+            common.mustCall(() => {
+              assert.strictEqual(agent.sockets[name], undefined);
+              assert.strictEqual(agent.freeSockets[name].length, 1);
+              remoteClose();
+            })
+          );
+        })
+      );
+    })
+  );
 }
 
 function remoteClose() {
   // mock remote server close the socket
-  get('/remote_close', common.mustCall((res) => {
-    assert.deepStrictEqual(res.statusCode, 200);
-    res.on('data', checkDataAndSockets);
-    res.on('end', common.mustCall(() => {
-      assert.strictEqual(agent.sockets[name].length, 1);
-      assert.strictEqual(agent.freeSockets[name], undefined);
-      process.nextTick(common.mustCall(() => {
-        assert.strictEqual(agent.sockets[name], undefined);
-        assert.strictEqual(agent.freeSockets[name].length, 1);
-        // waiting remote server close the socket
-        setTimeout(common.mustCall(() => {
-          assert.strictEqual(agent.sockets[name], undefined);
+  get(
+    '/remote_close',
+    common.mustCall((res) => {
+      assert.deepStrictEqual(res.statusCode, 200);
+      res.on('data', checkDataAndSockets);
+      res.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(agent.sockets[name].length, 1);
           assert.strictEqual(agent.freeSockets[name], undefined);
-          remoteError();
-        }), common.platformTimeout(200));
-      }));
-    }));
-  }));
+          process.nextTick(
+            common.mustCall(() => {
+              assert.strictEqual(agent.sockets[name], undefined);
+              assert.strictEqual(agent.freeSockets[name].length, 1);
+              // waiting remote server close the socket
+              setTimeout(
+                common.mustCall(() => {
+                  assert.strictEqual(agent.sockets[name], undefined);
+                  assert.strictEqual(agent.freeSockets[name], undefined);
+                  remoteError();
+                }),
+                common.platformTimeout(200)
+              );
+            })
+          );
+        })
+      );
+    })
+  );
 }
 
 function remoteError() {
   // remote server will destroy the socket
   const req = get('/error', common.mustNotCall());
-  req.on('error', common.mustCall((err) => {
-    assert(err);
-    assert.strictEqual(err.message, 'socket hang up');
-    assert.strictEqual(agent.sockets[name].length, 1);
-    assert.strictEqual(agent.freeSockets[name], undefined);
-    // Wait socket 'close' event emit
-    setTimeout(common.mustCall(() => {
-      assert.strictEqual(agent.sockets[name], undefined);
+  req.on(
+    'error',
+    common.mustCall((err) => {
+      assert(err);
+      assert.strictEqual(err.message, 'socket hang up');
+      assert.strictEqual(agent.sockets[name].length, 1);
       assert.strictEqual(agent.freeSockets[name], undefined);
-      server.close();
-    }), common.platformTimeout(1));
-  }));
+      // Wait socket 'close' event emit
+      setTimeout(
+        common.mustCall(() => {
+          assert.strictEqual(agent.sockets[name], undefined);
+          assert.strictEqual(agent.freeSockets[name], undefined);
+          server.close();
+        }),
+        common.platformTimeout(1)
+      );
+    })
+  );
 }
 
-server.listen(0, common.mustCall(() => {
-  name = `localhost:${server.address().port}:`;
-  // request first, and keep alive
-  get('/first', common.mustCall((res) => {
-    assert.strictEqual(res.statusCode, 200);
-    res.on('data', checkDataAndSockets);
-    res.on('end', common.mustCall(() => {
-      assert.strictEqual(agent.sockets[name].length, 1);
-      assert.strictEqual(agent.freeSockets[name], undefined);
-      process.nextTick(common.mustCall(() => {
-        assert.strictEqual(agent.sockets[name], undefined);
-        assert.strictEqual(agent.freeSockets[name].length, 1);
-        second();
-      }));
-    }));
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    name = `localhost:${server.address().port}:`;
+    // request first, and keep alive
+    get(
+      '/first',
+      common.mustCall((res) => {
+        assert.strictEqual(res.statusCode, 200);
+        res.on('data', checkDataAndSockets);
+        res.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(agent.sockets[name].length, 1);
+            assert.strictEqual(agent.freeSockets[name], undefined);
+            process.nextTick(
+              common.mustCall(() => {
+                assert.strictEqual(agent.sockets[name], undefined);
+                assert.strictEqual(agent.freeSockets[name].length, 1);
+                second();
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-agent-maxsockets.js b/test/parallel/test-http-agent-maxsockets.js
index 267f820e0435eb..d2c6e0e28dc53b 100644
--- a/test/parallel/test-http-agent-maxsockets.js
+++ b/test/parallel/test-http-agent-maxsockets.js
@@ -11,25 +11,33 @@ const agent = new http.Agent({
   maxFreeSockets: 2
 });
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end('hello world');
-}, 2));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.end('hello world');
+  }, 2)
+);
 
 server.keepAliveTimeout = 0;
 
 function get(path, callback) {
-  return http.get({
-    host: 'localhost',
-    port: server.address().port,
-    agent: agent,
-    path: path
-  }, callback);
+  return http.get(
+    {
+      host: 'localhost',
+      port: server.address().port,
+      agent: agent,
+      path: path
+    },
+    callback
+  );
 }
 
 const countdown = new Countdown(2, () => {
   const freepool = agent.freeSockets[Object.keys(agent.freeSockets)[0]];
-  assert.strictEqual(freepool.length, 2,
-                     `expect keep 2 free sockets, but got ${freepool.length}`);
+  assert.strictEqual(
+    freepool.length,
+    2,
+    `expect keep 2 free sockets, but got ${freepool.length}`
+  );
   agent.destroy();
   server.close();
 });
@@ -44,7 +52,10 @@ function onGet(res) {
   res.on('end', common.mustCall(dec));
 }
 
-server.listen(0, common.mustCall(() => {
-  get('/1', common.mustCall(onGet));
-  get('/2', common.mustCall(onGet));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    get('/1', common.mustCall(onGet));
+    get('/2', common.mustCall(onGet));
+  })
+);
diff --git a/test/parallel/test-http-agent-no-protocol.js b/test/parallel/test-http-agent-no-protocol.js
index b5a144abc93d9e..c32123601a7c39 100644
--- a/test/parallel/test-http-agent-no-protocol.js
+++ b/test/parallel/test-http-agent-no-protocol.js
@@ -24,18 +24,29 @@ const common = require('../common');
 const http = require('http');
 const url = require('url');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end();
-})).listen(0, '127.0.0.1', common.mustCall(() => {
-  const opts = url.parse(`http://127.0.0.1:${server.address().port}/`);
+const server = http
+  .createServer(
+    common.mustCall((req, res) => {
+      res.end();
+    })
+  )
+  .listen(
+    0,
+    '127.0.0.1',
+    common.mustCall(() => {
+      const opts = url.parse(`http://127.0.0.1:${server.address().port}/`);
 
-  // remove the `protocol` field… the `http` module should fall back
-  // to "http:", as defined by the global, default `http.Agent` instance.
-  opts.agent = new http.Agent();
-  opts.agent.protocol = null;
+      // remove the `protocol` field… the `http` module should fall back
+      // to "http:", as defined by the global, default `http.Agent` instance.
+      opts.agent = new http.Agent();
+      opts.agent.protocol = null;
 
-  http.get(opts, common.mustCall((res) => {
-    res.resume();
-    server.close();
-  }));
-}));
+      http.get(
+        opts,
+        common.mustCall((res) => {
+          res.resume();
+          server.close();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-http-agent-null.js b/test/parallel/test-http-agent-null.js
index 0f87d098134b50..1caf37fc48598f 100644
--- a/test/parallel/test-http-agent-null.js
+++ b/test/parallel/test-http-agent-null.js
@@ -23,15 +23,25 @@
 const common = require('../common');
 const http = require('http');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end();
-})).listen(0, common.mustCall(() => {
-  const options = {
-    agent: null,
-    port: server.address().port
-  };
-  http.get(options, common.mustCall((res) => {
-    res.resume();
-    server.close();
-  }));
-}));
+const server = http
+  .createServer(
+    common.mustCall((req, res) => {
+      res.end();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const options = {
+        agent: null,
+        port: server.address().port
+      };
+      http.get(
+        options,
+        common.mustCall((res) => {
+          res.resume();
+          server.close();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-http-agent-remove.js b/test/parallel/test-http-agent-remove.js
index 24fc7fcb8282fe..2e7fb4fa65ddc0 100644
--- a/test/parallel/test-http-agent-remove.js
+++ b/test/parallel/test-http-agent-remove.js
@@ -4,18 +4,26 @@ const { mustCall } = require('../common');
 const http = require('http');
 const { strictEqual } = require('assert');
 
-const server = http.createServer(mustCall((req, res) => {
-  res.flushHeaders();
-}));
+const server = http.createServer(
+  mustCall((req, res) => {
+    res.flushHeaders();
+  })
+);
 
-server.listen(0, mustCall(() => {
-  const req = http.get({
-    port: server.address().port
-  }, mustCall(() => {
-    const { socket } = req;
-    socket.emit('agentRemove');
-    strictEqual(socket._httpMessage, req);
-    socket.destroy();
-    server.close();
-  }));
-}));
+server.listen(
+  0,
+  mustCall(() => {
+    const req = http.get(
+      {
+        port: server.address().port
+      },
+      mustCall(() => {
+        const { socket } = req;
+        socket.emit('agentRemove');
+        strictEqual(socket._httpMessage, req);
+        socket.destroy();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-agent-uninitialized-with-handle.js b/test/parallel/test-http-agent-uninitialized-with-handle.js
index 77f01771734c87..ef2c5cf68bfbd5 100644
--- a/test/parallel/test-http-agent-uninitialized-with-handle.js
+++ b/test/parallel/test-http-agent-uninitialized-with-handle.js
@@ -5,27 +5,39 @@ const http = require('http');
 const net = require('net');
 
 const agent = new http.Agent({
-  keepAlive: true,
+  keepAlive: true
 });
 const socket = new net.Socket();
 // If _handle exists then internals assume a couple methods exist.
 socket._handle = {
-  ref() { },
-  readStart() { },
+  ref() {},
+  readStart() {}
 };
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end();
-})).listen(0, common.mustCall(() => {
-  const req = new http.ClientRequest(`http://localhost:${server.address().port}/`);
+const server = http
+  .createServer(
+    common.mustCall((req, res) => {
+      res.end();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const req = new http.ClientRequest(
+        `http://localhost:${server.address().port}/`
+      );
 
-  // Manually add the socket without a _handle.
-  agent.freeSockets[agent.getName(req)] = [socket];
-  // Now force the agent to use the socket and check that _handle exists before
-  // calling asyncReset().
-  agent.addRequest(req, {});
-  req.on('response', common.mustCall(() => {
-    server.close();
-  }));
-  req.end();
-}));
+      // Manually add the socket without a _handle.
+      agent.freeSockets[agent.getName(req)] = [socket];
+      // Now force the agent to use the socket and check that _handle exists before
+      // calling asyncReset().
+      agent.addRequest(req, {});
+      req.on(
+        'response',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+      req.end();
+    })
+  );
diff --git a/test/parallel/test-http-agent-uninitialized.js b/test/parallel/test-http-agent-uninitialized.js
index dbb38e3b0f9847..21d3025db2ee8b 100644
--- a/test/parallel/test-http-agent-uninitialized.js
+++ b/test/parallel/test-http-agent-uninitialized.js
@@ -5,22 +5,34 @@ const http = require('http');
 const net = require('net');
 
 const agent = new http.Agent({
-  keepAlive: true,
+  keepAlive: true
 });
 const socket = new net.Socket();
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end();
-})).listen(0, common.mustCall(() => {
-  const req = new http.ClientRequest(`http://localhost:${server.address().port}/`);
+const server = http
+  .createServer(
+    common.mustCall((req, res) => {
+      res.end();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const req = new http.ClientRequest(
+        `http://localhost:${server.address().port}/`
+      );
 
-  // Manually add the socket without a _handle.
-  agent.freeSockets[agent.getName(req)] = [socket];
-  // Now force the agent to use the socket and check that _handle exists before
-  // calling asyncReset().
-  agent.addRequest(req, {});
-  req.on('response', common.mustCall(() => {
-    server.close();
-  }));
-  req.end();
-}));
+      // Manually add the socket without a _handle.
+      agent.freeSockets[agent.getName(req)] = [socket];
+      // Now force the agent to use the socket and check that _handle exists before
+      // calling asyncReset().
+      agent.addRequest(req, {});
+      req.on(
+        'response',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+      req.end();
+    })
+  );
diff --git a/test/parallel/test-http-agent.js b/test/parallel/test-http-agent.js
index 4ff781ecb95f91..ff15c7fafcb84a 100644
--- a/test/parallel/test-http-agent.js
+++ b/test/parallel/test-http-agent.js
@@ -27,10 +27,12 @@ const http = require('http');
 
 const N = 4;
 const M = 4;
-const server = http.Server(common.mustCall(function(req, res) {
-  res.writeHead(200);
-  res.end('hello world\n');
-}, (N * M))); // N * M = good requests (the errors will not be counted)
+const server = http.Server(
+  common.mustCall(function(req, res) {
+    res.writeHead(200);
+    res.end('hello world\n');
+  }, N * M)
+); // N * M = good requests (the errors will not be counted)
 
 function makeRequests(outCount, inCount, shouldFail) {
   const countdown = new Countdown(
@@ -44,8 +46,7 @@ function makeRequests(outCount, inCount, shouldFail) {
         resolve();
       }
 
-      if (!shouldFail)
-        res.resume();
+      if (!shouldFail) res.resume();
     }, outCount * inCount);
   });
 
@@ -55,10 +56,8 @@ function makeRequests(outCount, inCount, shouldFail) {
       setTimeout(() => {
         for (let j = 0; j < inCount; j++) {
           const req = http.get({ port: port, path: '/' }, onRequest);
-          if (shouldFail)
-            req.on('error', common.mustCall(onRequest));
-          else
-            req.on('error', (e) => assert.fail(e));
+          if (shouldFail) req.on('error', common.mustCall(onRequest));
+          else req.on('error', (e) => assert.fail(e));
         }
       }, i);
     }
@@ -78,11 +77,8 @@ const test2 = () => {
   return makeRequests(N, M, true);
 };
 
-test1
-  .then(test2)
-  .catch((e) => {
-    // This is currently the way to fail a test with a Promise.
-    console.error(e);
-    process.exit(1);
-  }
-  );
+test1.then(test2).catch((e) => {
+  // This is currently the way to fail a test with a Promise.
+  console.error(e);
+  process.exit(1);
+});
diff --git a/test/parallel/test-http-allow-req-after-204-res.js b/test/parallel/test-http-allow-req-after-204-res.js
index 84dd876985e2e6..e2e806de3f1860 100644
--- a/test/parallel/test-http-allow-req-after-204-res.js
+++ b/test/parallel/test-http-allow-req-after-204-res.js
@@ -30,31 +30,38 @@ const codes = [204, 200];
 
 const countdown = new Countdown(codes.length, () => server.close());
 
-const server = http.createServer(common.mustCall((req, res) => {
-  const code = codes.shift();
-  assert.strictEqual(typeof code, 'number');
-  assert.ok(code > 0);
-  res.writeHead(code, {});
-  res.end();
-}, codes.length));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    const code = codes.shift();
+    assert.strictEqual(typeof code, 'number');
+    assert.ok(code > 0);
+    res.writeHead(code, {});
+    res.end();
+  }, codes.length)
+);
 
 function nextRequest() {
-
-  const request = http.get({
-    port: server.address().port,
-    path: '/'
-  }, common.mustCall((response) => {
-    response.on('end', common.mustCall(() => {
-      if (countdown.dec()) {
-        // throws error:
-        nextRequest();
-        // TODO: investigate why this does not work fine even though it should.
-        // works just fine:
-        // process.nextTick(nextRequest);
-      }
-    }));
-    response.resume();
-  }));
+  const request = http.get(
+    {
+      port: server.address().port,
+      path: '/'
+    },
+    common.mustCall((response) => {
+      response.on(
+        'end',
+        common.mustCall(() => {
+          if (countdown.dec()) {
+            // throws error:
+            nextRequest();
+            // TODO: investigate why this does not work fine even though it should.
+            // works just fine:
+            // process.nextTick(nextRequest);
+          }
+        })
+      );
+      response.resume();
+    })
+  );
   request.end();
 }
 
diff --git a/test/parallel/test-http-automatic-headers.js b/test/parallel/test-http-automatic-headers.js
index 5e99f1ee39dd6b..03fdbaafdcd902 100644
--- a/test/parallel/test-http-automatic-headers.js
+++ b/test/parallel/test-http-automatic-headers.js
@@ -3,29 +3,40 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.setHeader('X-Date', 'foo');
-  res.setHeader('X-Connection', 'bar');
-  res.setHeader('X-Content-Length', 'baz');
-  res.end();
-}));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.setHeader('X-Date', 'foo');
+    res.setHeader('X-Connection', 'bar');
+    res.setHeader('X-Content-Length', 'baz');
+    res.end();
+  })
+);
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-  const agent = new http.Agent({ port: server.address().port, maxSockets: 1 });
-  http.get({
-    port: server.address().port,
-    path: '/hello',
-    agent: agent
-  }, common.mustCall((res) => {
-    assert.strictEqual(res.statusCode, 200);
-    assert.strictEqual(res.headers['x-date'], 'foo');
-    assert.strictEqual(res.headers['x-connection'], 'bar');
-    assert.strictEqual(res.headers['x-content-length'], 'baz');
-    assert(res.headers.date);
-    assert.strictEqual(res.headers.connection, 'keep-alive');
-    assert.strictEqual(res.headers['content-length'], '0');
-    server.close();
-    agent.destroy();
-  }));
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const agent = new http.Agent({
+      port: server.address().port,
+      maxSockets: 1
+    });
+    http.get(
+      {
+        port: server.address().port,
+        path: '/hello',
+        agent: agent
+      },
+      common.mustCall((res) => {
+        assert.strictEqual(res.statusCode, 200);
+        assert.strictEqual(res.headers['x-date'], 'foo');
+        assert.strictEqual(res.headers['x-connection'], 'bar');
+        assert.strictEqual(res.headers['x-content-length'], 'baz');
+        assert(res.headers.date);
+        assert.strictEqual(res.headers.connection, 'keep-alive');
+        assert.strictEqual(res.headers['content-length'], '0');
+        server.close();
+        agent.destroy();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-bind-twice.js b/test/parallel/test-http-bind-twice.js
index 50834cc5cb028b..b8045c6e13ad9f 100644
--- a/test/parallel/test-http-bind-twice.js
+++ b/test/parallel/test-http-bind-twice.js
@@ -25,12 +25,19 @@ const assert = require('assert');
 const http = require('http');
 
 const server1 = http.createServer(common.mustNotCall());
-server1.listen(0, '127.0.0.1', common.mustCall(function() {
-  const server2 = http.createServer(common.mustNotCall());
-  server2.listen(this.address().port, '127.0.0.1', common.mustNotCall());
+server1.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    const server2 = http.createServer(common.mustNotCall());
+    server2.listen(this.address().port, '127.0.0.1', common.mustNotCall());
 
-  server2.on('error', common.mustCall(function(e) {
-    assert.strictEqual(e.code, 'EADDRINUSE');
-    server1.close();
-  }));
-}));
+    server2.on(
+      'error',
+      common.mustCall(function(e) {
+        assert.strictEqual(e.code, 'EADDRINUSE');
+        server1.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-blank-header.js b/test/parallel/test-http-blank-header.js
index 3f2b512fc85567..a5640b40aac313 100644
--- a/test/parallel/test-http-blank-header.js
+++ b/test/parallel/test-http-blank-header.js
@@ -25,35 +25,52 @@ const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  assert.strictEqual(req.method, 'GET');
-  assert.strictEqual(req.url, '/blah');
-  assert.deepStrictEqual({
-    host: 'example.org:443',
-    origin: 'http://example.org',
-    cookie: ''
-  }, req.headers);
-}));
-
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    assert.strictEqual(req.method, 'GET');
+    assert.strictEqual(req.url, '/blah');
+    assert.deepStrictEqual(
+      {
+        host: 'example.org:443',
+        origin: 'http://example.org',
+        cookie: ''
+      },
+      req.headers
+    );
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const c = net.createConnection(server.address().port);
-  let received = '';
+server.listen(
+  0,
+  common.mustCall(() => {
+    const c = net.createConnection(server.address().port);
+    let received = '';
 
-  c.on('connect', common.mustCall(() => {
-    c.write('GET /blah HTTP/1.1\r\n' +
+    c.on(
+      'connect',
+      common.mustCall(() => {
+        c.write(
+          'GET /blah HTTP/1.1\r\n' +
             'Host: example.org:443\r\n' +
             'Cookie:\r\n' +
             'Origin: http://example.org\r\n' +
             '\r\n\r\nhello world'
+        );
+      })
+    );
+    c.on(
+      'data',
+      common.mustCall((data) => {
+        received += data.toString();
+      })
+    );
+    c.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual('HTTP/1.1 400 Bad Request\r\n\r\n', received);
+        c.end();
+      })
     );
-  }));
-  c.on('data', common.mustCall((data) => {
-    received += data.toString();
-  }));
-  c.on('end', common.mustCall(() => {
-    assert.strictEqual('HTTP/1.1 400 Bad Request\r\n\r\n', received);
-    c.end();
-  }));
-  c.on('close', common.mustCall(() => server.close()));
-}));
+    c.on('close', common.mustCall(() => server.close()));
+  })
+);
diff --git a/test/parallel/test-http-buffer-sanity.js b/test/parallel/test-http-buffer-sanity.js
index 05c027fd482582..48bf3b4b441a7c 100644
--- a/test/parallel/test-http-buffer-sanity.js
+++ b/test/parallel/test-http-buffer-sanity.js
@@ -45,27 +45,39 @@ const server = http.Server(function(req, res) {
     }
   });
 
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(measuredSize, bufferSize);
-    res.writeHead(200);
-    res.write('thanks');
-    res.end();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(measuredSize, bufferSize);
+      res.writeHead(200);
+      res.write('thanks');
+      res.end();
+    })
+  );
 });
 
-server.listen(0, common.mustCall(() => {
-  const req = http.request({
-    port: server.address().port,
-    method: 'POST',
-    path: '/',
-    headers: { 'content-length': buffer.length }
-  }, common.mustCall((res) => {
-    res.setEncoding('utf8');
-    let data = '';
-    res.on('data', (chunk) => data += chunk);
-    res.on('end', common.mustCall(() => {
-      assert.strictEqual(data, 'thanks');
-    }));
-  }));
-  req.end(buffer);
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.request(
+      {
+        port: server.address().port,
+        method: 'POST',
+        path: '/',
+        headers: { 'content-length': buffer.length }
+      },
+      common.mustCall((res) => {
+        res.setEncoding('utf8');
+        let data = '';
+        res.on('data', (chunk) => (data += chunk));
+        res.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(data, 'thanks');
+          })
+        );
+      })
+    );
+    req.end(buffer);
+  })
+);
diff --git a/test/parallel/test-http-byteswritten.js b/test/parallel/test-http-byteswritten.js
index 32495613afa66f..d56934550b1fc8 100644
--- a/test/parallel/test-http-byteswritten.js
+++ b/test/parallel/test-http-byteswritten.js
@@ -26,29 +26,34 @@ const http = require('http');
 
 const body = 'hello world\n';
 
-const httpServer = http.createServer(common.mustCall(function(req, res) {
-  httpServer.close();
+const httpServer = http.createServer(
+  common.mustCall(function(req, res) {
+    httpServer.close();
 
-  res.on('finish', common.mustCall(function() {
-    assert.strictEqual(typeof req.connection.bytesWritten, 'number');
-    assert(req.connection.bytesWritten > 0);
-  }));
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.on(
+      'finish',
+      common.mustCall(function() {
+        assert.strictEqual(typeof req.connection.bytesWritten, 'number');
+        assert(req.connection.bytesWritten > 0);
+      })
+    );
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
 
-  // Write 1.5mb to cause some requests to buffer
-  // Also, mix up the encodings a bit.
-  const chunk = '7'.repeat(1024);
-  const bchunk = Buffer.from(chunk);
-  for (let i = 0; i < 1024; i++) {
-    res.write(chunk);
-    res.write(bchunk);
-    res.write(chunk, 'hex');
-  }
-  // Get .bytesWritten while buffer is not empty
-  assert(res.connection.bytesWritten > 0);
+    // Write 1.5mb to cause some requests to buffer
+    // Also, mix up the encodings a bit.
+    const chunk = '7'.repeat(1024);
+    const bchunk = Buffer.from(chunk);
+    for (let i = 0; i < 1024; i++) {
+      res.write(chunk);
+      res.write(bchunk);
+      res.write(chunk, 'hex');
+    }
+    // Get .bytesWritten while buffer is not empty
+    assert(res.connection.bytesWritten > 0);
 
-  res.end(body);
-}));
+    res.end(body);
+  })
+);
 
 httpServer.listen(0, function() {
   http.get({ port: this.address().port });
diff --git a/test/parallel/test-http-catch-uncaughtexception.js b/test/parallel/test-http-catch-uncaughtexception.js
index 1366b6e26ea37f..a925c3d4ad8957 100644
--- a/test/parallel/test-http-catch-uncaughtexception.js
+++ b/test/parallel/test-http-catch-uncaughtexception.js
@@ -10,14 +10,18 @@ const uncaughtCallback = common.mustCall(function(er) {
 
 process.on('uncaughtException', uncaughtCallback);
 
-const server = http.createServer(function(req, res) {
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.end('bye');
-}).listen(0, function() {
-  http.get({ port: this.address().port }, function(res) {
-    res.resume();
-    throw new Error('get did fail');
-  }).on('close', function() {
-    server.close();
+const server = http
+  .createServer(function(req, res) {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end('bye');
+  })
+  .listen(0, function() {
+    http
+      .get({ port: this.address().port }, function(res) {
+        res.resume();
+        throw new Error('get did fail');
+      })
+      .on('close', function() {
+        server.close();
+      });
   });
-});
diff --git a/test/parallel/test-http-chunk-problem.js b/test/parallel/test-http-chunk-problem.js
index 4a2886da3f8e40..eb1b4985c3e8cd 100644
--- a/test/parallel/test-http-chunk-problem.js
+++ b/test/parallel/test-http-chunk-problem.js
@@ -1,8 +1,7 @@
 'use strict';
 // http://groups.google.com/group/nodejs/browse_thread/thread/f66cd3c960406919
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 
@@ -43,24 +42,28 @@ const filename = require('path').join(tmpdir.path, 'big');
 let server;
 
 function executeRequest(cb) {
-  cp.exec([`"${process.execPath}"`,
-           `"${__filename}"`,
-           'request',
-           server.address().port,
-           '|',
-           `"${process.execPath}"`,
-           `"${__filename}"`,
-           'shasum' ].join(' '),
-          (err, stdout, stderr) => {
-            assert.ifError(err);
-            assert.strictEqual(stdout.slice(0, 40),
-                               '8c206a1a87599f532ce68675536f0b1546900d7a');
-            cb();
-          }
+  cp.exec(
+    [
+      `"${process.execPath}"`,
+      `"${__filename}"`,
+      'request',
+      server.address().port,
+      '|',
+      `"${process.execPath}"`,
+      `"${__filename}"`,
+      'shasum'
+    ].join(' '),
+    (err, stdout, stderr) => {
+      assert.ifError(err);
+      assert.strictEqual(
+        stdout.slice(0, 40),
+        '8c206a1a87599f532ce68675536f0b1546900d7a'
+      );
+      cb();
+    }
   );
 }
 
-
 tmpdir.refresh();
 
 common.createZeroFilledFile(filename);
@@ -85,7 +88,6 @@ server = http.createServer(function(req, res) {
       process.exit(1);
     }
   });
-
 });
 
 server.listen(0, () => {
diff --git a/test/parallel/test-http-chunked-304.js b/test/parallel/test-http-chunked-304.js
index 2a8c33a5901f92..35527eccbad007 100644
--- a/test/parallel/test-http-chunked-304.js
+++ b/test/parallel/test-http-chunked-304.js
@@ -37,31 +37,42 @@ test(204);
 test(304);
 
 function test(statusCode) {
-  const server = http.createServer(common.mustCall((req, res) => {
-    res.writeHead(statusCode, { 'Transfer-Encoding': 'chunked' });
-    res.end();
-    server.close();
-  }));
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      res.writeHead(statusCode, { 'Transfer-Encoding': 'chunked' });
+      res.end();
+      server.close();
+    })
+  );
 
-  server.listen(0, common.mustCall(() => {
-    const conn = net.createConnection(
-      server.address().port,
-      common.mustCall(() => {
-        conn.write('GET / HTTP/1.1\r\n\r\n');
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const conn = net.createConnection(
+        server.address().port,
+        common.mustCall(() => {
+          conn.write('GET / HTTP/1.1\r\n\r\n');
 
-        let resp = '';
-        conn.setEncoding('utf8');
-        conn.on('data', common.mustCall((data) => {
-          resp += data;
-        }));
+          let resp = '';
+          conn.setEncoding('utf8');
+          conn.on(
+            'data',
+            common.mustCall((data) => {
+              resp += data;
+            })
+          );
 
-        conn.on('end', common.mustCall(() => {
-          // Connection: close should be in the response
-          assert.strictEqual(/^Connection: close\r\n$/m.test(resp), true);
-          // Make sure this doesn't end with 0\r\n\r\n
-          assert.strictEqual(/^0\r\n$/m.test(resp), false);
-        }));
-      })
-    );
-  }));
+          conn.on(
+            'end',
+            common.mustCall(() => {
+              // Connection: close should be in the response
+              assert.strictEqual(/^Connection: close\r\n$/m.test(resp), true);
+              // Make sure this doesn't end with 0\r\n\r\n
+              assert.strictEqual(/^0\r\n$/m.test(resp), false);
+            })
+          );
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http-chunked.js b/test/parallel/test-http-chunked.js
index 264a87be6adc7f..8591640483a503 100644
--- a/test/parallel/test-http-chunked.js
+++ b/test/parallel/test-http-chunked.js
@@ -24,33 +24,47 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const UTF8_STRING = '南越国是前203年至前111年存在于岭南地区的一个国家，' +
-                    '国都位于番禺，疆域包括今天中国的广东、广西两省区的大部份地区，福建省、湖南、' +
-                    '贵州、云南的一小部份地区和越南的北部。南越国是秦朝灭亡后，' +
-                    '由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。前196年和前179年，' +
-                    '南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
-                    '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。' +
-                    '南越国共存在93年，历经五代君主。南越国是岭南地区的第一个有记载的政权国家，' +
-                    '采用封建制和郡县制并存的制度，它的建立保证了秦末乱世岭南地区社会秩序的稳定，' +
-                    '有效的改善了岭南地区落后的政治、经济现状。';
+const UTF8_STRING =
+  '南越国是前203年至前111年存在于岭南地区的一个国家，' +
+  '国都位于番禺，疆域包括今天中国的广东、广西两省区的大部份地区，福建省、湖南、' +
+  '贵州、云南的一小部份地区和越南的北部。南越国是秦朝灭亡后，' +
+  '由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。前196年和前179年，' +
+  '南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
+  '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。' +
+  '南越国共存在93年，历经五代君主。南越国是岭南地区的第一个有记载的政权国家，' +
+  '采用封建制和郡县制并存的制度，它的建立保证了秦末乱世岭南地区社会秩序的稳定，' +
+  '有效的改善了岭南地区落后的政治、经济现状。';
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf8' });
-  res.end(UTF8_STRING, 'utf8');
-}));
-server.listen(0, common.mustCall(() => {
-  let data = '';
-  http.get({
-    path: '/',
-    host: 'localhost',
-    port: server.address().port
-  }, common.mustCall((x) => {
-    x.setEncoding('utf8');
-    x.on('data', (c) => data += c);
-    x.on('end', common.mustCall(() => {
-      assert.strictEqual(typeof data, 'string');
-      assert.strictEqual(UTF8_STRING, data);
-      server.close();
-    }));
-  })).end();
-}));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf8' });
+    res.end(UTF8_STRING, 'utf8');
+  })
+);
+server.listen(
+  0,
+  common.mustCall(() => {
+    let data = '';
+    http
+      .get(
+        {
+          path: '/',
+          host: 'localhost',
+          port: server.address().port
+        },
+        common.mustCall((x) => {
+          x.setEncoding('utf8');
+          x.on('data', (c) => (data += c));
+          x.on(
+            'end',
+            common.mustCall(() => {
+              assert.strictEqual(typeof data, 'string');
+              assert.strictEqual(UTF8_STRING, data);
+              server.close();
+            })
+          );
+        })
+      )
+      .end();
+  })
+);
diff --git a/test/parallel/test-http-client-abort-event.js b/test/parallel/test-http-client-abort-event.js
index 0392060196405c..5b197b50ac0985 100644
--- a/test/parallel/test-http-client-abort-event.js
+++ b/test/parallel/test-http-client-abort-event.js
@@ -5,16 +5,25 @@ const server = http.createServer(function(req, res) {
   res.end();
 });
 
-server.listen(0, common.mustCall(function() {
-  const req = http.request({
-    port: this.address().port
-  }, common.mustNotCall());
+server.listen(
+  0,
+  common.mustCall(function() {
+    const req = http.request(
+      {
+        port: this.address().port
+      },
+      common.mustNotCall()
+    );
 
-  req.on('abort', common.mustCall(function() {
-    server.close();
-  }));
+    req.on(
+      'abort',
+      common.mustCall(function() {
+        server.close();
+      })
+    );
 
-  req.end();
-  req.abort();
-  req.abort();
-}));
+    req.end();
+    req.abort();
+    req.abort();
+  })
+);
diff --git a/test/parallel/test-http-client-abort-keep-alive-queued-tcp-socket.js b/test/parallel/test-http-client-abort-keep-alive-queued-tcp-socket.js
index 6282aa3da7caf2..4eece31a990d87 100644
--- a/test/parallel/test-http-client-abort-keep-alive-queued-tcp-socket.js
+++ b/test/parallel/test-http-client-abort-keep-alive-queued-tcp-socket.js
@@ -15,22 +15,28 @@ class Agent extends http.Agent {
 
 const server = http.createServer((req, res) => res.end());
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const agent = new Agent({
-    keepAlive: true,
-    maxSockets: 1
-  });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const agent = new Agent({
+      keepAlive: true,
+      maxSockets: 1
+    });
 
-  http.get({ agent, port }, (res) => res.resume());
+    http.get({ agent, port }, (res) => res.resume());
 
-  const req = http.get({ agent, port }, common.mustNotCall());
-  req.abort();
+    const req = http.get({ agent, port }, common.mustNotCall());
+    req.abort();
 
-  http.get({ agent, port }, common.mustCall((res) => {
-    res.resume();
-    assert.strictEqual(socketsCreated, 1);
-    agent.destroy();
-    server.close();
-  }));
-}));
+    http.get(
+      { agent, port },
+      common.mustCall((res) => {
+        res.resume();
+        assert.strictEqual(socketsCreated, 1);
+        agent.destroy();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-client-abort-keep-alive-queued-unix-socket.js b/test/parallel/test-http-client-abort-keep-alive-queued-unix-socket.js
index 745ed4ceeee887..4dd7f105bae77f 100644
--- a/test/parallel/test-http-client-abort-keep-alive-queued-unix-socket.js
+++ b/test/parallel/test-http-client-abort-keep-alive-queued-unix-socket.js
@@ -19,21 +19,27 @@ const socketPath = common.PIPE;
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-server.listen(socketPath, common.mustCall(() => {
-  const agent = new Agent({
-    keepAlive: true,
-    maxSockets: 1
-  });
-
-  http.get({ agent, socketPath }, (res) => res.resume());
-
-  const req = http.get({ agent, socketPath }, common.mustNotCall());
-  req.abort();
-
-  http.get({ agent, socketPath }, common.mustCall((res) => {
-    res.resume();
-    assert.strictEqual(socketsCreated, 1);
-    agent.destroy();
-    server.close();
-  }));
-}));
+server.listen(
+  socketPath,
+  common.mustCall(() => {
+    const agent = new Agent({
+      keepAlive: true,
+      maxSockets: 1
+    });
+
+    http.get({ agent, socketPath }, (res) => res.resume());
+
+    const req = http.get({ agent, socketPath }, common.mustNotCall());
+    req.abort();
+
+    http.get(
+      { agent, socketPath },
+      common.mustCall((res) => {
+        res.resume();
+        assert.strictEqual(socketsCreated, 1);
+        agent.destroy();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-client-abort-no-agent.js b/test/parallel/test-http-client-abort-no-agent.js
index 2f9fda96d49b65..21fa3617b91420 100644
--- a/test/parallel/test-http-client-abort-no-agent.js
+++ b/test/parallel/test-http-client-abort-no-agent.js
@@ -5,15 +5,18 @@ const net = require('net');
 
 const server = http.createServer(common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const req = http.get({
-    createConnection(options, oncreate) {
-      const socket = net.createConnection(options, oncreate);
-      socket.once('close', () => server.close());
-      return socket;
-    },
-    port: server.address().port
-  });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.get({
+      createConnection(options, oncreate) {
+        const socket = net.createConnection(options, oncreate);
+        socket.once('close', () => server.close());
+        return socket;
+      },
+      port: server.address().port
+    });
 
-  req.abort();
-}));
+    req.abort();
+  })
+);
diff --git a/test/parallel/test-http-client-abort-unix-socket.js b/test/parallel/test-http-client-abort-unix-socket.js
index bf666b7935a3a6..c0088ef6922364 100644
--- a/test/parallel/test-http-client-abort-unix-socket.js
+++ b/test/parallel/test-http-client-abort-unix-socket.js
@@ -15,11 +15,14 @@ class Agent extends http.Agent {
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-server.listen(common.PIPE, common.mustCall(() => {
-  const req = http.get({
-    agent: new Agent(),
-    socketPath: common.PIPE
-  });
+server.listen(
+  common.PIPE,
+  common.mustCall(() => {
+    const req = http.get({
+      agent: new Agent(),
+      socketPath: common.PIPE
+    });
 
-  req.abort();
-}));
+    req.abort();
+  })
+);
diff --git a/test/parallel/test-http-client-abort.js b/test/parallel/test-http-client-abort.js
index f767189ea9d593..03f48073febcd5 100644
--- a/test/parallel/test-http-client-abort.js
+++ b/test/parallel/test-http-client-abort.js
@@ -28,27 +28,35 @@ const N = 8;
 
 const countdown = new Countdown(N, () => server.close());
 
-const server = http.Server(common.mustCall((req, res) => {
-  res.writeHead(200);
-  res.write('Working on it...');
-  req.on('aborted', common.mustCall(() => countdown.dec()));
-}, N));
-
-server.listen(0, common.mustCall(() => {
-
-  const requests = [];
-  const reqCountdown = new Countdown(N, () => {
-    requests.forEach((req) => req.abort());
-  });
-
-  const options = { port: server.address().port };
-
-  for (let i = 0; i < N; i++) {
-    options.path = `/?id=${i}`;
-    requests.push(
-      http.get(options, common.mustCall((res) => {
-        res.resume();
-        reqCountdown.dec();
-      })));
-  }
-}));
+const server = http.Server(
+  common.mustCall((req, res) => {
+    res.writeHead(200);
+    res.write('Working on it...');
+    req.on('aborted', common.mustCall(() => countdown.dec()));
+  }, N)
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const requests = [];
+    const reqCountdown = new Countdown(N, () => {
+      requests.forEach((req) => req.abort());
+    });
+
+    const options = { port: server.address().port };
+
+    for (let i = 0; i < N; i++) {
+      options.path = `/?id=${i}`;
+      requests.push(
+        http.get(
+          options,
+          common.mustCall((res) => {
+            res.resume();
+            reqCountdown.dec();
+          })
+        )
+      );
+    }
+  })
+);
diff --git a/test/parallel/test-http-client-abort2.js b/test/parallel/test-http-client-abort2.js
index bc4b0e40838b36..5b2d210f4a4f96 100644
--- a/test/parallel/test-http-client-abort2.js
+++ b/test/parallel/test-http-client-abort2.js
@@ -23,16 +23,24 @@
 const common = require('../common');
 const http = require('http');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end('Hello');
-}));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.end('Hello');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const options = { port: server.address().port };
-  const req = http.get(options, common.mustCall((res) => {
-    res.on('data', (data) => {
-      req.abort();
-      server.close();
-    });
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const options = { port: server.address().port };
+    const req = http.get(
+      options,
+      common.mustCall((res) => {
+        res.on('data', (data) => {
+          req.abort();
+          server.close();
+        });
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-client-aborted-event.js b/test/parallel/test-http-client-aborted-event.js
index 1e7feb7d5860f6..90e6963e3f84e3 100644
--- a/test/parallel/test-http-client-aborted-event.js
+++ b/test/parallel/test-http-client-aborted-event.js
@@ -8,13 +8,19 @@ const server = http.Server(function(req, res) {
   serverRes = res;
 });
 
-server.listen(0, common.mustCall(function() {
-  http.get({
-    port: this.address().port,
-    headers: { connection: 'keep-alive' }
-  }, common.mustCall(function(res) {
-    server.close();
-    serverRes.destroy();
-    res.on('aborted', common.mustCall());
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    http.get(
+      {
+        port: this.address().port,
+        headers: { connection: 'keep-alive' }
+      },
+      common.mustCall(function(res) {
+        server.close();
+        serverRes.destroy();
+        res.on('aborted', common.mustCall());
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-client-agent.js b/test/parallel/test-http-client-agent.js
index 3ae906f09c92ae..29adc750f1417b 100644
--- a/test/parallel/test-http-client-agent.js
+++ b/test/parallel/test-http-client-agent.js
@@ -28,22 +28,29 @@ const Countdown = require('../common/countdown');
 let name;
 const max = 3;
 
-const server = http.Server(common.mustCall((req, res) => {
-  if (req.url === '/0') {
-    setTimeout(common.mustCall(() => {
+const server = http.Server(
+  common.mustCall((req, res) => {
+    if (req.url === '/0') {
+      setTimeout(
+        common.mustCall(() => {
+          res.writeHead(200);
+          res.end('Hello, World!');
+        }),
+        100
+      );
+    } else {
       res.writeHead(200);
       res.end('Hello, World!');
-    }), 100);
-  } else {
-    res.writeHead(200);
-    res.end('Hello, World!');
-  }
-}, max));
-server.listen(0, common.mustCall(() => {
-  name = http.globalAgent.getName({ port: server.address().port });
-  for (let i = 0; i < max; ++i)
-    request(i);
-}));
+    }
+  }, max)
+);
+server.listen(
+  0,
+  common.mustCall(() => {
+    name = http.globalAgent.getName({ port: server.address().port });
+    for (let i = 0; i < max; ++i) request(i);
+  })
+);
 
 const countdown = new Countdown(max, () => {
   assert(!http.globalAgent.sockets.hasOwnProperty(name));
@@ -52,18 +59,26 @@ const countdown = new Countdown(max, () => {
 });
 
 function request(i) {
-  const req = http.get({
-    port: server.address().port,
-    path: `/${i}`
-  }, function(res) {
-    const socket = req.socket;
-    socket.on('close', common.mustCall(() => {
-      countdown.dec();
-      if (countdown.remaining > 0) {
-        assert.strictEqual(http.globalAgent.sockets[name].includes(socket),
-                           false);
-      }
-    }));
-    res.resume();
-  });
+  const req = http.get(
+    {
+      port: server.address().port,
+      path: `/${i}`
+    },
+    function(res) {
+      const socket = req.socket;
+      socket.on(
+        'close',
+        common.mustCall(() => {
+          countdown.dec();
+          if (countdown.remaining > 0) {
+            assert.strictEqual(
+              http.globalAgent.sockets[name].includes(socket),
+              false
+            );
+          }
+        })
+      );
+      res.resume();
+    }
+  );
 }
diff --git a/test/parallel/test-http-client-check-http-token.js b/test/parallel/test-http-client-check-http-token.js
index 828d7fa79a503c..6d2f7a5b496a2d 100644
--- a/test/parallel/test-http-client-check-http-token.js
+++ b/test/parallel/test-http-client-check-http-token.js
@@ -6,28 +6,38 @@ const Countdown = require('../common/countdown');
 const expectedSuccesses = [undefined, null, 'GET', 'post'];
 const expectedFails = [-1, 1, 0, {}, true, false, [], Symbol()];
 
-const countdown =
-  new Countdown(expectedSuccesses.length,
-                common.mustCall(() => server.close()));
+const countdown = new Countdown(
+  expectedSuccesses.length,
+  common.mustCall(() => server.close())
+);
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end();
-  countdown.dec();
-}, expectedSuccesses.length));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.end();
+    countdown.dec();
+  }, expectedSuccesses.length)
+);
 
-server.listen(0, common.mustCall(() => {
-  expectedFails.forEach((method) => {
-    common.expectsError(() => {
-      http.request({ method, path: '/' }, common.mustNotCall());
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "method" argument must be of type string. ' +
-               `Received type ${typeof method}`
+server.listen(
+  0,
+  common.mustCall(() => {
+    expectedFails.forEach((method) => {
+      common.expectsError(
+        () => {
+          http.request({ method, path: '/' }, common.mustNotCall());
+        },
+        {
+          code: 'ERR_INVALID_ARG_TYPE',
+          type: TypeError,
+          message:
+            'The "method" argument must be of type string. ' +
+            `Received type ${typeof method}`
+        }
+      );
     });
-  });
 
-  expectedSuccesses.forEach((method) => {
-    http.request({ method, port: server.address().port }).end();
-  });
-}));
+    expectedSuccesses.forEach((method) => {
+      http.request({ method, port: server.address().port }).end();
+    });
+  })
+);
diff --git a/test/parallel/test-http-client-close-event.js b/test/parallel/test-http-client-close-event.js
index 7573931ac48ef6..c34adb965a69b2 100644
--- a/test/parallel/test-http-client-close-event.js
+++ b/test/parallel/test-http-client-close-event.js
@@ -10,21 +10,27 @@ const http = require('http');
 
 const server = http.createServer(common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const req = http.get({ port: server.address().port }, common.mustNotCall());
-  let errorEmitted = false;
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.get({ port: server.address().port }, common.mustNotCall());
+    let errorEmitted = false;
 
-  req.on('error', (err) => {
-    errorEmitted = true;
-    assert.strictEqual(err.constructor, Error);
-    assert.strictEqual(err.message, 'socket hang up');
-    assert.strictEqual(err.code, 'ECONNRESET');
-  });
+    req.on('error', (err) => {
+      errorEmitted = true;
+      assert.strictEqual(err.constructor, Error);
+      assert.strictEqual(err.message, 'socket hang up');
+      assert.strictEqual(err.code, 'ECONNRESET');
+    });
 
-  req.on('close', common.mustCall(() => {
-    assert.strictEqual(errorEmitted, true);
-    server.close();
-  }));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(errorEmitted, true);
+        server.close();
+      })
+    );
 
-  req.destroy();
-}));
+    req.destroy();
+  })
+);
diff --git a/test/parallel/test-http-client-default-headers-exist.js b/test/parallel/test-http-client-default-headers-exist.js
index e0cf82e46220c4..596e7e16237cad 100644
--- a/test/parallel/test-http-client-default-headers-exist.js
+++ b/test/parallel/test-http-client-default-headers-exist.js
@@ -26,49 +26,59 @@ const http = require('http');
 const Countdown = require('../common/countdown');
 
 const expectedHeaders = {
-  'DELETE': ['host', 'connection'],
-  'GET': ['host', 'connection'],
-  'HEAD': ['host', 'connection'],
-  'OPTIONS': ['host', 'connection'],
-  'POST': ['host', 'connection', 'content-length'],
-  'PUT': ['host', 'connection', 'content-length']
+  DELETE: ['host', 'connection'],
+  GET: ['host', 'connection'],
+  HEAD: ['host', 'connection'],
+  OPTIONS: ['host', 'connection'],
+  POST: ['host', 'connection', 'content-length'],
+  PUT: ['host', 'connection', 'content-length']
 };
 
 const expectedMethods = Object.keys(expectedHeaders);
 
-const countdown =
-  new Countdown(expectedMethods.length,
-                common.mustCall(() => server.close()));
+const countdown = new Countdown(
+  expectedMethods.length,
+  common.mustCall(() => server.close())
+);
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end();
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.end();
 
-  assert(expectedHeaders.hasOwnProperty(req.method),
-         `${req.method} was an unexpected method`);
+    assert(
+      expectedHeaders.hasOwnProperty(req.method),
+      `${req.method} was an unexpected method`
+    );
+
+    const requestHeaders = Object.keys(req.headers);
+    requestHeaders.forEach((header) => {
+      assert.strictEqual(
+        expectedHeaders[req.method].includes(header.toLowerCase()),
+        true,
+        `${header} should not exist for method ${req.method}`
+      );
+    });
 
-  const requestHeaders = Object.keys(req.headers);
-  requestHeaders.forEach((header) => {
     assert.strictEqual(
-      expectedHeaders[req.method].includes(header.toLowerCase()),
-      true,
-      `${header} should not exist for method ${req.method}`
+      requestHeaders.length,
+      expectedHeaders[req.method].length,
+      `some headers were missing for method: ${req.method}`
     );
-  });
-
-  assert.strictEqual(
-    requestHeaders.length,
-    expectedHeaders[req.method].length,
-    `some headers were missing for method: ${req.method}`
-  );
 
-  countdown.dec();
-}, expectedMethods.length));
+    countdown.dec();
+  }, expectedMethods.length)
+);
 
-server.listen(0, common.mustCall(() => {
-  expectedMethods.forEach((method) => {
-    http.request({
-      method: method,
-      port: server.address().port
-    }).end();
-  });
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    expectedMethods.forEach((method) => {
+      http
+        .request({
+          method: method,
+          port: server.address().port
+        })
+        .end();
+    });
+  })
+);
diff --git a/test/parallel/test-http-client-encoding.js b/test/parallel/test-http-client-encoding.js
index a4701cdbd0abb1..c82ee4f4e578c8 100644
--- a/test/parallel/test-http-client-encoding.js
+++ b/test/parallel/test-http-client-encoding.js
@@ -24,16 +24,29 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server = http.createServer((req, res) => {
-  res.end('ok');
-  server.close();
-}).listen(0, common.mustCall(() => {
-  http.request({
-    port: server.address().port,
-    encoding: 'utf8'
-  }, common.mustCall((res) => {
-    let data = '';
-    res.on('data', (chunk) => data += chunk);
-    res.on('end', common.mustCall(() => assert.strictEqual(data, 'ok')));
-  })).end();
-}));
+const server = http
+  .createServer((req, res) => {
+    res.end('ok');
+    server.close();
+  })
+  .listen(
+    0,
+    common.mustCall(() => {
+      http
+        .request(
+          {
+            port: server.address().port,
+            encoding: 'utf8'
+          },
+          common.mustCall((res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on(
+              'end',
+              common.mustCall(() => assert.strictEqual(data, 'ok'))
+            );
+          })
+        )
+        .end();
+    })
+  );
diff --git a/test/parallel/test-http-client-get-url.js b/test/parallel/test-http-client-get-url.js
index a72eea56538c4d..8081d80fd6601b 100644
--- a/test/parallel/test-http-client-get-url.js
+++ b/test/parallel/test-http-client-get-url.js
@@ -27,21 +27,38 @@ const url = require('url');
 const URL = url.URL;
 const testPath = '/foo?bar';
 
-const server = http.createServer(common.mustCall((req, res) => {
-  assert.strictEqual(req.method, 'GET');
-  assert.strictEqual(req.url, testPath);
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.write('hello\n');
-  res.end();
-}, 3));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    assert.strictEqual(req.method, 'GET');
+    assert.strictEqual(req.url, testPath);
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write('hello\n');
+    res.end();
+  }, 3)
+);
 
-server.listen(0, common.localhostIPv4, common.mustCall(() => {
-  const u = `http://${common.localhostIPv4}:${server.address().port}${testPath}`;
-  http.get(u, common.mustCall(() => {
-    http.get(url.parse(u), common.mustCall(() => {
-      http.get(new URL(u), common.mustCall(() => {
-        server.close();
-      }));
-    }));
-  }));
-}));
+server.listen(
+  0,
+  common.localhostIPv4,
+  common.mustCall(() => {
+    const u = `http://${common.localhostIPv4}:${
+      server.address().port
+    }${testPath}`;
+    http.get(
+      u,
+      common.mustCall(() => {
+        http.get(
+          url.parse(u),
+          common.mustCall(() => {
+            http.get(
+              new URL(u),
+              common.mustCall(() => {
+                server.close();
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-client-headers-array.js b/test/parallel/test-http-client-headers-array.js
index c637de61c012b5..15a003a8d89dd9 100644
--- a/test/parallel/test-http-client-headers-array.js
+++ b/test/parallel/test-http-client-headers-array.js
@@ -6,55 +6,67 @@ const assert = require('assert');
 const http = require('http');
 
 function execute(options) {
-  http.createServer(function(req, res) {
-    const expectHeaders = {
-      'x-foo': 'boom',
-      'cookie': 'a=1; b=2; c=3',
-      'connection': 'close'
-    };
-
-    // no Host header when you set headers an array
-    if (!Array.isArray(options.headers)) {
-      expectHeaders.host = `localhost:${this.address().port}`;
-    }
-
-    // no Authorization header when you set headers an array
-    if (options.auth && !Array.isArray(options.headers)) {
-      expectHeaders.authorization =
-          `Basic ${Buffer.from(options.auth).toString('base64')}`;
-    }
-
-    this.close();
-
-    assert.deepStrictEqual(req.headers, expectHeaders);
-
-    res.end();
-  }).listen(0, function() {
-    options = Object.assign(options, {
-      port: this.address().port,
-      path: '/'
+  http
+    .createServer(function(req, res) {
+      const expectHeaders = {
+        'x-foo': 'boom',
+        cookie: 'a=1; b=2; c=3',
+        connection: 'close'
+      };
+
+      // no Host header when you set headers an array
+      if (!Array.isArray(options.headers)) {
+        expectHeaders.host = `localhost:${this.address().port}`;
+      }
+
+      // no Authorization header when you set headers an array
+      if (options.auth && !Array.isArray(options.headers)) {
+        expectHeaders.authorization = `Basic ${Buffer.from(
+          options.auth
+        ).toString('base64')}`;
+      }
+
+      this.close();
+
+      assert.deepStrictEqual(req.headers, expectHeaders);
+
+      res.end();
+    })
+    .listen(0, function() {
+      options = Object.assign(options, {
+        port: this.address().port,
+        path: '/'
+      });
+      const req = http.request(options);
+      req.end();
     });
-    const req = http.request(options);
-    req.end();
-  });
 }
 
 // should be the same except for implicit Host header on the first two
-execute({ headers: { 'x-foo': 'boom', 'cookie': 'a=1; b=2; c=3' } });
-execute({ headers: { 'x-foo': 'boom', 'cookie': [ 'a=1', 'b=2', 'c=3' ] } });
-execute({ headers: [[ 'x-foo', 'boom' ], [ 'cookie', 'a=1; b=2; c=3' ]] });
-execute({ headers: [
-  [ 'x-foo', 'boom' ], [ 'cookie', [ 'a=1', 'b=2', 'c=3' ]]
-] });
-execute({ headers: [
-  [ 'x-foo', 'boom' ], [ 'cookie', 'a=1' ],
-  [ 'cookie', 'b=2' ], [ 'cookie', 'c=3']
-] });
+execute({ headers: { 'x-foo': 'boom', cookie: 'a=1; b=2; c=3' } });
+execute({ headers: { 'x-foo': 'boom', cookie: ['a=1', 'b=2', 'c=3'] } });
+execute({ headers: [['x-foo', 'boom'], ['cookie', 'a=1; b=2; c=3']] });
+execute({ headers: [['x-foo', 'boom'], ['cookie', ['a=1', 'b=2', 'c=3']]] });
+execute({
+  headers: [
+    ['x-foo', 'boom'],
+    ['cookie', 'a=1'],
+    ['cookie', 'b=2'],
+    ['cookie', 'c=3']
+  ]
+});
 
 // Authorization and Host header both missing from the second
-execute({ auth: 'foo:bar', headers:
-  { 'x-foo': 'boom', 'cookie': 'a=1; b=2; c=3' } });
-execute({ auth: 'foo:bar', headers: [
-  [ 'x-foo', 'boom' ], [ 'cookie', 'a=1' ],
-  [ 'cookie', 'b=2' ], [ 'cookie', 'c=3']
-] });
+execute({
+  auth: 'foo:bar',
+  headers: { 'x-foo': 'boom', cookie: 'a=1; b=2; c=3' }
+});
+execute({
+  auth: 'foo:bar',
+  headers: [
+    ['x-foo', 'boom'],
+    ['cookie', 'a=1'],
+    ['cookie', 'b=2'],
+    ['cookie', 'c=3']
+  ]
+});
diff --git a/test/parallel/test-http-client-immediate-error.js b/test/parallel/test-http-client-immediate-error.js
index ff29ad72bd8585..25a4688a4c69f3 100644
--- a/test/parallel/test-http-client-immediate-error.js
+++ b/test/parallel/test-http-client-immediate-error.js
@@ -35,10 +35,15 @@ agent.createConnection = common.mustCall((cfg) => {
   return sock;
 });
 
-http.get({
-  host: '127.0.0.1',
-  port: 1,
-  agent
-}).on('error', common.mustCall((err) => {
-  assert.strictEqual(err.code, 'ENETUNREACH');
-}));
+http
+  .get({
+    host: '127.0.0.1',
+    port: 1,
+    agent
+  })
+  .on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENETUNREACH');
+    })
+  );
diff --git a/test/parallel/test-http-client-invalid-path.js b/test/parallel/test-http-client-invalid-path.js
index c042d61eda0999..8ef1b1b13ca36d 100644
--- a/test/parallel/test-http-client-invalid-path.js
+++ b/test/parallel/test-http-client-invalid-path.js
@@ -2,11 +2,16 @@
 const common = require('../common');
 const http = require('http');
 
-common.expectsError(() => {
-  http.request({
-    path: '/thisisinvalid\uffe2'
-  }).end();
-}, {
-  code: 'ERR_UNESCAPED_CHARACTERS',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    http
+      .request({
+        path: '/thisisinvalid\uffe2'
+      })
+      .end();
+  },
+  {
+    code: 'ERR_UNESCAPED_CHARACTERS',
+    type: TypeError
+  }
+);
diff --git a/test/parallel/test-http-client-keep-alive-release-before-finish.js b/test/parallel/test-http-client-keep-alive-release-before-finish.js
index 0efedc91e2613d..317fcc69d16b63 100644
--- a/test/parallel/test-http-client-keep-alive-release-before-finish.js
+++ b/test/parallel/test-http-client-keep-alive-release-before-finish.js
@@ -2,39 +2,52 @@
 const common = require('../common');
 const http = require('http');
 
-const server = http.createServer((req, res) => {
-  res.end();
-}).listen(0, common.mustCall(() => {
-  const agent = new http.Agent({
-    maxSockets: 1,
-    keepAlive: true
-  });
+const server = http
+  .createServer((req, res) => {
+    res.end();
+  })
+  .listen(
+    0,
+    common.mustCall(() => {
+      const agent = new http.Agent({
+        maxSockets: 1,
+        keepAlive: true
+      });
 
-  const port = server.address().port;
+      const port = server.address().port;
 
-  const post = http.request({
-    agent,
-    method: 'POST',
-    port,
-  }, common.mustCall((res) => {
-    res.resume();
-  }));
+      const post = http.request(
+        {
+          agent,
+          method: 'POST',
+          port
+        },
+        common.mustCall((res) => {
+          res.resume();
+        })
+      );
 
-  /* What happens here is that the server `end`s the response before we send
-   * `something`, and the client thought that this is a green light for sending
-   * next GET request
-   */
-  post.write(Buffer.alloc(16 * 1024, 'X'));
-  setTimeout(() => {
-    post.end('something');
-  }, 100);
+      /* What happens here is that the server `end`s the response before we send
+       * `something`, and the client thought that this is a green light for sending
+       * next GET request
+       */
+      post.write(Buffer.alloc(16 * 1024, 'X'));
+      setTimeout(() => {
+        post.end('something');
+      }, 100);
 
-  http.request({
-    agent,
-    method: 'GET',
-    port,
-  }, common.mustCall((res) => {
-    server.close();
-    res.connection.end();
-  })).end();
-}));
+      http
+        .request(
+          {
+            agent,
+            method: 'GET',
+            port
+          },
+          common.mustCall((res) => {
+            server.close();
+            res.connection.end();
+          })
+        )
+        .end();
+    })
+  );
diff --git a/test/parallel/test-http-client-parse-error.js b/test/parallel/test-http-client-parse-error.js
index cb4e3ff08434dd..508c9649c5cf0f 100644
--- a/test/parallel/test-http-client-parse-error.js
+++ b/test/parallel/test-http-client-parse-error.js
@@ -33,20 +33,29 @@ const payloads = [
 ];
 
 // Create a TCP server
-const server =
-  net.createServer(common.mustCall((c) => c.end(payloads.shift()), 2));
+const server = net.createServer(
+  common.mustCall((c) => c.end(payloads.shift()), 2)
+);
 
-server.listen(0, common.mustCall(() => {
-  for (let i = 0; i < 2; i++) {
-    http.get({
-      port: server.address().port,
-      path: '/'
-    }).on('error', common.mustCall((e) => {
-      common.expectsError({
-        code: 'HPE_INVALID_CONSTANT',
-        message: 'Parse Error'
-      })(e);
-      countdown.dec();
-    }));
-  }
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    for (let i = 0; i < 2; i++) {
+      http
+        .get({
+          port: server.address().port,
+          path: '/'
+        })
+        .on(
+          'error',
+          common.mustCall((e) => {
+            common.expectsError({
+              code: 'HPE_INVALID_CONSTANT',
+              message: 'Parse Error'
+            })(e);
+            countdown.dec();
+          })
+        );
+    }
+  })
+);
diff --git a/test/parallel/test-http-client-pipe-end.js b/test/parallel/test-http-client-pipe-end.js
index 9dcdbe4a49d83a..8642a5b9368153 100644
--- a/test/parallel/test-http-client-pipe-end.js
+++ b/test/parallel/test-http-client-pipe-end.js
@@ -47,16 +47,16 @@ server.listen(common.PIPE, function() {
 
   req.write('.');
 
-  sched(function() { req.end(); }, 5);
+  sched(function() {
+    req.end();
+  }, 5);
 });
 
 // schedule a callback after `ticks` event loop ticks
 function sched(cb, ticks) {
   function fn() {
-    if (--ticks)
-      setImmediate(fn);
-    else
-      cb();
+    if (--ticks) setImmediate(fn);
+    else cb();
   }
   setImmediate(fn);
 }
diff --git a/test/parallel/test-http-client-race-2.js b/test/parallel/test-http-client-race-2.js
index 951b8e0d749261..8ad3631a68a25a 100644
--- a/test/parallel/test-http-client-race-2.js
+++ b/test/parallel/test-http-client-race-2.js
@@ -39,9 +39,14 @@ const server = http.createServer(function(req, res) {
 
   let body;
   switch (pathname) {
-    case '/1': body = body1_s; break;
-    case '/2': body = body2_s; break;
-    default: body = body3_s;
+    case '/1':
+      body = body1_s;
+      break;
+    case '/2':
+      body = body2_s;
+      break;
+    default:
+      body = body3_s;
   }
 
   res.writeHead(200, {
@@ -85,9 +90,10 @@ server.on('listening', function() {
         const req2 = http.get({ port: server.address().port, path: '/2' });
         req2.on('response', function(res2) {
           res2.setEncoding('utf8');
-          res2.on('data', function(chunk) { body2 += chunk; });
+          res2.on('data', function(chunk) {
+            body2 += chunk;
+          });
           res2.on('end', function() {
-
             //
             // Just to be really sure we've covered all our bases, execute a
             // request using client2.
@@ -95,8 +101,12 @@ server.on('listening', function() {
             const req3 = http.get({ port: server.address().port, path: '/3' });
             req3.on('response', function(res3) {
               res3.setEncoding('utf8');
-              res3.on('data', function(chunk) { body3 += chunk; });
-              res3.on('end', function() { server.close(); });
+              res3.on('data', function(chunk) {
+                body3 += chunk;
+              });
+              res3.on('end', function() {
+                server.close();
+              });
             });
           });
         });
diff --git a/test/parallel/test-http-client-race.js b/test/parallel/test-http-client-race.js
index 60b6b497372c7b..7e613fb5397068 100644
--- a/test/parallel/test-http-client-race.js
+++ b/test/parallel/test-http-client-race.js
@@ -56,8 +56,12 @@ server.on('listening', function() {
       req2.end();
       req2.on('response', function(res2) {
         res2.setEncoding('utf8');
-        res2.on('data', function(chunk) { body2 += chunk; });
-        res2.on('end', function() { server.close(); });
+        res2.on('data', function(chunk) {
+          body2 += chunk;
+        });
+        res2.on('end', function() {
+          server.close();
+        });
       });
     });
   });
diff --git a/test/parallel/test-http-client-read-in-error.js b/test/parallel/test-http-client-read-in-error.js
index 73b86b0d7edd62..bb92075da0507f 100644
--- a/test/parallel/test-http-client-read-in-error.js
+++ b/test/parallel/test-http-client-read-in-error.js
@@ -12,16 +12,18 @@ class Agent extends http.Agent {
     });
 
     let onNewListener;
-    socket.on('newListener', onNewListener = (name) => {
-      if (name !== 'error')
-        return;
-      socket.removeListener('newListener', onNewListener);
-
-      // Let other listeners to be set up too
-      process.nextTick(() => {
-        this.breakSocket(socket);
-      });
-    });
+    socket.on(
+      'newListener',
+      (onNewListener = (name) => {
+        if (name !== 'error') return;
+        socket.removeListener('newListener', onNewListener);
+
+        // Let other listeners to be set up too
+        process.nextTick(() => {
+          this.breakSocket(socket);
+        });
+      })
+    );
 
     return socket;
   }
@@ -33,8 +35,10 @@ class Agent extends http.Agent {
 
 const agent = new Agent();
 
-http.request({
-  agent
-}).once('error', function() {
-  console.log('ignore');
-});
+http
+  .request({
+    agent
+  })
+  .once('error', function() {
+    console.log('ignore');
+  });
diff --git a/test/parallel/test-http-client-readable.js b/test/parallel/test-http-client-readable.js
index c35ab259f25f2b..6244afd40f8b64 100644
--- a/test/parallel/test-http-client-readable.js
+++ b/test/parallel/test-http-client-readable.js
@@ -32,8 +32,7 @@ class FakeAgent extends http.Agent {
     let once = false;
 
     s._read = function() {
-      if (once)
-        return this.push(null);
+      if (once) return this.push(null);
       once = true;
 
       this.push('HTTP/1.1 200 Ok\r\nTransfer-Encoding: chunked\r\n\r\n');
@@ -57,15 +56,21 @@ class FakeAgent extends http.Agent {
 
 let received = '';
 
-const req = http.request({
-  agent: new FakeAgent()
-}, common.mustCall(function requestCallback(res) {
-  res.on('data', function dataCallback(chunk) {
-    received += chunk;
-  });
+const req = http.request(
+  {
+    agent: new FakeAgent()
+  },
+  common.mustCall(function requestCallback(res) {
+    res.on('data', function dataCallback(chunk) {
+      received += chunk;
+    });
 
-  res.on('end', common.mustCall(function endCallback() {
-    assert.strictEqual(received, 'hello world');
-  }));
-}));
+    res.on(
+      'end',
+      common.mustCall(function endCallback() {
+        assert.strictEqual(received, 'hello world');
+      })
+    );
+  })
+);
 req.end();
diff --git a/test/parallel/test-http-client-reject-chunked-with-content-length.js b/test/parallel/test-http-client-reject-chunked-with-content-length.js
index 8683b5726e2758..6aceff3b78d9b7 100644
--- a/test/parallel/test-http-client-reject-chunked-with-content-length.js
+++ b/test/parallel/test-http-client-reject-chunked-with-content-length.js
@@ -5,9 +5,10 @@ const http = require('http');
 const net = require('net');
 const assert = require('assert');
 
-const reqstr = 'HTTP/1.1 200 OK\r\n' +
-               'Content-Length: 1\r\n' +
-               'Transfer-Encoding: chunked\r\n\r\n';
+const reqstr =
+  'HTTP/1.1 200 OK\r\n' +
+  'Content-Length: 1\r\n' +
+  'Transfer-Encoding: chunked\r\n\r\n';
 
 const server = net.createServer((socket) => {
   socket.write(reqstr);
@@ -18,9 +19,12 @@ server.listen(0, () => {
   // both a Content-Length header and a Transfer-Encoding: chunked
   // header, which is a violation of the HTTP spec.
   const req = http.get({ port: server.address().port }, common.mustNotCall());
-  req.on('error', common.mustCall((err) => {
-    assert(/^Parse Error/.test(err.message));
-    assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
-    server.close();
-  }));
+  req.on(
+    'error',
+    common.mustCall((err) => {
+      assert(/^Parse Error/.test(err.message));
+      assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
+      server.close();
+    })
+  );
 });
diff --git a/test/parallel/test-http-client-reject-cr-no-lf.js b/test/parallel/test-http-client-reject-cr-no-lf.js
index bd303888bb63f9..2bfa0d5962eba4 100644
--- a/test/parallel/test-http-client-reject-cr-no-lf.js
+++ b/test/parallel/test-http-client-reject-cr-no-lf.js
@@ -5,9 +5,8 @@ const http = require('http');
 const net = require('net');
 const assert = require('assert');
 
-const reqstr = 'HTTP/1.1 200 OK\r\n' +
-               'Foo: Bar\r' +
-               'Content-Length: 1\r\n\r\n';
+const reqstr =
+  'HTTP/1.1 200 OK\r\n' + 'Foo: Bar\r' + 'Content-Length: 1\r\n\r\n';
 
 const server = net.createServer((socket) => {
   socket.write(reqstr);
@@ -17,9 +16,12 @@ server.listen(0, () => {
   // The callback should not be called because the server is sending a
   // header field that ends only in \r with no following \n
   const req = http.get({ port: server.address().port }, common.mustNotCall());
-  req.on('error', common.mustCall((err) => {
-    assert(/^Parse Error/.test(err.message));
-    assert.strictEqual(err.code, 'HPE_LF_EXPECTED');
-    server.close();
-  }));
+  req.on(
+    'error',
+    common.mustCall((err) => {
+      assert(/^Parse Error/.test(err.message));
+      assert.strictEqual(err.code, 'HPE_LF_EXPECTED');
+      server.close();
+    })
+  );
 });
diff --git a/test/parallel/test-http-client-reject-unexpected-agent.js b/test/parallel/test-http-client-reject-unexpected-agent.js
index 27cb77951cf5fd..637aca6c7d3731 100644
--- a/test/parallel/test-http-client-reject-unexpected-agent.js
+++ b/test/parallel/test-http-client-reject-unexpected-agent.js
@@ -6,24 +6,12 @@ const http = require('http');
 const baseOptions = {
   method: 'GET',
   port: undefined,
-  host: common.localhostIPv4,
+  host: common.localhostIPv4
 };
 
-const failingAgentOptions = [
-  true,
-  'agent',
-  {},
-  1,
-  () => null,
-  Symbol(),
-];
+const failingAgentOptions = [true, 'agent', {}, 1, () => null, Symbol()];
 
-const acceptableAgentOptions = [
-  false,
-  undefined,
-  null,
-  new http.Agent(),
-];
+const acceptableAgentOptions = [false, undefined, null, new http.Agent()];
 
 const server = http.createServer((req, res) => {
   res.end('hello');
@@ -35,33 +23,38 @@ function createRequest(agent) {
   const options = Object.assign(baseOptions, { agent });
   const request = http.request(options);
   request.end();
-  request.on('response', common.mustCall(() => {
-    numberOfResponses++;
-    if (numberOfResponses === acceptableAgentOptions.length) {
-      server.close();
-    }
-  }));
+  request.on(
+    'response',
+    common.mustCall(() => {
+      numberOfResponses++;
+      if (numberOfResponses === acceptableAgentOptions.length) {
+        server.close();
+      }
+    })
+  );
 }
 
-server.listen(0, baseOptions.host, common.mustCall(function() {
-  baseOptions.port = this.address().port;
+server.listen(
+  0,
+  baseOptions.host,
+  common.mustCall(function() {
+    baseOptions.port = this.address().port;
 
-  failingAgentOptions.forEach((agent) => {
-    common.expectsError(
-      () => createRequest(agent),
-      {
+    failingAgentOptions.forEach((agent) => {
+      common.expectsError(() => createRequest(agent), {
         code: 'ERR_INVALID_ARG_TYPE',
         type: TypeError,
-        message: 'The "options.agent" property must be one of type Agent-like' +
-                 ` Object, undefined, or false. Received type ${typeof agent}`
-      }
-    );
-  });
-
-  acceptableAgentOptions.forEach((agent) => {
-    createRequest(agent);
-  });
-}));
+        message:
+          'The "options.agent" property must be one of type Agent-like' +
+          ` Object, undefined, or false. Received type ${typeof agent}`
+      });
+    });
+
+    acceptableAgentOptions.forEach((agent) => {
+      createRequest(agent);
+    });
+  })
+);
 
 process.on('exit', () => {
   assert.strictEqual(numberOfResponses, acceptableAgentOptions.length);
diff --git a/test/parallel/test-http-client-req-error-dont-double-fire.js b/test/parallel/test-http-client-req-error-dont-double-fire.js
index d2c526eab69c6c..8bf16a37c9fbe2 100644
--- a/test/parallel/test-http-client-req-error-dont-double-fire.js
+++ b/test/parallel/test-http-client-req-error-dont-double-fire.js
@@ -17,10 +17,16 @@ const req = http.get({
   lookup: common.mustCall(errorLookupMock())
 });
 const err = new Error('mock unexpected code error');
-req.on('error', common.mustCall(() => {
-  throw err;
-}));
+req.on(
+  'error',
+  common.mustCall(() => {
+    throw err;
+  })
+);
 
-process.on('uncaughtException', common.mustCall((e) => {
-  assert.strictEqual(e, err);
-}));
+process.on(
+  'uncaughtException',
+  common.mustCall((e) => {
+    assert.strictEqual(e, err);
+  })
+);
diff --git a/test/parallel/test-http-client-response-domain.js b/test/parallel/test-http-client-response-domain.js
index 617dc729acb71f..beb685706df111 100644
--- a/test/parallel/test-http-client-response-domain.js
+++ b/test/parallel/test-http-client-response-domain.js
@@ -43,10 +43,12 @@ server.listen(common.PIPE, function() {
 });
 
 function test() {
-
-  d.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.message, 'should be caught by domain');
-  }));
+  d.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.message, 'should be caught by domain');
+    })
+  );
 
   const req = http.get({
     socketPath: common.PIPE,
diff --git a/test/parallel/test-http-client-set-timeout.js b/test/parallel/test-http-client-set-timeout.js
index 51284b42765493..cd0a18a6efc392 100644
--- a/test/parallel/test-http-client-set-timeout.js
+++ b/test/parallel/test-http-client-set-timeout.js
@@ -13,7 +13,7 @@ const options = {
   port: undefined,
   host: '127.0.0.1',
   path: '/',
-  timeout: HTTP_CLIENT_TIMEOUT,
+  timeout: HTTP_CLIENT_TIMEOUT
 };
 
 const server = http.createServer(() => {
@@ -34,9 +34,12 @@ function doRequest() {
   req.on('close', common.mustCall(() => server.close()));
 
   let timeout_events = 0;
-  req.on('timeout', common.mustCall(() => {
-    timeout_events += 1;
-  }));
+  req.on(
+    'timeout',
+    common.mustCall(() => {
+      timeout_events += 1;
+    })
+  );
   req.end();
 
   setTimeout(function() {
diff --git a/test/parallel/test-http-client-spurious-aborted.js b/test/parallel/test-http-client-spurious-aborted.js
index 58a2f92de94054..6ac64007b8e021 100644
--- a/test/parallel/test-http-client-spurious-aborted.js
+++ b/test/parallel/test-http-client-spurious-aborted.js
@@ -9,32 +9,40 @@ const Countdown = require('../common/countdown');
 const N = 2;
 let abortRequest = true;
 
-const server = http.Server(common.mustCall((req, res) => {
-  const headers = { 'Content-Type': 'text/plain' };
-  headers['Content-Length'] = 50;
-  const socket = res.socket;
-  res.writeHead(200, headers);
-  res.write('aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd');
-  if (abortRequest) {
-    process.nextTick(() => socket.destroy());
-  } else {
-    process.nextTick(() => res.end('eeeeeeeeee'));
-  }
-}, N));
+const server = http.Server(
+  common.mustCall((req, res) => {
+    const headers = { 'Content-Type': 'text/plain' };
+    headers['Content-Length'] = 50;
+    const socket = res.socket;
+    res.writeHead(200, headers);
+    res.write('aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd');
+    if (abortRequest) {
+      process.nextTick(() => socket.destroy());
+    } else {
+      process.nextTick(() => res.end('eeeeeeeeee'));
+    }
+  }, N)
+);
 
-server.listen(0, common.mustCall(() => {
-  download();
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    download();
+  })
+);
 
-const finishCountdown = new Countdown(N, common.mustCall(() => {
-  server.close();
-}));
+const finishCountdown = new Countdown(
+  N,
+  common.mustCall(() => {
+    server.close();
+  })
+);
 const reqCountdown = new Countdown(N, common.mustCall());
 
 function download() {
   const opts = {
     port: server.address().port,
-    path: '/',
+    path: '/'
   };
   const req = http.get(opts);
   req.on('error', common.mustNotCall());
@@ -56,9 +64,12 @@ function download() {
       if (res.complete) res.readable = true;
       callback();
     };
-    res.on('end', common.mustCall(() => {
-      reqCountdown.dec();
-    }));
+    res.on(
+      'end',
+      common.mustCall(() => {
+        reqCountdown.dec();
+      })
+    );
     res.on('aborted', () => {
       aborted = true;
     });
diff --git a/test/parallel/test-http-client-timeout-agent.js b/test/parallel/test-http-client-timeout-agent.js
index 8ce14f865c269c..214ca1f7247ceb 100644
--- a/test/parallel/test-http-client-timeout-agent.js
+++ b/test/parallel/test-http-client-timeout-agent.js
@@ -29,7 +29,7 @@ let requests_done = 0;
 const options = {
   method: 'GET',
   port: undefined,
-  host: '127.0.0.1',
+  host: '127.0.0.1'
 };
 
 const server = http.createServer(function(req, res) {
diff --git a/test/parallel/test-http-client-timeout-connect-listener.js b/test/parallel/test-http-client-timeout-connect-listener.js
index ea09aff718d557..a5b91668391f19 100644
--- a/test/parallel/test-http-client-timeout-connect-listener.js
+++ b/test/parallel/test-http-client-timeout-connect-listener.js
@@ -15,21 +15,33 @@ const server = http.createServer((req, res) => {
   res.end();
 });
 
-server.listen(0, common.mustCall(() => {
-  const agent = new http.Agent({ keepAlive: true, maxSockets: 1 });
-  const options = { port: server.address().port, agent: agent };
-
-  doRequest(options, common.mustCall(() => {
-    const req = doRequest(options, common.mustCall(() => {
-      agent.destroy();
-      server.close();
-    }));
-
-    req.on('socket', common.mustCall((socket) => {
-      assert.strictEqual(socket.listenerCount('connect'), 0);
-    }));
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const agent = new http.Agent({ keepAlive: true, maxSockets: 1 });
+    const options = { port: server.address().port, agent: agent };
+
+    doRequest(
+      options,
+      common.mustCall(() => {
+        const req = doRequest(
+          options,
+          common.mustCall(() => {
+            agent.destroy();
+            server.close();
+          })
+        );
+
+        req.on(
+          'socket',
+          common.mustCall((socket) => {
+            assert.strictEqual(socket.listenerCount('connect'), 0);
+          })
+        );
+      })
+    );
+  })
+);
 
 function doRequest(options, callback) {
   const req = http.get(options, (res) => {
diff --git a/test/parallel/test-http-client-timeout-event.js b/test/parallel/test-http-client-timeout-event.js
index c76d56ef256407..120322e8a2c3eb 100644
--- a/test/parallel/test-http-client-timeout-event.js
+++ b/test/parallel/test-http-client-timeout-event.js
@@ -41,11 +41,14 @@ server.listen(0, options.host, function() {
   req.on('close', common.mustCall(() => server.close()));
 
   req.setTimeout(1);
-  req.on('timeout', common.mustCall(() => {
-    req.end(() => {
-      setTimeout(() => {
-        req.destroy();
-      }, 100);
-    });
-  }));
+  req.on(
+    'timeout',
+    common.mustCall(() => {
+      req.end(() => {
+        setTimeout(() => {
+          req.destroy();
+        }, 100);
+      });
+    })
+  );
 });
diff --git a/test/parallel/test-http-client-timeout-on-connect.js b/test/parallel/test-http-client-timeout-on-connect.js
index 3a0098229d9af8..3188aaa1b56d3c 100644
--- a/test/parallel/test-http-client-timeout-on-connect.js
+++ b/test/parallel/test-http-client-timeout-on-connect.js
@@ -11,20 +11,33 @@ const server = http.createServer((req, res) => {
   // This space is intentionally left blank.
 });
 
-server.listen(0, common.localhostIPv4, common.mustCall(() => {
-  const port = server.address().port;
-  const req = http.get(`http://${common.localhostIPv4}:${port}`);
+server.listen(
+  0,
+  common.localhostIPv4,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const req = http.get(`http://${common.localhostIPv4}:${port}`);
 
-  req.setTimeout(1);
-  req.on('socket', common.mustCall((socket) => {
-    assert.strictEqual(socket[kTimeout], null);
-    socket.on('connect', common.mustCall(() => {
-      assert.strictEqual(socket[kTimeout]._idleTimeout, 1);
-    }));
-  }));
-  req.on('timeout', common.mustCall(() => req.abort()));
-  req.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.message, 'socket hang up');
-    server.close();
-  }));
-}));
+    req.setTimeout(1);
+    req.on(
+      'socket',
+      common.mustCall((socket) => {
+        assert.strictEqual(socket[kTimeout], null);
+        socket.on(
+          'connect',
+          common.mustCall(() => {
+            assert.strictEqual(socket[kTimeout]._idleTimeout, 1);
+          })
+        );
+      })
+    );
+    req.on('timeout', common.mustCall(() => req.abort()));
+    req.on(
+      'error',
+      common.mustCall((err) => {
+        assert.strictEqual(err.message, 'socket hang up');
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-client-timeout-option-listeners.js b/test/parallel/test-http-client-timeout-option-listeners.js
index 727b5fddf09624..0ea7c7573c524b 100644
--- a/test/parallel/test-http-client-timeout-option-listeners.js
+++ b/test/parallel/test-http-client-timeout-option-listeners.js
@@ -21,27 +21,43 @@ const options = {
   timeout: timeout
 };
 
-server.listen(0, options.host, common.mustCall(() => {
-  options.port = server.address().port;
-  doRequest(common.mustCall((numListeners) => {
-    assert.strictEqual(numListeners, 1);
-    doRequest(common.mustCall((numListeners) => {
-      assert.strictEqual(numListeners, 1);
-      server.close();
-      agent.destroy();
-    }));
-  }));
-}));
+server.listen(
+  0,
+  options.host,
+  common.mustCall(() => {
+    options.port = server.address().port;
+    doRequest(
+      common.mustCall((numListeners) => {
+        assert.strictEqual(numListeners, 1);
+        doRequest(
+          common.mustCall((numListeners) => {
+            assert.strictEqual(numListeners, 1);
+            server.close();
+            agent.destroy();
+          })
+        );
+      })
+    );
+  })
+);
 
 function doRequest(cb) {
-  http.request(options, common.mustCall((response) => {
-    const sockets = agent.sockets[`${options.host}:${options.port}:`];
-    assert.strictEqual(sockets.length, 1);
-    const socket = sockets[0];
-    const numListeners = socket.listeners('timeout').length;
-    response.resume();
-    response.once('end', common.mustCall(() => {
-      process.nextTick(cb, numListeners);
-    }));
-  })).end();
+  http
+    .request(
+      options,
+      common.mustCall((response) => {
+        const sockets = agent.sockets[`${options.host}:${options.port}:`];
+        assert.strictEqual(sockets.length, 1);
+        const socket = sockets[0];
+        const numListeners = socket.listeners('timeout').length;
+        response.resume();
+        response.once(
+          'end',
+          common.mustCall(() => {
+            process.nextTick(cb, numListeners);
+          })
+        );
+      })
+    )
+    .end();
 }
diff --git a/test/parallel/test-http-client-timeout-option-with-agent.js b/test/parallel/test-http-client-timeout-option-with-agent.js
index 26c93ec55bc903..e1b2414818a0b6 100644
--- a/test/parallel/test-http-client-timeout-option-with-agent.js
+++ b/test/parallel/test-http-client-timeout-option-with-agent.js
@@ -17,7 +17,7 @@ const options = {
   host: '127.0.0.1',
   path: '/',
   timeout: HTTP_CLIENT_TIMEOUT,
-  agent,
+  agent
 };
 
 const server = http.createServer(() => {
@@ -38,16 +38,19 @@ function doRequest() {
   req.on('close', common.mustCall(() => server.close()));
 
   let timeout_events = 0;
-  req.on('timeout', common.mustCall(() => {
-    timeout_events += 1;
-    const duration = Date.now() - start;
-    // The timeout event cannot be precisely timed. It will delay
-    // some number of milliseconds.
-    assert.ok(
-      duration >= HTTP_CLIENT_TIMEOUT,
-      `duration ${duration}ms less than timeout ${HTTP_CLIENT_TIMEOUT}ms`
-    );
-  }));
+  req.on(
+    'timeout',
+    common.mustCall(() => {
+      timeout_events += 1;
+      const duration = Date.now() - start;
+      // The timeout event cannot be precisely timed. It will delay
+      // some number of milliseconds.
+      assert.ok(
+        duration >= HTTP_CLIENT_TIMEOUT,
+        `duration ${duration}ms less than timeout ${HTTP_CLIENT_TIMEOUT}ms`
+      );
+    })
+  );
   req.end();
 
   setTimeout(function() {
diff --git a/test/parallel/test-http-client-timeout-option.js b/test/parallel/test-http-client-timeout-option.js
index 6741fbe0bd1e35..27d288a5b9e04d 100644
--- a/test/parallel/test-http-client-timeout-option.js
+++ b/test/parallel/test-http-client-timeout-option.js
@@ -22,7 +22,7 @@ server.listen(0, options.host, function() {
   req.on('close', common.mustCall(() => server.close()));
 
   let timeout_events = 0;
-  req.on('timeout', common.mustCall(() => timeout_events += 1));
+  req.on('timeout', common.mustCall(() => (timeout_events += 1)));
   setTimeout(function() {
     req.destroy();
     assert.strictEqual(timeout_events, 1);
diff --git a/test/parallel/test-http-client-timeout-with-data.js b/test/parallel/test-http-client-timeout-with-data.js
index bc5670b6939e39..f8b1af40a91bbf 100644
--- a/test/parallel/test-http-client-timeout-with-data.js
+++ b/test/parallel/test-http-client-timeout-with-data.js
@@ -36,7 +36,12 @@ const options = {
 const server = http.createServer(function(req, res) {
   res.writeHead(200, { 'Content-Length': '2' });
   res.write('*');
-  server.once('timeout', common.mustCall(function() { res.end('*'); }));
+  server.once(
+    'timeout',
+    common.mustCall(function() {
+      res.end('*');
+    })
+  );
 });
 
 server.listen(0, options.host, function() {
@@ -45,19 +50,28 @@ server.listen(0, options.host, function() {
   req.end();
 
   function onresponse(res) {
-    req.setTimeout(50, common.mustCall(function() {
-      assert.strictEqual(nchunks, 1); // should have received the first chunk
-      server.emit('timeout');
-    }));
-
-    res.on('data', common.mustCall(function(data) {
-      assert.strictEqual(String(data), '*');
-      nchunks++;
-    }, 2));
-
-    res.on('end', common.mustCall(function() {
-      assert.strictEqual(nchunks, 2);
-      server.close();
-    }));
+    req.setTimeout(
+      50,
+      common.mustCall(function() {
+        assert.strictEqual(nchunks, 1); // should have received the first chunk
+        server.emit('timeout');
+      })
+    );
+
+    res.on(
+      'data',
+      common.mustCall(function(data) {
+        assert.strictEqual(String(data), '*');
+        nchunks++;
+      }, 2)
+    );
+
+    res.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(nchunks, 2);
+        server.close();
+      })
+    );
   }
 });
diff --git a/test/parallel/test-http-client-unescaped-path.js b/test/parallel/test-http-client-unescaped-path.js
index 6d5a945dd5f893..c9070f10bad43d 100644
--- a/test/parallel/test-http-client-unescaped-path.js
+++ b/test/parallel/test-http-client-unescaped-path.js
@@ -25,12 +25,9 @@ const http = require('http');
 
 for (let i = 0; i <= 32; i += 1) {
   const path = `bad${String.fromCharCode(i)}path`;
-  common.expectsError(
-    () => http.get({ path }, common.mustNotCall()),
-    {
-      code: 'ERR_UNESCAPED_CHARACTERS',
-      type: TypeError,
-      message: 'Request path contains unescaped characters'
-    }
-  );
+  common.expectsError(() => http.get({ path }, common.mustNotCall()), {
+    code: 'ERR_UNESCAPED_CHARACTERS',
+    type: TypeError,
+    message: 'Request path contains unescaped characters'
+  });
 }
diff --git a/test/parallel/test-http-client-upload-buf.js b/test/parallel/test-http-client-upload-buf.js
index 1c75612c807874..14231530d780ce 100644
--- a/test/parallel/test-http-client-upload-buf.js
+++ b/test/parallel/test-http-client-upload-buf.js
@@ -26,39 +26,53 @@ const http = require('http');
 
 const N = 1024;
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  assert.strictEqual(req.method, 'POST');
-  let bytesReceived = 0;
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    assert.strictEqual(req.method, 'POST');
+    let bytesReceived = 0;
 
-  req.on('data', function(chunk) {
-    bytesReceived += chunk.length;
-  });
+    req.on('data', function(chunk) {
+      bytesReceived += chunk.length;
+    });
 
-  req.on('end', common.mustCall(function() {
-    assert.strictEqual(N, bytesReceived);
-    console.log('request complete from server');
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write('hello\n');
-    res.end();
-  }));
-}));
+    req.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(N, bytesReceived);
+        console.log('request complete from server');
+        res.writeHead(200, { 'Content-Type': 'text/plain' });
+        res.write('hello\n');
+        res.end();
+      })
+    );
+  })
+);
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const req = http.request({
-    port: this.address().port,
-    method: 'POST',
-    path: '/'
-  }, common.mustCall(function(res) {
-    res.setEncoding('utf8');
-    res.on('data', function(chunk) {
-      console.log(chunk);
-    });
-    res.on('end', common.mustCall(function() {
-      server.close();
-    }));
-  }));
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const req = http.request(
+      {
+        port: this.address().port,
+        method: 'POST',
+        path: '/'
+      },
+      common.mustCall(function(res) {
+        res.setEncoding('utf8');
+        res.on('data', function(chunk) {
+          console.log(chunk);
+        });
+        res.on(
+          'end',
+          common.mustCall(function() {
+            server.close();
+          })
+        );
+      })
+    );
 
-  req.write(Buffer.allocUnsafe(N));
-  req.end();
-}));
+    req.write(Buffer.allocUnsafe(N));
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http-client-upload.js b/test/parallel/test-http-client-upload.js
index 830c37da8ef567..e195c3fcf398dd 100644
--- a/test/parallel/test-http-client-upload.js
+++ b/test/parallel/test-http-client-upload.js
@@ -24,44 +24,58 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  assert.strictEqual(req.method, 'POST');
-  req.setEncoding('utf8');
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    assert.strictEqual(req.method, 'POST');
+    req.setEncoding('utf8');
 
-  let sent_body = '';
+    let sent_body = '';
 
-  req.on('data', function(chunk) {
-    console.log(`server got: ${JSON.stringify(chunk)}`);
-    sent_body += chunk;
-  });
+    req.on('data', function(chunk) {
+      console.log(`server got: ${JSON.stringify(chunk)}`);
+      sent_body += chunk;
+    });
 
-  req.on('end', common.mustCall(function() {
-    assert.strictEqual(sent_body, '1\n2\n3\n');
-    console.log('request complete from server');
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write('hello\n');
-    res.end();
-  }));
-}));
+    req.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(sent_body, '1\n2\n3\n');
+        console.log('request complete from server');
+        res.writeHead(200, { 'Content-Type': 'text/plain' });
+        res.write('hello\n');
+        res.end();
+      })
+    );
+  })
+);
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const req = http.request({
-    port: this.address().port,
-    method: 'POST',
-    path: '/'
-  }, common.mustCall(function(res) {
-    res.setEncoding('utf8');
-    res.on('data', function(chunk) {
-      console.log(chunk);
-    });
-    res.on('end', common.mustCall(function() {
-      server.close();
-    }));
-  }));
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const req = http.request(
+      {
+        port: this.address().port,
+        method: 'POST',
+        path: '/'
+      },
+      common.mustCall(function(res) {
+        res.setEncoding('utf8');
+        res.on('data', function(chunk) {
+          console.log(chunk);
+        });
+        res.on(
+          'end',
+          common.mustCall(function() {
+            server.close();
+          })
+        );
+      })
+    );
 
-  req.write('1\n');
-  req.write('2\n');
-  req.write('3\n');
-  req.end();
-}));
+    req.write('1\n');
+    req.write('2\n');
+    req.write('3\n');
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http-conn-reset.js b/test/parallel/test-http-conn-reset.js
index 7d0509a89ff68e..7b01afb308f267 100644
--- a/test/parallel/test-http-conn-reset.js
+++ b/test/parallel/test-http-conn-reset.js
@@ -42,8 +42,11 @@ server.listen(0, options.host, common.mustCall(onListen));
 function onListen() {
   options.port = this.address().port;
   const req = http.request(options, common.mustNotCall());
-  req.on('error', common.mustCall(function(err) {
-    assert.strictEqual(err.code, 'ECONNRESET');
-  }));
+  req.on(
+    'error',
+    common.mustCall(function(err) {
+      assert.strictEqual(err.code, 'ECONNRESET');
+    })
+  );
   req.end();
 }
diff --git a/test/parallel/test-http-connect-req-res.js b/test/parallel/test-http-connect-req-res.js
index 5db19aedde91d8..ef9b543a5d4c21 100644
--- a/test/parallel/test-http-connect-req-res.js
+++ b/test/parallel/test-http-connect-req-res.js
@@ -4,65 +4,77 @@ const assert = require('assert');
 const http = require('http');
 
 const server = http.createServer(common.mustNotCall());
-server.on('connect', common.mustCall(function(req, socket, firstBodyChunk) {
-  assert.strictEqual(req.method, 'CONNECT');
-  assert.strictEqual(req.url, 'example.com:443');
-  console.error('Server got CONNECT request');
+server.on(
+  'connect',
+  common.mustCall(function(req, socket, firstBodyChunk) {
+    assert.strictEqual(req.method, 'CONNECT');
+    assert.strictEqual(req.url, 'example.com:443');
+    console.error('Server got CONNECT request');
 
-  // It is legal for the server to send some data intended for the client
-  // along with the CONNECT response
-  socket.write(
-    'HTTP/1.1 200 Connection established\r\n' +
-    'Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n' +
-    '\r\n' +
-    'Head'
-  );
+    // It is legal for the server to send some data intended for the client
+    // along with the CONNECT response
+    socket.write(
+      'HTTP/1.1 200 Connection established\r\n' +
+        'Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n' +
+        '\r\n' +
+        'Head'
+    );
 
-  let data = firstBodyChunk.toString();
-  socket.on('data', function(buf) {
-    data += buf.toString();
-  });
-  socket.on('end', function() {
-    socket.end(data);
-  });
-}));
-server.listen(0, common.mustCall(function() {
-  const req = http.request({
-    port: this.address().port,
-    method: 'CONNECT',
-    path: 'example.com:443'
-  }, common.mustNotCall());
+    let data = firstBodyChunk.toString();
+    socket.on('data', function(buf) {
+      data += buf.toString();
+    });
+    socket.on('end', function() {
+      socket.end(data);
+    });
+  })
+);
+server.listen(
+  0,
+  common.mustCall(function() {
+    const req = http.request(
+      {
+        port: this.address().port,
+        method: 'CONNECT',
+        path: 'example.com:443'
+      },
+      common.mustNotCall()
+    );
 
-  req.on('close', common.mustCall());
+    req.on('close', common.mustCall());
 
-  req.on('connect', common.mustCall(function(res, socket, firstBodyChunk) {
-    console.error('Client got CONNECT request');
+    req.on(
+      'connect',
+      common.mustCall(function(res, socket, firstBodyChunk) {
+        console.error('Client got CONNECT request');
 
-    // Make sure this request got removed from the pool.
-    const name = `localhost:${server.address().port}`;
-    assert(!http.globalAgent.sockets.hasOwnProperty(name));
-    assert(!http.globalAgent.requests.hasOwnProperty(name));
+        // Make sure this request got removed from the pool.
+        const name = `localhost:${server.address().port}`;
+        assert(!http.globalAgent.sockets.hasOwnProperty(name));
+        assert(!http.globalAgent.requests.hasOwnProperty(name));
 
-    // Make sure this socket has detached.
-    assert(!socket.ondata);
-    assert(!socket.onend);
-    assert.strictEqual(socket.listeners('connect').length, 0);
-    assert.strictEqual(socket.listeners('data').length, 0);
+        // Make sure this socket has detached.
+        assert(!socket.ondata);
+        assert(!socket.onend);
+        assert.strictEqual(socket.listeners('connect').length, 0);
+        assert.strictEqual(socket.listeners('data').length, 0);
 
-    let data = firstBodyChunk.toString();
+        let data = firstBodyChunk.toString();
 
-    // test that the firstBodyChunk was not parsed as HTTP
-    assert.strictEqual(data, 'Head');
+        // test that the firstBodyChunk was not parsed as HTTP
+        assert.strictEqual(data, 'Head');
 
-    socket.on('data', function(buf) {
-      data += buf.toString();
-    });
-    socket.on('end', function() {
-      assert.strictEqual(data, 'HeadRequestEnd');
-      server.close();
-    });
-    socket.end('End');
-  }));
+        socket.on('data', function(buf) {
+          data += buf.toString();
+        });
+        socket.on('end', function() {
+          assert.strictEqual(data, 'HeadRequestEnd');
+          server.close();
+        });
+        socket.end('End');
+      })
+    );
 
-  req.end('Request');
-}));
+    req.end('Request');
+  })
+);
diff --git a/test/parallel/test-http-connect.js b/test/parallel/test-http-connect.js
index ec2c8846bbb134..7dd3a7f8d593f0 100644
--- a/test/parallel/test-http-connect.js
+++ b/test/parallel/test-http-connect.js
@@ -26,78 +26,99 @@ const http = require('http');
 
 const server = http.createServer(common.mustNotCall());
 
-server.on('connect', common.mustCall((req, socket, firstBodyChunk) => {
-  assert.strictEqual(req.method, 'CONNECT');
-  assert.strictEqual(req.url, 'google.com:443');
-
-  // Make sure this socket has detached.
-  assert.strictEqual(socket.listeners('close').length, 0);
-  assert.strictEqual(socket.listeners('drain').length, 0);
-  assert.strictEqual(socket.listeners('data').length, 0);
-  assert.strictEqual(socket.listeners('end').length, 1);
-  assert.strictEqual(socket.listeners('error').length, 0);
-
-  socket.write('HTTP/1.1 200 Connection established\r\n\r\n');
-
-  let data = firstBodyChunk.toString();
-  socket.on('data', (buf) => {
-    data += buf.toString();
-  });
-
-  socket.on('end', common.mustCall(() => {
-    socket.end(data);
-  }));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const req = http.request({
-    port: server.address().port,
-    method: 'CONNECT',
-    path: 'google.com:443'
-  }, common.mustNotCall());
-
-  req.on('socket', common.mustCall((socket) => {
-    assert.strictEqual(socket._httpMessage, req);
-  }));
-
-  req.on('close', common.mustCall());
-
-  req.on('connect', common.mustCall((res, socket, firstBodyChunk) => {
-    // Make sure this request got removed from the pool.
-    const name = `localhost:${server.address().port}`;
-    assert(!http.globalAgent.sockets.hasOwnProperty(name));
-    assert(!http.globalAgent.requests.hasOwnProperty(name));
+server.on(
+  'connect',
+  common.mustCall((req, socket, firstBodyChunk) => {
+    assert.strictEqual(req.method, 'CONNECT');
+    assert.strictEqual(req.url, 'google.com:443');
 
     // Make sure this socket has detached.
-    assert(!socket.ondata);
-    assert(!socket.onend);
-    assert.strictEqual(socket._httpMessage, null);
-    assert.strictEqual(socket.listeners('connect').length, 0);
-    assert.strictEqual(socket.listeners('data').length, 0);
+    assert.strictEqual(socket.listeners('close').length, 0);
     assert.strictEqual(socket.listeners('drain').length, 0);
+    assert.strictEqual(socket.listeners('data').length, 0);
     assert.strictEqual(socket.listeners('end').length, 1);
-    assert.strictEqual(socket.listeners('free').length, 0);
-    assert.strictEqual(socket.listeners('close').length, 0);
     assert.strictEqual(socket.listeners('error').length, 0);
-    assert.strictEqual(socket.listeners('agentRemove').length, 0);
+
+    socket.write('HTTP/1.1 200 Connection established\r\n\r\n');
 
     let data = firstBodyChunk.toString();
     socket.on('data', (buf) => {
       data += buf.toString();
     });
 
-    socket.on('end', common.mustCall(() => {
-      assert.strictEqual(data, 'HeadBody');
-      server.close();
-    }));
-
-    socket.write('Body');
-    socket.end();
-  }));
-
-  // It is legal for the client to send some data intended for the server
-  // before the "200 Connection established" (or any other success or
-  // error code) is received.
-  req.write('Head');
-  req.end();
-}));
+    socket.on(
+      'end',
+      common.mustCall(() => {
+        socket.end(data);
+      })
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.request(
+      {
+        port: server.address().port,
+        method: 'CONNECT',
+        path: 'google.com:443'
+      },
+      common.mustNotCall()
+    );
+
+    req.on(
+      'socket',
+      common.mustCall((socket) => {
+        assert.strictEqual(socket._httpMessage, req);
+      })
+    );
+
+    req.on('close', common.mustCall());
+
+    req.on(
+      'connect',
+      common.mustCall((res, socket, firstBodyChunk) => {
+        // Make sure this request got removed from the pool.
+        const name = `localhost:${server.address().port}`;
+        assert(!http.globalAgent.sockets.hasOwnProperty(name));
+        assert(!http.globalAgent.requests.hasOwnProperty(name));
+
+        // Make sure this socket has detached.
+        assert(!socket.ondata);
+        assert(!socket.onend);
+        assert.strictEqual(socket._httpMessage, null);
+        assert.strictEqual(socket.listeners('connect').length, 0);
+        assert.strictEqual(socket.listeners('data').length, 0);
+        assert.strictEqual(socket.listeners('drain').length, 0);
+        assert.strictEqual(socket.listeners('end').length, 1);
+        assert.strictEqual(socket.listeners('free').length, 0);
+        assert.strictEqual(socket.listeners('close').length, 0);
+        assert.strictEqual(socket.listeners('error').length, 0);
+        assert.strictEqual(socket.listeners('agentRemove').length, 0);
+
+        let data = firstBodyChunk.toString();
+        socket.on('data', (buf) => {
+          data += buf.toString();
+        });
+
+        socket.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(data, 'HeadBody');
+            server.close();
+          })
+        );
+
+        socket.write('Body');
+        socket.end();
+      })
+    );
+
+    // It is legal for the client to send some data intended for the server
+    // before the "200 Connection established" (or any other success or
+    // error code) is received.
+    req.write('Head');
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http-content-length.js b/test/parallel/test-http-content-length.js
index e6ba3719f95ba6..51730b3811e2ef 100644
--- a/test/parallel/test-http-content-length.js
+++ b/test/parallel/test-http-content-length.js
@@ -5,21 +5,20 @@ const http = require('http');
 const Countdown = require('../common/countdown');
 
 const expectedHeadersMultipleWrites = {
-  'connection': 'close',
-  'transfer-encoding': 'chunked',
+  connection: 'close',
+  'transfer-encoding': 'chunked'
 };
 
 const expectedHeadersEndWithData = {
-  'connection': 'close',
+  connection: 'close',
   'content-length': String('hello world'.length)
 };
 
 const expectedHeadersEndNoData = {
-  'connection': 'close',
-  'content-length': '0',
+  connection: 'close',
+  'content-length': '0'
 };
 
-
 const countdown = new Countdown(3, () => server.close());
 
 const server = http.createServer(function(req, res) {
@@ -85,5 +84,4 @@ server.listen(0, function() {
   req.on('response', function(res) {
     assert.deepStrictEqual(res.headers, expectedHeadersEndNoData);
   });
-
 });
diff --git a/test/parallel/test-http-contentLength0.js b/test/parallel/test-http-contentLength0.js
index 975e2abe881ac5..e7ea872d3064f2 100644
--- a/test/parallel/test-http-contentLength0.js
+++ b/test/parallel/test-http-contentLength0.js
@@ -27,13 +27,11 @@ const http = require('http');
 // with a 'Content-Length: 0 ' response header.
 // I.E. a space character after the 'Content-Length' throws an `error` event.
 
-
 const s = http.createServer(function(req, res) {
   res.writeHead(200, { 'Content-Length': '0 ' });
   res.end();
 });
 s.listen(0, function() {
-
   const request = http.request({ port: this.address().port }, (response) => {
     console.log(`STATUS: ${response.statusCode}`);
     s.close();
diff --git a/test/parallel/test-http-correct-hostname.js b/test/parallel/test-http-correct-hostname.js
index b4279c1da4339f..021e982379936e 100644
--- a/test/parallel/test-http-correct-hostname.js
+++ b/test/parallel/test-http-correct-hostname.js
@@ -19,10 +19,13 @@ Object.keys(modules).forEach((module) => {
   const doNotCall = common.mustNotCall(
     `${module}.request should not connect to ${module}://example.com%60x.example.com`
   );
-  const req = modules[module].request(`${module}://example.com%60x.example.com`, doNotCall);
+  const req = modules[module].request(
+    `${module}://example.com%60x.example.com`,
+    doNotCall
+  );
   assert.deepStrictEqual(req[outHeadersKey].host, [
     'Host',
-    'example.com`x.example.com',
+    'example.com`x.example.com'
   ]);
   req.abort();
 });
diff --git a/test/parallel/test-http-createConnection.js b/test/parallel/test-http-createConnection.js
index a65b9a158c679d..c1790aa92986c1 100644
--- a/test/parallel/test-http-createConnection.js
+++ b/test/parallel/test-http-createConnection.js
@@ -25,33 +25,42 @@ const http = require('http');
 const net = require('net');
 const assert = require('assert');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  res.end();
-}, 4)).listen(0, '127.0.0.1', function() {
-  let fn = common.mustCall(createConnection);
-  http.get({ createConnection: fn }, function(res) {
-    res.resume();
-    fn = common.mustCall(createConnectionAsync);
+const server = http
+  .createServer(
+    common.mustCall(function(req, res) {
+      res.end();
+    }, 4)
+  )
+  .listen(0, '127.0.0.1', function() {
+    let fn = common.mustCall(createConnection);
     http.get({ createConnection: fn }, function(res) {
       res.resume();
-      fn = common.mustCall(createConnectionBoth1);
+      fn = common.mustCall(createConnectionAsync);
       http.get({ createConnection: fn }, function(res) {
         res.resume();
-        fn = common.mustCall(createConnectionBoth2);
+        fn = common.mustCall(createConnectionBoth1);
         http.get({ createConnection: fn }, function(res) {
           res.resume();
-          fn = common.mustCall(createConnectionError);
+          fn = common.mustCall(createConnectionBoth2);
           http.get({ createConnection: fn }, function(res) {
-            assert.fail('Unexpected response callback');
-          }).on('error', common.mustCall(function(err) {
-            assert.strictEqual(err.message, 'Could not create socket');
-            server.close();
-          }));
+            res.resume();
+            fn = common.mustCall(createConnectionError);
+            http
+              .get({ createConnection: fn }, function(res) {
+                assert.fail('Unexpected response callback');
+              })
+              .on(
+                'error',
+                common.mustCall(function(err) {
+                  assert.strictEqual(err.message, 'Could not create socket');
+                  server.close();
+                })
+              );
+          });
         });
       });
     });
   });
-});
 
 function createConnection() {
   return net.createConnection(server.address().port, '127.0.0.1');
diff --git a/test/parallel/test-http-date-header.js b/test/parallel/test-http-date-header.js
index b389e33664738c..7613ef270d3947 100644
--- a/test/parallel/test-http-date-header.js
+++ b/test/parallel/test-http-date-header.js
@@ -27,8 +27,7 @@ const http = require('http');
 const testResBody = 'other stuff!\n';
 
 const server = http.createServer((req, res) => {
-  assert.ok(!('date' in req.headers),
-            'Request headers contained a Date.');
+  assert.ok(!('date' in req.headers), 'Request headers contained a Date.');
   res.writeHead(200, {
     'Content-Type': 'text/plain'
   });
@@ -36,7 +35,6 @@ const server = http.createServer((req, res) => {
 });
 server.listen(0);
 
-
 server.addListener('listening', () => {
   const options = {
     port: server.address().port,
@@ -44,8 +42,7 @@ server.addListener('listening', () => {
     method: 'GET'
   };
   const req = http.request(options, (res) => {
-    assert.ok('date' in res.headers,
-              'Response headers didn\'t contain a Date.');
+    assert.ok('date' in res.headers, "Response headers didn't contain a Date.");
     res.addListener('end', () => {
       server.close();
       process.exit();
diff --git a/test/parallel/test-http-debug.js b/test/parallel/test-http-debug.js
index 4b1c093c663974..87907804079f40 100644
--- a/test/parallel/test-http-debug.js
+++ b/test/parallel/test-http-debug.js
@@ -6,9 +6,15 @@ const child_process = require('child_process');
 const path = require('path');
 
 process.env.NODE_DEBUG = 'http';
-const { stderr } = child_process.spawnSync(process.execPath, [
-  path.resolve(__dirname, 'test-http-conn-reset.js')
-], { encoding: 'utf8' });
+const { stderr } = child_process.spawnSync(
+  process.execPath,
+  [path.resolve(__dirname, 'test-http-conn-reset.js')],
+  { encoding: 'utf8' }
+);
 
-assert(stderr.match(/Setting the NODE_DEBUG environment variable to 'http' can expose sensitive data \(such as passwords, tokens and authentication headers\) in the resulting log\./),
-       stderr);
+assert(
+  stderr.match(
+    /Setting the NODE_DEBUG environment variable to 'http' can expose sensitive data \(such as passwords, tokens and authentication headers\) in the resulting log\./
+  ),
+  stderr
+);
diff --git a/test/parallel/test-http-default-encoding.js b/test/parallel/test-http-default-encoding.js
index 36d3f0a65244fe..e90fa48545c85a 100644
--- a/test/parallel/test-http-default-encoding.js
+++ b/test/parallel/test-http-default-encoding.js
@@ -29,28 +29,35 @@ let result = '';
 
 const server = http.Server((req, res) => {
   req.setEncoding('utf8');
-  req.on('data', (chunk) => {
-    result += chunk;
-  }).on('end', () => {
-    server.close();
-    res.writeHead(200);
-    res.end('hello world\n');
-  });
-
+  req
+    .on('data', (chunk) => {
+      result += chunk;
+    })
+    .on('end', () => {
+      server.close();
+      res.writeHead(200);
+      res.end('hello world\n');
+    });
 });
 
 server.listen(0, function() {
-  http.request({
-    port: this.address().port,
-    path: '/',
-    method: 'POST'
-  }, (res) => {
-    console.log(res.statusCode);
-    res.resume();
-  }).on('error', (e) => {
-    console.log(e.message);
-    process.exit(1);
-  }).end(expected);
+  http
+    .request(
+      {
+        port: this.address().port,
+        path: '/',
+        method: 'POST'
+      },
+      (res) => {
+        console.log(res.statusCode);
+        res.resume();
+      }
+    )
+    .on('error', (e) => {
+      console.log(e.message);
+      process.exit(1);
+    })
+    .end(expected);
 });
 
 process.on('exit', () => {
diff --git a/test/parallel/test-http-default-port.js b/test/parallel/test-http-default-port.js
index a5af439a8ec6c3..454141f3780c50 100644
--- a/test/parallel/test-http-default-port.js
+++ b/test/parallel/test-http-default-port.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const http = require('http');
@@ -39,22 +38,30 @@ for (const { mod, createServer } of [
   { mod: http, createServer: http.createServer },
   { mod: https, createServer: https.createServer.bind(null, options) }
 ]) {
-  const server = createServer(common.mustCall((req, res) => {
-    assert.strictEqual(req.headers.host, hostExpect);
-    assert.strictEqual(req.headers['x-port'], `${server.address().port}`);
-    res.writeHead(200);
-    res.end('ok');
-    server.close();
-  })).listen(0, common.mustCall(() => {
-    mod.globalAgent.defaultPort = server.address().port;
-    mod.get({
-      host: 'localhost',
-      rejectUnauthorized: false,
-      headers: {
-        'x-port': server.address().port
-      }
-    }, common.mustCall((res) => {
-      res.resume();
-    }));
-  }));
+  const server = createServer(
+    common.mustCall((req, res) => {
+      assert.strictEqual(req.headers.host, hostExpect);
+      assert.strictEqual(req.headers['x-port'], `${server.address().port}`);
+      res.writeHead(200);
+      res.end('ok');
+      server.close();
+    })
+  ).listen(
+    0,
+    common.mustCall(() => {
+      mod.globalAgent.defaultPort = server.address().port;
+      mod.get(
+        {
+          host: 'localhost',
+          rejectUnauthorized: false,
+          headers: {
+            'x-port': server.address().port
+          }
+        },
+        common.mustCall((res) => {
+          res.resume();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http-deprecated-urls.js b/test/parallel/test-http-deprecated-urls.js
index 5bb9f66ebe7126..a1d6538041031e 100644
--- a/test/parallel/test-http-deprecated-urls.js
+++ b/test/parallel/test-http-deprecated-urls.js
@@ -8,19 +8,21 @@ const http = require('http');
 const modules = { http };
 
 const deprecations = [
-  ['The provided URL http://[www.nodejs.org] is not a valid URL, and is supported ' +
-  'in the http module solely for compatibility.',
-   'DEP0109'],
+  [
+    'The provided URL http://[www.nodejs.org] is not a valid URL, and is supported ' +
+      'in the http module solely for compatibility.',
+    'DEP0109'
+  ]
 ];
 
 if (common.hasCrypto) {
   const https = require('https');
   modules.https = https;
-  deprecations.push(
-    ['The provided URL https://[www.nodejs.org] is not a valid URL, and is supported ' +
-    'in the https module solely for compatibility.',
-     'DEP0109'],
-  );
+  deprecations.push([
+    'The provided URL https://[www.nodejs.org] is not a valid URL, and is supported ' +
+      'in the https module solely for compatibility.',
+    'DEP0109'
+  ]);
 }
 
 common.expectWarning('DeprecationWarning', deprecations);
diff --git a/test/parallel/test-http-destroyed-socket-write2.js b/test/parallel/test-http-destroyed-socket-write2.js
index 48899415e37a4f..01cb5704a2b7b1 100644
--- a/test/parallel/test-http-destroyed-socket-write2.js
+++ b/test/parallel/test-http-destroyed-socket-write2.js
@@ -46,33 +46,34 @@ server.listen(0, function() {
     });
   }
 
-  req.on('error', common.mustCall(function(er) {
-    switch (er.code) {
-      // This is the expected case
-      case 'ECONNRESET':
-        break;
+  req.on(
+    'error',
+    common.mustCall(function(er) {
+      switch (er.code) {
+        // This is the expected case
+        case 'ECONNRESET':
+          break;
 
-      // On Windows, this sometimes manifests as ECONNABORTED
-      case 'ECONNABORTED':
-        break;
+        // On Windows, this sometimes manifests as ECONNABORTED
+        case 'ECONNABORTED':
+          break;
 
-      // This test is timing sensitive so an EPIPE is not out of the question.
-      // It should be infrequent, given the 50 ms timeout, but not impossible.
-      case 'EPIPE':
-        break;
+        // This test is timing sensitive so an EPIPE is not out of the question.
+        // It should be infrequent, given the 50 ms timeout, but not impossible.
+        case 'EPIPE':
+          break;
 
-      default:
-        // Write to a torn down client should RESET or ABORT
-        assert.strictEqual(er.code,
-                           'ECONNRESET');
-        break;
-    }
+        default:
+          // Write to a torn down client should RESET or ABORT
+          assert.strictEqual(er.code, 'ECONNRESET');
+          break;
+      }
 
-
-    assert.strictEqual(req.output.length, 0);
-    assert.strictEqual(req.outputEncodings.length, 0);
-    server.close();
-  }));
+      assert.strictEqual(req.output.length, 0);
+      assert.strictEqual(req.outputEncodings.length, 0);
+      server.close();
+    })
+  );
 
   req.on('response', function(res) {
     res.on('data', common.mustNotCall('Should not receive response data'));
diff --git a/test/parallel/test-http-dns-error.js b/test/parallel/test-http-dns-error.js
index e3d09a39d0e276..8c226d4f612c2d 100644
--- a/test/parallel/test-http-dns-error.js
+++ b/test/parallel/test-http-dns-error.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http = require('http');
@@ -33,36 +32,44 @@ const host = '*'.repeat(64);
 const MAX_TRIES = 5;
 
 let errCode = 'ENOTFOUND';
-if (common.isOpenBSD)
-  errCode = 'EAI_FAIL';
+if (common.isOpenBSD) errCode = 'EAI_FAIL';
 
 function tryGet(mod, tries) {
   // Bad host name should not throw an uncatchable exception.
   // Ensure that there is time to attach an error listener.
   const req = mod.get({ host: host, port: 42 }, common.mustNotCall());
-  req.on('error', common.mustCall(function(err) {
-    if (err.code === 'EAGAIN' && tries < MAX_TRIES) {
-      tryGet(mod, ++tries);
-      return;
-    }
-    assert.strictEqual(err.code, errCode);
-  }));
+  req.on(
+    'error',
+    common.mustCall(function(err) {
+      if (err.code === 'EAGAIN' && tries < MAX_TRIES) {
+        tryGet(mod, ++tries);
+        return;
+      }
+      assert.strictEqual(err.code, errCode);
+    })
+  );
   // http.get() called req1.end() for us
 }
 
 function tryRequest(mod, tries) {
-  const req = mod.request({
-    method: 'GET',
-    host: host,
-    port: 42
-  }, common.mustNotCall());
-  req.on('error', common.mustCall(function(err) {
-    if (err.code === 'EAGAIN' && tries < MAX_TRIES) {
-      tryRequest(mod, ++tries);
-      return;
-    }
-    assert.strictEqual(err.code, errCode);
-  }));
+  const req = mod.request(
+    {
+      method: 'GET',
+      host: host,
+      port: 42
+    },
+    common.mustNotCall()
+  );
+  req.on(
+    'error',
+    common.mustCall(function(err) {
+      if (err.code === 'EAGAIN' && tries < MAX_TRIES) {
+        tryRequest(mod, ++tries);
+        return;
+      }
+      assert.strictEqual(err.code, errCode);
+    })
+  );
   req.end();
 }
 
diff --git a/test/parallel/test-http-double-content-length.js b/test/parallel/test-http-double-content-length.js
index 53f924d652dd75..2d4dddd6eeef49 100644
--- a/test/parallel/test-http-double-content-length.js
+++ b/test/parallel/test-http-double-content-length.js
@@ -8,19 +8,28 @@ const assert = require('assert');
 // should respond with a 400 Client Error when a double
 // Content-Length header is received.
 const server = http.createServer(common.mustNotCall());
-server.on('clientError', common.mustCall((err, socket) => {
-  assert(/^Parse Error/.test(err.message));
-  assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
-  socket.destroy();
-}));
+server.on(
+  'clientError',
+  common.mustCall((err, socket) => {
+    assert(/^Parse Error/.test(err.message));
+    assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
+    socket.destroy();
+  })
+);
 
 server.listen(0, () => {
-  const req = http.get({
-    port: server.address().port,
-    // Send two content-length header values.
-    headers: { 'Content-Length': [1, 2] }
-  }, common.mustNotCall('an error should have occurred'));
-  req.on('error', common.mustCall(() => {
-    server.close();
-  }));
+  const req = http.get(
+    {
+      port: server.address().port,
+      // Send two content-length header values.
+      headers: { 'Content-Length': [1, 2] }
+    },
+    common.mustNotCall('an error should have occurred')
+  );
+  req.on(
+    'error',
+    common.mustCall(() => {
+      server.close();
+    })
+  );
 });
diff --git a/test/parallel/test-http-dump-req-when-res-ends.js b/test/parallel/test-http-dump-req-when-res-ends.js
index 718797fae1fe68..fc04fa76a61622 100644
--- a/test/parallel/test-http-dump-req-when-res-ends.js
+++ b/test/parallel/test-http-dump-req-when-res-ends.js
@@ -6,57 +6,71 @@ const fs = require('fs');
 const http = require('http');
 const { strictEqual } = require('assert');
 
-const server = http.createServer(mustCall(function(req, res) {
-  strictEqual(req.socket.listenerCount('data'), 1);
-  req.socket.once('data', mustCall(function() {
-    // Ensure that a chunk of data is received before calling `res.end()`.
-    res.end('hello world');
-  }));
-  // This checks if the request gets dumped
-  // resume will be triggered by res.end().
-  req.on('resume', mustCall(function() {
-    // There is no 'data' event handler anymore
-    // it gets automatically removed when dumping the request.
-    strictEqual(req.listenerCount('data'), 0);
-    req.on('data', mustCall());
-  }));
-
-  // We explicitly pause the stream
-  // so that the following on('data') does not cause
-  // a resume.
-  req.pause();
-  req.on('data', function() {});
-
-  // Start sending the response.
-  res.flushHeaders();
-}));
-
-server.listen(0, mustCall(function() {
-  const req = http.request({
-    method: 'POST',
-    port: server.address().port
-  });
-
-  // Send the http request without waiting
-  // for the body.
-  req.flushHeaders();
-
-  req.on('response', mustCall(function(res) {
-    // Pipe the body as soon as we get the headers of the
-    // response back.
-    fs.createReadStream(__filename).pipe(req);
-
-    res.resume();
-
-    // Wait for the response.
-    res.on('end', function() {
-      server.close();
+const server = http.createServer(
+  mustCall(function(req, res) {
+    strictEqual(req.socket.listenerCount('data'), 1);
+    req.socket.once(
+      'data',
+      mustCall(function() {
+        // Ensure that a chunk of data is received before calling `res.end()`.
+        res.end('hello world');
+      })
+    );
+    // This checks if the request gets dumped
+    // resume will be triggered by res.end().
+    req.on(
+      'resume',
+      mustCall(function() {
+        // There is no 'data' event handler anymore
+        // it gets automatically removed when dumping the request.
+        strictEqual(req.listenerCount('data'), 0);
+        req.on('data', mustCall());
+      })
+    );
+
+    // We explicitly pause the stream
+    // so that the following on('data') does not cause
+    // a resume.
+    req.pause();
+    req.on('data', function() {});
+
+    // Start sending the response.
+    res.flushHeaders();
+  })
+);
+
+server.listen(
+  0,
+  mustCall(function() {
+    const req = http.request({
+      method: 'POST',
+      port: server.address().port
+    });
+
+    // Send the http request without waiting
+    // for the body.
+    req.flushHeaders();
+
+    req.on(
+      'response',
+      mustCall(function(res) {
+        // Pipe the body as soon as we get the headers of the
+        // response back.
+        fs.createReadStream(__filename).pipe(req);
+
+        res.resume();
+
+        // Wait for the response.
+        res.on('end', function() {
+          server.close();
+        });
+      })
+    );
+
+    req.on('error', function() {
+      // An error can happen if there is some data still
+      // being sent, as the other side is calling .destroy()
+      // this is safe to ignore.
     });
-  }));
-
-  req.on('error', function() {
-    // An error can happen if there is some data still
-    // being sent, as the other side is calling .destroy()
-    // this is safe to ignore.
-  });
-}));
+  })
+);
diff --git a/test/parallel/test-http-end-throw-socket-handling.js b/test/parallel/test-http-end-throw-socket-handling.js
index 956096270ecc1b..330098f0605c3e 100644
--- a/test/parallel/test-http-end-throw-socket-handling.js
+++ b/test/parallel/test-http-end-throw-socket-handling.js
@@ -37,17 +37,23 @@ const server = http.createServer((req, res) => {
   res.end('ok');
 });
 
-server.listen(0, common.mustCall(() => {
-  for (let i = 0; i < 10; i++) {
-    const options = { port: server.address().port };
-    const req = http.request(options, (res) => {
-      res.resume();
-      res.on('end', common.mustCall(() => {
-        throw new Error('gleep glorp');
-      }));
-    });
-    req.end();
-  }
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    for (let i = 0; i < 10; i++) {
+      const options = { port: server.address().port };
+      const req = http.request(options, (res) => {
+        res.resume();
+        res.on(
+          'end',
+          common.mustCall(() => {
+            throw new Error('gleep glorp');
+          })
+        );
+      });
+      req.end();
+    }
+  })
+);
 
 process.on('uncaughtException', common.mustCall(10));
diff --git a/test/parallel/test-http-eof-on-connect.js b/test/parallel/test-http-eof-on-connect.js
index 5e885bb91a9daa..333510c14077b7 100644
--- a/test/parallel/test-http-eof-on-connect.js
+++ b/test/parallel/test-http-eof-on-connect.js
@@ -33,9 +33,12 @@ const server = http.createServer(common.mustNotCall());
 server.listen(0);
 
 server.on('listening', function() {
-  net.createConnection(this.address().port).on('connect', function() {
-    this.destroy();
-  }).on('close', function() {
-    server.close();
-  });
+  net
+    .createConnection(this.address().port)
+    .on('connect', function() {
+      this.destroy();
+    })
+    .on('close', function() {
+      server.close();
+    });
 });
diff --git a/test/parallel/test-http-expect-continue.js b/test/parallel/test-http-expect-continue.js
index 10bcb9d568ff35..c1708b9fcfde12 100644
--- a/test/parallel/test-http-expect-continue.js
+++ b/test/parallel/test-http-expect-continue.js
@@ -34,49 +34,68 @@ const handler = common.mustCall((req, res) => {
   console.error('Server sending full response...');
   res.writeHead(200, {
     'Content-Type': 'text/plain',
-    'ABCD': '1'
+    ABCD: '1'
   });
   res.end(test_res_body);
 });
 
 const server = http.createServer(common.mustNotCall());
-server.on('checkContinue', common.mustCall((req, res) => {
-  console.error('Server got Expect: 100-continue...');
-  res.writeContinue();
-  sent_continue = true;
-  setTimeout(function() {
-    handler(req, res);
-  }, 100);
-}));
+server.on(
+  'checkContinue',
+  common.mustCall((req, res) => {
+    console.error('Server got Expect: 100-continue...');
+    res.writeContinue();
+    sent_continue = true;
+    setTimeout(function() {
+      handler(req, res);
+    }, 100);
+  })
+);
 server.listen(0);
 
-
-server.on('listening', common.mustCall(() => {
-  const req = http.request({
-    port: server.address().port,
-    method: 'POST',
-    path: '/world',
-    headers: { 'Expect': '100-continue' }
-  });
-  console.error('Client sending request...');
-  let body = '';
-  req.on('continue', common.mustCall(() => {
-    console.error('Client got 100 Continue...');
-    got_continue = true;
-    req.end(test_req_body);
-  }));
-  req.on('response', common.mustCall((res) => {
-    assert.ok(got_continue, 'Full response received before 100 Continue');
-    assert.strictEqual(res.statusCode, 200,
-                       `Final status code was ${res.statusCode}, not 200.`);
-    res.setEncoding('utf8');
-    res.on('data', function(chunk) { body += chunk; });
-    res.on('end', common.mustCall(() => {
-      console.error('Got full response.');
-      assert.strictEqual(body, test_res_body);
-      assert.ok('abcd' in res.headers, 'Response headers missing.');
-      server.close();
-      process.exit();
-    }));
-  }));
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const req = http.request({
+      port: server.address().port,
+      method: 'POST',
+      path: '/world',
+      headers: { Expect: '100-continue' }
+    });
+    console.error('Client sending request...');
+    let body = '';
+    req.on(
+      'continue',
+      common.mustCall(() => {
+        console.error('Client got 100 Continue...');
+        got_continue = true;
+        req.end(test_req_body);
+      })
+    );
+    req.on(
+      'response',
+      common.mustCall((res) => {
+        assert.ok(got_continue, 'Full response received before 100 Continue');
+        assert.strictEqual(
+          res.statusCode,
+          200,
+          `Final status code was ${res.statusCode}, not 200.`
+        );
+        res.setEncoding('utf8');
+        res.on('data', function(chunk) {
+          body += chunk;
+        });
+        res.on(
+          'end',
+          common.mustCall(() => {
+            console.error('Got full response.');
+            assert.strictEqual(body, test_res_body);
+            assert.ok('abcd' in res.headers, 'Response headers missing.');
+            server.close();
+            process.exit();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-expect-handling.js b/test/parallel/test-http-expect-handling.js
index 11d2b6ecf4e614..532b6eb19d7c94 100644
--- a/test/parallel/test-http-expect-handling.js
+++ b/test/parallel/test-http-expect-handling.js
@@ -18,7 +18,7 @@ s.listen(0, nextTest);
 function nextTest() {
   const options = {
     port: s.address().port,
-    headers: { 'Expect': 'meoww' }
+    headers: { Expect: 'meoww' }
   };
 
   if (testIdx === tests.length) {
@@ -28,10 +28,13 @@ function nextTest() {
   const test = tests[testIdx];
 
   if (testIdx > 0) {
-    s.on('checkExpectation', common.mustCall((req, res) => {
-      res.statusCode = 417;
-      res.end();
-    }));
+    s.on(
+      'checkExpectation',
+      common.mustCall((req, res) => {
+        res.statusCode = 417;
+        res.end();
+      })
+    );
   }
 
   http.get(options, function(response) {
@@ -49,7 +52,6 @@ function nextTest() {
   });
 }
 
-
 process.on('exit', function() {
   assert.strictEqual(testsComplete, 2);
 });
diff --git a/test/parallel/test-http-extra-response.js b/test/parallel/test-http-extra-response.js
index 6d1a770487402d..cbd39a748d9fd0 100644
--- a/test/parallel/test-http-extra-response.js
+++ b/test/parallel/test-http-extra-response.js
@@ -31,15 +31,15 @@ const net = require('net');
 
 const body = 'hello world\r\n';
 const fullResponse =
-    'HTTP/1.1 500 Internal Server Error\r\n' +
-    `Content-Length: ${body.length}\r\n` +
-    'Content-Type: text/plain\r\n' +
-    'Date: Fri + 18 Feb 2011 06:22:45 GMT\r\n' +
-    'Host: 10.20.149.2\r\n' +
-    'Access-Control-Allow-Credentials: true\r\n' +
-    'Server: badly broken/0.1 (OS NAME)\r\n' +
-    '\r\n' +
-    body;
+  'HTTP/1.1 500 Internal Server Error\r\n' +
+  `Content-Length: ${body.length}\r\n` +
+  'Content-Type: text/plain\r\n' +
+  'Date: Fri + 18 Feb 2011 06:22:45 GMT\r\n' +
+  'Host: 10.20.149.2\r\n' +
+  'Access-Control-Allow-Credentials: true\r\n' +
+  'Server: badly broken/0.1 (OS NAME)\r\n' +
+  '\r\n' +
+  body;
 
 const server = net.createServer(function(socket) {
   let postBody = '';
@@ -60,21 +60,29 @@ const server = net.createServer(function(socket) {
   });
 });
 
+server.listen(
+  0,
+  common.mustCall(function() {
+    http.get(
+      { port: this.address().port },
+      common.mustCall(function(res) {
+        let buffer = '';
+        console.log(`Got res code: ${res.statusCode}`);
 
-server.listen(0, common.mustCall(function() {
-  http.get({ port: this.address().port }, common.mustCall(function(res) {
-    let buffer = '';
-    console.log(`Got res code: ${res.statusCode}`);
+        res.setEncoding('utf8');
+        res.on('data', function(chunk) {
+          buffer += chunk;
+        });
 
-    res.setEncoding('utf8');
-    res.on('data', function(chunk) {
-      buffer += chunk;
-    });
-
-    res.on('end', common.mustCall(function() {
-      console.log(`Response ended, read ${buffer.length} bytes`);
-      assert.strictEqual(body, buffer);
-      server.close();
-    }));
-  }));
-}));
+        res.on(
+          'end',
+          common.mustCall(function() {
+            console.log(`Response ended, read ${buffer.length} bytes`);
+            assert.strictEqual(body, buffer);
+            server.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-flush-headers.js b/test/parallel/test-http-flush-headers.js
index 88e8bddaed9e54..453f73af10c152 100644
--- a/test/parallel/test-http-flush-headers.js
+++ b/test/parallel/test-http-flush-headers.js
@@ -13,7 +13,7 @@ server.listen(0, '127.0.0.1', function() {
   const req = http.request({
     method: 'GET',
     host: '127.0.0.1',
-    port: this.address().port,
+    port: this.address().port
   });
   req.setHeader('foo', 'bar');
   req.flushHeaders();
diff --git a/test/parallel/test-http-flush-response-headers.js b/test/parallel/test-http-flush-response-headers.js
index 0f0a1387b56733..8e047fc691967d 100644
--- a/test/parallel/test-http-flush-response-headers.js
+++ b/test/parallel/test-http-flush-response-headers.js
@@ -6,16 +6,19 @@ const http = require('http');
 const server = http.createServer();
 
 server.on('request', function(req, res) {
-  res.writeHead(200, { 'foo': 'bar' });
+  res.writeHead(200, { foo: 'bar' });
   res.flushHeaders();
   res.flushHeaders(); // Should be idempotent.
 });
 server.listen(0, common.localhostIPv4, function() {
-  const req = http.request({
-    method: 'GET',
-    host: common.localhostIPv4,
-    port: this.address().port,
-  }, onResponse);
+  const req = http.request(
+    {
+      method: 'GET',
+      host: common.localhostIPv4,
+      port: this.address().port
+    },
+    onResponse
+  );
 
   req.end();
 
diff --git a/test/parallel/test-http-flush.js b/test/parallel/test-http-flush.js
index 24f43d5efecfa4..686ddb53985631 100644
--- a/test/parallel/test-http-flush.js
+++ b/test/parallel/test-http-flush.js
@@ -23,15 +23,17 @@
 require('../common');
 const http = require('http');
 
-http.createServer(function(req, res) {
-  res.end('ok');
-  this.close();
-}).listen(0, '127.0.0.1', function() {
-  const req = http.request({
-    method: 'POST',
-    host: '127.0.0.1',
-    port: this.address().port,
+http
+  .createServer(function(req, res) {
+    res.end('ok');
+    this.close();
+  })
+  .listen(0, '127.0.0.1', function() {
+    const req = http.request({
+      method: 'POST',
+      host: '127.0.0.1',
+      port: this.address().port
+    });
+    req.flush(); // Flush the request headers.
+    req.flush(); // Should be idempotent.
   });
-  req.flush();  // Flush the request headers.
-  req.flush();  // Should be idempotent.
-});
diff --git a/test/parallel/test-http-full-response.js b/test/parallel/test-http-full-response.js
index d08e091ebd9808..e070b37ab9e116 100644
--- a/test/parallel/test-http-full-response.js
+++ b/test/parallel/test-http-full-response.js
@@ -65,17 +65,29 @@ function runAb(opts, callback) {
   });
 }
 
-server.listen(0, common.mustCall(function() {
-  runAb('-c 1 -n 10', common.mustCall(function() {
-    console.log('-c 1 -n 10 okay');
+server.listen(
+  0,
+  common.mustCall(function() {
+    runAb(
+      '-c 1 -n 10',
+      common.mustCall(function() {
+        console.log('-c 1 -n 10 okay');
 
-    runAb('-c 1 -n 100', common.mustCall(function() {
-      console.log('-c 1 -n 100 okay');
+        runAb(
+          '-c 1 -n 100',
+          common.mustCall(function() {
+            console.log('-c 1 -n 100 okay');
 
-      runAb('-c 1 -n 1000', common.mustCall(function() {
-        console.log('-c 1 -n 1000 okay');
-        server.close();
-      }));
-    }));
-  }));
-}));
+            runAb(
+              '-c 1 -n 1000',
+              common.mustCall(function() {
+                console.log('-c 1 -n 1000 okay');
+                server.close();
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-generic-streams.js b/test/parallel/test-http-generic-streams.js
index bc28d1fcd4632b..c30892dec9bd12 100644
--- a/test/parallel/test-http-generic-streams.js
+++ b/test/parallel/test-http-generic-streams.js
@@ -7,49 +7,65 @@ const MakeDuplexPair = require('../common/duplexpair');
 // Test 1: Simple HTTP test, no keep-alive.
 {
   const testData = 'Hello, World!\n';
-  const server = http.createServer(common.mustCall((req, res) => {
-    res.statusCode = 200;
-    res.setHeader('Content-Type', 'text/plain');
-    res.end(testData);
-  }));
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      res.statusCode = 200;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end(testData);
+    })
+  );
 
   const { clientSide, serverSide } = MakeDuplexPair();
   server.emit('connection', serverSide);
 
-  const req = http.request({
-    createConnection: common.mustCall(() => clientSide)
-  }, common.mustCall((res) => {
-    res.setEncoding('utf8');
-    res.on('data', common.mustCall((data) => {
-      assert.strictEqual(data, testData);
-    }));
-  }));
+  const req = http.request(
+    {
+      createConnection: common.mustCall(() => clientSide)
+    },
+    common.mustCall((res) => {
+      res.setEncoding('utf8');
+      res.on(
+        'data',
+        common.mustCall((data) => {
+          assert.strictEqual(data, testData);
+        })
+      );
+    })
+  );
   req.end();
 }
 
 // Test 2: Keep-alive for 2 requests.
 {
   const testData = 'Hello, World!\n';
-  const server = http.createServer(common.mustCall((req, res) => {
-    res.statusCode = 200;
-    res.setHeader('Content-Type', 'text/plain');
-    res.end(testData);
-  }, 2));
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      res.statusCode = 200;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end(testData);
+    }, 2)
+  );
 
   const { clientSide, serverSide } = MakeDuplexPair();
   server.emit('connection', serverSide);
 
   function doRequest(cb) {
-    const req = http.request({
-      createConnection: common.mustCall(() => clientSide),
-      headers: { Connection: 'keep-alive' }
-    }, common.mustCall((res) => {
-      res.setEncoding('utf8');
-      res.on('data', common.mustCall((data) => {
-        assert.strictEqual(data, testData);
-      }));
-      res.on('end', common.mustCall(cb));
-    }));
+    const req = http.request(
+      {
+        createConnection: common.mustCall(() => clientSide),
+        headers: { Connection: 'keep-alive' }
+      },
+      common.mustCall((res) => {
+        res.setEncoding('utf8');
+        res.on(
+          'data',
+          common.mustCall((data) => {
+            assert.strictEqual(data, testData);
+          })
+        );
+        res.on('end', common.mustCall(cb));
+      })
+    );
     req.shouldKeepAlive = true;
     req.end();
   }
diff --git a/test/parallel/test-http-get-pipeline-problem.js b/test/parallel/test-http-get-pipeline-problem.js
index b8b11e7e77c29a..4302aaf0688009 100644
--- a/test/parallel/test-http-get-pipeline-problem.js
+++ b/test/parallel/test-http-get-pipeline-problem.js
@@ -40,23 +40,25 @@ const image = fixtures.readSync('/person.jpg');
 console.log(`image.length = ${image.length}`);
 
 const total = 10;
-const responseCountdown = new Countdown(total, common.mustCall(() => {
-  checkFiles();
-  server.close();
-}));
+const responseCountdown = new Countdown(
+  total,
+  common.mustCall(() => {
+    checkFiles();
+    server.close();
+  })
+);
 
 const server = http.Server(function(req, res) {
   setTimeout(function() {
     res.writeHead(200, {
       'content-type': 'image/jpeg',
-      'connection': 'close',
+      connection: 'close',
       'content-length': image.length
     });
     res.end(image);
   }, 1);
 });
 
-
 server.listen(0, function() {
   for (let i = 0; i < total; i++) {
     (function() {
@@ -67,19 +69,21 @@ server.listen(0, function() {
         headers: { connection: 'close' }
       };
 
-      http.get(opts, function(res) {
-        console.error(`recv ${x}`);
-        const s = fs.createWriteStream(`${tmpdir.path}/${x}.jpg`);
-        res.pipe(s);
+      http
+        .get(opts, function(res) {
+          console.error(`recv ${x}`);
+          const s = fs.createWriteStream(`${tmpdir.path}/${x}.jpg`);
+          res.pipe(s);
 
-        s.on('finish', function() {
-          console.error(`done ${x}`);
-          responseCountdown.dec();
+          s.on('finish', function() {
+            console.error(`done ${x}`);
+            responseCountdown.dec();
+          });
+        })
+        .on('error', function(e) {
+          console.error('error! ', e.message);
+          throw e;
         });
-      }).on('error', function(e) {
-        console.error('error! ', e.message);
-        throw e;
-      });
     })();
   }
 });
@@ -94,7 +98,9 @@ function checkFiles() {
     assert.ok(files.includes(fn), `couldn't find '${fn}'`);
     const stat = fs.statSync(`${tmpdir.path}/${fn}`);
     assert.strictEqual(
-      image.length, stat.size,
-      `size doesn't match on '${fn}'. Got ${stat.size} bytes`);
+      image.length,
+      stat.size,
+      `size doesn't match on '${fn}'. Got ${stat.size} bytes`
+    );
   }
 }
diff --git a/test/parallel/test-http-head-request.js b/test/parallel/test-http-head-request.js
index 26d490d357dcfd..525647de82e32a 100644
--- a/test/parallel/test-http-head-request.js
+++ b/test/parallel/test-http-head-request.js
@@ -33,20 +33,29 @@ function test(headers) {
     server.close();
   });
 
-  server.listen(0, common.mustCall(function() {
-    const request = http.request({
-      port: this.address().port,
-      method: 'HEAD',
-      path: '/'
-    }, common.mustCall(function(response) {
-      console.error('response start');
-      response.on('end', common.mustCall(function() {
-        console.error('response end');
-      }));
-      response.resume();
-    }));
-    request.end();
-  }));
+  server.listen(
+    0,
+    common.mustCall(function() {
+      const request = http.request(
+        {
+          port: this.address().port,
+          method: 'HEAD',
+          path: '/'
+        },
+        common.mustCall(function(response) {
+          console.error('response start');
+          response.on(
+            'end',
+            common.mustCall(function() {
+              console.error('response end');
+            })
+          );
+          response.resume();
+        })
+      );
+      request.end();
+    })
+  );
 }
 
 test({
diff --git a/test/parallel/test-http-head-response-has-no-body-end.js b/test/parallel/test-http-head-response-has-no-body-end.js
index 824a1bafe3a5e3..d700b397422219 100644
--- a/test/parallel/test-http-head-response-has-no-body-end.js
+++ b/test/parallel/test-http-head-response-has-no-body-end.js
@@ -33,16 +33,25 @@ const server = http.createServer(function(req, res) {
 });
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const req = http.request({
-    port: this.address().port,
-    method: 'HEAD',
-    path: '/'
-  }, common.mustCall(function(res) {
-    res.on('end', common.mustCall(function() {
-      server.close();
-    }));
-    res.resume();
-  }));
-  req.end();
-}));
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const req = http.request(
+      {
+        port: this.address().port,
+        method: 'HEAD',
+        path: '/'
+      },
+      common.mustCall(function(res) {
+        res.on(
+          'end',
+          common.mustCall(function() {
+            server.close();
+          })
+        );
+        res.resume();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http-head-response-has-no-body.js b/test/parallel/test-http-head-response-has-no-body.js
index bd96d7161b7a4f..986296befe8d62 100644
--- a/test/parallel/test-http-head-response-has-no-body.js
+++ b/test/parallel/test-http-head-response-has-no-body.js
@@ -33,16 +33,25 @@ const server = http.createServer(function(req, res) {
 });
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const req = http.request({
-    port: this.address().port,
-    method: 'HEAD',
-    path: '/'
-  }, common.mustCall(function(res) {
-    res.on('end', common.mustCall(function() {
-      server.close();
-    }));
-    res.resume();
-  }));
-  req.end();
-}));
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const req = http.request(
+      {
+        port: this.address().port,
+        method: 'HEAD',
+        path: '/'
+      },
+      common.mustCall(function(res) {
+        res.on(
+          'end',
+          common.mustCall(function() {
+            server.close();
+          })
+        );
+        res.resume();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http-header-obstext.js b/test/parallel/test-http-header-obstext.js
index 23aea246d782f7..6a4e1adecbd075 100644
--- a/test/parallel/test-http-header-obstext.js
+++ b/test/parallel/test-http-header-obstext.js
@@ -7,15 +7,20 @@ const common = require('../common');
 const http = require('http');
 const assert = require('assert');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end('ok');
-}));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.end('ok');
+  })
+);
 server.listen(0, () => {
-  http.get({
-    port: server.address().port,
-    headers: { 'Test': 'Düsseldorf' }
-  }, common.mustCall((res) => {
-    assert.strictEqual(res.statusCode, 200);
-    server.close();
-  }));
+  http.get(
+    {
+      port: server.address().port,
+      headers: { Test: 'Düsseldorf' }
+    },
+    common.mustCall((res) => {
+      assert.strictEqual(res.statusCode, 200);
+      server.close();
+    })
+  );
 });
diff --git a/test/parallel/test-http-hex-write.js b/test/parallel/test-http-hex-write.js
index a3cbec6b36c0ad..f64cfc48e38fed 100644
--- a/test/parallel/test-http-hex-write.js
+++ b/test/parallel/test-http-hex-write.js
@@ -27,23 +27,36 @@ const http = require('http');
 
 const expect = 'hex\nutf8\n';
 
-http.createServer(function(q, s) {
-  s.setHeader('content-length', expect.length);
-  s.write('6865780a', 'hex');
-  s.write('utf8\n');
-  s.end();
-  this.close();
-}).listen(0, common.mustCall(function() {
-  http.request({ port: this.address().port })
-    .on('response', common.mustCall(function(res) {
-      let data = '';
+http
+  .createServer(function(q, s) {
+    s.setHeader('content-length', expect.length);
+    s.write('6865780a', 'hex');
+    s.write('utf8\n');
+    s.end();
+    this.close();
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      http
+        .request({ port: this.address().port })
+        .on(
+          'response',
+          common.mustCall(function(res) {
+            let data = '';
 
-      res.setEncoding('ascii');
-      res.on('data', function(c) {
-        data += c;
-      });
-      res.on('end', common.mustCall(function() {
-        assert.strictEqual(data, expect);
-      }));
-    })).end();
-}));
+            res.setEncoding('ascii');
+            res.on('data', function(c) {
+              data += c;
+            });
+            res.on(
+              'end',
+              common.mustCall(function() {
+                assert.strictEqual(data, expect);
+              })
+            );
+          })
+        )
+        .end();
+    })
+  );
diff --git a/test/parallel/test-http-highwatermark.js b/test/parallel/test-http-highwatermark.js
index 79d9c46a558b60..a18f828f341757 100644
--- a/test/parallel/test-http-highwatermark.js
+++ b/test/parallel/test-http-highwatermark.js
@@ -11,42 +11,55 @@ const http = require('http');
 
 let requestReceived = 0;
 
-const server = http.createServer(function(req, res) {
-  const id = ++requestReceived;
-  const enoughToDrain = req.connection.writableHighWaterMark;
-  const body = 'x'.repeat(enoughToDrain * 100);
+const server = http
+  .createServer(function(req, res) {
+    const id = ++requestReceived;
+    const enoughToDrain = req.connection.writableHighWaterMark;
+    const body = 'x'.repeat(enoughToDrain * 100);
 
-  if (id === 1) {
-    // Case of needParse = false
-    req.connection.once('pause', common.mustCall(() => {
-      assert(req.connection._paused, '_paused must be true because it exceeds' +
-                                     'highWaterMark by second request');
-    }));
-  } else {
-    // Case of needParse = true
-    const resume = req.connection.parser.resume.bind(req.connection.parser);
-    req.connection.parser.resume = common.mustCall((...args) => {
-      const paused = req.connection._paused;
-      assert(!paused, '_paused must be false because it become false by ' +
-                      'socketOnDrain when outgoingData falls below ' +
-                      'highWaterMark');
-      return resume(...args);
+    if (id === 1) {
+      // Case of needParse = false
+      req.connection.once(
+        'pause',
+        common.mustCall(() => {
+          assert(
+            req.connection._paused,
+            '_paused must be true because it exceeds' +
+              'highWaterMark by second request'
+          );
+        })
+      );
+    } else {
+      // Case of needParse = true
+      const resume = req.connection.parser.resume.bind(req.connection.parser);
+      req.connection.parser.resume = common.mustCall((...args) => {
+        const paused = req.connection._paused;
+        assert(
+          !paused,
+          '_paused must be false because it become false by ' +
+            'socketOnDrain when outgoingData falls below ' +
+            'highWaterMark'
+        );
+        return resume(...args);
+      });
+    }
+    assert(
+      !res.write(body),
+      'res.write must return false because it will ' +
+        'exceed highWaterMark on this call'
+    );
+    res.end();
+  })
+  .on('listening', () => {
+    const c = net.createConnection(server.address().port, () => {
+      c.write('GET / HTTP/1.1\r\n\r\n');
+      c.write('GET / HTTP/1.1\r\n\r\n', () => setImmediate(() => c.resume()));
+      c.end();
     });
-  }
-  assert(!res.write(body), 'res.write must return false because it will ' +
-                           'exceed highWaterMark on this call');
-  res.end();
-}).on('listening', () => {
-  const c = net.createConnection(server.address().port, () => {
-    c.write('GET / HTTP/1.1\r\n\r\n');
-    c.write('GET / HTTP/1.1\r\n\r\n',
-            () => setImmediate(() => c.resume()));
-    c.end();
-  });
 
-  c.on('end', () => {
-    server.close();
+    c.on('end', () => {
+      server.close();
+    });
   });
-});
 
 server.listen(0);
diff --git a/test/parallel/test-http-host-header-ipv6-fail.js b/test/parallel/test-http-host-header-ipv6-fail.js
index 0c56afad7f28e5..f3023b7c11afd1 100644
--- a/test/parallel/test-http-host-header-ipv6-fail.js
+++ b/test/parallel/test-http-host-header-ipv6-fail.js
@@ -26,17 +26,21 @@ function createLocalConnection(options) {
   return net.createConnection(options);
 }
 
-http.createServer(common.mustCall(function(req, res) {
-  this.requests = this.requests || 0;
-  assert.strictEqual(req.headers.host, req.headers.expectedhost);
-  res.end();
-  if (++this.requests === requests.length)
-    this.close();
-}, requests.length)).listen(0, function() {
-  const address = this.address();
-  for (let i = 0; i < requests.length; ++i) {
-    requests[i].createConnection =
-      common.mustCall(createLocalConnection.bind(address));
-    http.get(requests[i]);
-  }
-});
+http
+  .createServer(
+    common.mustCall(function(req, res) {
+      this.requests = this.requests || 0;
+      assert.strictEqual(req.headers.host, req.headers.expectedhost);
+      res.end();
+      if (++this.requests === requests.length) this.close();
+    }, requests.length)
+  )
+  .listen(0, function() {
+    const address = this.address();
+    for (let i = 0; i < requests.length; ++i) {
+      requests[i].createConnection = common.mustCall(
+        createLocalConnection.bind(address)
+      );
+      http.get(requests[i]);
+    }
+  });
diff --git a/test/parallel/test-http-host-headers.js b/test/parallel/test-http-host-headers.js
index 97d200ade1bb6a..4b5ce0ae5c0774 100644
--- a/test/parallel/test-http-host-headers.js
+++ b/test/parallel/test-http-host-headers.js
@@ -30,8 +30,10 @@ function reqHandler(req, res) {
     assert.strictEqual(req.headers.host, undefined);
   } else {
     assert.strictEqual(
-      req.headers.host, `localhost:${this.address().port}`,
-      `Wrong host header for req[${req.url}]: ${req.headers.host}`);
+      req.headers.host,
+      `localhost:${this.address().port}`,
+      `Wrong host header for req[${req.url}]: ${req.headers.host}`
+    );
   }
   res.writeHead(200, {});
   res.end('ok');
@@ -40,7 +42,6 @@ function reqHandler(req, res) {
 testHttp();
 
 function testHttp() {
-
   let counter = 0;
 
   function cb(res) {
@@ -53,44 +54,73 @@ function testHttp() {
 
   httpServer.listen(0, (er) => {
     assert.ifError(er);
-    http.get({
-      method: 'GET',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: httpServer.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', common.mustNotCall());
+    http
+      .get(
+        {
+          method: 'GET',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: httpServer.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', common.mustNotCall());
 
-    http.request({
-      method: 'GET',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: httpServer.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', common.mustNotCall()).end();
+    http
+      .request(
+        {
+          method: 'GET',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: httpServer.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', common.mustNotCall())
+      .end();
 
-    http.request({
-      method: 'POST',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: httpServer.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', common.mustNotCall()).end();
+    http
+      .request(
+        {
+          method: 'POST',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: httpServer.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', common.mustNotCall())
+      .end();
 
-    http.request({
-      method: 'PUT',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: httpServer.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', common.mustNotCall()).end();
+    http
+      .request(
+        {
+          method: 'PUT',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: httpServer.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', common.mustNotCall())
+      .end();
 
-    http.request({
-      method: 'DELETE',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: httpServer.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', common.mustNotCall()).end();
+    http
+      .request(
+        {
+          method: 'DELETE',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: httpServer.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', common.mustNotCall())
+      .end();
   });
 }
diff --git a/test/parallel/test-http-hostname-typechecking.js b/test/parallel/test-http-hostname-typechecking.js
index 72440391fa2938..77960b329eddf3 100644
--- a/test/parallel/test-http-hostname-typechecking.js
+++ b/test/parallel/test-http-hostname-typechecking.js
@@ -8,33 +8,35 @@ const http = require('http');
 const vals = [{}, [], NaN, Infinity, -Infinity, true, false, 1, 0, new Date()];
 
 vals.forEach((v) => {
-  common.expectsError(
-    () => http.request({ hostname: v }),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "options.hostname" property must be one of ' +
-               'type string, undefined, or null. ' +
-               `Received type ${typeof v}`
-    }
-  );
+  common.expectsError(() => http.request({ hostname: v }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "options.hostname" property must be one of ' +
+      'type string, undefined, or null. ' +
+      `Received type ${typeof v}`
+  });
 
-  common.expectsError(
-    () => http.request({ host: v }),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "options.host" property must be one of ' +
-               'type string, undefined, or null. ' +
-               `Received type ${typeof v}`
-    }
-  );
+  common.expectsError(() => http.request({ host: v }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "options.host" property must be one of ' +
+      'type string, undefined, or null. ' +
+      `Received type ${typeof v}`
+  });
 });
 
 // These values are OK and should not throw synchronously.
 // Only testing for 'hostname' validation so ignore connection errors.
 const dontCare = () => {};
 ['', undefined, null].forEach((v) => {
-  http.request({ hostname: v }).on('error', dontCare).end();
-  http.request({ host: v }).on('error', dontCare).end();
+  http
+    .request({ hostname: v })
+    .on('error', dontCare)
+    .end();
+  http
+    .request({ host: v })
+    .on('error', dontCare)
+    .end();
 });
diff --git a/test/parallel/test-http-incoming-matchKnownFields.js b/test/parallel/test-http-incoming-matchKnownFields.js
index 14ba8acd021f68..947a288679219c 100644
--- a/test/parallel/test-http-incoming-matchKnownFields.js
+++ b/test/parallel/test-http-incoming-matchKnownFields.js
@@ -8,8 +8,7 @@ function checkDest(field, result, value) {
 
   const incomingMessage = new IncomingMessage(field);
   // dest is changed by IncomingMessage._addHeaderLine
-  if (value)
-    incomingMessage._addHeaderLine(field, 'test', dest);
+  if (value) incomingMessage._addHeaderLine(field, 'test', dest);
   incomingMessage._addHeaderLine(field, value, dest);
   assert.deepStrictEqual(dest, result);
 }
diff --git a/test/parallel/test-http-incoming-pipelined-socket-destroy.js b/test/parallel/test-http-incoming-pipelined-socket-destroy.js
index 8e63bdb8a9bbd2..f5461abf6a1076 100644
--- a/test/parallel/test-http-incoming-pipelined-socket-destroy.js
+++ b/test/parallel/test-http-incoming-pipelined-socket-destroy.js
@@ -26,59 +26,66 @@ const Countdown = require('../common/countdown');
 const http = require('http');
 const net = require('net');
 
-const seeds = [ 3, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 ];
+const seeds = [3, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4];
 const countdown = new Countdown(seeds.length, () => server.close());
 
 // Set up some timing issues where sockets can be destroyed
 // via either the req or res.
-const server = http.createServer(common.mustCall(function(req, res) {
-  switch (req.url) {
-    case '/1':
-      return setImmediate(function() {
-        req.socket.destroy();
-        server.emit('requestDone');
-      });
-
-    case '/2':
-      return process.nextTick(function() {
-        res.destroy();
-        server.emit('requestDone');
-      });
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    switch (req.url) {
+      case '/1':
+        return setImmediate(function() {
+          req.socket.destroy();
+          server.emit('requestDone');
+        });
 
-    // in one case, actually send a response in 2 chunks
-    case '/3':
-      res.write('hello ');
-      return setImmediate(function() {
-        res.end('world!');
-        server.emit('requestDone');
-      });
+      case '/2':
+        return process.nextTick(function() {
+          res.destroy();
+          server.emit('requestDone');
+        });
 
-    default:
-      res.destroy();
-      server.emit('requestDone');
-  }
-}, seeds.length));
+      // in one case, actually send a response in 2 chunks
+      case '/3':
+        res.write('hello ');
+        return setImmediate(function() {
+          res.end('world!');
+          server.emit('requestDone');
+        });
 
+      default:
+        res.destroy();
+        server.emit('requestDone');
+    }
+  }, seeds.length)
+);
 
 // Make a bunch of requests pipelined on the same socket
 function generator(seeds) {
   const port = server.address().port;
-  return seeds.map(function(r) {
-    return `GET /${r} HTTP/1.1\r\n` +
-           `Host: localhost:${port}\r\n` +
-           '\r\n' +
-           '\r\n';
-  }).join('');
+  return seeds
+    .map(function(r) {
+      return (
+        `GET /${r} HTTP/1.1\r\n` +
+        `Host: localhost:${port}\r\n` +
+        '\r\n' +
+        '\r\n'
+      );
+    })
+    .join('');
 }
 
+server.listen(
+  0,
+  common.mustCall(function() {
+    const client = net.connect({ port: this.address().port });
+    server.on('requestDone', function() {
+      countdown.dec();
+    });
 
-server.listen(0, common.mustCall(function() {
-  const client = net.connect({ port: this.address().port });
-  server.on('requestDone', function() {
-    countdown.dec();
-  });
-
-  // immediately write the pipelined requests.
-  // Some of these will not have a socket to destroy!
-  client.write(generator(seeds));
-}));
+    // immediately write the pipelined requests.
+    // Some of these will not have a socket to destroy!
+    client.write(generator(seeds));
+  })
+);
diff --git a/test/parallel/test-http-information-processing.js b/test/parallel/test-http-information-processing.js
index 94554c2109d433..9ca992944e05f6 100644
--- a/test/parallel/test-http-information-processing.js
+++ b/test/parallel/test-http-information-processing.js
@@ -15,7 +15,7 @@ const server = http.createServer((req, res) => {
   console.error('Server sending full response...');
   res.writeHead(200, {
     'Content-Type': 'text/plain',
-    'ABCD': '1'
+    ABCD: '1'
   });
   res.end(test_res_body);
 });
@@ -38,10 +38,15 @@ server.listen(0, function() {
   req.on('response', function(res) {
     // Check that all 102 Processing received before full response received.
     assert.strictEqual(countdown.remaining, 1);
-    assert.strictEqual(res.statusCode, 200,
-                       `Final status code was ${res.statusCode}, not 200.`);
+    assert.strictEqual(
+      res.statusCode,
+      200,
+      `Final status code was ${res.statusCode}, not 200.`
+    );
     res.setEncoding('utf8');
-    res.on('data', function(chunk) { body += chunk; });
+    res.on('data', function(chunk) {
+      body += chunk;
+    });
     res.on('end', function() {
       console.error('Got full response.');
       assert.strictEqual(body, test_res_body);
diff --git a/test/parallel/test-http-invalid-path-chars.js b/test/parallel/test-http-invalid-path-chars.js
index c1d0baa62c3e9b..dd1ed83d7a3a3b 100644
--- a/test/parallel/test-http-invalid-path-chars.js
+++ b/test/parallel/test-http-invalid-path-chars.js
@@ -4,11 +4,14 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const expectedError = common.expectsError({
-  code: 'ERR_UNESCAPED_CHARACTERS',
-  type: TypeError,
-  message: 'Request path contains unescaped characters'
-}, 1320);
+const expectedError = common.expectsError(
+  {
+    code: 'ERR_UNESCAPED_CHARACTERS',
+    type: TypeError,
+    message: 'Request path contains unescaped characters'
+  },
+  1320
+);
 const theExperimentallyDeterminedNumber = 39;
 
 function fail(path) {
diff --git a/test/parallel/test-http-invalid-urls.js b/test/parallel/test-http-invalid-urls.js
index 7c9f67c4734810..e5b434c3b70e9a 100644
--- a/test/parallel/test-http-invalid-urls.js
+++ b/test/parallel/test-http-invalid-urls.js
@@ -5,7 +5,7 @@
 const common = require('../common');
 
 const http = require('http');
-const modules = { 'http': http };
+const modules = { http: http };
 
 if (common.hasCrypto) {
   const https = require('https');
@@ -18,7 +18,9 @@ function test(host) {
       const doNotCall = common.mustNotCall(
         `${module}.${fn} should not connect to ${host}`
       );
-      const throws = () => { modules[module][fn](host, doNotCall); };
+      const throws = () => {
+        modules[module][fn](host, doNotCall);
+      };
       common.expectsError(throws, {
         type: TypeError,
         code: 'ERR_INVALID_URL'
diff --git a/test/parallel/test-http-invalidheaderfield.js b/test/parallel/test-http-invalidheaderfield.js
index 01315ba69044a2..c37d318b7794ea 100644
--- a/test/parallel/test-http-invalidheaderfield.js
+++ b/test/parallel/test-http-invalidheaderfield.js
@@ -16,7 +16,6 @@ const server = http.createServer(function(req, res) {
   res.end('');
 });
 server.listen(0, function() {
-
   http.get({ port: this.address().port }, function() {
     ee.emit('done');
   });
@@ -38,7 +37,7 @@ server.listen(0, function() {
   // Should not throw.
   const options = {
     port: server.address().port,
-    headers: { 'testing_123': 123 }
+    headers: { testing_123: 123 }
   };
   http.get(options, function() {
     ee.emit('done');
diff --git a/test/parallel/test-http-invalidheaderfield2.js b/test/parallel/test-http-invalidheaderfield2.js
index 40415d9c368891..c0ff8403339317 100644
--- a/test/parallel/test-http-invalidheaderfield2.js
+++ b/test/parallel/test-http-invalidheaderfield2.js
@@ -22,14 +22,16 @@ const { _checkIsHttpToken, _checkInvalidHeaderChar } = require('_http_common');
   '$et-Cookie',
   '%%Test%%',
   'Test&123',
-  'It\'s_fun',
+  "It's_fun",
   '2*3',
   '4+2',
   '3.14159265359'
 ].forEach(function(str) {
   assert.strictEqual(
-    _checkIsHttpToken(str), true,
-    `_checkIsHttpToken(${inspect(str)}) unexpectedly failed`);
+    _checkIsHttpToken(str),
+    true,
+    `_checkIsHttpToken(${inspect(str)}) unexpectedly failed`
+  );
 });
 // Bad header field names
 [
@@ -54,11 +56,12 @@ const { _checkIsHttpToken, _checkInvalidHeaderChar } = require('_http_common');
   'This,That'
 ].forEach(function(str) {
   assert.strictEqual(
-    _checkIsHttpToken(str), false,
-    `_checkIsHttpToken(${inspect(str)}) unexpectedly succeeded`);
+    _checkIsHttpToken(str),
+    false,
+    `_checkIsHttpToken(${inspect(str)}) unexpectedly succeeded`
+  );
 });
 
-
 // Good header field values
 [
   'foo bar',
@@ -67,8 +70,10 @@ const { _checkIsHttpToken, _checkInvalidHeaderChar } = require('_http_common');
   '!@#$%^&*()-_=+\\;\':"[]{}<>,./?|~`'
 ].forEach(function(str) {
   assert.strictEqual(
-    _checkInvalidHeaderChar(str), false,
-    `_checkInvalidHeaderChar(${inspect(str)}) unexpectedly failed`);
+    _checkInvalidHeaderChar(str),
+    false,
+    `_checkInvalidHeaderChar(${inspect(str)}) unexpectedly failed`
+  );
 });
 
 // Bad header field values
@@ -83,6 +88,8 @@ const { _checkIsHttpToken, _checkInvalidHeaderChar } = require('_http_common');
   'Ding!\x07'
 ].forEach(function(str) {
   assert.strictEqual(
-    _checkInvalidHeaderChar(str), true,
-    `_checkInvalidHeaderChar(${inspect(str)}) unexpectedly succeeded`);
+    _checkInvalidHeaderChar(str),
+    true,
+    `_checkInvalidHeaderChar(${inspect(str)}) unexpectedly succeeded`
+  );
 });
diff --git a/test/parallel/test-http-keep-alive-close-on-header.js b/test/parallel/test-http-keep-alive-close-on-header.js
index fd0c52037fa78c..5b068fdb9aa61f 100644
--- a/test/parallel/test-http-keep-alive-close-on-header.js
+++ b/test/parallel/test-http-keep-alive-close-on-header.js
@@ -25,30 +25,32 @@ const assert = require('assert');
 const http = require('http');
 
 const body = 'hello world\n';
-const headers = { 'connection': 'keep-alive' };
+const headers = { connection: 'keep-alive' };
 
 const server = http.createServer(function(req, res) {
-  res.writeHead(200, { 'Content-Length': body.length, 'Connection': 'close' });
+  res.writeHead(200, { 'Content-Length': body.length, Connection: 'close' });
   res.write(body);
   res.end();
 });
 
 let connectCount = 0;
 
-
 server.listen(0, function() {
   const agent = new http.Agent({ maxSockets: 1 });
   const name = agent.getName({ port: this.address().port });
-  let request = http.request({
-    method: 'GET',
-    path: '/',
-    headers: headers,
-    port: this.address().port,
-    agent: agent
-  }, function(res) {
-    assert.strictEqual(agent.sockets[name].length, 1);
-    res.resume();
-  });
+  let request = http.request(
+    {
+      method: 'GET',
+      path: '/',
+      headers: headers,
+      port: this.address().port,
+      agent: agent
+    },
+    function(res) {
+      assert.strictEqual(agent.sockets[name].length, 1);
+      res.resume();
+    }
+  );
   request.on('socket', function(s) {
     s.on('connect', function() {
       connectCount++;
@@ -56,35 +58,41 @@ server.listen(0, function() {
   });
   request.end();
 
-  request = http.request({
-    method: 'GET',
-    path: '/',
-    headers: headers,
-    port: this.address().port,
-    agent: agent
-  }, function(res) {
-    assert.strictEqual(agent.sockets[name].length, 1);
-    res.resume();
-  });
+  request = http.request(
+    {
+      method: 'GET',
+      path: '/',
+      headers: headers,
+      port: this.address().port,
+      agent: agent
+    },
+    function(res) {
+      assert.strictEqual(agent.sockets[name].length, 1);
+      res.resume();
+    }
+  );
   request.on('socket', function(s) {
     s.on('connect', function() {
       connectCount++;
     });
   });
   request.end();
-  request = http.request({
-    method: 'GET',
-    path: '/',
-    headers: headers,
-    port: this.address().port,
-    agent: agent
-  }, function(response) {
-    response.on('end', function() {
-      assert.strictEqual(agent.sockets[name].length, 1);
-      server.close();
-    });
-    response.resume();
-  });
+  request = http.request(
+    {
+      method: 'GET',
+      path: '/',
+      headers: headers,
+      port: this.address().port,
+      agent: agent
+    },
+    function(response) {
+      response.on('end', function() {
+        assert.strictEqual(agent.sockets[name].length, 1);
+        server.close();
+      });
+      response.resume();
+    }
+  );
   request.on('socket', function(s) {
     s.on('connect', function() {
       connectCount++;
diff --git a/test/parallel/test-http-keep-alive.js b/test/parallel/test-http-keep-alive.js
index 42d534e8e6b459..b5cf98630b3a89 100644
--- a/test/parallel/test-http-keep-alive.js
+++ b/test/parallel/test-http-keep-alive.js
@@ -24,47 +24,73 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  const body = 'hello world\n';
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    const body = 'hello world\n';
 
-  res.writeHead(200, { 'Content-Length': body.length });
-  res.write(body);
-  res.end();
-}, 3));
+    res.writeHead(200, { 'Content-Length': body.length });
+    res.write(body);
+    res.end();
+  }, 3)
+);
 
 const agent = new http.Agent({ maxSockets: 1 });
-const headers = { 'connection': 'keep-alive' };
+const headers = { connection: 'keep-alive' };
 let name;
 
-server.listen(0, common.mustCall(function() {
-  name = agent.getName({ port: this.address().port });
-  http.get({
-    path: '/', headers: headers, port: this.address().port, agent: agent
-  }, common.mustCall((response) => {
-    assert.strictEqual(agent.sockets[name].length, 1);
-    assert.strictEqual(agent.requests[name].length, 2);
-    response.resume();
-  }));
+server.listen(
+  0,
+  common.mustCall(function() {
+    name = agent.getName({ port: this.address().port });
+    http.get(
+      {
+        path: '/',
+        headers: headers,
+        port: this.address().port,
+        agent: agent
+      },
+      common.mustCall((response) => {
+        assert.strictEqual(agent.sockets[name].length, 1);
+        assert.strictEqual(agent.requests[name].length, 2);
+        response.resume();
+      })
+    );
 
-  http.get({
-    path: '/', headers: headers, port: this.address().port, agent: agent
-  }, common.mustCall((response) => {
-    assert.strictEqual(agent.sockets[name].length, 1);
-    assert.strictEqual(agent.requests[name].length, 1);
-    response.resume();
-  }));
+    http.get(
+      {
+        path: '/',
+        headers: headers,
+        port: this.address().port,
+        agent: agent
+      },
+      common.mustCall((response) => {
+        assert.strictEqual(agent.sockets[name].length, 1);
+        assert.strictEqual(agent.requests[name].length, 1);
+        response.resume();
+      })
+    );
 
-  http.get({
-    path: '/', headers: headers, port: this.address().port, agent: agent
-  }, common.mustCall((response) => {
-    response.on('end', common.mustCall(() => {
-      assert.strictEqual(agent.sockets[name].length, 1);
-      assert(!agent.requests.hasOwnProperty(name));
-      server.close();
-    }));
-    response.resume();
-  }));
-}));
+    http.get(
+      {
+        path: '/',
+        headers: headers,
+        port: this.address().port,
+        agent: agent
+      },
+      common.mustCall((response) => {
+        response.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(agent.sockets[name].length, 1);
+            assert(!agent.requests.hasOwnProperty(name));
+            server.close();
+          })
+        );
+        response.resume();
+      })
+    );
+  })
+);
 
 process.on('exit', () => {
   assert(!agent.sockets.hasOwnProperty(name));
diff --git a/test/parallel/test-http-keepalive-client.js b/test/parallel/test-http-keepalive-client.js
index 5a9277feee9ae6..7b315f2692fc81 100644
--- a/test/parallel/test-http-keepalive-client.js
+++ b/test/parallel/test-http-keepalive-client.js
@@ -25,7 +25,6 @@ const assert = require('assert');
 
 const http = require('http');
 
-
 let serverSocket = null;
 const server = http.createServer(function(req, res) {
   // They should all come in on the same server socket.
@@ -43,12 +42,10 @@ server.listen(0, function() {
 
 const agent = http.Agent({ keepAlive: true });
 
-
 let clientSocket = null;
 const expectRequests = 10;
 let actualRequests = 0;
 
-
 function makeRequest(n) {
   if (n === 0) {
     server.close();
diff --git a/test/parallel/test-http-keepalive-override.js b/test/parallel/test-http-keepalive-override.js
index d25fc319747ad2..909eb60caf88cb 100644
--- a/test/parallel/test-http-keepalive-override.js
+++ b/test/parallel/test-http-keepalive-override.js
@@ -4,64 +4,83 @@ const assert = require('assert');
 
 const http = require('http');
 
-const server = http.createServer((req, res) => {
-  res.end('ok');
-}).listen(0, common.mustCall(() => {
-  const agent = http.Agent({
-    keepAlive: true,
-    maxSockets: 5,
-    maxFreeSockets: 2
-  });
+const server = http
+  .createServer((req, res) => {
+    res.end('ok');
+  })
+  .listen(
+    0,
+    common.mustCall(() => {
+      const agent = http.Agent({
+        keepAlive: true,
+        maxSockets: 5,
+        maxFreeSockets: 2
+      });
 
-  const keepSocketAlive = agent.keepSocketAlive;
-  const reuseSocket = agent.reuseSocket;
+      const keepSocketAlive = agent.keepSocketAlive;
+      const reuseSocket = agent.reuseSocket;
 
-  let called = 0;
-  let expectedSocket;
-  agent.keepSocketAlive = common.mustCall((socket) => {
-    assert(socket);
+      let called = 0;
+      let expectedSocket;
+      agent.keepSocketAlive = common.mustCall((socket) => {
+        assert(socket);
 
-    called++;
-    if (called === 1) {
-      return false;
-    } else if (called === 2) {
-      expectedSocket = socket;
-      return keepSocketAlive.call(agent, socket);
-    }
+        called++;
+        if (called === 1) {
+          return false;
+        } else if (called === 2) {
+          expectedSocket = socket;
+          return keepSocketAlive.call(agent, socket);
+        }
 
-    assert.strictEqual(socket, expectedSocket);
-    return false;
-  }, 3);
+        assert.strictEqual(socket, expectedSocket);
+        return false;
+      }, 3);
 
-  agent.reuseSocket = common.mustCall((socket, req) => {
-    assert.strictEqual(socket, expectedSocket);
-    assert(req);
+      agent.reuseSocket = common.mustCall((socket, req) => {
+        assert.strictEqual(socket, expectedSocket);
+        assert(req);
 
-    return reuseSocket.call(agent, socket, req);
-  }, 1);
+        return reuseSocket.call(agent, socket, req);
+      }, 1);
 
-  function req(callback) {
-    http.request({
-      method: 'GET',
-      path: '/',
-      agent,
-      port: server.address().port
-    }, common.mustCall((res) => {
-      res.resume();
-      res.once('end', common.mustCall(() => {
-        setImmediate(callback);
-      }));
-    })).end();
-  }
+      function req(callback) {
+        http
+          .request(
+            {
+              method: 'GET',
+              path: '/',
+              agent,
+              port: server.address().port
+            },
+            common.mustCall((res) => {
+              res.resume();
+              res.once(
+                'end',
+                common.mustCall(() => {
+                  setImmediate(callback);
+                })
+              );
+            })
+          )
+          .end();
+      }
 
-  // Should destroy socket instead of keeping it alive
-  req(common.mustCall(() => {
-    // Should keep socket alive
-    req(common.mustCall(() => {
-      // Should reuse the socket
-      req(common.mustCall(() => {
-        server.close();
-      }));
-    }));
-  }));
-}));
+      // Should destroy socket instead of keeping it alive
+      req(
+        common.mustCall(() => {
+          // Should keep socket alive
+          req(
+            common.mustCall(() => {
+              // Should reuse the socket
+              req(
+                common.mustCall(() => {
+                  server.close();
+                })
+              );
+            })
+          );
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-http-keepalive-request.js b/test/parallel/test-http-keepalive-request.js
index 574dea9ba562dc..874d28920a46e2 100644
--- a/test/parallel/test-http-keepalive-request.js
+++ b/test/parallel/test-http-keepalive-request.js
@@ -25,7 +25,6 @@ const assert = require('assert');
 
 const http = require('http');
 
-
 let serverSocket = null;
 const server = http.createServer(function(req, res) {
   // They should all come in on the same server socket.
@@ -43,12 +42,10 @@ server.listen(0, function() {
 
 const agent = http.Agent({ keepAlive: true });
 
-
 let clientSocket = null;
 const expectRequests = 10;
 let actualRequests = 0;
 
-
 function makeRequest(n) {
   if (n === 0) {
     server.close();
diff --git a/test/parallel/test-http-listening.js b/test/parallel/test-http-listening.js
index 3fd93f3e2e0b26..d09cc3e4fcac4f 100644
--- a/test/parallel/test-http-listening.js
+++ b/test/parallel/test-http-listening.js
@@ -7,10 +7,15 @@ const server = http.createServer();
 
 assert.strictEqual(server.listening, false);
 
-server.listen(0, common.mustCall(() => {
-  assert.strictEqual(server.listening, true);
+server.listen(
+  0,
+  common.mustCall(() => {
+    assert.strictEqual(server.listening, true);
 
-  server.close(common.mustCall(() => {
-    assert.strictEqual(server.listening, false);
-  }));
-}));
+    server.close(
+      common.mustCall(() => {
+        assert.strictEqual(server.listening, false);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-localaddress-bind-error.js b/test/parallel/test-http-localaddress-bind-error.js
index d4bd72bae1d5db..969b263a0ba1de 100644
--- a/test/parallel/test-http-localaddress-bind-error.js
+++ b/test/parallel/test-http-localaddress-bind-error.js
@@ -36,17 +36,30 @@ const server = http.createServer(function(req, res) {
   req.resume();
 });
 
-server.listen(0, '127.0.0.1', common.mustCall(function() {
-  http.request({
-    host: 'localhost',
-    port: this.address().port,
-    path: '/',
-    method: 'GET',
-    localAddress: invalidLocalAddress
-  }, function(res) {
-    assert.fail('unexpectedly got response from server');
-  }).on('error', common.mustCall(function(e) {
-    console.log(`client got error: ${e.message}`);
-    server.close();
-  })).end();
-}));
+server.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    http
+      .request(
+        {
+          host: 'localhost',
+          port: this.address().port,
+          path: '/',
+          method: 'GET',
+          localAddress: invalidLocalAddress
+        },
+        function(res) {
+          assert.fail('unexpectedly got response from server');
+        }
+      )
+      .on(
+        'error',
+        common.mustCall(function(e) {
+          console.log(`client got error: ${e.message}`);
+          server.close();
+        })
+      )
+      .end();
+  })
+);
diff --git a/test/parallel/test-http-localaddress.js b/test/parallel/test-http-localaddress.js
index 6763fae1265ac3..e5115abc27383d 100644
--- a/test/parallel/test-http-localaddress.js
+++ b/test/parallel/test-http-localaddress.js
@@ -22,8 +22,7 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-if (!common.hasMultiLocalhost())
-  common.skip('platform-specific test.');
+if (!common.hasMultiLocalhost()) common.skip('platform-specific test.');
 
 const http = require('http');
 const assert = require('assert');
@@ -40,11 +39,13 @@ const server = http.createServer(function(req, res) {
 });
 
 server.listen(0, '127.0.0.1', function() {
-  const options = { host: 'localhost',
-                    port: this.address().port,
-                    path: '/',
-                    method: 'GET',
-                    localAddress: '127.0.0.2' };
+  const options = {
+    host: 'localhost',
+    port: this.address().port,
+    path: '/',
+    method: 'GET',
+    localAddress: '127.0.0.2'
+  };
 
   const req = http.request(options, function(res) {
     res.on('end', function() {
diff --git a/test/parallel/test-http-malformed-request.js b/test/parallel/test-http-malformed-request.js
index 781c629bfacd17..e0a74726557557 100644
--- a/test/parallel/test-http-malformed-request.js
+++ b/test/parallel/test-http-malformed-request.js
@@ -27,15 +27,17 @@ const url = require('url');
 
 // Make sure no exceptions are thrown when receiving malformed HTTP
 // requests.
-const server = http.createServer(common.mustCall((req, res) => {
-  console.log(`req: ${JSON.stringify(url.parse(req.url))}`);
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    console.log(`req: ${JSON.stringify(url.parse(req.url))}`);
 
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.write('Hello World');
-  res.end();
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write('Hello World');
+    res.end();
 
-  server.close();
-}));
+    server.close();
+  })
+);
 server.listen(0);
 
 server.on('listening', function() {
diff --git a/test/parallel/test-http-many-ended-pipelines.js b/test/parallel/test-http-many-ended-pipelines.js
index d17090cec918a0..814e99b39e441b 100644
--- a/test/parallel/test-http-many-ended-pipelines.js
+++ b/test/parallel/test-http-many-ended-pipelines.js
@@ -49,12 +49,14 @@ const server = http.createServer(function(req, res) {
 });
 
 server.listen(0, function() {
-  const client = net.connect({ port: this.address().port,
-                               allowHalfOpen: true });
+  const client = net.connect({
+    port: this.address().port,
+    allowHalfOpen: true
+  });
   for (let i = 0; i < numRequests; i++) {
-    client.write('GET / HTTP/1.1\r\n' +
-                 'Host: some.host.name\r\n' +
-                 '\r\n\r\n');
+    client.write(
+      'GET / HTTP/1.1\r\n' + 'Host: some.host.name\r\n' + '\r\n\r\n'
+    );
   }
   client.end();
   client.pipe(process.stdout);
diff --git a/test/parallel/test-http-max-headers-count.js b/test/parallel/test-http-max-headers-count.js
index 05f4f774c2c929..a26b498f7dd304 100644
--- a/test/parallel/test-http-max-headers-count.js
+++ b/test/parallel/test-http-max-headers-count.js
@@ -33,7 +33,8 @@ for (let i = 0; i < N; ++i) {
   headers[`key${i}`] = i;
 }
 
-const maxAndExpected = [ // for server
+const maxAndExpected = [
+  // for server
   [50, 50],
   [1500, 1500],
   [0, N + 2] // Host and Connection
@@ -54,7 +55,8 @@ const server = http.createServer(function(req, res) {
 server.maxHeadersCount = max;
 
 server.listen(0, function() {
-  const maxAndExpected = [ // for client
+  const maxAndExpected = [
+    // for client
     [20, 20],
     [1200, 1200],
     [0, N + 3] // Connection, Date and Transfer-Encoding
@@ -64,20 +66,23 @@ server.listen(0, function() {
   function doRequest() {
     const max = maxAndExpected[responses][0];
     const expected = maxAndExpected[responses][1];
-    const req = http.request({
-      port: server.address().port,
-      headers: headers
-    }, function(res) {
-      assert.strictEqual(Object.keys(res.headers).length, expected);
-      res.on('end', function() {
-        if (++responses < maxAndExpected.length) {
-          doRequest();
-        } else {
-          server.close();
-        }
-      });
-      res.resume();
-    });
+    const req = http.request(
+      {
+        port: server.address().port,
+        headers: headers
+      },
+      function(res) {
+        assert.strictEqual(Object.keys(res.headers).length, expected);
+        res.on('end', function() {
+          if (++responses < maxAndExpected.length) {
+            doRequest();
+          } else {
+            server.close();
+          }
+        });
+        res.resume();
+      }
+    );
     req.maxHeadersCount = max;
     req.end();
   }
diff --git a/test/parallel/test-http-methods.js b/test/parallel/test-http-methods.js
index 43541707a4350c..73f07a9806ed80 100644
--- a/test/parallel/test-http-methods.js
+++ b/test/parallel/test-http-methods.js
@@ -61,7 +61,7 @@ const methods = [
   'MKCALENDAR',
   'LINK',
   'UNLINK',
-  'SOURCE',
+  'SOURCE'
 ];
 
 assert.deepStrictEqual(http.METHODS, methods.sort());
diff --git a/test/parallel/test-http-multi-line-headers.js b/test/parallel/test-http-multi-line-headers.js
index 99c48cd97b58b9..84884e45e3fbfc 100644
--- a/test/parallel/test-http-multi-line-headers.js
+++ b/test/parallel/test-http-multi-line-headers.js
@@ -30,26 +30,34 @@ const server = net.createServer(function(conn) {
   const body = 'Yet another node.js server.';
 
   const response =
-      'HTTP/1.1 200 OK\r\n' +
-      'Connection: close\r\n' +
-      `Content-Length: ${body.length}\r\n` +
-      'Content-Type: text/plain;\r\n' +
-      ' x-unix-mode=0600;\r\n' +
-      ' name="hello.txt"\r\n' +
-      '\r\n' +
-      body;
+    'HTTP/1.1 200 OK\r\n' +
+    'Connection: close\r\n' +
+    `Content-Length: ${body.length}\r\n` +
+    'Content-Type: text/plain;\r\n' +
+    ' x-unix-mode=0600;\r\n' +
+    ' name="hello.txt"\r\n' +
+    '\r\n' +
+    body;
 
   conn.end(response);
   server.close();
 });
 
-server.listen(0, common.mustCall(function() {
-  http.get({
-    host: '127.0.0.1',
-    port: this.address().port
-  }, common.mustCall(function(res) {
-    assert.strictEqual(res.headers['content-type'],
-                       'text/plain; x-unix-mode=0600; name="hello.txt"');
-    res.destroy();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    http.get(
+      {
+        host: '127.0.0.1',
+        port: this.address().port
+      },
+      common.mustCall(function(res) {
+        assert.strictEqual(
+          res.headers['content-type'],
+          'text/plain; x-unix-mode=0600; name="hello.txt"'
+        );
+        res.destroy();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-mutable-headers.js b/test/parallel/test-http-mutable-headers.js
index 0ff05f234c2c5d..01cb6f0192b369 100644
--- a/test/parallel/test-http-mutable-headers.js
+++ b/test/parallel/test-http-mutable-headers.js
@@ -39,179 +39,182 @@ const cookies = [
   'prefers_open_id=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT'
 ];
 
-const s = http.createServer(common.mustCall((req, res) => {
-  switch (test) {
-    case 'headers':
-      // Check that header-related functions work before setting any headers
-      const headers = res.getHeaders();
-      const exoticObj = Object.create(null);
-      assert.deepStrictEqual(headers, exoticObj);
-      assert.deepStrictEqual(res.getHeaderNames(), []);
-      assert.deepStrictEqual(res.hasHeader('Connection'), false);
-      assert.deepStrictEqual(res.getHeader('Connection'), undefined);
-
-      common.expectsError(
-        () => res.setHeader(),
-        {
+const s = http.createServer(
+  common.mustCall((req, res) => {
+    switch (test) {
+      case 'headers':
+        // Check that header-related functions work before setting any headers
+        const headers = res.getHeaders();
+        const exoticObj = Object.create(null);
+        assert.deepStrictEqual(headers, exoticObj);
+        assert.deepStrictEqual(res.getHeaderNames(), []);
+        assert.deepStrictEqual(res.hasHeader('Connection'), false);
+        assert.deepStrictEqual(res.getHeader('Connection'), undefined);
+
+        common.expectsError(() => res.setHeader(), {
           code: 'ERR_INVALID_HTTP_TOKEN',
           type: TypeError,
           message: 'Header name must be a valid HTTP token ["undefined"]'
-        }
-      );
-      common.expectsError(
-        () => res.setHeader('someHeader'),
-        {
+        });
+        common.expectsError(() => res.setHeader('someHeader'), {
           code: 'ERR_HTTP_INVALID_HEADER_VALUE',
           type: TypeError,
           message: 'Invalid value "undefined" for header "someHeader"'
-        }
-      );
-      common.expectsError(
-        () => res.getHeader(),
-        {
+        });
+        common.expectsError(() => res.getHeader(), {
           code: 'ERR_INVALID_ARG_TYPE',
           type: TypeError,
-          message: 'The "name" argument must be of type string. ' +
-                   'Received type undefined'
-        }
-      );
-      common.expectsError(
-        () => res.removeHeader(),
-        {
+          message:
+            'The "name" argument must be of type string. ' +
+            'Received type undefined'
+        });
+        common.expectsError(() => res.removeHeader(), {
           code: 'ERR_INVALID_ARG_TYPE',
           type: TypeError,
-          message: 'The "name" argument must be of type string. ' +
-                   'Received type undefined'
-        }
-      );
-
-      const arrayValues = [1, 2, 3];
-      res.setHeader('x-test-header', 'testing');
-      res.setHeader('X-TEST-HEADER2', 'testing');
-      res.setHeader('set-cookie', cookies);
-      res.setHeader('x-test-array-header', arrayValues);
-
-      assert.strictEqual(res.getHeader('x-test-header'), 'testing');
-      assert.strictEqual(res.getHeader('x-test-header2'), 'testing');
-
-      const headersCopy = res.getHeaders();
-      const expected = {
-        'x-test-header': 'testing',
-        'x-test-header2': 'testing',
-        'set-cookie': cookies,
-        'x-test-array-header': arrayValues
-      };
-      Object.setPrototypeOf(expected, null);
-      assert.deepStrictEqual(headersCopy, expected);
-
-      assert.deepStrictEqual(res.getHeaderNames(),
-                             ['x-test-header', 'x-test-header2',
-                              'set-cookie', 'x-test-array-header']);
-
-      assert.strictEqual(res.hasHeader('x-test-header2'), true);
-      assert.strictEqual(res.hasHeader('X-TEST-HEADER2'), true);
-      assert.strictEqual(res.hasHeader('X-Test-Header2'), true);
-      [
-        undefined,
-        null,
-        true,
-        {},
-        { toString: () => 'X-TEST-HEADER2' },
-        () => { }
-      ].forEach((val) => {
-        common.expectsError(
-          () => res.hasHeader(val),
-          {
+          message:
+            'The "name" argument must be of type string. ' +
+            'Received type undefined'
+        });
+
+        const arrayValues = [1, 2, 3];
+        res.setHeader('x-test-header', 'testing');
+        res.setHeader('X-TEST-HEADER2', 'testing');
+        res.setHeader('set-cookie', cookies);
+        res.setHeader('x-test-array-header', arrayValues);
+
+        assert.strictEqual(res.getHeader('x-test-header'), 'testing');
+        assert.strictEqual(res.getHeader('x-test-header2'), 'testing');
+
+        const headersCopy = res.getHeaders();
+        const expected = {
+          'x-test-header': 'testing',
+          'x-test-header2': 'testing',
+          'set-cookie': cookies,
+          'x-test-array-header': arrayValues
+        };
+        Object.setPrototypeOf(expected, null);
+        assert.deepStrictEqual(headersCopy, expected);
+
+        assert.deepStrictEqual(res.getHeaderNames(), [
+          'x-test-header',
+          'x-test-header2',
+          'set-cookie',
+          'x-test-array-header'
+        ]);
+
+        assert.strictEqual(res.hasHeader('x-test-header2'), true);
+        assert.strictEqual(res.hasHeader('X-TEST-HEADER2'), true);
+        assert.strictEqual(res.hasHeader('X-Test-Header2'), true);
+        [
+          undefined,
+          null,
+          true,
+          {},
+          { toString: () => 'X-TEST-HEADER2' },
+          () => {}
+        ].forEach((val) => {
+          common.expectsError(() => res.hasHeader(val), {
             code: 'ERR_INVALID_ARG_TYPE',
             type: TypeError,
-            message: 'The "name" argument must be of type string. ' +
-                     `Received type ${typeof val}`
-          }
-        );
-      });
-
-      res.removeHeader('x-test-header2');
-
-      assert.strictEqual(res.hasHeader('x-test-header2'), false);
-      assert.strictEqual(res.hasHeader('X-TEST-HEADER2'), false);
-      assert.strictEqual(res.hasHeader('X-Test-Header2'), false);
-      break;
+            message:
+              'The "name" argument must be of type string. ' +
+              `Received type ${typeof val}`
+          });
+        });
 
-    case 'contentLength':
-      res.setHeader('content-length', content.length);
-      assert.strictEqual(res.getHeader('Content-Length'), content.length);
-      break;
+        res.removeHeader('x-test-header2');
 
-    case 'transferEncoding':
-      res.setHeader('transfer-encoding', 'chunked');
-      assert.strictEqual(res.getHeader('Transfer-Encoding'), 'chunked');
-      break;
-
-    case 'writeHead':
-      res.statusCode = 404;
-      res.setHeader('x-foo', 'keyboard cat');
-      res.writeHead(200, { 'x-foo': 'bar', 'x-bar': 'baz' });
-      break;
-
-    default:
-      assert.fail('Unknown test');
-  }
-
-  res.statusCode = 201;
-  res.end(content);
-}, 4));
-
-s.listen(0, nextTest);
-
-
-function nextTest() {
-  if (test === 'end') {
-    return s.close();
-  }
-
-  let bufferedResponse = '';
-
-  http.get({ port: s.address().port }, common.mustCall((response) => {
-    switch (test) {
-      case 'headers':
-        assert.strictEqual(response.statusCode, 201);
-        assert.strictEqual(response.headers['x-test-header'], 'testing');
-        assert.strictEqual(response.headers['x-test-array-header'],
-                           [1, 2, 3].join(', '));
-        assert.deepStrictEqual(cookies, response.headers['set-cookie']);
-        assert.strictEqual(response.headers['x-test-header2'], undefined);
-        test = 'contentLength';
+        assert.strictEqual(res.hasHeader('x-test-header2'), false);
+        assert.strictEqual(res.hasHeader('X-TEST-HEADER2'), false);
+        assert.strictEqual(res.hasHeader('X-Test-Header2'), false);
         break;
 
       case 'contentLength':
-        assert.strictEqual(+response.headers['content-length'], content.length);
-        test = 'transferEncoding';
+        res.setHeader('content-length', content.length);
+        assert.strictEqual(res.getHeader('Content-Length'), content.length);
         break;
 
       case 'transferEncoding':
-        assert.strictEqual(response.headers['transfer-encoding'], 'chunked');
-        test = 'writeHead';
+        res.setHeader('transfer-encoding', 'chunked');
+        assert.strictEqual(res.getHeader('Transfer-Encoding'), 'chunked');
         break;
 
       case 'writeHead':
-        assert.strictEqual(response.headers['x-foo'], 'bar');
-        assert.strictEqual(response.headers['x-bar'], 'baz');
-        assert.strictEqual(response.statusCode, 200);
-        test = 'end';
+        res.statusCode = 404;
+        res.setHeader('x-foo', 'keyboard cat');
+        res.writeHead(200, { 'x-foo': 'bar', 'x-bar': 'baz' });
         break;
 
       default:
         assert.fail('Unknown test');
     }
 
-    response.setEncoding('utf8');
-    response.on('data', (s) => {
-      bufferedResponse += s;
-    });
+    res.statusCode = 201;
+    res.end(content);
+  }, 4)
+);
 
-    response.on('end', common.mustCall(() => {
-      assert.strictEqual(bufferedResponse, content);
-      common.mustCall(nextTest)();
-    }));
-  }));
+s.listen(0, nextTest);
+
+function nextTest() {
+  if (test === 'end') {
+    return s.close();
+  }
+
+  let bufferedResponse = '';
+
+  http.get(
+    { port: s.address().port },
+    common.mustCall((response) => {
+      switch (test) {
+        case 'headers':
+          assert.strictEqual(response.statusCode, 201);
+          assert.strictEqual(response.headers['x-test-header'], 'testing');
+          assert.strictEqual(
+            response.headers['x-test-array-header'],
+            [1, 2, 3].join(', ')
+          );
+          assert.deepStrictEqual(cookies, response.headers['set-cookie']);
+          assert.strictEqual(response.headers['x-test-header2'], undefined);
+          test = 'contentLength';
+          break;
+
+        case 'contentLength':
+          assert.strictEqual(
+            +response.headers['content-length'],
+            content.length
+          );
+          test = 'transferEncoding';
+          break;
+
+        case 'transferEncoding':
+          assert.strictEqual(response.headers['transfer-encoding'], 'chunked');
+          test = 'writeHead';
+          break;
+
+        case 'writeHead':
+          assert.strictEqual(response.headers['x-foo'], 'bar');
+          assert.strictEqual(response.headers['x-bar'], 'baz');
+          assert.strictEqual(response.statusCode, 200);
+          test = 'end';
+          break;
+
+        default:
+          assert.fail('Unknown test');
+      }
+
+      response.setEncoding('utf8');
+      response.on('data', (s) => {
+        bufferedResponse += s;
+      });
+
+      response.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(bufferedResponse, content);
+          common.mustCall(nextTest)();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http-no-content-length.js b/test/parallel/test-http-no-content-length.js
index a3a51c015ec86f..d43551fa3ad2ba 100644
--- a/test/parallel/test-http-no-content-length.js
+++ b/test/parallel/test-http-no-content-length.js
@@ -25,20 +25,31 @@ const assert = require('assert');
 const net = require('net');
 const http = require('http');
 
-const server = net.createServer(function(socket) {
-  // Neither Content-Length nor Connection
-  socket.end('HTTP/1.1 200 ok\r\n\r\nHello');
-}).listen(0, common.mustCall(function() {
-  http.get({ port: this.address().port }, common.mustCall(function(res) {
-    let body = '';
+const server = net
+  .createServer(function(socket) {
+    // Neither Content-Length nor Connection
+    socket.end('HTTP/1.1 200 ok\r\n\r\nHello');
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      http.get(
+        { port: this.address().port },
+        common.mustCall(function(res) {
+          let body = '';
 
-    res.setEncoding('utf8');
-    res.on('data', function(chunk) {
-      body += chunk;
-    });
-    res.on('end', common.mustCall(function() {
-      assert.strictEqual(body, 'Hello');
-      server.close();
-    }));
-  }));
-}));
+          res.setEncoding('utf8');
+          res.on('data', function(chunk) {
+            body += chunk;
+          });
+          res.on(
+            'end',
+            common.mustCall(function() {
+              assert.strictEqual(body, 'Hello');
+              server.close();
+            })
+          );
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-http-no-read-no-dump.js b/test/parallel/test-http-no-read-no-dump.js
index 17d36c56b2eeba..0fc0c83fcff9f7 100644
--- a/test/parallel/test-http-no-read-no-dump.js
+++ b/test/parallel/test-http-no-read-no-dump.js
@@ -4,50 +4,62 @@ const http = require('http');
 
 let onPause = null;
 
-const server = http.createServer((req, res) => {
-  if (req.method === 'GET')
-    return res.end();
-
-  res.writeHead(200);
-  res.flushHeaders();
-
-  req.connection.on('pause', () => {
-    res.end();
-    onPause();
-  });
-}).listen(0, common.mustCall(() => {
-  const agent = new http.Agent({
-    maxSockets: 1,
-    keepAlive: true
-  });
-
-  const port = server.address().port;
-
-  const post = http.request({
-    agent,
-    method: 'POST',
-    port,
-  }, common.mustCall((res) => {
-    res.resume();
-
-    post.write(Buffer.alloc(16 * 1024).fill('X'));
-    onPause = () => {
-      post.end('something');
-    };
-  }));
-
-  /* What happens here is that the server `end`s the response before we send
-   * `something`, and the client thought that this is a green light for sending
-   * next GET request
-   */
-  post.write('initial');
-
-  http.request({
-    agent,
-    method: 'GET',
-    port,
-  }, common.mustCall((res) => {
-    server.close();
-    res.connection.end();
-  })).end();
-}));
+const server = http
+  .createServer((req, res) => {
+    if (req.method === 'GET') return res.end();
+
+    res.writeHead(200);
+    res.flushHeaders();
+
+    req.connection.on('pause', () => {
+      res.end();
+      onPause();
+    });
+  })
+  .listen(
+    0,
+    common.mustCall(() => {
+      const agent = new http.Agent({
+        maxSockets: 1,
+        keepAlive: true
+      });
+
+      const port = server.address().port;
+
+      const post = http.request(
+        {
+          agent,
+          method: 'POST',
+          port
+        },
+        common.mustCall((res) => {
+          res.resume();
+
+          post.write(Buffer.alloc(16 * 1024).fill('X'));
+          onPause = () => {
+            post.end('something');
+          };
+        })
+      );
+
+      /* What happens here is that the server `end`s the response before we send
+       * `something`, and the client thought that this is a green light for sending
+       * next GET request
+       */
+      post.write('initial');
+
+      http
+        .request(
+          {
+            agent,
+            method: 'GET',
+            port
+          },
+          common.mustCall((res) => {
+            server.close();
+            res.connection.end();
+          })
+        )
+        .end();
+    })
+  );
diff --git a/test/parallel/test-http-outgoing-finish-writable.js b/test/parallel/test-http-outgoing-finish-writable.js
index 033e9b6bc1a7db..cc551376ad70e4 100644
--- a/test/parallel/test-http-outgoing-finish-writable.js
+++ b/test/parallel/test-http-outgoing-finish-writable.js
@@ -6,33 +6,38 @@ const http = require('http');
 // Verify that after calling end() on an `OutgoingMessage` (or a type that
 // inherits from `OutgoingMessage`), its `writable` property is not set to false
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  assert.strictEqual(res.writable, true);
-  assert.strictEqual(res.finished, false);
-  res.end();
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    assert.strictEqual(res.writable, true);
+    assert.strictEqual(res.finished, false);
+    res.end();
 
-  // res.writable is set to false after it has finished sending
-  // Ref: https://github.com/nodejs/node/issues/15029
-  assert.strictEqual(res.writable, true);
-  assert.strictEqual(res.finished, true);
+    // res.writable is set to false after it has finished sending
+    // Ref: https://github.com/nodejs/node/issues/15029
+    assert.strictEqual(res.writable, true);
+    assert.strictEqual(res.finished, true);
 
-  server.close();
-}));
+    server.close();
+  })
+);
 
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const clientRequest = http.request({
-    port: server.address().port,
-    method: 'GET',
-    path: '/'
-  });
-
-  assert.strictEqual(clientRequest.writable, true);
-  clientRequest.end();
-
-  // writable is still true when close
-  // THIS IS LEGACY, we cannot change it
-  // unless we break error detection
-  assert.strictEqual(clientRequest.writable, true);
-}));
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const clientRequest = http.request({
+      port: server.address().port,
+      method: 'GET',
+      path: '/'
+    });
+
+    assert.strictEqual(clientRequest.writable, true);
+    clientRequest.end();
+
+    // writable is still true when close
+    // THIS IS LEGACY, we cannot change it
+    // unless we break error detection
+    assert.strictEqual(clientRequest.writable, true);
+  })
+);
diff --git a/test/parallel/test-http-outgoing-finish.js b/test/parallel/test-http-outgoing-finish.js
index c805a89cc165f2..6e2b37dba26c80 100644
--- a/test/parallel/test-http-outgoing-finish.js
+++ b/test/parallel/test-http-outgoing-finish.js
@@ -25,22 +25,24 @@ const assert = require('assert');
 
 const http = require('http');
 
-http.createServer(function(req, res) {
-  req.resume();
-  req.on('end', function() {
-    write(res);
-  });
-  this.close();
-}).listen(0, function() {
-  const req = http.request({
-    port: this.address().port,
-    method: 'PUT'
-  });
-  write(req);
-  req.on('response', function(res) {
-    res.resume();
+http
+  .createServer(function(req, res) {
+    req.resume();
+    req.on('end', function() {
+      write(res);
+    });
+    this.close();
+  })
+  .listen(0, function() {
+    const req = http.request({
+      port: this.address().port,
+      method: 'PUT'
+    });
+    write(req);
+    req.on('response', function(res) {
+      res.resume();
+    });
   });
-});
 
 const buf = Buffer.alloc(1024 * 16, 'x');
 function write(out) {
diff --git a/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js b/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js
index 7249230cfadbb7..acbfa4aead5a13 100644
--- a/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js
+++ b/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js
@@ -8,29 +8,42 @@ const http = require('http');
 const net = require('net');
 
 for (const enc of ['utf8', 'utf16le', 'latin1', 'UTF-8']) {
-  const server = http.createServer(common.mustCall((req, res) => {
-    res.setHeader('content-type', `text/plain; charset=${enc}`);
-    res.write('helloworld', enc);
-    res.end();
-  })).listen(0);
+  const server = http
+    .createServer(
+      common.mustCall((req, res) => {
+        res.setHeader('content-type', `text/plain; charset=${enc}`);
+        res.write('helloworld', enc);
+        res.end();
+      })
+    )
+    .listen(0);
 
-  server.on('listening', common.mustCall(() => {
-    const buffers = [];
-    const socket = net.connect(server.address().port);
-    socket.write('GET / HTTP/1.0\r\n\r\n');
-    socket.on('data', (data) => buffers.push(data));
-    socket.on('end', common.mustCall(() => {
-      const received = Buffer.concat(buffers);
-      const headerEnd = received.indexOf('\r\n\r\n', 'utf8');
-      assert.notStrictEqual(headerEnd, -1);
+  server.on(
+    'listening',
+    common.mustCall(() => {
+      const buffers = [];
+      const socket = net.connect(server.address().port);
+      socket.write('GET / HTTP/1.0\r\n\r\n');
+      socket.on('data', (data) => buffers.push(data));
+      socket.on(
+        'end',
+        common.mustCall(() => {
+          const received = Buffer.concat(buffers);
+          const headerEnd = received.indexOf('\r\n\r\n', 'utf8');
+          assert.notStrictEqual(headerEnd, -1);
 
-      const header = received.toString('utf8', 0, headerEnd).split('\r\n');
-      const body = received.toString(enc, headerEnd + 4);
+          const header = received.toString('utf8', 0, headerEnd).split('\r\n');
+          const body = received.toString(enc, headerEnd + 4);
 
-      assert.strictEqual(header[0], 'HTTP/1.1 200 OK');
-      assert.strictEqual(header[1], `content-type: text/plain; charset=${enc}`);
-      assert.strictEqual(body, 'helloworld');
-      server.close();
-    }));
-  }));
+          assert.strictEqual(header[0], 'HTTP/1.1 200 OK');
+          assert.strictEqual(
+            header[1],
+            `content-type: text/plain; charset=${enc}`
+          );
+          assert.strictEqual(body, 'helloworld');
+          server.close();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http-outgoing-internal-headers.js b/test/parallel/test-http-outgoing-internal-headers.js
index de75a44e8a05d7..3bbfbeb4a804d5 100644
--- a/test/parallel/test-http-outgoing-internal-headers.js
+++ b/test/parallel/test-http-outgoing-internal-headers.js
@@ -26,5 +26,6 @@ const { OutgoingMessage } = require('http');
     Object.entries({
       host: ['host', 'risingstack.com'],
       origin: ['Origin', 'localhost']
-    }));
+    })
+  );
 }
diff --git a/test/parallel/test-http-outgoing-proto.js b/test/parallel/test-http-outgoing-proto.js
index 0070f5399470e0..158973df340183 100644
--- a/test/parallel/test-http-outgoing-proto.js
+++ b/test/parallel/test-http-outgoing-proto.js
@@ -7,91 +7,115 @@ const OutgoingMessage = http.OutgoingMessage;
 const ClientRequest = http.ClientRequest;
 const ServerResponse = http.ServerResponse;
 
-assert.strictEqual(
-  typeof ClientRequest.prototype._implicitHeader, 'function');
-assert.strictEqual(
-  typeof ServerResponse.prototype._implicitHeader, 'function');
+assert.strictEqual(typeof ClientRequest.prototype._implicitHeader, 'function');
+assert.strictEqual(typeof ServerResponse.prototype._implicitHeader, 'function');
 
 // validateHeader
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.setHeader();
-}, {
-  code: 'ERR_INVALID_HTTP_TOKEN',
-  type: TypeError,
-  message: 'Header name must be a valid HTTP token ["undefined"]'
-});
-
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.setHeader('test');
-}, {
-  code: 'ERR_HTTP_INVALID_HEADER_VALUE',
-  type: TypeError,
-  message: 'Invalid value "undefined" for header "test"'
-});
-
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.setHeader(404);
-}, {
-  code: 'ERR_INVALID_HTTP_TOKEN',
-  type: TypeError,
-  message: 'Header name must be a valid HTTP token ["404"]'
-});
-
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.setHeader.call({ _header: 'test' }, 'test', 'value');
-}, {
-  code: 'ERR_HTTP_HEADERS_SENT',
-  type: Error,
-  message: 'Cannot set headers after they are sent to the client'
-});
-
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.setHeader('200', 'あ');
-}, {
-  code: 'ERR_INVALID_CHAR',
-  type: TypeError,
-  message: 'Invalid character in header content ["200"]'
-});
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.setHeader();
+  },
+  {
+    code: 'ERR_INVALID_HTTP_TOKEN',
+    type: TypeError,
+    message: 'Header name must be a valid HTTP token ["undefined"]'
+  }
+);
+
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.setHeader('test');
+  },
+  {
+    code: 'ERR_HTTP_INVALID_HEADER_VALUE',
+    type: TypeError,
+    message: 'Invalid value "undefined" for header "test"'
+  }
+);
+
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.setHeader(404);
+  },
+  {
+    code: 'ERR_INVALID_HTTP_TOKEN',
+    type: TypeError,
+    message: 'Header name must be a valid HTTP token ["404"]'
+  }
+);
+
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.setHeader.call({ _header: 'test' }, 'test', 'value');
+  },
+  {
+    code: 'ERR_HTTP_HEADERS_SENT',
+    type: Error,
+    message: 'Cannot set headers after they are sent to the client'
+  }
+);
+
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.setHeader('200', 'あ');
+  },
+  {
+    code: 'ERR_INVALID_CHAR',
+    type: TypeError,
+    message: 'Invalid character in header content ["200"]'
+  }
+);
 
 // write
 {
   const outgoingMessage = new OutgoingMessage();
 
-  outgoingMessage.on('error', common.expectsError({
-    code: 'ERR_METHOD_NOT_IMPLEMENTED',
-    type: Error,
-    message: 'The _implicitHeader() method is not implemented'
-  }));
+  outgoingMessage.on(
+    'error',
+    common.expectsError({
+      code: 'ERR_METHOD_NOT_IMPLEMENTED',
+      type: Error,
+      message: 'The _implicitHeader() method is not implemented'
+    })
+  );
 
   outgoingMessage.write('');
 }
 
 assert(OutgoingMessage.prototype.write.call({ _header: 'test' }));
 
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.write.call({ _header: 'test', _hasBody: 'test' });
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The first argument must be one of type string or Buffer. ' +
-           'Received type undefined'
-});
-
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.write.call({ _header: 'test', _hasBody: 'test' }, 1);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The first argument must be one of type string or Buffer. ' +
-           'Received type number'
-});
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.write.call({ _header: 'test', _hasBody: 'test' });
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The first argument must be one of type string or Buffer. ' +
+      'Received type undefined'
+  }
+);
+
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.write.call({ _header: 'test', _hasBody: 'test' }, 1);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The first argument must be one of type string or Buffer. ' +
+      'Received type number'
+  }
+);
 
 // addTrailers()
 // The `Error` comes from the JavaScript engine so confirm that it is a
@@ -102,20 +126,26 @@ assert.throws(() => {
   outgoingMessage.addTrailers();
 }, TypeError);
 
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.addTrailers({ 'あ': 'value' });
-}, {
-  code: 'ERR_INVALID_HTTP_TOKEN',
-  type: TypeError,
-  message: 'Trailer name must be a valid HTTP token ["あ"]'
-});
-
-common.expectsError(() => {
-  const outgoingMessage = new OutgoingMessage();
-  outgoingMessage.addTrailers({ 404: 'あ' });
-}, {
-  code: 'ERR_INVALID_CHAR',
-  type: TypeError,
-  message: 'Invalid character in trailer content ["404"]'
-});
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.addTrailers({ あ: 'value' });
+  },
+  {
+    code: 'ERR_INVALID_HTTP_TOKEN',
+    type: TypeError,
+    message: 'Trailer name must be a valid HTTP token ["あ"]'
+  }
+);
+
+common.expectsError(
+  () => {
+    const outgoingMessage = new OutgoingMessage();
+    outgoingMessage.addTrailers({ 404: 'あ' });
+  },
+  {
+    code: 'ERR_INVALID_CHAR',
+    type: TypeError,
+    message: 'Invalid character in trailer content ["404"]'
+  }
+);
diff --git a/test/parallel/test-http-outgoing-renderHeaders.js b/test/parallel/test-http-outgoing-renderHeaders.js
index 138ab967539edb..b73379dcdb76f3 100644
--- a/test/parallel/test-http-outgoing-renderHeaders.js
+++ b/test/parallel/test-http-outgoing-renderHeaders.js
@@ -11,14 +11,11 @@ const OutgoingMessage = http.OutgoingMessage;
 {
   const outgoingMessage = new OutgoingMessage();
   outgoingMessage._header = {};
-  common.expectsError(
-    outgoingMessage._renderHeaders.bind(outgoingMessage),
-    {
-      code: 'ERR_HTTP_HEADERS_SENT',
-      type: Error,
-      message: 'Cannot render headers after they are sent to the client'
-    }
-  );
+  common.expectsError(outgoingMessage._renderHeaders.bind(outgoingMessage), {
+    code: 'ERR_HTTP_HEADERS_SENT',
+    type: Error,
+    message: 'Cannot render headers after they are sent to the client'
+  });
 }
 
 {
@@ -28,7 +25,6 @@ const OutgoingMessage = http.OutgoingMessage;
   assert.deepStrictEqual(result, {});
 }
 
-
 {
   const outgoingMessage = new OutgoingMessage();
   outgoingMessage[outHeadersKey] = {};
diff --git a/test/parallel/test-http-parser-bad-ref.js b/test/parallel/test-http-parser-bad-ref.js
index 5b002b2ce0e926..146411a509e1a9 100644
--- a/test/parallel/test-http-parser-bad-ref.js
+++ b/test/parallel/test-http-parser-bad-ref.js
@@ -46,7 +46,6 @@ function demoBug(part1, part2) {
     messagesComplete++;
   };
 
-
   // We use a function to eliminate references to the Buffer b
   // We want b to be GCed. The parser will hold a bad reference to it.
   (function() {
@@ -70,16 +69,18 @@ function demoBug(part1, part2) {
   flushPool();
 }
 
-
-demoBug('POST /1', '/22 HTTP/1.1\r\n' +
-        'Content-Type: text/plain\r\n' +
-        'Content-Length: 4\r\n\r\n' +
-        'pong');
-
-demoBug('POST /1/22 HTTP/1.1\r\n' +
-        'Content-Type: tex', 't/plain\r\n' +
-        'Content-Length: 4\r\n\r\n' +
-        'pong');
+demoBug(
+  'POST /1',
+  '/22 HTTP/1.1\r\n' +
+    'Content-Type: text/plain\r\n' +
+    'Content-Length: 4\r\n\r\n' +
+    'pong'
+);
+
+demoBug(
+  'POST /1/22 HTTP/1.1\r\n' + 'Content-Type: tex',
+  't/plain\r\n' + 'Content-Length: 4\r\n\r\n' + 'pong'
+);
 
 process.on('exit', function() {
   assert.strictEqual(headersComplete, 2);
diff --git a/test/parallel/test-http-parser-freed-before-upgrade.js b/test/parallel/test-http-parser-freed-before-upgrade.js
index 4ba1de9501681c..c7cb16a1df9c78 100644
--- a/test/parallel/test-http-parser-freed-before-upgrade.js
+++ b/test/parallel/test-http-parser-freed-before-upgrade.js
@@ -6,28 +6,38 @@ const http = require('http');
 
 const server = http.createServer();
 
-server.on('upgrade', common.mustCall((request, socket) => {
-  assert.strictEqual(socket.parser, null);
-  socket.write([
-    'HTTP/1.1 101 Switching Protocols',
-    'Connection: Upgrade',
-    'Upgrade: WebSocket',
-    '\r\n'
-  ].join('\r\n'));
-}));
+server.on(
+  'upgrade',
+  common.mustCall((request, socket) => {
+    assert.strictEqual(socket.parser, null);
+    socket.write(
+      [
+        'HTTP/1.1 101 Switching Protocols',
+        'Connection: Upgrade',
+        'Upgrade: WebSocket',
+        '\r\n'
+      ].join('\r\n')
+    );
+  })
+);
 
-server.listen(common.mustCall(() => {
-  const request = http.get({
-    port: server.address().port,
-    headers: {
-      Connection: 'Upgrade',
-      Upgrade: 'WebSocket'
-    }
-  });
+server.listen(
+  common.mustCall(() => {
+    const request = http.get({
+      port: server.address().port,
+      headers: {
+        Connection: 'Upgrade',
+        Upgrade: 'WebSocket'
+      }
+    });
 
-  request.on('upgrade', common.mustCall((response, socket) => {
-    assert.strictEqual(socket.parser, null);
-    socket.destroy();
-    server.close();
-  }));
-}));
+    request.on(
+      'upgrade',
+      common.mustCall((response, socket) => {
+        assert.strictEqual(socket.parser, null);
+        socket.destroy();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-parser-lazy-loaded.js b/test/parallel/test-http-parser-lazy-loaded.js
index c1eb29fb163d00..5dec72acc30ef2 100644
--- a/test/parallel/test-http-parser-lazy-loaded.js
+++ b/test/parallel/test-http-parser-lazy-loaded.js
@@ -25,13 +25,18 @@ assert.strictEqual(parser.test_type, DummyParser.REQUEST);
 
 if (process.argv[2] !== 'child') {
   // Also test in a child process with IPC (specific case of https://github.com/nodejs/node/issues/23716)
-  const child = spawn(process.execPath, [
-    '--expose-internals', __filename, 'child'
-  ], {
-    stdio: ['inherit', 'inherit', 'inherit', 'ipc']
-  });
-  child.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  }));
+  const child = spawn(
+    process.execPath,
+    ['--expose-internals', __filename, 'child'],
+    {
+      stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+    }
+  );
+  child.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 }
diff --git a/test/parallel/test-http-parser.js b/test/parallel/test-http-parser.js
index 36f41f79e59dcf..2546de2e982ec7 100644
--- a/test/parallel/test-http-parser.js
+++ b/test/parallel/test-http-parser.js
@@ -39,7 +39,6 @@ const kOnMessageComplete = HTTPParser.kOnMessageComplete | 0;
 // upstream to https://github.com/joyent/http-parser for inclusion into
 // deps/http-parser/test.c
 
-
 function newParser(type) {
   const parser = new HTTPParser(type);
 
@@ -51,18 +50,15 @@ function newParser(type) {
     parser.url += url;
   };
 
-  parser[kOnHeadersComplete] = function() {
-  };
+  parser[kOnHeadersComplete] = function() {};
 
   parser[kOnBody] = mustNotCall('kOnBody should not be called');
 
-  parser[kOnMessageComplete] = function() {
-  };
+  parser[kOnMessageComplete] = function() {};
 
   return parser;
 }
 
-
 function expectBody(expected) {
   return mustCall(function(buf, start, len) {
     const body = String(buf.slice(start, start + len));
@@ -70,15 +66,19 @@ function expectBody(expected) {
   });
 }
 
-
 //
 // Simple request test.
 //
 {
   const request = Buffer.from('GET /hello HTTP/1.1\r\n\r\n');
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url) => {
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(versionMajor, 1);
     assert.strictEqual(versionMinor, 1);
     assert.strictEqual(method, methods.indexOf('GET'));
@@ -101,26 +101,34 @@ function expectBody(expected) {
   parser.reinitialize(HTTPParser.REQUEST, false);
 
   assert.throws(
-    () => { parser.execute(request, 0, request.length); },
+    () => {
+      parser.execute(request, 0, request.length);
+    },
     { name: 'Error', message: 'hello world' }
   );
 }
 
-
 //
 // Simple response test.
 //
 {
   const request = Buffer.from(
     'HTTP/1.1 200 OK\r\n' +
-    'Content-Type: text/plain\r\n' +
-    'Content-Length: 4\r\n' +
-    '\r\n' +
-    'pong'
+      'Content-Type: text/plain\r\n' +
+      'Content-Length: 4\r\n' +
+      '\r\n' +
+      'pong'
   );
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url, statusCode, statusMessage) => {
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url,
+    statusCode,
+    statusMessage
+  ) => {
     assert.strictEqual(method, undefined);
     assert.strictEqual(versionMajor, 1);
     assert.strictEqual(versionMinor, 1);
@@ -139,16 +147,21 @@ function expectBody(expected) {
   parser.execute(request, 0, request.length);
 }
 
-
 //
 // Response with no headers.
 //
 {
-  const request = Buffer.from(
-    'HTTP/1.0 200 Connection established\r\n\r\n');
-
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url, statusCode, statusMessage) => {
+  const request = Buffer.from('HTTP/1.0 200 Connection established\r\n\r\n');
+
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url,
+    statusCode,
+    statusMessage
+  ) => {
     assert.strictEqual(versionMajor, 1);
     assert.strictEqual(versionMinor, 0);
     assert.strictEqual(method, undefined);
@@ -162,33 +175,41 @@ function expectBody(expected) {
   parser.execute(request, 0, request.length);
 }
 
-
 //
 // Trailing headers.
 //
 {
   const request = Buffer.from(
     'POST /it HTTP/1.1\r\n' +
-    'Transfer-Encoding: chunked\r\n' +
-    '\r\n' +
-    '4\r\n' +
-    'ping\r\n' +
-    '0\r\n' +
-    'Vary: *\r\n' +
-    'Content-Type: text/plain\r\n' +
-    '\r\n'
+      'Transfer-Encoding: chunked\r\n' +
+      '\r\n' +
+      '4\r\n' +
+      'ping\r\n' +
+      '0\r\n' +
+      'Vary: *\r\n' +
+      'Content-Type: text/plain\r\n' +
+      '\r\n'
   );
 
   let seen_body = false;
 
   const onHeaders = (headers) => {
     assert.ok(seen_body); // trailers should come after the body
-    assert.deepStrictEqual(headers,
-                           ['Vary', '*', 'Content-Type', 'text/plain']);
+    assert.deepStrictEqual(headers, [
+      'Vary',
+      '*',
+      'Content-Type',
+      'text/plain'
+    ]);
   };
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url) => {
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(method, methods.indexOf('POST'));
     assert.strictEqual(url || parser.url, '/it');
     assert.strictEqual(versionMajor, 1);
@@ -209,27 +230,30 @@ function expectBody(expected) {
   parser.execute(request, 0, request.length);
 }
 
-
 //
 // Test header ordering.
 //
 {
   const request = Buffer.from(
     'GET / HTTP/1.0\r\n' +
-    'X-Filler: 1337\r\n' +
-    'X-Filler:   42\r\n' +
-    'X-Filler2:  42\r\n' +
-    '\r\n'
+      'X-Filler: 1337\r\n' +
+      'X-Filler:   42\r\n' +
+      'X-Filler2:  42\r\n' +
+      '\r\n'
   );
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method) => {
+  const onHeadersComplete = (versionMajor, versionMinor, headers, method) => {
     assert.strictEqual(method, methods.indexOf('GET'));
     assert.strictEqual(versionMajor, 1);
     assert.strictEqual(versionMinor, 0);
-    assert.deepStrictEqual(
-      headers || parser.headers,
-      ['X-Filler', '1337', 'X-Filler', '42', 'X-Filler2', '42']);
+    assert.deepStrictEqual(headers || parser.headers, [
+      'X-Filler',
+      '1337',
+      'X-Filler',
+      '42',
+      'X-Filler2',
+      '42'
+    ]);
   };
 
   const parser = newParser(REQUEST);
@@ -237,7 +261,6 @@ function expectBody(expected) {
   parser.execute(request, 0, request.length);
 }
 
-
 //
 // Test large number of headers
 //
@@ -246,13 +269,16 @@ function expectBody(expected) {
   const lots_of_headers = 'X-Filler: 42\r\n'.repeat(256);
 
   const request = Buffer.from(
-    'GET /foo/bar/baz?quux=42#1337 HTTP/1.0\r\n' +
-    lots_of_headers +
-    '\r\n'
+    'GET /foo/bar/baz?quux=42#1337 HTTP/1.0\r\n' + lots_of_headers + '\r\n'
   );
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url) => {
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(method, methods.indexOf('GET'));
     assert.strictEqual(url || parser.url, '/foo/bar/baz?quux=42#1337');
     assert.strictEqual(versionMajor, 1);
@@ -272,21 +298,25 @@ function expectBody(expected) {
   parser.execute(request, 0, request.length);
 }
 
-
 //
 // Test request body
 //
 {
   const request = Buffer.from(
     'POST /it HTTP/1.1\r\n' +
-    'Content-Type: application/x-www-form-urlencoded\r\n' +
-    'Content-Length: 15\r\n' +
-    '\r\n' +
-    'foo=42&bar=1337'
+      'Content-Type: application/x-www-form-urlencoded\r\n' +
+      'Content-Length: 15\r\n' +
+      '\r\n' +
+      'foo=42&bar=1337'
   );
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url) => {
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(method, methods.indexOf('POST'));
     assert.strictEqual(url || parser.url, '/it');
     assert.strictEqual(versionMajor, 1);
@@ -304,27 +334,31 @@ function expectBody(expected) {
   parser.execute(request, 0, request.length);
 }
 
-
 //
 // Test chunked request body
 //
 {
   const request = Buffer.from(
     'POST /it HTTP/1.1\r\n' +
-    'Content-Type: text/plain\r\n' +
-    'Transfer-Encoding: chunked\r\n' +
-    '\r\n' +
-    '3\r\n' +
-    '123\r\n' +
-    '6\r\n' +
-    '123456\r\n' +
-    'A\r\n' +
-    '1234567890\r\n' +
-    '0\r\n'
+      'Content-Type: text/plain\r\n' +
+      'Transfer-Encoding: chunked\r\n' +
+      '\r\n' +
+      '3\r\n' +
+      '123\r\n' +
+      '6\r\n' +
+      '123456\r\n' +
+      'A\r\n' +
+      '1234567890\r\n' +
+      '0\r\n'
   );
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url) => {
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(method, methods.indexOf('POST'));
     assert.strictEqual(url || parser.url, '/it');
     assert.strictEqual(versionMajor, 1);
@@ -345,24 +379,28 @@ function expectBody(expected) {
   parser.execute(request, 0, request.length);
 }
 
-
 //
 // Test chunked request body spread over multiple buffers (packets)
 //
 {
   let request = Buffer.from(
     'POST /it HTTP/1.1\r\n' +
-    'Content-Type: text/plain\r\n' +
-    'Transfer-Encoding: chunked\r\n' +
-    '\r\n' +
-    '3\r\n' +
-    '123\r\n' +
-    '6\r\n' +
-    '123456\r\n'
+      'Content-Type: text/plain\r\n' +
+      'Transfer-Encoding: chunked\r\n' +
+      '\r\n' +
+      '3\r\n' +
+      '123\r\n' +
+      '6\r\n' +
+      '123456\r\n'
   );
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url) => {
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(method, methods.indexOf('POST'));
     assert.strictEqual(url || parser.url, '/it');
     assert.strictEqual(versionMajor, 1);
@@ -370,8 +408,13 @@ function expectBody(expected) {
   };
 
   let body_part = 0;
-  const body_parts =
-          ['123', '123456', '123456789', '123456789ABC', '123456789ABCDEF'];
+  const body_parts = [
+    '123',
+    '123456',
+    '123456789',
+    '123456789ABC',
+    '123456789ABCDEF'
+  ];
 
   const onBody = (buf, start, len) => {
     const body = String(buf.slice(start, start + len));
@@ -385,43 +428,47 @@ function expectBody(expected) {
 
   request = Buffer.from(
     '9\r\n' +
-    '123456789\r\n' +
-    'C\r\n' +
-    '123456789ABC\r\n' +
-    'F\r\n' +
-    '123456789ABCDEF\r\n' +
-    '0\r\n'
+      '123456789\r\n' +
+      'C\r\n' +
+      '123456789ABC\r\n' +
+      'F\r\n' +
+      '123456789ABCDEF\r\n' +
+      '0\r\n'
   );
 
   parser.execute(request, 0, request.length);
 }
 
-
 //
 // Stress test.
 //
 {
   const request = Buffer.from(
     'POST /helpme HTTP/1.1\r\n' +
-    'Content-Type: text/plain\r\n' +
-    'Transfer-Encoding: chunked\r\n' +
-    '\r\n' +
-    '3\r\n' +
-    '123\r\n' +
-    '6\r\n' +
-    '123456\r\n' +
-    '9\r\n' +
-    '123456789\r\n' +
-    'C\r\n' +
-    '123456789ABC\r\n' +
-    'F\r\n' +
-    '123456789ABCDEF\r\n' +
-    '0\r\n'
+      'Content-Type: text/plain\r\n' +
+      'Transfer-Encoding: chunked\r\n' +
+      '\r\n' +
+      '3\r\n' +
+      '123\r\n' +
+      '6\r\n' +
+      '123456\r\n' +
+      '9\r\n' +
+      '123456789\r\n' +
+      'C\r\n' +
+      '123456789ABC\r\n' +
+      'F\r\n' +
+      '123456789ABCDEF\r\n' +
+      '0\r\n'
   );
 
   function test(a, b) {
-    const onHeadersComplete = (versionMajor, versionMinor, headers,
-                               method, url) => {
+    const onHeadersComplete = (
+      versionMajor,
+      versionMinor,
+      headers,
+      method,
+      url
+    ) => {
       assert.strictEqual(method, methods.indexOf('POST'));
       assert.strictEqual(url || parser.url, '/helpme');
       assert.strictEqual(versionMajor, 1);
@@ -454,38 +501,45 @@ function expectBody(expected) {
   }
 }
 
-
 //
 // Byte by byte test.
 //
 {
   const request = Buffer.from(
     'POST /it HTTP/1.1\r\n' +
-    'Content-Type: text/plain\r\n' +
-    'Transfer-Encoding: chunked\r\n' +
-    '\r\n' +
-    '3\r\n' +
-    '123\r\n' +
-    '6\r\n' +
-    '123456\r\n' +
-    '9\r\n' +
-    '123456789\r\n' +
-    'C\r\n' +
-    '123456789ABC\r\n' +
-    'F\r\n' +
-    '123456789ABCDEF\r\n' +
-    '0\r\n'
+      'Content-Type: text/plain\r\n' +
+      'Transfer-Encoding: chunked\r\n' +
+      '\r\n' +
+      '3\r\n' +
+      '123\r\n' +
+      '6\r\n' +
+      '123456\r\n' +
+      '9\r\n' +
+      '123456789\r\n' +
+      'C\r\n' +
+      '123456789ABC\r\n' +
+      'F\r\n' +
+      '123456789ABCDEF\r\n' +
+      '0\r\n'
   );
 
-  const onHeadersComplete = (versionMajor, versionMinor, headers,
-                             method, url) => {
+  const onHeadersComplete = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(method, methods.indexOf('POST'));
     assert.strictEqual(url || parser.url, '/it');
     assert.strictEqual(versionMajor, 1);
     assert.strictEqual(versionMinor, 1);
-    assert.deepStrictEqual(
-      headers || parser.headers,
-      ['Content-Type', 'text/plain', 'Transfer-Encoding', 'chunked']);
+    assert.deepStrictEqual(headers || parser.headers, [
+      'Content-Type',
+      'text/plain',
+      'Transfer-Encoding',
+      'chunked'
+    ]);
   };
 
   let expected_body = '123123456123456789123456789ABC123456789ABCDEF';
@@ -507,50 +561,64 @@ function expectBody(expected) {
   assert.strictEqual(expected_body, '');
 }
 
-
 //
 // Test parser reinit sequence.
 //
 {
   const req1 = Buffer.from(
     'PUT /this HTTP/1.1\r\n' +
-    'Content-Type: text/plain\r\n' +
-    'Transfer-Encoding: chunked\r\n' +
-    '\r\n' +
-    '4\r\n' +
-    'ping\r\n' +
-    '0\r\n'
+      'Content-Type: text/plain\r\n' +
+      'Transfer-Encoding: chunked\r\n' +
+      '\r\n' +
+      '4\r\n' +
+      'ping\r\n' +
+      '0\r\n'
   );
 
   const req2 = Buffer.from(
     'POST /that HTTP/1.0\r\n' +
-    'Content-Type: text/plain\r\n' +
-    'Content-Length: 4\r\n' +
-    '\r\n' +
-    'pong'
+      'Content-Type: text/plain\r\n' +
+      'Content-Length: 4\r\n' +
+      '\r\n' +
+      'pong'
   );
 
-  const onHeadersComplete1 = (versionMajor, versionMinor, headers,
-                              method, url) => {
+  const onHeadersComplete1 = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(method, methods.indexOf('PUT'));
     assert.strictEqual(url, '/this');
     assert.strictEqual(versionMajor, 1);
     assert.strictEqual(versionMinor, 1);
-    assert.deepStrictEqual(
-      headers,
-      ['Content-Type', 'text/plain', 'Transfer-Encoding', 'chunked']);
+    assert.deepStrictEqual(headers, [
+      'Content-Type',
+      'text/plain',
+      'Transfer-Encoding',
+      'chunked'
+    ]);
   };
 
-  const onHeadersComplete2 = (versionMajor, versionMinor, headers,
-                              method, url) => {
+  const onHeadersComplete2 = (
+    versionMajor,
+    versionMinor,
+    headers,
+    method,
+    url
+  ) => {
     assert.strictEqual(method, methods.indexOf('POST'));
     assert.strictEqual(url, '/that');
     assert.strictEqual(versionMajor, 1);
     assert.strictEqual(versionMinor, 0);
-    assert.deepStrictEqual(
-      headers,
-      ['Content-Type', 'text/plain', 'Content-Length', '4']
-    );
+    assert.deepStrictEqual(headers, [
+      'Content-Type',
+      'text/plain',
+      'Content-Length',
+      '4'
+    ]);
   };
 
   const parser = newParser(REQUEST);
diff --git a/test/parallel/test-http-pause-no-dump.js b/test/parallel/test-http-pause-no-dump.js
index b794634c489326..011a4f5465f605 100644
--- a/test/parallel/test-http-pause-no-dump.js
+++ b/test/parallel/test-http-pause-no-dump.js
@@ -4,30 +4,47 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  req.once('data', common.mustCall(() => {
-    req.pause();
-    res.writeHead(200);
-    res.end();
-    res.on('finish', common.mustCall(() => {
-      assert(!req._dumped);
-    }));
-  }));
-}));
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    req.once(
+      'data',
+      common.mustCall(() => {
+        req.pause();
+        res.writeHead(200);
+        res.end();
+        res.on(
+          'finish',
+          common.mustCall(() => {
+            assert(!req._dumped);
+          })
+        );
+      })
+    );
+  })
+);
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const req = http.request({
-    port: this.address().port,
-    method: 'POST',
-    path: '/'
-  }, common.mustCall(function(res) {
-    assert.strictEqual(res.statusCode, 200);
-    res.resume();
-    res.on('end', common.mustCall(() => {
-      server.close();
-    }));
-  }));
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const req = http.request(
+      {
+        port: this.address().port,
+        method: 'POST',
+        path: '/'
+      },
+      common.mustCall(function(res) {
+        assert.strictEqual(res.statusCode, 200);
+        res.resume();
+        res.on(
+          'end',
+          common.mustCall(() => {
+            server.close();
+          })
+        );
+      })
+    );
 
-  req.end(Buffer.allocUnsafe(1024));
-}));
+    req.end(Buffer.allocUnsafe(1024));
+  })
+);
diff --git a/test/parallel/test-http-pause-resume-one-end.js b/test/parallel/test-http-pause-resume-one-end.js
index 4886a7d490e413..a0df0bcf304fa3 100644
--- a/test/parallel/test-http-pause-resume-one-end.js
+++ b/test/parallel/test-http-pause-resume-one-end.js
@@ -29,20 +29,29 @@ const server = http.Server(function(req, res) {
   server.close();
 });
 
-server.listen(0, common.mustCall(function() {
-  const opts = {
-    port: this.address().port,
-    headers: { connection: 'close' }
-  };
+server.listen(
+  0,
+  common.mustCall(function() {
+    const opts = {
+      port: this.address().port,
+      headers: { connection: 'close' }
+    };
 
-  http.get(opts, common.mustCall(function(res) {
-    res.on('data', common.mustCall(function() {
-      res.pause();
-      setImmediate(function() {
-        res.resume();
-      });
-    }));
+    http.get(
+      opts,
+      common.mustCall(function(res) {
+        res.on(
+          'data',
+          common.mustCall(function() {
+            res.pause();
+            setImmediate(function() {
+              res.resume();
+            });
+          })
+        );
 
-    res.on('end', common.mustCall());
-  }));
-}));
+        res.on('end', common.mustCall());
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-pause.js b/test/parallel/test-http-pause.js
index e2f462582ffa0a..e7ce0cdf9ed5e1 100644
--- a/test/parallel/test-http-pause.js
+++ b/test/parallel/test-http-pause.js
@@ -48,25 +48,28 @@ const server = http.createServer((req, res) => {
 });
 
 server.listen(0, function() {
-  const req = http.request({
-    port: this.address().port,
-    path: '/',
-    method: 'POST'
-  }, (res) => {
-    console.error('pause client response');
-    res.pause();
-    setTimeout(() => {
-      console.error('resume client response');
-      res.resume();
-      res.on('data', (chunk) => {
-        resultClient += chunk;
-      });
-      res.on('end', () => {
-        console.error(resultClient);
-        server.close();
-      });
-    }, 100);
-  });
+  const req = http.request(
+    {
+      port: this.address().port,
+      path: '/',
+      method: 'POST'
+    },
+    (res) => {
+      console.error('pause client response');
+      res.pause();
+      setTimeout(() => {
+        console.error('resume client response');
+        res.resume();
+        res.on('data', (chunk) => {
+          resultClient += chunk;
+        });
+        res.on('end', () => {
+          console.error(resultClient);
+          server.close();
+        });
+      }, 100);
+    }
+  );
   req.end(expectedServer);
 });
 
diff --git a/test/parallel/test-http-pipe-fs.js b/test/parallel/test-http-pipe-fs.js
index dfb44ff3b25d99..040f9e5705edc9 100644
--- a/test/parallel/test-http-pipe-fs.js
+++ b/test/parallel/test-http-pipe-fs.js
@@ -34,33 +34,40 @@ tmpdir.refresh();
 
 const file = path.join(tmpdir.path, 'http-pipe-fs-test.txt');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  const stream = fs.createWriteStream(file);
-  req.pipe(stream);
-  stream.on('close', function() {
-    res.writeHead(200);
-    res.end();
-  });
-}, 2)).listen(0, function() {
-  http.globalAgent.maxSockets = 1;
+const server = http
+  .createServer(
+    common.mustCall(function(req, res) {
+      const stream = fs.createWriteStream(file);
+      req.pipe(stream);
+      stream.on('close', function() {
+        res.writeHead(200);
+        res.end();
+      });
+    }, 2)
+  )
+  .listen(0, function() {
+    http.globalAgent.maxSockets = 1;
 
-  for (let i = 0; i < NUMBER_OF_STREAMS; ++i) {
-    const req = http.request({
-      port: server.address().port,
-      method: 'POST',
-      headers: {
-        'Content-Length': 5
-      }
-    }, function(res) {
-      res.on('end', function() {
-        console.error(`res${i + 1} end`);
-        countdown.dec();
+    for (let i = 0; i < NUMBER_OF_STREAMS; ++i) {
+      const req = http.request(
+        {
+          port: server.address().port,
+          method: 'POST',
+          headers: {
+            'Content-Length': 5
+          }
+        },
+        function(res) {
+          res.on('end', function() {
+            console.error(`res${i + 1} end`);
+            countdown.dec();
+          });
+          res.resume();
+        }
+      );
+      req.on('socket', function(s) {
+        console.error(`req${i + 1} start`);
       });
-      res.resume();
-    });
-    req.on('socket', function(s) {
-      console.error(`req${i + 1} start`);
-    });
-    req.end('12345');
-  }
-});
+      req.end('12345');
+    }
+  });
diff --git a/test/parallel/test-http-pipeline-flood.js b/test/parallel/test-http-pipeline-flood.js
index 29df81e857db60..ea5557905f29c9 100644
--- a/test/parallel/test-http-pipeline-flood.js
+++ b/test/parallel/test-http-pipeline-flood.js
@@ -52,13 +52,19 @@ function parent() {
     const spawn = require('child_process').spawn;
     const args = [__filename, 'child', this.address().port];
     const child = spawn(process.execPath, args, { stdio: 'inherit' });
-    child.on('close', common.mustCall(function() {
-      server.close();
-    }));
-
-    server.setTimeout(200, common.mustCallAtLeast(function() {
-      child.kill();
-    }, 1));
+    child.on(
+      'close',
+      common.mustCall(function() {
+        server.close();
+      })
+    );
+
+    server.setTimeout(
+      200,
+      common.mustCallAtLeast(function() {
+        child.kill();
+      }, 1)
+    );
   });
 }
 
diff --git a/test/parallel/test-http-pipeline-requests-connection-leak.js b/test/parallel/test-http-pipeline-requests-connection-leak.js
index aa5db56f77862b..322d2d2b06924e 100644
--- a/test/parallel/test-http-pipeline-requests-connection-leak.js
+++ b/test/parallel/test-http-pipeline-requests-connection-leak.js
@@ -27,8 +27,11 @@ const server = http
   })
   .listen(0, function() {
     const req = 'GET / HTTP/1.1\r\n\r\n'.repeat(COUNT);
-    client = net.connect(this.address().port, function() {
-      client.write(req);
-    });
+    client = net.connect(
+      this.address().port,
+      function() {
+        client.write(req);
+      }
+    );
     client.resume();
   });
diff --git a/test/parallel/test-http-proxy.js b/test/parallel/test-http-proxy.js
index 6a986024af29be..a136be2d72a164 100644
--- a/test/parallel/test-http-proxy.js
+++ b/test/parallel/test-http-proxy.js
@@ -30,9 +30,11 @@ const cookies = [
   'prefers_open_id=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT'
 ];
 
-const headers = { 'content-type': 'text/plain',
-                  'set-cookie': cookies,
-                  'hello': 'world' };
+const headers = {
+  'content-type': 'text/plain',
+  'set-cookie': cookies,
+  hello: 'world'
+};
 
 const backend = http.createServer(function(req, res) {
   console.error('backend request');
@@ -43,28 +45,30 @@ const backend = http.createServer(function(req, res) {
 
 const proxy = http.createServer(function(req, res) {
   console.error(`proxy req headers: ${JSON.stringify(req.headers)}`);
-  http.get({
-    port: backend.address().port,
-    path: url.parse(req.url).pathname
-  }, function(proxy_res) {
-
-    console.error(`proxy res headers: ${JSON.stringify(proxy_res.headers)}`);
-
-    assert.strictEqual(proxy_res.headers.hello, 'world');
-    assert.strictEqual(proxy_res.headers['content-type'], 'text/plain');
-    assert.deepStrictEqual(proxy_res.headers['set-cookie'], cookies);
-
-    res.writeHead(proxy_res.statusCode, proxy_res.headers);
-
-    proxy_res.on('data', function(chunk) {
-      res.write(chunk);
-    });
-
-    proxy_res.on('end', function() {
-      res.end();
-      console.error('proxy res');
-    });
-  });
+  http.get(
+    {
+      port: backend.address().port,
+      path: url.parse(req.url).pathname
+    },
+    function(proxy_res) {
+      console.error(`proxy res headers: ${JSON.stringify(proxy_res.headers)}`);
+
+      assert.strictEqual(proxy_res.headers.hello, 'world');
+      assert.strictEqual(proxy_res.headers['content-type'], 'text/plain');
+      assert.deepStrictEqual(proxy_res.headers['set-cookie'], cookies);
+
+      res.writeHead(proxy_res.statusCode, proxy_res.headers);
+
+      proxy_res.on('data', function(chunk) {
+        res.write(chunk);
+      });
+
+      proxy_res.on('end', function() {
+        res.end();
+        console.error('proxy res');
+      });
+    }
+  );
 });
 
 let body = '';
@@ -74,25 +78,30 @@ function startReq() {
   nlistening++;
   if (nlistening < 2) return;
 
-  http.get({
-    port: proxy.address().port,
-    path: '/test'
-  }, function(res) {
-    console.error('got res');
-    assert.strictEqual(res.statusCode, 200);
-
-    assert.strictEqual(res.headers.hello, 'world');
-    assert.strictEqual(res.headers['content-type'], 'text/plain');
-    assert.deepStrictEqual(res.headers['set-cookie'], cookies);
-
-    res.setEncoding('utf8');
-    res.on('data', function(chunk) { body += chunk; });
-    res.on('end', function() {
-      proxy.close();
-      backend.close();
-      console.error('closed both');
-    });
-  });
+  http.get(
+    {
+      port: proxy.address().port,
+      path: '/test'
+    },
+    function(res) {
+      console.error('got res');
+      assert.strictEqual(res.statusCode, 200);
+
+      assert.strictEqual(res.headers.hello, 'world');
+      assert.strictEqual(res.headers['content-type'], 'text/plain');
+      assert.deepStrictEqual(res.headers['set-cookie'], cookies);
+
+      res.setEncoding('utf8');
+      res.on('data', function(chunk) {
+        body += chunk;
+      });
+      res.on('end', function() {
+        proxy.close();
+        backend.close();
+        console.error('closed both');
+      });
+    }
+  );
   console.error('client req');
 }
 
diff --git a/test/parallel/test-http-raw-headers.js b/test/parallel/test-http-raw-headers.js
index 8ce20db351302c..4cb0cca1b1e43c 100644
--- a/test/parallel/test-http-raw-headers.js
+++ b/test/parallel/test-http-raw-headers.js
@@ -25,103 +25,107 @@ const assert = require('assert');
 
 const http = require('http');
 
-http.createServer(function(req, res) {
-  const expectRawHeaders = [
-    'Host',
-    `localhost:${this.address().port}`,
-    'transfer-ENCODING',
-    'CHUNKED',
-    'x-BaR',
-    'yoyoyo',
-    'Connection',
-    'close'
-  ];
-  const expectHeaders = {
-    'host': `localhost:${this.address().port}`,
-    'transfer-encoding': 'CHUNKED',
-    'x-bar': 'yoyoyo',
-    'connection': 'close'
-  };
-  const expectRawTrailers = [
-    'x-bAr',
-    'yOyOyOy',
-    'x-baR',
-    'OyOyOyO',
-    'X-bAr',
-    'yOyOyOy',
-    'X-baR',
-    'OyOyOyO'
-  ];
-  const expectTrailers = { 'x-bar': 'yOyOyOy, OyOyOyO, yOyOyOy, OyOyOyO' };
-
-  this.close();
-
-  assert.deepStrictEqual(req.rawHeaders, expectRawHeaders);
-  assert.deepStrictEqual(req.headers, expectHeaders);
-
-  req.on('end', function() {
-    assert.deepStrictEqual(req.rawTrailers, expectRawTrailers);
-    assert.deepStrictEqual(req.trailers, expectTrailers);
-  });
-
-  req.resume();
-  res.setHeader('Trailer', 'x-foo');
-  res.addTrailers([
-    ['x-fOo', 'xOxOxOx'],
-    ['x-foO', 'OxOxOxO'],
-    ['X-fOo', 'xOxOxOx'],
-    ['X-foO', 'OxOxOxO']
-  ]);
-  res.end('x f o o');
-}).listen(0, function() {
-  const req = http.request({ port: this.address().port, path: '/' });
-  req.addTrailers([
-    ['x-bAr', 'yOyOyOy'],
-    ['x-baR', 'OyOyOyO'],
-    ['X-bAr', 'yOyOyOy'],
-    ['X-baR', 'OyOyOyO']
-  ]);
-  req.setHeader('transfer-ENCODING', 'CHUNKED');
-  req.setHeader('x-BaR', 'yoyoyo');
-  req.end('y b a r');
-  req.on('response', function(res) {
+http
+  .createServer(function(req, res) {
     const expectRawHeaders = [
-      'Trailer',
-      'x-foo',
-      'Date',
-      null,
+      'Host',
+      `localhost:${this.address().port}`,
+      'transfer-ENCODING',
+      'CHUNKED',
+      'x-BaR',
+      'yoyoyo',
       'Connection',
-      'close',
-      'Transfer-Encoding',
-      'chunked'
+      'close'
     ];
     const expectHeaders = {
-      'trailer': 'x-foo',
-      'date': null,
-      'connection': 'close',
-      'transfer-encoding': 'chunked'
+      host: `localhost:${this.address().port}`,
+      'transfer-encoding': 'CHUNKED',
+      'x-bar': 'yoyoyo',
+      connection: 'close'
     };
-    res.rawHeaders[3] = null;
-    res.headers.date = null;
-    assert.deepStrictEqual(res.rawHeaders, expectRawHeaders);
-    assert.deepStrictEqual(res.headers, expectHeaders);
-    res.on('end', function() {
-      const expectRawTrailers = [
-        'x-fOo',
-        'xOxOxOx',
-        'x-foO',
-        'OxOxOxO',
-        'X-fOo',
-        'xOxOxOx',
-        'X-foO',
-        'OxOxOxO'
+    const expectRawTrailers = [
+      'x-bAr',
+      'yOyOyOy',
+      'x-baR',
+      'OyOyOyO',
+      'X-bAr',
+      'yOyOyOy',
+      'X-baR',
+      'OyOyOyO'
+    ];
+    const expectTrailers = { 'x-bar': 'yOyOyOy, OyOyOyO, yOyOyOy, OyOyOyO' };
+
+    this.close();
+
+    assert.deepStrictEqual(req.rawHeaders, expectRawHeaders);
+    assert.deepStrictEqual(req.headers, expectHeaders);
+
+    req.on('end', function() {
+      assert.deepStrictEqual(req.rawTrailers, expectRawTrailers);
+      assert.deepStrictEqual(req.trailers, expectTrailers);
+    });
+
+    req.resume();
+    res.setHeader('Trailer', 'x-foo');
+    res.addTrailers([
+      ['x-fOo', 'xOxOxOx'],
+      ['x-foO', 'OxOxOxO'],
+      ['X-fOo', 'xOxOxOx'],
+      ['X-foO', 'OxOxOxO']
+    ]);
+    res.end('x f o o');
+  })
+  .listen(0, function() {
+    const req = http.request({ port: this.address().port, path: '/' });
+    req.addTrailers([
+      ['x-bAr', 'yOyOyOy'],
+      ['x-baR', 'OyOyOyO'],
+      ['X-bAr', 'yOyOyOy'],
+      ['X-baR', 'OyOyOyO']
+    ]);
+    req.setHeader('transfer-ENCODING', 'CHUNKED');
+    req.setHeader('x-BaR', 'yoyoyo');
+    req.end('y b a r');
+    req.on('response', function(res) {
+      const expectRawHeaders = [
+        'Trailer',
+        'x-foo',
+        'Date',
+        null,
+        'Connection',
+        'close',
+        'Transfer-Encoding',
+        'chunked'
       ];
-      const expectTrailers = { 'x-foo': 'xOxOxOx, OxOxOxO, xOxOxOx, OxOxOxO' };
+      const expectHeaders = {
+        trailer: 'x-foo',
+        date: null,
+        connection: 'close',
+        'transfer-encoding': 'chunked'
+      };
+      res.rawHeaders[3] = null;
+      res.headers.date = null;
+      assert.deepStrictEqual(res.rawHeaders, expectRawHeaders);
+      assert.deepStrictEqual(res.headers, expectHeaders);
+      res.on('end', function() {
+        const expectRawTrailers = [
+          'x-fOo',
+          'xOxOxOx',
+          'x-foO',
+          'OxOxOxO',
+          'X-fOo',
+          'xOxOxOx',
+          'X-foO',
+          'OxOxOxO'
+        ];
+        const expectTrailers = {
+          'x-foo': 'xOxOxOx, OxOxOxO, xOxOxOx, OxOxOxO'
+        };
 
-      assert.deepStrictEqual(res.rawTrailers, expectRawTrailers);
-      assert.deepStrictEqual(res.trailers, expectTrailers);
-      console.log('ok');
+        assert.deepStrictEqual(res.rawTrailers, expectRawTrailers);
+        assert.deepStrictEqual(res.trailers, expectTrailers);
+        console.log('ok');
+      });
+      res.resume();
     });
-    res.resume();
   });
-});
diff --git a/test/parallel/test-http-readable-data-event.js b/test/parallel/test-http-readable-data-event.js
index 1c48a451ef9714..e0a9b6c4fc452e 100644
--- a/test/parallel/test-http-readable-data-event.js
+++ b/test/parallel/test-http-readable-data-event.js
@@ -8,51 +8,62 @@ const helloAgainLater = 'Hello again later!';
 
 let next = null;
 
-const server = http.createServer((req, res) => {
-  res.writeHead(200, {
-    'Content-Length': '' + (helloWorld.length + helloAgainLater.length)
-  });
+const server = http
+  .createServer((req, res) => {
+    res.writeHead(200, {
+      'Content-Length': '' + (helloWorld.length + helloAgainLater.length)
+    });
 
-  // we need to make sure the data is flushed
-  // before writing again
-  next = () => {
-    res.end(helloAgainLater);
-    next = () => {};
-  };
-
-  res.write(helloWorld);
-}).listen(0, function() {
-  const opts = {
-    hostname: 'localhost',
-    port: server.address().port,
-    path: '/'
-  };
-
-  const expectedData = [helloWorld, helloAgainLater];
-  const expectedRead = [helloWorld, null, helloAgainLater, null];
-
-  const req = http.request(opts, (res) => {
-    res.on('error', common.mustNotCall());
-
-    res.on('readable', common.mustCall(() => {
-      let data;
-
-      do {
-        data = res.read();
-        assert.strictEqual(data, expectedRead.shift());
-        next();
-      } while (data !== null);
-    }, 2));
-
-    res.setEncoding('utf8');
-    res.on('data', common.mustCall((data) => {
-      assert.strictEqual(data, expectedData.shift());
-    }, 2));
-
-    res.on('end', common.mustCall(() => {
-      server.close();
-    }));
-  });
+    // we need to make sure the data is flushed
+    // before writing again
+    next = () => {
+      res.end(helloAgainLater);
+      next = () => {};
+    };
+
+    res.write(helloWorld);
+  })
+  .listen(0, function() {
+    const opts = {
+      hostname: 'localhost',
+      port: server.address().port,
+      path: '/'
+    };
+
+    const expectedData = [helloWorld, helloAgainLater];
+    const expectedRead = [helloWorld, null, helloAgainLater, null];
+
+    const req = http.request(opts, (res) => {
+      res.on('error', common.mustNotCall());
 
-  req.end();
-});
+      res.on(
+        'readable',
+        common.mustCall(() => {
+          let data;
+
+          do {
+            data = res.read();
+            assert.strictEqual(data, expectedRead.shift());
+            next();
+          } while (data !== null);
+        }, 2)
+      );
+
+      res.setEncoding('utf8');
+      res.on(
+        'data',
+        common.mustCall((data) => {
+          assert.strictEqual(data, expectedData.shift());
+        }, 2)
+      );
+
+      res.on(
+        'end',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+    });
+
+    req.end();
+  });
diff --git a/test/parallel/test-http-req-res-close.js b/test/parallel/test-http-req-res-close.js
index daba55f43427c2..b308d4d79ba10c 100644
--- a/test/parallel/test-http-req-res-close.js
+++ b/test/parallel/test-http-req-res-close.js
@@ -4,22 +4,36 @@ const common = require('../common');
 const http = require('http');
 const assert = require('assert');
 
-const server = http.Server(common.mustCall((req, res) => {
-  let resClosed = false;
+const server = http.Server(
+  common.mustCall((req, res) => {
+    let resClosed = false;
 
-  res.end();
-  res.on('finish', common.mustCall(() => {
-    assert.strictEqual(resClosed, false);
-  }));
-  res.on('close', common.mustCall(() => {
-    resClosed = true;
-  }));
-  req.on('close', common.mustCall(() => {
-    assert.strictEqual(req._readableState.ended, true);
-  }));
-  res.socket.on('close', () => server.close());
-}));
+    res.end();
+    res.on(
+      'finish',
+      common.mustCall(() => {
+        assert.strictEqual(resClosed, false);
+      })
+    );
+    res.on(
+      'close',
+      common.mustCall(() => {
+        resClosed = true;
+      })
+    );
+    req.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(req._readableState.ended, true);
+      })
+    );
+    res.socket.on('close', () => server.close());
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  http.get({ port: server.address().port }, common.mustCall());
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    http.get({ port: server.address().port }, common.mustCall());
+  })
+);
diff --git a/test/parallel/test-http-request-agent.js b/test/parallel/test-http-request-agent.js
index a1f3077ed2820f..0b11d45f17abc9 100644
--- a/test/parallel/test-http-request-agent.js
+++ b/test/parallel/test-http-request-agent.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
@@ -22,19 +21,27 @@ const server = https.createServer(options, function(req, res) {
   res.end('hello world\n');
 });
 
-server.listen(0, common.mustCall(function() {
-  console.error('listening');
-  https.get({
-    agent: false,
-    path: '/',
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(function(res) {
-    console.error(res.statusCode, res.headers);
-    res.resume();
-    server.close();
-  })).on('error', function(e) {
-    console.error(e.stack);
-    process.exit(1);
-  });
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    console.error('listening');
+    https
+      .get(
+        {
+          agent: false,
+          path: '/',
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        common.mustCall(function(res) {
+          console.error(res.statusCode, res.headers);
+          res.resume();
+          server.close();
+        })
+      )
+      .on('error', function(e) {
+        console.error(e.stack);
+        process.exit(1);
+      });
+  })
+);
diff --git a/test/parallel/test-http-request-dont-override-options.js b/test/parallel/test-http-request-dont-override-options.js
index ff534436cb8f93..f0e6f279946bec 100644
--- a/test/parallel/test-http-request-dont-override-options.js
+++ b/test/parallel/test-http-request-dont-override-options.js
@@ -4,11 +4,12 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-
-const server = http.createServer(common.mustCall(function(req, res) {
-  res.writeHead(200);
-  res.end('ok');
-}));
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    res.writeHead(200);
+    res.end('ok');
+  })
+);
 
 server.listen(0, function() {
   const agent = new http.Agent();
@@ -27,14 +28,16 @@ server.listen(0, function() {
     agent: agent
   };
 
-  http.request(options, function(res) {
-    res.resume();
-    server.close();
-    assert.strictEqual(options.host, undefined);
-    assert.strictEqual(options.hostname, common.localhostIPv4);
-    assert.strictEqual(options.port, undefined);
-    assert.strictEqual(options.defaultPort, undefined);
-    assert.strictEqual(options.path, undefined);
-    assert.strictEqual(options.method, undefined);
-  }).end();
+  http
+    .request(options, function(res) {
+      res.resume();
+      server.close();
+      assert.strictEqual(options.host, undefined);
+      assert.strictEqual(options.hostname, common.localhostIPv4);
+      assert.strictEqual(options.port, undefined);
+      assert.strictEqual(options.defaultPort, undefined);
+      assert.strictEqual(options.path, undefined);
+      assert.strictEqual(options.method, undefined);
+    })
+    .end();
 });
diff --git a/test/parallel/test-http-request-end.js b/test/parallel/test-http-request-end.js
index a0cdcf27dd03a9..5a032f6474a6fc 100644
--- a/test/parallel/test-http-request-end.js
+++ b/test/parallel/test-http-request-end.js
@@ -40,21 +40,25 @@ const server = http.Server(function(req, res) {
     res.writeHead(200);
     res.end('hello world\n');
   });
-
 });
 
 server.listen(0, function() {
-  const req = http.request({
-    port: this.address().port,
-    path: '/',
-    method: 'POST'
-  }, function(res) {
-    console.log(res.statusCode);
-    res.resume();
-  }).on('error', function(e) {
-    console.log(e.message);
-    process.exit(1);
-  });
+  const req = http
+    .request(
+      {
+        port: this.address().port,
+        path: '/',
+        method: 'POST'
+      },
+      function(res) {
+        console.log(res.statusCode);
+        res.resume();
+      }
+    )
+    .on('error', function(e) {
+      console.log(e.message);
+      process.exit(1);
+    });
 
   const result = req.end(expected);
 
diff --git a/test/parallel/test-http-request-invalid-method-error.js b/test/parallel/test-http-request-invalid-method-error.js
index ae11985e12ff87..281753e57d9bc5 100644
--- a/test/parallel/test-http-request-invalid-method-error.js
+++ b/test/parallel/test-http-request-invalid-method-error.js
@@ -2,11 +2,8 @@
 const common = require('../common');
 const http = require('http');
 
-common.expectsError(
-  () => http.request({ method: '\0' }),
-  {
-    code: 'ERR_INVALID_HTTP_TOKEN',
-    type: TypeError,
-    message: 'Method must be a valid HTTP token ["\u0000"]'
-  }
-);
+common.expectsError(() => http.request({ method: '\0' }), {
+  code: 'ERR_INVALID_HTTP_TOKEN',
+  type: TypeError,
+  message: 'Method must be a valid HTTP token ["\u0000"]'
+});
diff --git a/test/parallel/test-http-request-methods.js b/test/parallel/test-http-request-methods.js
index 3532d45c637c0d..8a81de80d201a2 100644
--- a/test/parallel/test-http-request-methods.js
+++ b/test/parallel/test-http-request-methods.js
@@ -28,38 +28,46 @@ const http = require('http');
 // Test that the DELETE, PATCH and PURGE verbs get passed through correctly
 
 ['DELETE', 'PATCH', 'PURGE'].forEach(function(method, index) {
-  const server = http.createServer(common.mustCall(function(req, res) {
-    assert.strictEqual(req.method, method);
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write('hello ');
-    res.write('world\n');
-    res.end();
-  }));
+  const server = http.createServer(
+    common.mustCall(function(req, res) {
+      assert.strictEqual(req.method, method);
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.write('hello ');
+      res.write('world\n');
+      res.end();
+    })
+  );
   server.listen(0);
 
-  server.on('listening', common.mustCall(function() {
-    const c = net.createConnection(this.address().port);
-    let server_response = '';
+  server.on(
+    'listening',
+    common.mustCall(function() {
+      const c = net.createConnection(this.address().port);
+      let server_response = '';
 
-    c.setEncoding('utf8');
+      c.setEncoding('utf8');
 
-    c.on('connect', function() {
-      c.write(`${method} / HTTP/1.0\r\n\r\n`);
-    });
+      c.on('connect', function() {
+        c.write(`${method} / HTTP/1.0\r\n\r\n`);
+      });
 
-    c.on('data', function(chunk) {
-      console.log(chunk);
-      server_response += chunk;
-    });
+      c.on('data', function(chunk) {
+        console.log(chunk);
+        server_response += chunk;
+      });
 
-    c.on('end', common.mustCall(function() {
-      const m = server_response.split('\r\n\r\n');
-      assert.strictEqual(m[1], 'hello world\n');
-      c.end();
-    }));
+      c.on(
+        'end',
+        common.mustCall(function() {
+          const m = server_response.split('\r\n\r\n');
+          assert.strictEqual(m[1], 'hello world\n');
+          c.end();
+        })
+      );
 
-    c.on('close', function() {
-      server.close();
-    });
-  }));
+      c.on('close', function() {
+        server.close();
+      });
+    })
+  );
 });
diff --git a/test/parallel/test-http-res-write-after-end.js b/test/parallel/test-http-res-write-after-end.js
index 75cb25f0a63e0c..246bce7c2b1d7e 100644
--- a/test/parallel/test-http-res-write-after-end.js
+++ b/test/parallel/test-http-res-write-after-end.js
@@ -24,19 +24,24 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server = http.Server(common.mustCall(function(req, res) {
-  res.on('error', common.expectsError({
-    code: 'ERR_STREAM_WRITE_AFTER_END',
-    type: Error
-  }));
+const server = http.Server(
+  common.mustCall(function(req, res) {
+    res.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_STREAM_WRITE_AFTER_END',
+        type: Error
+      })
+    );
 
-  res.write('This should write.');
-  res.end();
+    res.write('This should write.');
+    res.end();
 
-  const r = res.write('This should raise an error.');
-  // write after end should return true
-  assert.strictEqual(r, true);
-}));
+    const r = res.write('This should raise an error.');
+    // write after end should return true
+    assert.strictEqual(r, true);
+  })
+);
 
 server.listen(0, function() {
   http.get({ port: this.address().port }, function(res) {
diff --git a/test/parallel/test-http-res-write-end-dont-take-array.js b/test/parallel/test-http-res-write-end-dont-take-array.js
index fbe71bd6fcbb67..015f965553f9d3 100644
--- a/test/parallel/test-http-res-write-end-dont-take-array.js
+++ b/test/parallel/test-http-res-write-end-dont-take-array.js
@@ -26,39 +26,39 @@ const http = require('http');
 
 const server = http.createServer();
 
-server.once('request', common.mustCall((req, res) => {
-  server.on('request', common.mustCall((req, res) => {
-    res.end(Buffer.from('asdf'));
-  }));
-  // write should accept string
-  res.write('string');
-  // write should accept buffer
-  res.write(Buffer.from('asdf'));
+server.once(
+  'request',
+  common.mustCall((req, res) => {
+    server.on(
+      'request',
+      common.mustCall((req, res) => {
+        res.end(Buffer.from('asdf'));
+      })
+    );
+    // write should accept string
+    res.write('string');
+    // write should accept buffer
+    res.write(Buffer.from('asdf'));
 
-  const expectedError = {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-  };
+    const expectedError = {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+    };
 
-  // write should not accept an Array
-  assert.throws(
-    () => {
+    // write should not accept an Array
+    assert.throws(() => {
       res.write(['array']);
-    },
-    expectedError
-  );
+    }, expectedError);
 
-  // end should not accept an Array
-  assert.throws(
-    () => {
+    // end should not accept an Array
+    assert.throws(() => {
       res.end(['moo']);
-    },
-    expectedError
-  );
+    }, expectedError);
 
-  // end should accept string
-  res.end('string');
-}));
+    // end should accept string
+    res.end('string');
+  })
+);
 
 server.listen(0, function() {
   // just make a request, other tests handle responses
diff --git a/test/parallel/test-http-response-add-header-after-sent.js b/test/parallel/test-http-response-add-header-after-sent.js
index a4d3f629e24b3d..96bc54df491cd9 100644
--- a/test/parallel/test-http-response-add-header-after-sent.js
+++ b/test/parallel/test-http-response-add-header-after-sent.js
@@ -5,14 +5,11 @@ const http = require('http');
 const server = http.createServer((req, res) => {
   res.setHeader('header1', 1);
   res.write('abc');
-  common.expectsError(
-    () => res.setHeader('header2', 2),
-    {
-      code: 'ERR_HTTP_HEADERS_SENT',
-      type: Error,
-      message: 'Cannot set headers after they are sent to the client'
-    }
-  );
+  common.expectsError(() => res.setHeader('header2', 2), {
+    code: 'ERR_HTTP_HEADERS_SENT',
+    type: Error,
+    message: 'Cannot set headers after they are sent to the client'
+  });
   res.end();
 });
 
diff --git a/test/parallel/test-http-response-close.js b/test/parallel/test-http-response-close.js
index 4c36003357980b..1f51c0360575f6 100644
--- a/test/parallel/test-http-response-close.js
+++ b/test/parallel/test-http-response-close.js
@@ -36,12 +36,18 @@ const http = require('http');
       http.get(
         { port: server.address().port },
         common.mustCall((res) => {
-          res.on('data', common.mustCall(() => {
-            res.destroy();
-          }));
-          res.on('close', common.mustCall(() => {
-            server.close();
-          }));
+          res.on(
+            'data',
+            common.mustCall(() => {
+              res.destroy();
+            })
+          );
+          res.on(
+            'close',
+            common.mustCall(() => {
+              server.close();
+            })
+          );
         })
       );
     })
@@ -61,9 +67,12 @@ const http = require('http');
       http.get(
         { port: server.address().port },
         common.mustCall((res) => {
-          res.on('close', common.mustCall(() => {
-            server.close();
-          }));
+          res.on(
+            'close',
+            common.mustCall(() => {
+              server.close();
+            })
+          );
           res.resume();
         })
       );
diff --git a/test/parallel/test-http-response-multi-content-length.js b/test/parallel/test-http-response-multi-content-length.js
index b2d28b7a9bcec1..cc480b5b2f64bc 100644
--- a/test/parallel/test-http-response-multi-content-length.js
+++ b/test/parallel/test-http-response-multi-content-length.js
@@ -27,21 +27,29 @@ const server = http.createServer((req, res) => {
 
 const countdown = new Countdown(MAX_COUNT, () => server.close());
 
-server.listen(0, common.mustCall(() => {
-  for (let n = 1; n <= MAX_COUNT; n++) {
-    // This runs twice, the first time, the server will use
-    // setHeader, the second time it uses writeHead. In either
-    // case, the error handler must be called because the client
-    // is not allowed to accept multiple content-length headers.
-    http.get(
-      { port: server.address().port, headers: { 'x-num': n } },
-      (res) => {
-        assert.fail('client allowed multiple content-length headers.');
-      }
-    ).on('error', common.mustCall((err) => {
-      assert(/^Parse Error/.test(err.message));
-      assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
-      countdown.dec();
-    }));
-  }
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    for (let n = 1; n <= MAX_COUNT; n++) {
+      // This runs twice, the first time, the server will use
+      // setHeader, the second time it uses writeHead. In either
+      // case, the error handler must be called because the client
+      // is not allowed to accept multiple content-length headers.
+      http
+        .get(
+          { port: server.address().port, headers: { 'x-num': n } },
+          (res) => {
+            assert.fail('client allowed multiple content-length headers.');
+          }
+        )
+        .on(
+          'error',
+          common.mustCall((err) => {
+            assert(/^Parse Error/.test(err.message));
+            assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
+            countdown.dec();
+          })
+        );
+    }
+  })
+);
diff --git a/test/parallel/test-http-response-multiheaders.js b/test/parallel/test-http-response-multiheaders.js
index f9429cff934276..5297e55e4a2b71 100644
--- a/test/parallel/test-http-response-multiheaders.js
+++ b/test/parallel/test-http-response-multiheaders.js
@@ -48,24 +48,27 @@ const server = http.createServer(function(req, res) {
   res.end('ok');
 });
 
-server.listen(0, common.mustCall(function() {
-  const countdown = new Countdown(runCount, () => server.close());
-  for (let n = 1; n <= runCount; n++) {
-    // this runs twice, the first time, the server will use
-    // setHeader, the second time it uses writeHead. The
-    // result on the client side should be the same in
-    // either case -- only the first instance of the header
-    // value should be reported for the header fields listed
-    // in the norepeat array.
-    http.get(
-      { port: this.address().port, headers: { 'x-num': n } },
-      common.mustCall(function(res) {
-        countdown.dec();
-        for (const name of norepeat) {
-          assert.strictEqual(res.headers[name], 'A');
-        }
-        assert.strictEqual(res.headers['x-a'], 'A, B');
-      })
-    );
-  }
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const countdown = new Countdown(runCount, () => server.close());
+    for (let n = 1; n <= runCount; n++) {
+      // this runs twice, the first time, the server will use
+      // setHeader, the second time it uses writeHead. The
+      // result on the client side should be the same in
+      // either case -- only the first instance of the header
+      // value should be reported for the header fields listed
+      // in the norepeat array.
+      http.get(
+        { port: this.address().port, headers: { 'x-num': n } },
+        common.mustCall(function(res) {
+          countdown.dec();
+          for (const name of norepeat) {
+            assert.strictEqual(res.headers[name], 'A');
+          }
+          assert.strictEqual(res.headers['x-a'], 'A, B');
+        })
+      );
+    }
+  })
+);
diff --git a/test/parallel/test-http-response-no-headers.js b/test/parallel/test-http-response-no-headers.js
index 87b0f8e67faf7c..079cc3348fa1f9 100644
--- a/test/parallel/test-http-response-no-headers.js
+++ b/test/parallel/test-http-response-no-headers.js
@@ -38,30 +38,40 @@ function test(httpVersion, callback) {
     conn.end(reply);
   });
 
-  server.listen(0, '127.0.0.1', common.mustCall(function() {
-    const options = {
-      host: '127.0.0.1',
-      port: this.address().port
-    };
+  server.listen(
+    0,
+    '127.0.0.1',
+    common.mustCall(function() {
+      const options = {
+        host: '127.0.0.1',
+        port: this.address().port
+      };
 
-    const req = http.get(options, common.mustCall(function(res) {
-      let body = '';
+      const req = http.get(
+        options,
+        common.mustCall(function(res) {
+          let body = '';
 
-      res.on('data', function(data) {
-        body += data;
-      });
+          res.on('data', function(data) {
+            body += data;
+          });
 
-      res.on('end', common.mustCall(function() {
-        assert.strictEqual(body, expected[httpVersion]);
-        server.close();
-        if (callback) process.nextTick(callback);
-      }));
-    }));
+          res.on(
+            'end',
+            common.mustCall(function() {
+              assert.strictEqual(body, expected[httpVersion]);
+              server.close();
+              if (callback) process.nextTick(callback);
+            })
+          );
+        })
+      );
 
-    req.on('error', function(err) {
-      throw err;
-    });
-  }));
+      req.on('error', function(err) {
+        throw err;
+      });
+    })
+  );
 }
 
 test('0.9', function() {
diff --git a/test/parallel/test-http-response-remove-header-after-sent.js b/test/parallel/test-http-response-remove-header-after-sent.js
index 52acd3d1059ef3..97b9f89c8bba4b 100644
--- a/test/parallel/test-http-response-remove-header-after-sent.js
+++ b/test/parallel/test-http-response-remove-header-after-sent.js
@@ -5,14 +5,11 @@ const http = require('http');
 const server = http.createServer((req, res) => {
   res.removeHeader('header1', 1);
   res.write('abc');
-  common.expectsError(
-    () => res.removeHeader('header2', 2),
-    {
-      code: 'ERR_HTTP_HEADERS_SENT',
-      type: Error,
-      message: 'Cannot remove headers after they are sent to the client'
-    }
-  );
+  common.expectsError(() => res.removeHeader('header2', 2), {
+    code: 'ERR_HTTP_HEADERS_SENT',
+    type: Error,
+    message: 'Cannot remove headers after they are sent to the client'
+  });
   res.end();
 });
 
diff --git a/test/parallel/test-http-response-splitting.js b/test/parallel/test-http-response-splitting.js
index 2c75940b7a3656..336db3d26d5c64 100644
--- a/test/parallel/test-http-response-splitting.js
+++ b/test/parallel/test-http-response-splitting.js
@@ -8,11 +8,12 @@ const assert = require('assert');
 const Countdown = require('../common/countdown');
 
 // Response splitting example, credit: Amit Klein, Safebreach
-const str = '/welcome?lang=bar%c4%8d%c4%8aContent­Length:%200%c4%8d%c4%8a%c' +
-            '4%8d%c4%8aHTTP/1.1%20200%20OK%c4%8d%c4%8aContent­Length:%202' +
-            '0%c4%8d%c4%8aLast­Modified:%20Mon,%2027%20Oct%202003%2014:50:18' +
-            '%20GMT%c4%8d%c4%8aContent­Type:%20text/html%c4%8d%c4%8a%c4%8' +
-            'd%c4%8a%3chtml%3eGotcha!%3c/html%3e';
+const str =
+  '/welcome?lang=bar%c4%8d%c4%8aContent­Length:%200%c4%8d%c4%8a%c' +
+  '4%8d%c4%8aHTTP/1.1%20200%20OK%c4%8d%c4%8aContent­Length:%202' +
+  '0%c4%8d%c4%8aLast­Modified:%20Mon,%2027%20Oct%202003%2014:50:18' +
+  '%20GMT%c4%8d%c4%8aContent­Type:%20text/html%c4%8d%c4%8a%c4%8' +
+  'd%c4%8a%3chtml%3eGotcha!%3c/html%3e';
 
 // Response splitting example, credit: Сковорода Никита Андреевич (@ChALkeR)
 const x = 'fooഊSet-Cookie: foo=barഊഊ<script>alert("Hi!")</script>';
@@ -23,14 +24,11 @@ const countdown = new Countdown(3, () => server.close());
 
 function test(res, code, key, value) {
   const header = { [key]: value };
-  common.expectsError(
-    () => res.writeHead(code, header),
-    {
-      code: 'ERR_INVALID_CHAR',
-      type: TypeError,
-      message: `Invalid character in header content ["${key}"]`
-    }
-  );
+  common.expectsError(() => res.writeHead(code, header), {
+    code: 'ERR_INVALID_CHAR',
+    type: TypeError,
+    message: `Invalid character in header content ["${key}"]`
+  });
 }
 
 const server = http.createServer((req, res) => {
@@ -53,10 +51,13 @@ const server = http.createServer((req, res) => {
 });
 server.listen(0, () => {
   const end = 'HTTP/1.1\r\n\r\n';
-  const client = net.connect({ port: server.address().port }, () => {
-    client.write(`GET ${str} ${end}`);
-    client.write(`GET / ${end}`);
-    client.write(`GET / ${end}`);
-    client.end();
-  });
+  const client = net.connect(
+    { port: server.address().port },
+    () => {
+      client.write(`GET ${str} ${end}`);
+      client.write(`GET / ${end}`);
+      client.write(`GET / ${end}`);
+      client.end();
+    }
+  );
 });
diff --git a/test/parallel/test-http-response-status-message.js b/test/parallel/test-http-response-status-message.js
index 0f9bce8fa87d67..aaf6204432d1e0 100644
--- a/test/parallel/test-http-response-status-message.js
+++ b/test/parallel/test-http-response-status-message.js
@@ -27,16 +27,23 @@ const net = require('net');
 const Countdown = require('../common/countdown');
 
 const testCases = [
-  { path: '/200', statusMessage: 'OK',
-    response: 'HTTP/1.1 200 OK\r\n\r\n' },
-  { path: '/500', statusMessage: 'Internal Server Error',
-    response: 'HTTP/1.1 500 Internal Server Error\r\n\r\n' },
-  { path: '/302', statusMessage: 'Moved Temporarily',
-    response: 'HTTP/1.1 302 Moved Temporarily\r\n\r\n' },
-  { path: '/missing', statusMessage: '',
-    response: 'HTTP/1.1 200 \r\n\r\n' },
-  { path: '/missing-no-space', statusMessage: '',
-    response: 'HTTP/1.1 200\r\n\r\n' }
+  { path: '/200', statusMessage: 'OK', response: 'HTTP/1.1 200 OK\r\n\r\n' },
+  {
+    path: '/500',
+    statusMessage: 'Internal Server Error',
+    response: 'HTTP/1.1 500 Internal Server Error\r\n\r\n'
+  },
+  {
+    path: '/302',
+    statusMessage: 'Moved Temporarily',
+    response: 'HTTP/1.1 302 Moved Temporarily\r\n\r\n'
+  },
+  { path: '/missing', statusMessage: '', response: 'HTTP/1.1 200 \r\n\r\n' },
+  {
+    path: '/missing-no-space',
+    statusMessage: '',
+    response: 'HTTP/1.1 200\r\n\r\n'
+  }
 ];
 testCases.findByPath = function(path) {
   const matching = this.filter(function(testCase) {
@@ -63,23 +70,28 @@ const countdown = new Countdown(testCases.length, () => server.close());
 function runTest(testCaseIndex) {
   const testCase = testCases[testCaseIndex];
 
-  http.get({
-    port: server.address().port,
-    path: testCase.path
-  }, function(response) {
-    console.log(`client: expected status message: ${testCase.statusMessage}`);
-    console.log(`client: actual status message: ${response.statusMessage}`);
-    assert.strictEqual(testCase.statusMessage, response.statusMessage);
+  http.get(
+    {
+      port: server.address().port,
+      path: testCase.path
+    },
+    function(response) {
+      console.log(`client: expected status message: ${testCase.statusMessage}`);
+      console.log(`client: actual status message: ${response.statusMessage}`);
+      assert.strictEqual(testCase.statusMessage, response.statusMessage);
 
-    response.on('end', function() {
-      countdown.dec();
-      if (testCaseIndex + 1 < testCases.length) {
-        runTest(testCaseIndex + 1);
-      }
-    });
+      response.on('end', function() {
+        countdown.dec();
+        if (testCaseIndex + 1 < testCases.length) {
+          runTest(testCaseIndex + 1);
+        }
+      });
 
-    response.resume();
-  });
+      response.resume();
+    }
+  );
 }
 
-server.listen(0, function() { runTest(0); });
+server.listen(0, function() {
+  runTest(0);
+});
diff --git a/test/parallel/test-http-response-statuscode.js b/test/parallel/test-http-response-statuscode.js
index 7e93ad10a9f9c8..7e41f4a7a5eb7f 100644
--- a/test/parallel/test-http-response-statuscode.js
+++ b/test/parallel/test-http-response-statuscode.js
@@ -8,83 +8,98 @@ const MAX_REQUESTS = 13;
 let reqNum = 0;
 
 function test(res, header, code) {
-  common.expectsError(() => {
-    res.writeHead(header);
-  }, {
-    code: 'ERR_HTTP_INVALID_STATUS_CODE',
-    type: RangeError,
-    message: `Invalid status code: ${code}`
-  });
+  common.expectsError(
+    () => {
+      res.writeHead(header);
+    },
+    {
+      code: 'ERR_HTTP_INVALID_STATUS_CODE',
+      type: RangeError,
+      message: `Invalid status code: ${code}`
+    }
+  );
 }
 
-const server = http.Server(common.mustCall(function(req, res) {
-  switch (reqNum) {
-    case 0:
-      test(res, -1, '-1');
-      break;
-    case 1:
-      test(res, Infinity, 'Infinity');
-      break;
-    case 2:
-      test(res, NaN, 'NaN');
-      break;
-    case 3:
-      test(res, {}, '[object Object]');
-      break;
-    case 4:
-      test(res, 99, '99');
-      break;
-    case 5:
-      test(res, 1000, '1000');
-      break;
-    case 6:
-      test(res, '1000', '1000');
-      break;
-    case 7:
-      test(res, null, 'null');
-      break;
-    case 8:
-      test(res, true, 'true');
-      break;
-    case 9:
-      test(res, [], '');
-      break;
-    case 10:
-      test(res, 'this is not valid', 'this is not valid');
-      break;
-    case 11:
-      test(res, '404 this is not valid either', '404 this is not valid either');
-      break;
-    case 12:
-      common.expectsError(() => { res.writeHead(); },
-                          {
-                            code: 'ERR_HTTP_INVALID_STATUS_CODE',
-                            type: RangeError,
-                            message: 'Invalid status code: undefined'
-                          });
-      this.close();
-      break;
-    default:
-      throw new Error('Unexpected request');
-  }
-  res.statusCode = 200;
-  res.end();
-}, MAX_REQUESTS));
+const server = http.Server(
+  common.mustCall(function(req, res) {
+    switch (reqNum) {
+      case 0:
+        test(res, -1, '-1');
+        break;
+      case 1:
+        test(res, Infinity, 'Infinity');
+        break;
+      case 2:
+        test(res, NaN, 'NaN');
+        break;
+      case 3:
+        test(res, {}, '[object Object]');
+        break;
+      case 4:
+        test(res, 99, '99');
+        break;
+      case 5:
+        test(res, 1000, '1000');
+        break;
+      case 6:
+        test(res, '1000', '1000');
+        break;
+      case 7:
+        test(res, null, 'null');
+        break;
+      case 8:
+        test(res, true, 'true');
+        break;
+      case 9:
+        test(res, [], '');
+        break;
+      case 10:
+        test(res, 'this is not valid', 'this is not valid');
+        break;
+      case 11:
+        test(
+          res,
+          '404 this is not valid either',
+          '404 this is not valid either'
+        );
+        break;
+      case 12:
+        common.expectsError(
+          () => {
+            res.writeHead();
+          },
+          {
+            code: 'ERR_HTTP_INVALID_STATUS_CODE',
+            type: RangeError,
+            message: 'Invalid status code: undefined'
+          }
+        );
+        this.close();
+        break;
+      default:
+        throw new Error('Unexpected request');
+    }
+    res.statusCode = 200;
+    res.end();
+  }, MAX_REQUESTS)
+);
 server.listen();
 
 const countdown = new Countdown(MAX_REQUESTS, () => server.close());
 
 server.on('listening', function makeRequest() {
-  http.get({
-    port: this.address().port
-  }, (res) => {
-    assert.strictEqual(res.statusCode, 200);
-    res.on('end', () => {
-      countdown.dec();
-      reqNum = MAX_REQUESTS - countdown.remaining;
-      if (countdown.remaining > 0)
-        makeRequest.call(this);
-    });
-    res.resume();
-  });
+  http.get(
+    {
+      port: this.address().port
+    },
+    (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      res.on('end', () => {
+        countdown.dec();
+        reqNum = MAX_REQUESTS - countdown.remaining;
+        if (countdown.remaining > 0) makeRequest.call(this);
+      });
+      res.resume();
+    }
+  );
 });
diff --git a/test/parallel/test-http-same-map.js b/test/parallel/test-http-same-map.js
index 0adb73222de184..304dcf72caefef 100644
--- a/test/parallel/test-http-same-map.js
+++ b/test/parallel/test-http-same-map.js
@@ -5,8 +5,9 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server =
-    http.createServer(onrequest).listen(0, common.localhostIPv4, () => next(0));
+const server = http
+  .createServer(onrequest)
+  .listen(0, common.localhostIPv4, () => next(0));
 
 function onrequest(req, res) {
   res.end('ok');
diff --git a/test/parallel/test-http-server-client-error.js b/test/parallel/test-http-server-client-error.js
index ffe78941553367..4acf3345e9bdfc 100644
--- a/test/parallel/test-http-server-client-error.js
+++ b/test/parallel/test-http-server-client-error.js
@@ -5,21 +5,26 @@ const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  res.end();
-}));
-
-server.on('clientError', common.mustCall(function(err, socket) {
-  assert.strictEqual(err instanceof Error, true);
-  assert.strictEqual(err.code, 'HPE_INVALID_METHOD');
-  assert.strictEqual(err.bytesParsed, 1);
-  assert.strictEqual(err.message, 'Parse Error');
-  assert.strictEqual(err.rawPacket.toString(), 'Oopsie-doopsie\r\n');
-
-  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
-
-  server.close();
-}));
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    res.end();
+  })
+);
+
+server.on(
+  'clientError',
+  common.mustCall(function(err, socket) {
+    assert.strictEqual(err instanceof Error, true);
+    assert.strictEqual(err.code, 'HPE_INVALID_METHOD');
+    assert.strictEqual(err.bytesParsed, 1);
+    assert.strictEqual(err.message, 'Parse Error');
+    assert.strictEqual(err.rawPacket.toString(), 'Oopsie-doopsie\r\n');
+
+    socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+
+    server.close();
+  })
+);
 
 server.listen(0, function() {
   function next() {
diff --git a/test/parallel/test-http-server-de-chunked-trailer.js b/test/parallel/test-http-server-de-chunked-trailer.js
index dad744209ee419..0ec84c42e5c7ad 100644
--- a/test/parallel/test-http-server-de-chunked-trailer.js
+++ b/test/parallel/test-http-server-de-chunked-trailer.js
@@ -7,27 +7,42 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  res.setHeader('Trailer', 'baz');
-  const trailerInvalidErr = {
-    code: 'ERR_HTTP_TRAILER_INVALID',
-    message: 'Trailers are invalid with this transfer encoding',
-    type: Error
-  };
-  common.expectsError(() => res.writeHead(200, { 'Content-Length': '2' }),
-                      trailerInvalidErr);
-  res.removeHeader('Trailer');
-  res.end('ok');
-}));
-server.listen(0, common.mustCall(() => {
-  http.get({ port: server.address().port }, common.mustCall((res) => {
-    assert.strictEqual(res.statusCode, 200);
-    let buf = '';
-    res.on('data', (chunk) => {
-      buf += chunk;
-    }).on('end', common.mustCall(() => {
-      assert.strictEqual(buf, 'ok');
-    }));
-    server.close();
-  }));
-}));
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    res.setHeader('Trailer', 'baz');
+    const trailerInvalidErr = {
+      code: 'ERR_HTTP_TRAILER_INVALID',
+      message: 'Trailers are invalid with this transfer encoding',
+      type: Error
+    };
+    common.expectsError(
+      () => res.writeHead(200, { 'Content-Length': '2' }),
+      trailerInvalidErr
+    );
+    res.removeHeader('Trailer');
+    res.end('ok');
+  })
+);
+server.listen(
+  0,
+  common.mustCall(() => {
+    http.get(
+      { port: server.address().port },
+      common.mustCall((res) => {
+        assert.strictEqual(res.statusCode, 200);
+        let buf = '';
+        res
+          .on('data', (chunk) => {
+            buf += chunk;
+          })
+          .on(
+            'end',
+            common.mustCall(() => {
+              assert.strictEqual(buf, 'ok');
+            })
+          );
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-server-keep-alive-timeout.js b/test/parallel/test-http-server-keep-alive-timeout.js
index 3a604b5b8a4506..3d74da2d4c0d59 100644
--- a/test/parallel/test-http-server-keep-alive-timeout.js
+++ b/test/parallel/test-http-server-keep-alive-timeout.js
@@ -26,33 +26,41 @@ function done(server, socket, cb) {
 function serverTest(withPipeline, cb) {
   let gotAll = false;
   let timedout = false;
-  const server = http.createServer(common.mustCall((req, res) => {
-    if (withPipeline)
-      res.end();
-    if (req.url === '/3') {
-      gotAll = true;
-      if (timedout)
-        done(server, req.socket, cb);
-    }
-  }, 3));
-  server.setTimeout(500, common.mustCallAtLeast((socket) => {
-    // End this test and call `run()` for the next test (if any).
-    timedout = true;
-    if (gotAll)
-      done(server, socket, cb);
-  }));
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      if (withPipeline) res.end();
+      if (req.url === '/3') {
+        gotAll = true;
+        if (timedout) done(server, req.socket, cb);
+      }
+    }, 3)
+  );
+  server.setTimeout(
+    500,
+    common.mustCallAtLeast((socket) => {
+      // End this test and call `run()` for the next test (if any).
+      timedout = true;
+      if (gotAll) done(server, socket, cb);
+    })
+  );
   server.keepAliveTimeout = 50;
-  server.listen(0, common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true
-    };
-    const c = net.connect(options, () => {
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-    });
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true
+      };
+      const c = net.connect(
+        options,
+        () => {
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+        }
+      );
+    })
+  );
 }
 
 test(function serverEndKeepAliveTimeoutWithPipeline(cb) {
diff --git a/test/parallel/test-http-server-multiheaders.js b/test/parallel/test-http-server-multiheaders.js
index bf918ad24cc168..2dd827a490f68f 100644
--- a/test/parallel/test-http-server-multiheaders.js
+++ b/test/parallel/test-http-server-multiheaders.js
@@ -36,8 +36,10 @@ const srv = http.createServer(function(req, res) {
   assert.strictEqual(req.headers['x-foo'], 'bingo');
   assert.strictEqual(req.headers['x-bar'], 'banjo, bango');
   assert.strictEqual(req.headers['sec-websocket-protocol'], 'chat, share');
-  assert.strictEqual(req.headers['sec-websocket-extensions'],
-                     'foo; 1, bar; 2, baz');
+  assert.strictEqual(
+    req.headers['sec-websocket-extensions'],
+    'foo; 1, bar; 2, baz'
+  );
   assert.strictEqual(req.headers.constructor, 'foo, bar, baz');
 
   res.writeHead(200, { 'Content-Type': 'text/plain' });
@@ -74,7 +76,7 @@ srv.listen(0, function() {
       ['sec-websocket-extensions', 'baz'],
       ['constructor', 'foo'],
       ['constructor', 'bar'],
-      ['constructor', 'baz'],
+      ['constructor', 'baz']
     ]
   });
 });
diff --git a/test/parallel/test-http-server-multiheaders2.js b/test/parallel/test-http-server-multiheaders2.js
index bb0fe0eaca57a9..6ecddc1d07b68b 100644
--- a/test/parallel/test-http-server-multiheaders2.js
+++ b/test/parallel/test-http-server-multiheaders2.js
@@ -49,7 +49,7 @@ const multipleAllowed = [
 
   // make sure that unspecified headers is treated as multiple
   'Some-Random-Header',
-  'X-Some-Random-Header',
+  'X-Some-Random-Header'
 ];
 
 const multipleForbidden = [
@@ -63,7 +63,7 @@ const multipleForbidden = [
   'If-Unmodified-Since',
   'From',
   'Location',
-  'Max-Forwards',
+  'Max-Forwards'
 
   // special case, tested differently
   // 'Content-Length',
@@ -71,13 +71,19 @@ const multipleForbidden = [
 
 const srv = http.createServer(function(req, res) {
   multipleForbidden.forEach(function(header) {
-    assert.strictEqual(req.headers[header.toLowerCase()], 'foo',
-                       `header parsed incorrectly: ${header}`);
+    assert.strictEqual(
+      req.headers[header.toLowerCase()],
+      'foo',
+      `header parsed incorrectly: ${header}`
+    );
   });
   multipleAllowed.forEach(function(header) {
-    const sep = (header.toLowerCase() === 'cookie' ? '; ' : ', ');
-    assert.strictEqual(req.headers[header.toLowerCase()], `foo${sep}bar`,
-                       `header parsed incorrectly: ${header}`);
+    const sep = header.toLowerCase() === 'cookie' ? '; ' : ', ';
+    assert.strictEqual(
+      req.headers[header.toLowerCase()],
+      `foo${sep}bar`,
+      `header parsed incorrectly: ${header}`
+    );
   });
 
   res.writeHead(200, { 'Content-Type': 'text/plain' });
@@ -103,6 +109,6 @@ srv.listen(0, function() {
     host: 'localhost',
     port: this.address().port,
     path: '/',
-    headers: headers,
+    headers: headers
   });
 });
diff --git a/test/parallel/test-http-server-options-incoming-message.js b/test/parallel/test-http-server-options-incoming-message.js
index d0f4a769d765a4..f4cc375a8680b6 100644
--- a/test/parallel/test-http-server-options-incoming-message.js
+++ b/test/parallel/test-http-server-options-incoming-message.js
@@ -16,26 +16,32 @@ class MyIncomingMessage extends http.IncomingMessage {
   }
 }
 
-const server = http.createServer({
-  IncomingMessage: MyIncomingMessage
-}, common.mustCall(function(req, res) {
-  assert.strictEqual(req.getUserAgent(), 'node-test');
-  res.statusCode = 200;
-  res.end();
-}));
+const server = http.createServer(
+  {
+    IncomingMessage: MyIncomingMessage
+  },
+  common.mustCall(function(req, res) {
+    assert.strictEqual(req.getUserAgent(), 'node-test');
+    res.statusCode = 200;
+    res.end();
+  })
+);
 server.listen();
 
 server.on('listening', function makeRequest() {
-  http.get({
-    port: this.address().port,
-    headers: {
-      'User-Agent': 'node-test'
+  http.get(
+    {
+      port: this.address().port,
+      headers: {
+        'User-Agent': 'node-test'
+      }
+    },
+    (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      res.on('end', () => {
+        server.close();
+      });
+      res.resume();
     }
-  }, (res) => {
-    assert.strictEqual(res.statusCode, 200);
-    res.on('end', () => {
-      server.close();
-    });
-    res.resume();
-  });
+  );
 });
diff --git a/test/parallel/test-http-server-options-server-response.js b/test/parallel/test-http-server-options-server-response.js
index f5adf39bed6d16..9f4145b8b92cb8 100644
--- a/test/parallel/test-http-server-options-server-response.js
+++ b/test/parallel/test-http-server-options-server-response.js
@@ -16,12 +16,15 @@ class MyServerResponse extends http.ServerResponse {
   }
 }
 
-const server = http.Server({
-  ServerResponse: MyServerResponse
-}, common.mustCall(function(req, res) {
-  res.status(200);
-  res.end();
-}));
+const server = http.Server(
+  {
+    ServerResponse: MyServerResponse
+  },
+  common.mustCall(function(req, res) {
+    res.status(200);
+    res.end();
+  })
+);
 server.listen();
 
 server.on('listening', function makeRequest() {
diff --git a/test/parallel/test-http-server-reject-chunked-with-content-length.js b/test/parallel/test-http-server-reject-chunked-with-content-length.js
index b3bc4295a84c0b..d8a58b9c45065b 100644
--- a/test/parallel/test-http-server-reject-chunked-with-content-length.js
+++ b/test/parallel/test-http-server-reject-chunked-with-content-length.js
@@ -5,21 +5,28 @@ const http = require('http');
 const net = require('net');
 const assert = require('assert');
 
-const reqstr = 'POST / HTTP/1.1\r\n' +
-               'Content-Length: 1\r\n' +
-               'Transfer-Encoding: chunked\r\n\r\n';
+const reqstr =
+  'POST / HTTP/1.1\r\n' +
+  'Content-Length: 1\r\n' +
+  'Transfer-Encoding: chunked\r\n\r\n';
 
 const server = http.createServer(common.mustNotCall());
-server.on('clientError', common.mustCall((err) => {
-  assert(/^Parse Error/.test(err.message));
-  assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
-  server.close();
-}));
+server.on(
+  'clientError',
+  common.mustCall((err) => {
+    assert(/^Parse Error/.test(err.message));
+    assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
+    server.close();
+  })
+);
 server.listen(0, () => {
-  const client = net.connect({ port: server.address().port }, () => {
-    client.write(reqstr);
-    client.end();
-  });
+  const client = net.connect(
+    { port: server.address().port },
+    () => {
+      client.write(reqstr);
+      client.end();
+    }
+  );
   client.on('data', (data) => {
     // Should not get to this point because the server should simply
     // close the connection without returning any data.
diff --git a/test/parallel/test-http-server-reject-cr-no-lf.js b/test/parallel/test-http-server-reject-cr-no-lf.js
index 5dace4f7bfd706..1187696dc52779 100644
--- a/test/parallel/test-http-server-reject-cr-no-lf.js
+++ b/test/parallel/test-http-server-reject-cr-no-lf.js
@@ -5,25 +5,31 @@ const net = require('net');
 const http = require('http');
 const assert = require('assert');
 
-const str = 'GET / HTTP/1.1\r\n' +
-            'Dummy: Header\r' +
-            'Content-Length: 1\r\n' +
-            '\r\n';
-
+const str =
+  'GET / HTTP/1.1\r\n' + 'Dummy: Header\r' + 'Content-Length: 1\r\n' + '\r\n';
 
 const server = http.createServer(common.mustNotCall());
-server.on('clientError', common.mustCall((err) => {
-  assert(/^Parse Error/.test(err.message));
-  assert.strictEqual(err.code, 'HPE_LF_EXPECTED');
-  server.close();
-}));
+server.on(
+  'clientError',
+  common.mustCall((err) => {
+    assert(/^Parse Error/.test(err.message));
+    assert.strictEqual(err.code, 'HPE_LF_EXPECTED');
+    server.close();
+  })
+);
 server.listen(0, () => {
-  const client = net.connect({ port: server.address().port }, () => {
-    client.on('data', common.mustNotCall());
-    client.on('end', common.mustCall(() => {
-      server.close();
-    }));
-    client.write(str);
-    client.end();
-  });
+  const client = net.connect(
+    { port: server.address().port },
+    () => {
+      client.on('data', common.mustNotCall());
+      client.on(
+        'end',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+      client.write(str);
+      client.end();
+    }
+  );
 });
diff --git a/test/parallel/test-http-server-stale-close.js b/test/parallel/test-http-server-stale-close.js
index b72c2b55a02f25..818a3df8854d25 100644
--- a/test/parallel/test-http-server-stale-close.js
+++ b/test/parallel/test-http-server-stale-close.js
@@ -25,12 +25,15 @@ const http = require('http');
 const fork = require('child_process').fork;
 
 if (process.env.NODE_TEST_FORK_PORT) {
-  const req = http.request({
-    headers: { 'Content-Length': '42' },
-    method: 'POST',
-    host: '127.0.0.1',
-    port: +process.env.NODE_TEST_FORK_PORT,
-  }, process.exit);
+  const req = http.request(
+    {
+      headers: { 'Content-Length': '42' },
+      method: 'POST',
+      host: '127.0.0.1',
+      port: +process.env.NODE_TEST_FORK_PORT
+    },
+    process.exit
+  );
   req.write('BAM');
   req.end();
 } else {
diff --git a/test/parallel/test-http-server-unconsume-consume.js b/test/parallel/test-http-server-unconsume-consume.js
index 0135205eb14ed9..e1fc15eaf43c85 100644
--- a/test/parallel/test-http-server-unconsume-consume.js
+++ b/test/parallel/test-http-server-unconsume-consume.js
@@ -3,17 +3,30 @@ const common = require('../common');
 const http = require('http');
 
 const testServer = http.createServer(common.mustNotCall());
-testServer.on('connect', common.mustCall((req, socket, head) => {
-  socket.write('HTTP/1.1 200 Connection Established\r\n' +
-      'Proxy-agent: Node-Proxy\r\n' +
-      '\r\n');
-  // This shouldn't raise an assertion in StreamBase::Consume.
-  testServer.emit('connection', socket);
-  testServer.close();
-}));
-testServer.listen(0, common.mustCall(() => {
-  http.request({
-    port: testServer.address().port,
-    method: 'CONNECT'
-  }, (res) => {}).end();
-}));
+testServer.on(
+  'connect',
+  common.mustCall((req, socket, head) => {
+    socket.write(
+      'HTTP/1.1 200 Connection Established\r\n' +
+        'Proxy-agent: Node-Proxy\r\n' +
+        '\r\n'
+    );
+    // This shouldn't raise an assertion in StreamBase::Consume.
+    testServer.emit('connection', socket);
+    testServer.close();
+  })
+);
+testServer.listen(
+  0,
+  common.mustCall(() => {
+    http
+      .request(
+        {
+          port: testServer.address().port,
+          method: 'CONNECT'
+        },
+        (res) => {}
+      )
+      .end();
+  })
+);
diff --git a/test/parallel/test-http-server-unconsume.js b/test/parallel/test-http-server-unconsume.js
index 9f80e9ea82de48..25c7c95773705b 100644
--- a/test/parallel/test-http-server-unconsume.js
+++ b/test/parallel/test-http-server-unconsume.js
@@ -6,24 +6,29 @@ const net = require('net');
 
 let received = '';
 
-const server = http.createServer(function(req, res) {
-  res.writeHead(200);
-  res.end();
+const server = http
+  .createServer(function(req, res) {
+    res.writeHead(200);
+    res.end();
 
-  req.socket.on('data', function(data) {
-    received += data;
-  });
+    req.socket.on('data', function(data) {
+      received += data;
+    });
 
-  server.close();
-}).listen(0, function() {
-  const socket = net.connect(this.address().port, function() {
-    socket.write('PUT / HTTP/1.1\r\n\r\n');
+    server.close();
+  })
+  .listen(0, function() {
+    const socket = net.connect(
+      this.address().port,
+      function() {
+        socket.write('PUT / HTTP/1.1\r\n\r\n');
 
-    socket.once('data', function() {
-      socket.end('hello world');
-    });
+        socket.once('data', function() {
+          socket.end('hello world');
+        });
+      }
+    );
   });
-});
 
 process.on('exit', function() {
   assert.strictEqual(received, 'hello world');
diff --git a/test/parallel/test-http-server-write-after-end.js b/test/parallel/test-http-server-write-after-end.js
index a405844cfc9659..1e0eb76302e0d4 100644
--- a/test/parallel/test-http-server-write-after-end.js
+++ b/test/parallel/test-http-server-write-after-end.js
@@ -8,22 +8,30 @@ const http = require('http');
 const server = http.createServer(handle);
 
 function handle(req, res) {
-  res.on('error', common.mustCall((err) => {
-    common.expectsError({
-      code: 'ERR_STREAM_WRITE_AFTER_END',
-      type: Error
-    })(err);
-    server.close();
-  }));
+  res.on(
+    'error',
+    common.mustCall((err) => {
+      common.expectsError({
+        code: 'ERR_STREAM_WRITE_AFTER_END',
+        type: Error
+      })(err);
+      server.close();
+    })
+  );
 
   res.write('hello');
   res.end();
 
-  setImmediate(common.mustCall(() => {
-    res.write('world');
-  }));
+  setImmediate(
+    common.mustCall(() => {
+      res.write('world');
+    })
+  );
 }
 
-server.listen(0, common.mustCall(() => {
-  http.get(`http://localhost:${server.address().port}`);
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    http.get(`http://localhost:${server.address().port}`);
+  })
+);
diff --git a/test/parallel/test-http-server.js b/test/parallel/test-http-server.js
index f591cd59fc63c2..9d2bf6677f8caa 100644
--- a/test/parallel/test-http-server.js
+++ b/test/parallel/test-http-server.js
@@ -30,14 +30,17 @@ const qs = require('querystring');
 // TODO: documentation does not allow Array as an option, so testing that
 // should fail, but currently http.Server does not typecheck further than
 // if `option` is `typeof object` - so we don't test that here right now
-const invalid_options = [ 'foo', 42, true ];
+const invalid_options = ['foo', 42, true];
 
 invalid_options.forEach((option) => {
-  assert.throws(() => {
-    new http.Server(option);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE'
-  });
+  assert.throws(
+    () => {
+      new http.Server(option);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE'
+    }
+  );
 });
 
 let request_number = 0;
@@ -75,7 +78,6 @@ const server = http.createServer(function(req, res) {
     res.write(url.parse(req.url).pathname);
     res.end();
   }, 1);
-
 });
 server.listen(0);
 
@@ -100,8 +102,10 @@ server.on('listening', function() {
     }
 
     if (requests_sent === 2) {
-      c.write('GET / HTTP/1.1\r\nX-X: foo\r\n\r\n' +
-              'GET / HTTP/1.1\r\nX-X: bar\r\n\r\n');
+      c.write(
+        'GET / HTTP/1.1\r\nX-X: foo\r\n\r\n' +
+          'GET / HTTP/1.1\r\nX-X: bar\r\n\r\n'
+      );
       // Note: we are making the connection half-closed here
       // before we've gotten the response from the server. This
       // is a pretty bad thing to do and not really supported
@@ -112,7 +116,6 @@ server.on('listening', function() {
       assert.strictEqual(c.readyState, 'readOnly');
       requests_sent += 2;
     }
-
   });
 
   c.on('end', function() {
diff --git a/test/parallel/test-http-set-cookies.js b/test/parallel/test-http-set-cookies.js
index 7a57523b04af9c..fc034ee2958dd9 100644
--- a/test/parallel/test-http-set-cookies.js
+++ b/test/parallel/test-http-set-cookies.js
@@ -28,13 +28,14 @@ const Countdown = require('../common/countdown');
 const countdown = new Countdown(2, () => server.close());
 const server = http.createServer(function(req, res) {
   if (req.url === '/one') {
-    res.writeHead(200, [['set-cookie', 'A'],
-                        ['content-type', 'text/plain']]);
+    res.writeHead(200, [['set-cookie', 'A'], ['content-type', 'text/plain']]);
     res.end('one\n');
   } else {
-    res.writeHead(200, [['set-cookie', 'A'],
-                        ['set-cookie', 'B'],
-                        ['content-type', 'text/plain']]);
+    res.writeHead(200, [
+      ['set-cookie', 'A'],
+      ['set-cookie', 'B'],
+      ['content-type', 'text/plain']
+    ]);
     res.end('two\n');
   }
 });
@@ -73,5 +74,4 @@ server.on('listening', function() {
       countdown.dec();
     });
   });
-
 });
diff --git a/test/parallel/test-http-set-timeout-server.js b/test/parallel/test-http-set-timeout-server.js
index 7984fdfc0ffbf0..6838813431a706 100644
--- a/test/parallel/test-http-set-timeout-server.js
+++ b/test/parallel/test-http-set-timeout-server.js
@@ -29,8 +29,7 @@ const net = require('net');
 const tests = [];
 
 function test(fn) {
-  if (!tests.length)
-    process.nextTick(run);
+  if (!tests.length) process.nextTick(run);
   tests.push(common.mustCall(fn));
 }
 
@@ -43,74 +42,106 @@ function run() {
 
 test(function serverTimeout(cb) {
   const server = http.createServer();
-  server.listen(common.mustCall(() => {
-    const s = server.setTimeout(50, common.mustCall((socket) => {
-      socket.destroy();
-      server.close();
-      cb();
-    }));
-    assert.ok(s instanceof http.Server);
-    http.get({
-      port: server.address().port
-    }).on('error', common.mustCall());
-  }));
+  server.listen(
+    common.mustCall(() => {
+      const s = server.setTimeout(
+        50,
+        common.mustCall((socket) => {
+          socket.destroy();
+          server.close();
+          cb();
+        })
+      );
+      assert.ok(s instanceof http.Server);
+      http
+        .get({
+          port: server.address().port
+        })
+        .on('error', common.mustCall());
+    })
+  );
 });
 
 test(function serverRequestTimeout(cb) {
-  const server = http.createServer(common.mustCall((req, res) => {
-    // just do nothing, we should get a timeout event.
-    const s = req.setTimeout(50, common.mustCall((socket) => {
-      socket.destroy();
-      server.close();
-      cb();
-    }));
-    assert.ok(s instanceof http.IncomingMessage);
-  }));
-  server.listen(common.mustCall(() => {
-    const req = http.request({
-      port: server.address().port,
-      method: 'POST'
-    });
-    req.on('error', common.mustCall());
-    req.write('Hello');
-    // req is in progress
-  }));
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      // just do nothing, we should get a timeout event.
+      const s = req.setTimeout(
+        50,
+        common.mustCall((socket) => {
+          socket.destroy();
+          server.close();
+          cb();
+        })
+      );
+      assert.ok(s instanceof http.IncomingMessage);
+    })
+  );
+  server.listen(
+    common.mustCall(() => {
+      const req = http.request({
+        port: server.address().port,
+        method: 'POST'
+      });
+      req.on('error', common.mustCall());
+      req.write('Hello');
+      // req is in progress
+    })
+  );
 });
 
 test(function serverResponseTimeout(cb) {
-  const server = http.createServer(common.mustCall((req, res) => {
-    // just do nothing, we should get a timeout event.
-    const s = res.setTimeout(50, common.mustCall((socket) => {
-      socket.destroy();
-      server.close();
-      cb();
-    }));
-    assert.ok(s instanceof http.OutgoingMessage);
-  }));
-  server.listen(common.mustCall(() => {
-    http.get({
-      port: server.address().port
-    }).on('error', common.mustCall());
-  }));
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      // just do nothing, we should get a timeout event.
+      const s = res.setTimeout(
+        50,
+        common.mustCall((socket) => {
+          socket.destroy();
+          server.close();
+          cb();
+        })
+      );
+      assert.ok(s instanceof http.OutgoingMessage);
+    })
+  );
+  server.listen(
+    common.mustCall(() => {
+      http
+        .get({
+          port: server.address().port
+        })
+        .on('error', common.mustCall());
+    })
+  );
 });
 
 test(function serverRequestNotTimeoutAfterEnd(cb) {
-  const server = http.createServer(common.mustCall((req, res) => {
-    // just do nothing, we should get a timeout event.
-    const s = req.setTimeout(50, common.mustNotCall());
-    assert.ok(s instanceof http.IncomingMessage);
-    res.on('timeout', common.mustCall());
-  }));
-  server.on('timeout', common.mustCall((socket) => {
-    socket.destroy();
-    server.close();
-    cb();
-  }));
-  server.listen(common.mustCall(() => {
-    http.get({
-      port: server.address().port
-    }).on('error', common.mustCall());
-  }));
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      // just do nothing, we should get a timeout event.
+      const s = req.setTimeout(50, common.mustNotCall());
+      assert.ok(s instanceof http.IncomingMessage);
+      res.on('timeout', common.mustCall());
+    })
+  );
+  server.on(
+    'timeout',
+    common.mustCall((socket) => {
+      socket.destroy();
+      server.close();
+      cb();
+    })
+  );
+  server.listen(
+    common.mustCall(() => {
+      http
+        .get({
+          port: server.address().port
+        })
+        .on('error', common.mustCall());
+    })
+  );
 });
 
 test(function serverResponseTimeoutWithPipeline(cb) {
@@ -120,8 +151,7 @@ test(function serverResponseTimeoutWithPipeline(cb) {
     assert.strictEqual(caughtTimeout, '/2');
   });
   const server = http.createServer((req, res) => {
-    if (req.url === '/2')
-      secReceived = true;
+    if (req.url === '/2') secReceived = true;
     if (req.url === '/1') {
       res.end();
       return;
@@ -131,50 +161,65 @@ test(function serverResponseTimeoutWithPipeline(cb) {
     });
     assert.ok(s instanceof http.OutgoingMessage);
   });
-  server.on('timeout', common.mustCall((socket) => {
-    if (secReceived) {
-      socket.destroy();
-      server.close();
-      cb();
-    }
-  }));
-  server.listen(common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true,
-    };
-    const c = net.connect(options, () => {
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-    });
-  }));
+  server.on(
+    'timeout',
+    common.mustCall((socket) => {
+      if (secReceived) {
+        socket.destroy();
+        server.close();
+        cb();
+      }
+    })
+  );
+  server.listen(
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true
+      };
+      const c = net.connect(
+        options,
+        () => {
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+        }
+      );
+    })
+  );
 });
 
 test(function idleTimeout(cb) {
   // Test that the an idle connection invokes the timeout callback.
   const server = http.createServer();
-  const s = server.setTimeout(50, common.mustCall((socket) => {
-    socket.destroy();
-    server.close();
-    cb();
-  }));
+  const s = server.setTimeout(
+    50,
+    common.mustCall((socket) => {
+      socket.destroy();
+      server.close();
+      cb();
+    })
+  );
   assert.ok(s instanceof http.Server);
-  server.listen(common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true,
-    };
-    const c = net.connect(options, () => {
-      // ECONNRESET could happen on a heavily-loaded server.
-      c.on('error', (e) => {
-        if (e.message !== 'read ECONNRESET')
-          throw e;
-      });
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      // Keep-Alive
-    });
-  }));
+  server.listen(
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true
+      };
+      const c = net.connect(
+        options,
+        () => {
+          // ECONNRESET could happen on a heavily-loaded server.
+          c.on('error', (e) => {
+            if (e.message !== 'read ECONNRESET') throw e;
+          });
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          // Keep-Alive
+        }
+      );
+    })
+  );
 });
 
 test(function fastTimeout(cb) {
@@ -190,26 +235,36 @@ test(function fastTimeout(cb) {
     }
   }
 
-  const server = http.createServer(common.mustCall((req, res) => {
-    req.on('timeout', common.mustNotCall());
-    res.end();
-    connectionHandlerInvoked = true;
-    invokeCallbackIfDone();
-  }));
-  const s = server.setTimeout(1, common.mustCall((socket) => {
-    connectionSocket = socket;
-    timeoutHandlerInvoked = true;
-    invokeCallbackIfDone();
-  }));
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      req.on('timeout', common.mustNotCall());
+      res.end();
+      connectionHandlerInvoked = true;
+      invokeCallbackIfDone();
+    })
+  );
+  const s = server.setTimeout(
+    1,
+    common.mustCall((socket) => {
+      connectionSocket = socket;
+      timeoutHandlerInvoked = true;
+      invokeCallbackIfDone();
+    })
+  );
   assert.ok(s instanceof http.Server);
-  server.listen(common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true,
-    };
-    const c = net.connect(options, () => {
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      // Keep-Alive
-    });
-  }));
+  server.listen(
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true
+      };
+      const c = net.connect(
+        options,
+        () => {
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          // Keep-Alive
+        }
+      );
+    })
+  );
 });
diff --git a/test/parallel/test-http-set-timeout.js b/test/parallel/test-http-set-timeout.js
index 5440c23c215521..872f4c8df75741 100644
--- a/test/parallel/test-http-set-timeout.js
+++ b/test/parallel/test-http-set-timeout.js
@@ -29,19 +29,25 @@ const server = http.createServer(function(req, res) {
   console.log('got request. setting 500ms timeout');
   const socket = req.connection.setTimeout(500);
   assert.ok(socket instanceof net.Socket);
-  req.connection.on('timeout', common.mustCall(function() {
-    req.connection.destroy();
-    console.error('TIMEOUT');
-    server.close();
-  }));
+  req.connection.on(
+    'timeout',
+    common.mustCall(function() {
+      req.connection.destroy();
+      console.error('TIMEOUT');
+      server.close();
+    })
+  );
 });
 
 server.listen(0, function() {
   console.log(`Server running at http://127.0.0.1:${this.address().port}/`);
 
   const request = http.get({ port: this.address().port, path: '/' });
-  request.on('error', common.mustCall(function() {
-    console.log('HTTP REQUEST COMPLETE (this is good)');
-  }));
+  request.on(
+    'error',
+    common.mustCall(function() {
+      console.log('HTTP REQUEST COMPLETE (this is good)');
+    })
+  );
   request.end();
 });
diff --git a/test/parallel/test-http-set-trailers.js b/test/parallel/test-http-set-trailers.js
index 74eff427a43d30..cc5931805e4049 100644
--- a/test/parallel/test-http-set-trailers.js
+++ b/test/parallel/test-http-set-trailers.js
@@ -35,7 +35,6 @@ const server = http.createServer(function(req, res) {
 });
 server.listen(0);
 
-
 // first, we test an HTTP/1.0 request.
 server.on('listening', function() {
   const c = net.createConnection(this.address().port);
@@ -77,12 +76,13 @@ server.on('listening', function() {
   c.on('connect', function() {
     outstanding_reqs++;
     c.write('GET / HTTP/1.1\r\n\r\n');
-    tid = setTimeout(common.mustNotCall(), 2000, 'Couldn\'t find last chunk.');
+    tid = setTimeout(common.mustNotCall(), 2000, "Couldn't find last chunk.");
   });
 
   c.on('data', function(chunk) {
     res_buffer += chunk;
-    if (/0\r\n/.test(res_buffer)) { // got the end.
+    if (/0\r\n/.test(res_buffer)) {
+      // got the end.
       outstanding_reqs--;
       clearTimeout(tid);
       assert.ok(
@@ -99,21 +99,26 @@ server.on('listening', function() {
 
 // now, see if the client sees the trailers.
 server.on('listening', function() {
-  http.get({
-    port: this.address().port,
-    path: '/hello',
-    headers: {}
-  }, function(res) {
-    res.on('end', function() {
-      assert.ok('x-foo' in res.trailers,
-                `${util.inspect(res.trailers)} misses the 'x-foo' property`);
-      outstanding_reqs--;
-      if (outstanding_reqs === 0) {
-        server.close();
-        process.exit();
-      }
-    });
-    res.resume();
-  });
+  http.get(
+    {
+      port: this.address().port,
+      path: '/hello',
+      headers: {}
+    },
+    function(res) {
+      res.on('end', function() {
+        assert.ok(
+          'x-foo' in res.trailers,
+          `${util.inspect(res.trailers)} misses the 'x-foo' property`
+        );
+        outstanding_reqs--;
+        if (outstanding_reqs === 0) {
+          server.close();
+          process.exit();
+        }
+      });
+      res.resume();
+    }
+  );
   outstanding_reqs++;
 });
diff --git a/test/parallel/test-http-should-keep-alive.js b/test/parallel/test-http-should-keep-alive.js
index 038af47ee4db97..2670964df2211c 100644
--- a/test/parallel/test-http-should-keep-alive.js
+++ b/test/parallel/test-http-should-keep-alive.js
@@ -36,11 +36,11 @@ const SERVER_RESPONSES = [
 ];
 const SHOULD_KEEP_ALIVE = [
   false, // HTTP/1.0, default
-  true,  // HTTP/1.0, Connection: keep-alive
+  true, // HTTP/1.0, Connection: keep-alive
   false, // HTTP/1.0, Connection: close
-  true,  // HTTP/1.1, default
-  true,  // HTTP/1.1, Connection: keep-alive
-  false  // HTTP/1.1, Connection: close
+  true, // HTTP/1.1, default
+  true, // HTTP/1.1, Connection: keep-alive
+  false // HTTP/1.1, Connection: close
 ];
 http.globalAgent.maxSockets = 5;
 
@@ -48,21 +48,26 @@ const countdown = new Countdown(SHOULD_KEEP_ALIVE.length, () => server.close());
 
 const getCountdownIndex = () => SERVER_RESPONSES.length - countdown.remaining;
 
-const server = net.createServer(function(socket) {
-  socket.write(SERVER_RESPONSES[getCountdownIndex()]);
-}).listen(0, function() {
-  function makeRequest() {
-    const req = http.get({ port: server.address().port }, function(res) {
-      assert.strictEqual(
-        req.shouldKeepAlive, SHOULD_KEEP_ALIVE[getCountdownIndex()],
-        `${SERVER_RESPONSES[getCountdownIndex()]} should ${
-          SHOULD_KEEP_ALIVE[getCountdownIndex()] ? '' : 'not '}Keep-Alive`);
-      countdown.dec();
-      if (countdown.remaining) {
-        makeRequest();
-      }
-      res.resume();
-    });
-  }
-  makeRequest();
-});
+const server = net
+  .createServer(function(socket) {
+    socket.write(SERVER_RESPONSES[getCountdownIndex()]);
+  })
+  .listen(0, function() {
+    function makeRequest() {
+      const req = http.get({ port: server.address().port }, function(res) {
+        assert.strictEqual(
+          req.shouldKeepAlive,
+          SHOULD_KEEP_ALIVE[getCountdownIndex()],
+          `${SERVER_RESPONSES[getCountdownIndex()]} should ${
+            SHOULD_KEEP_ALIVE[getCountdownIndex()] ? '' : 'not '
+          }Keep-Alive`
+        );
+        countdown.dec();
+        if (countdown.remaining) {
+          makeRequest();
+        }
+        res.resume();
+      });
+    }
+    makeRequest();
+  });
diff --git a/test/parallel/test-http-status-code.js b/test/parallel/test-http-status-code.js
index 246d22c131fe65..f8de790bd8671d 100644
--- a/test/parallel/test-http-status-code.js
+++ b/test/parallel/test-http-status-code.js
@@ -41,7 +41,6 @@ const s = http.createServer(function(req, res) {
 
 s.listen(0, nextTest);
 
-
 function nextTest() {
   test = tests.shift();
 
@@ -50,8 +49,7 @@ function nextTest() {
     console.log(`client: statusCode: ${response.statusCode}`);
     assert.strictEqual(response.statusCode, test);
     response.on('end', function() {
-      if (countdown.dec())
-        nextTest();
+      if (countdown.dec()) nextTest();
     });
     response.resume();
   });
diff --git a/test/parallel/test-http-status-reason-invalid-chars.js b/test/parallel/test-http-status-reason-invalid-chars.js
index ce08ff84a09b42..763c74d893d6a3 100644
--- a/test/parallel/test-http-status-reason-invalid-chars.js
+++ b/test/parallel/test-http-status-reason-invalid-chars.js
@@ -27,21 +27,26 @@ function implicit(req, res) {
   res.end();
 }
 
-const server = http.createServer((req, res) => {
-  if (req.url === '/explicit') {
-    explicit(req, res);
-  } else {
-    implicit(req, res);
-  }
-}).listen(0, common.mustCall(() => {
-  const hostname = 'localhost';
-  const countdown = new Countdown(2, () => server.close());
-  const url = `http://${hostname}:${server.address().port}`;
-  const check = common.mustCall((res) => {
-    assert.notStrictEqual(res.headers['content-type'], 'text/html');
-    assert.notStrictEqual(res.headers['content-type'], 'gotcha');
-    countdown.dec();
-  }, 2);
-  http.get(`${url}/explicit`, check).end();
-  http.get(`${url}/implicit`, check).end();
-}));
+const server = http
+  .createServer((req, res) => {
+    if (req.url === '/explicit') {
+      explicit(req, res);
+    } else {
+      implicit(req, res);
+    }
+  })
+  .listen(
+    0,
+    common.mustCall(() => {
+      const hostname = 'localhost';
+      const countdown = new Countdown(2, () => server.close());
+      const url = `http://${hostname}:${server.address().port}`;
+      const check = common.mustCall((res) => {
+        assert.notStrictEqual(res.headers['content-type'], 'text/html');
+        assert.notStrictEqual(res.headers['content-type'], 'gotcha');
+        countdown.dec();
+      }, 2);
+      http.get(`${url}/explicit`, check).end();
+      http.get(`${url}/implicit`, check).end();
+    })
+  );
diff --git a/test/parallel/test-http-timeout-client-warning.js b/test/parallel/test-http-timeout-client-warning.js
index f11515b95fe340..e4500a8d591efa 100644
--- a/test/parallel/test-http-timeout-client-warning.js
+++ b/test/parallel/test-http-timeout-client-warning.js
@@ -6,16 +6,25 @@ const assert = require('assert');
 // Checks that the setTimeout duration overflow warning is emitted
 // synchronously and therefore contains a meaningful stacktrace.
 
-process.on('warning', common.mustCall((warning) => {
-  assert(warning.stack.includes(__filename));
-}));
+process.on(
+  'warning',
+  common.mustCall((warning) => {
+    assert(warning.stack.includes(__filename));
+  })
+);
 
 const server = http.createServer((req, resp) => resp.end());
-server.listen(common.mustCall(() => {
-  http.request(`http://localhost:${server.address().port}`)
-    .setTimeout(2 ** 40)
-    .on('response', common.mustCall(() => {
-      server.close();
-    }))
-    .end();
-}));
+server.listen(
+  common.mustCall(() => {
+    http
+      .request(`http://localhost:${server.address().port}`)
+      .setTimeout(2 ** 40)
+      .on(
+        'response',
+        common.mustCall(() => {
+          server.close();
+        })
+      )
+      .end();
+  })
+);
diff --git a/test/parallel/test-http-timeout-overflow.js b/test/parallel/test-http-timeout-overflow.js
index e95405bc8b3554..6469042f0df43b 100644
--- a/test/parallel/test-http-timeout-overflow.js
+++ b/test/parallel/test-http-timeout-overflow.js
@@ -23,27 +23,35 @@
 const common = require('../common');
 const http = require('http');
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.end('OK');
-}));
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end('OK');
+  })
+);
 
 server.listen(0, function() {
   function callback() {}
 
-  const req = http.request({
-    port: this.address().port,
-    path: '/',
-    agent: false
-  }, function(res) {
-    req.clearTimeout(callback);
+  const req = http.request(
+    {
+      port: this.address().port,
+      path: '/',
+      agent: false
+    },
+    function(res) {
+      req.clearTimeout(callback);
 
-    res.on('end', common.mustCall(function() {
-      server.close();
-    }));
+      res.on(
+        'end',
+        common.mustCall(function() {
+          server.close();
+        })
+      );
 
-    res.resume();
-  });
+      res.resume();
+    }
+  );
 
   // Overflow signed int32
   req.setTimeout(0xffffffff, callback);
diff --git a/test/parallel/test-http-timeout.js b/test/parallel/test-http-timeout.js
index c576f1c5429101..4442a24d5f34ab 100644
--- a/test/parallel/test-http-timeout.js
+++ b/test/parallel/test-http-timeout.js
@@ -35,7 +35,6 @@ const agent = new http.Agent({ maxSockets: 1 });
 const countdown = new Countdown(MAX_COUNT, () => server.close());
 
 server.listen(0, function() {
-
   for (let i = 0; i < MAX_COUNT; ++i) {
     createRequest().end();
   }
diff --git a/test/parallel/test-http-unix-socket-keep-alive.js b/test/parallel/test-http-unix-socket-keep-alive.js
index 11b3d9b39264a4..70f6afff5eb1aa 100644
--- a/test/parallel/test-http-unix-socket-keep-alive.js
+++ b/test/parallel/test-http-unix-socket-keep-alive.js
@@ -8,15 +8,24 @@ const server = http.createServer((req, res) => res.end());
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-server.listen(common.PIPE, common.mustCall(() =>
-  asyncLoop(makeKeepAliveRequest, 10, common.mustCall(() =>
-    server.getConnections(common.mustCall((err, conns) => {
-      assert.ifError(err);
-      assert.strictEqual(conns, 1);
-      server.close();
-    }))
-  ))
-));
+server.listen(
+  common.PIPE,
+  common.mustCall(() =>
+    asyncLoop(
+      makeKeepAliveRequest,
+      10,
+      common.mustCall(() =>
+        server.getConnections(
+          common.mustCall((err, conns) => {
+            assert.ifError(err);
+            assert.strictEqual(conns, 1);
+            server.close();
+          })
+        )
+      )
+    )
+  )
+);
 
 function asyncLoop(fn, times, cb) {
   fn(function handler() {
@@ -28,11 +37,15 @@ function asyncLoop(fn, times, cb) {
   });
 }
 function makeKeepAliveRequest(cb) {
-  http.get({
-    socketPath: common.PIPE,
-    headers: { connection: 'keep-alive' }
-  }, (res) => res.on('data', common.mustNotCall())
-    .on('error', assert.fail)
-    .on('end', cb)
+  http.get(
+    {
+      socketPath: common.PIPE,
+      headers: { connection: 'keep-alive' }
+    },
+    (res) =>
+      res
+        .on('data', common.mustNotCall())
+        .on('error', assert.fail)
+        .on('end', cb)
   );
 }
diff --git a/test/parallel/test-http-unix-socket.js b/test/parallel/test-http-unix-socket.js
index cfed45a43c2e83..f61208532e2c71 100644
--- a/test/parallel/test-http-unix-socket.js
+++ b/test/parallel/test-http-unix-socket.js
@@ -27,7 +27,7 @@ const http = require('http');
 const server = http.createServer(function(req, res) {
   res.writeHead(200, {
     'Content-Type': 'text/plain',
-    'Connection': 'close'
+    Connection: 'close'
   });
   res.write('hello ');
   res.write('world\n');
@@ -37,41 +37,52 @@ const server = http.createServer(function(req, res) {
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-server.listen(common.PIPE, common.mustCall(function() {
+server.listen(
+  common.PIPE,
+  common.mustCall(function() {
+    const options = {
+      socketPath: common.PIPE,
+      path: '/'
+    };
 
-  const options = {
-    socketPath: common.PIPE,
-    path: '/'
-  };
+    const req = http.get(
+      options,
+      common.mustCall(function(res) {
+        assert.strictEqual(res.statusCode, 200);
+        assert.strictEqual(res.headers['content-type'], 'text/plain');
 
-  const req = http.get(options, common.mustCall(function(res) {
-    assert.strictEqual(res.statusCode, 200);
-    assert.strictEqual(res.headers['content-type'], 'text/plain');
+        res.body = '';
+        res.setEncoding('utf8');
 
-    res.body = '';
-    res.setEncoding('utf8');
+        res.on('data', function(chunk) {
+          res.body += chunk;
+        });
 
-    res.on('data', function(chunk) {
-      res.body += chunk;
-    });
-
-    res.on('end', common.mustCall(function() {
-      assert.strictEqual(res.body, 'hello world\n');
-      server.close(common.mustCall(function(error) {
-        assert.strictEqual(error, undefined);
-        server.close(common.expectsError({
-          code: 'ERR_SERVER_NOT_RUNNING',
-          message: 'Server is not running.',
-          type: Error
-        }));
-      }));
-    }));
-  }));
+        res.on(
+          'end',
+          common.mustCall(function() {
+            assert.strictEqual(res.body, 'hello world\n');
+            server.close(
+              common.mustCall(function(error) {
+                assert.strictEqual(error, undefined);
+                server.close(
+                  common.expectsError({
+                    code: 'ERR_SERVER_NOT_RUNNING',
+                    message: 'Server is not running.',
+                    type: Error
+                  })
+                );
+              })
+            );
+          })
+        );
+      })
+    );
 
-  req.on('error', function(e) {
-    assert.fail(e.stack);
-  });
-
-  req.end();
+    req.on('error', function(e) {
+      assert.fail(e.stack);
+    });
 
-}));
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http-upgrade-advertise.js b/test/parallel/test-http-upgrade-advertise.js
index 6d033ba36a5d60..25651a422af1a9 100644
--- a/test/parallel/test-http-upgrade-advertise.js
+++ b/test/parallel/test-http-upgrade-advertise.js
@@ -10,12 +10,11 @@ const tests = [
   { headers: { connection: 'upgrade' }, expected: 'regular' },
   { headers: { connection: 'upgrade', upgrade: 'h2c' }, expected: 'upgrade' },
   { headers: { connection: 'upgrade', upgrade: 'h2c' }, expected: 'destroy' },
-  { headers: { connection: 'upgrade', upgrade: 'h2c' }, expected: 'regular' },
+  { headers: { connection: 'upgrade', upgrade: 'h2c' }, expected: 'regular' }
 ];
 
 function fire() {
-  if (tests.length === 0)
-    return server.close();
+  if (tests.length === 0) return server.close();
 
   const test = tests.shift();
 
@@ -25,20 +24,25 @@ function fire() {
     fire();
   });
 
-  const req = http.request({
-    port: server.address().port,
-    path: '/',
-    headers: test.headers
-  }, function onResponse(res) {
-    res.resume();
-    done('regular');
-  });
+  const req = http.request(
+    {
+      port: server.address().port,
+      path: '/',
+      headers: test.headers
+    },
+    function onResponse(res) {
+      res.resume();
+      done('regular');
+    }
+  );
 
   if (test.expected === 'destroy') {
-    req.on('socket', () => req.socket.on('close', () => {
-      server.removeAllListeners('upgrade');
-      done('destroy');
-    }));
+    req.on('socket', () =>
+      req.socket.on('close', () => {
+        server.removeAllListeners('upgrade');
+        done('destroy');
+      })
+    );
   } else {
     req.on('upgrade', function onUpgrade(res, socket) {
       socket.destroy();
@@ -49,15 +53,20 @@ function fire() {
   req.end();
 }
 
-const server = http.createServer(function(req, res) {
-  res.writeHead(200, {
-    Connection: 'upgrade, keep-alive',
-    Upgrade: 'h2c'
-  });
-  res.end('hello world');
-}).on('upgrade', function(req, socket) {
-  socket.end('HTTP/1.1 101 Switching protocols\r\n' +
-             'Connection: upgrade\r\n' +
-             'Upgrade: h2c\r\n\r\n' +
-             'ohai');
-}).listen(0, fire);
+const server = http
+  .createServer(function(req, res) {
+    res.writeHead(200, {
+      Connection: 'upgrade, keep-alive',
+      Upgrade: 'h2c'
+    });
+    res.end('hello world');
+  })
+  .on('upgrade', function(req, socket) {
+    socket.end(
+      'HTTP/1.1 101 Switching protocols\r\n' +
+        'Connection: upgrade\r\n' +
+        'Upgrade: h2c\r\n\r\n' +
+        'ohai'
+    );
+  })
+  .listen(0, fire);
diff --git a/test/parallel/test-http-upgrade-agent.js b/test/parallel/test-http-upgrade-agent.js
index 5c840eeb532814..b3cc0134bb104e 100644
--- a/test/parallel/test-http-upgrade-agent.js
+++ b/test/parallel/test-http-upgrade-agent.js
@@ -46,43 +46,57 @@ const srv = net.createServer(function(c) {
   });
 });
 
-srv.listen(0, '127.0.0.1', common.mustCall(function() {
+srv.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    const options = {
+      port: this.address().port,
+      host: '127.0.0.1',
+      headers: {
+        connection: 'upgrade',
+        upgrade: 'websocket'
+      }
+    };
+    const name = `${options.host}:${options.port}`;
 
-  const options = {
-    port: this.address().port,
-    host: '127.0.0.1',
-    headers: {
-      'connection': 'upgrade',
-      'upgrade': 'websocket'
-    }
-  };
-  const name = `${options.host}:${options.port}`;
+    const req = http.request(options);
+    req.end();
 
-  const req = http.request(options);
-  req.end();
+    req.on(
+      'upgrade',
+      common.mustCall(function(res, socket, upgradeHead) {
+        let recvData = upgradeHead;
+        socket.on('data', function(d) {
+          recvData += d;
+        });
 
-  req.on('upgrade', common.mustCall(function(res, socket, upgradeHead) {
-    let recvData = upgradeHead;
-    socket.on('data', function(d) {
-      recvData += d;
-    });
+        socket.on(
+          'close',
+          common.mustCall(function() {
+            assert.strictEqual(recvData.toString(), 'nurtzo');
+          })
+        );
 
-    socket.on('close', common.mustCall(function() {
-      assert.strictEqual(recvData.toString(), 'nurtzo');
-    }));
+        console.log(res.headers);
+        const expectedHeaders = {
+          hello: 'world',
+          connection: 'upgrade',
+          upgrade: 'websocket'
+        };
+        assert.deepStrictEqual(expectedHeaders, res.headers);
 
-    console.log(res.headers);
-    const expectedHeaders = { 'hello': 'world',
-                              'connection': 'upgrade',
-                              'upgrade': 'websocket' };
-    assert.deepStrictEqual(expectedHeaders, res.headers);
+        // Make sure this request got removed from the pool.
+        assert(!http.globalAgent.sockets.hasOwnProperty(name));
 
-    // Make sure this request got removed from the pool.
-    assert(!http.globalAgent.sockets.hasOwnProperty(name));
-
-    req.on('close', common.mustCall(function() {
-      socket.end();
-      srv.close();
-    }));
-  }));
-}));
+        req.on(
+          'close',
+          common.mustCall(function() {
+            socket.end();
+            srv.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-upgrade-binary.js b/test/parallel/test-http-upgrade-binary.js
index 002ac9c564ad1e..496856a435ff19 100644
--- a/test/parallel/test-http-upgrade-binary.js
+++ b/test/parallel/test-http-upgrade-binary.js
@@ -7,22 +7,37 @@ const net = require('net');
 // https://github.com/nodejs/node/issues/17789 - a connection upgrade response
 // that has a Transfer-Encoding header and a body whose first byte is > 127
 // triggers a bug where said byte is skipped over.
-net.createServer(mustCall(function(conn) {
-  conn.write('HTTP/1.1 101 Switching Protocols\r\n' +
-             'Connection: upgrade\r\n' +
-             'Transfer-Encoding: chunked\r\n' +
-             'Upgrade: websocket\r\n' +
-             '\r\n' +
-             '\u0080', 'latin1');
-  this.close();
-})).listen(0, mustCall(function() {
-  http.get({
-    host: this.address().host,
-    port: this.address().port,
-    headers: { 'Connection': 'upgrade', 'Upgrade': 'websocket' },
-  }).on('upgrade', mustCall((res, conn, head) => {
-    assert.strictEqual(head.length, 1);
-    assert.strictEqual(head[0], 128);
-    conn.destroy();
-  }));
-}));
+net
+  .createServer(
+    mustCall(function(conn) {
+      conn.write(
+        'HTTP/1.1 101 Switching Protocols\r\n' +
+          'Connection: upgrade\r\n' +
+          'Transfer-Encoding: chunked\r\n' +
+          'Upgrade: websocket\r\n' +
+          '\r\n' +
+          '\u0080',
+        'latin1'
+      );
+      this.close();
+    })
+  )
+  .listen(
+    0,
+    mustCall(function() {
+      http
+        .get({
+          host: this.address().host,
+          port: this.address().port,
+          headers: { Connection: 'upgrade', Upgrade: 'websocket' }
+        })
+        .on(
+          'upgrade',
+          mustCall((res, conn, head) => {
+            assert.strictEqual(head.length, 1);
+            assert.strictEqual(head[0], 128);
+            conn.destroy();
+          })
+        );
+    })
+  );
diff --git a/test/parallel/test-http-upgrade-client.js b/test/parallel/test-http-upgrade-client.js
index c637324a53d801..cef31148b328c5 100644
--- a/test/parallel/test-http-upgrade-client.js
+++ b/test/parallel/test-http-upgrade-client.js
@@ -47,52 +47,65 @@ const srv = net.createServer(function(c) {
   });
 });
 
-srv.listen(0, '127.0.0.1', common.mustCall(function() {
-  const port = this.address().port;
-  const headers = [
-    {
-      connection: 'upgrade',
-      upgrade: 'websocket'
-    },
-    [
-      ['Host', 'echo.websocket.org'],
-      ['Connection', 'Upgrade'],
-      ['Upgrade', 'websocket'],
-      ['Origin', 'http://www.websocket.org']
-    ]
-  ];
-  const countdown = new Countdown(headers.length, () => srv.close());
+srv.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    const port = this.address().port;
+    const headers = [
+      {
+        connection: 'upgrade',
+        upgrade: 'websocket'
+      },
+      [
+        ['Host', 'echo.websocket.org'],
+        ['Connection', 'Upgrade'],
+        ['Upgrade', 'websocket'],
+        ['Origin', 'http://www.websocket.org']
+      ]
+    ];
+    const countdown = new Countdown(headers.length, () => srv.close());
 
-  headers.forEach(function(h) {
-    const req = http.get({
-      port: port,
-      headers: h
-    });
-    let sawUpgrade = false;
-    req.on('upgrade', common.mustCall(function(res, socket, upgradeHead) {
-      sawUpgrade = true;
-      let recvData = upgradeHead;
-      socket.on('data', function(d) {
-        recvData += d;
+    headers.forEach(function(h) {
+      const req = http.get({
+        port: port,
+        headers: h
       });
+      let sawUpgrade = false;
+      req.on(
+        'upgrade',
+        common.mustCall(function(res, socket, upgradeHead) {
+          sawUpgrade = true;
+          let recvData = upgradeHead;
+          socket.on('data', function(d) {
+            recvData += d;
+          });
 
-      socket.on('close', common.mustCall(function() {
-        assert.strictEqual(recvData.toString(), 'nurtzo');
-      }));
+          socket.on(
+            'close',
+            common.mustCall(function() {
+              assert.strictEqual(recvData.toString(), 'nurtzo');
+            })
+          );
 
-      console.log(res.headers);
-      const expectedHeaders = {
-        hello: 'world',
-        connection: 'upgrade',
-        upgrade: 'websocket'
-      };
-      assert.deepStrictEqual(expectedHeaders, res.headers);
+          console.log(res.headers);
+          const expectedHeaders = {
+            hello: 'world',
+            connection: 'upgrade',
+            upgrade: 'websocket'
+          };
+          assert.deepStrictEqual(expectedHeaders, res.headers);
 
-      socket.end();
-      countdown.dec();
-    }));
-    req.on('close', common.mustCall(function() {
-      assert.strictEqual(sawUpgrade, true);
-    }));
-  });
-}));
+          socket.end();
+          countdown.dec();
+        })
+      );
+      req.on(
+        'close',
+        common.mustCall(function() {
+          assert.strictEqual(sawUpgrade, true);
+        })
+      );
+    });
+  })
+);
diff --git a/test/parallel/test-http-upgrade-client2.js b/test/parallel/test-http-upgrade-client2.js
index 8883faa9e05067..d2edd98fc4f867 100644
--- a/test/parallel/test-http-upgrade-client2.js
+++ b/test/parallel/test-http-upgrade-client2.js
@@ -27,55 +27,62 @@ const CRLF = '\r\n';
 
 const server = http.createServer();
 server.on('upgrade', function(req, socket) {
-  socket.write(`HTTP/1.1 101 Ok${CRLF}` +
-               `Connection: Upgrade${CRLF}` +
-               `Upgrade: Test${CRLF}${CRLF}` +
-               'head');
+  socket.write(
+    `HTTP/1.1 101 Ok${CRLF}` +
+      `Connection: Upgrade${CRLF}` +
+      `Upgrade: Test${CRLF}${CRLF}` +
+      'head'
+  );
   socket.on('end', function() {
     socket.end();
   });
 });
 
-server.listen(0, common.mustCall(function() {
+server.listen(
+  0,
+  common.mustCall(function() {
+    function upgradeRequest(fn) {
+      console.log('req');
+      const header = { Connection: 'Upgrade', Upgrade: 'Test' };
+      const request = http.request({
+        port: server.address().port,
+        headers: header
+      });
+      let wasUpgrade = false;
 
-  function upgradeRequest(fn) {
-    console.log('req');
-    const header = { 'Connection': 'Upgrade', 'Upgrade': 'Test' };
-    const request = http.request({
-      port: server.address().port,
-      headers: header
-    });
-    let wasUpgrade = false;
+      function onUpgrade(res, socket) {
+        console.log('client upgraded');
+        wasUpgrade = true;
 
-    function onUpgrade(res, socket) {
-      console.log('client upgraded');
-      wasUpgrade = true;
-
-      request.removeListener('upgrade', onUpgrade);
-      socket.end();
-    }
-    request.on('upgrade', onUpgrade);
-
-    function onEnd() {
-      console.log('client end');
-      request.removeListener('end', onEnd);
-      if (!wasUpgrade) {
-        throw new Error('hasn\'t received upgrade event');
-      } else {
-        fn && process.nextTick(fn);
+        request.removeListener('upgrade', onUpgrade);
+        socket.end();
       }
-    }
-    request.on('close', onEnd);
+      request.on('upgrade', onUpgrade);
 
-    request.write('head');
+      function onEnd() {
+        console.log('client end');
+        request.removeListener('end', onEnd);
+        if (!wasUpgrade) {
+          throw new Error("hasn't received upgrade event");
+        } else {
+          fn && process.nextTick(fn);
+        }
+      }
+      request.on('close', onEnd);
 
-  }
+      request.write('head');
+    }
 
-  upgradeRequest(common.mustCall(function() {
-    upgradeRequest(common.mustCall(function() {
-      // Test pass
-      console.log('Pass!');
-      server.close();
-    }));
-  }));
-}));
+    upgradeRequest(
+      common.mustCall(function() {
+        upgradeRequest(
+          common.mustCall(function() {
+            // Test pass
+            console.log('Pass!');
+            server.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-upgrade-reconsume-stream.js b/test/parallel/test-http-upgrade-reconsume-stream.js
index e712ea647b3ad9..0ed576c2296423 100644
--- a/test/parallel/test-http-upgrade-reconsume-stream.js
+++ b/test/parallel/test-http-upgrade-reconsume-stream.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const http = require('http');
@@ -11,19 +10,27 @@ const http = require('http');
 
 const server = http.createServer(common.mustNotCall());
 
-server.on('upgrade', common.mustCall((request, socket, head) => {
-  // This should not crash.
-  new tls.TLSSocket(socket);
-  server.close();
-  socket.destroy();
-}));
+server.on(
+  'upgrade',
+  common.mustCall((request, socket, head) => {
+    // This should not crash.
+    new tls.TLSSocket(socket);
+    server.close();
+    socket.destroy();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  http.get({
-    port: server.address().port,
-    headers: {
-      'Connection': 'Upgrade',
-      'Upgrade': 'websocket'
-    }
-  }).on('error', () => {});
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    http
+      .get({
+        port: server.address().port,
+        headers: {
+          Connection: 'Upgrade',
+          Upgrade: 'websocket'
+        }
+      })
+      .on('error', () => {});
+  })
+);
diff --git a/test/parallel/test-http-upgrade-server.js b/test/parallel/test-http-upgrade-server.js
index 4271ad920d6c39..a0179e4a4c64df 100644
--- a/test/parallel/test-http-upgrade-server.js
+++ b/test/parallel/test-http-upgrade-server.js
@@ -28,7 +28,6 @@ const util = require('util');
 const net = require('net');
 const http = require('http');
 
-
 let requests_recv = 0;
 let requests_sent = 0;
 let request_upgradeHead = null;
@@ -51,10 +50,12 @@ function testServer() {
   });
 
   this.on('upgrade', function(req, socket, upgradeHead) {
-    socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
-                 'Upgrade: WebSocket\r\n' +
-                 'Connection: Upgrade\r\n' +
-                 '\r\n\r\n');
+    socket.write(
+      'HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
+        'Upgrade: WebSocket\r\n' +
+        'Connection: Upgrade\r\n' +
+        '\r\n\r\n'
+    );
 
     request_upgradeHead = upgradeHead;
 
@@ -71,13 +72,11 @@ function testServer() {
 
 util.inherits(testServer, http.Server);
 
-
 function writeReq(socket, data, encoding) {
   requests_sent++;
   socket.write(data);
 }
 
-
 /*-----------------------------------------------
   connection: Upgrade with listener
 -----------------------------------------------*/
@@ -87,12 +86,14 @@ function test_upgrade_with_listener() {
   let state = 0;
 
   conn.on('connect', function() {
-    writeReq(conn,
-             'GET / HTTP/1.1\r\n' +
-             'Upgrade: WebSocket\r\n' +
-             'Connection: Upgrade\r\n' +
-             '\r\n' +
-             'WjN}|M(6');
+    writeReq(
+      conn,
+      'GET / HTTP/1.1\r\n' +
+        'Upgrade: WebSocket\r\n' +
+        'Connection: Upgrade\r\n' +
+        '\r\n' +
+        'WjN}|M(6'
+    );
   });
 
   conn.on('data', function(data) {
@@ -126,11 +127,13 @@ function test_upgrade_no_listener() {
   conn.setEncoding('utf8');
 
   conn.on('connect', function() {
-    writeReq(conn,
-             'GET / HTTP/1.1\r\n' +
-             'Upgrade: WebSocket\r\n' +
-             'Connection: Upgrade\r\n' +
-             '\r\n');
+    writeReq(
+      conn,
+      'GET / HTTP/1.1\r\n' +
+        'Upgrade: WebSocket\r\n' +
+        'Connection: Upgrade\r\n' +
+        '\r\n'
+    );
   });
 
   conn.once('data', (data) => {
@@ -166,7 +169,6 @@ function test_standard_http() {
   });
 }
 
-
 const server = createTestServer();
 
 server.listen(0, function() {
@@ -174,7 +176,6 @@ server.listen(0, function() {
   test_upgrade_with_listener();
 });
 
-
 /*-----------------------------------------------
   Fin.
 -----------------------------------------------*/
diff --git a/test/parallel/test-http-upgrade-server2.js b/test/parallel/test-http-upgrade-server2.js
index a6c142e60ac9aa..0d845aa08537f4 100644
--- a/test/parallel/test-http-upgrade-server2.js
+++ b/test/parallel/test-http-upgrade-server2.js
@@ -26,7 +26,7 @@ const http = require('http');
 const net = require('net');
 
 const server = http.createServer(function(req, res) {
-  throw new Error('This shouldn\'t happen.');
+  throw new Error("This shouldn't happen.");
 });
 
 server.on('upgrade', function(req, socket, upgradeHead) {
@@ -35,20 +35,24 @@ server.on('upgrade', function(req, socket, upgradeHead) {
   throw new Error('upgrade error');
 });
 
-process.on('uncaughtException', common.mustCall(function(e) {
-  assert.strictEqual(e.message, 'upgrade error');
-  process.exit(0);
-}));
-
+process.on(
+  'uncaughtException',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.message, 'upgrade error');
+    process.exit(0);
+  })
+);
 
 server.listen(0, function() {
   const c = net.createConnection(this.address().port);
 
   c.on('connect', function() {
-    c.write('GET /blah HTTP/1.1\r\n' +
-            'Upgrade: WebSocket\r\n' +
-            'Connection: Upgrade\r\n' +
-            '\r\n\r\nhello world');
+    c.write(
+      'GET /blah HTTP/1.1\r\n' +
+        'Upgrade: WebSocket\r\n' +
+        'Connection: Upgrade\r\n' +
+        '\r\n\r\nhello world'
+    );
   });
 
   c.on('end', function() {
diff --git a/test/parallel/test-http-url.parse-auth-with-header-in-request.js b/test/parallel/test-http-url.parse-auth-with-header-in-request.js
index c10f5ed7b0d31b..a78958155c3b9c 100644
--- a/test/parallel/test-http-url.parse-auth-with-header-in-request.js
+++ b/test/parallel/test-http-url.parse-auth-with-header-in-request.js
@@ -39,8 +39,9 @@ const server = http.createServer(function(request, response) {
 });
 
 server.listen(0, function() {
-  const testURL =
-    url.parse(`http://asdf:qwer@localhost:${this.address().port}`);
+  const testURL = url.parse(
+    `http://asdf:qwer@localhost:${this.address().port}`
+  );
   // the test here is if you set a specific authorization header in the
   // request we should not override that with basic auth
   testURL.headers = {
diff --git a/test/parallel/test-http-url.parse-basic.js b/test/parallel/test-http-url.parse-basic.js
index a6ecd3918f1803..76640784ed7fc4 100644
--- a/test/parallel/test-http-url.parse-basic.js
+++ b/test/parallel/test-http-url.parse-basic.js
@@ -34,8 +34,10 @@ function check(request) {
   // there are no URL params, so you should not see any
   assert.strictEqual(request.url, '/');
   // the host header should use the url.parse.hostname
-  assert.strictEqual(request.headers.host,
-                     `${testURL.hostname}:${testURL.port}`);
+  assert.strictEqual(
+    request.headers.host,
+    `${testURL.hostname}:${testURL.port}`
+  );
 }
 
 const server = http.createServer(function(request, response) {
diff --git a/test/parallel/test-http-url.parse-https.request.js b/test/parallel/test-http-url.parse-https.request.js
index f58be0257c1fc5..b3e9983b540337 100644
--- a/test/parallel/test-http-url.parse-https.request.js
+++ b/test/parallel/test-http-url.parse-https.request.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const { readKey } = require('../common/fixtures');
 
 const assert = require('assert');
diff --git a/test/parallel/test-http-url.parse-only-support-http-https-protocol.js b/test/parallel/test-http-url.parse-only-support-http-https-protocol.js
index 5df547594b8450..7fe222b543c70a 100644
--- a/test/parallel/test-http-url.parse-only-support-http-https-protocol.js
+++ b/test/parallel/test-http-url.parse-only-support-http-https-protocol.js
@@ -28,14 +28,16 @@ const invalidUrls = [
   'file:///whatever',
   'mailto:asdf@asdf.com',
   'ftp://www.example.com',
-  'javascript:alert(\'hello\');',
+  "javascript:alert('hello');",
   'xmpp:foo@bar.com',
   'f://some.host/path'
 ];
 
 invalidUrls.forEach((invalid) => {
   common.expectsError(
-    () => { http.request(url.parse(invalid)); },
+    () => {
+      http.request(url.parse(invalid));
+    },
     {
       code: 'ERR_INVALID_PROTOCOL',
       type: TypeError
diff --git a/test/parallel/test-http-url.parse-post.js b/test/parallel/test-http-url.parse-post.js
index 91a567d1560f1a..fcbf7caec6846b 100644
--- a/test/parallel/test-http-url.parse-post.js
+++ b/test/parallel/test-http-url.parse-post.js
@@ -33,8 +33,10 @@ function check(request) {
   // Everything else should be right
   assert.strictEqual(request.url, '/asdf?qwer=zxcv');
   // The host header should use the url.parse.hostname
-  assert.strictEqual(request.headers.host,
-                     `${testURL.hostname}:${testURL.port}`);
+  assert.strictEqual(
+    request.headers.host,
+    `${testURL.hostname}:${testURL.port}`
+  );
 }
 
 const server = http.createServer(function(request, response) {
diff --git a/test/parallel/test-http-wget.js b/test/parallel/test-http-wget.js
index ef06deefdf8afa..ae5bac7c747d2c 100644
--- a/test/parallel/test-http-wget.js
+++ b/test/parallel/test-http-wget.js
@@ -48,31 +48,39 @@ const server = http.createServer(function(req, res) {
 });
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const c = net.createConnection(this.address().port);
-  let server_response = '';
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const c = net.createConnection(this.address().port);
+    let server_response = '';
 
-  c.setEncoding('utf8');
+    c.setEncoding('utf8');
 
-  c.on('connect', function() {
-    c.write('GET / HTTP/1.0\r\n' +
-            'Connection: Keep-Alive\r\n\r\n');
-  });
+    c.on('connect', function() {
+      c.write('GET / HTTP/1.0\r\n' + 'Connection: Keep-Alive\r\n\r\n');
+    });
 
-  c.on('data', function(chunk) {
-    console.log(chunk);
-    server_response += chunk;
-  });
+    c.on('data', function(chunk) {
+      console.log(chunk);
+      server_response += chunk;
+    });
 
-  c.on('end', common.mustCall(function() {
-    const m = server_response.split('\r\n\r\n');
-    assert.strictEqual(m[1], 'hello world\n');
-    console.log('got end');
-    c.end();
-  }));
+    c.on(
+      'end',
+      common.mustCall(function() {
+        const m = server_response.split('\r\n\r\n');
+        assert.strictEqual(m[1], 'hello world\n');
+        console.log('got end');
+        c.end();
+      })
+    );
 
-  c.on('close', common.mustCall(function() {
-    console.log('got close');
-    server.close();
-  }));
-}));
+    c.on(
+      'close',
+      common.mustCall(function() {
+        console.log('got close');
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-writable-true-after-close.js b/test/parallel/test-http-writable-true-after-close.js
index a1915dd69c5da8..1ae36cc0a57cba 100644
--- a/test/parallel/test-http-writable-true-after-close.js
+++ b/test/parallel/test-http-writable-true-after-close.js
@@ -11,32 +11,42 @@ let internal;
 let external;
 
 // Proxy server
-const server = createServer(common.mustCall((req, res) => {
-  const listener = common.mustCall(() => {
-    assert.strictEqual(res.writable, true);
-  });
+const server = createServer(
+  common.mustCall((req, res) => {
+    const listener = common.mustCall(() => {
+      assert.strictEqual(res.writable, true);
+    });
 
-  // on CentOS 5, 'finish' is emitted
-  res.on('finish', listener);
-  // everywhere else, 'close' is emitted
-  res.on('close', listener);
+    // on CentOS 5, 'finish' is emitted
+    res.on('finish', listener);
+    // everywhere else, 'close' is emitted
+    res.on('close', listener);
 
-  get(`http://127.0.0.1:${internal.address().port}`, common.mustCall((inner) => {
-    inner.pipe(res);
-  }));
-})).listen(0, () => {
+    get(
+      `http://127.0.0.1:${internal.address().port}`,
+      common.mustCall((inner) => {
+        inner.pipe(res);
+      })
+    );
+  })
+).listen(0, () => {
   // Http server
   internal = createServer((req, res) => {
     res.writeHead(200);
-    setImmediate(common.mustCall(() => {
-      external.abort();
-      res.end('Hello World\n');
-    }));
+    setImmediate(
+      common.mustCall(() => {
+        external.abort();
+        res.end('Hello World\n');
+      })
+    );
   }).listen(0, () => {
     external = get(`http://127.0.0.1:${server.address().port}`);
-    external.on('error', common.mustCall(() => {
-      server.close();
-      internal.close();
-    }));
+    external.on(
+      'error',
+      common.mustCall(() => {
+        server.close();
+        internal.close();
+      })
+    );
   });
 });
diff --git a/test/parallel/test-http-write-callbacks.js b/test/parallel/test-http-write-callbacks.js
index 440807a2df7ca0..54120362d72f5e 100644
--- a/test/parallel/test-http-write-callbacks.js
+++ b/test/parallel/test-http-write-callbacks.js
@@ -75,7 +75,7 @@ server.listen(0, function() {
   const req = http.request({
     port: this.address().port,
     method: 'PUT',
-    headers: { 'expect': '100-continue' }
+    headers: { expect: '100-continue' }
   });
   req.on('continue', function() {
     // ok, good to go.
diff --git a/test/parallel/test-http-write-empty-string.js b/test/parallel/test-http-write-empty-string.js
index d4ab070667ef6d..9fcfd5ce1d5f85 100644
--- a/test/parallel/test-http-write-empty-string.js
+++ b/test/parallel/test-http-write-empty-string.js
@@ -38,17 +38,26 @@ const server = http.createServer(function(request, response) {
   this.close();
 });
 
-server.listen(0, common.mustCall(function() {
-  http.get({ port: this.address().port }, common.mustCall(function(res) {
-    let response = '';
+server.listen(
+  0,
+  common.mustCall(function() {
+    http.get(
+      { port: this.address().port },
+      common.mustCall(function(res) {
+        let response = '';
 
-    assert.strictEqual(res.statusCode, 200);
-    res.setEncoding('ascii');
-    res.on('data', function(chunk) {
-      response += chunk;
-    });
-    res.on('end', common.mustCall(function() {
-      assert.strictEqual(response, '1\n2\n3\n');
-    }));
-  }));
-}));
+        assert.strictEqual(res.statusCode, 200);
+        res.setEncoding('ascii');
+        res.on('data', function(chunk) {
+          response += chunk;
+        });
+        res.on(
+          'end',
+          common.mustCall(function() {
+            assert.strictEqual(response, '1\n2\n3\n');
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http-write-head.js b/test/parallel/test-http-write-head.js
index 83dfcfa20bdb1e..1327b2098ea7af 100644
--- a/test/parallel/test-http-write-head.js
+++ b/test/parallel/test-http-write-head.js
@@ -27,52 +27,57 @@ const http = require('http');
 // Verify that ServerResponse.writeHead() works as setHeader.
 // Issue 5036 on github.
 
-const s = http.createServer(common.mustCall((req, res) => {
-  res.setHeader('test', '1');
+const s = http.createServer(
+  common.mustCall((req, res) => {
+    res.setHeader('test', '1');
 
-  // toLowerCase() is used on the name argument, so it must be a string.
-  // Non-String header names should throw
-  common.expectsError(
-    () => res.setHeader(0xf00, 'bar'),
-    {
+    // toLowerCase() is used on the name argument, so it must be a string.
+    // Non-String header names should throw
+    common.expectsError(() => res.setHeader(0xf00, 'bar'), {
       code: 'ERR_INVALID_HTTP_TOKEN',
       type: TypeError,
       message: 'Header name must be a valid HTTP token ["3840"]'
-    }
-  );
+    });
 
-  // undefined value should throw, via 979d0ca8
-  common.expectsError(
-    () => res.setHeader('foo', undefined),
-    {
+    // undefined value should throw, via 979d0ca8
+    common.expectsError(() => res.setHeader('foo', undefined), {
       code: 'ERR_HTTP_INVALID_HEADER_VALUE',
       type: TypeError,
       message: 'Invalid value "undefined" for header "foo"'
-    }
-  );
+    });
 
-  res.writeHead(200, { Test: '2' });
+    res.writeHead(200, { Test: '2' });
 
-  common.expectsError(() => {
-    res.writeHead(100, {});
-  }, {
-    code: 'ERR_HTTP_HEADERS_SENT',
-    type: Error,
-    message: 'Cannot render headers after they are sent to the client'
-  });
+    common.expectsError(
+      () => {
+        res.writeHead(100, {});
+      },
+      {
+        code: 'ERR_HTTP_HEADERS_SENT',
+        type: Error,
+        message: 'Cannot render headers after they are sent to the client'
+      }
+    );
 
-  res.end();
-}));
+    res.end();
+  })
+);
 
 s.listen(0, common.mustCall(runTest));
 
 function runTest() {
-  http.get({ port: this.address().port }, common.mustCall((response) => {
-    response.on('end', common.mustCall(() => {
-      assert.strictEqual(response.headers.test, '2');
-      assert(response.rawHeaders.includes('Test'));
-      s.close();
-    }));
-    response.resume();
-  }));
+  http.get(
+    { port: this.address().port },
+    common.mustCall((response) => {
+      response.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(response.headers.test, '2');
+          assert(response.rawHeaders.includes('Test'));
+          s.close();
+        })
+      );
+      response.resume();
+    })
+  );
 }
diff --git a/test/parallel/test-http-zero-length-write.js b/test/parallel/test-http-zero-length-write.js
index 35a1b616d704f3..62fda66c8ca405 100644
--- a/test/parallel/test-http-zero-length-write.js
+++ b/test/parallel/test-http-zero-length-write.js
@@ -41,10 +41,9 @@ function getSrc() {
     paused = false;
   };
 
-  const chunks = [ '', 'asdf', '', 'foo', '', 'bar', '' ];
+  const chunks = ['', 'asdf', '', 'foo', '', 'bar', ''];
   const interval = setInterval(function() {
-    if (paused)
-      return;
+    if (paused) return;
 
     const chunk = chunks.shift();
     if (chunk !== undefined) {
@@ -58,7 +57,6 @@ function getSrc() {
   return src;
 }
 
-
 const expect = 'asdffoobar';
 
 const server = http.createServer(function(req, res) {
diff --git a/test/parallel/test-http-zerolengthbuffer.js b/test/parallel/test-http-zerolengthbuffer.js
index c59fc18108c2b9..bc0a13473928a5 100644
--- a/test/parallel/test-http-zerolengthbuffer.js
+++ b/test/parallel/test-http-zerolengthbuffer.js
@@ -6,18 +6,25 @@ const http = require('http');
 
 const server = http.createServer((req, res) => {
   const buffer = Buffer.alloc(0);
-  res.writeHead(200, { 'Content-Type': 'text/html',
-                       'Content-Length': buffer.length });
+  res.writeHead(200, {
+    'Content-Type': 'text/html',
+    'Content-Length': buffer.length
+  });
   res.end(buffer);
 });
 
-server.listen(0, common.mustCall(() => {
-  http.get({ port: server.address().port }, common.mustCall((res) => {
+server.listen(
+  0,
+  common.mustCall(() => {
+    http.get(
+      { port: server.address().port },
+      common.mustCall((res) => {
+        res.on('data', common.mustNotCall());
 
-    res.on('data', common.mustNotCall());
-
-    res.on('end', (d) => {
-      server.close();
-    });
-  }));
-}));
+        res.on('end', (d) => {
+          server.close();
+        });
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http.js b/test/parallel/test-http.js
index e9a48c0fba3826..de771934676c39 100644
--- a/test/parallel/test-http.js
+++ b/test/parallel/test-http.js
@@ -27,108 +27,145 @@ const url = require('url');
 
 const expectedRequests = ['/hello', '/there', '/world'];
 
-const server = http.Server(common.mustCall(function(req, res) {
-  assert.strictEqual(expectedRequests.shift(), req.url);
+const server = http.Server(
+  common.mustCall(function(req, res) {
+    assert.strictEqual(expectedRequests.shift(), req.url);
 
-  switch (req.url) {
-    case '/hello':
-      assert.strictEqual(req.method, 'GET');
-      assert.strictEqual(req.headers.accept, '*/*');
-      assert.strictEqual(req.headers.foo, 'bar');
-      assert.strictEqual(req.headers.cookie, 'foo=bar; bar=baz; baz=quux');
-      break;
-    case '/there':
-      assert.strictEqual(req.method, 'PUT');
-      assert.strictEqual(req.headers.cookie, 'node=awesome; ta=da');
-      break;
-    case '/world':
-      assert.strictEqual(req.method, 'POST');
-      assert.deepStrictEqual(req.headers.cookie, 'abc=123; def=456; ghi=789');
-      break;
-    default:
-      assert(false, `Unexpected request for ${req.url}`);
-  }
+    switch (req.url) {
+      case '/hello':
+        assert.strictEqual(req.method, 'GET');
+        assert.strictEqual(req.headers.accept, '*/*');
+        assert.strictEqual(req.headers.foo, 'bar');
+        assert.strictEqual(req.headers.cookie, 'foo=bar; bar=baz; baz=quux');
+        break;
+      case '/there':
+        assert.strictEqual(req.method, 'PUT');
+        assert.strictEqual(req.headers.cookie, 'node=awesome; ta=da');
+        break;
+      case '/world':
+        assert.strictEqual(req.method, 'POST');
+        assert.deepStrictEqual(req.headers.cookie, 'abc=123; def=456; ghi=789');
+        break;
+      default:
+        assert(false, `Unexpected request for ${req.url}`);
+    }
 
-  if (expectedRequests.length === 0)
-    this.close();
+    if (expectedRequests.length === 0) this.close();
 
-  req.on('end', function() {
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write(`The path was ${url.parse(req.url).pathname}`);
-    res.end();
-  });
-  req.resume();
-}, 3));
+    req.on('end', function() {
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.write(`The path was ${url.parse(req.url).pathname}`);
+      res.end();
+    });
+    req.resume();
+  }, 3)
+);
 server.listen(0);
 
 server.on('listening', function() {
   const agent = new http.Agent({ port: this.address().port, maxSockets: 1 });
-  const req = http.get({
-    port: this.address().port,
-    path: '/hello',
-    headers: {
-      Accept: '*/*',
-      Foo: 'bar',
-      Cookie: [ 'foo=bar', 'bar=baz', 'baz=quux' ]
-    },
-    agent: agent
-  }, common.mustCall((res) => {
-    const cookieHeaders = req._header.match(/^Cookie: .+$/img);
-    assert.deepStrictEqual(cookieHeaders,
-                           ['Cookie: foo=bar; bar=baz; baz=quux']);
-    assert.strictEqual(res.statusCode, 200);
-    let body = '';
-    res.setEncoding('utf8');
-    res.on('data', (chunk) => { body += chunk; });
-    res.on('end', common.mustCall(() => {
-      assert.strictEqual(body, 'The path was /hello');
-    }));
-  }));
-
-  setTimeout(common.mustCall(() => {
-    const req = http.request({
-      port: server.address().port,
-      method: 'PUT',
-      path: '/there',
+  const req = http.get(
+    {
+      port: this.address().port,
+      path: '/hello',
+      headers: {
+        Accept: '*/*',
+        Foo: 'bar',
+        Cookie: ['foo=bar', 'bar=baz', 'baz=quux']
+      },
       agent: agent
-    }, common.mustCall((res) => {
-      const cookieHeaders = req._header.match(/^Cookie: .+$/img);
-      assert.deepStrictEqual(cookieHeaders, ['Cookie: node=awesome; ta=da']);
+    },
+    common.mustCall((res) => {
+      const cookieHeaders = req._header.match(/^Cookie: .+$/gim);
+      assert.deepStrictEqual(cookieHeaders, [
+        'Cookie: foo=bar; bar=baz; baz=quux'
+      ]);
       assert.strictEqual(res.statusCode, 200);
       let body = '';
       res.setEncoding('utf8');
-      res.on('data', (chunk) => { body += chunk; });
-      res.on('end', common.mustCall(() => {
-        assert.strictEqual(body, 'The path was /there');
-      }));
-    }));
-    req.setHeader('Cookie', ['node=awesome', 'ta=da']);
-    req.end();
-  }), 1);
+      res.on('data', (chunk) => {
+        body += chunk;
+      });
+      res.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(body, 'The path was /hello');
+        })
+      );
+    })
+  );
 
-  setTimeout(common.mustCall(() => {
-    const req = http.request({
-      port: server.address().port,
-      method: 'POST',
-      path: '/world',
-      headers: [ ['Cookie', 'abc=123'],
-                 ['Cookie', 'def=456'],
-                 ['Cookie', 'ghi=789'] ],
-      agent: agent
-    }, common.mustCall((res) => {
-      const cookieHeaders = req._header.match(/^Cookie: .+$/img);
-      assert.deepStrictEqual(cookieHeaders,
-                             ['Cookie: abc=123',
-                              'Cookie: def=456',
-                              'Cookie: ghi=789']);
-      assert.strictEqual(res.statusCode, 200);
-      let body = '';
-      res.setEncoding('utf8');
-      res.on('data', (chunk) => { body += chunk; });
-      res.on('end', common.mustCall(() => {
-        assert.strictEqual(body, 'The path was /world');
-      }));
-    }));
-    req.end();
-  }), 2);
+  setTimeout(
+    common.mustCall(() => {
+      const req = http.request(
+        {
+          port: server.address().port,
+          method: 'PUT',
+          path: '/there',
+          agent: agent
+        },
+        common.mustCall((res) => {
+          const cookieHeaders = req._header.match(/^Cookie: .+$/gim);
+          assert.deepStrictEqual(cookieHeaders, [
+            'Cookie: node=awesome; ta=da'
+          ]);
+          assert.strictEqual(res.statusCode, 200);
+          let body = '';
+          res.setEncoding('utf8');
+          res.on('data', (chunk) => {
+            body += chunk;
+          });
+          res.on(
+            'end',
+            common.mustCall(() => {
+              assert.strictEqual(body, 'The path was /there');
+            })
+          );
+        })
+      );
+      req.setHeader('Cookie', ['node=awesome', 'ta=da']);
+      req.end();
+    }),
+    1
+  );
+
+  setTimeout(
+    common.mustCall(() => {
+      const req = http.request(
+        {
+          port: server.address().port,
+          method: 'POST',
+          path: '/world',
+          headers: [
+            ['Cookie', 'abc=123'],
+            ['Cookie', 'def=456'],
+            ['Cookie', 'ghi=789']
+          ],
+          agent: agent
+        },
+        common.mustCall((res) => {
+          const cookieHeaders = req._header.match(/^Cookie: .+$/gim);
+          assert.deepStrictEqual(cookieHeaders, [
+            'Cookie: abc=123',
+            'Cookie: def=456',
+            'Cookie: ghi=789'
+          ]);
+          assert.strictEqual(res.statusCode, 200);
+          let body = '';
+          res.setEncoding('utf8');
+          res.on('data', (chunk) => {
+            body += chunk;
+          });
+          res.on(
+            'end',
+            common.mustCall(() => {
+              assert.strictEqual(body, 'The path was /world');
+            })
+          );
+        })
+      );
+      req.end();
+    }),
+    2
+  );
 });
diff --git a/test/parallel/test-http2-altsvc.js b/test/parallel/test-http2-altsvc.js
index d4216e973df3ca..4696110c95e79a 100644
--- a/test/parallel/test-http2-altsvc.js
+++ b/test/parallel/test-http2-altsvc.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http2 = require('http2');
@@ -10,122 +9,119 @@ const { URL } = require('url');
 const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.session.altsvc('h2=":8000"', stream.id);
-  stream.respond();
-  stream.end('ok');
-}));
-server.on('session', common.mustCall((session) => {
-  // Origin may be specified by string, URL object, or object with an
-  // origin property. For string and URL object, origin is guaranteed
-  // to be an ASCII serialized origin. For object with an origin
-  // property, it is up to the user to ensure proper serialization.
-  session.altsvc('h2=":8000"', 'https://example.org:8111/this');
-  session.altsvc('h2=":8000"', new URL('https://example.org:8111/this'));
-  session.altsvc('h2=":8000"', { origin: 'https://example.org:8111' });
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.session.altsvc('h2=":8000"', stream.id);
+    stream.respond();
+    stream.end('ok');
+  })
+);
+server.on(
+  'session',
+  common.mustCall((session) => {
+    // Origin may be specified by string, URL object, or object with an
+    // origin property. For string and URL object, origin is guaranteed
+    // to be an ASCII serialized origin. For object with an origin
+    // property, it is up to the user to ensure proper serialization.
+    session.altsvc('h2=":8000"', 'https://example.org:8111/this');
+    session.altsvc('h2=":8000"', new URL('https://example.org:8111/this'));
+    session.altsvc('h2=":8000"', { origin: 'https://example.org:8111' });
 
-  // Won't error, but won't send anything because the stream does not exist
-  session.altsvc('h2=":8000"', 3);
+    // Won't error, but won't send anything because the stream does not exist
+    session.altsvc('h2=":8000"', 3);
 
-  // Will error because the numeric stream id is out of valid range
-  [0, -1, 1.1, 0xFFFFFFFF + 1, Infinity, -Infinity].forEach((input) => {
-    assert.throws(
-      () => session.altsvc('h2=":8000"', input),
-      {
+    // Will error because the numeric stream id is out of valid range
+    [0, -1, 1.1, 0xffffffff + 1, Infinity, -Infinity].forEach((input) => {
+      assert.throws(() => session.altsvc('h2=":8000"', input), {
         code: 'ERR_OUT_OF_RANGE',
         name: 'RangeError [ERR_OUT_OF_RANGE]',
-        message: 'The value of "originOrStream" is out of ' +
-                 `range. It must be > 0 && < 4294967296. Received ${input}`
-      }
-    );
-  });
+        message:
+          'The value of "originOrStream" is out of ' +
+          `range. It must be > 0 && < 4294967296. Received ${input}`
+      });
+    });
 
-  // First argument must be a string
-  [0, {}, [], null, Infinity].forEach((input) => {
-    assert.throws(
-      () => session.altsvc(input),
-      {
+    // First argument must be a string
+    [0, {}, [], null, Infinity].forEach((input) => {
+      assert.throws(() => session.altsvc(input), {
         code: 'ERR_INVALID_ARG_TYPE',
         name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-      }
-    );
-  });
+      });
+    });
 
-  ['\u0001', 'h2="\uff20"', '👀'].forEach((input) => {
-    assert.throws(
-      () => session.altsvc(input),
-      {
+    ['\u0001', 'h2="\uff20"', '👀'].forEach((input) => {
+      assert.throws(() => session.altsvc(input), {
         code: 'ERR_INVALID_CHAR',
         name: 'TypeError [ERR_INVALID_CHAR]',
         message: 'Invalid character in alt'
-      }
-    );
-  });
+      });
+    });
 
-  [{}, [], true].forEach((input) => {
-    assert.throws(
-      () => session.altsvc('clear', input),
-      {
+    [{}, [], true].forEach((input) => {
+      assert.throws(() => session.altsvc('clear', input), {
         code: 'ERR_INVALID_ARG_TYPE',
         name: 'TypeError [ERR_INVALID_ARG_TYPE]'
+      });
+    });
+
+    ['abc:', new URL('abc:'), { origin: 'null' }, { origin: '' }].forEach(
+      (input) => {
+        assert.throws(() => session.altsvc('h2=":8000', input), {
+          code: 'ERR_HTTP2_ALTSVC_INVALID_ORIGIN',
+          name: 'TypeError [ERR_HTTP2_ALTSVC_INVALID_ORIGIN]',
+          message: 'HTTP/2 ALTSVC frames require a valid origin'
+        });
       }
     );
-  });
 
-  [
-    'abc:',
-    new URL('abc:'),
-    { origin: 'null' },
-    { origin: '' }
-  ].forEach((input) => {
+    // arguments + origin are too long for an ALTSVC frame
     assert.throws(
-      () => session.altsvc('h2=":8000', input),
+      () => {
+        session.altsvc(
+          'h2=":8000"',
+          `http://example.${'a'.repeat(17000)}.org:8000`
+        );
+      },
       {
-        code: 'ERR_HTTP2_ALTSVC_INVALID_ORIGIN',
-        name: 'TypeError [ERR_HTTP2_ALTSVC_INVALID_ORIGIN]',
-        message: 'HTTP/2 ALTSVC frames require a valid origin'
+        code: 'ERR_HTTP2_ALTSVC_LENGTH',
+        name: 'TypeError [ERR_HTTP2_ALTSVC_LENGTH]',
+        message: 'HTTP/2 ALTSVC frames are limited to 16382 bytes'
       }
     );
-  });
+  })
+);
 
-  // arguments + origin are too long for an ALTSVC frame
-  assert.throws(
-    () => {
-      session.altsvc('h2=":8000"',
-                     `http://example.${'a'.repeat(17000)}.org:8000`);
-    },
-    {
-      code: 'ERR_HTTP2_ALTSVC_LENGTH',
-      name: 'TypeError [ERR_HTTP2_ALTSVC_LENGTH]',
-      message: 'HTTP/2 ALTSVC frames are limited to 16382 bytes'
-    }
-  );
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+    const countdown = new Countdown(4, () => {
+      client.close();
+      server.close();
+    });
 
-  const countdown = new Countdown(4, () => {
-    client.close();
-    server.close();
-  });
-
-  client.on('altsvc', common.mustCall((alt, origin, stream) => {
-    assert.strictEqual(alt, 'h2=":8000"');
-    switch (stream) {
-      case 0:
-        assert.strictEqual(origin, 'https://example.org:8111');
-        break;
-      case 1:
-        assert.strictEqual(origin, '');
-        break;
-      default:
-        assert.fail('should not happen');
-    }
-    countdown.dec();
-  }, 4));
+    client.on(
+      'altsvc',
+      common.mustCall((alt, origin, stream) => {
+        assert.strictEqual(alt, 'h2=":8000"');
+        switch (stream) {
+          case 0:
+            assert.strictEqual(origin, 'https://example.org:8111');
+            break;
+          case 1:
+            assert.strictEqual(origin, '');
+            break;
+          default:
+            assert.fail('should not happen');
+        }
+        countdown.dec();
+      }, 4)
+    );
 
-  const req = client.request();
-  req.resume();
-  req.on('close', common.mustCall());
-}));
+    const req = client.request();
+    req.resume();
+    req.on('close', common.mustCall());
+  })
+);
diff --git a/test/parallel/test-http2-backpressure.js b/test/parallel/test-http2-backpressure.js
index 1f9687831eb1a8..9ecb65208df798 100644
--- a/test/parallel/test-http2-backpressure.js
+++ b/test/parallel/test-http2-backpressure.js
@@ -3,8 +3,7 @@
 // Verifies that a full HTTP2 pipeline handles backpressure.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const makeDuplexPair = require('../common/duplexpair');
@@ -12,28 +11,34 @@ const makeDuplexPair = require('../common/duplexpair');
 {
   let req;
   const server = http2.createServer();
-  server.on('stream', mustCallAsync(async (stream, headers) => {
-    stream.respond({
-      'content-type': 'text/html',
-      ':status': 200
-    });
-    req._readableState.highWaterMark = 20;
-    stream._writableState.highWaterMark = 20;
-    assert.strictEqual(stream.write('A'.repeat(5)), true);
-    assert.strictEqual(stream.write('A'.repeat(40)), false);
-    assert.strictEqual(await event(req, 'data'), 'A'.repeat(5));
-    assert.strictEqual(await event(req, 'data'), 'A'.repeat(40));
-    await event(stream, 'drain');
-    assert.strictEqual(stream.write('A'.repeat(5)), true);
-    assert.strictEqual(stream.write('A'.repeat(40)), false);
-  }));
+  server.on(
+    'stream',
+    mustCallAsync(async (stream, headers) => {
+      stream.respond({
+        'content-type': 'text/html',
+        ':status': 200
+      });
+      req._readableState.highWaterMark = 20;
+      stream._writableState.highWaterMark = 20;
+      assert.strictEqual(stream.write('A'.repeat(5)), true);
+      assert.strictEqual(stream.write('A'.repeat(40)), false);
+      assert.strictEqual(await event(req, 'data'), 'A'.repeat(5));
+      assert.strictEqual(await event(req, 'data'), 'A'.repeat(40));
+      await event(stream, 'drain');
+      assert.strictEqual(stream.write('A'.repeat(5)), true);
+      assert.strictEqual(stream.write('A'.repeat(40)), false);
+    })
+  );
 
   const { clientSide, serverSide } = makeDuplexPair();
   server.emit('connection', serverSide);
 
-  const client = http2.connect('http://localhost:80', {
-    createConnection: common.mustCall(() => clientSide)
-  });
+  const client = http2.connect(
+    'http://localhost:80',
+    {
+      createConnection: common.mustCall(() => clientSide)
+    }
+  );
 
   req = client.request({ ':path': '/' });
   req.setEncoding('utf8');
diff --git a/test/parallel/test-http2-binding.js b/test/parallel/test-http2-binding.js
index 6991f98afd72d1..f04ea13b49ca36 100644
--- a/test/parallel/test-http2-binding.js
+++ b/test/parallel/test-http2-binding.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const { internalBinding } = require('internal/test/binding');
 
@@ -19,8 +18,10 @@ assert.strictEqual(settings.enablePush, true);
 assert.strictEqual(settings.initialWindowSize, 65535);
 assert.strictEqual(settings.maxFrameSize, 16384);
 
-assert.strictEqual(binding.nghttp2ErrorString(-517),
-                   'GOAWAY has already been sent');
+assert.strictEqual(
+  binding.nghttp2ErrorString(-517),
+  'GOAWAY has already been sent'
+);
 
 // assert constants are present
 assert(binding.constants);
@@ -106,7 +107,8 @@ const expectedHeaderNames = {
   HTTP2_HEADER_ACCEPT_LANGUAGE: 'accept-language',
   HTTP2_HEADER_ACCEPT_RANGES: 'accept-ranges',
   HTTP2_HEADER_ACCEPT: 'accept',
-  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS: 'access-control-allow-credentials', // eslint-disable-line max-len
+  HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS:
+    'access-control-allow-credentials', // eslint-disable-line max-len
   HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS: 'access-control-allow-headers',
   HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS: 'access-control-allow-methods',
   HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN: 'access-control-allow-origin',
@@ -233,16 +235,28 @@ const defaultSettings = {
 
 for (const name of Object.keys(constants)) {
   if (name.startsWith('HTTP_STATUS_')) {
-    assert.strictEqual(expectedStatusCodes[name], constants[name],
-                       `Expected status code match for ${name}`);
+    assert.strictEqual(
+      expectedStatusCodes[name],
+      constants[name],
+      `Expected status code match for ${name}`
+    );
   } else if (name.startsWith('HTTP2_HEADER_')) {
-    assert.strictEqual(expectedHeaderNames[name], constants[name],
-                       `Expected header name match for ${name}`);
+    assert.strictEqual(
+      expectedHeaderNames[name],
+      constants[name],
+      `Expected header name match for ${name}`
+    );
   } else if (name.startsWith('NGHTTP2_')) {
-    assert.strictEqual(expectedNGConstants[name], constants[name],
-                       `Expected ng constant match for ${name}`);
+    assert.strictEqual(
+      expectedNGConstants[name],
+      constants[name],
+      `Expected ng constant match for ${name}`
+    );
   } else if (name.startsWith('DEFAULT_SETTINGS_')) {
-    assert.strictEqual(defaultSettings[name], constants[name],
-                       `Expected default setting match for ${name}`);
+    assert.strictEqual(
+      defaultSettings[name],
+      constants[name],
+      `Expected default setting match for ${name}`
+    );
   }
 }
diff --git a/test/parallel/test-http2-buffersize.js b/test/parallel/test-http2-buffersize.js
index be56d8ce3d9344..cf24cd78760b0d 100644
--- a/test/parallel/test-http2-buffersize.js
+++ b/test/parallel/test-http2-buffersize.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const { mustCall, hasCrypto, skip } = require('../common');
-if (!hasCrypto)
-  skip('missing crypto');
+if (!hasCrypto) skip('missing crypto');
 const assert = require('assert');
 const { createServer, connect } = require('http2');
 const Countdown = require('../common/countdown');
@@ -17,35 +16,44 @@ const Countdown = require('../common/countdown');
 
   // Other `bufferSize` tests for net module and tls module
   // don't assert `bufferSize` of server-side sockets.
-  server.on('stream', mustCall((stream) => {
-    stream.on('data', mustCall());
-    stream.on('end', mustCall());
-  }, SOCKETS));
+  server.on(
+    'stream',
+    mustCall((stream) => {
+      stream.on('data', mustCall());
+      stream.on('end', mustCall());
+    }, SOCKETS)
+  );
 
-  server.listen(0, mustCall(() => {
-    const authority = `http://localhost:${server.address().port}`;
-    const client = connect(authority);
-    const countdown = new Countdown(SOCKETS, () => {
-      client.close();
-      server.close();
-    });
+  server.listen(
+    0,
+    mustCall(() => {
+      const authority = `http://localhost:${server.address().port}`;
+      const client = connect(authority);
+      const countdown = new Countdown(SOCKETS, () => {
+        client.close();
+        server.close();
+      });
 
-    client.once('connect', mustCall());
+      client.once('connect', mustCall());
 
-    for (let j = 0; j < SOCKETS; j += 1) {
-      const stream = client.request({ ':method': 'POST' });
-      stream.on('data', () => {});
-      stream.on('close', mustCall(() => {
-        countdown.dec();
-      }));
+      for (let j = 0; j < SOCKETS; j += 1) {
+        const stream = client.request({ ':method': 'POST' });
+        stream.on('data', () => {});
+        stream.on(
+          'close',
+          mustCall(() => {
+            countdown.dec();
+          })
+        );
 
-      for (let i = 0; i < TIMES; i += 1) {
-        stream.write(Buffer.allocUnsafe(BUFFER_SIZE), mustCall());
-        const expectedSocketBufferSize = BUFFER_SIZE * (i + 1);
-        assert.strictEqual(stream.bufferSize, expectedSocketBufferSize);
+        for (let i = 0; i < TIMES; i += 1) {
+          stream.write(Buffer.allocUnsafe(BUFFER_SIZE), mustCall());
+          const expectedSocketBufferSize = BUFFER_SIZE * (i + 1);
+          assert.strictEqual(stream.bufferSize, expectedSocketBufferSize);
+        }
+        stream.end();
+        stream.close();
       }
-      stream.end();
-      stream.close();
-    }
-  }));
+    })
+  );
 }
diff --git a/test/parallel/test-http2-client-data-end.js b/test/parallel/test-http2-client-data-end.js
index 2f251692d5c412..7fa9339ac00e5c 100644
--- a/test/parallel/test-http2-client-data-end.js
+++ b/test/parallel/test-http2-client-data-end.js
@@ -1,72 +1,91 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers, flags) => {
-  if (headers[':path'] === '/') {
-    stream.pushStream({ ':path': '/foobar' }, (err, push, headers) => {
-      assert.ifError(err);
-      push.respond({
-        'content-type': 'text/html',
-        'x-push-data': 'pushed by server',
+server.on(
+  'stream',
+  common.mustCall((stream, headers, flags) => {
+    if (headers[':path'] === '/') {
+      stream.pushStream({ ':path': '/foobar' }, (err, push, headers) => {
+        assert.ifError(err);
+        push.respond({
+          'content-type': 'text/html',
+          'x-push-data': 'pushed by server'
+        });
+        push.write('pushed by server ');
+        setImmediate(() => push.end('data'));
+        stream.end('st');
       });
-      push.write('pushed by server ');
-      setImmediate(() => push.end('data'));
-      stream.end('st');
-    });
-  }
-  stream.respond({ 'content-type': 'text/html' });
-  stream.write('te');
-}));
-
+    }
+    stream.respond({ 'content-type': 'text/html' });
+    stream.write('te');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
 
-  const req = client.request();
+    const req = client.request();
 
-  const countdown = new Countdown(2, () => {
-    server.close();
-    client.close();
-  });
+    const countdown = new Countdown(2, () => {
+      server.close();
+      client.close();
+    });
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 200);
-    assert.strictEqual(headers['content-type'], 'text/html');
-  }));
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers[':status'], 200);
+        assert.strictEqual(headers['content-type'], 'text/html');
+      })
+    );
 
-  client.on('stream', common.mustCall((stream, headers, flags) => {
-    assert.strictEqual(headers[':scheme'], 'http');
-    assert.strictEqual(headers[':path'], '/foobar');
-    assert.strictEqual(headers[':authority'], `localhost:${port}`);
-    stream.on('push', common.mustCall((headers, flags) => {
-      assert.strictEqual(headers[':status'], 200);
-      assert.strictEqual(headers['content-type'], 'text/html');
-      assert.strictEqual(headers['x-push-data'], 'pushed by server');
-    }));
+    client.on(
+      'stream',
+      common.mustCall((stream, headers, flags) => {
+        assert.strictEqual(headers[':scheme'], 'http');
+        assert.strictEqual(headers[':path'], '/foobar');
+        assert.strictEqual(headers[':authority'], `localhost:${port}`);
+        stream.on(
+          'push',
+          common.mustCall((headers, flags) => {
+            assert.strictEqual(headers[':status'], 200);
+            assert.strictEqual(headers['content-type'], 'text/html');
+            assert.strictEqual(headers['x-push-data'], 'pushed by server');
+          })
+        );
 
-    stream.setEncoding('utf8');
-    let pushData = '';
-    stream.on('data', (d) => pushData += d);
-    stream.on('end', common.mustCall(() => {
-      assert.strictEqual(pushData, 'pushed by server data');
-    }));
-    stream.on('close', () => countdown.dec());
-  }));
+        stream.setEncoding('utf8');
+        let pushData = '';
+        stream.on('data', (d) => (pushData += d));
+        stream.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(pushData, 'pushed by server data');
+          })
+        );
+        stream.on('close', () => countdown.dec());
+      })
+    );
 
-  let data = '';
+    let data = '';
 
-  req.setEncoding('utf8');
-  req.on('data', common.mustCallAtLeast((d) => data += d));
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(data, 'test');
-  }));
-  req.on('close', () => countdown.dec());
-}));
+    req.setEncoding('utf8');
+    req.on('data', common.mustCallAtLeast((d) => (data += d)));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(data, 'test');
+      })
+    );
+    req.on('close', () => countdown.dec());
+  })
+);
diff --git a/test/parallel/test-http2-client-destroy.js b/test/parallel/test-http2-client-destroy.js
index 43fc6819e21f7a..8225c4d8294321 100644
--- a/test/parallel/test-http2-client-destroy.js
+++ b/test/parallel/test-http2-client-destroy.js
@@ -3,8 +3,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const { kSocket } = require('internal/http2/util');
@@ -12,112 +11,136 @@ const Countdown = require('../common/countdown');
 
 {
   const server = h2.createServer();
-  server.listen(0, common.mustCall(() => {
-    const destroyCallbacks = [
-      (client) => client.destroy(),
-      (client) => client[kSocket].destroy()
-    ];
-
-    const countdown = new Countdown(destroyCallbacks.length, () => {
-      server.close();
-    });
-
-    destroyCallbacks.forEach((destroyCallback) => {
-      const client = h2.connect(`http://localhost:${server.address().port}`);
-      client.on('connect', common.mustCall(() => {
-        const socket = client[kSocket];
-
-        assert(socket, 'client session has associated socket');
-        assert(
-          !client.destroyed,
-          'client has not been destroyed before destroy is called'
-        );
-        assert(
-          !socket.destroyed,
-          'socket has not been destroyed before destroy is called'
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const destroyCallbacks = [
+        (client) => client.destroy(),
+        (client) => client[kSocket].destroy()
+      ];
+
+      const countdown = new Countdown(destroyCallbacks.length, () => {
+        server.close();
+      });
+
+      destroyCallbacks.forEach((destroyCallback) => {
+        const client = h2.connect(`http://localhost:${server.address().port}`);
+        client.on(
+          'connect',
+          common.mustCall(() => {
+            const socket = client[kSocket];
+
+            assert(socket, 'client session has associated socket');
+            assert(
+              !client.destroyed,
+              'client has not been destroyed before destroy is called'
+            );
+            assert(
+              !socket.destroyed,
+              'socket has not been destroyed before destroy is called'
+            );
+
+            destroyCallback(client);
+
+            client.on(
+              'close',
+              common.mustCall(() => {
+                assert(client.destroyed);
+              })
+            );
+
+            countdown.dec();
+          })
         );
-
-        destroyCallback(client);
-
-        client.on('close', common.mustCall(() => {
-          assert(client.destroyed);
-        }));
-
-        countdown.dec();
-      }));
-    });
-  }));
+      });
+    })
+  );
 }
 
 // test destroy before client operations
 {
   const server = h2.createServer();
-  server.listen(0, common.mustCall(() => {
-    const client = h2.connect(`http://localhost:${server.address().port}`);
-    const socket = client[kSocket];
-    socket.on('close', common.mustCall(() => {
-      assert(socket.destroyed);
-    }));
-
-    const req = client.request();
-    req.on('error', common.expectsError({
-      code: 'ERR_HTTP2_STREAM_CANCEL',
-      type: Error,
-      message: 'The pending stream has been canceled'
-    }));
-
-    client.destroy();
-
-    req.on('response', common.mustNotCall());
-
-    const sessionError = {
-      type: Error,
-      code: 'ERR_HTTP2_INVALID_SESSION',
-      message: 'The session has been destroyed'
-    };
-
-    common.expectsError(() => client.setNextStreamID(), sessionError);
-    common.expectsError(() => client.ping(), sessionError);
-    common.expectsError(() => client.settings({}), sessionError);
-    common.expectsError(() => client.goaway(), sessionError);
-    common.expectsError(() => client.request(), sessionError);
-    client.close();  // should be a non-op at this point
-
-    // Wait for setImmediate call from destroy() to complete
-    // so that state.destroyed is set to true
-    setImmediate(() => {
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const client = h2.connect(`http://localhost:${server.address().port}`);
+      const socket = client[kSocket];
+      socket.on(
+        'close',
+        common.mustCall(() => {
+          assert(socket.destroyed);
+        })
+      );
+
+      const req = client.request();
+      req.on(
+        'error',
+        common.expectsError({
+          code: 'ERR_HTTP2_STREAM_CANCEL',
+          type: Error,
+          message: 'The pending stream has been canceled'
+        })
+      );
+
+      client.destroy();
+
+      req.on('response', common.mustNotCall());
+
+      const sessionError = {
+        type: Error,
+        code: 'ERR_HTTP2_INVALID_SESSION',
+        message: 'The session has been destroyed'
+      };
+
       common.expectsError(() => client.setNextStreamID(), sessionError);
       common.expectsError(() => client.ping(), sessionError);
       common.expectsError(() => client.settings({}), sessionError);
       common.expectsError(() => client.goaway(), sessionError);
       common.expectsError(() => client.request(), sessionError);
-      client.close();  // should be a non-op at this point
-    });
-
-    req.resume();
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(() => server.close()));
-  }));
+      client.close(); // should be a non-op at this point
+
+      // Wait for setImmediate call from destroy() to complete
+      // so that state.destroyed is set to true
+      setImmediate(() => {
+        common.expectsError(() => client.setNextStreamID(), sessionError);
+        common.expectsError(() => client.ping(), sessionError);
+        common.expectsError(() => client.settings({}), sessionError);
+        common.expectsError(() => client.goaway(), sessionError);
+        common.expectsError(() => client.request(), sessionError);
+        client.close(); // should be a non-op at this point
+      });
+
+      req.resume();
+      req.on('end', common.mustCall());
+      req.on('close', common.mustCall(() => server.close()));
+    })
+  );
 }
 
 // test destroy before goaway
 {
   const server = h2.createServer();
-  server.on('stream', common.mustCall((stream) => {
-    stream.session.destroy();
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    const client = h2.connect(`http://localhost:${server.address().port}`);
+  server.on(
+    'stream',
+    common.mustCall((stream) => {
+      stream.session.destroy();
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const client = h2.connect(`http://localhost:${server.address().port}`);
 
-    client.on('close', () => {
-      server.close();
-      // calling destroy in here should not matter
-      client.destroy();
-    });
+      client.on('close', () => {
+        server.close();
+        // calling destroy in here should not matter
+        client.destroy();
+      });
 
-    client.request();
-  }));
+      client.request();
+    })
+  );
 }
 
 // test destroy before connect
@@ -125,15 +148,21 @@ const Countdown = require('../common/countdown');
   const server = h2.createServer();
   server.on('stream', common.mustNotCall());
 
-  server.listen(0, common.mustCall(() => {
-    const client = h2.connect(`http://localhost:${server.address().port}`);
-
-    server.on('connection', common.mustCall(() => {
-      server.close();
-      client.close();
-    }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const client = h2.connect(`http://localhost:${server.address().port}`);
 
-    const req = client.request();
-    req.destroy();
-  }));
+      server.on(
+        'connection',
+        common.mustCall(() => {
+          server.close();
+          client.close();
+        })
+      );
+
+      const req = client.request();
+      req.destroy();
+    })
+  );
 }
diff --git a/test/parallel/test-http2-client-http1-server.js b/test/parallel/test-http2-client-http1-server.js
index c7535adcef2381..d2340d8a5eaf83 100644
--- a/test/parallel/test-http2-client-http1-server.js
+++ b/test/parallel/test-http2-client-http1-server.js
@@ -2,8 +2,7 @@
 // Flags: --expose-internals
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http = require('http');
 const http2 = require('http2');
@@ -12,24 +11,33 @@ const { NghttpError } = require('internal/http2/util');
 // Creating an http1 server here...
 const server = http.createServer(common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-
-  const req = client.request();
-  req.on('close', common.mustCall());
-
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_ERROR',
-    type: NghttpError,
-    message: 'Protocol error'
-  }));
-
-  client.on('error', common.expectsError({
-    code: 'ERR_HTTP2_ERROR',
-    type: NghttpError,
-    name: 'Error [ERR_HTTP2_ERROR]',
-    message: 'Protocol error'
-  }));
-
-  client.on('close', common.mustCall(() => server.close()));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    const req = client.request();
+    req.on('close', common.mustCall());
+
+    req.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_ERROR',
+        type: NghttpError,
+        message: 'Protocol error'
+      })
+    );
+
+    client.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_ERROR',
+        type: NghttpError,
+        name: 'Error [ERR_HTTP2_ERROR]',
+        message: 'Protocol error'
+      })
+    );
+
+    client.on('close', common.mustCall(() => server.close()));
+  })
+);
diff --git a/test/parallel/test-http2-client-onconnect-errors.js b/test/parallel/test-http2-client-onconnect-errors.js
index e72b5f454ba650..76299698f7120d 100644
--- a/test/parallel/test-http2-client-onconnect-errors.js
+++ b/test/parallel/test-http2-client-onconnect-errors.js
@@ -2,15 +2,12 @@
 // Flags: --expose-internals
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const { internalBinding } = require('internal/test/binding');
-const {
-  constants,
-  Http2Session,
-  nghttp2ErrorString
-} = internalBinding('http2');
+const { constants, Http2Session, nghttp2ErrorString } = internalBinding(
+  'http2'
+);
 const http2 = require('http2');
 const { NghttpError } = require('internal/http2/util');
 
@@ -30,8 +27,9 @@ const specificTests = [
     error: {
       code: 'ERR_HTTP2_OUT_OF_STREAMS',
       type: Error,
-      message: 'No stream ID is available because ' +
-               'maximum stream ID has been reached'
+      message:
+        'No stream ID is available because ' +
+        'maximum stream ID has been reached'
     },
     type: 'stream'
   },
@@ -43,13 +41,14 @@ const specificTests = [
       message: 'A stream cannot depend on itself'
     },
     type: 'stream'
-  },
+  }
 ];
 
 const genericTests = Object.getOwnPropertyNames(constants)
-  .filter((key) => (
-    key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
-  ))
+  .filter(
+    (key) =>
+      key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
+  )
   .map((key) => ({
     ngError: constants[key],
     error: {
@@ -103,13 +102,16 @@ function runTest(test) {
   }
 
   req.on('end', common.mustCall());
-  req.on('close', common.mustCall(() => {
-    client.destroy();
-
-    if (!tests.length) {
-      server.close();
-    } else {
-      runTest(tests.shift());
-    }
-  }));
+  req.on(
+    'close',
+    common.mustCall(() => {
+      client.destroy();
+
+      if (!tests.length) {
+        server.close();
+      } else {
+        runTest(tests.shift());
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-http2-client-port-80.js b/test/parallel/test-http2-client-port-80.js
index fc82e231f6af8f..2a123f622c99ff 100644
--- a/test/parallel/test-http2-client-port-80.js
+++ b/test/parallel/test-http2-client-port-80.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const net = require('net');
diff --git a/test/parallel/test-http2-client-priority-before-connect.js b/test/parallel/test-http2-client-priority-before-connect.js
index a9615d2cd69f12..b94d895399e60a 100644
--- a/test/parallel/test-http2-client-priority-before-connect.js
+++ b/test/parallel/test-http2-client-priority-before-connect.js
@@ -1,28 +1,36 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 const server = h2.createServer();
 
 // we use the lower-level API here
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.end('ok');
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    stream.end('ok');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  req.priority({});
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    req.priority({});
 
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall());
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-client-promisify-connect.js b/test/parallel/test-http2-client-promisify-connect.js
index 3e41bee49bb5c3..5ac2d032ee7ddd 100644
--- a/test/parallel/test-http2-client-promisify-connect.js
+++ b/test/parallel/test-http2-client-promisify-connect.js
@@ -2,31 +2,40 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const util = require('util');
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.end('ok');
-}));
-server.listen(0, common.mustCall(() => {
-  const connect = util.promisify(http2.connect);
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    stream.end('ok');
+  })
+);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const connect = util.promisify(http2.connect);
 
-  connect(`http://localhost:${server.address().port}`)
-    .then(common.mustCall((client) => {
-      assert(client);
-      const req = client.request();
-      let data = '';
-      req.setEncoding('utf8');
-      req.on('data', (chunk) => data += chunk);
-      req.on('end', common.mustCall(() => {
-        assert.strictEqual(data, 'ok');
-        client.close();
-        server.close();
-      }));
-    }));
-}));
+    connect(`http://localhost:${server.address().port}`).then(
+      common.mustCall((client) => {
+        assert(client);
+        const req = client.request();
+        let data = '';
+        req.setEncoding('utf8');
+        req.on('data', (chunk) => (data += chunk));
+        req.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(data, 'ok');
+            client.close();
+            server.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-client-request-options-errors.js b/test/parallel/test-http2-client-request-options-errors.js
index d170443f72848e..e334ec52e5183f 100644
--- a/test/parallel/test-http2-client-request-options-errors.js
+++ b/test/parallel/test-http2-client-request-options-errors.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 // Check if correct errors are emitted when wrong type of data is passed
@@ -28,31 +27,40 @@ const types = {
 
 const server = http2.createServer(common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
-
-  client.on('connect', () => {
-    Object.keys(optionsToTest).forEach((option) => {
-      Object.keys(types).forEach((type) => {
-        if (type === optionsToTest[option])
-          return;
-
-        common.expectsError(
-          () => client.request({
-            ':method': 'CONNECT',
-            ':authority': `localhost:${port}`
-          }, {
-            [option]: types[type]
-          }), {
-            type: TypeError,
-            code: 'ERR_INVALID_OPT_VALUE',
-            message: `The value "${String(types[type])}" is invalid ` +
-                    `for option "${option}"`
-          });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
+
+    client.on('connect', () => {
+      Object.keys(optionsToTest).forEach((option) => {
+        Object.keys(types).forEach((type) => {
+          if (type === optionsToTest[option]) return;
+
+          common.expectsError(
+            () =>
+              client.request(
+                {
+                  ':method': 'CONNECT',
+                  ':authority': `localhost:${port}`
+                },
+                {
+                  [option]: types[type]
+                }
+              ),
+            {
+              type: TypeError,
+              code: 'ERR_INVALID_OPT_VALUE',
+              message:
+                `The value "${String(types[type])}" is invalid ` +
+                `for option "${option}"`
+            }
+          );
+        });
       });
+      server.close();
+      client.close();
     });
-    server.close();
-    client.close();
-  });
-}));
+  })
+);
diff --git a/test/parallel/test-http2-client-rststream-before-connect.js b/test/parallel/test-http2-client-rststream-before-connect.js
index 33e22130aad19b..7f3498610880fe 100644
--- a/test/parallel/test-http2-client-rststream-before-connect.js
+++ b/test/parallel/test-http2-client-rststream-before-connect.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -13,64 +12,68 @@ server.on('stream', (stream) => {
   stream.end('ok');
 });
 
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  const closeCode = 1;
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    const closeCode = 1;
 
-  assert.throws(
-    () => req.close(2 ** 32),
-    {
+    assert.throws(() => req.close(2 ** 32), {
       name: 'RangeError [ERR_OUT_OF_RANGE]',
       code: 'ERR_OUT_OF_RANGE',
-      message: 'The value of "code" is out of range. It must be ' +
-               '>= 0 && <= 4294967295. Received 4294967296'
-    }
-  );
-  assert.strictEqual(req.closed, false);
+      message:
+        'The value of "code" is out of range. It must be ' +
+        '>= 0 && <= 4294967295. Received 4294967296'
+    });
+    assert.strictEqual(req.closed, false);
 
-  [true, 1, {}, [], null, 'test'].forEach((notFunction) => {
-    common.expectsError(
-      () => req.close(closeCode, notFunction),
-      {
+    [true, 1, {}, [], null, 'test'].forEach((notFunction) => {
+      common.expectsError(() => req.close(closeCode, notFunction), {
         type: TypeError,
         code: 'ERR_INVALID_CALLBACK',
         message: 'Callback must be a function'
-      }
-    );
-    assert.strictEqual(req.closed, false);
-  });
+      });
+      assert.strictEqual(req.closed, false);
+    });
 
-  req.close(closeCode, common.mustCall());
-  assert.strictEqual(req.closed, true);
+    req.close(closeCode, common.mustCall());
+    assert.strictEqual(req.closed, true);
 
-  // Make sure that destroy is called.
-  req._destroy = common.mustCall(req._destroy.bind(req));
+    // Make sure that destroy is called.
+    req._destroy = common.mustCall(req._destroy.bind(req));
 
-  // Second call doesn't do anything.
-  req.close(closeCode + 1);
+    // Second call doesn't do anything.
+    req.close(closeCode + 1);
 
-  req.on('close', common.mustCall(() => {
-    assert.strictEqual(req.destroyed, true);
-    assert.strictEqual(req.rstCode, closeCode);
-    server.close();
-    client.close();
-  }));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(req.destroyed, true);
+        assert.strictEqual(req.rstCode, closeCode);
+        server.close();
+        client.close();
+      })
+    );
 
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code NGHTTP2_PROTOCOL_ERROR'
-  }));
+    req.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_STREAM_ERROR',
+        type: Error,
+        message: 'Stream closed with error code NGHTTP2_PROTOCOL_ERROR'
+      })
+    );
 
-  // The `response` event should not fire as the server should receive the
-  // RST_STREAM frame before it ever has a chance to reply.
-  req.on('response', common.mustNotCall());
+    // The `response` event should not fire as the server should receive the
+    // RST_STREAM frame before it ever has a chance to reply.
+    req.on('response', common.mustNotCall());
 
-  // The `end` event should still fire as we close the readable stream by
-  // pushing a `null` chunk.
-  req.on('end', common.mustCall());
+    // The `end` event should still fire as we close the readable stream by
+    // pushing a `null` chunk.
+    req.on('end', common.mustCall());
 
-  req.resume();
-  req.end();
-}));
+    req.resume();
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-client-set-priority.js b/test/parallel/test-http2-client-set-priority.js
index 64b7b56dfa2543..590e13dc7db455 100644
--- a/test/parallel/test-http2-client-set-priority.js
+++ b/test/parallel/test-http2-client-set-priority.js
@@ -1,30 +1,38 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const checkWeight = (actual, expect) => {
   const server = http2.createServer();
-  server.on('stream', common.mustCall((stream, headers, flags) => {
-    assert.strictEqual(stream.state.weight, expect);
-    stream.respond();
-    stream.end('test');
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    const client = http2.connect(`http://localhost:${server.address().port}`);
-    const req = client.request({}, { weight: actual });
-
-    req.on('data', common.mustCall());
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(() => {
-      server.close();
-      client.close();
-    }));
-  }));
+  server.on(
+    'stream',
+    common.mustCall((stream, headers, flags) => {
+      assert.strictEqual(stream.state.weight, expect);
+      stream.respond();
+      stream.end('test');
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const client = http2.connect(`http://localhost:${server.address().port}`);
+      const req = client.request({}, { weight: actual });
+
+      req.on('data', common.mustCall());
+      req.on('end', common.mustCall());
+      req.on(
+        'close',
+        common.mustCall(() => {
+          server.close();
+          client.close();
+        })
+      );
+    })
+  );
 };
 
 // when client weight is lower than 1, weight is 1
diff --git a/test/parallel/test-http2-client-setNextStreamID-errors.js b/test/parallel/test-http2-client-setNextStreamID-errors.js
index 3fb4728b7d3a1c..39dffd204b25a6 100644
--- a/test/parallel/test-http2-client-setNextStreamID-errors.js
+++ b/test/parallel/test-http2-client-setNextStreamID-errors.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http2 = require('http2');
 
@@ -22,39 +21,39 @@ const types = {
   symbol: Symbol('test')
 };
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  client.on('connect', () => {
-    const outOfRangeNum = 2 ** 31;
-    common.expectsError(
-      () => client.setNextStreamID(outOfRangeNum),
-      {
+    client.on('connect', () => {
+      const outOfRangeNum = 2 ** 31;
+      common.expectsError(() => client.setNextStreamID(outOfRangeNum), {
         type: RangeError,
         code: 'ERR_OUT_OF_RANGE',
-        message: 'The value of "id" is out of range.' +
-           ' It must be > 0 and <= 2147483647. Received ' + outOfRangeNum
-      }
-    );
-
-    // should throw if something other than number is passed to setNextStreamID
-    Object.entries(types).forEach(([type, value]) => {
-      if (type === 'number') {
-        return;
-      }
-
-      common.expectsError(
-        () => client.setNextStreamID(value),
-        {
+        message:
+          'The value of "id" is out of range.' +
+          ' It must be > 0 and <= 2147483647. Received ' +
+          outOfRangeNum
+      });
+
+      // should throw if something other than number is passed to setNextStreamID
+      Object.entries(types).forEach(([type, value]) => {
+        if (type === 'number') {
+          return;
+        }
+
+        common.expectsError(() => client.setNextStreamID(value), {
           type: TypeError,
           code: 'ERR_INVALID_ARG_TYPE',
-          message: 'The "id" argument must be of type number. Received type ' +
-                   typeof value
-        }
-      );
+          message:
+            'The "id" argument must be of type number. Received type ' +
+            typeof value
+        });
+      });
+
+      server.close();
+      client.close();
     });
-
-    server.close();
-    client.close();
-  });
-}));
+  })
+);
diff --git a/test/parallel/test-http2-client-settings-before-connect.js b/test/parallel/test-http2-client-settings-before-connect.js
index ceea1bc39ad7d3..f8bdfa1b122a98 100644
--- a/test/parallel/test-http2-client-settings-before-connect.js
+++ b/test/parallel/test-http2-client-settings-before-connect.js
@@ -1,68 +1,73 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 const server = h2.createServer();
 
 // we use the lower-level API here
-server.on('stream', common.mustCall((stream, headers, flags) => {
-  stream.respond();
-  stream.end('ok');
-}));
-server.on('session', common.mustCall((session) => {
-  session.on('remoteSettings', common.mustCall(2));
-}));
+server.on(
+  'stream',
+  common.mustCall((stream, headers, flags) => {
+    stream.respond();
+    stream.end('ok');
+  })
+);
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.on('remoteSettings', common.mustCall(2));
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
 
-  [
-    ['headerTableSize', -1, RangeError],
-    ['headerTableSize', 2 ** 32, RangeError],
-    ['initialWindowSize', -1, RangeError],
-    ['initialWindowSize', 2 ** 32, RangeError],
-    ['maxFrameSize', 1, RangeError],
-    ['maxFrameSize', 2 ** 24, RangeError],
-    ['maxConcurrentStreams', -1, RangeError],
-    ['maxConcurrentStreams', 2 ** 31, RangeError],
-    ['maxHeaderListSize', -1, RangeError],
-    ['maxHeaderListSize', 2 ** 32, RangeError],
-    ['enablePush', 'a', TypeError],
-    ['enablePush', 1, TypeError],
-    ['enablePush', 0, TypeError],
-    ['enablePush', null, TypeError],
-    ['enablePush', {}, TypeError]
-  ].forEach(([name, value, errorType]) =>
-    common.expectsError(
-      () => client.settings({ [name]: value }),
-      {
+    [
+      ['headerTableSize', -1, RangeError],
+      ['headerTableSize', 2 ** 32, RangeError],
+      ['initialWindowSize', -1, RangeError],
+      ['initialWindowSize', 2 ** 32, RangeError],
+      ['maxFrameSize', 1, RangeError],
+      ['maxFrameSize', 2 ** 24, RangeError],
+      ['maxConcurrentStreams', -1, RangeError],
+      ['maxConcurrentStreams', 2 ** 31, RangeError],
+      ['maxHeaderListSize', -1, RangeError],
+      ['maxHeaderListSize', 2 ** 32, RangeError],
+      ['enablePush', 'a', TypeError],
+      ['enablePush', 1, TypeError],
+      ['enablePush', 0, TypeError],
+      ['enablePush', null, TypeError],
+      ['enablePush', {}, TypeError]
+    ].forEach(([name, value, errorType]) =>
+      common.expectsError(() => client.settings({ [name]: value }), {
         code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
         type: errorType
-      }
-    )
-  );
+      })
+    );
 
-  [1, true, {}, []].forEach((invalidCallback) =>
-    common.expectsError(
-      () => client.settings({}, invalidCallback),
-      {
+    [1, true, {}, []].forEach((invalidCallback) =>
+      common.expectsError(() => client.settings({}, invalidCallback), {
         type: TypeError,
         code: 'ERR_INVALID_CALLBACK',
         message: 'Callback must be a function'
-      }
-    )
-  );
+      })
+    );
 
-  client.settings({ maxFrameSize: 1234567 });
+    client.settings({ maxFrameSize: 1234567 });
 
-  const req = client.request();
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+    const req = client.request();
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-client-shutdown-before-connect.js b/test/parallel/test-http2-client-shutdown-before-connect.js
index bd971ebf7de69c..b5c3665947cb82 100644
--- a/test/parallel/test-http2-client-shutdown-before-connect.js
+++ b/test/parallel/test-http2-client-shutdown-before-connect.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 const server = h2.createServer();
@@ -10,7 +9,10 @@ const server = h2.createServer();
 // we use the lower-level API here
 server.on('stream', common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  client.close(common.mustCall(() => server.close()));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    client.close(common.mustCall(() => server.close()));
+  })
+);
diff --git a/test/parallel/test-http2-client-socket-destroy.js b/test/parallel/test-http2-client-socket-destroy.js
index 3eb7e898edcfc1..ed9741af20ef39 100644
--- a/test/parallel/test-http2-client-socket-destroy.js
+++ b/test/parallel/test-http2-client-socket-destroy.js
@@ -3,8 +3,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 const { kSocket } = require('internal/http2/util');
 
@@ -14,27 +13,36 @@ const body =
 const server = h2.createServer();
 
 // we use the lower-level API here
-server.on('stream', common.mustCall((stream) => {
-  stream.on('aborted', common.mustCall());
-  stream.on('close', common.mustCall());
-  stream.respond();
-  stream.write(body);
-  // purposefully do not end()
-}));
-
-server.listen(0, common.mustCall(function() {
-  const client = h2.connect(`http://localhost:${this.address().port}`);
-  const req = client.request();
-
-  req.on('response', common.mustCall(() => {
-    // send a premature socket close
-    client[kSocket].destroy();
-  }));
-
-  req.resume();
-  req.on('end', common.mustCall());
-  req.on('close', common.mustCall(() => server.close()));
-
-  // On the client, the close event must call
-  client.on('close', common.mustCall());
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.on('aborted', common.mustCall());
+    stream.on('close', common.mustCall());
+    stream.respond();
+    stream.write(body);
+    // purposefully do not end()
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(function() {
+    const client = h2.connect(`http://localhost:${this.address().port}`);
+    const req = client.request();
+
+    req.on(
+      'response',
+      common.mustCall(() => {
+        // send a premature socket close
+        client[kSocket].destroy();
+      })
+    );
+
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => server.close()));
+
+    // On the client, the close event must call
+    client.on('close', common.mustCall());
+  })
+);
diff --git a/test/parallel/test-http2-client-stream-destroy-before-connect.js b/test/parallel/test-http2-client-stream-destroy-before-connect.js
index d834de5d11ebe7..2797c61b26eded 100644
--- a/test/parallel/test-http2-client-stream-destroy-before-connect.js
+++ b/test/parallel/test-http2-client-stream-destroy-before-connect.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const NGHTTP2_INTERNAL_ERROR = h2.constants.NGHTTP2_INTERNAL_ERROR;
@@ -18,32 +17,43 @@ server.on('stream', (stream) => {
   // system specific timings.
   stream.on('error', (err) => {
     assert.strictEqual(err.code, 'ERR_HTTP2_STREAM_ERROR');
-    assert.strictEqual(err.message,
-                       'Stream closed with error code NGHTTP2_INTERNAL_ERROR');
+    assert.strictEqual(
+      err.message,
+      'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
+    );
   });
   stream.respond();
   stream.end();
 });
 
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const req = client.request();
-  req.destroy(new Error('test'));
-
-  req.on('error', common.expectsError({
-    type: Error,
-    message: 'test'
-  }));
-
-  req.on('close', common.mustCall(() => {
-    assert.strictEqual(req.rstCode, NGHTTP2_INTERNAL_ERROR);
-    assert.strictEqual(req.rstCode, NGHTTP2_INTERNAL_ERROR);
-    server.close();
-    client.close();
-  }));
-
-  req.on('response', common.mustNotCall());
-  req.resume();
-  req.on('end', common.mustCall());
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+
+    const req = client.request();
+    req.destroy(new Error('test'));
+
+    req.on(
+      'error',
+      common.expectsError({
+        type: Error,
+        message: 'test'
+      })
+    );
+
+    req.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(req.rstCode, NGHTTP2_INTERNAL_ERROR);
+        assert.strictEqual(req.rstCode, NGHTTP2_INTERNAL_ERROR);
+        server.close();
+        client.close();
+      })
+    );
+
+    req.on('response', common.mustNotCall());
+    req.resume();
+    req.on('end', common.mustCall());
+  })
+);
diff --git a/test/parallel/test-http2-client-unescaped-path.js b/test/parallel/test-http2-client-unescaped-path.js
index ff122a02ca1a68..c58bf8c83793aa 100644
--- a/test/parallel/test-http2-client-unescaped-path.js
+++ b/test/parallel/test-http2-client-unescaped-path.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
 
@@ -12,26 +11,33 @@ server.on('stream', common.mustNotCall());
 
 const count = 32;
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  client.setMaxListeners(33);
-
-  const countdown = new Countdown(count + 1, () => {
-    server.close();
-    client.close();
-  });
-
-  // nghttp2 will catch the bad header value for us.
-  function doTest(i) {
-    const req = client.request({ ':path': `bad${String.fromCharCode(i)}path` });
-    req.on('error', common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code NGHTTP2_PROTOCOL_ERROR'
-    }));
-    req.on('close', common.mustCall(() => countdown.dec()));
-  }
-
-  for (let i = 0; i <= count; i += 1)
-    doTest(i);
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    client.setMaxListeners(33);
+
+    const countdown = new Countdown(count + 1, () => {
+      server.close();
+      client.close();
+    });
+
+    // nghttp2 will catch the bad header value for us.
+    function doTest(i) {
+      const req = client.request({
+        ':path': `bad${String.fromCharCode(i)}path`
+      });
+      req.on(
+        'error',
+        common.expectsError({
+          code: 'ERR_HTTP2_STREAM_ERROR',
+          type: Error,
+          message: 'Stream closed with error code NGHTTP2_PROTOCOL_ERROR'
+        })
+      );
+      req.on('close', common.mustCall(() => countdown.dec()));
+    }
+
+    for (let i = 0; i <= count; i += 1) doTest(i);
+  })
+);
diff --git a/test/parallel/test-http2-client-upload-reject.js b/test/parallel/test-http2-client-upload-reject.js
index 678114130e3dba..eb143df46580e7 100644
--- a/test/parallel/test-http2-client-upload-reject.js
+++ b/test/parallel/test-http2-client-upload-reject.js
@@ -3,8 +3,7 @@
 // Verifies that uploading data from a client works
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const fs = require('fs');
@@ -14,38 +13,58 @@ const loc = fixtures.path('person-large.jpg');
 
 assert(fs.existsSync(loc));
 
-fs.readFile(loc, common.mustCall((err, data) => {
-  assert.ifError(err);
-
-  const server = http2.createServer();
-
-  server.on('stream', common.mustCall((stream) => {
-    // Wait for some data to come through.
-    setImmediate(() => {
-      stream.on('close', common.mustCall(() => {
-        assert.strictEqual(stream.rstCode, 0);
-      }));
-
-      stream.respond({ ':status': 400 });
-      stream.end();
-    });
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    const client = http2.connect(`http://localhost:${server.address().port}`);
-
-    const req = client.request({ ':method': 'POST' });
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers[':status'], 400);
-    }));
-
-    req.resume();
-    req.on('end', common.mustCall(() => {
-      server.close();
-      client.close();
-    }));
-
-    const str = fs.createReadStream(loc);
-    str.pipe(req);
-  }));
-}));
+fs.readFile(
+  loc,
+  common.mustCall((err, data) => {
+    assert.ifError(err);
+
+    const server = http2.createServer();
+
+    server.on(
+      'stream',
+      common.mustCall((stream) => {
+        // Wait for some data to come through.
+        setImmediate(() => {
+          stream.on(
+            'close',
+            common.mustCall(() => {
+              assert.strictEqual(stream.rstCode, 0);
+            })
+          );
+
+          stream.respond({ ':status': 400 });
+          stream.end();
+        });
+      })
+    );
+
+    server.listen(
+      0,
+      common.mustCall(() => {
+        const client = http2.connect(
+          `http://localhost:${server.address().port}`
+        );
+
+        const req = client.request({ ':method': 'POST' });
+        req.on(
+          'response',
+          common.mustCall((headers) => {
+            assert.strictEqual(headers[':status'], 400);
+          })
+        );
+
+        req.resume();
+        req.on(
+          'end',
+          common.mustCall(() => {
+            server.close();
+            client.close();
+          })
+        );
+
+        const str = fs.createReadStream(loc);
+        str.pipe(req);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-client-upload.js b/test/parallel/test-http2-client-upload.js
index 78c6d47cbb4f44..6c565b68601393 100644
--- a/test/parallel/test-http2-client-upload.js
+++ b/test/parallel/test-http2-client-upload.js
@@ -3,8 +3,7 @@
 // Verifies that uploading data from a client works
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const fs = require('fs');
@@ -16,40 +15,54 @@ let fileData;
 
 assert(fs.existsSync(loc));
 
-fs.readFile(loc, common.mustCall((err, data) => {
-  assert.ifError(err);
-  fileData = data;
-
-  const server = http2.createServer();
-
-  server.on('stream', common.mustCall((stream) => {
-    let data = Buffer.alloc(0);
-    stream.on('data', (chunk) => data = Buffer.concat([data, chunk]));
-    stream.on('end', common.mustCall(() => {
-      assert.deepStrictEqual(data, fileData);
-    }));
-    stream.respond();
-    stream.end();
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    const client = http2.connect(`http://localhost:${server.address().port}`);
-
-    const countdown = new Countdown(2, () => {
-      server.close();
-      client.close();
-    });
-
-    const req = client.request({ ':method': 'POST' });
-    req.on('response', common.mustCall());
-
-    req.resume();
-    req.on('end', common.mustCall());
-
-    req.on('finish', () => countdown.dec());
-    const str = fs.createReadStream(loc);
-    str.on('end', common.mustCall());
-    str.on('close', () => countdown.dec());
-    str.pipe(req);
-  }));
-}));
+fs.readFile(
+  loc,
+  common.mustCall((err, data) => {
+    assert.ifError(err);
+    fileData = data;
+
+    const server = http2.createServer();
+
+    server.on(
+      'stream',
+      common.mustCall((stream) => {
+        let data = Buffer.alloc(0);
+        stream.on('data', (chunk) => (data = Buffer.concat([data, chunk])));
+        stream.on(
+          'end',
+          common.mustCall(() => {
+            assert.deepStrictEqual(data, fileData);
+          })
+        );
+        stream.respond();
+        stream.end();
+      })
+    );
+
+    server.listen(
+      0,
+      common.mustCall(() => {
+        const client = http2.connect(
+          `http://localhost:${server.address().port}`
+        );
+
+        const countdown = new Countdown(2, () => {
+          server.close();
+          client.close();
+        });
+
+        const req = client.request({ ':method': 'POST' });
+        req.on('response', common.mustCall());
+
+        req.resume();
+        req.on('end', common.mustCall());
+
+        req.on('finish', () => countdown.dec());
+        const str = fs.createReadStream(loc);
+        str.on('end', common.mustCall());
+        str.on('close', () => countdown.dec());
+        str.pipe(req);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-client-write-before-connect.js b/test/parallel/test-http2-client-write-before-connect.js
index 6588d7dccd139d..811956de0d720f 100644
--- a/test/parallel/test-http2-client-write-before-connect.js
+++ b/test/parallel/test-http2-client-write-before-connect.js
@@ -1,37 +1,48 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 const server = h2.createServer();
 
 // we use the lower-level API here
-server.on('stream', common.mustCall((stream, headers, flags) => {
-  let data = '';
-  stream.setEncoding('utf8');
-  stream.on('data', (chunk) => data += chunk);
-  stream.on('end', common.mustCall(() => {
-    assert.strictEqual(data, 'some data more data');
-  }));
-  stream.respond();
-  stream.end('ok');
-}));
+server.on(
+  'stream',
+  common.mustCall((stream, headers, flags) => {
+    let data = '';
+    stream.setEncoding('utf8');
+    stream.on('data', (chunk) => (data += chunk));
+    stream.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(data, 'some data more data');
+      })
+    );
+    stream.respond();
+    stream.end('ok');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
 
-  const req = client.request({ ':method': 'POST' });
-  req.write('some data ');
-  req.end('more data');
+    const req = client.request({ ':method': 'POST' });
+    req.write('some data ');
+    req.end('more data');
 
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall());
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-client-write-empty-string.js b/test/parallel/test-http2-client-write-empty-string.js
index de46507fb17137..88f6ea88b39f4f 100644
--- a/test/parallel/test-http2-client-write-empty-string.js
+++ b/test/parallel/test-http2-client-write-empty-string.js
@@ -2,53 +2,66 @@
 
 const assert = require('assert');
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http2 = require('http2');
 
-for (const chunkSequence of [
-  [ '' ],
-  [ '', '' ]
-]) {
+for (const chunkSequence of [[''], ['', '']]) {
   const server = http2.createServer();
-  server.on('stream', common.mustCall((stream, headers, flags) => {
-    stream.respond({ 'content-type': 'text/html' });
-
-    let data = '';
-    stream.on('data', common.mustNotCall((chunk) => {
-      data += chunk.toString();
-    }));
-    stream.on('end', common.mustCall(() => {
-      stream.end(`"${data}"`);
-    }));
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const client = http2.connect(`http://localhost:${port}`);
-
-    const req = client.request({
-      ':method': 'POST',
-      ':path': '/'
-    });
-
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers[':status'], 200);
-      assert.strictEqual(headers['content-type'], 'text/html');
-    }));
-
-    let data = '';
-    req.setEncoding('utf8');
-    req.on('data', common.mustCallAtLeast((d) => data += d));
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(data, '""');
-      server.close();
-      client.close();
-    }));
-
-    for (const chunk of chunkSequence)
-      req.write(chunk);
-    req.end();
-  }));
+  server.on(
+    'stream',
+    common.mustCall((stream, headers, flags) => {
+      stream.respond({ 'content-type': 'text/html' });
+
+      let data = '';
+      stream.on(
+        'data',
+        common.mustNotCall((chunk) => {
+          data += chunk.toString();
+        })
+      );
+      stream.on(
+        'end',
+        common.mustCall(() => {
+          stream.end(`"${data}"`);
+        })
+      );
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const client = http2.connect(`http://localhost:${port}`);
+
+      const req = client.request({
+        ':method': 'POST',
+        ':path': '/'
+      });
+
+      req.on(
+        'response',
+        common.mustCall((headers) => {
+          assert.strictEqual(headers[':status'], 200);
+          assert.strictEqual(headers['content-type'], 'text/html');
+        })
+      );
+
+      let data = '';
+      req.setEncoding('utf8');
+      req.on('data', common.mustCallAtLeast((d) => (data += d)));
+      req.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(data, '""');
+          server.close();
+          client.close();
+        })
+      );
+
+      for (const chunk of chunkSequence) req.write(chunk);
+      req.end();
+    })
+  );
 }
diff --git a/test/parallel/test-http2-compat-aborted.js b/test/parallel/test-http2-compat-aborted.js
index 01caf95f98688a..291966307d000f 100644
--- a/test/parallel/test-http2-compat-aborted.js
+++ b/test/parallel/test-http2-compat-aborted.js
@@ -1,27 +1,39 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 const assert = require('assert');
 
+const server = h2.createServer(
+  common.mustCall(function(req, res) {
+    req.on(
+      'aborted',
+      common.mustCall(function() {
+        assert.strictEqual(this.aborted, true);
+      })
+    );
+    assert.strictEqual(req.aborted, false);
+    res.write('hello');
+    server.close();
+  })
+);
 
-const server = h2.createServer(common.mustCall(function(req, res) {
-  req.on('aborted', common.mustCall(function() {
-    assert.strictEqual(this.aborted, true);
-  }));
-  assert.strictEqual(req.aborted, false);
-  res.write('hello');
-  server.close();
-}));
-
-server.listen(0, common.mustCall(function() {
-  const url = `http://localhost:${server.address().port}`;
-  const client = h2.connect(url, common.mustCall(() => {
-    const request = client.request();
-    request.on('data', common.mustCall((chunk) => {
-      client.destroy();
-    }));
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const url = `http://localhost:${server.address().port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(() => {
+        const request = client.request();
+        request.on(
+          'data',
+          common.mustCall((chunk) => {
+            client.destroy();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-client-upload-reject.js b/test/parallel/test-http2-compat-client-upload-reject.js
index e6a187cb12b264..0d403638ee14c0 100644
--- a/test/parallel/test-http2-compat-client-upload-reject.js
+++ b/test/parallel/test-http2-compat-client-upload-reject.js
@@ -3,8 +3,7 @@
 // Verifies that uploading data from a client works
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const fs = require('fs');
@@ -14,31 +13,47 @@ const loc = fixtures.path('person-large.jpg');
 
 assert(fs.existsSync(loc));
 
-fs.readFile(loc, common.mustCall((err, data) => {
-  assert.ifError(err);
-
-  const server = http2.createServer(common.mustCall((req, res) => {
-    setImmediate(() => {
-      res.writeHead(400);
-      res.end();
-    });
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    const client = http2.connect(`http://localhost:${server.address().port}`);
-
-    const req = client.request({ ':method': 'POST' });
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers[':status'], 400);
-    }));
-
-    req.resume();
-    req.on('end', common.mustCall(() => {
-      server.close();
-      client.close();
-    }));
-
-    const str = fs.createReadStream(loc);
-    str.pipe(req);
-  }));
-}));
+fs.readFile(
+  loc,
+  common.mustCall((err, data) => {
+    assert.ifError(err);
+
+    const server = http2.createServer(
+      common.mustCall((req, res) => {
+        setImmediate(() => {
+          res.writeHead(400);
+          res.end();
+        });
+      })
+    );
+
+    server.listen(
+      0,
+      common.mustCall(() => {
+        const client = http2.connect(
+          `http://localhost:${server.address().port}`
+        );
+
+        const req = client.request({ ':method': 'POST' });
+        req.on(
+          'response',
+          common.mustCall((headers) => {
+            assert.strictEqual(headers[':status'], 400);
+          })
+        );
+
+        req.resume();
+        req.on(
+          'end',
+          common.mustCall(() => {
+            server.close();
+            client.close();
+          })
+        );
+
+        const str = fs.createReadStream(loc);
+        str.pipe(req);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-errors.js b/test/parallel/test-http2-compat-errors.js
index c84318bad68e35..4474dfad2a234e 100644
--- a/test/parallel/test-http2-compat-errors.js
+++ b/test/parallel/test-http2-compat-errors.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 // Errors should not be reported both in Http2ServerRequest
@@ -11,26 +10,37 @@ const h2 = require('http2');
 
 let expected = null;
 
-const server = h2.createServer(common.mustCall(function(req, res) {
-  res.stream.on('error', common.mustCall());
-  req.on('error', common.mustNotCall());
-  res.on('error', common.mustNotCall());
-  req.on('aborted', common.mustCall());
-  res.on('aborted', common.mustNotCall());
+const server = h2.createServer(
+  common.mustCall(function(req, res) {
+    res.stream.on('error', common.mustCall());
+    req.on('error', common.mustNotCall());
+    res.on('error', common.mustNotCall());
+    req.on('aborted', common.mustCall());
+    res.on('aborted', common.mustNotCall());
 
-  res.write('hello');
+    res.write('hello');
 
-  expected = new Error('kaboom');
-  res.stream.destroy(expected);
-  server.close();
-}));
+    expected = new Error('kaboom');
+    res.stream.destroy(expected);
+    server.close();
+  })
+);
 
-server.listen(0, common.mustCall(function() {
-  const url = `http://localhost:${server.address().port}`;
-  const client = h2.connect(url, common.mustCall(() => {
-    const request = client.request();
-    request.on('data', common.mustCall((chunk) => {
-      client.destroy();
-    }));
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const url = `http://localhost:${server.address().port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(() => {
+        const request = client.request();
+        request.on(
+          'data',
+          common.mustCall((chunk) => {
+            client.destroy();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-expect-continue-check.js b/test/parallel/test-http2-compat-expect-continue-check.js
index 4f2514a44a4f9e..ec113e7aaa07b9 100644
--- a/test/parallel/test-http2-compat-expect-continue-check.js
+++ b/test/parallel/test-http2-compat-expect-continue-check.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -16,43 +15,66 @@ const server = http2.createServer(
   common.mustNotCall('Full request received before 100 Continue')
 );
 
-server.on('checkContinue', common.mustCall((req, res) => {
-  res.writeContinue();
-  res.writeHead(200, {});
-  res.end(testResBody);
-  // should simply return false if already too late to write
-  assert.strictEqual(res.writeContinue(), false);
-  res.on('finish', common.mustCall(
-    () => process.nextTick(() => assert.strictEqual(res.writeContinue(), false))
-  ));
-}));
-
-server.listen(0, common.mustCall(() => {
-  let body = '';
-
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request({
-    ':method': 'POST',
-    'expect': '100-continue'
-  });
-
-  let gotContinue = false;
-  req.on('continue', common.mustCall(() => {
-    gotContinue = true;
-  }));
-
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(gotContinue, true);
-    assert.strictEqual(headers[':status'], 200);
-    req.end();
-  }));
-
-  req.setEncoding('utf-8');
-  req.on('data', common.mustCall((chunk) => { body += chunk; }));
-
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(body, testResBody);
-    client.close();
-    server.close();
-  }));
-}));
+server.on(
+  'checkContinue',
+  common.mustCall((req, res) => {
+    res.writeContinue();
+    res.writeHead(200, {});
+    res.end(testResBody);
+    // should simply return false if already too late to write
+    assert.strictEqual(res.writeContinue(), false);
+    res.on(
+      'finish',
+      common.mustCall(() =>
+        process.nextTick(() => assert.strictEqual(res.writeContinue(), false))
+      )
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    let body = '';
+
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({
+      ':method': 'POST',
+      expect: '100-continue'
+    });
+
+    let gotContinue = false;
+    req.on(
+      'continue',
+      common.mustCall(() => {
+        gotContinue = true;
+      })
+    );
+
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(gotContinue, true);
+        assert.strictEqual(headers[':status'], 200);
+        req.end();
+      })
+    );
+
+    req.setEncoding('utf-8');
+    req.on(
+      'data',
+      common.mustCall((chunk) => {
+        body += chunk;
+      })
+    );
+
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(body, testResBody);
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-expect-continue.js b/test/parallel/test-http2-compat-expect-continue.js
index cb90e51f3bc9d7..e6362ac1764fc1 100644
--- a/test/parallel/test-http2-compat-expect-continue.js
+++ b/test/parallel/test-http2-compat-expect-continue.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -16,39 +15,59 @@ const server = http2.createServer();
 
 let sentResponse = false;
 
-server.on('request', common.mustCall((req, res) => {
-  res.end(testResBody);
-  sentResponse = true;
-}));
+server.on(
+  'request',
+  common.mustCall((req, res) => {
+    res.end(testResBody);
+    sentResponse = true;
+  })
+);
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-  let body = '';
-
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request({
-    ':method': 'POST',
-    'expect': '100-continue'
-  });
-
-  let gotContinue = false;
-  req.on('continue', common.mustCall(() => {
-    gotContinue = true;
-  }));
-
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(gotContinue, true);
-    assert.strictEqual(sentResponse, true);
-    assert.strictEqual(headers[':status'], 200);
-    req.end();
-  }));
-
-  req.setEncoding('utf8');
-  req.on('data', common.mustCall((chunk) => { body += chunk; }));
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(body, testResBody);
-    client.close();
-    server.close();
-  }));
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    let body = '';
+
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({
+      ':method': 'POST',
+      expect: '100-continue'
+    });
+
+    let gotContinue = false;
+    req.on(
+      'continue',
+      common.mustCall(() => {
+        gotContinue = true;
+      })
+    );
+
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(gotContinue, true);
+        assert.strictEqual(sentResponse, true);
+        assert.strictEqual(headers[':status'], 200);
+        req.end();
+      })
+    );
+
+    req.setEncoding('utf8');
+    req.on(
+      'data',
+      common.mustCall((chunk) => {
+        body += chunk;
+      })
+    );
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(body, testResBody);
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-expect-handling.js b/test/parallel/test-http2-compat-expect-handling.js
index 77f22758345cff..bb1cb9927ac637 100644
--- a/test/parallel/test-http2-compat-expect-handling.js
+++ b/test/parallel/test-http2-compat-expect-handling.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -10,11 +9,14 @@ const expectValue = 'meoww';
 
 const server = http2.createServer(common.mustNotCall());
 
-server.once('checkExpectation', common.mustCall((req, res) => {
-  assert.strictEqual(req.headers.expect, expectValue);
-  res.statusCode = 417;
-  res.end();
-}));
+server.once(
+  'checkExpectation',
+  common.mustCall((req, res) => {
+    assert.strictEqual(req.headers.expect, expectValue);
+    res.statusCode = 417;
+    res.end();
+  })
+);
 
 server.listen(0, common.mustCall(() => nextTest(2)));
 
@@ -30,16 +32,22 @@ function nextTest(testsToRun) {
     ':method': 'GET',
     ':scheme': 'http',
     ':authority': `localhost:${port}`,
-    'expect': expectValue
+    expect: expectValue
   });
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 417);
-    req.resume();
-  }));
-
-  req.on('end', common.mustCall(() => {
-    client.close();
-    nextTest(testsToRun - 1);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 417);
+      req.resume();
+    })
+  );
+
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      nextTest(testsToRun - 1);
+    })
+  );
 }
diff --git a/test/parallel/test-http2-compat-method-connect.js b/test/parallel/test-http2-compat-method-connect.js
index 21ad23e92ba65b..6f41efd2c50b69 100644
--- a/test/parallel/test-http2-compat-method-connect.js
+++ b/test/parallel/test-http2-compat-method-connect.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -10,11 +9,14 @@ const server = http2.createServer(common.mustNotCall());
 
 server.listen(0, common.mustCall(() => testMethodConnect(2)));
 
-server.once('connect', common.mustCall((req, res) => {
-  assert.strictEqual(req.headers[':method'], 'CONNECT');
-  res.statusCode = 405;
-  res.end();
-}));
+server.once(
+  'connect',
+  common.mustCall((req, res) => {
+    assert.strictEqual(req.headers[':method'], 'CONNECT');
+    res.statusCode = 405;
+    res.end();
+  })
+);
 
 function testMethodConnect(testsToRun) {
   if (!testsToRun) {
@@ -28,13 +30,19 @@ function testMethodConnect(testsToRun) {
     ':authority': `localhost:${port}`
   });
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 405);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 405);
+    })
+  );
   req.resume();
-  req.on('end', common.mustCall(() => {
-    client.close();
-    testMethodConnect(testsToRun - 1);
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      testMethodConnect(testsToRun - 1);
+    })
+  );
   req.end();
 }
diff --git a/test/parallel/test-http2-compat-serverrequest-end.js b/test/parallel/test-http2-compat-serverrequest-end.js
index 45a678d1a950d1..9f9ba9c6f60d19 100644
--- a/test/parallel/test-http2-compat-serverrequest-end.js
+++ b/test/parallel/test-http2-compat-serverrequest-end.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -10,32 +9,53 @@ const h2 = require('http2');
 // even on GET requests with no body
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    assert.strictEqual(request.complete, false);
-    request.on('data', () => {});
-    request.on('end', common.mustCall(() => {
-      assert.strictEqual(request.complete, true);
-      response.on('finish', common.mustCall(function() {
-        // the following tests edge cases on request socket
-        // right after finished fires but before backing
-        // Http2Stream is destroyed
-        assert.strictEqual(request.socket.readable, request.stream.readable);
-        assert.strictEqual(request.socket.readable, false);
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        assert.strictEqual(request.complete, false);
+        request.on('data', () => {});
+        request.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(request.complete, true);
+            response.on(
+              'finish',
+              common.mustCall(function() {
+                // the following tests edge cases on request socket
+                // right after finished fires but before backing
+                // Http2Stream is destroyed
+                assert.strictEqual(
+                  request.socket.readable,
+                  request.stream.readable
+                );
+                assert.strictEqual(request.socket.readable, false);
 
-        server.close();
-      }));
-      assert.strictEqual(response.end(), response);
-    }));
-  }));
+                server.close();
+              })
+            );
+            assert.strictEqual(response.end(), response);
+          })
+        );
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(() => {
-    const request = client.request();
-    request.resume();
-    request.on('end', common.mustCall(() => {
-      client.close();
-    }));
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(() => {
+        const request = client.request();
+        request.resume();
+        request.on(
+          'end',
+          common.mustCall(() => {
+            client.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverrequest-headers.js b/test/parallel/test-http2-compat-serverrequest-headers.js
index bd46b719000240..06f3226a7000fc 100644
--- a/test/parallel/test-http2-compat-serverrequest-headers.js
+++ b/test/parallel/test-http2-compat-serverrequest-headers.js
@@ -1,88 +1,97 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 // Http2ServerRequest should have header helpers
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    const expected = {
-      ':path': '/foobar',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`,
-      'foo-bar': 'abc123'
-    };
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        const expected = {
+          ':path': '/foobar',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`,
+          'foo-bar': 'abc123'
+        };
 
-    assert.strictEqual(request.path, undefined);
-    assert.strictEqual(request.method, expected[':method']);
-    assert.strictEqual(request.scheme, expected[':scheme']);
-    assert.strictEqual(request.url, expected[':path']);
-    assert.strictEqual(request.authority, expected[':authority']);
+        assert.strictEqual(request.path, undefined);
+        assert.strictEqual(request.method, expected[':method']);
+        assert.strictEqual(request.scheme, expected[':scheme']);
+        assert.strictEqual(request.url, expected[':path']);
+        assert.strictEqual(request.authority, expected[':authority']);
 
-    const headers = request.headers;
-    for (const [name, value] of Object.entries(expected)) {
-      assert.strictEqual(headers[name], value);
-    }
+        const headers = request.headers;
+        for (const [name, value] of Object.entries(expected)) {
+          assert.strictEqual(headers[name], value);
+        }
 
-    const rawHeaders = request.rawHeaders;
-    for (const [name, value] of Object.entries(expected)) {
-      const position = rawHeaders.indexOf(name);
-      assert.notStrictEqual(position, -1);
-      assert.strictEqual(rawHeaders[position + 1], value);
-    }
+        const rawHeaders = request.rawHeaders;
+        for (const [name, value] of Object.entries(expected)) {
+          const position = rawHeaders.indexOf(name);
+          assert.notStrictEqual(position, -1);
+          assert.strictEqual(rawHeaders[position + 1], value);
+        }
 
-    request.url = '/one';
-    assert.strictEqual(request.url, '/one');
+        request.url = '/one';
+        assert.strictEqual(request.url, '/one');
 
-    // Third-party plugins for packages like express use query params to
-    // change the request method
-    request.method = 'POST';
-    assert.strictEqual(request.method, 'POST');
-    assert.throws(
-      () => request.method = '   ',
-      {
-        code: 'ERR_INVALID_ARG_VALUE',
-        name: 'TypeError [ERR_INVALID_ARG_VALUE]',
-        message: "The argument 'method' is invalid. Received '   '"
-      }
-    );
-    assert.throws(
-      () => request.method = true,
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-        message: 'The "method" argument must be of type string. ' +
-                 'Received type boolean'
-      }
-    );
+        // Third-party plugins for packages like express use query params to
+        // change the request method
+        request.method = 'POST';
+        assert.strictEqual(request.method, 'POST');
+        assert.throws(() => (request.method = '   '), {
+          code: 'ERR_INVALID_ARG_VALUE',
+          name: 'TypeError [ERR_INVALID_ARG_VALUE]',
+          message: "The argument 'method' is invalid. Received '   '"
+        });
+        assert.throws(() => (request.method = true), {
+          code: 'ERR_INVALID_ARG_TYPE',
+          name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+          message:
+            'The "method" argument must be of type string. ' +
+            'Received type boolean'
+        });
 
-    response.on('finish', common.mustCall(function() {
-      server.close();
-    }));
-    response.end();
-  }));
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            server.close();
+          })
+        );
+        response.end();
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/foobar',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`,
-      'foo-bar': 'abc123'
-    };
-    const request = client.request(headers);
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/foobar',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`,
+          'foo-bar': 'abc123'
+        };
+        const request = client.request(headers);
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverrequest-pause.js b/test/parallel/test-http2-compat-serverrequest-pause.js
index 9c81e8ff6140c7..6b88cca2726a8a 100644
--- a/test/parallel/test-http2-compat-serverrequest-pause.js
+++ b/test/parallel/test-http2-compat-serverrequest-pause.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -12,41 +11,61 @@ const testStr = 'Request Body from Client';
 
 const server = h2.createServer();
 
-server.on('request', common.mustCall((req, res) => {
-  let data = '';
-  req.pause();
-  req.setEncoding('utf8');
-  req.on('data', common.mustCall((chunk) => (data += chunk)));
-  setTimeout(common.mustCall(() => {
-    assert.strictEqual(data, '');
-    req.resume();
-  }), common.platformTimeout(100));
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(data, testStr);
-    res.end();
-  }));
-
-  // shouldn't throw if underlying Http2Stream no longer exists
-  res.on('finish', common.mustCall(() => process.nextTick(() => {
+server.on(
+  'request',
+  common.mustCall((req, res) => {
+    let data = '';
     req.pause();
-    req.resume();
-  })));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-
-  const client = h2.connect(`http://localhost:${port}`);
-  const request = client.request({
-    ':path': '/foobar',
-    ':method': 'POST',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  });
-  request.resume();
-  request.end(testStr);
-  request.on('end', common.mustCall(function() {
-    client.close();
-    server.close();
-  }));
-}));
+    req.setEncoding('utf8');
+    req.on('data', common.mustCall((chunk) => (data += chunk)));
+    setTimeout(
+      common.mustCall(() => {
+        assert.strictEqual(data, '');
+        req.resume();
+      }),
+      common.platformTimeout(100)
+    );
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(data, testStr);
+        res.end();
+      })
+    );
+
+    // shouldn't throw if underlying Http2Stream no longer exists
+    res.on(
+      'finish',
+      common.mustCall(() =>
+        process.nextTick(() => {
+          req.pause();
+          req.resume();
+        })
+      )
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+
+    const client = h2.connect(`http://localhost:${port}`);
+    const request = client.request({
+      ':path': '/foobar',
+      ':method': 'POST',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    });
+    request.resume();
+    request.end(testStr);
+    request.on(
+      'end',
+      common.mustCall(function() {
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverrequest-pipe.js b/test/parallel/test-http2-compat-serverrequest-pipe.js
index f5889073060b44..5220159336a3da 100644
--- a/test/parallel/test-http2-compat-serverrequest-pipe.js
+++ b/test/parallel/test-http2-compat-serverrequest-pipe.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const http2 = require('http2');
@@ -18,33 +17,45 @@ const fn = path.join(tmpdir.path, 'http2-url-tests.js');
 
 const server = http2.createServer();
 
-server.on('request', common.mustCall((req, res) => {
-  const dest = req.pipe(fs.createWriteStream(fn));
-  dest.on('finish', common.mustCall(() => {
-    assert.strictEqual(req.complete, true);
-    assert.strictEqual(fs.readFileSync(loc).length, fs.readFileSync(fn).length);
-    fs.unlinkSync(fn);
-    res.end();
-  }));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
-
-  let remaining = 2;
-  function maybeClose() {
-    if (--remaining === 0) {
-      server.close();
-      client.close();
+server.on(
+  'request',
+  common.mustCall((req, res) => {
+    const dest = req.pipe(fs.createWriteStream(fn));
+    dest.on(
+      'finish',
+      common.mustCall(() => {
+        assert.strictEqual(req.complete, true);
+        assert.strictEqual(
+          fs.readFileSync(loc).length,
+          fs.readFileSync(fn).length
+        );
+        fs.unlinkSync(fn);
+        res.end();
+      })
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
+
+    let remaining = 2;
+    function maybeClose() {
+      if (--remaining === 0) {
+        server.close();
+        client.close();
+      }
     }
-  }
-
-  const req = client.request({ ':method': 'POST' });
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall(maybeClose));
-  const str = fs.createReadStream(loc);
-  str.on('end', common.mustCall(maybeClose));
-  str.pipe(req);
-}));
+
+    const req = client.request({ ':method': 'POST' });
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on('end', common.mustCall(maybeClose));
+    const str = fs.createReadStream(loc);
+    str.on('end', common.mustCall(maybeClose));
+    str.pipe(req);
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverrequest-settimeout.js b/test/parallel/test-http2-compat-serverrequest-settimeout.js
index 4b7a629cf55fde..b9d737c7b6a2cf 100644
--- a/test/parallel/test-http2-compat-serverrequest-settimeout.js
+++ b/test/parallel/test-http2-compat-serverrequest-settimeout.js
@@ -1,39 +1,50 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 const msecs = common.platformTimeout(1);
 const server = http2.createServer();
 
 server.on('request', (req, res) => {
-  req.setTimeout(msecs, common.mustCall(() => {
-    res.end();
-  }));
+  req.setTimeout(
+    msecs,
+    common.mustCall(() => {
+      res.end();
+    })
+  );
   req.on('timeout', common.mustCall());
-  res.on('finish', common.mustCall(() => {
-    req.setTimeout(msecs, common.mustNotCall());
-    process.nextTick(() => {
+  res.on(
+    'finish',
+    common.mustCall(() => {
       req.setTimeout(msecs, common.mustNotCall());
-      server.close();
-    });
-  }));
+      process.nextTick(() => {
+        req.setTimeout(msecs, common.mustNotCall());
+        server.close();
+      });
+    })
+  );
 });
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
-  const req = client.request({
-    ':path': '/',
-    ':method': 'GET',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  });
-  req.on('end', common.mustCall(() => {
-    client.close();
-  }));
-  req.resume();
-  req.end();
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
+    const req = client.request({
+      ':path': '/',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    });
+    req.on(
+      'end',
+      common.mustCall(() => {
+        client.close();
+      })
+    );
+    req.resume();
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverrequest-trailers.js b/test/parallel/test-http2-compat-serverrequest-trailers.js
index 735ff1345e1a39..feb66d39e8da58 100644
--- a/test/parallel/test-http2-compat-serverrequest-trailers.js
+++ b/test/parallel/test-http2-compat-serverrequest-trailers.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -14,60 +13,78 @@ const expectedTrailers = {
 };
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    let data = '';
-    request.setEncoding('utf8');
-    request.on('data', common.mustCallAtLeast((chunk) => data += chunk));
-    request.on('end', common.mustCall(() => {
-      const trailers = request.trailers;
-      for (const [name, value] of Object.entries(expectedTrailers)) {
-        assert.strictEqual(trailers[name], value);
-      }
-      assert.deepStrictEqual([
-        'x-foo',
-        'xOxOxOx',
-        'x-foo',
-        'OxOxOxO',
-        'x-foo',
-        'xOxOxOx',
-        'x-foo',
-        'OxOxOxO',
-        'x-foo-test',
-        'test, test'
-      ], request.rawTrailers);
-      assert.strictEqual(data, 'test\ntest');
-      response.end();
-    }));
-  }));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        let data = '';
+        request.setEncoding('utf8');
+        request.on('data', common.mustCallAtLeast((chunk) => (data += chunk)));
+        request.on(
+          'end',
+          common.mustCall(() => {
+            const trailers = request.trailers;
+            for (const [name, value] of Object.entries(expectedTrailers)) {
+              assert.strictEqual(trailers[name], value);
+            }
+            assert.deepStrictEqual(
+              [
+                'x-foo',
+                'xOxOxOx',
+                'x-foo',
+                'OxOxOxO',
+                'x-foo',
+                'xOxOxOx',
+                'x-foo',
+                'OxOxOxO',
+                'x-foo-test',
+                'test, test'
+              ],
+              request.rawTrailers
+            );
+            assert.strictEqual(data, 'test\ntest');
+            response.end();
+          })
+        );
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/foobar',
-      ':method': 'POST',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers, { waitForTrailers: true });
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/foobar',
+          ':method': 'POST',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers, { waitForTrailers: true });
 
-    request.on('wantTrailers', () => {
-      request.sendTrailers({
-        'x-fOo': 'xOxOxOx',
-        'x-foO': 'OxOxOxO',
-        'X-fOo': 'xOxOxOx',
-        'X-foO': 'OxOxOxO',
-        'x-foo-test': 'test, test'
-      });
-    });
+        request.on('wantTrailers', () => {
+          request.sendTrailers({
+            'x-fOo': 'xOxOxOx',
+            'x-foO': 'OxOxOxO',
+            'X-fOo': 'xOxOxOx',
+            'X-foO': 'OxOxOxO',
+            'x-foo-test': 'test, test'
+          });
+        });
 
-    request.resume();
-    request.on('end', common.mustCall(function() {
-      server.close();
-      client.close();
-    }));
-    request.write('test\n');
-    request.end('test');
-  }));
-}));
+        request.resume();
+        request.on(
+          'end',
+          common.mustCall(function() {
+            server.close();
+            client.close();
+          })
+        );
+        request.write('test\n');
+        request.end('test');
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverrequest.js b/test/parallel/test-http2-compat-serverrequest.js
index d92da61d943cb7..a19ee9d89b3ed0 100644
--- a/test/parallel/test-http2-compat-serverrequest.js
+++ b/test/parallel/test-http2-compat-serverrequest.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const net = require('net');
@@ -10,45 +9,60 @@ const net = require('net');
 // Http2ServerRequest should expose convenience properties
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    const expected = {
-      version: '2.0',
-      httpVersionMajor: 2,
-      httpVersionMinor: 0
-    };
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        const expected = {
+          version: '2.0',
+          httpVersionMajor: 2,
+          httpVersionMinor: 0
+        };
 
-    assert.strictEqual(request.httpVersion, expected.version);
-    assert.strictEqual(request.httpVersionMajor, expected.httpVersionMajor);
-    assert.strictEqual(request.httpVersionMinor, expected.httpVersionMinor);
+        assert.strictEqual(request.httpVersion, expected.version);
+        assert.strictEqual(request.httpVersionMajor, expected.httpVersionMajor);
+        assert.strictEqual(request.httpVersionMinor, expected.httpVersionMinor);
 
-    assert.ok(request.socket instanceof net.Socket);
-    assert.ok(request.connection instanceof net.Socket);
-    assert.strictEqual(request.socket, request.connection);
+        assert.ok(request.socket instanceof net.Socket);
+        assert.ok(request.connection instanceof net.Socket);
+        assert.strictEqual(request.socket, request.connection);
 
-    response.on('finish', common.mustCall(function() {
-      process.nextTick(() => {
-        assert.ok(request.socket);
-        server.close();
-      });
-    }));
-    response.end();
-  }));
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            process.nextTick(() => {
+              assert.ok(request.socket);
+              server.close();
+            });
+          })
+        );
+        response.end();
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/foobar',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/foobar',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-close.js b/test/parallel/test-http2-compat-serverresponse-close.js
index 0ff6bd3a83f600..1128836ac48ad0 100644
--- a/test/parallel/test-http2-compat-serverresponse-close.js
+++ b/test/parallel/test-http2-compat-serverresponse-close.js
@@ -2,31 +2,38 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 // Server request and response should receive close event
 // if the connection was terminated before response.end
 // could be called or flushed
 
-const server = h2.createServer(common.mustCall((req, res) => {
-  res.writeHead(200);
-  res.write('a');
+const server = h2.createServer(
+  common.mustCall((req, res) => {
+    res.writeHead(200);
+    res.write('a');
 
-  req.on('close', common.mustCall());
-  res.on('close', common.mustCall());
-  req.on('error', common.mustNotCall());
-}));
+    req.on('close', common.mustCall());
+    res.on('close', common.mustCall());
+    req.on('error', common.mustNotCall());
+  })
+);
 server.listen(0);
 
 server.on('listening', () => {
   const url = `http://localhost:${server.address().port}`;
-  const client = h2.connect(url, common.mustCall(() => {
-    const request = client.request();
-    request.on('data', common.mustCall(function(chunk) {
-      client.destroy();
-      server.close();
-    }));
-  }));
+  const client = h2.connect(
+    url,
+    common.mustCall(() => {
+      const request = client.request();
+      request.on(
+        'data',
+        common.mustCall(function(chunk) {
+          client.destroy();
+          server.close();
+        })
+      );
+    })
+  );
 });
diff --git a/test/parallel/test-http2-compat-serverresponse-createpushresponse.js b/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
index 1992d41af69a5d..7ef787e3b6f00d 100644
--- a/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
+++ b/test/parallel/test-http2-compat-serverresponse-createpushresponse.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -17,10 +16,14 @@ const server = h2.createServer((request, response) => {
 
   // callback must be specified (and be a function)
   common.expectsError(
-    () => response.createPushResponse({
-      ':path': '/pushed',
-      ':method': 'GET'
-    }, undefined),
+    () =>
+      response.createPushResponse(
+        {
+          ':path': '/pushed',
+          ':method': 'GET'
+        },
+        undefined
+      ),
     {
       code: 'ERR_INVALID_CALLBACK',
       type: TypeError,
@@ -29,74 +32,101 @@ const server = h2.createServer((request, response) => {
   );
 
   response.stream.on('close', () => {
-    response.createPushResponse({
-      ':path': '/pushed',
-      ':method': 'GET'
-    }, common.mustCall((error) => {
-      assert.strictEqual(error.code, 'ERR_HTTP2_INVALID_STREAM');
-    }));
+    response.createPushResponse(
+      {
+        ':path': '/pushed',
+        ':method': 'GET'
+      },
+      common.mustCall((error) => {
+        assert.strictEqual(error.code, 'ERR_HTTP2_INVALID_STREAM');
+      })
+    );
   });
 
-  response.createPushResponse({
-    ':path': '/pushed',
-    ':method': 'GET'
-  }, common.mustCall((error, push) => {
-    assert.ifError(error);
-    assert.strictEqual(push.stream.id % 2, 0);
-    push.end(pushExpect);
-    response.end();
-  }));
+  response.createPushResponse(
+    {
+      ':path': '/pushed',
+      ':method': 'GET'
+    },
+    common.mustCall((error, push) => {
+      assert.ifError(error);
+      assert.strictEqual(push.stream.id % 2, 0);
+      push.end(pushExpect);
+      response.end();
+    })
+  );
 });
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
 
-  const client = h2.connect(`http://localhost:${port}`, common.mustCall(() => {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-    };
+    const client = h2.connect(
+      `http://localhost:${port}`,
+      common.mustCall(() => {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET'
+        };
 
-    let remaining = 2;
-    function maybeClose() {
-      if (--remaining === 0) {
-        client.close();
-        server.close();
-      }
-    }
+        let remaining = 2;
+        function maybeClose() {
+          if (--remaining === 0) {
+            client.close();
+            server.close();
+          }
+        }
 
-    const req = client.request(headers);
+        const req = client.request(headers);
 
-    client.on('stream', common.mustCall((pushStream, headers) => {
-      assert.strictEqual(headers[':path'], '/pushed');
-      assert.strictEqual(headers[':method'], 'GET');
-      assert.strictEqual(headers[':scheme'], 'http');
-      assert.strictEqual(headers[':authority'], `localhost:${port}`);
+        client.on(
+          'stream',
+          common.mustCall((pushStream, headers) => {
+            assert.strictEqual(headers[':path'], '/pushed');
+            assert.strictEqual(headers[':method'], 'GET');
+            assert.strictEqual(headers[':scheme'], 'http');
+            assert.strictEqual(headers[':authority'], `localhost:${port}`);
 
-      let actual = '';
-      pushStream.on('push', common.mustCall((headers) => {
-        assert.strictEqual(headers[':status'], 200);
-        assert(headers.date);
-      }));
-      pushStream.setEncoding('utf8');
-      pushStream.on('data', (chunk) => actual += chunk);
-      pushStream.on('end', common.mustCall(() => {
-        assert.strictEqual(actual, pushExpect);
-        maybeClose();
-      }));
-    }));
+            let actual = '';
+            pushStream.on(
+              'push',
+              common.mustCall((headers) => {
+                assert.strictEqual(headers[':status'], 200);
+                assert(headers.date);
+              })
+            );
+            pushStream.setEncoding('utf8');
+            pushStream.on('data', (chunk) => (actual += chunk));
+            pushStream.on(
+              'end',
+              common.mustCall(() => {
+                assert.strictEqual(actual, pushExpect);
+                maybeClose();
+              })
+            );
+          })
+        );
 
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers[':status'], 200);
-      assert(headers.date);
-    }));
+        req.on(
+          'response',
+          common.mustCall((headers) => {
+            assert.strictEqual(headers[':status'], 200);
+            assert(headers.date);
+          })
+        );
 
-    let actual = '';
-    req.setEncoding('utf8');
-    req.on('data', (chunk) => actual += chunk);
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(actual, servExpect);
-      maybeClose();
-    }));
-  }));
-}));
+        let actual = '';
+        req.setEncoding('utf8');
+        req.on('data', (chunk) => (actual += chunk));
+        req.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(actual, servExpect);
+            maybeClose();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-destroy.js b/test/parallel/test-http2-compat-serverresponse-destroy.js
index 9082ec2ab8e931..bb516f8689e652 100644
--- a/test/parallel/test-http2-compat-serverresponse-destroy.js
+++ b/test/parallel/test-http2-compat-serverresponse-destroy.js
@@ -1,82 +1,92 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
 
 // Check that destroying the Http2ServerResponse stream produces
 // the expected result.
 
-const errors = [
-  'test-error',
-  Error('test')
-];
+const errors = ['test-error', Error('test')];
 let nextError;
 
-const server = http2.createServer(common.mustCall((req, res) => {
-  req.on('error', common.mustNotCall());
-  res.on('error', common.mustNotCall());
+const server = http2.createServer(
+  common.mustCall((req, res) => {
+    req.on('error', common.mustNotCall());
+    res.on('error', common.mustNotCall());
+
+    res.on(
+      'finish',
+      common.mustCall(() => {
+        res.destroy(nextError);
+        process.nextTick(() => {
+          res.destroy(nextError);
+        });
+      })
+    );
+
+    if (req.url !== '/') {
+      nextError = errors.shift();
+    }
 
-  res.on('finish', common.mustCall(() => {
     res.destroy(nextError);
-    process.nextTick(() => {
-      res.destroy(nextError);
-    });
-  }));
-
-  if (req.url !== '/') {
-    nextError = errors.shift();
-  }
+  }, 3)
+);
 
-  res.destroy(nextError);
-}, 3));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-
-  const countdown = new Countdown(3, () => {
-    server.close();
-    client.close();
-  });
+    const countdown = new Countdown(3, () => {
+      server.close();
+      client.close();
+    });
 
-  {
-    const req = client.request();
-    req.on('response', common.mustNotCall());
-    req.on('error', common.mustNotCall());
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(() => countdown.dec()));
-    req.resume();
-  }
-
-  {
-    const req = client.request({ ':path': '/error' });
-
-    req.on('response', common.mustNotCall());
-    req.on('error', common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
-    }));
-    req.on('close', common.mustCall(() => countdown.dec()));
-
-    req.resume();
-    req.on('end', common.mustCall());
-  }
-
-  {
-    const req = client.request({ ':path': '/error' });
-
-    req.on('response', common.mustNotCall());
-    req.on('error', common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
-    }));
-    req.on('close', common.mustCall(() => countdown.dec()));
-
-    req.resume();
-    req.on('end', common.mustCall());
-  }
-}));
+    {
+      const req = client.request();
+      req.on('response', common.mustNotCall());
+      req.on('error', common.mustNotCall());
+      req.on('end', common.mustCall());
+      req.on('close', common.mustCall(() => countdown.dec()));
+      req.resume();
+    }
+
+    {
+      const req = client.request({ ':path': '/error' });
+
+      req.on('response', common.mustNotCall());
+      req.on(
+        'error',
+        common.expectsError({
+          code: 'ERR_HTTP2_STREAM_ERROR',
+          type: Error,
+          message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
+        })
+      );
+      req.on('close', common.mustCall(() => countdown.dec()));
+
+      req.resume();
+      req.on('end', common.mustCall());
+    }
+
+    {
+      const req = client.request({ ':path': '/error' });
+
+      req.on('response', common.mustNotCall());
+      req.on(
+        'error',
+        common.expectsError({
+          code: 'ERR_HTTP2_STREAM_ERROR',
+          type: Error,
+          message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
+        })
+      );
+      req.on('close', common.mustCall(() => countdown.dec()));
+
+      req.resume();
+      req.on('end', common.mustCall());
+    }
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-drain.js b/test/parallel/test-http2-compat-serverresponse-drain.js
index 7ccbb1f4d21209..07b454986b255f 100644
--- a/test/parallel/test-http2-compat-serverresponse-drain.js
+++ b/test/parallel/test-http2-compat-serverresponse-drain.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -12,32 +11,41 @@ const testString = 'tests';
 
 const server = h2.createServer();
 
-server.on('request', common.mustCall((req, res) => {
-  res.stream._writableState.highWaterMark = testString.length;
-  assert.strictEqual(res.write(testString), false);
-  res.on('drain', common.mustCall(() => res.end(testString)));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-
-  const client = h2.connect(`http://localhost:${port}`);
-  const request = client.request({
-    ':path': '/foobar',
-    ':method': 'POST',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  });
-  request.resume();
-  request.end();
-
-  let data = '';
-  request.setEncoding('utf8');
-  request.on('data', (chunk) => (data += chunk));
-
-  request.on('end', common.mustCall(function() {
-    assert.strictEqual(data, testString.repeat(2));
-    client.close();
-    server.close();
-  }));
-}));
+server.on(
+  'request',
+  common.mustCall((req, res) => {
+    res.stream._writableState.highWaterMark = testString.length;
+    assert.strictEqual(res.write(testString), false);
+    res.on('drain', common.mustCall(() => res.end(testString)));
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+
+    const client = h2.connect(`http://localhost:${port}`);
+    const request = client.request({
+      ':path': '/foobar',
+      ':method': 'POST',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    });
+    request.resume();
+    request.end();
+
+    let data = '';
+    request.setEncoding('utf8');
+    request.on('data', (chunk) => (data += chunk));
+
+    request.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(data, testString.repeat(2));
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js b/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js
index ce8cbe600c8bd8..67dd6a480c0e91 100644
--- a/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js
+++ b/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 // This test case ensures that calling of res.end after sending
@@ -18,30 +17,37 @@ const {
 const statusWithoutBody = [
   HTTP_STATUS_NO_CONTENT,
   HTTP_STATUS_RESET_CONTENT,
-  HTTP_STATUS_NOT_MODIFIED,
+  HTTP_STATUS_NOT_MODIFIED
 ];
 const STATUS_CODES_COUNT = statusWithoutBody.length;
 
-const server = h2.createServer(common.mustCall(function(req, res) {
-  res.writeHead(statusWithoutBody.pop());
-  res.end();
-}, STATUS_CODES_COUNT));
-
-server.listen(0, common.mustCall(function() {
-  const url = `http://localhost:${server.address().port}`;
-  const client = h2.connect(url, common.mustCall(() => {
-    let responseCount = 0;
-    const closeAfterResponse = () => {
-      if (STATUS_CODES_COUNT === ++responseCount) {
-        client.destroy();
-        server.close();
-      }
-    };
-
-    for (let i = 0; i < STATUS_CODES_COUNT; i++) {
-      const request = client.request();
-      request.on('response', common.mustCall(closeAfterResponse));
-    }
-
-  }));
-}));
+const server = h2.createServer(
+  common.mustCall(function(req, res) {
+    res.writeHead(statusWithoutBody.pop());
+    res.end();
+  }, STATUS_CODES_COUNT)
+);
+
+server.listen(
+  0,
+  common.mustCall(function() {
+    const url = `http://localhost:${server.address().port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(() => {
+        let responseCount = 0;
+        const closeAfterResponse = () => {
+          if (STATUS_CODES_COUNT === ++responseCount) {
+            client.destroy();
+            server.close();
+          }
+        };
+
+        for (let i = 0; i < STATUS_CODES_COUNT; i++) {
+          const request = client.request();
+          request.on('response', common.mustCall(closeAfterResponse));
+        }
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-end.js b/test/parallel/test-http2-compat-serverresponse-end.js
index 0e846a5948e3cc..340bee584ae21f 100644
--- a/test/parallel/test-http2-compat-serverresponse-end.js
+++ b/test/parallel/test-http2-compat-serverresponse-end.js
@@ -7,319 +7,449 @@ const {
   platformTimeout,
   skip
 } = require('../common');
-if (!hasCrypto)
-  skip('missing crypto');
+if (!hasCrypto) skip('missing crypto');
 const { strictEqual } = require('assert');
 const {
   createServer,
   connect,
-  constants: {
-    HTTP2_HEADER_STATUS,
-    HTTP_STATUS_OK
-  }
+  constants: { HTTP2_HEADER_STATUS, HTTP_STATUS_OK }
 } = require('http2');
 
 {
   // Http2ServerResponse.end accepts chunk, encoding, cb as args
   // It may be invoked repeatedly without throwing errors
   // but callback will only be called once
-  const server = createServer(mustCall((request, response) => {
-    response.end('end', 'utf8', mustCall(() => {
+  const server = createServer(
+    mustCall((request, response) => {
+      response.end(
+        'end',
+        'utf8',
+        mustCall(() => {
+          response.end(mustNotCall());
+          process.nextTick(() => {
+            response.end(mustNotCall());
+            server.close();
+          });
+        })
+      );
+      response.on(
+        'finish',
+        mustCall(() => {
+          response.end(mustNotCall());
+        })
+      );
       response.end(mustNotCall());
-      process.nextTick(() => {
-        response.end(mustNotCall());
-        server.close();
-      });
-    }));
-    response.on('finish', mustCall(() => {
-      response.end(mustNotCall());
-    }));
-    response.end(mustNotCall());
-  }));
-  server.listen(0, mustCall(() => {
-    let data = '';
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'GET',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.setEncoding('utf8');
-      request.on('data', (chunk) => (data += chunk));
-      request.on('end', mustCall(() => {
-        strictEqual(data, 'end');
-        client.close();
-      }));
-      request.end();
-      request.resume();
-    }));
-  }));
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      let data = '';
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'GET',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.setEncoding('utf8');
+          request.on('data', (chunk) => (data += chunk));
+          request.on(
+            'end',
+            mustCall(() => {
+              strictEqual(data, 'end');
+              client.close();
+            })
+          );
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
 
 {
   // Http2ServerResponse.end can omit encoding arg, sets it to utf-8
-  const server = createServer(mustCall((request, response) => {
-    response.end('test\uD83D\uDE00', mustCall(() => {
-      server.close();
-    }));
-  }));
-  server.listen(0, mustCall(() => {
-    let data = '';
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'GET',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.setEncoding('utf8');
-      request.on('data', (chunk) => (data += chunk));
-      request.on('end', mustCall(() => {
-        strictEqual(data, 'test\uD83D\uDE00');
-        client.close();
-      }));
-      request.end();
-      request.resume();
-    }));
-  }));
+  const server = createServer(
+    mustCall((request, response) => {
+      response.end(
+        'test\uD83D\uDE00',
+        mustCall(() => {
+          server.close();
+        })
+      );
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      let data = '';
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'GET',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.setEncoding('utf8');
+          request.on('data', (chunk) => (data += chunk));
+          request.on(
+            'end',
+            mustCall(() => {
+              strictEqual(data, 'test\uD83D\uDE00');
+              client.close();
+            })
+          );
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
 
 {
   // Http2ServerResponse.end can omit chunk & encoding args
-  const server = createServer(mustCall((request, response) => {
-    response.end(mustCall(() => {
-      server.close();
-    }));
-  }));
-  server.listen(0, mustCall(() => {
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'GET',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.on('data', mustNotCall());
-      request.on('end', mustCall(() => client.close()));
-      request.end();
-      request.resume();
-    }));
-  }));
+  const server = createServer(
+    mustCall((request, response) => {
+      response.end(
+        mustCall(() => {
+          server.close();
+        })
+      );
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'GET',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on('data', mustNotCall());
+          request.on('end', mustCall(() => client.close()));
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
 
 {
   // Http2ServerResponse.end is necessary on HEAD requests in compat
   // for http1 compatibility
-  const server = createServer(mustCall((request, response) => {
-    strictEqual(response.finished, true);
-    response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
-    response.end('data', mustCall());
-  }));
-  server.listen(0, mustCall(() => {
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'HEAD',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.on('response', mustCall((headers, flags) => {
-        strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
-        strictEqual(flags, 5); // the end of stream flag is set
-        strictEqual(headers.foo, 'bar');
-      }));
-      request.on('data', mustNotCall());
-      request.on('end', mustCall(() => {
-        client.close();
-        server.close();
-      }));
-      request.end();
-      request.resume();
-    }));
-  }));
+  const server = createServer(
+    mustCall((request, response) => {
+      strictEqual(response.finished, true);
+      response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
+      response.end('data', mustCall());
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'HEAD',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on(
+            'response',
+            mustCall((headers, flags) => {
+              strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
+              strictEqual(flags, 5); // the end of stream flag is set
+              strictEqual(headers.foo, 'bar');
+            })
+          );
+          request.on('data', mustNotCall());
+          request.on(
+            'end',
+            mustCall(() => {
+              client.close();
+              server.close();
+            })
+          );
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
 
 {
   // .end should trigger 'end' event on request if user did not attempt
   // to read from the request
-  const server = createServer(mustCall((request, response) => {
-    request.on('end', mustCall());
-    response.end();
-  }));
-  server.listen(0, mustCall(() => {
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'HEAD',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.on('data', mustNotCall());
-      request.on('end', mustCall(() => {
-        client.close();
-        server.close();
-      }));
-      request.end();
-      request.resume();
-    }));
-  }));
+  const server = createServer(
+    mustCall((request, response) => {
+      request.on('end', mustCall());
+      response.end();
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'HEAD',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on('data', mustNotCall());
+          request.on(
+            'end',
+            mustCall(() => {
+              client.close();
+              server.close();
+            })
+          );
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
 
-
 {
   // Should be able to call .end with cb from stream 'close'
-  const server = createServer(mustCall((request, response) => {
-    response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
-    response.stream.on('close', mustCall(() => {
-      response.end(mustCall());
-    }));
-  }));
-  server.listen(0, mustCall(() => {
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'HEAD',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.on('response', mustCall((headers, flags) => {
-        strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
-        strictEqual(flags, 5); // the end of stream flag is set
-        strictEqual(headers.foo, 'bar');
-      }));
-      request.on('data', mustNotCall());
-      request.on('end', mustCall(() => {
-        client.close();
-        server.close();
-      }));
-      request.end();
-      request.resume();
-    }));
-  }));
+  const server = createServer(
+    mustCall((request, response) => {
+      response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
+      response.stream.on(
+        'close',
+        mustCall(() => {
+          response.end(mustCall());
+        })
+      );
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'HEAD',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on(
+            'response',
+            mustCall((headers, flags) => {
+              strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
+              strictEqual(flags, 5); // the end of stream flag is set
+              strictEqual(headers.foo, 'bar');
+            })
+          );
+          request.on('data', mustNotCall());
+          request.on(
+            'end',
+            mustCall(() => {
+              client.close();
+              server.close();
+            })
+          );
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
 
 {
   // Should be able to respond to HEAD request after timeout
-  const server = createServer(mustCall((request, response) => {
-    setTimeout(mustCall(() => {
-      response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
-      response.end('data', mustCall());
-    }), platformTimeout(10));
-  }));
-  server.listen(0, mustCall(() => {
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'HEAD',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.on('response', mustCall((headers, flags) => {
-        strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
-        strictEqual(flags, 5); // the end of stream flag is set
-        strictEqual(headers.foo, 'bar');
-      }));
-      request.on('data', mustNotCall());
-      request.on('end', mustCall(() => {
-        client.close();
-        server.close();
-      }));
-      request.end();
-      request.resume();
-    }));
-  }));
+  const server = createServer(
+    mustCall((request, response) => {
+      setTimeout(
+        mustCall(() => {
+          response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
+          response.end('data', mustCall());
+        }),
+        platformTimeout(10)
+      );
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'HEAD',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on(
+            'response',
+            mustCall((headers, flags) => {
+              strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
+              strictEqual(flags, 5); // the end of stream flag is set
+              strictEqual(headers.foo, 'bar');
+            })
+          );
+          request.on('data', mustNotCall());
+          request.on(
+            'end',
+            mustCall(() => {
+              client.close();
+              server.close();
+            })
+          );
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
 
 {
   // finish should only trigger after 'end' is called
-  const server = createServer(mustCall((request, response) => {
-    let finished = false;
-    response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
-    response.on('finish', mustCall(() => {
-      finished = false;
-    }));
-    response.end('data', mustCall(() => {
-      strictEqual(finished, false);
-      response.end('data', mustNotCall());
-    }));
-  }));
-  server.listen(0, mustCall(() => {
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'HEAD',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.on('response', mustCall((headers, flags) => {
-        strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
-        strictEqual(flags, 5); // the end of stream flag is set
-        strictEqual(headers.foo, 'bar');
-      }));
-      request.on('data', mustNotCall());
-      request.on('end', mustCall(() => {
-        client.close();
-        server.close();
-      }));
-      request.end();
-      request.resume();
-    }));
-  }));
+  const server = createServer(
+    mustCall((request, response) => {
+      let finished = false;
+      response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
+      response.on(
+        'finish',
+        mustCall(() => {
+          finished = false;
+        })
+      );
+      response.end(
+        'data',
+        mustCall(() => {
+          strictEqual(finished, false);
+          response.end('data', mustNotCall());
+        })
+      );
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'HEAD',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on(
+            'response',
+            mustCall((headers, flags) => {
+              strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
+              strictEqual(flags, 5); // the end of stream flag is set
+              strictEqual(headers.foo, 'bar');
+            })
+          );
+          request.on('data', mustNotCall());
+          request.on(
+            'end',
+            mustCall(() => {
+              client.close();
+              server.close();
+            })
+          );
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
 
 {
   // Should be able to respond to HEAD with just .end
-  const server = createServer(mustCall((request, response) => {
-    response.end('data', mustCall());
-    response.end(mustNotCall());
-  }));
-  server.listen(0, mustCall(() => {
-    const { port } = server.address();
-    const url = `http://localhost:${port}`;
-    const client = connect(url, mustCall(() => {
-      const headers = {
-        ':path': '/',
-        ':method': 'HEAD',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`
-      };
-      const request = client.request(headers);
-      request.on('response', mustCall((headers, flags) => {
-        strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
-        strictEqual(flags, 5); // the end of stream flag is set
-      }));
-      request.on('data', mustNotCall());
-      request.on('end', mustCall(() => {
-        client.close();
-        server.close();
-      }));
-      request.end();
-      request.resume();
-    }));
-  }));
+  const server = createServer(
+    mustCall((request, response) => {
+      response.end('data', mustCall());
+      response.end(mustNotCall());
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      const { port } = server.address();
+      const url = `http://localhost:${port}`;
+      const client = connect(
+        url,
+        mustCall(() => {
+          const headers = {
+            ':path': '/',
+            ':method': 'HEAD',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on(
+            'response',
+            mustCall((headers, flags) => {
+              strictEqual(headers[HTTP2_HEADER_STATUS], HTTP_STATUS_OK);
+              strictEqual(flags, 5); // the end of stream flag is set
+            })
+          );
+          request.on('data', mustNotCall());
+          request.on(
+            'end',
+            mustCall(() => {
+              client.close();
+              server.close();
+            })
+          );
+          request.end();
+          request.resume();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http2-compat-serverresponse-finished.js b/test/parallel/test-http2-compat-serverresponse-finished.js
index 4da592a5b354b0..ff51b5350cc04f 100644
--- a/test/parallel/test-http2-compat-serverresponse-finished.js
+++ b/test/parallel/test-http2-compat-serverresponse-finished.js
@@ -1,47 +1,63 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const net = require('net');
 
 // Http2ServerResponse.finished
 const server = h2.createServer();
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  server.once('request', common.mustCall((request, response) => {
-    assert.ok(response.socket instanceof net.Socket);
-    assert.ok(response.connection instanceof net.Socket);
-    assert.strictEqual(response.socket, response.connection);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall((request, response) => {
+        assert.ok(response.socket instanceof net.Socket);
+        assert.ok(response.connection instanceof net.Socket);
+        assert.strictEqual(response.socket, response.connection);
 
-    response.on('finish', common.mustCall(() => {
-      assert.strictEqual(response.socket, undefined);
-      assert.strictEqual(response.connection, undefined);
-      process.nextTick(common.mustCall(() => {
-        assert.ok(response.stream);
-        server.close();
-      }));
-    }));
-    assert.strictEqual(response.finished, false);
-    response.end();
-    assert.strictEqual(response.finished, true);
-  }));
+        response.on(
+          'finish',
+          common.mustCall(() => {
+            assert.strictEqual(response.socket, undefined);
+            assert.strictEqual(response.connection, undefined);
+            process.nextTick(
+              common.mustCall(() => {
+                assert.ok(response.stream);
+                server.close();
+              })
+            );
+          })
+        );
+        assert.strictEqual(response.finished, false);
+        response.end();
+        assert.strictEqual(response.finished, true);
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(() => {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('end', common.mustCall(() => {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(() => {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'end',
+          common.mustCall(() => {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-flushheaders.js b/test/parallel/test-http2-compat-serverresponse-flushheaders.js
index d155b07863d26c..f08869dfdcea23 100644
--- a/test/parallel/test-http2-compat-serverresponse-flushheaders.js
+++ b/test/parallel/test-http2-compat-serverresponse-flushheaders.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -11,49 +10,70 @@ const h2 = require('http2');
 let serverResponse;
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    assert.strictEqual(response.headersSent, false);
-    assert.strictEqual(response._header, false); // alias for headersSent
-    response.flushHeaders();
-    assert.strictEqual(response.headersSent, true);
-    assert.strictEqual(response._header, true);
-    response.flushHeaders(); // Idempotent
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        assert.strictEqual(response.headersSent, false);
+        assert.strictEqual(response._header, false); // alias for headersSent
+        response.flushHeaders();
+        assert.strictEqual(response.headersSent, true);
+        assert.strictEqual(response._header, true);
+        response.flushHeaders(); // Idempotent
 
-    common.expectsError(() => {
-      response.writeHead(400, { 'foo-bar': 'abc123' });
-    }, {
-      code: 'ERR_HTTP2_HEADERS_SENT'
-    });
+        common.expectsError(
+          () => {
+            response.writeHead(400, { 'foo-bar': 'abc123' });
+          },
+          {
+            code: 'ERR_HTTP2_HEADERS_SENT'
+          }
+        );
 
-    response.on('finish', common.mustCall(function() {
-      server.close();
-      process.nextTick(() => {
-        response.flushHeaders(); // Idempotent
-      });
-    }));
-    serverResponse = response;
-  }));
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            server.close();
+            process.nextTick(() => {
+              response.flushHeaders(); // Idempotent
+            });
+          })
+        );
+        serverResponse = response;
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('response', common.mustCall(function(headers, flags) {
-      assert.strictEqual(headers['foo-bar'], undefined);
-      assert.strictEqual(headers[':status'], 200);
-      serverResponse.end();
-    }, 1));
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'response',
+          common.mustCall(function(headers, flags) {
+            assert.strictEqual(headers['foo-bar'], undefined);
+            assert.strictEqual(headers[':status'], 200);
+            serverResponse.end();
+          }, 1)
+        );
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-headers-after-destroy.js b/test/parallel/test-http2-compat-serverresponse-headers-after-destroy.js
index 206bd1c9d43e06..acde0fe156d8bb 100644
--- a/test/parallel/test-http2-compat-serverresponse-headers-after-destroy.js
+++ b/test/parallel/test-http2-compat-serverresponse-headers-after-destroy.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -10,38 +9,53 @@ const h2 = require('http2');
 // any errors if the stream was destroyed before headers were sent
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    response.on('finish', common.mustCall(() => {
-      assert.strictEqual(response.headersSent, false);
-      response.setHeader('test', 'value');
-      response.removeHeader('test', 'value');
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        response.on(
+          'finish',
+          common.mustCall(() => {
+            assert.strictEqual(response.headersSent, false);
+            response.setHeader('test', 'value');
+            response.removeHeader('test', 'value');
 
-      process.nextTick(() => {
-        response.setHeader('test', 'value');
-        response.removeHeader('test', 'value');
+            process.nextTick(() => {
+              response.setHeader('test', 'value');
+              response.removeHeader('test', 'value');
 
-        server.close();
-      });
-    }));
+              server.close();
+            });
+          })
+        );
 
-    response.destroy();
-  }));
+        response.destroy();
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-headers.js b/test/parallel/test-http2-compat-serverresponse-headers.js
index 94f1d19373742c..87aabd57046387 100644
--- a/test/parallel/test-http2-compat-serverresponse-headers.js
+++ b/test/parallel/test-http2-compat-serverresponse-headers.js
@@ -1,175 +1,182 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 // Http2ServerResponse should support checking and reading custom headers
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    const real = 'foo-bar';
-    const fake = 'bar-foo';
-    const denormalised = ` ${real.toUpperCase()}\n\t`;
-    const expectedValue = 'abc123';
-
-    response.setHeader(real, expectedValue);
-
-    assert.strictEqual(response.hasHeader(real), true);
-    assert.strictEqual(response.hasHeader(fake), false);
-    assert.strictEqual(response.hasHeader(denormalised), true);
-    assert.strictEqual(response.getHeader(real), expectedValue);
-    assert.strictEqual(response.getHeader(denormalised), expectedValue);
-    assert.strictEqual(response.getHeader(fake), undefined);
-
-    response.removeHeader(fake);
-    assert.strictEqual(response.hasHeader(fake), false);
-
-    response.setHeader(real, expectedValue);
-    assert.strictEqual(response.getHeader(real), expectedValue);
-    assert.strictEqual(response.hasHeader(real), true);
-    response.removeHeader(real);
-    assert.strictEqual(response.hasHeader(real), false);
-
-    response.setHeader(denormalised, expectedValue);
-    assert.strictEqual(response.getHeader(denormalised), expectedValue);
-    assert.strictEqual(response.hasHeader(denormalised), true);
-    response.removeHeader(denormalised);
-    assert.strictEqual(response.hasHeader(denormalised), false);
-
-    ['hasHeader', 'getHeader', 'removeHeader'].forEach((fnName) => {
-      assert.throws(
-        () => response[fnName](),
-        {
-          code: 'ERR_INVALID_ARG_TYPE',
-          name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-          message: 'The "name" argument must be of type string. Received ' +
-                   'type undefined'
-        }
-      );
-    });
-
-    [
-      ':status',
-      ':method',
-      ':path',
-      ':authority',
-      ':scheme'
-    ].forEach((header) => common.expectsError(
-      () => response.setHeader(header, 'foobar'),
-      {
-        code: 'ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED',
-        type: TypeError,
-        message: 'Cannot set HTTP/2 pseudo-headers'
-      })
-    );
-    common.expectsError(function() {
-      response.setHeader(real, null);
-    }, {
-      code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
-      type: TypeError,
-      message: 'Invalid value "null" for header "foo-bar"'
-    });
-    common.expectsError(function() {
-      response.setHeader(real, undefined);
-    }, {
-      code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
-      type: TypeError,
-      message: 'Invalid value "undefined" for header "foo-bar"'
-    });
-    common.expectsError(
-      () => response.setHeader(), // Header name undefined
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        type: TypeError,
-        message: 'The "name" argument must be of type string. Received type ' +
-                 'undefined'
-      }
-    );
-    common.expectsError(
-      () => response.setHeader(''),
-      {
-        code: 'ERR_INVALID_HTTP_TOKEN',
-        type: TypeError,
-        message: 'Header name must be a valid HTTP token [""]'
-      }
-    );
-
-    response.setHeader(real, expectedValue);
-    const expectedHeaderNames = [real];
-    assert.deepStrictEqual(response.getHeaderNames(), expectedHeaderNames);
-    const expectedHeaders = { [real]: expectedValue };
-    assert.deepStrictEqual(response.getHeaders(), expectedHeaders);
-
-    response.getHeaders()[fake] = fake;
-    assert.strictEqual(response.hasHeader(fake), false);
-
-    assert.strictEqual(response.sendDate, true);
-    response.sendDate = false;
-    assert.strictEqual(response.sendDate, false);
-
-    response.on('finish', common.mustCall(function() {
-      assert.strictEqual(response.headersSent, true);
-
-      common.expectsError(
-        () => response.setHeader(real, expectedValue),
-        {
-          code: 'ERR_HTTP2_HEADERS_SENT',
-          type: Error,
-          message: 'Response has already been initiated.'
-        }
-      );
-      common.expectsError(
-        () => response.removeHeader(real, expectedValue),
-        {
-          code: 'ERR_HTTP2_HEADERS_SENT',
-          type: Error,
-          message: 'Response has already been initiated.'
-        }
-      );
-
-      process.nextTick(() => {
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        const real = 'foo-bar';
+        const fake = 'bar-foo';
+        const denormalised = ` ${real.toUpperCase()}\n\t`;
+        const expectedValue = 'abc123';
+
+        response.setHeader(real, expectedValue);
+
+        assert.strictEqual(response.hasHeader(real), true);
+        assert.strictEqual(response.hasHeader(fake), false);
+        assert.strictEqual(response.hasHeader(denormalised), true);
+        assert.strictEqual(response.getHeader(real), expectedValue);
+        assert.strictEqual(response.getHeader(denormalised), expectedValue);
+        assert.strictEqual(response.getHeader(fake), undefined);
+
+        response.removeHeader(fake);
+        assert.strictEqual(response.hasHeader(fake), false);
+
+        response.setHeader(real, expectedValue);
+        assert.strictEqual(response.getHeader(real), expectedValue);
+        assert.strictEqual(response.hasHeader(real), true);
+        response.removeHeader(real);
+        assert.strictEqual(response.hasHeader(real), false);
+
+        response.setHeader(denormalised, expectedValue);
+        assert.strictEqual(response.getHeader(denormalised), expectedValue);
+        assert.strictEqual(response.hasHeader(denormalised), true);
+        response.removeHeader(denormalised);
+        assert.strictEqual(response.hasHeader(denormalised), false);
+
+        ['hasHeader', 'getHeader', 'removeHeader'].forEach((fnName) => {
+          assert.throws(() => response[fnName](), {
+            code: 'ERR_INVALID_ARG_TYPE',
+            name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+            message:
+              'The "name" argument must be of type string. Received ' +
+              'type undefined'
+          });
+        });
+
+        [':status', ':method', ':path', ':authority', ':scheme'].forEach(
+          (header) =>
+            common.expectsError(() => response.setHeader(header, 'foobar'), {
+              code: 'ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED',
+              type: TypeError,
+              message: 'Cannot set HTTP/2 pseudo-headers'
+            })
+        );
+        common.expectsError(
+          function() {
+            response.setHeader(real, null);
+          },
+          {
+            code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
+            type: TypeError,
+            message: 'Invalid value "null" for header "foo-bar"'
+          }
+        );
         common.expectsError(
-          () => response.setHeader(real, expectedValue),
+          function() {
+            response.setHeader(real, undefined);
+          },
           {
-            code: 'ERR_HTTP2_HEADERS_SENT',
-            type: Error,
-            message: 'Response has already been initiated.'
+            code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
+            type: TypeError,
+            message: 'Invalid value "undefined" for header "foo-bar"'
           }
         );
         common.expectsError(
-          () => response.removeHeader(real, expectedValue),
+          () => response.setHeader(), // Header name undefined
           {
-            code: 'ERR_HTTP2_HEADERS_SENT',
-            type: Error,
-            message: 'Response has already been initiated.'
+            code: 'ERR_INVALID_ARG_TYPE',
+            type: TypeError,
+            message:
+              'The "name" argument must be of type string. Received type ' +
+              'undefined'
           }
         );
+        common.expectsError(() => response.setHeader(''), {
+          code: 'ERR_INVALID_HTTP_TOKEN',
+          type: TypeError,
+          message: 'Header name must be a valid HTTP token [""]'
+        });
+
+        response.setHeader(real, expectedValue);
+        const expectedHeaderNames = [real];
+        assert.deepStrictEqual(response.getHeaderNames(), expectedHeaderNames);
+        const expectedHeaders = { [real]: expectedValue };
+        assert.deepStrictEqual(response.getHeaders(), expectedHeaders);
+
+        response.getHeaders()[fake] = fake;
+        assert.strictEqual(response.hasHeader(fake), false);
+
+        assert.strictEqual(response.sendDate, true);
+        response.sendDate = false;
+        assert.strictEqual(response.sendDate, false);
+
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            assert.strictEqual(response.headersSent, true);
+
+            common.expectsError(() => response.setHeader(real, expectedValue), {
+              code: 'ERR_HTTP2_HEADERS_SENT',
+              type: Error,
+              message: 'Response has already been initiated.'
+            });
+            common.expectsError(
+              () => response.removeHeader(real, expectedValue),
+              {
+                code: 'ERR_HTTP2_HEADERS_SENT',
+                type: Error,
+                message: 'Response has already been initiated.'
+              }
+            );
+
+            process.nextTick(() => {
+              common.expectsError(
+                () => response.setHeader(real, expectedValue),
+                {
+                  code: 'ERR_HTTP2_HEADERS_SENT',
+                  type: Error,
+                  message: 'Response has already been initiated.'
+                }
+              );
+              common.expectsError(
+                () => response.removeHeader(real, expectedValue),
+                {
+                  code: 'ERR_HTTP2_HEADERS_SENT',
+                  type: Error,
+                  message: 'Response has already been initiated.'
+                }
+              );
+
+              assert.strictEqual(response.headersSent, true);
+              server.close();
+            });
+          })
+        );
+        response.end();
+      })
+    );
 
-        assert.strictEqual(response.headersSent, true);
-        server.close();
-      });
-    }));
-    response.end();
-  }));
-
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-settimeout.js b/test/parallel/test-http2-compat-serverresponse-settimeout.js
index e24621ad097f3f..a166cff8d2bfe9 100644
--- a/test/parallel/test-http2-compat-serverresponse-settimeout.js
+++ b/test/parallel/test-http2-compat-serverresponse-settimeout.js
@@ -1,39 +1,50 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 const msecs = common.platformTimeout(1);
 const server = http2.createServer();
 
 server.on('request', (req, res) => {
-  res.setTimeout(msecs, common.mustCall(() => {
-    res.end();
-  }));
+  res.setTimeout(
+    msecs,
+    common.mustCall(() => {
+      res.end();
+    })
+  );
   res.on('timeout', common.mustCall());
-  res.on('finish', common.mustCall(() => {
-    res.setTimeout(msecs, common.mustNotCall());
-    process.nextTick(() => {
+  res.on(
+    'finish',
+    common.mustCall(() => {
       res.setTimeout(msecs, common.mustNotCall());
-      server.close();
-    });
-  }));
+      process.nextTick(() => {
+        res.setTimeout(msecs, common.mustNotCall());
+        server.close();
+      });
+    })
+  );
 });
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
-  const req = client.request({
-    ':path': '/',
-    ':method': 'GET',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  });
-  req.on('end', common.mustCall(() => {
-    client.close();
-  }));
-  req.resume();
-  req.end();
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
+    const req = client.request({
+      ':path': '/',
+      ':method': 'GET',
+      ':scheme': 'http',
+      ':authority': `localhost:${port}`
+    });
+    req.on(
+      'end',
+      common.mustCall(() => {
+        client.close();
+      })
+    );
+    req.resume();
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-statuscode.js b/test/parallel/test-http2-compat-serverresponse-statuscode.js
index dd92db8d96597a..911e108f784ad0 100644
--- a/test/parallel/test-http2-compat-serverresponse-statuscode.js
+++ b/test/parallel/test-http2-compat-serverresponse-statuscode.js
@@ -1,76 +1,99 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 // Http2ServerResponse should have a statusCode property
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    const expectedDefaultStatusCode = 200;
-    const realStatusCodes = {
-      continue: 100,
-      ok: 200,
-      multipleChoices: 300,
-      badRequest: 400,
-      internalServerError: 500
-    };
-    const fakeStatusCodes = {
-      tooLow: 99,
-      tooHigh: 600
-    };
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        const expectedDefaultStatusCode = 200;
+        const realStatusCodes = {
+          continue: 100,
+          ok: 200,
+          multipleChoices: 300,
+          badRequest: 400,
+          internalServerError: 500
+        };
+        const fakeStatusCodes = {
+          tooLow: 99,
+          tooHigh: 600
+        };
 
-    assert.strictEqual(response.statusCode, expectedDefaultStatusCode);
+        assert.strictEqual(response.statusCode, expectedDefaultStatusCode);
 
-    // Setting the response.statusCode should not throw.
-    response.statusCode = realStatusCodes.ok;
-    response.statusCode = realStatusCodes.multipleChoices;
-    response.statusCode = realStatusCodes.badRequest;
-    response.statusCode = realStatusCodes.internalServerError;
+        // Setting the response.statusCode should not throw.
+        response.statusCode = realStatusCodes.ok;
+        response.statusCode = realStatusCodes.multipleChoices;
+        response.statusCode = realStatusCodes.badRequest;
+        response.statusCode = realStatusCodes.internalServerError;
 
-    common.expectsError(function() {
-      response.statusCode = realStatusCodes.continue;
-    }, {
-      code: 'ERR_HTTP2_INFO_STATUS_NOT_ALLOWED',
-      type: RangeError
-    });
-    common.expectsError(function() {
-      response.statusCode = fakeStatusCodes.tooLow;
-    }, {
-      code: 'ERR_HTTP2_STATUS_INVALID',
-      type: RangeError
-    });
-    common.expectsError(function() {
-      response.statusCode = fakeStatusCodes.tooHigh;
-    }, {
-      code: 'ERR_HTTP2_STATUS_INVALID',
-      type: RangeError
-    });
+        common.expectsError(
+          function() {
+            response.statusCode = realStatusCodes.continue;
+          },
+          {
+            code: 'ERR_HTTP2_INFO_STATUS_NOT_ALLOWED',
+            type: RangeError
+          }
+        );
+        common.expectsError(
+          function() {
+            response.statusCode = fakeStatusCodes.tooLow;
+          },
+          {
+            code: 'ERR_HTTP2_STATUS_INVALID',
+            type: RangeError
+          }
+        );
+        common.expectsError(
+          function() {
+            response.statusCode = fakeStatusCodes.tooHigh;
+          },
+          {
+            code: 'ERR_HTTP2_STATUS_INVALID',
+            type: RangeError
+          }
+        );
 
-    response.on('finish', common.mustCall(function() {
-      server.close();
-    }));
-    response.end();
-  }));
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            server.close();
+          })
+        );
+        response.end();
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-statusmessage-property-set.js b/test/parallel/test-http2-compat-serverresponse-statusmessage-property-set.js
index 87e172402899f2..0d41702312deff 100644
--- a/test/parallel/test-http2-compat-serverresponse-statusmessage-property-set.js
+++ b/test/parallel/test-http2-compat-serverresponse-statusmessage-property-set.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -17,34 +16,52 @@ process.on('warning', ({ name, message }) => {
 });
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    response.on('finish', common.mustCall(function() {
-      response.statusMessage = 'test';
-      response.statusMessage = 'test'; // only warn once
-      assert.strictEqual(response.statusMessage, ''); // no change
-      server.close();
-    }));
-    response.end();
-  }));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            response.statusMessage = 'test';
+            response.statusMessage = 'test'; // only warn once
+            assert.strictEqual(response.statusMessage, ''); // no change
+            server.close();
+          })
+        );
+        response.end();
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('response', common.mustCall(function(headers) {
-      assert.strictEqual(headers[':status'], 200);
-    }, 1));
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'response',
+          common.mustCall(function(headers) {
+            assert.strictEqual(headers[':status'], 200);
+          }, 1)
+        );
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-statusmessage-property.js b/test/parallel/test-http2-compat-serverresponse-statusmessage-property.js
index 8a083cf3ba1638..6a512877e01d1c 100644
--- a/test/parallel/test-http2-compat-serverresponse-statusmessage-property.js
+++ b/test/parallel/test-http2-compat-serverresponse-statusmessage-property.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -17,33 +16,51 @@ process.on('warning', ({ name, message }) => {
 });
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    response.on('finish', common.mustCall(function() {
-      assert.strictEqual(response.statusMessage, '');
-      assert.strictEqual(response.statusMessage, ''); // only warn once
-      server.close();
-    }));
-    response.end();
-  }));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            assert.strictEqual(response.statusMessage, '');
+            assert.strictEqual(response.statusMessage, ''); // only warn once
+            server.close();
+          })
+        );
+        response.end();
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('response', common.mustCall(function(headers) {
-      assert.strictEqual(headers[':status'], 200);
-    }, 1));
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'response',
+          common.mustCall(function(headers) {
+            assert.strictEqual(headers[':status'], 200);
+          }, 1)
+        );
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-statusmessage.js b/test/parallel/test-http2-compat-serverresponse-statusmessage.js
index dee916d1aeef54..978688e5d738d1 100644
--- a/test/parallel/test-http2-compat-serverresponse-statusmessage.js
+++ b/test/parallel/test-http2-compat-serverresponse-statusmessage.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -17,37 +16,55 @@ process.on('warning', ({ name, message }) => {
 });
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    const statusCode = 200;
-    const statusMessage = 'OK';
-    const headers = { 'foo-bar': 'abc123' };
-    response.writeHead(statusCode, statusMessage, headers);
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        const statusCode = 200;
+        const statusMessage = 'OK';
+        const headers = { 'foo-bar': 'abc123' };
+        response.writeHead(statusCode, statusMessage, headers);
 
-    response.on('finish', common.mustCall(function() {
-      server.close();
-    }));
-    response.end();
-  }));
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            server.close();
+          })
+        );
+        response.end();
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('response', common.mustCall(function(headers) {
-      assert.strictEqual(headers[':status'], 200);
-      assert.strictEqual(headers['foo-bar'], 'abc123');
-    }, 1));
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'response',
+          common.mustCall(function(headers) {
+            assert.strictEqual(headers[':status'], 200);
+            assert.strictEqual(headers['foo-bar'], 'abc123');
+          }, 1)
+        );
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-trailers.js b/test/parallel/test-http2-compat-serverresponse-trailers.js
index fe722c84ee782a..a1f0b5847158c1 100644
--- a/test/parallel/test-http2-compat-serverresponse-trailers.js
+++ b/test/parallel/test-http2-compat-serverresponse-trailers.js
@@ -1,76 +1,79 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const server = http2.createServer();
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  server.once('request', common.mustCall((request, response) => {
-    response.addTrailers({
-      ABC: 123
-    });
-    response.setTrailer('ABCD', 123);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall((request, response) => {
+        response.addTrailers({
+          ABC: 123
+        });
+        response.setTrailer('ABCD', 123);
 
-    common.expectsError(
-      () => response.addTrailers({ '': 'test' }),
-      {
-        code: 'ERR_INVALID_HTTP_TOKEN',
-        type: TypeError,
-        message: 'Header name must be a valid HTTP token [""]'
-      }
-    );
-    common.expectsError(
-      () => response.setTrailer('test', undefined),
-      {
-        code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
-        type: TypeError,
-        message: 'Invalid value "undefined" for header "test"'
-      }
-    );
-    common.expectsError(
-      () => response.setTrailer('test', null),
-      {
-        code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
-        type: TypeError,
-        message: 'Invalid value "null" for header "test"'
-      }
-    );
-    common.expectsError(
-      () => response.setTrailer(), // Trailer name undefined
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        type: TypeError,
-        message: 'The "name" argument must be of type string. Received type ' +
-                 'undefined'
-      }
-    );
-    common.expectsError(
-      () => response.setTrailer(''),
-      {
-        code: 'ERR_INVALID_HTTP_TOKEN',
-        type: TypeError,
-        message: 'Header name must be a valid HTTP token [""]'
-      }
-    );
+        common.expectsError(() => response.addTrailers({ '': 'test' }), {
+          code: 'ERR_INVALID_HTTP_TOKEN',
+          type: TypeError,
+          message: 'Header name must be a valid HTTP token [""]'
+        });
+        common.expectsError(() => response.setTrailer('test', undefined), {
+          code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
+          type: TypeError,
+          message: 'Invalid value "undefined" for header "test"'
+        });
+        common.expectsError(() => response.setTrailer('test', null), {
+          code: 'ERR_HTTP2_INVALID_HEADER_VALUE',
+          type: TypeError,
+          message: 'Invalid value "null" for header "test"'
+        });
+        common.expectsError(
+          () => response.setTrailer(), // Trailer name undefined
+          {
+            code: 'ERR_INVALID_ARG_TYPE',
+            type: TypeError,
+            message:
+              'The "name" argument must be of type string. Received type ' +
+              'undefined'
+          }
+        );
+        common.expectsError(() => response.setTrailer(''), {
+          code: 'ERR_INVALID_HTTP_TOKEN',
+          type: TypeError,
+          message: 'Header name must be a valid HTTP token [""]'
+        });
 
-    response.end('hello');
-  }));
+        response.end('hello');
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = http2.connect(url, common.mustCall(() => {
-    const request = client.request();
-    request.on('trailers', common.mustCall((headers) => {
-      assert.strictEqual(headers.abc, '123');
-      assert.strictEqual(headers.abcd, '123');
-    }));
-    request.resume();
-    request.on('end', common.mustCall(() => {
-      client.close();
-      server.close();
-    }));
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = http2.connect(
+      url,
+      common.mustCall(() => {
+        const request = client.request();
+        request.on(
+          'trailers',
+          common.mustCall((headers) => {
+            assert.strictEqual(headers.abc, '123');
+            assert.strictEqual(headers.abcd, '123');
+          })
+        );
+        request.resume();
+        request.on(
+          'end',
+          common.mustCall(() => {
+            client.close();
+            server.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-write.js b/test/parallel/test-http2-compat-serverresponse-write.js
index af3029835eaecb..17c874ff9cefbc 100644
--- a/test/parallel/test-http2-compat-serverresponse-write.js
+++ b/test/parallel/test-http2-compat-serverresponse-write.js
@@ -7,46 +7,62 @@ const {
   hasCrypto,
   skip
 } = require('../common');
-if (!hasCrypto)
-  skip('missing crypto');
+if (!hasCrypto) skip('missing crypto');
 const { createServer, connect } = require('http2');
 const assert = require('assert');
 
 const server = createServer();
-server.listen(0, mustCall(() => {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const client = connect(url, mustCall(() => {
-    const request = client.request();
-    request.resume();
-    request.on('end', mustCall());
-    request.on('close', mustCall(() => {
-      client.close();
-    }));
-  }));
+server.listen(
+  0,
+  mustCall(() => {
+    const port = server.address().port;
+    const url = `http://localhost:${port}`;
+    const client = connect(
+      url,
+      mustCall(() => {
+        const request = client.request();
+        request.resume();
+        request.on('end', mustCall());
+        request.on(
+          'close',
+          mustCall(() => {
+            client.close();
+          })
+        );
+      })
+    );
 
-  server.once('request', mustCall((request, response) => {
-    // response.write() returns true
-    assert(response.write('muahaha', 'utf8', mustCall()));
+    server.once(
+      'request',
+      mustCall((request, response) => {
+        // response.write() returns true
+        assert(response.write('muahaha', 'utf8', mustCall()));
 
-    response.stream.close(0, mustCall(() => {
-      response.on('error', mustNotCall());
+        response.stream.close(
+          0,
+          mustCall(() => {
+            response.on('error', mustNotCall());
 
-      // response.write() without cb returns error
-      expectsError(
-        () => { response.write('muahaha'); },
-        {
-          type: Error,
-          code: 'ERR_HTTP2_INVALID_STREAM',
-          message: 'The stream has been destroyed'
-        }
-      );
+            // response.write() without cb returns error
+            expectsError(
+              () => {
+                response.write('muahaha');
+              },
+              {
+                type: Error,
+                code: 'ERR_HTTP2_INVALID_STREAM',
+                message: 'The stream has been destroyed'
+              }
+            );
 
-      // response.write() with cb returns falsy value
-      assert(!response.write('muahaha', mustCall()));
+            // response.write() with cb returns falsy value
+            assert(!response.write('muahaha', mustCall()));
 
-      client.destroy();
-      server.close();
-    }));
-  }));
-}));
+            client.destroy();
+            server.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-serverresponse-writehead.js b/test/parallel/test-http2-compat-serverresponse-writehead.js
index 5fd787e100350c..fd436455e8d866 100644
--- a/test/parallel/test-http2-compat-serverresponse-writehead.js
+++ b/test/parallel/test-http2-compat-serverresponse-writehead.js
@@ -1,52 +1,81 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 // Http2ServerResponse.writeHead should override previous headers
 
 const server = h2.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  server.once('request', common.mustCall(function(request, response) {
-    response.setHeader('foo-bar', 'def456');
-    response.writeHead(418, { 'foo-bar': 'abc123' }); // Override
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    server.once(
+      'request',
+      common.mustCall(function(request, response) {
+        response.setHeader('foo-bar', 'def456');
+        response.writeHead(418, { 'foo-bar': 'abc123' }); // Override
 
-    common.expectsError(() => { response.writeHead(300); }, {
-      code: 'ERR_HTTP2_HEADERS_SENT'
-    });
+        common.expectsError(
+          () => {
+            response.writeHead(300);
+          },
+          {
+            code: 'ERR_HTTP2_HEADERS_SENT'
+          }
+        );
 
-    response.on('finish', common.mustCall(function() {
-      server.close();
-      process.nextTick(common.mustCall(() => {
-        common.expectsError(() => { response.writeHead(300); }, {
-          code: 'ERR_HTTP2_INVALID_STREAM'
-        });
-      }));
-    }));
-    response.end();
-  }));
+        response.on(
+          'finish',
+          common.mustCall(function() {
+            server.close();
+            process.nextTick(
+              common.mustCall(() => {
+                common.expectsError(
+                  () => {
+                    response.writeHead(300);
+                  },
+                  {
+                    code: 'ERR_HTTP2_INVALID_STREAM'
+                  }
+                );
+              })
+            );
+          })
+        );
+        response.end();
+      })
+    );
 
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('response', common.mustCall(function(headers) {
-      assert.strictEqual(headers['foo-bar'], 'abc123');
-      assert.strictEqual(headers[':status'], 418);
-    }, 1));
-    request.on('end', common.mustCall(function() {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'response',
+          common.mustCall(function(headers) {
+            assert.strictEqual(headers['foo-bar'], 'abc123');
+            assert.strictEqual(headers[':status'], 418);
+          }, 1)
+        );
+        request.on(
+          'end',
+          common.mustCall(function() {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-short-stream-client-server.js b/test/parallel/test-http2-compat-short-stream-client-server.js
index f7ef9412106f59..f61f9b9153c686 100644
--- a/test/parallel/test-http2-compat-short-stream-client-server.js
+++ b/test/parallel/test-http2-compat-short-stream-client-server.js
@@ -1,50 +1,63 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const { Readable } = require('stream');
 
-const server = http2.createServer(common.mustCall((req, res) => {
-  res.setHeader('content-type', 'text/html');
-  const input = new Readable({
-    read() {
-      this.push('test');
-      this.push(null);
-    }
-  });
-  input.pipe(res);
-}));
-
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
-
-  const req = client.request();
-
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 200);
-    assert.strictEqual(headers['content-type'], 'text/html');
-  }));
-
-  let data = '';
-
-  const notCallClose = common.mustNotCall();
-
-  setTimeout(() => {
-    req.setEncoding('utf8');
-    req.removeListener('close', notCallClose);
-    req.on('close', common.mustCall(() => {
-      server.close();
-      client.close();
-    }));
-    req.on('data', common.mustCallAtLeast((d) => data += d));
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(data, 'test');
-    }));
-  }, common.platformTimeout(100));
-
-  req.on('close', notCallClose);
-}));
+const server = http2.createServer(
+  common.mustCall((req, res) => {
+    res.setHeader('content-type', 'text/html');
+    const input = new Readable({
+      read() {
+        this.push('test');
+        this.push(null);
+      }
+    });
+    input.pipe(res);
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
+
+    const req = client.request();
+
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers[':status'], 200);
+        assert.strictEqual(headers['content-type'], 'text/html');
+      })
+    );
+
+    let data = '';
+
+    const notCallClose = common.mustNotCall();
+
+    setTimeout(() => {
+      req.setEncoding('utf8');
+      req.removeListener('close', notCallClose);
+      req.on(
+        'close',
+        common.mustCall(() => {
+          server.close();
+          client.close();
+        })
+      );
+      req.on('data', common.mustCallAtLeast((d) => (data += d)));
+      req.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(data, 'test');
+        })
+      );
+    }, common.platformTimeout(100));
+
+    req.on('close', notCallClose);
+  })
+);
diff --git a/test/parallel/test-http2-compat-socket-destroy-delayed.js b/test/parallel/test-http2-compat-socket-destroy-delayed.js
index 62405047d8266e..50fe9403632584 100644
--- a/test/parallel/test-http2-compat-socket-destroy-delayed.js
+++ b/test/parallel/test-http2-compat-socket-destroy-delayed.js
@@ -3,40 +3,49 @@
 const common = require('../common');
 const { mustCall } = common;
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http2 = require('http2');
 const assert = require('assert');
 
-const {
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_METHOD,
-} = http2.constants;
+const { HTTP2_HEADER_PATH, HTTP2_HEADER_METHOD } = http2.constants;
 
 // This tests verifies that calling `req.socket.destroy()` via
 // setImmediate does not crash.
 // Fixes https://github.com/nodejs/node/issues/22855.
 
-const app = http2.createServer(mustCall((req, res) => {
-  res.end('hello');
-  setImmediate(() => req.socket.destroy());
-}));
+const app = http2.createServer(
+  mustCall((req, res) => {
+    res.end('hello');
+    setImmediate(() => req.socket.destroy());
+  })
+);
 
-app.listen(0, mustCall(() => {
-  const session = http2.connect(`http://localhost:${app.address().port}`);
-  const request = session.request({
-    [HTTP2_HEADER_PATH]: '/',
-    [HTTP2_HEADER_METHOD]: 'get'
-  });
-  request.once('response', mustCall((headers, flags) => {
-    let data = '';
-    request.on('data', (chunk) => { data += chunk; });
-    request.on('end', mustCall(() => {
-      assert.strictEqual(data, 'hello');
-      session.close();
-      app.close();
-    }));
-  }));
-  request.end();
-}));
+app.listen(
+  0,
+  mustCall(() => {
+    const session = http2.connect(`http://localhost:${app.address().port}`);
+    const request = session.request({
+      [HTTP2_HEADER_PATH]: '/',
+      [HTTP2_HEADER_METHOD]: 'get'
+    });
+    request.once(
+      'response',
+      mustCall((headers, flags) => {
+        let data = '';
+        request.on('data', (chunk) => {
+          data += chunk;
+        });
+        request.on(
+          'end',
+          mustCall(() => {
+            assert.strictEqual(data, 'hello');
+            session.close();
+            app.close();
+          })
+        );
+      })
+    );
+    request.end();
+  })
+);
diff --git a/test/parallel/test-http2-compat-socket-set.js b/test/parallel/test-http2-compat-socket-set.js
index 05beb09d548e91..114d882b8f65da 100644
--- a/test/parallel/test-http2-compat-socket-set.js
+++ b/test/parallel/test-http2-compat-socket-set.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -12,96 +11,112 @@ const h2 = require('http2');
 const errMsg = {
   code: 'ERR_HTTP2_NO_SOCKET_MANIPULATION',
   type: Error,
-  message: 'HTTP/2 sockets should not be directly manipulated ' +
-           '(e.g. read and written)'
+  message:
+    'HTTP/2 sockets should not be directly manipulated ' +
+    '(e.g. read and written)'
 };
 
 const server = h2.createServer();
 
-server.on('request', common.mustCall(function(request, response) {
-  const noop = () => {};
-
-  assert.strictEqual(request.stream.destroyed, false);
-  request.socket.destroyed = true;
-  assert.strictEqual(request.stream.destroyed, true);
-  request.socket.destroyed = false;
-
-  assert.strictEqual(request.stream.readable, false);
-  request.socket.readable = true;
-  assert.strictEqual(request.stream.readable, true);
-
-  assert.strictEqual(request.stream.writable, true);
-  request.socket.writable = false;
-  assert.strictEqual(request.stream.writable, false);
-
-  const realOn = request.stream.on;
-  request.socket.on = noop;
-  assert.strictEqual(request.stream.on, noop);
-  request.stream.on = realOn;
-
-  const realOnce = request.stream.once;
-  request.socket.once = noop;
-  assert.strictEqual(request.stream.once, noop);
-  request.stream.once = realOnce;
-
-  const realEnd = request.stream.end;
-  request.socket.end = noop;
-  assert.strictEqual(request.stream.end, noop);
-  request.socket.end = common.mustCall();
-  request.socket.end();
-  request.stream.end = realEnd;
-
-  const realEmit = request.stream.emit;
-  request.socket.emit = noop;
-  assert.strictEqual(request.stream.emit, noop);
-  request.stream.emit = realEmit;
-
-  const realDestroy = request.stream.destroy;
-  request.socket.destroy = noop;
-  assert.strictEqual(request.stream.destroy, noop);
-  request.stream.destroy = realDestroy;
-
-  request.socket.setTimeout = noop;
-  assert.strictEqual(request.stream.session.setTimeout, noop);
-
-  assert.strictEqual(request.stream.session.socket._isProcessing, undefined);
-  request.socket._isProcessing = true;
-  assert.strictEqual(request.stream.session.socket._isProcessing, true);
-
-  common.expectsError(() => request.socket.read = noop, errMsg);
-  common.expectsError(() => request.socket.write = noop, errMsg);
-  common.expectsError(() => request.socket.pause = noop, errMsg);
-  common.expectsError(() => request.socket.resume = noop, errMsg);
-
-  request.stream.on('finish', common.mustCall(() => {
-    setImmediate(() => {
-      request.socket.setTimeout = noop;
-      assert.strictEqual(request.stream.setTimeout, noop);
-
-      assert.strictEqual(request.stream._isProcessing, undefined);
-      request.socket._isProcessing = true;
-      assert.strictEqual(request.stream._isProcessing, true);
-    });
-  }));
-  response.stream.destroy();
-}));
-
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(function() {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('end', common.mustCall(() => {
-      client.close();
-      server.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+server.on(
+  'request',
+  common.mustCall(function(request, response) {
+    const noop = () => {};
+
+    assert.strictEqual(request.stream.destroyed, false);
+    request.socket.destroyed = true;
+    assert.strictEqual(request.stream.destroyed, true);
+    request.socket.destroyed = false;
+
+    assert.strictEqual(request.stream.readable, false);
+    request.socket.readable = true;
+    assert.strictEqual(request.stream.readable, true);
+
+    assert.strictEqual(request.stream.writable, true);
+    request.socket.writable = false;
+    assert.strictEqual(request.stream.writable, false);
+
+    const realOn = request.stream.on;
+    request.socket.on = noop;
+    assert.strictEqual(request.stream.on, noop);
+    request.stream.on = realOn;
+
+    const realOnce = request.stream.once;
+    request.socket.once = noop;
+    assert.strictEqual(request.stream.once, noop);
+    request.stream.once = realOnce;
+
+    const realEnd = request.stream.end;
+    request.socket.end = noop;
+    assert.strictEqual(request.stream.end, noop);
+    request.socket.end = common.mustCall();
+    request.socket.end();
+    request.stream.end = realEnd;
+
+    const realEmit = request.stream.emit;
+    request.socket.emit = noop;
+    assert.strictEqual(request.stream.emit, noop);
+    request.stream.emit = realEmit;
+
+    const realDestroy = request.stream.destroy;
+    request.socket.destroy = noop;
+    assert.strictEqual(request.stream.destroy, noop);
+    request.stream.destroy = realDestroy;
+
+    request.socket.setTimeout = noop;
+    assert.strictEqual(request.stream.session.setTimeout, noop);
+
+    assert.strictEqual(request.stream.session.socket._isProcessing, undefined);
+    request.socket._isProcessing = true;
+    assert.strictEqual(request.stream.session.socket._isProcessing, true);
+
+    common.expectsError(() => (request.socket.read = noop), errMsg);
+    common.expectsError(() => (request.socket.write = noop), errMsg);
+    common.expectsError(() => (request.socket.pause = noop), errMsg);
+    common.expectsError(() => (request.socket.resume = noop), errMsg);
+
+    request.stream.on(
+      'finish',
+      common.mustCall(() => {
+        setImmediate(() => {
+          request.socket.setTimeout = noop;
+          assert.strictEqual(request.stream.setTimeout, noop);
+
+          assert.strictEqual(request.stream._isProcessing, undefined);
+          request.socket._isProcessing = true;
+          assert.strictEqual(request.stream._isProcessing, true);
+        });
+      })
+    );
+    response.stream.destroy();
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(function() {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'end',
+          common.mustCall(() => {
+            client.close();
+            server.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-compat-socket.js b/test/parallel/test-http2-compat-socket.js
index 498677af6ee796..c7e81bae30a3d4 100644
--- a/test/parallel/test-http2-compat-socket.js
+++ b/test/parallel/test-http2-compat-socket.js
@@ -3,8 +3,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const net = require('net');
@@ -18,76 +17,95 @@ const { kTimeout } = require('internal/timers');
 const errMsg = {
   code: 'ERR_HTTP2_NO_SOCKET_MANIPULATION',
   type: Error,
-  message: 'HTTP/2 sockets should not be directly manipulated ' +
-           '(e.g. read and written)'
+  message:
+    'HTTP/2 sockets should not be directly manipulated ' +
+    '(e.g. read and written)'
 };
 
 const server = h2.createServer();
 
-server.on('request', common.mustCall(function(request, response) {
-  assert.ok(request.socket instanceof net.Socket);
-  assert.ok(response.socket instanceof net.Socket);
-  assert.strictEqual(request.socket, response.socket);
+server.on(
+  'request',
+  common.mustCall(function(request, response) {
+    assert.ok(request.socket instanceof net.Socket);
+    assert.ok(response.socket instanceof net.Socket);
+    assert.strictEqual(request.socket, response.socket);
 
-  assert.ok(request.socket.readable);
-  request.resume();
-  assert.ok(request.socket.writable);
-  assert.strictEqual(request.socket.destroyed, false);
+    assert.ok(request.socket.readable);
+    request.resume();
+    assert.ok(request.socket.writable);
+    assert.strictEqual(request.socket.destroyed, false);
 
-  request.socket.setTimeout(987);
-  assert.strictEqual(request.stream.session[kTimeout]._idleTimeout, 987);
-  request.socket.setTimeout(0);
+    request.socket.setTimeout(987);
+    assert.strictEqual(request.stream.session[kTimeout]._idleTimeout, 987);
+    request.socket.setTimeout(0);
 
-  common.expectsError(() => request.socket.read(), errMsg);
-  common.expectsError(() => request.socket.write(), errMsg);
-  common.expectsError(() => request.socket.pause(), errMsg);
-  common.expectsError(() => request.socket.resume(), errMsg);
+    common.expectsError(() => request.socket.read(), errMsg);
+    common.expectsError(() => request.socket.write(), errMsg);
+    common.expectsError(() => request.socket.pause(), errMsg);
+    common.expectsError(() => request.socket.resume(), errMsg);
 
-  // should have correct this context for socket methods & getters
-  assert.ok(request.socket.address() != null);
-  assert.ok(request.socket.remotePort);
+    // should have correct this context for socket methods & getters
+    assert.ok(request.socket.address() != null);
+    assert.ok(request.socket.remotePort);
 
-  request.on('end', common.mustCall(() => {
-    assert.strictEqual(request.socket.readable, false);
-    response.socket.destroy();
-  }));
-  response.on('finish', common.mustCall(() => {
-    assert.ok(request.socket);
-    assert.strictEqual(response.socket, undefined);
-    assert.ok(request.socket.destroyed);
-    assert.strictEqual(request.socket.readable, false);
-    process.nextTick(() => {
-      assert.strictEqual(request.socket.writable, false);
-      server.close();
-    });
-  }));
+    request.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(request.socket.readable, false);
+        response.socket.destroy();
+      })
+    );
+    response.on(
+      'finish',
+      common.mustCall(() => {
+        assert.ok(request.socket);
+        assert.strictEqual(response.socket, undefined);
+        assert.ok(request.socket.destroyed);
+        assert.strictEqual(request.socket.readable, false);
+        process.nextTick(() => {
+          assert.strictEqual(request.socket.writable, false);
+          server.close();
+        });
+      })
+    );
 
-  // properties that do not exist on the proxy are retrieved from the socket
-  assert.ok(request.socket._server);
-  assert.strictEqual(request.socket.connecting, false);
+    // properties that do not exist on the proxy are retrieved from the socket
+    assert.ok(request.socket._server);
+    assert.strictEqual(request.socket.connecting, false);
 
-  // socket events are bound and emitted on Http2Stream
-  request.socket.on('close', common.mustCall());
-  request.socket.once('close', common.mustCall());
-  request.socket.on('testEvent', common.mustCall());
-  request.socket.emit('testEvent');
-}));
+    // socket events are bound and emitted on Http2Stream
+    request.socket.on('close', common.mustCall());
+    request.socket.once('close', common.mustCall());
+    request.socket.on('testEvent', common.mustCall());
+    request.socket.emit('testEvent');
+  })
+);
 
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(() => {
-    const headers = {
-      ':path': '/',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`
-    };
-    const request = client.request(headers);
-    request.on('end', common.mustCall(() => {
-      client.close();
-    }));
-    request.end();
-    request.resume();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(() => {
+        const headers = {
+          ':path': '/',
+          ':method': 'GET',
+          ':scheme': 'http',
+          ':authority': `localhost:${port}`
+        };
+        const request = client.request(headers);
+        request.on(
+          'end',
+          common.mustCall(() => {
+            client.close();
+          })
+        );
+        request.end();
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-connect-method-extended-cant-turn-off.js b/test/parallel/test-http2-connect-method-extended-cant-turn-off.js
index f4d033efe65707..8c9188abab8d51 100644
--- a/test/parallel/test-http2-connect-method-extended-cant-turn-off.js
+++ b/test/parallel/test-http2-connect-method-extended-cant-turn-off.js
@@ -1,30 +1,41 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const settings = { enableConnectProtocol: true };
 const server = http2.createServer({ settings });
 server.on('stream', common.mustNotCall());
-server.on('session', common.mustCall((session) => {
-  // This will force the connection to close because once extended connect
-  // is on, it cannot be turned off. The server is behaving badly.
-  session.settings({ enableConnectProtocol: false });
-}));
+server.on(
+  'session',
+  common.mustCall((session) => {
+    // This will force the connection to close because once extended connect
+    // is on, it cannot be turned off. The server is behaving badly.
+    session.settings({ enableConnectProtocol: false });
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  client.on('remoteSettings', common.mustCall((settings) => {
-    assert(settings.enableConnectProtocol);
-    const req = client.request({
-      ':method': 'CONNECT',
-      ':protocol': 'foo'
-    });
-    req.on('error', common.mustCall(() => {
-      server.close();
-    }));
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    client.on(
+      'remoteSettings',
+      common.mustCall((settings) => {
+        assert(settings.enableConnectProtocol);
+        const req = client.request({
+          ':method': 'CONNECT',
+          ':protocol': 'foo'
+        });
+        req.on(
+          'error',
+          common.mustCall(() => {
+            server.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-connect-method-extended.js b/test/parallel/test-http2-connect-method-extended.js
index bb424c73f0a2ad..ae4c052943376e 100644
--- a/test/parallel/test-http2-connect-method-extended.js
+++ b/test/parallel/test-http2-connect-method-extended.js
@@ -1,39 +1,52 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const settings = { enableConnectProtocol: true };
 const server = http2.createServer({ settings });
-server.on('stream', common.mustCall((stream, headers) => {
-  assert.strictEqual(headers[':method'], 'CONNECT');
-  assert.strictEqual(headers[':scheme'], 'http');
-  assert.strictEqual(headers[':protocol'], 'foo');
-  assert.strictEqual(headers[':authority'],
-                     `localhost:${server.address().port}`);
-  assert.strictEqual(headers[':path'], '/');
-  stream.respond();
-  stream.end('ok');
-}));
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    assert.strictEqual(headers[':method'], 'CONNECT');
+    assert.strictEqual(headers[':scheme'], 'http');
+    assert.strictEqual(headers[':protocol'], 'foo');
+    assert.strictEqual(
+      headers[':authority'],
+      `localhost:${server.address().port}`
+    );
+    assert.strictEqual(headers[':path'], '/');
+    stream.respond();
+    stream.end('ok');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  client.on('remoteSettings', common.mustCall((settings) => {
-    assert(settings.enableConnectProtocol);
-    const req = client.request({
-      ':method': 'CONNECT',
-      ':protocol': 'foo'
-    });
-    req.resume();
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(() => {
-      assert.strictEqual(req.rstCode, 0);
-      server.close();
-      client.close();
-    }));
-    req.end();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    client.on(
+      'remoteSettings',
+      common.mustCall((settings) => {
+        assert(settings.enableConnectProtocol);
+        const req = client.request({
+          ':method': 'CONNECT',
+          ':protocol': 'foo'
+        });
+        req.resume();
+        req.on('end', common.mustCall());
+        req.on(
+          'close',
+          common.mustCall(() => {
+            assert.strictEqual(req.rstCode, 0);
+            server.close();
+            client.close();
+          })
+        );
+        req.end();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-connect-method.js b/test/parallel/test-http2-connect-method.js
index 0ddbc60433cf85..4dd5e3d184d0bb 100644
--- a/test/parallel/test-http2-connect-method.js
+++ b/test/parallel/test-http2-connect-method.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const net = require('net');
 const http2 = require('http2');
@@ -17,93 +16,113 @@ const {
   NGHTTP2_REFUSED_STREAM
 } = http2.constants;
 
-const server = net.createServer(common.mustCall((socket) => {
-  let data = '';
-  socket.setEncoding('utf8');
-  socket.on('data', (chunk) => data += chunk);
-  socket.on('end', common.mustCall(() => {
-    assert.strictEqual(data, 'hello');
-  }));
-  socket.on('close', common.mustCall());
-  socket.end('hello');
-}));
+const server = net.createServer(
+  common.mustCall((socket) => {
+    let data = '';
+    socket.setEncoding('utf8');
+    socket.on('data', (chunk) => (data += chunk));
+    socket.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(data, 'hello');
+      })
+    );
+    socket.on('close', common.mustCall());
+    socket.end('hello');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
 
-  const port = server.address().port;
+    const proxy = http2.createServer();
+    proxy.on(
+      'stream',
+      common.mustCall((stream, headers) => {
+        if (headers[HTTP2_HEADER_METHOD] !== 'CONNECT') {
+          stream.close(NGHTTP2_REFUSED_STREAM);
+          return;
+        }
+        const auth = new URL(`tcp://${headers[HTTP2_HEADER_AUTHORITY]}`);
+        assert.strictEqual(auth.hostname, 'localhost');
+        assert.strictEqual(+auth.port, port);
+        const socket = net.connect(
+          auth.port,
+          auth.hostname,
+          () => {
+            stream.respond();
+            socket.pipe(stream);
+            stream.pipe(socket);
+          }
+        );
+        socket.on('close', common.mustCall());
+        socket.on('error', (error) => {
+          stream.close(NGHTTP2_CONNECT_ERROR);
+        });
+      })
+    );
 
-  const proxy = http2.createServer();
-  proxy.on('stream', common.mustCall((stream, headers) => {
-    if (headers[HTTP2_HEADER_METHOD] !== 'CONNECT') {
-      stream.close(NGHTTP2_REFUSED_STREAM);
-      return;
-    }
-    const auth = new URL(`tcp://${headers[HTTP2_HEADER_AUTHORITY]}`);
-    assert.strictEqual(auth.hostname, 'localhost');
-    assert.strictEqual(+auth.port, port);
-    const socket = net.connect(auth.port, auth.hostname, () => {
-      stream.respond();
-      socket.pipe(stream);
-      stream.pipe(socket);
-    });
-    socket.on('close', common.mustCall());
-    socket.on('error', (error) => {
-      stream.close(NGHTTP2_CONNECT_ERROR);
-    });
-  }));
+    proxy.listen(0, () => {
+      const client = http2.connect(`http://localhost:${proxy.address().port}`);
 
-  proxy.listen(0, () => {
-    const client = http2.connect(`http://localhost:${proxy.address().port}`);
+      // confirm that :authority is required and :scheme & :path are forbidden
+      common.expectsError(
+        () =>
+          client.request({
+            [HTTP2_HEADER_METHOD]: 'CONNECT'
+          }),
+        {
+          code: 'ERR_HTTP2_CONNECT_AUTHORITY',
+          message: ':authority header is required for CONNECT requests'
+        }
+      );
+      common.expectsError(
+        () =>
+          client.request({
+            [HTTP2_HEADER_METHOD]: 'CONNECT',
+            [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`,
+            [HTTP2_HEADER_SCHEME]: 'http'
+          }),
+        {
+          code: 'ERR_HTTP2_CONNECT_SCHEME',
+          message: 'The :scheme header is forbidden for CONNECT requests'
+        }
+      );
+      common.expectsError(
+        () =>
+          client.request({
+            [HTTP2_HEADER_METHOD]: 'CONNECT',
+            [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`,
+            [HTTP2_HEADER_PATH]: '/'
+          }),
+        {
+          code: 'ERR_HTTP2_CONNECT_PATH',
+          message: 'The :path header is forbidden for CONNECT requests'
+        }
+      );
 
-    // confirm that :authority is required and :scheme & :path are forbidden
-    common.expectsError(
-      () => client.request({
-        [HTTP2_HEADER_METHOD]: 'CONNECT'
-      }),
-      {
-        code: 'ERR_HTTP2_CONNECT_AUTHORITY',
-        message: ':authority header is required for CONNECT requests'
-      }
-    );
-    common.expectsError(
-      () => client.request({
-        [HTTP2_HEADER_METHOD]: 'CONNECT',
-        [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`,
-        [HTTP2_HEADER_SCHEME]: 'http'
-      }),
-      {
-        code: 'ERR_HTTP2_CONNECT_SCHEME',
-        message: 'The :scheme header is forbidden for CONNECT requests'
-      }
-    );
-    common.expectsError(
-      () => client.request({
+      // valid CONNECT request
+      const req = client.request({
         [HTTP2_HEADER_METHOD]: 'CONNECT',
-        [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`,
-        [HTTP2_HEADER_PATH]: '/'
-      }),
-      {
-        code: 'ERR_HTTP2_CONNECT_PATH',
-        message: 'The :path header is forbidden for CONNECT requests'
-      }
-    );
+        [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`
+      });
 
-    // valid CONNECT request
-    const req = client.request({
-      [HTTP2_HEADER_METHOD]: 'CONNECT',
-      [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`,
+      req.on('response', common.mustCall());
+      let data = '';
+      req.setEncoding('utf8');
+      req.on('data', (chunk) => (data += chunk));
+      req.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(data, 'hello');
+          client.close();
+          proxy.close();
+          server.close();
+        })
+      );
+      req.end('hello');
     });
-
-    req.on('response', common.mustCall());
-    let data = '';
-    req.setEncoding('utf8');
-    req.on('data', (chunk) => data += chunk);
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(data, 'hello');
-      client.close();
-      proxy.close();
-      server.close();
-    }));
-    req.end('hello');
-  });
-}));
+  })
+);
diff --git a/test/parallel/test-http2-connect.js b/test/parallel/test-http2-connect.js
index 252efa1229ad85..b6e90fe8d5e2c3 100644
--- a/test/parallel/test-http2-connect.js
+++ b/test/parallel/test-http2-connect.js
@@ -1,58 +1,86 @@
 'use strict';
 
 const { mustCall, hasCrypto, skip, expectsError } = require('../common');
-if (!hasCrypto)
-  skip('missing crypto');
+if (!hasCrypto) skip('missing crypto');
 const { createServer, connect } = require('http2');
 const { connect: netConnect } = require('net');
 
 // check for session connect callback and event
 {
   const server = createServer();
-  server.listen(0, mustCall(() => {
-    const authority = `http://localhost:${server.address().port}`;
-    const options = {};
-    const listener = () => mustCall();
+  server.listen(
+    0,
+    mustCall(() => {
+      const authority = `http://localhost:${server.address().port}`;
+      const options = {};
+      const listener = () => mustCall();
 
-    const clients = new Set();
-    // Should not throw.
-    clients.add(connect(authority));
-    clients.add(connect(authority, options));
-    clients.add(connect(authority, options, listener()));
-    clients.add(connect(authority, listener()));
+      const clients = new Set();
+      // Should not throw.
+      clients.add(connect(authority));
+      clients.add(
+        connect(
+          authority,
+          options
+        )
+      );
+      clients.add(
+        connect(
+          authority,
+          options,
+          listener()
+        )
+      );
+      clients.add(
+        connect(
+          authority,
+          listener()
+        )
+      );
 
-    for (const client of clients) {
-      client.once('connect', mustCall((headers) => {
-        client.close();
-        clients.delete(client);
-        if (clients.size === 0) {
-          server.close();
-        }
-      }));
-    }
-  }));
+      for (const client of clients) {
+        client.once(
+          'connect',
+          mustCall((headers) => {
+            client.close();
+            clients.delete(client);
+            if (clients.size === 0) {
+              server.close();
+            }
+          })
+        );
+      }
+    })
+  );
 }
 
 // check for session connect callback on already connected socket
 {
   const server = createServer();
-  server.listen(0, mustCall(() => {
-    const { port } = server.address();
+  server.listen(
+    0,
+    mustCall(() => {
+      const { port } = server.address();
 
-    const onSocketConnect = () => {
-      const authority = `http://localhost:${port}`;
-      const createConnection = mustCall(() => socket);
-      const options = { createConnection };
-      connect(authority, options, mustCall(onSessionConnect));
-    };
+      const onSocketConnect = () => {
+        const authority = `http://localhost:${port}`;
+        const createConnection = mustCall(() => socket);
+        const options = { createConnection };
+        connect(
+          authority,
+          options,
+          mustCall(onSessionConnect)
+        );
+      };
 
-    const onSessionConnect = (session) => {
-      session.close();
-      server.close();
-    };
+      const onSessionConnect = (session) => {
+        session.close();
+        server.close();
+      };
 
-    const socket = netConnect(port, mustCall(onSocketConnect));
-  }));
+      const socket = netConnect(port, mustCall(onSocketConnect));
+    })
+  );
 }
 
 // check for https as protocol
@@ -66,10 +94,13 @@ const { connect: netConnect } = require('net');
 // check for error for an invalid protocol (not http or https)
 {
   const authority = 'ssh://localhost';
-  expectsError(() => {
-    connect(authority);
-  }, {
-    code: 'ERR_HTTP2_UNSUPPORTED_PROTOCOL',
-    type: Error
-  });
+  expectsError(
+    () => {
+      connect(authority);
+    },
+    {
+      code: 'ERR_HTTP2_UNSUPPORTED_PROTOCOL',
+      type: Error
+    }
+  );
 }
diff --git a/test/parallel/test-http2-cookies.js b/test/parallel/test-http2-cookies.js
index 275fbf05e79460..1e5e1f4f69b769 100644
--- a/test/parallel/test-http2-cookies.js
+++ b/test/parallel/test-http2-cookies.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -18,7 +17,6 @@ const setCookie = [
 server.on('stream', common.mustCall(onStream));
 
 function onStream(stream, headers, flags) {
-
   assert.strictEqual(typeof headers.abc, 'string');
   assert.strictEqual(headers.abc, '1, 2, 3');
   assert.strictEqual(typeof headers.cookie, 'string');
@@ -35,26 +33,33 @@ function onStream(stream, headers, flags) {
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const req = client.request({
-    ':path': '/',
-    'abc': [1, 2, 3],
-    'cookie': ['a=b', 'c=d', 'e=f'],
-  });
-  req.resume();
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
 
-  req.on('response', common.mustCall((headers) => {
-    assert(Array.isArray(headers['set-cookie']));
-    assert.deepStrictEqual(headers['set-cookie'], setCookie);
-  }));
+    const req = client.request({
+      ':path': '/',
+      abc: [1, 2, 3],
+      cookie: ['a=b', 'c=d', 'e=f']
+    });
+    req.resume();
 
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-  req.end();
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert(Array.isArray(headers['set-cookie']));
+        assert.deepStrictEqual(headers['set-cookie'], setCookie);
+      })
+    );
 
-}));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-create-client-connect.js b/test/parallel/test-http2-create-client-connect.js
index 02c6c70642acb0..dc8d5948316dd4 100644
--- a/test/parallel/test-http2-create-client-connect.js
+++ b/test/parallel/test-http2-create-client-connect.js
@@ -4,8 +4,7 @@
 
 const common = require('../common');
 const Countdown = require('../common/countdown');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const h2 = require('http2');
 const url = require('url');
@@ -15,71 +14,79 @@ const URL = url.URL;
   const server = h2.createServer();
   server.listen(0);
 
-  server.on('listening', common.mustCall(function() {
-    const port = this.address().port;
-
-    const items = [
-      [`http://localhost:${port}`],
-      [new URL(`http://localhost:${port}`)],
-      [url.parse(`http://localhost:${port}`)],
-      [{ port }, { protocol: 'http:' }],
-      [{ port, hostname: '127.0.0.1' }, { protocol: 'http:' }]
-    ];
-
-    const serverClose = new Countdown(items.length + 1,
-                                      () => setImmediate(() => server.close()));
-
-    const maybeClose = common.mustCall((client) => {
-      client.close();
-      serverClose.dec();
-    }, items.length);
-
-    items.forEach((i) => {
-      const client =
-        h2.connect.apply(null, i)
+  server.on(
+    'listening',
+    common.mustCall(function() {
+      const port = this.address().port;
+
+      const items = [
+        [`http://localhost:${port}`],
+        [new URL(`http://localhost:${port}`)],
+        [url.parse(`http://localhost:${port}`)],
+        [{ port }, { protocol: 'http:' }],
+        [{ port, hostname: '127.0.0.1' }, { protocol: 'http:' }]
+      ];
+
+      const serverClose = new Countdown(items.length + 1, () =>
+        setImmediate(() => server.close())
+      );
+
+      const maybeClose = common.mustCall((client) => {
+        client.close();
+        serverClose.dec();
+      }, items.length);
+
+      items.forEach((i) => {
+        const client = h2.connect
+          .apply(null, i)
           .on('connect', common.mustCall(() => maybeClose(client)));
-    });
-
-    // Will fail because protocol does not match the server.
-    h2.connect({ port: port, protocol: 'https:' })
-      .on('error', common.mustCall(() => serverClose.dec()));
-  }));
+      });
+
+      // Will fail because protocol does not match the server.
+      h2.connect({ port: port, protocol: 'https:' }).on(
+        'error',
+        common.mustCall(() => serverClose.dec())
+      );
+    })
+  );
 }
 
-
 {
-
   const options = {
     key: fixtures.readKey('agent3-key.pem'),
     cert: fixtures.readKey('agent3-cert.pem')
   };
 
   const server = h2.createSecureServer(options);
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-
-    const opts = { rejectUnauthorized: false };
-
-    const items = [
-      [`https://localhost:${port}`, opts],
-      [new URL(`https://localhost:${port}`), opts],
-      [url.parse(`https://localhost:${port}`), opts],
-      [{ port: port, protocol: 'https:' }, opts],
-      [{ port: port, hostname: '127.0.0.1', protocol: 'https:' }, opts]
-    ];
-
-    const serverClose = new Countdown(items.length,
-                                      () => setImmediate(() => server.close()));
-
-    const maybeClose = common.mustCall((client) => {
-      client.close();
-      serverClose.dec();
-    }, items.length);
-
-    items.forEach((i) => {
-      const client =
-        h2.connect.apply(null, i)
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+
+      const opts = { rejectUnauthorized: false };
+
+      const items = [
+        [`https://localhost:${port}`, opts],
+        [new URL(`https://localhost:${port}`), opts],
+        [url.parse(`https://localhost:${port}`), opts],
+        [{ port: port, protocol: 'https:' }, opts],
+        [{ port: port, hostname: '127.0.0.1', protocol: 'https:' }, opts]
+      ];
+
+      const serverClose = new Countdown(items.length, () =>
+        setImmediate(() => server.close())
+      );
+
+      const maybeClose = common.mustCall((client) => {
+        client.close();
+        serverClose.dec();
+      }, items.length);
+
+      items.forEach((i) => {
+        const client = h2.connect
+          .apply(null, i)
           .on('connect', common.mustCall(() => maybeClose(client)));
-    });
-  }));
+      });
+    })
+  );
 }
diff --git a/test/parallel/test-http2-create-client-secure-session.js b/test/parallel/test-http2-create-client-secure-session.js
index 8b2aa1c168cb5e..66ca6dcc13e530 100644
--- a/test/parallel/test-http2-create-client-secure-session.js
+++ b/test/parallel/test-http2-create-client-secure-session.js
@@ -4,8 +4,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -24,70 +23,93 @@ function onStream(stream, headers) {
   assert.strictEqual(stream.session.alpnProtocol, 'h2');
   const originSet = stream.session.originSet;
   assert(Array.isArray(originSet));
-  assert.strictEqual(originSet[0],
-                     `https://${socket.servername}:${socket.remotePort}`);
+  assert.strictEqual(
+    originSet[0],
+    `https://${socket.servername}:${socket.remotePort}`
+  );
 
   assert(headers[':authority'].startsWith(socket.servername));
   stream.respond({ 'content-type': 'application/json' });
-  stream.end(JSON.stringify({
-    servername: socket.servername,
-    alpnProtocol: socket.alpnProtocol
-  }));
+  stream.end(
+    JSON.stringify({
+      servername: socket.servername,
+      alpnProtocol: socket.alpnProtocol
+    })
+  );
 }
 
 function verifySecureSession(key, cert, ca, opts) {
   const server = h2.createSecureServer({ cert, key });
   server.on('stream', common.mustCall(onStream));
   server.on('close', common.mustCall());
-  server.listen(0, common.mustCall(() => {
-    opts = opts || { };
-    opts.secureContext = tls.createSecureContext({ ca });
-    const client = h2.connect(`https://localhost:${server.address().port}`,
-                              opts);
-    // Verify that a 'secureConnect' listener is attached
-    assert.strictEqual(client.socket.listenerCount('secureConnect'), 1);
-    const req = client.request();
+  server.listen(
+    0,
+    common.mustCall(() => {
+      opts = opts || {};
+      opts.secureContext = tls.createSecureContext({ ca });
+      const client = h2.connect(
+        `https://localhost:${server.address().port}`,
+        opts
+      );
+      // Verify that a 'secureConnect' listener is attached
+      assert.strictEqual(client.socket.listenerCount('secureConnect'), 1);
+      const req = client.request();
 
-    client.on('connect', common.mustCall(() => {
-      assert(client.encrypted);
-      assert.strictEqual(client.alpnProtocol, 'h2');
-      const originSet = client.originSet;
-      assert(Array.isArray(originSet));
-      assert.strictEqual(originSet.length, 1);
-      assert.strictEqual(
-        originSet[0],
-        `https://${opts.servername || 'localhost'}:${server.address().port}`);
-    }));
+      client.on(
+        'connect',
+        common.mustCall(() => {
+          assert(client.encrypted);
+          assert.strictEqual(client.alpnProtocol, 'h2');
+          const originSet = client.originSet;
+          assert(Array.isArray(originSet));
+          assert.strictEqual(originSet.length, 1);
+          assert.strictEqual(
+            originSet[0],
+            `https://${opts.servername || 'localhost'}:${server.address().port}`
+          );
+        })
+      );
 
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers[':status'], 200);
-      assert.strictEqual(headers['content-type'], 'application/json');
-      assert(headers.date);
-    }));
+      req.on(
+        'response',
+        common.mustCall((headers) => {
+          assert.strictEqual(headers[':status'], 200);
+          assert.strictEqual(headers['content-type'], 'application/json');
+          assert(headers.date);
+        })
+      );
 
-    let data = '';
-    req.setEncoding('utf8');
-    req.on('data', (d) => data += d);
-    req.on('end', common.mustCall(() => {
-      const jsonData = JSON.parse(data);
-      assert.strictEqual(jsonData.servername,
-                         opts.servername || 'localhost');
-      assert.strictEqual(jsonData.alpnProtocol, 'h2');
-      server.close(common.mustCall());
-      client[kSocket].destroy();
-    }));
-  }));
+      let data = '';
+      req.setEncoding('utf8');
+      req.on('data', (d) => (data += d));
+      req.on(
+        'end',
+        common.mustCall(() => {
+          const jsonData = JSON.parse(data);
+          assert.strictEqual(
+            jsonData.servername,
+            opts.servername || 'localhost'
+          );
+          assert.strictEqual(jsonData.alpnProtocol, 'h2');
+          server.close(common.mustCall());
+          client[kSocket].destroy();
+        })
+      );
+    })
+  );
 }
 
 // The server can be connected as 'localhost'.
 verifySecureSession(
   loadKey('agent8-key.pem'),
   loadKey('agent8-cert.pem'),
-  loadKey('fake-startcom-root-cert.pem'));
+  loadKey('fake-startcom-root-cert.pem')
+);
 
 // Custom servername is specified.
 verifySecureSession(
   loadKey('agent1-key.pem'),
   loadKey('agent1-cert.pem'),
   loadKey('ca1-cert.pem'),
-  { servername: 'agent1' });
+  { servername: 'agent1' }
+);
diff --git a/test/parallel/test-http2-create-client-session.js b/test/parallel/test-http2-create-client-session.js
index 35de927ea7924e..20cea07c6a7d44 100644
--- a/test/parallel/test-http2-create-client-session.js
+++ b/test/parallel/test-http2-create-client-session.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const Countdown = require('../common/countdown');
@@ -33,39 +32,50 @@ server.on('close', common.mustCall());
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    client.setMaxListeners(101);
 
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  client.setMaxListeners(101);
+    client.on('goaway', console.log);
 
-  client.on('goaway', console.log);
+    client.on(
+      'connect',
+      common.mustCall(() => {
+        assert(!client.encrypted);
+        assert(!client.originSet);
+        assert.strictEqual(client.alpnProtocol, 'h2c');
+      })
+    );
 
-  client.on('connect', common.mustCall(() => {
-    assert(!client.encrypted);
-    assert(!client.originSet);
-    assert.strictEqual(client.alpnProtocol, 'h2c');
-  }));
+    const countdown = new Countdown(count, () => {
+      client.close();
+      server.close(common.mustCall());
+    });
 
-  const countdown = new Countdown(count, () => {
-    client.close();
-    server.close(common.mustCall());
-  });
-
-  for (let n = 0; n < count; n++) {
-    const req = client.request();
+    for (let n = 0; n < count; n++) {
+      const req = client.request();
 
-    req.on('response', common.mustCall(function(headers) {
-      assert.strictEqual(headers[':status'], 200);
-      assert.strictEqual(headers['content-type'], 'text/html');
-      assert(headers.date);
-    }));
+      req.on(
+        'response',
+        common.mustCall(function(headers) {
+          assert.strictEqual(headers[':status'], 200);
+          assert.strictEqual(headers['content-type'], 'text/html');
+          assert(headers.date);
+        })
+      );
 
-    let data = '';
-    req.setEncoding('utf8');
-    req.on('data', (d) => data += d);
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(body, data);
-    }));
-    req.on('close', common.mustCall(() => countdown.dec()));
-  }
-}));
+      let data = '';
+      req.setEncoding('utf8');
+      req.on('data', (d) => (data += d));
+      req.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(body, data);
+        })
+      );
+      req.on('close', common.mustCall(() => countdown.dec()));
+    }
+  })
+);
diff --git a/test/parallel/test-http2-createsecureserver-nooptions.js b/test/parallel/test-http2-createsecureserver-nooptions.js
index 767797febc48f0..b3eb5db17b6aef 100644
--- a/test/parallel/test-http2-createsecureserver-nooptions.js
+++ b/test/parallel/test-http2-createsecureserver-nooptions.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http2 = require('http2');
@@ -10,13 +9,11 @@ const http2 = require('http2');
 // Error if options are not passed to createSecureServer
 const invalidOptions = [() => {}, 1, 'test', null];
 invalidOptions.forEach((invalidOption) => {
-  assert.throws(
-    () => http2.createSecureServer(invalidOption),
-    {
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: 'The "options" argument must be of type Object. Received ' +
-               `type ${typeof invalidOption}`
-    }
-  );
+  assert.throws(() => http2.createSecureServer(invalidOption), {
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "options" argument must be of type Object. Received ' +
+      `type ${typeof invalidOption}`
+  });
 });
diff --git a/test/parallel/test-http2-createwritereq.js b/test/parallel/test-http2-createwritereq.js
index 1575424d1609b4..6847deb0766ba2 100644
--- a/test/parallel/test-http2-createwritereq.js
+++ b/test/parallel/test-http2-createwritereq.js
@@ -3,8 +3,7 @@
 // Flags: --expose-gc
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -14,65 +13,76 @@ const http2 = require('http2');
 const testString = 'a\u00A1\u0100\uD83D\uDE00';
 
 const encodings = {
-  'buffer': 'utf8',
-  'ascii': 'ascii',
-  'latin1': 'latin1',
-  'binary': 'latin1',
-  'utf8': 'utf8',
+  buffer: 'utf8',
+  ascii: 'ascii',
+  latin1: 'latin1',
+  binary: 'latin1',
+  utf8: 'utf8',
   'utf-8': 'utf8',
-  'ucs2': 'ucs2',
+  ucs2: 'ucs2',
   'ucs-2': 'ucs2',
-  'utf16le': 'ucs2',
+  utf16le: 'ucs2',
   'utf-16le': 'ucs2',
-  'UTF8': 'utf8' // should fall through to Buffer.from
+  UTF8: 'utf8' // should fall through to Buffer.from
 };
 
 const testsToRun = Object.keys(encodings).length;
 let testsFinished = 0;
 
-const server = http2.createServer(common.mustCall((req, res) => {
-  const testEncoding = encodings[req.url.slice(1)];
+const server = http2.createServer(
+  common.mustCall((req, res) => {
+    const testEncoding = encodings[req.url.slice(1)];
 
-  req.on('data', common.mustCall((chunk) => assert.ok(
-    Buffer.from(testString, testEncoding).equals(chunk)
-  )));
+    req.on(
+      'data',
+      common.mustCall((chunk) =>
+        assert.ok(Buffer.from(testString, testEncoding).equals(chunk))
+      )
+    );
 
-  req.on('end', () => res.end());
-}, Object.keys(encodings).length));
+    req.on('end', () => res.end());
+  }, Object.keys(encodings).length)
+);
 
-server.listen(0, common.mustCall(function() {
-  Object.keys(encodings).forEach((writeEncoding) => {
-    const client = http2.connect(`http://localhost:${this.address().port}`);
-    const req = client.request({
-      ':path': `/${writeEncoding}`,
-      ':method': 'POST'
-    });
+server.listen(
+  0,
+  common.mustCall(function() {
+    Object.keys(encodings).forEach((writeEncoding) => {
+      const client = http2.connect(`http://localhost:${this.address().port}`);
+      const req = client.request({
+        ':path': `/${writeEncoding}`,
+        ':method': 'POST'
+      });
 
-    assert.strictEqual(req._writableState.decodeStrings, false);
-    req.write(
-      writeEncoding !== 'buffer' ? testString : Buffer.from(testString),
-      writeEncoding !== 'buffer' ? writeEncoding : undefined
-    );
-    req.resume();
+      assert.strictEqual(req._writableState.decodeStrings, false);
+      req.write(
+        writeEncoding !== 'buffer' ? testString : Buffer.from(testString),
+        writeEncoding !== 'buffer' ? writeEncoding : undefined
+      );
+      req.resume();
 
-    req.on('end', common.mustCall(function() {
-      client.close();
-      testsFinished++;
+      req.on(
+        'end',
+        common.mustCall(function() {
+          client.close();
+          testsFinished++;
 
-      if (testsFinished === testsToRun) {
-        server.close(common.mustCall());
-      }
-    }));
+          if (testsFinished === testsToRun) {
+            server.close(common.mustCall());
+          }
+        })
+      );
 
-    // Ref: https://github.com/nodejs/node/issues/17840
-    const origDestroy = req.destroy;
-    req.destroy = function(...args) {
-      // Schedule a garbage collection event at the end of the current
-      // MakeCallback() run.
-      process.nextTick(global.gc);
-      return origDestroy.call(this, ...args);
-    };
+      // Ref: https://github.com/nodejs/node/issues/17840
+      const origDestroy = req.destroy;
+      req.destroy = function(...args) {
+        // Schedule a garbage collection event at the end of the current
+        // MakeCallback() run.
+        process.nextTick(global.gc);
+        return origDestroy.call(this, ...args);
+      };
 
-    req.end();
-  });
-}));
+      req.end();
+    });
+  })
+);
diff --git a/test/parallel/test-http2-date-header.js b/test/parallel/test-http2-date-header.js
index 2b63e1b7899a2e..4c39fcaa75abcc 100644
--- a/test/parallel/test-http2-date-header.js
+++ b/test/parallel/test-http2-date-header.js
@@ -1,29 +1,40 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  // Date header is defaulted
-  stream.respond();
-  stream.end();
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    // Date header is defaulted
+    stream.respond();
+    stream.end();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  req.on('response', common.mustCall((headers) => {
-    // The date header must be set to a non-invalid value
-    assert.notStrictEqual((new Date()).toString(), 'Invalid Date');
-  }));
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        // The date header must be set to a non-invalid value
+        assert.notStrictEqual(new Date().toString(), 'Invalid Date');
+      })
+    );
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-debug.js b/test/parallel/test-http2-debug.js
index ad86e76ab75771..20478f2fd03f3f 100644
--- a/test/parallel/test-http2-debug.js
+++ b/test/parallel/test-http2-debug.js
@@ -1,23 +1,40 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const child_process = require('child_process');
 const path = require('path');
 
 process.env.NODE_DEBUG_NATIVE = 'http2';
 process.env.NODE_DEBUG = 'http2';
-const { stdout, stderr } = child_process.spawnSync(process.execPath, [
-  path.resolve(__dirname, 'test-http2-ping.js')
-], { encoding: 'utf8' });
+const { stdout, stderr } = child_process.spawnSync(
+  process.execPath,
+  [path.resolve(__dirname, 'test-http2-ping.js')],
+  { encoding: 'utf8' }
+);
 
-assert(stderr.match(/Setting the NODE_DEBUG environment variable to 'http2' can expose sensitive data \(such as passwords, tokens and authentication headers\) in the resulting log\./),
-       stderr);
-assert(stderr.match(/Http2Session client \(\d+\) handling data frame for stream \d+/),
-       stderr);
-assert(stderr.match(/HttpStream \d+ \(\d+\) \[Http2Session client \(\d+\)\] reading starting/),
-       stderr);
-assert(stderr.match(/HttpStream \d+ \(\d+\) \[Http2Session server \(\d+\)\] tearing down stream/),
-       stderr);
+assert(
+  stderr.match(
+    /Setting the NODE_DEBUG environment variable to 'http2' can expose sensitive data \(such as passwords, tokens and authentication headers\) in the resulting log\./
+  ),
+  stderr
+);
+assert(
+  stderr.match(
+    /Http2Session client \(\d+\) handling data frame for stream \d+/
+  ),
+  stderr
+);
+assert(
+  stderr.match(
+    /HttpStream \d+ \(\d+\) \[Http2Session client \(\d+\)\] reading starting/
+  ),
+  stderr
+);
+assert(
+  stderr.match(
+    /HttpStream \d+ \(\d+\) \[Http2Session server \(\d+\)\] tearing down stream/
+  ),
+  stderr
+);
 assert.strictEqual(stdout.trim(), '');
diff --git a/test/parallel/test-http2-dont-lose-data.js b/test/parallel/test-http2-dont-lose-data.js
index eb85277b7b124c..a27b2284ed3aa4 100644
--- a/test/parallel/test-http2-dont-lose-data.js
+++ b/test/parallel/test-http2-dont-lose-data.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -11,11 +10,14 @@ const server = http2.createServer();
 server.on('stream', (s) => {
   assert(s.pushAllowed);
 
-  s.pushStream({ ':path': '/file' }, common.mustCall((err, pushStream) => {
-    assert.ifError(err);
-    pushStream.respond();
-    pushStream.end('a push stream');
-  }));
+  s.pushStream(
+    { ':path': '/file' },
+    common.mustCall((err, pushStream) => {
+      assert.ifError(err);
+      pushStream.respond();
+      pushStream.end('a push stream');
+    })
+  );
 
   s.respond();
   s.end('hello world');
@@ -31,28 +33,40 @@ server.listen(0, () => {
 
   let pushStream;
 
-  client.on('stream', common.mustCall((s, headers) => {
-    assert.strictEqual(headers[':path'], '/file');
-    pushStream = s;
-  }));
-
-  req.on('response', common.mustCall((headers) => {
-    let pushData = '';
-    pushStream.setEncoding('utf8');
-    pushStream.on('data', (d) => pushData += d);
-    pushStream.on('end', common.mustCall(() => {
-      assert.strictEqual(pushData, 'a push stream');
-
-      // removing the setImmediate causes the test to pass
-      setImmediate(function() {
-        let data = '';
-        req.setEncoding('utf8');
-        req.on('data', (d) => data += d);
-        req.on('end', common.mustCall(() => {
-          assert.strictEqual(data, 'hello world');
-          client.close();
-        }));
-      });
-    }));
-  }));
+  client.on(
+    'stream',
+    common.mustCall((s, headers) => {
+      assert.strictEqual(headers[':path'], '/file');
+      pushStream = s;
+    })
+  );
+
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      let pushData = '';
+      pushStream.setEncoding('utf8');
+      pushStream.on('data', (d) => (pushData += d));
+      pushStream.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(pushData, 'a push stream');
+
+          // removing the setImmediate causes the test to pass
+          setImmediate(function() {
+            let data = '';
+            req.setEncoding('utf8');
+            req.on('data', (d) => (data += d));
+            req.on(
+              'end',
+              common.mustCall(() => {
+                assert.strictEqual(data, 'hello world');
+                client.close();
+              })
+            );
+          });
+        })
+      );
+    })
+  );
 });
diff --git a/test/parallel/test-http2-dont-override.js b/test/parallel/test-http2-dont-override.js
index b45713deb3ca60..8a4c0096b6bd6a 100644
--- a/test/parallel/test-http2-dont-override.js
+++ b/test/parallel/test-http2-dont-override.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -13,37 +12,46 @@ const server = http2.createServer(options);
 // options are defaulted but the options are not modified
 assert.deepStrictEqual(Object.keys(options), []);
 
-server.on('stream', common.mustCall((stream) => {
-  const headers = {};
-  const options = {};
-  stream.respond(headers, options);
-
-  // The headers are defaulted but the original object is not modified
-  assert.deepStrictEqual(Object.keys(headers), []);
-
-  // Options are defaulted but the original object is not modified
-  assert.deepStrictEqual(Object.keys(options), []);
-
-  stream.end();
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-
-  const headers = {};
-  const options = {};
-
-  const req = client.request(headers, options);
-
-  // The headers are defaulted but the original object is not modified
-  assert.deepStrictEqual(Object.keys(headers), []);
-
-  // Options are defaulted but the original object is not modified
-  assert.deepStrictEqual(Object.keys(options), []);
-
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    const headers = {};
+    const options = {};
+    stream.respond(headers, options);
+
+    // The headers are defaulted but the original object is not modified
+    assert.deepStrictEqual(Object.keys(headers), []);
+
+    // Options are defaulted but the original object is not modified
+    assert.deepStrictEqual(Object.keys(options), []);
+
+    stream.end();
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    const headers = {};
+    const options = {};
+
+    const req = client.request(headers, options);
+
+    // The headers are defaulted but the original object is not modified
+    assert.deepStrictEqual(Object.keys(headers), []);
+
+    // Options are defaulted but the original object is not modified
+    assert.deepStrictEqual(Object.keys(options), []);
+
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-endafterheaders.js b/test/parallel/test-http2-endafterheaders.js
index 429ffc3188452d..8157792b2d36ee 100644
--- a/test/parallel/test-http2-endafterheaders.js
+++ b/test/parallel/test-http2-endafterheaders.js
@@ -1,50 +1,67 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const check = headers[':method'] === 'GET' ? true : false;
-  assert.strictEqual(stream.endAfterHeaders, check);
-  stream.on('data', common.mustNotCall());
-  stream.on('end', common.mustCall());
-  stream.respond();
-  stream.end('ok');
-}, 2));
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    const check = headers[':method'] === 'GET' ? true : false;
+    assert.strictEqual(stream.endAfterHeaders, check);
+    stream.on('data', common.mustNotCall());
+    stream.on('end', common.mustCall());
+    stream.respond();
+    stream.end('ok');
+  }, 2)
+);
 
 const countdown = new Countdown(2, () => server.close());
 
-server.listen(0, common.mustCall(() => {
-  {
-    const client = http2.connect(`http://localhost:${server.address().port}`);
-    const req = client.request();
+server.listen(
+  0,
+  common.mustCall(() => {
+    {
+      const client = http2.connect(`http://localhost:${server.address().port}`);
+      const req = client.request();
 
-    req.resume();
-    req.on('response', common.mustCall(() => {
-      assert.strictEqual(req.endAfterHeaders, false);
-    }));
-    req.on('end', common.mustCall(() => {
-      client.close();
-      countdown.dec();
-    }));
-  }
-  {
-    const client = http2.connect(`http://localhost:${server.address().port}`);
-    const req = client.request({ ':method': 'POST' });
+      req.resume();
+      req.on(
+        'response',
+        common.mustCall(() => {
+          assert.strictEqual(req.endAfterHeaders, false);
+        })
+      );
+      req.on(
+        'end',
+        common.mustCall(() => {
+          client.close();
+          countdown.dec();
+        })
+      );
+    }
+    {
+      const client = http2.connect(`http://localhost:${server.address().port}`);
+      const req = client.request({ ':method': 'POST' });
 
-    req.resume();
-    req.end();
-    req.on('response', common.mustCall(() => {
-      assert.strictEqual(req.endAfterHeaders, false);
-    }));
-    req.on('end', common.mustCall(() => {
-      client.close();
-      countdown.dec();
-    }));
-  }
-}));
+      req.resume();
+      req.end();
+      req.on(
+        'response',
+        common.mustCall(() => {
+          assert.strictEqual(req.endAfterHeaders, false);
+        })
+      );
+      req.on(
+        'end',
+        common.mustCall(() => {
+          client.close();
+          countdown.dec();
+        })
+      );
+    }
+  })
+);
diff --git a/test/parallel/test-http2-forget-closed-streams.js b/test/parallel/test-http2-forget-closed-streams.js
index c0b3bcd819140c..399485bd418e4c 100644
--- a/test/parallel/test-http2-forget-closed-streams.js
+++ b/test/parallel/test-http2-forget-closed-streams.js
@@ -22,13 +22,19 @@ const server = http2.createServer({ maxSessionMemory: 1 });
 
 server.on('session', function(session) {
   session.on('stream', function(stream) {
-    stream.on('end', common.mustCall(function() {
-      this.respond({
-        ':status': 200
-      }, {
-        endStream: true
-      });
-    }));
+    stream.on(
+      'end',
+      common.mustCall(function() {
+        this.respond(
+          {
+            ':status': 200
+          },
+          {
+            endStream: true
+          }
+        );
+      })
+    );
     stream.resume();
   });
 });
@@ -42,10 +48,13 @@ server.listen(0, function() {
       return server.close();
     }
     const stream = client.request({ ':method': 'POST' });
-    stream.on('response', common.mustCall(function(headers) {
-      assert.strictEqual(headers[':status'], 200);
-      this.on('close', common.mustCall(() => next(i + 1)));
-    }));
+    stream.on(
+      'response',
+      common.mustCall(function(headers) {
+        assert.strictEqual(headers[':status'], 200);
+        this.on('close', common.mustCall(() => next(i + 1)));
+      })
+    );
     stream.end();
   }
 
diff --git a/test/parallel/test-http2-generic-streams-sendfile.js b/test/parallel/test-http2-generic-streams-sendfile.js
index b752b0fdcb815a..3c5ca98761e922 100644
--- a/test/parallel/test-http2-generic-streams-sendfile.js
+++ b/test/parallel/test-http2-generic-streams-sendfile.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const fs = require('fs');
@@ -9,30 +8,42 @@ const makeDuplexPair = require('../common/duplexpair');
 
 {
   const server = http2.createServer();
-  server.on('stream', common.mustCall((stream, headers) => {
-    stream.respondWithFile(__filename);
-  }));
+  server.on(
+    'stream',
+    common.mustCall((stream, headers) => {
+      stream.respondWithFile(__filename);
+    })
+  );
 
   const { clientSide, serverSide } = makeDuplexPair();
   server.emit('connection', serverSide);
 
-  const client = http2.connect('http://localhost:80', {
-    createConnection: common.mustCall(() => clientSide)
-  });
+  const client = http2.connect(
+    'http://localhost:80',
+    {
+      createConnection: common.mustCall(() => clientSide)
+    }
+  );
 
   const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 200);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 200);
+    })
+  );
 
   req.setEncoding('utf8');
   let data = '';
-  req.on('data', (chunk) => data += chunk);
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(data, fs.readFileSync(__filename, 'utf8'));
-    clientSide.destroy();
-    clientSide.end();
-  }));
+  req.on('data', (chunk) => (data += chunk));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(data, fs.readFileSync(__filename, 'utf8'));
+      clientSide.destroy();
+      clientSide.end();
+    })
+  );
   req.end();
 }
diff --git a/test/parallel/test-http2-generic-streams.js b/test/parallel/test-http2-generic-streams.js
index d97e86a5ecea55..cf71568bb33a61 100644
--- a/test/parallel/test-http2-generic-streams.js
+++ b/test/parallel/test-http2-generic-streams.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const makeDuplexPair = require('../common/duplexpair');
@@ -9,37 +8,52 @@ const makeDuplexPair = require('../common/duplexpair');
 {
   const testData = '<h1>Hello World</h1>';
   const server = http2.createServer();
-  server.on('stream', common.mustCall((stream, headers) => {
-    stream.respond({
-      'content-type': 'text/html',
-      ':status': 200
-    });
-    stream.end(testData);
-  }));
+  server.on(
+    'stream',
+    common.mustCall((stream, headers) => {
+      stream.respond({
+        'content-type': 'text/html',
+        ':status': 200
+      });
+      stream.end(testData);
+    })
+  );
 
   const { clientSide, serverSide } = makeDuplexPair();
   server.emit('connection', serverSide);
 
-  const client = http2.connect('http://localhost:80', {
-    createConnection: common.mustCall(() => clientSide)
-  });
+  const client = http2.connect(
+    'http://localhost:80',
+    {
+      createConnection: common.mustCall(() => clientSide)
+    }
+  );
 
   const req = client.request({ ':path': '/' });
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 200);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 200);
+    })
+  );
 
   req.setEncoding('utf8');
   // Note: This is checking that this small amount of data is passed through in
   // a single chunk, which is unusual for our test suite but seems like a
   // reasonable assumption here.
-  req.on('data', common.mustCall((data) => {
-    assert.strictEqual(data, testData);
-  }));
-  req.on('end', common.mustCall(() => {
-    clientSide.destroy();
-    clientSide.end();
-  }));
+  req.on(
+    'data',
+    common.mustCall((data) => {
+      assert.strictEqual(data, testData);
+    })
+  );
+  req.on(
+    'end',
+    common.mustCall(() => {
+      clientSide.destroy();
+      clientSide.end();
+    })
+  );
   req.end();
 }
diff --git a/test/parallel/test-http2-getpackedsettings.js b/test/parallel/test-http2-getpackedsettings.js
index 77c8cf442f5f27..6bbe526fa498a3 100644
--- a/test/parallel/test-http2-getpackedsettings.js
+++ b/test/parallel/test-http2-getpackedsettings.js
@@ -1,16 +1,42 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
-const check = Buffer.from([0x00, 0x01, 0x00, 0x00, 0x10, 0x00,
-                           0x00, 0x05, 0x00, 0x00, 0x40, 0x00,
-                           0x00, 0x04, 0x00, 0x00, 0xff, 0xff,
-                           0x00, 0x06, 0x00, 0x00, 0xff, 0xff,
-                           0x00, 0x02, 0x00, 0x00, 0x00, 0x01]);
+const check = Buffer.from([
+  0x00,
+  0x01,
+  0x00,
+  0x00,
+  0x10,
+  0x00,
+  0x00,
+  0x05,
+  0x00,
+  0x00,
+  0x40,
+  0x00,
+  0x00,
+  0x04,
+  0x00,
+  0x00,
+  0xff,
+  0xff,
+  0x00,
+  0x06,
+  0x00,
+  0x00,
+  0xff,
+  0xff,
+  0x00,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x01
+]);
 const val = http2.getPackedSettings(http2.getDefaultSettings());
 assert.deepStrictEqual(val, check);
 
@@ -45,33 +71,70 @@ http2.getPackedSettings({ enablePush: false });
   ['maxHeaderListSize', -1],
   ['maxHeaderListSize', 2 ** 32]
 ].forEach((i) => {
-  common.expectsError(() => {
-    http2.getPackedSettings({ [i[0]]: i[1] });
-  }, {
-    code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-    type: RangeError,
-    message: `Invalid value for setting "${i[0]}": ${i[1]}`
-  });
+  common.expectsError(
+    () => {
+      http2.getPackedSettings({ [i[0]]: i[1] });
+    },
+    {
+      code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+      type: RangeError,
+      message: `Invalid value for setting "${i[0]}": ${i[1]}`
+    }
+  );
 });
 
-[
-  1, null, '', Infinity, new Date(), {}, NaN, [false]
-].forEach((i) => {
-  common.expectsError(() => {
-    http2.getPackedSettings({ enablePush: i });
-  }, {
-    code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-    type: TypeError,
-    message: `Invalid value for setting "enablePush": ${i}`
-  });
+[1, null, '', Infinity, new Date(), {}, NaN, [false]].forEach((i) => {
+  common.expectsError(
+    () => {
+      http2.getPackedSettings({ enablePush: i });
+    },
+    {
+      code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+      type: TypeError,
+      message: `Invalid value for setting "enablePush": ${i}`
+    }
+  );
 });
 
 {
   const check = Buffer.from([
-    0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x03, 0x00, 0x00,
-    0x00, 0xc8, 0x00, 0x05, 0x00, 0x00, 0x4e, 0x20, 0x00, 0x04,
-    0x00, 0x00, 0x00, 0x64, 0x00, 0x06, 0x00, 0x00, 0x00, 0x64,
-    0x00, 0x02, 0x00, 0x00, 0x00, 0x01]);
+    0x00,
+    0x01,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x03,
+    0x00,
+    0x00,
+    0x00,
+    0xc8,
+    0x00,
+    0x05,
+    0x00,
+    0x00,
+    0x4e,
+    0x20,
+    0x00,
+    0x04,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x06,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x02,
+    0x00,
+    0x00,
+    0x00,
+    0x01
+  ]);
 
   const packed = http2.getPackedSettings({
     headerTableSize: 100,
@@ -94,30 +157,69 @@ http2.getPackedSettings({ enablePush: false });
 
 {
   const packed = Buffer.from([
-    0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x03, 0x00, 0x00,
-    0x00, 0xc8, 0x00, 0x05, 0x00, 0x00, 0x4e, 0x20, 0x00, 0x04,
-    0x00, 0x00, 0x00, 0x64, 0x00, 0x06, 0x00, 0x00, 0x00, 0x64,
-    0x00, 0x02, 0x00, 0x00, 0x00, 0x01]);
+    0x00,
+    0x01,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x03,
+    0x00,
+    0x00,
+    0x00,
+    0xc8,
+    0x00,
+    0x05,
+    0x00,
+    0x00,
+    0x4e,
+    0x20,
+    0x00,
+    0x04,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x06,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x02,
+    0x00,
+    0x00,
+    0x00,
+    0x01
+  ]);
 
   [1, true, '', [], {}, NaN].forEach((input) => {
-    common.expectsError(() => {
-      http2.getUnpackedSettings(input);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message:
-        'The "buf" argument must be one of type Buffer, TypedArray, or ' +
-        `DataView. Received type ${typeof input}`
-    });
+    common.expectsError(
+      () => {
+        http2.getUnpackedSettings(input);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "buf" argument must be one of type Buffer, TypedArray, or ' +
+          `DataView. Received type ${typeof input}`
+      }
+    );
   });
 
-  common.expectsError(() => {
-    http2.getUnpackedSettings(packed.slice(5));
-  }, {
-    code: 'ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH',
-    type: RangeError,
-    message: 'Packed settings length must be a multiple of six'
-  });
+  common.expectsError(
+    () => {
+      http2.getUnpackedSettings(packed.slice(5));
+    },
+    {
+      code: 'ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH',
+      type: RangeError,
+      message: 'Packed settings length must be a multiple of six'
+    }
+  );
 
   const settings = http2.getUnpackedSettings(packed);
 
@@ -131,15 +233,13 @@ http2.getPackedSettings({ enablePush: false });
 }
 
 {
-  const packed = Buffer.from([
-    0x00, 0x02, 0x00, 0x00, 0x00, 0x00]);
+  const packed = Buffer.from([0x00, 0x02, 0x00, 0x00, 0x00, 0x00]);
 
   const settings = http2.getUnpackedSettings(packed, { validate: true });
   assert.strictEqual(settings.enablePush, false);
 }
 {
-  const packed = Buffer.from([
-    0x00, 0x02, 0x00, 0x00, 0x00, 0x64]);
+  const packed = Buffer.from([0x00, 0x02, 0x00, 0x00, 0x00, 0x64]);
 
   const settings = http2.getUnpackedSettings(packed, { validate: true });
   assert.strictEqual(settings.enablePush, true);
@@ -148,10 +248,43 @@ http2.getPackedSettings({ enablePush: false });
 // Verify that passing {validate: true} does not throw.
 {
   const packed = Buffer.from([
-    0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x03, 0x00, 0x00,
-    0x00, 0xc8, 0x00, 0x05, 0x00, 0x00, 0x4e, 0x20, 0x00, 0x04,
-    0x00, 0x00, 0x00, 0x64, 0x00, 0x06, 0x00, 0x00, 0x00, 0x64,
-    0x00, 0x02, 0x00, 0x00, 0x00, 0x01]);
+    0x00,
+    0x01,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x03,
+    0x00,
+    0x00,
+    0x00,
+    0xc8,
+    0x00,
+    0x05,
+    0x00,
+    0x00,
+    0x4e,
+    0x20,
+    0x00,
+    0x04,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x06,
+    0x00,
+    0x00,
+    0x00,
+    0x64,
+    0x00,
+    0x02,
+    0x00,
+    0x00,
+    0x00,
+    0x01
+  ]);
 
   http2.getUnpackedSettings(packed, { validate: true });
 }
@@ -160,24 +293,30 @@ http2.getPackedSettings({ enablePush: false });
 {
   const packed = Buffer.from([0x00, 0x05, 0x01, 0x00, 0x00, 0x00]);
 
-  common.expectsError(() => {
-    http2.getUnpackedSettings(packed, { validate: true });
-  }, {
-    code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-    type: RangeError,
-    message: 'Invalid value for setting "maxFrameSize": 16777216'
-  });
+  common.expectsError(
+    () => {
+      http2.getUnpackedSettings(packed, { validate: true });
+    },
+    {
+      code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+      type: RangeError,
+      message: 'Invalid value for setting "maxFrameSize": 16777216'
+    }
+  );
 }
 
 // Check for maxConcurrentStreams failing the max number.
 {
-  const packed = Buffer.from([0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF]);
-
-  common.expectsError(() => {
-    http2.getUnpackedSettings(packed, { validate: true });
-  }, {
-    code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-    type: RangeError,
-    message: 'Invalid value for setting "maxConcurrentStreams": 4294967295'
-  });
+  const packed = Buffer.from([0x00, 0x03, 0xff, 0xff, 0xff, 0xff]);
+
+  common.expectsError(
+    () => {
+      http2.getUnpackedSettings(packed, { validate: true });
+    },
+    {
+      code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+      type: RangeError,
+      message: 'Invalid value for setting "maxConcurrentStreams": 4294967295'
+    }
+  );
 }
diff --git a/test/parallel/test-http2-goaway-opaquedata.js b/test/parallel/test-http2-goaway-opaquedata.js
index 3f1fb4d7954414..6a91c6187f479c 100644
--- a/test/parallel/test-http2-goaway-opaquedata.js
+++ b/test/parallel/test-http2-goaway-opaquedata.js
@@ -1,29 +1,33 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const server = http2.createServer();
 const data = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
 
-server.on('stream', common.mustCall((stream) => {
-  stream.session.goaway(0, 0, data);
-  stream.respond();
-  stream.end();
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.session.goaway(0, 0, data);
+    stream.respond();
+    stream.end();
+  })
+);
 
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
-  client.once('goaway', common.mustCall((code, lastStreamID, buf) => {
-    assert.deepStrictEqual(code, 0);
-    assert.deepStrictEqual(lastStreamID, 1);
-    assert.deepStrictEqual(data, buf);
-    server.close();
-  }));
+  client.once(
+    'goaway',
+    common.mustCall((code, lastStreamID, buf) => {
+      assert.deepStrictEqual(code, 0);
+      assert.deepStrictEqual(lastStreamID, 1);
+      assert.deepStrictEqual(data, buf);
+      server.close();
+    })
+  );
   const req = client.request();
   req.resume();
   req.on('end', common.mustCall());
diff --git a/test/parallel/test-http2-head-request.js b/test/parallel/test-http2-head-request.js
index a56abf3c9006f3..1f0be44ad87bee 100644
--- a/test/parallel/test-http2-head-request.js
+++ b/test/parallel/test-http2-head-request.js
@@ -1,27 +1,28 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
-const errCheck = common.expectsError({
-  type: Error,
-  code: 'ERR_STREAM_WRITE_AFTER_END',
-  message: 'write after end'
-}, 2);
+const errCheck = common.expectsError(
+  {
+    type: Error,
+    code: 'ERR_STREAM_WRITE_AFTER_END',
+    message: 'write after end'
+  },
+  2
+);
 
 const {
   HTTP2_HEADER_PATH,
   HTTP2_HEADER_METHOD,
   HTTP2_HEADER_STATUS,
-  HTTP2_METHOD_HEAD,
+  HTTP2_METHOD_HEAD
 } = http2.constants;
 
 const server = http2.createServer();
 server.on('stream', (stream, headers) => {
-
   assert.strictEqual(headers[HTTP2_HEADER_METHOD], HTTP2_METHOD_HEAD);
 
   stream.respond({ [HTTP2_HEADER_STATUS]: 200 });
@@ -31,9 +32,7 @@ server.on('stream', (stream, headers) => {
   stream.write('data');
 });
 
-
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
 
   const req = client.request({
@@ -47,13 +46,19 @@ server.listen(0, () => {
   req.on('error', common.mustCall(errCheck));
   req.write('data');
 
-  req.on('response', common.mustCall((headers, flags) => {
-    assert.strictEqual(headers[HTTP2_HEADER_STATUS], 200);
-    assert.strictEqual(flags, 5); // the end of stream flag is set
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers, flags) => {
+      assert.strictEqual(headers[HTTP2_HEADER_STATUS], 200);
+      assert.strictEqual(flags, 5); // the end of stream flag is set
+    })
+  );
   req.on('data', common.mustNotCall());
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      server.close();
+      client.close();
+    })
+  );
 });
diff --git a/test/parallel/test-http2-https-fallback-http-server-options.js b/test/parallel/test-http2-https-fallback-http-server-options.js
index 8143f56d491ccc..46c6344959861e 100644
--- a/test/parallel/test-http2-https-fallback-http-server-options.js
+++ b/test/parallel/test-http2-https-fallback-http-server-options.js
@@ -3,8 +3,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const url = require('url');
@@ -18,14 +17,17 @@ const cert = fixtures.readKey('agent8-cert.pem');
 const ca = fixtures.readKey('fake-startcom-root-cert.pem');
 
 function onRequest(request, response) {
-  const { socket: { alpnProtocol } } = request.httpVersion === '2.0' ?
-    request.stream.session : request;
+  const {
+    socket: { alpnProtocol }
+  } = request.httpVersion === '2.0' ? request.stream.session : request;
   response.status(200);
-  response.end(JSON.stringify({
-    alpnProtocol,
-    httpVersion: request.httpVersion,
-    userAgent: request.getUserAgent()
-  }));
+  response.end(
+    JSON.stringify({
+      alpnProtocol,
+      httpVersion: request.httpVersion,
+      userAgent: request.getUserAgent()
+    })
+  );
 }
 
 class MyIncomingMessage extends http.IncomingMessage {
@@ -45,7 +47,8 @@ class MyServerResponse extends http.ServerResponse {
   const server = http2.createSecureServer(
     {
       cert,
-      key, allowHTTP1: true,
+      key,
+      allowHTTP1: true,
       Http1IncomingMessage: MyIncomingMessage,
       Http1ServerResponse: MyServerResponse
     },
@@ -54,36 +57,44 @@ class MyServerResponse extends http.ServerResponse {
 
   server.listen(0);
 
-  server.on('listening', common.mustCall(() => {
-    const { port } = server.address();
-    const origin = `https://localhost:${port}`;
+  server.on(
+    'listening',
+    common.mustCall(() => {
+      const { port } = server.address();
+      const origin = `https://localhost:${port}`;
 
-    // HTTP/1.1 client
-    https.get(
-      Object.assign(url.parse(origin), {
-        secureContext: tls.createSecureContext({ ca }),
-        headers: { 'User-Agent': 'node-test' }
-      }),
-      common.mustCall((response) => {
-        assert.strictEqual(response.statusCode, 200);
-        assert.strictEqual(response.statusMessage, 'OK');
-        assert.strictEqual(
-          response.headers['content-type'],
-          'application/json'
-        );
+      // HTTP/1.1 client
+      https.get(
+        Object.assign(url.parse(origin), {
+          secureContext: tls.createSecureContext({ ca }),
+          headers: { 'User-Agent': 'node-test' }
+        }),
+        common.mustCall((response) => {
+          assert.strictEqual(response.statusCode, 200);
+          assert.strictEqual(response.statusMessage, 'OK');
+          assert.strictEqual(
+            response.headers['content-type'],
+            'application/json'
+          );
 
-        response.setEncoding('utf8');
-        let raw = '';
-        response.on('data', (chunk) => { raw += chunk; });
-        response.on('end', common.mustCall(() => {
-          const { alpnProtocol, httpVersion, userAgent } = JSON.parse(raw);
-          assert.strictEqual(alpnProtocol, false);
-          assert.strictEqual(httpVersion, '1.1');
-          assert.strictEqual(userAgent, 'node-test');
+          response.setEncoding('utf8');
+          let raw = '';
+          response.on('data', (chunk) => {
+            raw += chunk;
+          });
+          response.on(
+            'end',
+            common.mustCall(() => {
+              const { alpnProtocol, httpVersion, userAgent } = JSON.parse(raw);
+              assert.strictEqual(alpnProtocol, false);
+              assert.strictEqual(httpVersion, '1.1');
+              assert.strictEqual(userAgent, 'node-test');
 
-          server.close();
-        }));
-      })
-    );
-  }));
+              server.close();
+            })
+          );
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http2-https-fallback.js b/test/parallel/test-http2-https-fallback.js
index a872d686d34f85..83a092423ea670 100644
--- a/test/parallel/test-http2-https-fallback.js
+++ b/test/parallel/test-http2-https-fallback.js
@@ -3,8 +3,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const { strictEqual, ok } = require('assert');
 const { createSecureContext } = require('tls');
@@ -22,13 +21,16 @@ const ca = fixtures.readKey('fake-startcom-root-cert.pem');
 const clientOptions = { secureContext: createSecureContext({ ca }) };
 
 function onRequest(request, response) {
-  const { socket: { alpnProtocol } } = request.httpVersion === '2.0' ?
-    request.stream.session : request;
+  const {
+    socket: { alpnProtocol }
+  } = request.httpVersion === '2.0' ? request.stream.session : request;
   response.writeHead(200, { 'content-type': 'application/json' });
-  response.end(JSON.stringify({
-    alpnProtocol,
-    httpVersion: request.httpVersion
-  }));
+  response.end(
+    JSON.stringify({
+      alpnProtocol,
+      httpVersion: request.httpVersion
+    })
+  );
 }
 
 function onSession(session, next) {
@@ -40,25 +42,33 @@ function onSession(session, next) {
   };
 
   const request = session.request(headers);
-  request.on('response', common.mustCall((headers) => {
-    strictEqual(headers[':status'], 200);
-    strictEqual(headers['content-type'], 'application/json');
-  }));
+  request.on(
+    'response',
+    common.mustCall((headers) => {
+      strictEqual(headers[':status'], 200);
+      strictEqual(headers['content-type'], 'application/json');
+    })
+  );
   request.setEncoding('utf8');
   let raw = '';
-  request.on('data', (chunk) => { raw += chunk; });
-  request.on('end', common.mustCall(() => {
-    const { alpnProtocol, httpVersion } = JSON.parse(raw);
-    strictEqual(alpnProtocol, 'h2');
-    strictEqual(httpVersion, '2.0');
-
-    session.close();
-    this.cleanup();
-
-    if (typeof next === 'function') {
-      next();
-    }
-  }));
+  request.on('data', (chunk) => {
+    raw += chunk;
+  });
+  request.on(
+    'end',
+    common.mustCall(() => {
+      const { alpnProtocol, httpVersion } = JSON.parse(raw);
+      strictEqual(alpnProtocol, 'h2');
+      strictEqual(httpVersion, '2.0');
+
+      session.close();
+      this.cleanup();
+
+      if (typeof next === 'function') {
+        next();
+      }
+    })
+  );
   request.end();
 }
 
@@ -71,90 +81,110 @@ function onSession(session, next) {
 
   server.listen(0);
 
-  server.on('listening', common.mustCall(() => {
-    const { port } = server.address();
-    const origin = `https://localhost:${port}`;
-
-    const cleanup = countdown(2, () => server.close());
-
-    // HTTP/2 client
-    connect(
-      origin,
-      clientOptions,
-      common.mustCall(onSession.bind({ cleanup, server }))
-    );
-
-    // HTTP/1.1 client
-    get(
-      Object.assign(parse(origin), clientOptions),
-      common.mustCall((response) => {
-        strictEqual(response.statusCode, 200);
-        strictEqual(response.statusMessage, 'OK');
-        strictEqual(response.headers['content-type'], 'application/json');
-
-        response.setEncoding('utf8');
-        let raw = '';
-        response.on('data', (chunk) => { raw += chunk; });
-        response.on('end', common.mustCall(() => {
-          const { alpnProtocol, httpVersion } = JSON.parse(raw);
-          strictEqual(alpnProtocol, false);
-          strictEqual(httpVersion, '1.1');
-
-          cleanup();
-        }));
-      })
-    );
-  }));
+  server.on(
+    'listening',
+    common.mustCall(() => {
+      const { port } = server.address();
+      const origin = `https://localhost:${port}`;
+
+      const cleanup = countdown(2, () => server.close());
+
+      // HTTP/2 client
+      connect(
+        origin,
+        clientOptions,
+        common.mustCall(onSession.bind({ cleanup, server }))
+      );
+
+      // HTTP/1.1 client
+      get(
+        Object.assign(parse(origin), clientOptions),
+        common.mustCall((response) => {
+          strictEqual(response.statusCode, 200);
+          strictEqual(response.statusMessage, 'OK');
+          strictEqual(response.headers['content-type'], 'application/json');
+
+          response.setEncoding('utf8');
+          let raw = '';
+          response.on('data', (chunk) => {
+            raw += chunk;
+          });
+          response.on(
+            'end',
+            common.mustCall(() => {
+              const { alpnProtocol, httpVersion } = JSON.parse(raw);
+              strictEqual(alpnProtocol, false);
+              strictEqual(httpVersion, '1.1');
+
+              cleanup();
+            })
+          );
+        })
+      );
+    })
+  );
 }
 
 // HTTP/2-only server
 {
-  const server = createSecureServer(
-    { cert, key },
-    common.mustCall(onRequest)
-  );
+  const server = createSecureServer({ cert, key }, common.mustCall(onRequest));
 
-  server.once('unknownProtocol', common.mustCall((socket) => {
-    socket.destroy();
-  }));
+  server.once(
+    'unknownProtocol',
+    common.mustCall((socket) => {
+      socket.destroy();
+    })
+  );
 
   server.listen(0);
 
-  server.on('listening', common.mustCall(() => {
-    const { port } = server.address();
-    const origin = `https://localhost:${port}`;
-
-    const cleanup = countdown(3, () => server.close());
-
-    // HTTP/2 client
-    connect(
-      origin,
-      clientOptions,
-      common.mustCall(function(session) {
-        onSession.call({ cleanup, server },
-                       session,
-                       common.mustCall(testNoTls));
-      })
-    );
-
-    function testNoTls() {
-      // HTTP/1.1 client
-      get(Object.assign(parse(origin), clientOptions), common.mustNotCall)
-        .on('error', common.mustCall(cleanup))
-        .on('error', common.mustCall(testWrongALPN))
-        .end();
-    }
-
-    function testWrongALPN() {
-      // Incompatible ALPN TLS client
-      let text = '';
-      tls(Object.assign({ port, ALPNProtocols: ['fake'] }, clientOptions))
-        .setEncoding('utf8')
-        .on('data', (chunk) => text += chunk)
-        .on('end', common.mustCall(() => {
-          ok(/Unknown ALPN Protocol, expected `h2` to be available/.test(text));
-          cleanup();
-        }));
-    }
-  }));
+  server.on(
+    'listening',
+    common.mustCall(() => {
+      const { port } = server.address();
+      const origin = `https://localhost:${port}`;
+
+      const cleanup = countdown(3, () => server.close());
+
+      // HTTP/2 client
+      connect(
+        origin,
+        clientOptions,
+        common.mustCall(function(session) {
+          onSession.call(
+            { cleanup, server },
+            session,
+            common.mustCall(testNoTls)
+          );
+        })
+      );
+
+      function testNoTls() {
+        // HTTP/1.1 client
+        get(Object.assign(parse(origin), clientOptions), common.mustNotCall)
+          .on('error', common.mustCall(cleanup))
+          .on('error', common.mustCall(testWrongALPN))
+          .end();
+      }
+
+      function testWrongALPN() {
+        // Incompatible ALPN TLS client
+        let text = '';
+        tls(Object.assign({ port, ALPNProtocols: ['fake'] }, clientOptions))
+          .setEncoding('utf8')
+          .on('data', (chunk) => (text += chunk))
+          .on(
+            'end',
+            common.mustCall(() => {
+              ok(
+                /Unknown ALPN Protocol, expected `h2` to be available/.test(
+                  text
+                )
+              );
+              cleanup();
+            })
+          );
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-http2-info-headers-errors.js b/test/parallel/test-http2-info-headers-errors.js
index e2cae58466bb82..7eb4dc3d5ba562 100644
--- a/test/parallel/test-http2-info-headers-errors.js
+++ b/test/parallel/test-http2-info-headers-errors.js
@@ -2,15 +2,10 @@
 // Flags: --expose-internals
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const { internalBinding } = require('internal/test/binding');
-const {
-  constants,
-  Http2Stream,
-  nghttp2ErrorString
-} = internalBinding('http2');
+const { constants, Http2Stream, nghttp2ErrorString } = internalBinding('http2');
 const { NghttpError } = require('internal/http2/util');
 
 // tests error handling within additionalHeaders
@@ -20,9 +15,10 @@ const specificTestKeys = [];
 const specificTests = [];
 
 const genericTests = Object.getOwnPropertyNames(constants)
-  .filter((key) => (
-    key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
-  ))
+  .filter(
+    (key) =>
+      key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
+  )
   .map((key) => ({
     ngError: constants[key],
     error: {
@@ -34,7 +30,6 @@ const genericTests = Object.getOwnPropertyNames(constants)
     type: 'stream'
   }));
 
-
 const tests = specificTests.concat(genericTests);
 
 let currentError;
@@ -43,22 +38,25 @@ let currentError;
 Http2Stream.prototype.info = () => currentError.ngError;
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const errorMustCall = common.expectsError(currentError.error);
-  const errorMustNotCall = common.mustNotCall(
-    `${currentError.error.code} should emit on ${currentError.type}`
-  );
-
-  if (currentError.type === 'stream') {
-    stream.session.on('error', errorMustNotCall);
-    stream.on('error', errorMustCall);
-  } else {
-    stream.session.once('error', errorMustCall);
-    stream.on('error', errorMustNotCall);
-  }
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    const errorMustCall = common.expectsError(currentError.error);
+    const errorMustNotCall = common.mustNotCall(
+      `${currentError.error.code} should emit on ${currentError.type}`
+    );
+
+    if (currentError.type === 'stream') {
+      stream.session.on('error', errorMustNotCall);
+      stream.on('error', errorMustCall);
+    } else {
+      stream.session.once('error', errorMustCall);
+      stream.on('error', errorMustNotCall);
+    }
 
-  stream.additionalHeaders({ ':status': 100 });
-}, tests.length));
+    stream.additionalHeaders({ ':status': 100 });
+  }, tests.length)
+);
 
 server.listen(0, common.mustCall(() => runTest(tests.shift())));
 
@@ -70,19 +68,25 @@ function runTest(test) {
   req.resume();
   req.end();
 
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
-  }));
-
-  req.on('close', common.mustCall(() => {
-    client.close();
+  req.on(
+    'error',
+    common.expectsError({
+      code: 'ERR_HTTP2_STREAM_ERROR',
+      type: Error,
+      message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
+    })
+  );
 
-    if (!tests.length) {
-      server.close();
-    } else {
-      runTest(tests.shift());
-    }
-  }));
+  req.on(
+    'close',
+    common.mustCall(() => {
+      client.close();
+
+      if (!tests.length) {
+        server.close();
+      } else {
+        runTest(tests.shift());
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-http2-info-headers.js b/test/parallel/test-http2-info-headers.js
index 132818c4090037..19efbb23000ac4 100644
--- a/test/parallel/test-http2-info-headers.js
+++ b/test/parallel/test-http2-info-headers.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -11,35 +10,27 @@ const server = h2.createServer();
 // we use the lower-level API here
 server.on('stream', common.mustCall(onStream));
 
-const status101regex =
-  /^HTTP status code 101 \(Switching Protocols\) is forbidden in HTTP\/2$/;
-const afterRespondregex =
-  /^Cannot specify additional headers after response initiated$/;
+const status101regex = /^HTTP status code 101 \(Switching Protocols\) is forbidden in HTTP\/2$/;
+const afterRespondregex = /^Cannot specify additional headers after response initiated$/;
 
 function onStream(stream, headers, flags) {
+  common.expectsError(() => stream.additionalHeaders({ ':status': 201 }), {
+    code: 'ERR_HTTP2_INVALID_INFO_STATUS',
+    type: RangeError,
+    message: /^Invalid informational status code: 201$/
+  });
+
+  common.expectsError(() => stream.additionalHeaders({ ':status': 101 }), {
+    code: 'ERR_HTTP2_STATUS_101',
+    type: Error,
+    message: status101regex
+  });
 
-  common.expectsError(() => stream.additionalHeaders({ ':status': 201 }),
-                      {
-                        code: 'ERR_HTTP2_INVALID_INFO_STATUS',
-                        type: RangeError,
-                        message: /^Invalid informational status code: 201$/
-                      });
-
-  common.expectsError(() => stream.additionalHeaders({ ':status': 101 }),
-                      {
-                        code: 'ERR_HTTP2_STATUS_101',
-                        type: Error,
-                        message: status101regex
-                      });
-
-  common.expectsError(
-    () => stream.additionalHeaders({ ':method': 'POST' }),
-    {
-      code: 'ERR_HTTP2_INVALID_PSEUDOHEADER',
-      type: TypeError,
-      message: '":method" is an invalid pseudoheader or is used incorrectly'
-    }
-  );
+  common.expectsError(() => stream.additionalHeaders({ ':method': 'POST' }), {
+    code: 'ERR_HTTP2_INVALID_PSEUDOHEADER',
+    type: TypeError,
+    message: '":method" is an invalid pseudoheader or is used incorrectly'
+  });
 
   // Can send more than one
   stream.additionalHeaders({ ':status': 100 });
@@ -50,46 +41,55 @@ function onStream(stream, headers, flags) {
     ':status': 200
   });
 
-  common.expectsError(() => stream.additionalHeaders({ abc: 123 }),
-                      {
-                        code: 'ERR_HTTP2_HEADERS_AFTER_RESPOND',
-                        type: Error,
-                        message: afterRespondregex
-                      });
+  common.expectsError(() => stream.additionalHeaders({ abc: 123 }), {
+    code: 'ERR_HTTP2_HEADERS_AFTER_RESPOND',
+    type: Error,
+    message: afterRespondregex
+  });
 
   stream.end('hello world');
 }
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const req = client.request({ ':path': '/' });
-
-  // The additionalHeaders method does not exist on client stream
-  assert.strictEqual(req.additionalHeaders, undefined);
-
-  // Additional informational headers
-  req.on('headers', common.mustCall((headers) => {
-    assert.notStrictEqual(headers, undefined);
-    assert.strictEqual(headers[':status'], 100);
-  }, 2));
-
-  // Response headers
-  req.on('response', common.mustCall((headers) => {
-    assert.notStrictEqual(headers, undefined);
-    assert.strictEqual(headers[':status'], 200);
-    assert.strictEqual(headers['content-type'], 'text/html');
-  }));
-
-  req.resume();
-
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-  req.end();
-
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+
+    const req = client.request({ ':path': '/' });
+
+    // The additionalHeaders method does not exist on client stream
+    assert.strictEqual(req.additionalHeaders, undefined);
+
+    // Additional informational headers
+    req.on(
+      'headers',
+      common.mustCall((headers) => {
+        assert.notStrictEqual(headers, undefined);
+        assert.strictEqual(headers[':status'], 100);
+      }, 2)
+    );
+
+    // Response headers
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.notStrictEqual(headers, undefined);
+        assert.strictEqual(headers[':status'], 200);
+        assert.strictEqual(headers['content-type'], 'text/html');
+      })
+    );
+
+    req.resume();
+
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-invalidargtypes-errors.js b/test/parallel/test-http2-invalidargtypes-errors.js
index d7c451569e273d..62f0b0f923f8c2 100644
--- a/test/parallel/test-http2-invalidargtypes-errors.js
+++ b/test/parallel/test-http2-invalidargtypes-errors.js
@@ -1,32 +1,37 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  common.expectsError(
-    () => stream.close('string'),
-    {
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    common.expectsError(() => stream.close('string'), {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError,
-      message: 'The "code" argument must be of type number. ' +
-               'Received type string'
-    }
-  );
-  stream.respond();
-  stream.end('ok');
-}));
+      message:
+        'The "code" argument must be of type number. ' + 'Received type string'
+    });
+    stream.respond();
+    stream.end('ok');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  req.resume();
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    req.resume();
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-large-write-close.js b/test/parallel/test-http2-large-write-close.js
index f9dee357d6da7b..321a460859c99d 100644
--- a/test/parallel/test-http2-large-write-close.js
+++ b/test/parallel/test-http2-large-write-close.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
@@ -12,33 +11,47 @@ const server = http2.createSecureServer({
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
 });
-server.on('stream', common.mustCall((stream) => {
-  stream.respond({
-    'Content-Type': 'application/octet-stream',
-    'Content-Length': (content.length.toString() * 2),
-    'Vary': 'Accept-Encoding'
-  });
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond({
+      'Content-Type': 'application/octet-stream',
+      'Content-Length': content.length.toString() * 2,
+      Vary: 'Accept-Encoding'
+    });
 
-  stream.write(content);
-  stream.write(content);
-  stream.end();
-  stream.close();
-}));
+    stream.write(content);
+    stream.write(content);
+    stream.end();
+    stream.close();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`https://localhost:${server.address().port}`,
-                               { rejectUnauthorized: false });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(
+      `https://localhost:${server.address().port}`,
+      { rejectUnauthorized: false }
+    );
 
-  const req = client.request({ ':path': '/' });
-  req.end();
+    const req = client.request({ ':path': '/' });
+    req.end();
 
-  let receivedBufferLength = 0;
-  req.on('data', common.mustCallAtLeast((buf) => {
-    receivedBufferLength += buf.length;
-  }, 1));
-  req.on('close', common.mustCall(() => {
-    assert.strictEqual(receivedBufferLength, content.length * 2);
-    client.close();
-    server.close();
-  }));
-}));
+    let receivedBufferLength = 0;
+    req.on(
+      'data',
+      common.mustCallAtLeast((buf) => {
+        receivedBufferLength += buf.length;
+      }, 1)
+    );
+    req.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(receivedBufferLength, content.length * 2);
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-large-write-destroy.js b/test/parallel/test-http2-large-write-destroy.js
index 24c0a055cc943f..3323dc45a1a059 100644
--- a/test/parallel/test-http2-large-write-destroy.js
+++ b/test/parallel/test-http2-large-write-destroy.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 
@@ -15,26 +14,40 @@ const server = http2.createSecureServer({
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
 });
-server.on('stream', common.mustCall((stream) => {
-  stream.respond({
-    'Content-Type': 'application/octet-stream',
-    'Content-Length': (content.length.toString() * 2),
-    'Vary': 'Accept-Encoding'
-  }, { waitForTrailers: true });
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond(
+      {
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': content.length.toString() * 2,
+        Vary: 'Accept-Encoding'
+      },
+      { waitForTrailers: true }
+    );
 
-  stream.write(content);
-  stream.destroy();
-}));
+    stream.write(content);
+    stream.destroy();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`https://localhost:${server.address().port}`,
-                               { rejectUnauthorized: false });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(
+      `https://localhost:${server.address().port}`,
+      { rejectUnauthorized: false }
+    );
 
-  const req = client.request({ ':path': '/' });
-  req.end();
+    const req = client.request({ ':path': '/' });
+    req.end();
 
-  req.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-}));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-malformed-altsvc.js b/test/parallel/test-http2-malformed-altsvc.js
index 28c0fb46b42281..b1652247c0f789 100644
--- a/test/parallel/test-http2-malformed-altsvc.js
+++ b/test/parallel/test-http2-malformed-altsvc.js
@@ -2,8 +2,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http2 = require('http2');
 const net = require('net');
@@ -17,19 +16,25 @@ const settingsAck = new h2test.SettingsFrame(true);
 const altsvc = new h2test.AltSvcFrame((1 << 14) + 1);
 
 server.listen(0, () => {
-  const client = net.connect(server.address().port, () => {
-    client.write(h2test.kClientMagic, () => {
-      client.write(settings.data, () => {
-        client.write(settingsAck.data);
-        // Prior to nghttp2 1.31.1, sending this malformed altsvc frame
-        // would cause a segfault. This test is successful if a segfault
-        // does not occur.
-        client.write(altsvc.data, common.mustCall(() => {
-          client.destroy();
-        }));
+  const client = net.connect(
+    server.address().port,
+    () => {
+      client.write(h2test.kClientMagic, () => {
+        client.write(settings.data, () => {
+          client.write(settingsAck.data);
+          // Prior to nghttp2 1.31.1, sending this malformed altsvc frame
+          // would cause a segfault. This test is successful if a segfault
+          // does not occur.
+          client.write(
+            altsvc.data,
+            common.mustCall(() => {
+              client.destroy();
+            })
+          );
+        });
       });
-    });
-  });
+    }
+  );
 
   // An error may or may not be emitted on the client side, we don't care
   // either way if it is, but we don't want to die if it is.
diff --git a/test/parallel/test-http2-many-writes-and-destroy.js b/test/parallel/test-http2-many-writes-and-destroy.js
index 78db76e001cd3a..d2885bad36df67 100644
--- a/test/parallel/test-http2-many-writes-and-destroy.js
+++ b/test/parallel/test-http2-many-writes-and-destroy.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 {
@@ -19,11 +18,14 @@ const http2 = require('http2');
       req.write(Buffer.alloc(6));
     }
 
-    req.on('close', common.mustCall(() => {
-      console.log('(req onclose)');
-      server.close();
-      client.close();
-    }));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        console.log('(req onclose)');
+        server.close();
+        client.close();
+      })
+    );
 
     req.once('data', common.mustCall(() => req.destroy()));
   });
diff --git a/test/parallel/test-http2-max-concurrent-streams.js b/test/parallel/test-http2-max-concurrent-streams.js
index b270d6cc6aff31..7b20924304b13b 100644
--- a/test/parallel/test-http2-max-concurrent-streams.js
+++ b/test/parallel/test-http2-max-concurrent-streams.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const Countdown = require('../common/countdown');
@@ -11,46 +10,58 @@ const Countdown = require('../common/countdown');
 const server = h2.createServer({ settings: { maxConcurrentStreams: 1 } });
 
 // The stream handler must be called only once
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.end('hello world');
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const countdown = new Countdown(2, () => {
-    server.close();
-    client.close();
-  });
-
-  client.on('remoteSettings', common.mustCall((settings) => {
-    assert.strictEqual(settings.maxConcurrentStreams, 1);
-  }));
-
-  // This one should go through with no problems
-  {
-    const req = client.request({ ':method': 'POST' });
-    req.on('aborted', common.mustNotCall());
-    req.on('response', common.mustCall());
-    req.resume();
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(() => countdown.dec()));
-    req.end();
-  }
-
-  {
-    // This one should be aborted
-    const req = client.request({ ':method': 'POST' });
-    req.on('aborted', common.mustCall());
-    req.on('response', common.mustNotCall());
-    req.resume();
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(() => countdown.dec()));
-    req.on('error', common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code NGHTTP2_REFUSED_STREAM'
-    }));
-  }
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    stream.end('hello world');
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+
+    const countdown = new Countdown(2, () => {
+      server.close();
+      client.close();
+    });
+
+    client.on(
+      'remoteSettings',
+      common.mustCall((settings) => {
+        assert.strictEqual(settings.maxConcurrentStreams, 1);
+      })
+    );
+
+    // This one should go through with no problems
+    {
+      const req = client.request({ ':method': 'POST' });
+      req.on('aborted', common.mustNotCall());
+      req.on('response', common.mustCall());
+      req.resume();
+      req.on('end', common.mustCall());
+      req.on('close', common.mustCall(() => countdown.dec()));
+      req.end();
+    }
+
+    {
+      // This one should be aborted
+      const req = client.request({ ':method': 'POST' });
+      req.on('aborted', common.mustCall());
+      req.on('response', common.mustNotCall());
+      req.resume();
+      req.on('end', common.mustCall());
+      req.on('close', common.mustCall(() => countdown.dec()));
+      req.on(
+        'error',
+        common.expectsError({
+          code: 'ERR_HTTP2_STREAM_ERROR',
+          type: Error,
+          message: 'Stream closed with error code NGHTTP2_REFUSED_STREAM'
+        })
+      );
+    }
+  })
+);
diff --git a/test/parallel/test-http2-methods.js b/test/parallel/test-http2-methods.js
index a291bdf00800d5..2d7bcb9f584656 100644
--- a/test/parallel/test-http2-methods.js
+++ b/test/parallel/test-http2-methods.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -27,23 +26,28 @@ function onStream(stream, headers, flags) {
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const headers = { ':path': '/' };
-
-  methods.forEach((method) => {
-    headers[':method'] = method;
-    const req = client.request(headers);
-    req.on('response', common.mustCall());
-    req.resume();
-    req.on('end', common.mustCall(() => {
-      if (--expected === 0) {
-        server.close();
-        client.close();
-      }
-    }));
-    req.end();
-  });
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+
+    const headers = { ':path': '/' };
+
+    methods.forEach((method) => {
+      headers[':method'] = method;
+      const req = client.request(headers);
+      req.on('response', common.mustCall());
+      req.resume();
+      req.on(
+        'end',
+        common.mustCall(() => {
+          if (--expected === 0) {
+            server.close();
+            client.close();
+          }
+        })
+      );
+      req.end();
+    });
+  })
+);
diff --git a/test/parallel/test-http2-misbehaving-flow-control-paused.js b/test/parallel/test-http2-misbehaving-flow-control-paused.js
index 26d2ed5dd244a2..4bc4daae6306a3 100644
--- a/test/parallel/test-http2-misbehaving-flow-control-paused.js
+++ b/test/parallel/test-http2-misbehaving-flow-control-paused.js
@@ -2,36 +2,219 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const h2 = require('http2');
 const net = require('net');
 
 const preamble = Buffer.from([
-  0x50, 0x52, 0x49, 0x20, 0x2a, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2f,
-  0x32, 0x2e, 0x30, 0x0d, 0x0a, 0x0d, 0x0a, 0x53, 0x4d, 0x0d, 0x0a,
-  0x0d, 0x0a, 0x00, 0x00, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x03, 0x00, 0x00, 0x00, 0x64, 0x00, 0x04, 0x00, 0x00, 0xff,
-  0xff, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-  0x00, 0xc8, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x05,
-  0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00,
-  0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-  0x02, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x07, 0x00,
-  0x00, 0x00, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
-  0x00, 0x03, 0x00, 0x00, 0x00, 0x2c, 0x01, 0x24, 0x00, 0x00, 0x00,
-  0x0d, 0x00, 0x00, 0x00, 0x0b, 0x0f, 0x83, 0x84, 0x86, 0x41, 0x8a,
-  0xa0, 0xe4, 0x1d, 0x13, 0x9d, 0x09, 0xb8, 0xf0, 0x1e, 0x07, 0x53,
-  0x03, 0x2a, 0x2f, 0x2a, 0x90, 0x7a, 0x8a, 0xaa, 0x69, 0xd2, 0x9a,
-  0xc4, 0xc0, 0x57, 0x0b, 0xcb, 0x87, 0x0f, 0x0d, 0x83, 0x08, 0x00,
+  0x50,
+  0x52,
+  0x49,
+  0x20,
+  0x2a,
+  0x20,
+  0x48,
+  0x54,
+  0x54,
+  0x50,
+  0x2f,
+  0x32,
+  0x2e,
+  0x30,
+  0x0d,
+  0x0a,
+  0x0d,
+  0x0a,
+  0x53,
+  0x4d,
+  0x0d,
+  0x0a,
+  0x0d,
+  0x0a,
+  0x00,
+  0x00,
+  0x0c,
+  0x04,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x03,
+  0x00,
+  0x00,
+  0x00,
+  0x64,
+  0x00,
+  0x04,
+  0x00,
+  0x00,
+  0xff,
+  0xff,
+  0x00,
+  0x00,
+  0x00,
+  0x04,
+  0x01,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x03,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0xc8,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x05,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x64,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x07,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x09,
+  0x00,
+  0x00,
+  0x00,
+  0x07,
+  0x00,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0b,
+  0x00,
+  0x00,
+  0x00,
+  0x03,
+  0x00,
+  0x00,
+  0x00,
+  0x2c,
+  0x01,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x00,
+  0x00,
+  0x00,
+  0x0b,
+  0x0f,
+  0x83,
+  0x84,
+  0x86,
+  0x41,
+  0x8a,
+  0xa0,
+  0xe4,
+  0x1d,
+  0x13,
+  0x9d,
+  0x09,
+  0xb8,
+  0xf0,
+  0x1e,
+  0x07,
+  0x53,
+  0x03,
+  0x2a,
+  0x2f,
+  0x2a,
+  0x90,
+  0x7a,
+  0x8a,
+  0xaa,
+  0x69,
+  0xd2,
+  0x9a,
+  0xc4,
+  0xc0,
+  0x57,
+  0x0b,
+  0xcb,
+  0x87,
+  0x0f,
+  0x0d,
+  0x83,
+  0x08,
+  0x00,
   0x0f
 ]);
 
 const data = Buffer.from([
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
-  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a
+  0x00,
+  0x00,
+  0x12,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a
 ]);
 
 // This is testing the case of a misbehaving client that is not paying
@@ -60,23 +243,32 @@ server.on('stream', (stream) => {
   // reads from the source stream (if we can consume them).
   stream._readableState.highWaterMark = 0;
   stream.pause();
-  stream.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code NGHTTP2_FLOW_CONTROL_ERROR'
-  }));
-  stream.on('close', common.mustCall(() => {
-    server.close();
-    client.destroy();
-  }));
+  stream.on(
+    'error',
+    common.expectsError({
+      code: 'ERR_HTTP2_STREAM_ERROR',
+      type: Error,
+      message: 'Stream closed with error code NGHTTP2_FLOW_CONTROL_ERROR'
+    })
+  );
+  stream.on(
+    'close',
+    common.mustCall(() => {
+      server.close();
+      client.destroy();
+    })
+  );
   stream.on('end', common.mustNotCall());
 });
 
 server.listen(0, () => {
-  client = net.connect(server.address().port, () => {
-    client.write(preamble);
-    client.write(data);
-    client.write(data);
-    client.write(data);
-  });
+  client = net.connect(
+    server.address().port,
+    () => {
+      client.write(preamble);
+      client.write(data);
+      client.write(data);
+      client.write(data);
+    }
+  );
 });
diff --git a/test/parallel/test-http2-misbehaving-flow-control.js b/test/parallel/test-http2-misbehaving-flow-control.js
index f2da0ba56c8e67..99ae274ed2b84d 100644
--- a/test/parallel/test-http2-misbehaving-flow-control.js
+++ b/test/parallel/test-http2-misbehaving-flow-control.js
@@ -2,51 +2,354 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const h2 = require('http2');
 const net = require('net');
 
 const preamble = Buffer.from([
-  0x50, 0x52, 0x49, 0x20, 0x2a, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2f,
-  0x32, 0x2e, 0x30, 0x0d, 0x0a, 0x0d, 0x0a, 0x53, 0x4d, 0x0d, 0x0a,
-  0x0d, 0x0a, 0x00, 0x00, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x03, 0x00, 0x00, 0x00, 0x64, 0x00, 0x04, 0x00, 0x00, 0xff,
-  0xff, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
-  0x00, 0xc8, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x05,
-  0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00,
-  0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-  0x02, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x07, 0x00,
-  0x00, 0x00, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
-  0x00, 0x03, 0x00, 0x00, 0x00, 0x2c, 0x01, 0x24, 0x00, 0x00, 0x00,
-  0x0d, 0x00, 0x00, 0x00, 0x0b, 0x0f, 0x83, 0x84, 0x86, 0x41, 0x8a,
-  0xa0, 0xe4, 0x1d, 0x13, 0x9d, 0x09, 0xb8, 0xf0, 0x1e, 0x07, 0x53,
-  0x03, 0x2a, 0x2f, 0x2a, 0x90, 0x7a, 0x8a, 0xaa, 0x69, 0xd2, 0x9a,
-  0xc4, 0xc0, 0x57, 0x0b, 0xcb, 0x87, 0x0f, 0x0d, 0x83, 0x08, 0x00,
+  0x50,
+  0x52,
+  0x49,
+  0x20,
+  0x2a,
+  0x20,
+  0x48,
+  0x54,
+  0x54,
+  0x50,
+  0x2f,
+  0x32,
+  0x2e,
+  0x30,
+  0x0d,
+  0x0a,
+  0x0d,
+  0x0a,
+  0x53,
+  0x4d,
+  0x0d,
+  0x0a,
+  0x0d,
+  0x0a,
+  0x00,
+  0x00,
+  0x0c,
+  0x04,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x03,
+  0x00,
+  0x00,
+  0x00,
+  0x64,
+  0x00,
+  0x04,
+  0x00,
+  0x00,
+  0xff,
+  0xff,
+  0x00,
+  0x00,
+  0x00,
+  0x04,
+  0x01,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x03,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0xc8,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x05,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x64,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x07,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x09,
+  0x00,
+  0x00,
+  0x00,
+  0x07,
+  0x00,
+  0x00,
+  0x00,
+  0x05,
+  0x02,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0b,
+  0x00,
+  0x00,
+  0x00,
+  0x03,
+  0x00,
+  0x00,
+  0x00,
+  0x2c,
+  0x01,
+  0x24,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x00,
+  0x00,
+  0x00,
+  0x0b,
+  0x0f,
+  0x83,
+  0x84,
+  0x86,
+  0x41,
+  0x8a,
+  0xa0,
+  0xe4,
+  0x1d,
+  0x13,
+  0x9d,
+  0x09,
+  0xb8,
+  0xf0,
+  0x1e,
+  0x07,
+  0x53,
+  0x03,
+  0x2a,
+  0x2f,
+  0x2a,
+  0x90,
+  0x7a,
+  0x8a,
+  0xaa,
+  0x69,
+  0xd2,
+  0x9a,
+  0xc4,
+  0xc0,
+  0x57,
+  0x0b,
+  0xcb,
+  0x87,
+  0x0f,
+  0x0d,
+  0x83,
+  0x08,
+  0x00,
   0x0f
 ]);
 
 const data = Buffer.from([
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
-  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
-  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
-  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
-  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
-  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a,
-  0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
-  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c,
-  0x6c, 0x6f, 0x0a, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a
+  0x00,
+  0x00,
+  0x12,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x00,
+  0x00,
+  0x12,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x00,
+  0x00,
+  0x12,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x00,
+  0x00,
+  0x12,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x00,
+  0x00,
+  0x12,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x00,
+  0x00,
+  0x12,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x00,
+  0x0d,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a,
+  0x68,
+  0x65,
+  0x6c,
+  0x6c,
+  0x6f,
+  0x0a
 ]);
 
 // This is testing the case of a misbehaving client that is not paying
@@ -66,15 +369,21 @@ const data = Buffer.from([
 let client;
 const server = h2.createServer({ settings: { initialWindowSize: 18 } });
 server.on('stream', (stream) => {
-  stream.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code NGHTTP2_FLOW_CONTROL_ERROR'
-  }));
-  stream.on('close', common.mustCall(() => {
-    server.close(common.mustCall());
-    client.destroy();
-  }));
+  stream.on(
+    'error',
+    common.expectsError({
+      code: 'ERR_HTTP2_STREAM_ERROR',
+      type: Error,
+      message: 'Stream closed with error code NGHTTP2_FLOW_CONTROL_ERROR'
+    })
+  );
+  stream.on(
+    'close',
+    common.mustCall(() => {
+      server.close(common.mustCall());
+      client.destroy();
+    })
+  );
   stream.resume();
   stream.respond();
   stream.end('ok');
@@ -83,9 +392,12 @@ server.on('stream', (stream) => {
 server.on('close', common.mustCall());
 
 server.listen(0, () => {
-  client = net.connect(server.address().port, () => {
-    client.write(preamble);
-    client.write(data);
-    client.write(data);
-  });
+  client = net.connect(
+    server.address().port,
+    () => {
+      client.write(preamble);
+      client.write(data);
+      client.write(data);
+    }
+  );
 });
diff --git a/test/parallel/test-http2-misbehaving-multiplex.js b/test/parallel/test-http2-misbehaving-multiplex.js
index b0b501eacbc5dd..05e065656795dc 100644
--- a/test/parallel/test-http2-misbehaving-multiplex.js
+++ b/test/parallel/test-http2-misbehaving-multiplex.js
@@ -3,8 +3,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const h2 = require('http2');
 const net = require('net');
@@ -13,25 +12,37 @@ const h2test = require('../common/http2');
 let client;
 
 const server = h2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.end('ok');
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    stream.end('ok');
 
-  // the error will be emitted asynchronously
-  stream.on('error', common.expectsError({
-    type: NghttpError,
-    code: 'ERR_HTTP2_ERROR',
-    message: 'Stream was already closed or invalid'
-  }));
-}, 2));
+    // the error will be emitted asynchronously
+    stream.on(
+      'error',
+      common.expectsError({
+        type: NghttpError,
+        code: 'ERR_HTTP2_ERROR',
+        message: 'Stream was already closed or invalid'
+      })
+    );
+  }, 2)
+);
 
-server.on('session', common.mustCall((session) => {
-  session.on('error', common.expectsError({
-    code: 'ERR_HTTP2_ERROR',
-    type: NghttpError,
-    message: 'Stream was already closed or invalid'
-  }));
-}));
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_ERROR',
+        type: NghttpError,
+        message: 'Stream was already closed or invalid'
+      })
+    );
+  })
+);
 
 const settings = new h2test.SettingsFrame();
 const settingsAck = new h2test.SettingsFrame(true);
@@ -41,26 +52,29 @@ const head3 = new h2test.HeadersFrame(1, h2test.kFakeRequestHeaders, 0, true);
 const head4 = new h2test.HeadersFrame(5, h2test.kFakeRequestHeaders, 0, true);
 
 server.listen(0, () => {
-  client = net.connect(server.address().port, () => {
-    client.write(h2test.kClientMagic, () => {
-      client.write(settings.data, () => {
-        client.write(settingsAck.data);
-        // This will make it ok.
-        client.write(head1.data, () => {
+  client = net.connect(
+    server.address().port,
+    () => {
+      client.write(h2test.kClientMagic, () => {
+        client.write(settings.data, () => {
+          client.write(settingsAck.data);
           // This will make it ok.
-          client.write(head2.data, () => {
-            // This will cause an error to occur because the client is
-            // attempting to reuse an already closed stream. This must
-            // cause the server session to be torn down.
-            client.write(head3.data, () => {
-              // This won't ever make it to the server
-              client.write(head4.data);
+          client.write(head1.data, () => {
+            // This will make it ok.
+            client.write(head2.data, () => {
+              // This will cause an error to occur because the client is
+              // attempting to reuse an already closed stream. This must
+              // cause the server session to be torn down.
+              client.write(head3.data, () => {
+                // This won't ever make it to the server
+                client.write(head4.data);
+              });
             });
           });
         });
       });
-    });
-  });
+    }
+  );
 
   // An error may or may not be emitted on the client side, we don't care
   // either way if it is, but we don't want to die if it is.
diff --git a/test/parallel/test-http2-misc-util.js b/test/parallel/test-http2-misc-util.js
index 14dc4a536617df..d3c0a557f4fbc1 100644
--- a/test/parallel/test-http2-misc-util.js
+++ b/test/parallel/test-http2-misc-util.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 
 const {
@@ -20,30 +19,24 @@ assert.strictEqual(sessionName(1), 'client');
 });
 
 // Code coverage for assertWithinRange function
-common.expectsError(
-  () => assertWithinRange('test', -1),
-  {
-    code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-    type: RangeError,
-    message: 'Invalid value for setting "test": -1'
-  });
+common.expectsError(() => assertWithinRange('test', -1), {
+  code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+  type: RangeError,
+  message: 'Invalid value for setting "test": -1'
+});
 
 assertWithinRange('test', 1);
 
-common.expectsError(
-  () => assertIsObject('foo', 'test'),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "test" argument must be of type Object. Received type string'
-  });
-
-common.expectsError(
-  () => assertIsObject('foo', 'test', ['Date']),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "test" argument must be of type Date. Received type string'
-  });
+common.expectsError(() => assertIsObject('foo', 'test'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'The "test" argument must be of type Object. Received type string'
+});
+
+common.expectsError(() => assertIsObject('foo', 'test', ['Date']), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'The "test" argument must be of type Date. Received type string'
+});
 
 assertIsObject({}, 'test');
diff --git a/test/parallel/test-http2-misused-pseudoheaders.js b/test/parallel/test-http2-misused-pseudoheaders.js
index c1ae37b9a36938..397e075e20cff3 100644
--- a/test/parallel/test-http2-misused-pseudoheaders.js
+++ b/test/parallel/test-http2-misused-pseudoheaders.js
@@ -1,49 +1,53 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 const server = h2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  [
-    ':path',
-    ':authority',
-    ':method',
-    ':scheme'
-  ].forEach((i) => {
-    common.expectsError(() => stream.respond({ [i]: '/' }),
-                        {
-                          code: 'ERR_HTTP2_INVALID_PSEUDOHEADER'
-                        });
-  });
-
-  stream.respond({}, { waitForTrailers: true });
-
-  stream.on('wantTrailers', () => {
-    common.expectsError(() => {
-      stream.sendTrailers({ ':status': 'bar' });
-    }, {
-      code: 'ERR_HTTP2_INVALID_PSEUDOHEADER'
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    [':path', ':authority', ':method', ':scheme'].forEach((i) => {
+      common.expectsError(() => stream.respond({ [i]: '/' }), {
+        code: 'ERR_HTTP2_INVALID_PSEUDOHEADER'
+      });
     });
-    stream.close();
-  });
 
-  stream.end('hello world');
-}));
-
-
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
+    stream.respond({}, { waitForTrailers: true });
+
+    stream.on('wantTrailers', () => {
+      common.expectsError(
+        () => {
+          stream.sendTrailers({ ':status': 'bar' });
+        },
+        {
+          code: 'ERR_HTTP2_INVALID_PSEUDOHEADER'
+        }
+      );
+      stream.close();
+    });
 
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall());
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+    stream.end('hello world');
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-multi-content-length.js b/test/parallel/test-http2-multi-content-length.js
index 7d8ff4858fedbb..5d3d366001ef09 100644
--- a/test/parallel/test-http2-multi-content-length.js
+++ b/test/parallel/test-http2-multi-content-length.js
@@ -1,64 +1,73 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.end();
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    stream.end();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  const countdown = new Countdown(2, () => {
-    server.close();
-    client.close();
-  });
+    const countdown = new Countdown(2, () => {
+      server.close();
+      client.close();
+    });
+
+    // Request 1 will fail because there are two content-length header values
+    common.expectsError(
+      () => {
+        client.request({
+          ':method': 'POST',
+          'content-length': 1,
+          'Content-Length': 2
+        });
+      },
+      {
+        code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
+        type: TypeError,
+        message: 'Header field "content-length" must only have a single value'
+      }
+    );
 
-  // Request 1 will fail because there are two content-length header values
-  common.expectsError(
-    () => {
-      client.request({
+    {
+      // Request 2 will succeed
+      const req = client.request({
         ':method': 'POST',
-        'content-length': 1,
-        'Content-Length': 2
+        'content-length': 1
       });
-    }, {
-      code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
-      type: TypeError,
-      message: 'Header field "content-length" must only have a single value'
+      req.resume();
+      req.on('end', common.mustCall());
+      req.on('close', common.mustCall(() => countdown.dec()));
+      req.end('a');
     }
-  );
 
-  {
-    // Request 2 will succeed
-    const req = client.request({
-      ':method': 'POST',
-      'content-length': 1
-    });
-    req.resume();
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(() => countdown.dec()));
-    req.end('a');
-  }
-
-  {
-    // Request 3 will fail because  nghttp2 does not allow the content-length
-    // header to be set for non-payload bearing requests...
-    const req = client.request({ 'content-length': 1 });
-    req.resume();
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(() => countdown.dec()));
-    req.on('error', common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code NGHTTP2_PROTOCOL_ERROR'
-    }));
-  }
-}));
+    {
+      // Request 3 will fail because  nghttp2 does not allow the content-length
+      // header to be set for non-payload bearing requests...
+      const req = client.request({ 'content-length': 1 });
+      req.resume();
+      req.on('end', common.mustCall());
+      req.on('close', common.mustCall(() => countdown.dec()));
+      req.on(
+        'error',
+        common.expectsError({
+          code: 'ERR_HTTP2_STREAM_ERROR',
+          type: Error,
+          message: 'Stream closed with error code NGHTTP2_PROTOCOL_ERROR'
+        })
+      );
+    }
+  })
+);
diff --git a/test/parallel/test-http2-multiheaders-raw.js b/test/parallel/test-http2-multiheaders-raw.js
index da9aa3a68eaa51..c234ebe8d51afb 100644
--- a/test/parallel/test-http2-multiheaders-raw.js
+++ b/test/parallel/test-http2-multiheaders-raw.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -14,36 +13,45 @@ src['WWW-Authenticate'] = 'bar';
 src['WWW-AUTHENTICATE'] = 'baz';
 src.test = 'foo, bar, baz';
 
-server.on('stream', common.mustCall((stream, headers, flags, rawHeaders) => {
-  const expected = [
-    ':path',
-    '/',
-    ':scheme',
-    'http',
-    ':authority',
-    `localhost:${server.address().port}`,
-    ':method',
-    'GET',
-    'www-authenticate',
-    'foo',
-    'www-authenticate',
-    'bar',
-    'www-authenticate',
-    'baz',
-    'test',
-    'foo, bar, baz'
-  ];
+server.on(
+  'stream',
+  common.mustCall((stream, headers, flags, rawHeaders) => {
+    const expected = [
+      ':path',
+      '/',
+      ':scheme',
+      'http',
+      ':authority',
+      `localhost:${server.address().port}`,
+      ':method',
+      'GET',
+      'www-authenticate',
+      'foo',
+      'www-authenticate',
+      'bar',
+      'www-authenticate',
+      'baz',
+      'test',
+      'foo, bar, baz'
+    ];
 
-  assert.deepStrictEqual(expected, rawHeaders);
-  stream.respond(src);
-  stream.end();
-}));
+    assert.deepStrictEqual(expected, rawHeaders);
+    stream.respond(src);
+    stream.end();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request(src);
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request(src);
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-multiheaders.js b/test/parallel/test-http2-multiheaders.js
index 6611dcf054d42a..5744ac83a41027 100644
--- a/test/parallel/test-http2-multiheaders.js
+++ b/test/parallel/test-http2-multiheaders.js
@@ -1,15 +1,14 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const server = http2.createServer();
 
 const src = Object.create(null);
-src.accept = [ 'abc', 'def' ];
+src.accept = ['abc', 'def'];
 src.Accept = 'ghijklmnop';
 src['www-authenticate'] = 'foo';
 src['WWW-Authenticate'] = 'bar';
@@ -29,33 +28,39 @@ src.__PROTO__ = 'bar';
 src.__Proto__ = 'baz';
 
 function checkHeaders(headers) {
-  assert.deepStrictEqual(headers.accept,
-                         'abc, def, ghijklmnop');
-  assert.deepStrictEqual(headers['www-authenticate'],
-                         'foo, bar, baz');
-  assert.deepStrictEqual(headers['proxy-authenticate'],
-                         'foo, bar, baz');
+  assert.deepStrictEqual(headers.accept, 'abc, def, ghijklmnop');
+  assert.deepStrictEqual(headers['www-authenticate'], 'foo, bar, baz');
+  assert.deepStrictEqual(headers['proxy-authenticate'], 'foo, bar, baz');
   assert.deepStrictEqual(headers['x-foo'], 'foo, bar, baz');
   assert.deepStrictEqual(headers.constructor, 'foo, bar, baz');
   // eslint-disable-next-line no-proto
   assert.deepStrictEqual(headers.__proto__, 'foo, bar, baz');
 }
 
-server.on('stream', common.mustCall((stream, headers) => {
-  assert.strictEqual(headers[':path'], '/');
-  assert.strictEqual(headers[':scheme'], 'http');
-  assert.strictEqual(headers[':method'], 'GET');
-  checkHeaders(headers);
-  stream.respond(src);
-  stream.end();
-}));
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    assert.strictEqual(headers[':path'], '/');
+    assert.strictEqual(headers[':scheme'], 'http');
+    assert.strictEqual(headers[':method'], 'GET');
+    checkHeaders(headers);
+    stream.respond(src);
+    stream.end();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request(src);
-  req.on('response', common.mustCall(checkHeaders));
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request(src);
+    req.on('response', common.mustCall(checkHeaders));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-multiplex.js b/test/parallel/test-http2-multiplex.js
index 1778bced5f92f4..24864243c3edc6 100644
--- a/test/parallel/test-http2-multiplex.js
+++ b/test/parallel/test-http2-multiplex.js
@@ -4,8 +4,7 @@
 // connection and makes sure that the data for each is appropriately echoed.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
@@ -14,45 +13,53 @@ const server = http2.createServer();
 
 const count = 100;
 
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.pipe(stream);
-}, count));
-
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  client.setMaxListeners(100);
-
-  const countdown = new Countdown(count, () => {
-    server.close();
-    client.close();
-  });
-
-  function doRequest() {
-    const req = client.request({ ':method': 'POST ' });
-
-    let data = '';
-    req.setEncoding('utf8');
-    req.on('data', (chunk) => data += chunk);
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(data, 'abcdefghij');
-    }));
-    req.on('close', common.mustCall(() => countdown.dec()));
-
-    let n = 0;
-    function writeChunk() {
-      if (n < 10) {
-        req.write(String.fromCharCode(97 + n));
-        setTimeout(writeChunk, 10);
-      } else {
-        req.end();
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    stream.pipe(stream);
+  }, count)
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    client.setMaxListeners(100);
+
+    const countdown = new Countdown(count, () => {
+      server.close();
+      client.close();
+    });
+
+    function doRequest() {
+      const req = client.request({ ':method': 'POST ' });
+
+      let data = '';
+      req.setEncoding('utf8');
+      req.on('data', (chunk) => (data += chunk));
+      req.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(data, 'abcdefghij');
+        })
+      );
+      req.on('close', common.mustCall(() => countdown.dec()));
+
+      let n = 0;
+      function writeChunk() {
+        if (n < 10) {
+          req.write(String.fromCharCode(97 + n));
+          setTimeout(writeChunk, 10);
+        } else {
+          req.end();
+        }
+        n++;
       }
-      n++;
-    }
 
-    writeChunk();
-  }
+      writeChunk();
+    }
 
-  for (let n = 0; n < count; n++)
-    doRequest();
-}));
+    for (let n = 0; n < count; n++) doRequest();
+  })
+);
diff --git a/test/parallel/test-http2-no-more-streams.js b/test/parallel/test-http2-no-more-streams.js
index ff0c8baa14ccdb..06f52779e7baf5 100644
--- a/test/parallel/test-http2-no-more-streams.js
+++ b/test/parallel/test-http2-no-more-streams.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http2 = require('http2');
@@ -14,40 +13,46 @@ server.on('stream', (stream) => {
   stream.end('ok');
 });
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const nextID = 2 ** 31 - 1;
-
-  client.on('connect', () => {
-    client.setNextStreamID(nextID);
-
-    assert.strictEqual(client.state.nextStreamID, nextID);
-
-    const countdown = new Countdown(2, () => {
-      server.close();
-      client.close();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const nextID = 2 ** 31 - 1;
+
+    client.on('connect', () => {
+      client.setNextStreamID(nextID);
+
+      assert.strictEqual(client.state.nextStreamID, nextID);
+
+      const countdown = new Countdown(2, () => {
+        server.close();
+        client.close();
+      });
+
+      {
+        // This one will be ok
+        const req = client.request();
+        assert.strictEqual(req.id, nextID);
+
+        req.on('error', common.mustNotCall());
+        req.resume();
+        req.on('end', () => countdown.dec());
+      }
+
+      {
+        // This one will error because there are no more stream IDs available
+        const req = client.request();
+        req.on(
+          'error',
+          common.expectsError({
+            code: 'ERR_HTTP2_OUT_OF_STREAMS',
+            type: Error,
+            message:
+              'No stream ID is available because maximum stream ID has been reached'
+          })
+        );
+        req.on('error', () => countdown.dec());
+      }
     });
-
-    {
-      // This one will be ok
-      const req = client.request();
-      assert.strictEqual(req.id, nextID);
-
-      req.on('error', common.mustNotCall());
-      req.resume();
-      req.on('end', () => countdown.dec());
-    }
-
-    {
-      // This one will error because there are no more stream IDs available
-      const req = client.request();
-      req.on('error', common.expectsError({
-        code: 'ERR_HTTP2_OUT_OF_STREAMS',
-        type: Error,
-        message:
-          'No stream ID is available because maximum stream ID has been reached'
-      }));
-      req.on('error', () => countdown.dec());
-    }
-  });
-}));
+  })
+);
diff --git a/test/parallel/test-http2-no-wanttrailers-listener.js b/test/parallel/test-http2-no-wanttrailers-listener.js
index 87bc21df48aa2c..50869050e36693 100644
--- a/test/parallel/test-http2-no-wanttrailers-listener.js
+++ b/test/parallel/test-http2-no-wanttrailers-listener.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 const server = h2.createServer();
@@ -20,13 +19,19 @@ function onStream(stream, headers, flags) {
 
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const client = h2.connect(`http://localhost:${this.address().port}`);
-  const req = client.request();
-  req.resume();
-  req.on('trailers', common.mustNotCall());
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const client = h2.connect(`http://localhost:${this.address().port}`);
+    const req = client.request();
+    req.resume();
+    req.on('trailers', common.mustNotCall());
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-onping.js b/test/parallel/test-http2-onping.js
index 134a94ddb8f582..e48927acfeba76 100644
--- a/test/parallel/test-http2-onping.js
+++ b/test/parallel/test-http2-onping.js
@@ -1,48 +1,59 @@
 'use strict';
 
-const {
-  hasCrypto,
-  mustCall,
-  skip
-} = require('../common');
-if (!hasCrypto)
-  skip('missing crypto');
+const { hasCrypto, mustCall, skip } = require('../common');
+if (!hasCrypto) skip('missing crypto');
 
-const {
-  deepStrictEqual
-} = require('assert');
-const {
-  createServer,
-  connect
-} = require('http2');
+const { deepStrictEqual } = require('assert');
+const { createServer, connect } = require('http2');
 
-const check = Buffer.from([ 1, 2, 3, 4, 5, 6, 7, 8 ]);
+const check = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 
 const server = createServer();
-server.on('stream', mustCall((stream) => {
-  stream.respond();
-  stream.end('ok');
-}));
-server.on('session', mustCall((session) => {
-  session.on('ping', mustCall((payload) => {
-    deepStrictEqual(check, payload);
-  }));
-  session.ping(check, mustCall());
-}));
-server.listen(0, mustCall(() => {
-  const client = connect(`http://localhost:${server.address().port}`);
+server.on(
+  'stream',
+  mustCall((stream) => {
+    stream.respond();
+    stream.end('ok');
+  })
+);
+server.on(
+  'session',
+  mustCall((session) => {
+    session.on(
+      'ping',
+      mustCall((payload) => {
+        deepStrictEqual(check, payload);
+      })
+    );
+    session.ping(check, mustCall());
+  })
+);
+server.listen(
+  0,
+  mustCall(() => {
+    const client = connect(`http://localhost:${server.address().port}`);
 
-  client.on('ping', mustCall((payload) => {
-    deepStrictEqual(check, payload);
-  }));
-  client.on('connect', mustCall(() => {
-    client.ping(check, mustCall());
-  }));
+    client.on(
+      'ping',
+      mustCall((payload) => {
+        deepStrictEqual(check, payload);
+      })
+    );
+    client.on(
+      'connect',
+      mustCall(() => {
+        client.ping(check, mustCall());
+      })
+    );
 
-  const req = client.request();
-  req.resume();
-  req.on('close', mustCall(() => {
-    client.close();
-    server.close();
-  }));
-}));
+    const req = client.request();
+    req.resume();
+    req.on(
+      'close',
+      mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-options-max-headers-block-length.js b/test/parallel/test-http2-options-max-headers-block-length.js
index 0706e6a83e6d48..e26de9af455a8e 100644
--- a/test/parallel/test-http2-options-max-headers-block-length.js
+++ b/test/parallel/test-http2-options-max-headers-block-length.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -10,34 +9,47 @@ const server = h2.createServer();
 
 // we use the lower-level API here
 server.on('stream', common.mustNotCall());
-server.listen(0, common.mustCall(() => {
-
-  // Setting the maxSendHeaderBlockLength, then attempting to send a
-  // headers block that is too big should cause a 'frameError' to
-  // be emitted, and will cause the stream to be shutdown.
-  const options = {
-    maxSendHeaderBlockLength: 10
-  };
-
-  const client = h2.connect(`http://localhost:${server.address().port}`,
-                            options);
-
-  const req = client.request();
-  req.on('response', common.mustNotCall());
-
-  req.resume();
-  req.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-
-  req.on('frameError', common.mustCall((type, code) => {
-    assert.strictEqual(code, h2.constants.NGHTTP2_ERR_FRAME_SIZE_ERROR);
-  }));
-
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code NGHTTP2_REFUSED_STREAM'
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    // Setting the maxSendHeaderBlockLength, then attempting to send a
+    // headers block that is too big should cause a 'frameError' to
+    // be emitted, and will cause the stream to be shutdown.
+    const options = {
+      maxSendHeaderBlockLength: 10
+    };
+
+    const client = h2.connect(
+      `http://localhost:${server.address().port}`,
+      options
+    );
+
+    const req = client.request();
+    req.on('response', common.mustNotCall());
+
+    req.resume();
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+
+    req.on(
+      'frameError',
+      common.mustCall((type, code) => {
+        assert.strictEqual(code, h2.constants.NGHTTP2_ERR_FRAME_SIZE_ERROR);
+      })
+    );
+
+    req.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_STREAM_ERROR',
+        type: Error,
+        message: 'Stream closed with error code NGHTTP2_REFUSED_STREAM'
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-options-max-reserved-streams.js b/test/parallel/test-http2-options-max-reserved-streams.js
index 6dbf54bf31c980..a5c9248ac8ecbb 100644
--- a/test/parallel/test-http2-options-max-reserved-streams.js
+++ b/test/parallel/test-http2-options-max-reserved-streams.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const Countdown = require('../common/countdown');
@@ -16,56 +15,76 @@ const countdown = new Countdown(3, () => {
 });
 
 // we use the lower-level API here
-server.on('stream', common.mustCall((stream) => {
-  // The first pushStream will complete as normal
-  stream.pushStream({
-    ':path': '/foobar',
-  }, common.mustCall((err, pushedStream) => {
-    assert.ifError(err);
-    pushedStream.respond();
-    pushedStream.end();
-    pushedStream.on('aborted', common.mustNotCall());
-  }));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    // The first pushStream will complete as normal
+    stream.pushStream(
+      {
+        ':path': '/foobar'
+      },
+      common.mustCall((err, pushedStream) => {
+        assert.ifError(err);
+        pushedStream.respond();
+        pushedStream.end();
+        pushedStream.on('aborted', common.mustNotCall());
+      })
+    );
 
-  // The second pushStream will be aborted because the client
-  // will reject it due to the maxReservedRemoteStreams option
-  // being set to only 1
-  stream.pushStream({
-    ':path': '/foobar',
-  }, common.mustCall((err, pushedStream) => {
-    assert.ifError(err);
-    pushedStream.respond();
-    pushedStream.on('aborted', common.mustCall());
-    pushedStream.on('error', common.mustNotCall());
-    pushedStream.on('close', common.mustCall(() => {
-      assert.strictEqual(pushedStream.rstCode, 8);
-      countdown.dec();
-    }));
-  }));
+    // The second pushStream will be aborted because the client
+    // will reject it due to the maxReservedRemoteStreams option
+    // being set to only 1
+    stream.pushStream(
+      {
+        ':path': '/foobar'
+      },
+      common.mustCall((err, pushedStream) => {
+        assert.ifError(err);
+        pushedStream.respond();
+        pushedStream.on('aborted', common.mustCall());
+        pushedStream.on('error', common.mustNotCall());
+        pushedStream.on(
+          'close',
+          common.mustCall(() => {
+            assert.strictEqual(pushedStream.rstCode, 8);
+            countdown.dec();
+          })
+        );
+      })
+    );
 
-  stream.respond();
-  stream.end('hello world');
-}));
+    stream.respond();
+    stream.end('hello world');
+  })
+);
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-  client = h2.connect(`http://localhost:${server.address().port}`,
-                      { maxReservedRemoteStreams: 1 });
+server.on(
+  'listening',
+  common.mustCall(() => {
+    client = h2.connect(
+      `http://localhost:${server.address().port}`,
+      { maxReservedRemoteStreams: 1 }
+    );
 
-  const req = client.request();
+    const req = client.request();
 
-  // Because maxReservedRemoteStream is 1, the stream event
-  // must only be emitted once, even tho the server sends
-  // two push streams.
-  client.on('stream', common.mustCall((stream) => {
-    stream.resume();
-    stream.on('push', common.mustCall());
-    stream.on('end', common.mustCall());
-    stream.on('close', common.mustCall(() => countdown.dec()));
-  }));
+    // Because maxReservedRemoteStream is 1, the stream event
+    // must only be emitted once, even tho the server sends
+    // two push streams.
+    client.on(
+      'stream',
+      common.mustCall((stream) => {
+        stream.resume();
+        stream.on('push', common.mustCall());
+        stream.on('end', common.mustCall());
+        stream.on('close', common.mustCall(() => countdown.dec()));
+      })
+    );
 
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall());
-  req.on('close', common.mustCall(() => countdown.dec()));
-}));
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => countdown.dec()));
+  })
+);
diff --git a/test/parallel/test-http2-options-server-request.js b/test/parallel/test-http2-options-server-request.js
index 2143d379823d51..e8fab8cfd88723 100644
--- a/test/parallel/test-http2-options-server-request.js
+++ b/test/parallel/test-http2-options-server-request.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -12,29 +11,37 @@ class MyServerRequest extends h2.Http2ServerRequest {
   }
 }
 
-const server = h2.createServer({
-  Http2ServerRequest: MyServerRequest
-}, (req, res) => {
-  assert.strictEqual(req.getUserAgent(), 'node-test');
+const server = h2.createServer(
+  {
+    Http2ServerRequest: MyServerRequest
+  },
+  (req, res) => {
+    assert.strictEqual(req.getUserAgent(), 'node-test');
 
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.end();
-});
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end();
+  }
+);
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request({
-    ':path': '/',
-    'User-Agent': 'node-test'
-  });
-
-  req.on('response', common.mustCall());
-
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.destroy();
-  }));
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({
+      ':path': '/',
+      'User-Agent': 'node-test'
+    });
+
+    req.on('response', common.mustCall());
+
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.destroy();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-options-server-response.js b/test/parallel/test-http2-options-server-response.js
index 6f1ae1881d22d8..f13a991cd80252 100644
--- a/test/parallel/test-http2-options-server-response.js
+++ b/test/parallel/test-http2-options-server-response.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 class MyServerResponse extends h2.Http2ServerResponse {
@@ -11,24 +10,32 @@ class MyServerResponse extends h2.Http2ServerResponse {
   }
 }
 
-const server = h2.createServer({
-  Http2ServerResponse: MyServerResponse
-}, (req, res) => {
-  res.status(200);
-  res.end();
-});
+const server = h2.createServer(
+  {
+    Http2ServerResponse: MyServerResponse
+  },
+  (req, res) => {
+    res.status(200);
+    res.end();
+  }
+);
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request({ ':path': '/' });
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({ ':path': '/' });
 
-  req.on('response', common.mustCall());
+    req.on('response', common.mustCall());
 
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.destroy();
-  }));
-}));
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.destroy();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-origin.js b/test/parallel/test-http2-origin.js
index 6312d1f00649f0..7e660c5b508e39 100644
--- a/test/parallel/test-http2-origin.js
+++ b/test/parallel/test-http2-origin.js
@@ -1,24 +1,10 @@
 'use strict';
 
-const {
-  hasCrypto,
-  mustCall,
-  mustNotCall,
-  skip
-} = require('../common');
-if (!hasCrypto)
-  skip('missing crypto');
-
-const {
-  deepStrictEqual,
-  strictEqual,
-  throws
-} = require('assert');
-const {
-  createSecureServer,
-  createServer,
-  connect
-} = require('http2');
+const { hasCrypto, mustCall, mustNotCall, skip } = require('../common');
+if (!hasCrypto) skip('missing crypto');
+
+const { deepStrictEqual, strictEqual, throws } = require('assert');
+const { createSecureServer, createServer, connect } = require('http2');
 const Countdown = require('../common/countdown');
 
 const { readKey } = require('../common/fixtures');
@@ -29,151 +15,209 @@ const ca = readKey('fake-startcom-root-cert.pem', 'binary');
 
 {
   const server = createSecureServer({ key, cert });
-  server.on('stream', mustCall((stream) => {
-    stream.session.origin('https://example.org/a/b/c',
-                          new URL('https://example.com'));
-    stream.respond();
-    stream.end('ok');
-  }));
-  server.on('session', mustCall((session) => {
-    session.origin('https://foo.org/a/b/c', new URL('https://bar.org'));
-
-    // Won't error, but won't send anything
-    session.origin();
-
-    [0, true, {}, []].forEach((input) => {
-      throws(
-        () => session.origin(input),
-        {
+  server.on(
+    'stream',
+    mustCall((stream) => {
+      stream.session.origin(
+        'https://example.org/a/b/c',
+        new URL('https://example.com')
+      );
+      stream.respond();
+      stream.end('ok');
+    })
+  );
+  server.on(
+    'session',
+    mustCall((session) => {
+      session.origin('https://foo.org/a/b/c', new URL('https://bar.org'));
+
+      // Won't error, but won't send anything
+      session.origin();
+
+      [0, true, {}, []].forEach((input) => {
+        throws(() => session.origin(input), {
           code: 'ERR_INVALID_ARG_TYPE',
           name: 'TypeError [ERR_INVALID_ARG_TYPE]'
-        }
-      );
-    });
+        });
+      });
 
-    [new URL('foo://bar'), 'foo://bar'].forEach((input) => {
-      throws(
-        () => session.origin(input),
-        {
+      [new URL('foo://bar'), 'foo://bar'].forEach((input) => {
+        throws(() => session.origin(input), {
           code: 'ERR_HTTP2_INVALID_ORIGIN',
           name: 'TypeError [ERR_HTTP2_INVALID_ORIGIN]'
-        }
-      );
-    });
+        });
+      });
 
-    ['not a valid url'].forEach((input) => {
-      throws(
-        () => session.origin(input),
-        {
+      ['not a valid url'].forEach((input) => {
+        throws(() => session.origin(input), {
           code: 'ERR_INVALID_URL',
           name: 'TypeError [ERR_INVALID_URL]'
-        }
+        });
+      });
+    })
+  );
+
+  server.listen(
+    0,
+    mustCall(() => {
+      const originSet = [`https://localhost:${server.address().port}`];
+      const client = connect(
+        originSet[0],
+        { ca }
       );
-    });
-  }));
-
-  server.listen(0, mustCall(() => {
-    const originSet = [`https://localhost:${server.address().port}`];
-    const client = connect(originSet[0], { ca });
-    const checks = [
-      ['https://foo.org', 'https://bar.org'],
-      ['https://example.org', 'https://example.com']
-    ];
-
-    const countdown = new Countdown(2, () => {
-      client.close();
-      server.close();
-    });
-
-    client.on('origin', mustCall((origins) => {
-      const check = checks.shift();
-      originSet.push(...check);
-      deepStrictEqual(originSet, client.originSet);
-      deepStrictEqual(origins, check);
-      countdown.dec();
-    }, 2));
-
-    client.request().on('close', mustCall()).resume();
-  }));
+      const checks = [
+        ['https://foo.org', 'https://bar.org'],
+        ['https://example.org', 'https://example.com']
+      ];
+
+      const countdown = new Countdown(2, () => {
+        client.close();
+        server.close();
+      });
+
+      client.on(
+        'origin',
+        mustCall((origins) => {
+          const check = checks.shift();
+          originSet.push(...check);
+          deepStrictEqual(originSet, client.originSet);
+          deepStrictEqual(origins, check);
+          countdown.dec();
+        }, 2)
+      );
+
+      client
+        .request()
+        .on('close', mustCall())
+        .resume();
+    })
+  );
 }
 
 // Test automatically sending origin on connection start
 {
-  const origins = [ 'https://foo.org/a/b/c', 'https://bar.org' ];
+  const origins = ['https://foo.org/a/b/c', 'https://bar.org'];
   const server = createSecureServer({ key, cert, origins });
-  server.on('stream', mustCall((stream) => {
-    stream.respond();
-    stream.end('ok');
-  }));
-
-  server.listen(0, mustCall(() => {
-    const check = ['https://foo.org', 'https://bar.org'];
-    const originSet = [`https://localhost:${server.address().port}`];
-    const client = connect(originSet[0], { ca });
-
-    client.on('origin', mustCall((origins) => {
-      originSet.push(...check);
-      deepStrictEqual(originSet, client.originSet);
-      deepStrictEqual(origins, check);
-      client.close();
-      server.close();
-    }));
-
-    client.request().on('close', mustCall()).resume();
-  }));
+  server.on(
+    'stream',
+    mustCall((stream) => {
+      stream.respond();
+      stream.end('ok');
+    })
+  );
+
+  server.listen(
+    0,
+    mustCall(() => {
+      const check = ['https://foo.org', 'https://bar.org'];
+      const originSet = [`https://localhost:${server.address().port}`];
+      const client = connect(
+        originSet[0],
+        { ca }
+      );
+
+      client.on(
+        'origin',
+        mustCall((origins) => {
+          originSet.push(...check);
+          deepStrictEqual(originSet, client.originSet);
+          deepStrictEqual(origins, check);
+          client.close();
+          server.close();
+        })
+      );
+
+      client
+        .request()
+        .on('close', mustCall())
+        .resume();
+    })
+  );
 }
 
 // If return status is 421, the request origin must be removed from the
 // originSet
 {
   const server = createSecureServer({ key, cert });
-  server.on('stream', mustCall((stream) => {
-    stream.respond({ ':status': 421 });
-    stream.end();
-  }));
-  server.on('session', mustCall((session) => {
-    session.origin('https://foo.org');
-  }));
-
-  server.listen(0, mustCall(() => {
-    const origin = `https://localhost:${server.address().port}`;
-    const client = connect(origin, { ca });
-
-    client.on('origin', mustCall((origins) => {
-      deepStrictEqual([origin, 'https://foo.org'], client.originSet);
-      const req = client.request({ ':authority': 'foo.org' });
-      req.on('response', mustCall((headers) => {
-        strictEqual(421, headers[':status']);
-        deepStrictEqual([origin], client.originSet);
-      }));
-      req.resume();
-      req.on('close', mustCall(() => {
-        client.close();
-        server.close();
-      }));
-    }, 1));
-  }));
+  server.on(
+    'stream',
+    mustCall((stream) => {
+      stream.respond({ ':status': 421 });
+      stream.end();
+    })
+  );
+  server.on(
+    'session',
+    mustCall((session) => {
+      session.origin('https://foo.org');
+    })
+  );
+
+  server.listen(
+    0,
+    mustCall(() => {
+      const origin = `https://localhost:${server.address().port}`;
+      const client = connect(
+        origin,
+        { ca }
+      );
+
+      client.on(
+        'origin',
+        mustCall((origins) => {
+          deepStrictEqual([origin, 'https://foo.org'], client.originSet);
+          const req = client.request({ ':authority': 'foo.org' });
+          req.on(
+            'response',
+            mustCall((headers) => {
+              strictEqual(421, headers[':status']);
+              deepStrictEqual([origin], client.originSet);
+            })
+          );
+          req.resume();
+          req.on(
+            'close',
+            mustCall(() => {
+              client.close();
+              server.close();
+            })
+          );
+        }, 1)
+      );
+    })
+  );
 }
 
 // Origin is ignored on plain text HTTP/2 connections... server will still
 // send them, but client will ignore them.
 {
   const server = createServer();
-  server.on('stream', mustCall((stream) => {
-    stream.session.origin('https://example.org',
-                          new URL('https://example.com'));
-    stream.respond();
-    stream.end('ok');
-  }));
-  server.listen(0, mustCall(() => {
-    const client = connect(`http://localhost:${server.address().port}`);
-    client.on('origin', mustNotCall());
-    strictEqual(client.originSet, undefined);
-    const req = client.request();
-    req.resume();
-    req.on('close', mustCall(() => {
-      client.close();
-      server.close();
-    }));
-  }));
+  server.on(
+    'stream',
+    mustCall((stream) => {
+      stream.session.origin(
+        'https://example.org',
+        new URL('https://example.com')
+      );
+      stream.respond();
+      stream.end('ok');
+    })
+  );
+  server.listen(
+    0,
+    mustCall(() => {
+      const client = connect(`http://localhost:${server.address().port}`);
+      client.on('origin', mustNotCall());
+      strictEqual(client.originSet, undefined);
+      const req = client.request();
+      req.resume();
+      req.on(
+        'close',
+        mustCall(() => {
+          client.close();
+          server.close();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http2-padding-aligned.js b/test/parallel/test-http2-padding-aligned.js
index 183eaef7389360..e0dcfbe3ddd95c 100644
--- a/test/parallel/test-http2-padding-aligned.js
+++ b/test/parallel/test-http2-padding-aligned.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const { PADDING_STRATEGY_ALIGNED } = http2.constants;
@@ -13,13 +12,16 @@ const makeDuplexPair = require('../common/duplexpair');
   const server = http2.createServer({
     paddingStrategy: PADDING_STRATEGY_ALIGNED
   });
-  server.on('stream', common.mustCall((stream, headers) => {
-    stream.respond({
-      'content-type': 'text/html',
-      ':status': 200
-    });
-    stream.end(testData);
-  }));
+  server.on(
+    'stream',
+    common.mustCall((stream, headers) => {
+      stream.respond({
+        'content-type': 'text/html',
+        ':status': 200
+      });
+      stream.end(testData);
+    })
+  );
 
   const { clientSide, serverSide } = makeDuplexPair();
 
@@ -31,38 +33,54 @@ const makeDuplexPair = require('../common/duplexpair');
   // Adjust for the 24-byte preamble and two 9-byte settings frames, and
   // the result must be equally divisible by 8
   assert.strictEqual(
-    (serverLengths.reduce((i, n) => i + n) - 24 - 9 - 9) % 8, 0);
+    (serverLengths.reduce((i, n) => i + n) - 24 - 9 - 9) % 8,
+    0
+  );
 
   // Adjust for two 9-byte settings frames, and the result must be equally
   // divisible by 8
-  assert.strictEqual(
-    (clientLengths.reduce((i, n) => i + n) - 9 - 9) % 8, 0);
+  assert.strictEqual((clientLengths.reduce((i, n) => i + n) - 9 - 9) % 8, 0);
 
-  serverSide.on('data', common.mustCall((chunk) => {
-    assert.strictEqual(chunk.length, serverLengths.shift());
-  }, serverLengths.length));
-  clientSide.on('data', common.mustCall((chunk) => {
-    assert.strictEqual(chunk.length, clientLengths.shift());
-  }, clientLengths.length));
+  serverSide.on(
+    'data',
+    common.mustCall((chunk) => {
+      assert.strictEqual(chunk.length, serverLengths.shift());
+    }, serverLengths.length)
+  );
+  clientSide.on(
+    'data',
+    common.mustCall((chunk) => {
+      assert.strictEqual(chunk.length, clientLengths.shift());
+    }, clientLengths.length)
+  );
 
   server.emit('connection', serverSide);
 
-  const client = http2.connect('http://localhost:80', {
-    paddingStrategy: PADDING_STRATEGY_ALIGNED,
-    createConnection: common.mustCall(() => clientSide)
-  });
+  const client = http2.connect(
+    'http://localhost:80',
+    {
+      paddingStrategy: PADDING_STRATEGY_ALIGNED,
+      createConnection: common.mustCall(() => clientSide)
+    }
+  );
 
   const req = client.request({ ':path': '/a' });
 
   req.on('response', common.mustCall());
 
   req.setEncoding('utf8');
-  req.on('data', common.mustCall((data) => {
-    assert.strictEqual(data, testData);
-  }));
-  req.on('close', common.mustCall(() => {
-    clientSide.destroy();
-    clientSide.end();
-  }));
+  req.on(
+    'data',
+    common.mustCall((data) => {
+      assert.strictEqual(data, testData);
+    })
+  );
+  req.on(
+    'close',
+    common.mustCall(() => {
+      clientSide.destroy();
+      clientSide.end();
+    })
+  );
   req.end();
 }
diff --git a/test/parallel/test-http2-padding-callback.js b/test/parallel/test-http2-padding-callback.js
index 6d6a6b27221b07..f881e1cacca228 100644
--- a/test/parallel/test-http2-padding-callback.js
+++ b/test/parallel/test-http2-padding-callback.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const { PADDING_STRATEGY_CALLBACK } = h2.constants;
@@ -36,16 +35,24 @@ function onStream(stream, headers, flags) {
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`,
-                            options);
-
-  const req = client.request({ ':path': '/' });
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-  req.end();
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(
+      `http://localhost:${server.address().port}`,
+      options
+    );
+
+    const req = client.request({ ':path': '/' });
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-perf_hooks.js b/test/parallel/test-http2-perf_hooks.js
index 5dd8ad0f6d883b..43722566d08ddd 100644
--- a/test/parallel/test-http2-perf_hooks.js
+++ b/test/parallel/test-http2-perf_hooks.js
@@ -1,52 +1,53 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 const { PerformanceObserver } = require('perf_hooks');
 
-const obs = new PerformanceObserver(common.mustCall((items) => {
-  const entry = items.getEntries()[0];
-  assert.strictEqual(entry.entryType, 'http2');
-  assert.strictEqual(typeof entry.startTime, 'number');
-  assert.strictEqual(typeof entry.duration, 'number');
-  switch (entry.name) {
-    case 'Http2Session':
-      assert.strictEqual(typeof entry.pingRTT, 'number');
-      assert.strictEqual(typeof entry.streamAverageDuration, 'number');
-      assert.strictEqual(typeof entry.streamCount, 'number');
-      assert.strictEqual(typeof entry.framesReceived, 'number');
-      assert.strictEqual(typeof entry.framesSent, 'number');
-      assert.strictEqual(typeof entry.bytesWritten, 'number');
-      assert.strictEqual(typeof entry.bytesRead, 'number');
-      assert.strictEqual(typeof entry.maxConcurrentStreams, 'number');
-      switch (entry.type) {
-        case 'server':
-          assert.strictEqual(entry.streamCount, 1);
-          assert(entry.framesReceived >= 3);
-          break;
-        case 'client':
-          assert.strictEqual(entry.streamCount, 1);
-          assert.strictEqual(entry.framesReceived, 8);
-          break;
-        default:
-          assert.fail('invalid Http2Session type');
-      }
-      break;
-    case 'Http2Stream':
-      assert.strictEqual(typeof entry.timeToFirstByte, 'number');
-      assert.strictEqual(typeof entry.timeToFirstByteSent, 'number');
-      assert.strictEqual(typeof entry.timeToFirstHeader, 'number');
-      assert.strictEqual(typeof entry.bytesWritten, 'number');
-      assert.strictEqual(typeof entry.bytesRead, 'number');
-      break;
-    default:
-      assert.fail('invalid entry name');
-  }
-}, 4));
+const obs = new PerformanceObserver(
+  common.mustCall((items) => {
+    const entry = items.getEntries()[0];
+    assert.strictEqual(entry.entryType, 'http2');
+    assert.strictEqual(typeof entry.startTime, 'number');
+    assert.strictEqual(typeof entry.duration, 'number');
+    switch (entry.name) {
+      case 'Http2Session':
+        assert.strictEqual(typeof entry.pingRTT, 'number');
+        assert.strictEqual(typeof entry.streamAverageDuration, 'number');
+        assert.strictEqual(typeof entry.streamCount, 'number');
+        assert.strictEqual(typeof entry.framesReceived, 'number');
+        assert.strictEqual(typeof entry.framesSent, 'number');
+        assert.strictEqual(typeof entry.bytesWritten, 'number');
+        assert.strictEqual(typeof entry.bytesRead, 'number');
+        assert.strictEqual(typeof entry.maxConcurrentStreams, 'number');
+        switch (entry.type) {
+          case 'server':
+            assert.strictEqual(entry.streamCount, 1);
+            assert(entry.framesReceived >= 3);
+            break;
+          case 'client':
+            assert.strictEqual(entry.streamCount, 1);
+            assert.strictEqual(entry.framesReceived, 8);
+            break;
+          default:
+            assert.fail('invalid Http2Session type');
+        }
+        break;
+      case 'Http2Stream':
+        assert.strictEqual(typeof entry.timeToFirstByte, 'number');
+        assert.strictEqual(typeof entry.timeToFirstByteSent, 'number');
+        assert.strictEqual(typeof entry.timeToFirstHeader, 'number');
+        assert.strictEqual(typeof entry.bytesWritten, 'number');
+        assert.strictEqual(typeof entry.bytesRead, 'number');
+        break;
+      default:
+        assert.fail('invalid entry name');
+    }
+  }, 4)
+);
 obs.observe({ entryTypes: ['http2'] });
 
 const body =
@@ -70,33 +71,46 @@ function onStream(stream, headers, flags) {
   stream.end(body.slice(20));
 }
 
-server.on('session', common.mustCall((session) => {
-  session.ping(common.mustCall());
-}));
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.ping(common.mustCall());
+  })
+);
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  client.on('connect', common.mustCall(() => {
-    client.ping(common.mustCall());
-  }));
-
-  const req = client.request();
-
-  req.on('response', common.mustCall());
-
-  let data = '';
-  req.setEncoding('utf8');
-  req.on('data', (d) => data += d);
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(body, data);
-  }));
-  req.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+
+    client.on(
+      'connect',
+      common.mustCall(() => {
+        client.ping(common.mustCall());
+      })
+    );
+
+    const req = client.request();
+
+    req.on('response', common.mustCall());
+
+    let data = '';
+    req.setEncoding('utf8');
+    req.on('data', (d) => (data += d));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(body, data);
+      })
+    );
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-ping-unsolicited-ack.js b/test/parallel/test-http2-ping-unsolicited-ack.js
index 5a3a261cb098b1..d4f0d543bf0538 100644
--- a/test/parallel/test-http2-ping-unsolicited-ack.js
+++ b/test/parallel/test-http2-ping-unsolicited-ack.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http2 = require('http2');
 const net = require('net');
@@ -16,28 +15,40 @@ const kPingAck = new http2util.PingFrame(true);
 const server = http2.createServer();
 
 server.on('stream', common.mustNotCall());
-server.on('session', common.mustCall((session) => {
-  session.on('error', common.expectsError({
-    code: 'ERR_HTTP2_ERROR',
-    message: 'Protocol error'
-  }));
-  session.on('close', common.mustCall(() => server.close()));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = net.connect(server.address().port);
-
-  client.on('connect', common.mustCall(() => {
-    client.write(http2util.kClientMagic, () => {
-      client.write(kSettings.data);
-      // Send an unsolicited ping ack
-      client.write(kPingAck.data);
-    });
-  }));
-
-  // An error event may or may not be emitted, depending on operating system
-  // and timing. We do not really care if one is emitted here or not, as the
-  // error on the server side is what we are testing for. Do not make this
-  // a common.mustCall() and there's no need to check the error details.
-  client.on('error', () => {});
-}));
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_ERROR',
+        message: 'Protocol error'
+      })
+    );
+    session.on('close', common.mustCall(() => server.close()));
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = net.connect(server.address().port);
+
+    client.on(
+      'connect',
+      common.mustCall(() => {
+        client.write(http2util.kClientMagic, () => {
+          client.write(kSettings.data);
+          // Send an unsolicited ping ack
+          client.write(kPingAck.data);
+        });
+      })
+    );
+
+    // An error event may or may not be emitted, depending on operating system
+    // and timing. We do not really care if one is emitted here or not, as the
+    // error on the server side is what we are testing for. Do not make this
+    // a common.mustCall() and there's no need to check the error details.
+    client.on('error', () => {});
+  })
+);
diff --git a/test/parallel/test-http2-ping.js b/test/parallel/test-http2-ping.js
index afb74af827b860..84022b74dcf4d3 100644
--- a/test/parallel/test-http2-ping.js
+++ b/test/parallel/test-http2-ping.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const async_hooks = require('async_hooks');
 const assert = require('assert');
@@ -41,95 +40,119 @@ process.on('exit', () => {
 });
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  assert(stream.session.ping(common.mustCall((err, duration, ret) => {
-    assert.strictEqual(err, null);
-    assert.strictEqual(typeof duration, 'number');
-    assert.strictEqual(ret.length, 8);
-    stream.end('ok');
-  })));
-  stream.respond();
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    assert(
+      stream.session.ping(
+        common.mustCall((err, duration, ret) => {
+          assert.strictEqual(err, null);
+          assert.strictEqual(typeof duration, 'number');
+          assert.strictEqual(ret.length, 8);
+          stream.end('ok');
+        })
+      )
+    );
+    stream.respond();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`,
-                               { maxOutstandingPings: 2 });
-  client.on('connect', common.mustCall(() => {
-    {
-      const payload = Buffer.from('abcdefgh');
-      assert(client.ping(payload, common.mustCall((err, duration, ret) => {
-        assert.strictEqual(err, null);
-        assert.strictEqual(typeof duration, 'number');
-        assert.deepStrictEqual(payload, ret);
-      })));
-    }
-    {
-      const payload = Buffer.from('abcdefgi');
-      assert(client.ping(payload, common.mustCall((err, duration, ret) => {
-        assert.strictEqual(err, null);
-        assert.strictEqual(typeof duration, 'number');
-        assert.deepStrictEqual(payload, ret);
-      })));
-    }
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(
+      `http://localhost:${server.address().port}`,
+      { maxOutstandingPings: 2 }
+    );
+    client.on(
+      'connect',
+      common.mustCall(() => {
+        {
+          const payload = Buffer.from('abcdefgh');
+          assert(
+            client.ping(
+              payload,
+              common.mustCall((err, duration, ret) => {
+                assert.strictEqual(err, null);
+                assert.strictEqual(typeof duration, 'number');
+                assert.deepStrictEqual(payload, ret);
+              })
+            )
+          );
+        }
+        {
+          const payload = Buffer.from('abcdefgi');
+          assert(
+            client.ping(
+              payload,
+              common.mustCall((err, duration, ret) => {
+                assert.strictEqual(err, null);
+                assert.strictEqual(typeof duration, 'number');
+                assert.deepStrictEqual(payload, ret);
+              })
+            )
+          );
+        }
 
-    // Only max 2 pings at a time based on the maxOutstandingPings option
-    assert(!client.ping(common.expectsError({
-      code: 'ERR_HTTP2_PING_CANCEL',
-      type: Error,
-      message: 'HTTP2 ping cancelled'
-    })));
+        // Only max 2 pings at a time based on the maxOutstandingPings option
+        assert(
+          !client.ping(
+            common.expectsError({
+              code: 'ERR_HTTP2_PING_CANCEL',
+              type: Error,
+              message: 'HTTP2 ping cancelled'
+            })
+          )
+        );
 
-    // Should throw if payload is not of type ArrayBufferView
-    {
-      [1, true, {}, []].forEach((payload) =>
-        common.expectsError(
-          () => client.ping(payload),
-          {
-            type: TypeError,
-            code: 'ERR_INVALID_ARG_TYPE',
-            message: 'The "payload" argument must be one of type Buffer, ' +
-                     `TypedArray, or DataView. Received type ${typeof payload}`
-          }
-        )
-      );
-    }
+        // Should throw if payload is not of type ArrayBufferView
+        {
+          [1, true, {}, []].forEach((payload) =>
+            common.expectsError(() => client.ping(payload), {
+              type: TypeError,
+              code: 'ERR_INVALID_ARG_TYPE',
+              message:
+                'The "payload" argument must be one of type Buffer, ' +
+                `TypedArray, or DataView. Received type ${typeof payload}`
+            })
+          );
+        }
 
-    // Should throw if payload length is not 8
-    {
-      const shortPayload = Buffer.from('abcdefg');
-      const longPayload = Buffer.from('abcdefghi');
-      [shortPayload, longPayload].forEach((payloadWithInvalidLength) =>
-        common.expectsError(
-          () => client.ping(payloadWithInvalidLength),
-          {
-            type: RangeError,
-            code: 'ERR_HTTP2_PING_LENGTH',
-            message: 'HTTP2 ping payload must be 8 bytes'
-          }
-        )
-      );
-    }
+        // Should throw if payload length is not 8
+        {
+          const shortPayload = Buffer.from('abcdefg');
+          const longPayload = Buffer.from('abcdefghi');
+          [shortPayload, longPayload].forEach((payloadWithInvalidLength) =>
+            common.expectsError(() => client.ping(payloadWithInvalidLength), {
+              type: RangeError,
+              code: 'ERR_HTTP2_PING_LENGTH',
+              message: 'HTTP2 ping payload must be 8 bytes'
+            })
+          );
+        }
 
-    // Should throw error is callback is not of type function
-    {
-      const payload = Buffer.from('abcdefgh');
-      [1, true, {}, []].forEach((invalidCallback) =>
-        common.expectsError(
-          () => client.ping(payload, invalidCallback),
-          {
-            type: TypeError,
-            code: 'ERR_INVALID_CALLBACK',
-            message: 'Callback must be a function'
-          }
-        )
-      );
-    }
+        // Should throw error is callback is not of type function
+        {
+          const payload = Buffer.from('abcdefgh');
+          [1, true, {}, []].forEach((invalidCallback) =>
+            common.expectsError(() => client.ping(payload, invalidCallback), {
+              type: TypeError,
+              code: 'ERR_INVALID_CALLBACK',
+              message: 'Callback must be a function'
+            })
+          );
+        }
 
-    const req = client.request();
-    req.resume();
-    req.on('end', common.mustCall(() => {
-      client.close();
-      server.close();
-    }));
-  }));
-}));
+        const req = client.request();
+        req.resume();
+        req.on(
+          'end',
+          common.mustCall(() => {
+            client.close();
+            server.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-pipe-named-pipe.js b/test/parallel/test-http2-pipe-named-pipe.js
index 7882f79657f701..0c731894727732 100644
--- a/test/parallel/test-http2-pipe-named-pipe.js
+++ b/test/parallel/test-http2-pipe-named-pipe.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const http2 = require('http2');
@@ -19,34 +18,48 @@ const fn = path.join(tmpdir.path, 'http2-url-tests.js');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  const dest = stream.pipe(fs.createWriteStream(fn));
-
-  dest.on('finish', () => {
-    assert.strictEqual(fs.readFileSync(loc).length,
-                       fs.readFileSync(fn).length);
-  });
-  stream.respond();
-  stream.end();
-}));
-
-server.listen(common.PIPE, common.mustCall(() => {
-  const client = http2.connect('http://localhost', {
-    createConnection(url) {
-      return net.connect(server.address());
-    }
-  });
-
-  const req = client.request({ ':method': 'POST' });
-  req.on('response', common.mustCall());
-  req.resume();
-
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-
-  const str = fs.createReadStream(loc);
-  str.on('end', common.mustCall());
-  str.pipe(req);
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    const dest = stream.pipe(fs.createWriteStream(fn));
+
+    dest.on('finish', () => {
+      assert.strictEqual(
+        fs.readFileSync(loc).length,
+        fs.readFileSync(fn).length
+      );
+    });
+    stream.respond();
+    stream.end();
+  })
+);
+
+server.listen(
+  common.PIPE,
+  common.mustCall(() => {
+    const client = http2.connect(
+      'http://localhost',
+      {
+        createConnection(url) {
+          return net.connect(server.address());
+        }
+      }
+    );
+
+    const req = client.request({ ':method': 'POST' });
+    req.on('response', common.mustCall());
+    req.resume();
+
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+
+    const str = fs.createReadStream(loc);
+    str.on('end', common.mustCall());
+    str.pipe(req);
+  })
+);
diff --git a/test/parallel/test-http2-pipe.js b/test/parallel/test-http2-pipe.js
index 2e564d3e329dbc..b9c0c8e068701c 100644
--- a/test/parallel/test-http2-pipe.js
+++ b/test/parallel/test-http2-pipe.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const http2 = require('http2');
@@ -18,31 +17,42 @@ const fn = path.join(tmpdir.path, 'http2-url-tests.js');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  const dest = stream.pipe(fs.createWriteStream(fn));
-
-  dest.on('finish', () => {
-    assert.strictEqual(fs.readFileSync(loc).length,
-                       fs.readFileSync(fn).length);
-  });
-  stream.respond();
-  stream.end();
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-
-  const req = client.request({ ':method': 'POST' });
-
-  req.on('response', common.mustCall());
-  req.resume();
-
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-
-  const str = fs.createReadStream(loc);
-  str.on('end', common.mustCall());
-  str.pipe(req);
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    const dest = stream.pipe(fs.createWriteStream(fn));
+
+    dest.on('finish', () => {
+      assert.strictEqual(
+        fs.readFileSync(loc).length,
+        fs.readFileSync(fn).length
+      );
+    });
+    stream.respond();
+    stream.end();
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    const req = client.request({ ':method': 'POST' });
+
+    req.on('response', common.mustCall());
+    req.resume();
+
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+
+    const str = fs.createReadStream(loc);
+    str.on('end', common.mustCall());
+    str.pipe(req);
+  })
+);
diff --git a/test/parallel/test-http2-priority-cycle-.js b/test/parallel/test-http2-priority-cycle-.js
index af0d66d8343cbf..be1036b16547ea 100644
--- a/test/parallel/test-http2-priority-cycle-.js
+++ b/test/parallel/test-http2-priority-cycle-.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
@@ -12,58 +11,67 @@ const largeBuffer = Buffer.alloc(1e4);
 
 // Verify that a dependency cycle may exist, but that it doesn't crash anything
 
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  setImmediate(() => {
-    stream.end(largeBuffer);
-  });
-}, 3));
-server.on('session', common.mustCall((session) => {
-  session.on('priority', (id, parent, weight, exclusive) => {
-    assert.strictEqual(weight, 16);
-    assert.strictEqual(exclusive, false);
-    switch (id) {
-      case 1:
-        assert.strictEqual(parent, 5);
-        break;
-      case 3:
-        assert.strictEqual(parent, 1);
-        break;
-      case 5:
-        assert.strictEqual(parent, 3);
-        break;
-      default:
-        assert.fail('should not happen');
-    }
-  });
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    setImmediate(() => {
+      stream.end(largeBuffer);
+    });
+  }, 3)
+);
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.on('priority', (id, parent, weight, exclusive) => {
+      assert.strictEqual(weight, 16);
+      assert.strictEqual(exclusive, false);
+      switch (id) {
+        case 1:
+          assert.strictEqual(parent, 5);
+          break;
+        case 3:
+          assert.strictEqual(parent, 1);
+          break;
+        case 5:
+          assert.strictEqual(parent, 3);
+          break;
+        default:
+          assert.fail('should not happen');
+      }
+    });
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  const countdown = new Countdown(3, () => {
-    client.close();
-    server.close();
-  });
+    const countdown = new Countdown(3, () => {
+      client.close();
+      server.close();
+    });
 
-  {
-    const req = client.request();
-    req.priority({ parent: 5 });
-    req.resume();
-    req.on('close', () => countdown.dec());
-  }
+    {
+      const req = client.request();
+      req.priority({ parent: 5 });
+      req.resume();
+      req.on('close', () => countdown.dec());
+    }
 
-  {
-    const req = client.request();
-    req.priority({ parent: 1 });
-    req.resume();
-    req.on('close', () => countdown.dec());
-  }
+    {
+      const req = client.request();
+      req.priority({ parent: 1 });
+      req.resume();
+      req.on('close', () => countdown.dec());
+    }
 
-  {
-    const req = client.request();
-    req.priority({ parent: 3 });
-    req.resume();
-    req.on('close', () => countdown.dec());
-  }
-}));
+    {
+      const req = client.request();
+      req.priority({ parent: 3 });
+      req.resume();
+      req.on('close', () => countdown.dec());
+    }
+  })
+);
diff --git a/test/parallel/test-http2-priority-event.js b/test/parallel/test-http2-priority-event.js
index fe04ffb342d70d..ef80ae92d0ffea 100644
--- a/test/parallel/test-http2-priority-event.js
+++ b/test/parallel/test-http2-priority-event.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -35,27 +34,31 @@ server.listen(0);
 
 server.on('priority', common.mustCall(onPriority));
 
-server.on('listening', common.mustCall(() => {
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({ ':path': '/' });
 
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request({ ':path': '/' });
-
-  client.on('connect', () => {
-    req.priority({
-      parent: 0,
-      weight: 1,
-      exclusive: false
+    client.on('connect', () => {
+      req.priority({
+        parent: 0,
+        weight: 1,
+        exclusive: false
+      });
     });
-  });
-
-  req.on('priority', common.mustCall(onPriority));
 
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-  req.end();
+    req.on('priority', common.mustCall(onPriority));
 
-}));
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-request-remove-connect-listener.js b/test/parallel/test-http2-request-remove-connect-listener.js
index 61de140c225144..b70ad24ee138df 100644
--- a/test/parallel/test-http2-request-remove-connect-listener.js
+++ b/test/parallel/test-http2-request-remove-connect-listener.js
@@ -1,28 +1,38 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
-
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.end();
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    stream.end();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  client.once('connect', common.mustCall());
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    client.once('connect', common.mustCall());
 
-  req.on('response', common.mustCall(() => {
-    assert.strictEqual(client.listenerCount('connect'), 0);
-  }));
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+    req.on(
+      'response',
+      common.mustCall(() => {
+        assert.strictEqual(client.listenerCount('connect'), 0);
+      })
+    );
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-request-response-proto.js b/test/parallel/test-http2-request-response-proto.js
index 9f84f9f475a1a2..f17efa23554bf4 100644
--- a/test/parallel/test-http2-request-response-proto.js
+++ b/test/parallel/test-http2-request-response-proto.js
@@ -1,15 +1,11 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
-const {
-  Http2ServerRequest,
-  Http2ServerResponse,
-} = http2;
+const { Http2ServerRequest, Http2ServerResponse } = http2;
 
 const protoRequest = Object.create(Http2ServerRequest.prototype);
 const protoResponse = Object.create(Http2ServerResponse.prototype);
diff --git a/test/parallel/test-http2-respond-errors.js b/test/parallel/test-http2-respond-errors.js
index 98f2558253deff..82a22a07d8abb1 100644
--- a/test/parallel/test-http2-respond-errors.js
+++ b/test/parallel/test-http2-respond-errors.js
@@ -2,8 +2,7 @@
 // Flags: --expose-internals
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const { internalBinding } = require('internal/test/binding');
 const { Http2Stream } = internalBinding('http2');
@@ -11,41 +10,43 @@ const { Http2Stream } = internalBinding('http2');
 const server = http2.createServer();
 
 Http2Stream.prototype.respond = () => 1;
-server.on('stream', common.mustCall((stream) => {
-
-  // Send headers
-  stream.respond({ 'content-type': 'text/plain' });
-
-  // Should throw if headers already sent
-  common.expectsError(
-    () => stream.respond(),
-    {
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    // Send headers
+    stream.respond({ 'content-type': 'text/plain' });
+
+    // Should throw if headers already sent
+    common.expectsError(() => stream.respond(), {
       type: Error,
       code: 'ERR_HTTP2_HEADERS_SENT',
       message: 'Response has already been initiated.'
-    }
-  );
+    });
 
-  // Should throw if stream already destroyed
-  stream.destroy();
-  common.expectsError(
-    () => stream.respond(),
-    {
+    // Should throw if stream already destroyed
+    stream.destroy();
+    common.expectsError(() => stream.respond(), {
       type: Error,
       code: 'ERR_HTTP2_INVALID_STREAM',
       message: 'The stream has been destroyed'
-    }
-  );
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-  req.resume();
-  req.end();
-}));
+    });
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+
+    req.on(
+      'end',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+    req.resume();
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-respond-file-204.js b/test/parallel/test-http2-respond-file-204.js
index b0ba634e67df69..addfe4a01586b5 100644
--- a/test/parallel/test-http2-respond-file-204.js
+++ b/test/parallel/test-http2-respond-file-204.js
@@ -1,30 +1,29 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 
-const {
-  HTTP2_HEADER_CONTENT_TYPE,
-  HTTP2_HEADER_STATUS
-} = http2.constants;
+const { HTTP2_HEADER_CONTENT_TYPE, HTTP2_HEADER_STATUS } = http2.constants;
 
 const fname = fixtures.path('elipses.txt');
 
 const server = http2.createServer();
 server.on('stream', (stream) => {
-  common.expectsError(() => {
-    stream.respondWithFile(fname, {
-      [HTTP2_HEADER_STATUS]: 204,
-      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
-    });
-  }, {
-    code: 'ERR_HTTP2_PAYLOAD_FORBIDDEN',
-    type: Error,
-    message: 'Responses with 204 status must not have a payload'
-  });
+  common.expectsError(
+    () => {
+      stream.respondWithFile(fname, {
+        [HTTP2_HEADER_STATUS]: 204,
+        [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+      });
+    },
+    {
+      code: 'ERR_HTTP2_PAYLOAD_FORBIDDEN',
+      type: Error,
+      message: 'Responses with 204 status must not have a payload'
+    }
+  );
   stream.respond({});
   stream.end();
 });
@@ -33,9 +32,12 @@ server.listen(0, () => {
   const req = client.request();
   req.on('response', common.mustCall());
   req.on('data', common.mustNotCall());
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
diff --git a/test/parallel/test-http2-respond-file-304.js b/test/parallel/test-http2-respond-file-304.js
index 536c48c624e73c..18521488830459 100644
--- a/test/parallel/test-http2-respond-file-304.js
+++ b/test/parallel/test-http2-respond-file-304.js
@@ -1,45 +1,50 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 const assert = require('assert');
 
-const {
-  HTTP2_HEADER_CONTENT_TYPE,
-  HTTP2_HEADER_STATUS
-} = http2.constants;
+const { HTTP2_HEADER_CONTENT_TYPE, HTTP2_HEADER_STATUS } = http2.constants;
 
 const fname = fixtures.path('elipses.txt');
 
 const server = http2.createServer();
 server.on('stream', (stream) => {
-  stream.respondWithFile(fname, {
-    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
-  }, {
-    statCheck(stat, headers) {
-      // abort the send and return a 304 Not Modified instead
-      stream.respond({ [HTTP2_HEADER_STATUS]: 304 });
-      return false;
+  stream.respondWithFile(
+    fname,
+    {
+      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+    },
+    {
+      statCheck(stat, headers) {
+        // abort the send and return a 304 Not Modified instead
+        stream.respond({ [HTTP2_HEADER_STATUS]: 304 });
+        return false;
+      }
     }
-  });
+  );
 });
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[HTTP2_HEADER_STATUS], 304);
-    assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE, undefined]);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[HTTP2_HEADER_STATUS], 304);
+      assert.strictEqual(headers[(HTTP2_HEADER_CONTENT_TYPE, undefined)]);
+    })
+  );
 
   req.on('data', common.mustNotCall());
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
diff --git a/test/parallel/test-http2-respond-file-404.js b/test/parallel/test-http2-respond-file-404.js
index 60bc21f185dd5c..b18595bd2b9cca 100644
--- a/test/parallel/test-http2-respond-file-404.js
+++ b/test/parallel/test-http2-respond-file-404.js
@@ -1,47 +1,53 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const assert = require('assert');
 const path = require('path');
 
-const {
-  HTTP2_HEADER_CONTENT_TYPE
-} = http2.constants;
+const { HTTP2_HEADER_CONTENT_TYPE } = http2.constants;
 
 const server = http2.createServer();
 server.on('stream', (stream) => {
   const file = path.join(process.cwd(), 'not-a-file');
-  stream.respondWithFile(file, {
-    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
-  }, {
-    onError(err) {
-      common.expectsError({
-        code: 'ENOENT',
-        type: Error,
-        message: `ENOENT: no such file or directory, open '${file}'`
-      })(err);
-
-      stream.respond({ ':status': 404 });
-      stream.end();
+  stream.respondWithFile(
+    file,
+    {
+      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
     },
-    statCheck: common.mustNotCall()
-  });
+    {
+      onError(err) {
+        common.expectsError({
+          code: 'ENOENT',
+          type: Error,
+          message: `ENOENT: no such file or directory, open '${file}'`
+        })(err);
+
+        stream.respond({ ':status': 404 });
+        stream.end();
+      },
+      statCheck: common.mustNotCall()
+    }
+  );
 });
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 404);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 404);
+    })
+  );
   req.on('data', common.mustNotCall());
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
diff --git a/test/parallel/test-http2-respond-file-compat.js b/test/parallel/test-http2-respond-file-compat.js
index 0205f2d0d85aaf..4f8714101f9207 100644
--- a/test/parallel/test-http2-respond-file-compat.js
+++ b/test/parallel/test-http2-respond-file-compat.js
@@ -1,24 +1,28 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const fixtures = require('../common/fixtures');
 
 const fname = fixtures.path('elipses.txt');
 
-const server = http2.createServer(common.mustCall((request, response) => {
-  response.stream.respondWithFile(fname);
-}));
+const server = http2.createServer(
+  common.mustCall((request, response) => {
+    response.stream.respondWithFile(fname);
+  })
+);
 server.listen(0, () => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
   req.on('response', common.mustCall());
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      server.close();
+    })
+  );
   req.end();
   req.resume();
 });
diff --git a/test/parallel/test-http2-respond-file-error-dir.js b/test/parallel/test-http2-respond-file-error-dir.js
index 24a6d2dc96597e..a3551a6f6219d4 100644
--- a/test/parallel/test-http2-respond-file-error-dir.js
+++ b/test/parallel/test-http2-respond-file-error-dir.js
@@ -1,41 +1,49 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const assert = require('assert');
 
 const server = http2.createServer();
 server.on('stream', (stream) => {
-  stream.respondWithFile(process.cwd(), {
-    'content-type': 'text/plain'
-  }, {
-    onError(err) {
-      common.expectsError({
-        code: 'ERR_HTTP2_SEND_FILE',
-        type: Error,
-        message: 'Directories cannot be sent'
-      })(err);
-
-      stream.respond({ ':status': 404 });
-      stream.end();
+  stream.respondWithFile(
+    process.cwd(),
+    {
+      'content-type': 'text/plain'
     },
-    statCheck: common.mustNotCall()
-  });
+    {
+      onError(err) {
+        common.expectsError({
+          code: 'ERR_HTTP2_SEND_FILE',
+          type: Error,
+          message: 'Directories cannot be sent'
+        })(err);
+
+        stream.respond({ ':status': 404 });
+        stream.end();
+      },
+      statCheck: common.mustNotCall()
+    }
+  );
 });
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 404);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 404);
+    })
+  );
   req.on('data', common.mustNotCall());
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
diff --git a/test/parallel/test-http2-respond-file-error-pipe-offset.js b/test/parallel/test-http2-respond-file-error-pipe-offset.js
index eb782e2dea66c4..646d5dc4ded86a 100644
--- a/test/parallel/test-http2-respond-file-error-pipe-offset.js
+++ b/test/parallel/test-http2-respond-file-error-pipe-offset.js
@@ -1,10 +1,8 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
-if (common.isWindows)
-  common.skip('no mkfifo on Windows');
+if (!common.hasCrypto) common.skip('missing crypto');
+if (common.isWindows) common.skip('no mkfifo on Windows');
 const child_process = require('child_process');
 const path = require('path');
 const fs = require('fs');
@@ -16,7 +14,7 @@ tmpdir.refresh();
 
 const pipeName = path.join(tmpdir.path, 'pipe');
 
-const mkfifo = child_process.spawnSync('mkfifo', [ pipeName ]);
+const mkfifo = child_process.spawnSync('mkfifo', [pipeName]);
 if (mkfifo.error && mkfifo.error.code === 'ENOENT') {
   common.skip('missing mkfifo');
 }
@@ -25,36 +23,45 @@ process.on('exit', () => fs.unlinkSync(pipeName));
 
 const server = http2.createServer();
 server.on('stream', (stream) => {
-  stream.respondWithFile(pipeName, {
-    'content-type': 'text/plain'
-  }, {
-    offset: 10,
-    onError(err) {
-      common.expectsError({
-        code: 'ERR_HTTP2_SEND_FILE_NOSEEK',
-        type: Error,
-        message: 'Offset or length can only be specified for regular files'
-      })(err);
-
-      stream.respond({ ':status': 404 });
-      stream.end();
+  stream.respondWithFile(
+    pipeName,
+    {
+      'content-type': 'text/plain'
     },
-    statCheck: common.mustNotCall()
-  });
+    {
+      offset: 10,
+      onError(err) {
+        common.expectsError({
+          code: 'ERR_HTTP2_SEND_FILE_NOSEEK',
+          type: Error,
+          message: 'Offset or length can only be specified for regular files'
+        })(err);
+
+        stream.respond({ ':status': 404 });
+        stream.end();
+      },
+      statCheck: common.mustNotCall()
+    }
+  );
 });
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 404);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 404);
+    })
+  );
   req.on('data', common.mustNotCall());
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
 
diff --git a/test/parallel/test-http2-respond-file-errors.js b/test/parallel/test-http2-respond-file-errors.js
index 96dd579a154fe7..db800aec610f4d 100644
--- a/test/parallel/test-http2-respond-file-errors.js
+++ b/test/parallel/test-http2-respond-file-errors.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 
@@ -26,75 +25,94 @@ const fname = fixtures.path('elipses.txt');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    // Check for all possible TypeError triggers on options
+    Object.keys(optionsWithTypeError).forEach((option) => {
+      Object.keys(types).forEach((type) => {
+        if (type === optionsWithTypeError[option]) {
+          return;
+        }
 
-  // Check for all possible TypeError triggers on options
-  Object.keys(optionsWithTypeError).forEach((option) => {
-    Object.keys(types).forEach((type) => {
-      if (type === optionsWithTypeError[option]) {
-        return;
-      }
+        common.expectsError(
+          () =>
+            stream.respondWithFile(
+              fname,
+              {
+                'content-type': 'text/plain'
+              },
+              {
+                [option]: types[type]
+              }
+            ),
+          {
+            type: TypeError,
+            code: 'ERR_INVALID_OPT_VALUE',
+            message:
+              `The value "${String(types[type])}" is invalid ` +
+              `for option "${option}"`
+          }
+        );
+      });
+    });
 
+    // Should throw if :status 204, 205 or 304
+    [204, 205, 304].forEach((status) =>
       common.expectsError(
-        () => stream.respondWithFile(fname, {
-          'content-type': 'text/plain'
-        }, {
-          [option]: types[type]
-        }),
+        () =>
+          stream.respondWithFile(fname, {
+            'content-type': 'text/plain',
+            ':status': status
+          }),
         {
-          type: TypeError,
-          code: 'ERR_INVALID_OPT_VALUE',
-          message: `The value "${String(types[type])}" is invalid ` +
-                   `for option "${option}"`
+          code: 'ERR_HTTP2_PAYLOAD_FORBIDDEN',
+          message: `Responses with ${status} status must not have a payload`
         }
-      );
-    });
-  });
-
-  // Should throw if :status 204, 205 or 304
-  [204, 205, 304].forEach((status) => common.expectsError(
-    () => stream.respondWithFile(fname, {
-      'content-type': 'text/plain',
-      ':status': status,
-    }),
-    {
-      code: 'ERR_HTTP2_PAYLOAD_FORBIDDEN',
-      message: `Responses with ${status} status must not have a payload`
-    }
-  ));
+      )
+    );
 
-  // Should throw if headers already sent
-  stream.respond({ ':status': 200 });
-  common.expectsError(
-    () => stream.respondWithFile(fname, {
-      'content-type': 'text/plain'
-    }),
-    {
-      code: 'ERR_HTTP2_HEADERS_SENT',
-      message: 'Response has already been initiated.'
-    }
-  );
+    // Should throw if headers already sent
+    stream.respond({ ':status': 200 });
+    common.expectsError(
+      () =>
+        stream.respondWithFile(fname, {
+          'content-type': 'text/plain'
+        }),
+      {
+        code: 'ERR_HTTP2_HEADERS_SENT',
+        message: 'Response has already been initiated.'
+      }
+    );
 
-  // Should throw if stream already destroyed
-  stream.destroy();
-  common.expectsError(
-    () => stream.respondWithFile(fname, {
-      'content-type': 'text/plain'
-    }),
-    {
-      code: 'ERR_HTTP2_INVALID_STREAM',
-      message: 'The stream has been destroyed'
-    }
-  );
-}));
+    // Should throw if stream already destroyed
+    stream.destroy();
+    common.expectsError(
+      () =>
+        stream.respondWithFile(fname, {
+          'content-type': 'text/plain'
+        }),
+      {
+        code: 'ERR_HTTP2_INVALID_STREAM',
+        message: 'The stream has been destroyed'
+      }
+    );
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
 
-  req.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-  req.end();
-}));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-respond-file-fd-errors.js b/test/parallel/test-http2-respond-file-fd-errors.js
index 078d0eb11e451d..8b99a2bf3e94b4 100644
--- a/test/parallel/test-http2-respond-file-fd-errors.js
+++ b/test/parallel/test-http2-respond-file-fd-errors.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 const fs = require('fs');
@@ -28,96 +27,118 @@ const fd = fs.openSync(fname, 'r');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  // should throw if fd isn't a number
-  Object.keys(types).forEach((type) => {
-    if (type === 'number') {
-      return;
-    }
-
-    common.expectsError(
-      () => stream.respondWithFD(types[type], {
-        'content-type': 'text/plain'
-      }),
-      {
-        type: TypeError,
-        code: 'ERR_INVALID_ARG_TYPE',
-        message: 'The "fd" argument must be of type number. Received type ' +
-                 typeof types[type]
-      }
-    );
-  });
-
-  // Check for all possible TypeError triggers on options
-  Object.keys(optionsWithTypeError).forEach((option) => {
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    // should throw if fd isn't a number
     Object.keys(types).forEach((type) => {
-      if (type === optionsWithTypeError[option]) {
+      if (type === 'number') {
         return;
       }
 
       common.expectsError(
-        () => stream.respondWithFD(fd, {
-          'content-type': 'text/plain'
-        }, {
-          [option]: types[type]
-        }),
+        () =>
+          stream.respondWithFD(types[type], {
+            'content-type': 'text/plain'
+          }),
         {
           type: TypeError,
-          code: 'ERR_INVALID_OPT_VALUE',
-          message: `The value "${String(types[type])}" is invalid ` +
-                   `for option "${option}"`
+          code: 'ERR_INVALID_ARG_TYPE',
+          message:
+            'The "fd" argument must be of type number. Received type ' +
+            typeof types[type]
         }
       );
     });
-  });
 
-  // Should throw if :status 204, 205 or 304
-  [204, 205, 304].forEach((status) => common.expectsError(
-    () => stream.respondWithFD(fd, {
-      'content-type': 'text/plain',
-      ':status': status,
-    }),
-    {
-      code: 'ERR_HTTP2_PAYLOAD_FORBIDDEN',
-      type: Error,
-      message: `Responses with ${status} status must not have a payload`
-    }
-  ));
+    // Check for all possible TypeError triggers on options
+    Object.keys(optionsWithTypeError).forEach((option) => {
+      Object.keys(types).forEach((type) => {
+        if (type === optionsWithTypeError[option]) {
+          return;
+        }
 
-  // Should throw if headers already sent
-  stream.respond();
-  common.expectsError(
-    () => stream.respondWithFD(fd, {
-      'content-type': 'text/plain'
-    }),
-    {
-      code: 'ERR_HTTP2_HEADERS_SENT',
-      type: Error,
-      message: 'Response has already been initiated.'
-    }
-  );
+        common.expectsError(
+          () =>
+            stream.respondWithFD(
+              fd,
+              {
+                'content-type': 'text/plain'
+              },
+              {
+                [option]: types[type]
+              }
+            ),
+          {
+            type: TypeError,
+            code: 'ERR_INVALID_OPT_VALUE',
+            message:
+              `The value "${String(types[type])}" is invalid ` +
+              `for option "${option}"`
+          }
+        );
+      });
+    });
 
-  // Should throw if stream already destroyed
-  stream.destroy();
-  common.expectsError(
-    () => stream.respondWithFD(fd, {
-      'content-type': 'text/plain'
-    }),
-    {
-      code: 'ERR_HTTP2_INVALID_STREAM',
-      type: Error,
-      message: 'The stream has been destroyed'
-    }
-  );
-}));
+    // Should throw if :status 204, 205 or 304
+    [204, 205, 304].forEach((status) =>
+      common.expectsError(
+        () =>
+          stream.respondWithFD(fd, {
+            'content-type': 'text/plain',
+            ':status': status
+          }),
+        {
+          code: 'ERR_HTTP2_PAYLOAD_FORBIDDEN',
+          type: Error,
+          message: `Responses with ${status} status must not have a payload`
+        }
+      )
+    );
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
+    // Should throw if headers already sent
+    stream.respond();
+    common.expectsError(
+      () =>
+        stream.respondWithFD(fd, {
+          'content-type': 'text/plain'
+        }),
+      {
+        code: 'ERR_HTTP2_HEADERS_SENT',
+        type: Error,
+        message: 'Response has already been initiated.'
+      }
+    );
+
+    // Should throw if stream already destroyed
+    stream.destroy();
+    common.expectsError(
+      () =>
+        stream.respondWithFD(fd, {
+          'content-type': 'text/plain'
+        }),
+      {
+        code: 'ERR_HTTP2_INVALID_STREAM',
+        type: Error,
+        message: 'The stream has been destroyed'
+      }
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
 
-  req.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-  req.end();
-}));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-respond-file-fd-invalid.js b/test/parallel/test-http2-respond-file-fd-invalid.js
index 7630b93bc63942..82884ccd5218fa 100644
--- a/test/parallel/test-http2-respond-file-fd-invalid.js
+++ b/test/parallel/test-http2-respond-file-fd-invalid.js
@@ -1,22 +1,22 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fs = require('fs');
 const http2 = require('http2');
 
-const {
-  NGHTTP2_INTERNAL_ERROR
-} = http2.constants;
+const { NGHTTP2_INTERNAL_ERROR } = http2.constants;
 
-const errorCheck = common.expectsError({
-  code: 'ERR_HTTP2_STREAM_ERROR',
-  type: Error,
-  message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
-}, 2);
+const errorCheck = common.expectsError(
+  {
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
+  },
+  2
+);
 
 const server = http2.createServer();
 server.on('stream', (stream) => {
@@ -33,17 +33,19 @@ server.on('stream', (stream) => {
   stream.on('error', common.mustCall(errorCheck));
 });
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
   req.on('response', common.mustCall());
   req.on('error', common.mustCall(errorCheck));
   req.on('data', common.mustNotCall());
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(req.rstCode, NGHTTP2_INTERNAL_ERROR);
-    client.close();
-    server.close();
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(req.rstCode, NGHTTP2_INTERNAL_ERROR);
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
diff --git a/test/parallel/test-http2-respond-file-fd-range.js b/test/parallel/test-http2-respond-file-fd-range.js
index 2dd73e0001544c..3825f197df2689 100644
--- a/test/parallel/test-http2-respond-file-fd-range.js
+++ b/test/parallel/test-http2-respond-file-fd-range.js
@@ -3,8 +3,7 @@
 // Tests the ability to minimally request a byte range with respondWithFD
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 const assert = require('assert');
@@ -23,29 +22,33 @@ const fd = fs.openSync(fname, 'r');
 // Note: this is not anywhere close to a proper implementation of the range
 // header.
 function getOffsetLength(range) {
-  if (range === undefined)
-    return [0, -1];
+  if (range === undefined) return [0, -1];
   const r = /bytes=(\d+)-(\d+)/.exec(range);
   return [+r[1], +r[2] - +r[1]];
 }
 
 const server = http2.createServer();
 server.on('stream', (stream, headers) => {
+  const [offset, length] = getOffsetLength(headers.range);
 
-  const [ offset, length ] = getOffsetLength(headers.range);
-
-  stream.respondWithFD(fd, {
-    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
-  }, {
-    statCheck: common.mustCall((stat, headers, options) => {
-      assert.strictEqual(options.length, length);
-      assert.strictEqual(options.offset, offset);
-      headers['content-length'] =
-        Math.min(options.length, stat.size - offset);
-    }),
-    offset: offset,
-    length: length
-  });
+  stream.respondWithFD(
+    fd,
+    {
+      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+    },
+    {
+      statCheck: common.mustCall((stat, headers, options) => {
+        assert.strictEqual(options.length, length);
+        assert.strictEqual(options.offset, offset);
+        headers['content-length'] = Math.min(
+          options.length,
+          stat.size - offset
+        );
+      }),
+      offset: offset,
+      length: length
+    }
+  );
 });
 server.on('close', common.mustCall(() => fs.closeSync(fd)));
 
@@ -60,16 +63,22 @@ server.listen(0, () => {
   {
     const req = client.request({ range: 'bytes=8-11' });
 
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers['content-type'], 'text/plain');
-      assert.strictEqual(+headers['content-length'], 3);
-    }));
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers['content-type'], 'text/plain');
+        assert.strictEqual(+headers['content-length'], 3);
+      })
+    );
     req.setEncoding('utf8');
     let check = '';
-    req.on('data', (chunk) => check += chunk);
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(check, data.toString('utf8', 8, 11));
-    }));
+    req.on('data', (chunk) => (check += chunk));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(check, data.toString('utf8', 8, 11));
+      })
+    );
     req.on('close', common.mustCall(() => countdown.dec()));
     req.end();
   }
@@ -77,18 +86,23 @@ server.listen(0, () => {
   {
     const req = client.request({ range: 'bytes=8-28' });
 
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
-      assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], 9);
-    }));
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
+        assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], 9);
+      })
+    );
     req.setEncoding('utf8');
     let check = '';
-    req.on('data', (chunk) => check += chunk);
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(check, data.toString('utf8', 8, 28));
-    }));
+    req.on('data', (chunk) => (check += chunk));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(check, data.toString('utf8', 8, 28));
+      })
+    );
     req.on('close', common.mustCall(() => countdown.dec()));
     req.end();
   }
-
 });
diff --git a/test/parallel/test-http2-respond-file-fd.js b/test/parallel/test-http2-respond-file-fd.js
index 7d4395bbc360aa..1c706af0e4bd43 100644
--- a/test/parallel/test-http2-respond-file-fd.js
+++ b/test/parallel/test-http2-respond-file-fd.js
@@ -2,8 +2,7 @@
 
 const common = require('../common');
 const fixtures = require('../common/fixtures');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const assert = require('assert');
 const fs = require('fs');
@@ -22,26 +21,31 @@ const server = http2.createServer();
 server.on('stream', (stream) => {
   stream.respondWithFD(fd, {
     [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain',
-    [HTTP2_HEADER_CONTENT_LENGTH]: stat.size,
+    [HTTP2_HEADER_CONTENT_LENGTH]: stat.size
   });
 });
 server.on('close', common.mustCall(() => fs.closeSync(fd)));
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
-    assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], data.length);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
+      assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], data.length);
+    })
+  );
   req.setEncoding('utf8');
   let check = '';
-  req.on('data', (chunk) => check += chunk);
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(check, data.toString('utf8'));
-    client.close();
-    server.close();
-  }));
+  req.on('data', (chunk) => (check += chunk));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(check, data.toString('utf8'));
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
diff --git a/test/parallel/test-http2-respond-file-push.js b/test/parallel/test-http2-respond-file-push.js
index a5229beb07d1a7..580a75d9938f04 100644
--- a/test/parallel/test-http2-respond-file-push.js
+++ b/test/parallel/test-http2-respond-file-push.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
@@ -26,17 +25,20 @@ server.on('stream', (stream) => {
   stream.respond({});
   stream.end();
 
-  stream.pushStream({
-    ':path': '/file.txt',
-    ':method': 'GET'
-  }, (err, stream) => {
-    assert.ifError(err);
-    stream.respondWithFD(fd, {
-      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain',
-      [HTTP2_HEADER_CONTENT_LENGTH]: stat.size,
-      [HTTP2_HEADER_LAST_MODIFIED]: stat.mtime.toUTCString()
-    });
-  });
+  stream.pushStream(
+    {
+      ':path': '/file.txt',
+      ':method': 'GET'
+    },
+    (err, stream) => {
+      assert.ifError(err);
+      stream.respondWithFD(fd, {
+        [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain',
+        [HTTP2_HEADER_CONTENT_LENGTH]: stat.size,
+        [HTTP2_HEADER_LAST_MODIFIED]: stat.mtime.toUTCString()
+      });
+    }
+  );
 
   stream.end();
 });
@@ -44,7 +46,6 @@ server.on('stream', (stream) => {
 server.on('close', common.mustCall(() => fs.closeSync(fd)));
 
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
 
   let expected = 2;
@@ -59,24 +60,36 @@ server.listen(0, () => {
 
   req.on('response', common.mustCall());
 
-  client.on('stream', common.mustCall((stream, headers) => {
-
-    stream.on('push', common.mustCall((headers) => {
-      assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
-      assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], data.length);
-      assert.strictEqual(headers[HTTP2_HEADER_LAST_MODIFIED],
-                         stat.mtime.toUTCString());
-    }));
-
-    stream.setEncoding('utf8');
-    let check = '';
-    stream.on('data', (chunk) => check += chunk);
-    stream.on('end', common.mustCall(() => {
-      assert.strictEqual(check, data.toString('utf8'));
-      maybeClose();
-    }));
-
-  }));
+  client.on(
+    'stream',
+    common.mustCall((stream, headers) => {
+      stream.on(
+        'push',
+        common.mustCall((headers) => {
+          assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
+          assert.strictEqual(
+            +headers[HTTP2_HEADER_CONTENT_LENGTH],
+            data.length
+          );
+          assert.strictEqual(
+            headers[HTTP2_HEADER_LAST_MODIFIED],
+            stat.mtime.toUTCString()
+          );
+        })
+      );
+
+      stream.setEncoding('utf8');
+      let check = '';
+      stream.on('data', (chunk) => (check += chunk));
+      stream.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(check, data.toString('utf8'));
+          maybeClose();
+        })
+      );
+    })
+  );
 
   req.resume();
   req.on('end', maybeClose);
diff --git a/test/parallel/test-http2-respond-file-range.js b/test/parallel/test-http2-respond-file-range.js
index 4e6a6074514f14..1f1f8dae7f2d1a 100644
--- a/test/parallel/test-http2-respond-file-range.js
+++ b/test/parallel/test-http2-respond-file-range.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 const assert = require('assert');
@@ -20,34 +19,45 @@ const stat = fs.statSync(fname);
 
 const server = http2.createServer();
 server.on('stream', (stream) => {
-  stream.respondWithFile(fname, {
-    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
-  }, {
-    statCheck: common.mustCall((stat, headers) => {
-      headers[HTTP2_HEADER_LAST_MODIFIED] = stat.mtime.toUTCString();
-    }),
-    offset: 8,
-    length: 3
-  });
+  stream.respondWithFile(
+    fname,
+    {
+      [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+    },
+    {
+      statCheck: common.mustCall((stat, headers) => {
+        headers[HTTP2_HEADER_LAST_MODIFIED] = stat.mtime.toUTCString();
+      }),
+      offset: 8,
+      length: 3
+    }
+  );
 });
 server.listen(0, () => {
-
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
-    assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], 3);
-    assert.strictEqual(headers[HTTP2_HEADER_LAST_MODIFIED],
-                       stat.mtime.toUTCString());
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
+      assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], 3);
+      assert.strictEqual(
+        headers[HTTP2_HEADER_LAST_MODIFIED],
+        stat.mtime.toUTCString()
+      );
+    })
+  );
   req.setEncoding('utf8');
   let check = '';
-  req.on('data', (chunk) => check += chunk);
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(check, data.toString('utf8', 8, 11));
-    client.close();
-    server.close();
-  }));
+  req.on('data', (chunk) => (check += chunk));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(check, data.toString('utf8', 8, 11));
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
diff --git a/test/parallel/test-http2-respond-file-with-pipe.js b/test/parallel/test-http2-respond-file-with-pipe.js
index 2b7ca3fc9a51ee..c2d07d35fd9f2f 100644
--- a/test/parallel/test-http2-respond-file-with-pipe.js
+++ b/test/parallel/test-http2-respond-file-with-pipe.js
@@ -1,10 +1,8 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
-if (common.isWindows)
-  common.skip('no mkfifo on Windows');
+if (!common.hasCrypto) common.skip('missing crypto');
+if (common.isWindows) common.skip('no mkfifo on Windows');
 const child_process = require('child_process');
 const path = require('path');
 const fs = require('fs');
@@ -16,7 +14,7 @@ tmpdir.refresh();
 
 const pipeName = path.join(tmpdir.path, 'pipe');
 
-const mkfifo = child_process.spawnSync('mkfifo', [ pipeName ]);
+const mkfifo = child_process.spawnSync('mkfifo', [pipeName]);
 if (mkfifo.error && mkfifo.error.code === 'ENOENT') {
   common.skip('missing mkfifo');
 }
@@ -25,34 +23,48 @@ process.on('exit', () => fs.unlinkSync(pipeName));
 
 const server = http2.createServer();
 server.on('stream', (stream) => {
-  stream.respondWithFile(pipeName, {
-    'content-type': 'text/plain'
-  }, {
-    onError: common.mustNotCall(),
-    statCheck: common.mustCall()
-  });
+  stream.respondWithFile(
+    pipeName,
+    {
+      'content-type': 'text/plain'
+    },
+    {
+      onError: common.mustNotCall(),
+      statCheck: common.mustCall()
+    }
+  );
 });
 
 server.listen(0, () => {
   const client = http2.connect(`http://localhost:${server.address().port}`);
   const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 200);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 200);
+    })
+  );
   let body = '';
   req.setEncoding('utf8');
-  req.on('data', (chunk) => body += chunk);
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(body, 'Hello, world!\n');
-    client.close();
-    server.close();
-  }));
+  req.on('data', (chunk) => (body += chunk));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(body, 'Hello, world!\n');
+      client.close();
+      server.close();
+    })
+  );
   req.end();
 });
 
-fs.open(pipeName, 'w', common.mustCall((err, fd) => {
-  assert.ifError(err);
-  fs.writeSync(fd, 'Hello, world!\n');
-  fs.closeSync(fd);
-}));
+fs.open(
+  pipeName,
+  'w',
+  common.mustCall((err, fd) => {
+    assert.ifError(err);
+    fs.writeSync(fd, 'Hello, world!\n');
+    fs.closeSync(fd);
+  })
+);
diff --git a/test/parallel/test-http2-respond-file.js b/test/parallel/test-http2-respond-file.js
index 1c10ceb4350723..2ac081a4a7f19f 100644
--- a/test/parallel/test-http2-respond-file.js
+++ b/test/parallel/test-http2-respond-file.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
 const assert = require('assert');
@@ -19,34 +18,52 @@ const data = fs.readFileSync(fname);
 const stat = fs.statSync(fname);
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.respondWithFile(fname, {
-    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
-  }, {
-    statCheck(stat, headers) {
-      headers[HTTP2_HEADER_LAST_MODIFIED] = stat.mtime.toUTCString();
-      headers[HTTP2_HEADER_CONTENT_LENGTH] = stat.size;
-    }
-  });
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respondWithFile(
+      fname,
+      {
+        [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain'
+      },
+      {
+        statCheck(stat, headers) {
+          headers[HTTP2_HEADER_LAST_MODIFIED] = stat.mtime.toUTCString();
+          headers[HTTP2_HEADER_CONTENT_LENGTH] = stat.size;
+        }
+      }
+    );
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
-    assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], data.length);
-    assert.strictEqual(headers[HTTP2_HEADER_LAST_MODIFIED],
-                       stat.mtime.toUTCString());
-  }));
-  req.setEncoding('utf8');
-  let check = '';
-  req.on('data', (chunk) => check += chunk);
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(check, data.toString('utf8'));
-    client.close();
-    server.close();
-  }));
-  req.end();
-}));
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers[HTTP2_HEADER_CONTENT_TYPE], 'text/plain');
+        assert.strictEqual(+headers[HTTP2_HEADER_CONTENT_LENGTH], data.length);
+        assert.strictEqual(
+          headers[HTTP2_HEADER_LAST_MODIFIED],
+          stat.mtime.toUTCString()
+        );
+      })
+    );
+    req.setEncoding('utf8');
+    let check = '';
+    req.on('data', (chunk) => (check += chunk));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(check, data.toString('utf8'));
+        client.close();
+        server.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-respond-nghttperrors.js b/test/parallel/test-http2-respond-nghttperrors.js
index 5ebd24a65b1b2f..1b78b939258c99 100644
--- a/test/parallel/test-http2-respond-nghttperrors.js
+++ b/test/parallel/test-http2-respond-nghttperrors.js
@@ -2,15 +2,10 @@
 // Flags: --expose-internals
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const { internalBinding } = require('internal/test/binding');
-const {
-  constants,
-  Http2Stream,
-  nghttp2ErrorString
-} = internalBinding('http2');
+const { constants, Http2Stream, nghttp2ErrorString } = internalBinding('http2');
 const { NghttpError } = require('internal/http2/util');
 
 // tests error handling within respond
@@ -21,9 +16,10 @@ const specificTestKeys = [];
 const specificTests = [];
 
 const genericTests = Object.getOwnPropertyNames(constants)
-  .filter((key) => (
-    key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
-  ))
+  .filter(
+    (key) =>
+      key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
+  )
   .map((key) => ({
     ngError: constants[key],
     error: {
@@ -35,7 +31,6 @@ const genericTests = Object.getOwnPropertyNames(constants)
     type: 'stream'
   }));
 
-
 const tests = specificTests.concat(genericTests);
 
 let currentError;
@@ -44,25 +39,31 @@ let currentError;
 Http2Stream.prototype.respond = () => currentError.ngError;
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const errorMustCall = common.expectsError(currentError.error);
-  const errorMustNotCall = common.mustNotCall(
-    `${currentError.error.code} should emit on ${currentError.type}`
-  );
-
-  if (currentError.type === 'stream') {
-    stream.session.on('error', errorMustNotCall);
-    stream.on('error', errorMustCall);
-    stream.on('error', common.mustCall(() => {
-      stream.destroy();
-    }));
-  } else {
-    stream.session.once('error', errorMustCall);
-    stream.on('error', errorMustNotCall);
-  }
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    const errorMustCall = common.expectsError(currentError.error);
+    const errorMustNotCall = common.mustNotCall(
+      `${currentError.error.code} should emit on ${currentError.type}`
+    );
+
+    if (currentError.type === 'stream') {
+      stream.session.on('error', errorMustNotCall);
+      stream.on('error', errorMustCall);
+      stream.on(
+        'error',
+        common.mustCall(() => {
+          stream.destroy();
+        })
+      );
+    } else {
+      stream.session.once('error', errorMustCall);
+      stream.on('error', errorMustNotCall);
+    }
 
-  stream.respond();
-}, tests.length));
+    stream.respond();
+  }, tests.length)
+);
 
 server.listen(0, common.mustCall(() => runTest(tests.shift())));
 
@@ -78,23 +79,29 @@ function runTest(test) {
 
   const client = http2.connect(url);
   const req = client.request(headers);
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
-  }));
+  req.on(
+    'error',
+    common.expectsError({
+      code: 'ERR_HTTP2_STREAM_ERROR',
+      type: Error,
+      message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
+    })
+  );
 
   currentError = test;
   req.resume();
   req.end();
 
-  req.on('end', common.mustCall(() => {
-    client.close();
-
-    if (!tests.length) {
-      server.close();
-    } else {
-      runTest(tests.shift());
-    }
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+
+      if (!tests.length) {
+        server.close();
+      } else {
+        runTest(tests.shift());
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-http2-respond-no-data.js b/test/parallel/test-http2-respond-no-data.js
index 9572bdffe54927..4c829322bad761 100644
--- a/test/parallel/test-http2-respond-no-data.js
+++ b/test/parallel/test-http2-respond-no-data.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const assert = require('assert');
 
@@ -12,12 +11,18 @@ const server = http2.createServer();
 
 const status = [204, 205, 304];
 
-server.on('stream', common.mustCall((stream) => {
-  stream.on('close', common.mustCall(() => {
-    assert.strictEqual(stream.destroyed, true);
-  }));
-  stream.respond({ ':status': status.shift() });
-}, 3));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(stream.destroyed, true);
+      })
+    );
+    stream.respond({ ':status': status.shift() });
+  }, 3)
+);
 
 server.listen(0, common.mustCall(makeRequest));
 
@@ -26,14 +31,17 @@ function makeRequest() {
   const req = client.request();
   req.resume();
 
-  req.on('end', common.mustCall(() => {
-    client.close();
-
-    if (!status.length) {
-      server.close();
-    } else {
-      makeRequest();
-    }
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+
+      if (!status.length) {
+        server.close();
+      } else {
+        makeRequest();
+      }
+    })
+  );
   req.end();
 }
diff --git a/test/parallel/test-http2-respond-with-fd-errors.js b/test/parallel/test-http2-respond-with-fd-errors.js
index 9dfd95ea5a2c7c..1571093ebef409 100644
--- a/test/parallel/test-http2-respond-with-fd-errors.js
+++ b/test/parallel/test-http2-respond-with-fd-errors.js
@@ -3,19 +3,14 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
 const http2 = require('http2');
 
 const { internalBinding } = require('internal/test/binding');
-const {
-  constants,
-  Http2Stream,
-  nghttp2ErrorString
-} = internalBinding('http2');
+const { constants, Http2Stream, nghttp2ErrorString } = internalBinding('http2');
 const { NghttpError } = require('internal/http2/util');
 
 // tests error handling within processRespondWithFD
@@ -28,9 +23,10 @@ const specificTestKeys = [];
 const specificTests = [];
 
 const genericTests = Object.getOwnPropertyNames(constants)
-  .filter((key) => (
-    key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
-  ))
+  .filter(
+    (key) =>
+      key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
+  )
   .map((key) => ({
     ngError: constants[key],
     error: {
@@ -42,7 +38,6 @@ const genericTests = Object.getOwnPropertyNames(constants)
     type: 'stream'
   }));
 
-
 const tests = specificTests.concat(genericTests);
 
 let currentError;
@@ -51,25 +46,31 @@ let currentError;
 Http2Stream.prototype.respond = () => currentError.ngError;
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const errorMustCall = common.expectsError(currentError.error);
-  const errorMustNotCall = common.mustNotCall(
-    `${currentError.error.code} should emit on ${currentError.type}`
-  );
-
-  if (currentError.type === 'stream') {
-    stream.session.on('error', errorMustNotCall);
-    stream.on('error', errorMustCall);
-    stream.on('error', common.mustCall(() => {
-      stream.destroy();
-    }));
-  } else {
-    stream.session.once('error', errorMustCall);
-    stream.on('error', errorMustNotCall);
-  }
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    const errorMustCall = common.expectsError(currentError.error);
+    const errorMustNotCall = common.mustNotCall(
+      `${currentError.error.code} should emit on ${currentError.type}`
+    );
+
+    if (currentError.type === 'stream') {
+      stream.session.on('error', errorMustNotCall);
+      stream.on('error', errorMustCall);
+      stream.on(
+        'error',
+        common.mustCall(() => {
+          stream.destroy();
+        })
+      );
+    } else {
+      stream.session.once('error', errorMustCall);
+      stream.on('error', errorMustNotCall);
+    }
 
-  stream.respondWithFile(fname);
-}, tests.length));
+    stream.respondWithFile(fname);
+  }, tests.length)
+);
 
 server.listen(0, common.mustCall(() => runTest(tests.shift())));
 
@@ -86,23 +87,29 @@ function runTest(test) {
   const client = http2.connect(url);
   const req = client.request(headers);
 
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
-  }));
+  req.on(
+    'error',
+    common.expectsError({
+      code: 'ERR_HTTP2_STREAM_ERROR',
+      type: Error,
+      message: 'Stream closed with error code NGHTTP2_INTERNAL_ERROR'
+    })
+  );
 
   currentError = test;
   req.resume();
   req.end();
 
-  req.on('end', common.mustCall(() => {
-    client.close();
-
-    if (!tests.length) {
-      server.close();
-    } else {
-      runTest(tests.shift());
-    }
-  }));
+  req.on(
+    'end',
+    common.mustCall(() => {
+      client.close();
+
+      if (!tests.length) {
+        server.close();
+      } else {
+        runTest(tests.shift());
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-http2-respond-with-file-connection-abort.js b/test/parallel/test-http2-respond-with-file-connection-abort.js
index ed200e5b391fe8..e5719e560cae71 100644
--- a/test/parallel/test-http2-respond-with-file-connection-abort.js
+++ b/test/parallel/test-http2-respond-with-file-connection-abort.js
@@ -1,32 +1,38 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const net = require('net');
 
-const {
-  HTTP2_HEADER_CONTENT_TYPE
-} = http2.constants;
+const { HTTP2_HEADER_CONTENT_TYPE } = http2.constants;
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.on('error', (err) => assert.strictEqual(err.code, 'ECONNRESET'));
-  stream.respondWithFile(process.execPath, {
-    [HTTP2_HEADER_CONTENT_TYPE]: 'application/octet-stream'
-  });
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.on('error', (err) => assert.strictEqual(err.code, 'ECONNRESET'));
+    stream.respondWithFile(process.execPath, {
+      [HTTP2_HEADER_CONTENT_TYPE]: 'application/octet-stream'
+    });
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
 
-  req.on('response', common.mustCall(() => {}));
-  req.once('data', common.mustCall(() => {
-    net.Socket.prototype.destroy.call(client.socket);
-    server.close();
-  }));
-  req.end();
-}));
+    req.on('response', common.mustCall(() => {}));
+    req.once(
+      'data',
+      common.mustCall(() => {
+        net.Socket.prototype.destroy.call(client.socket);
+        server.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-response-splitting.js b/test/parallel/test-http2-response-splitting.js
index 9613eca9636ae4..16cfb671867f99 100644
--- a/test/parallel/test-http2-response-splitting.js
+++ b/test/parallel/test-http2-response-splitting.js
@@ -5,18 +5,18 @@
 // contain invalid characters.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const { URL } = require('url');
 
 // Response splitting example, credit: Amit Klein, Safebreach
-const str = '/welcome?lang=bar%c4%8d%c4%8aContent­Length:%200%c4%8d%c4%8a%c' +
-            '4%8d%c4%8aHTTP/1.1%20200%20OK%c4%8d%c4%8aContent­Length:%202' +
-            '0%c4%8d%c4%8aLast­Modified:%20Mon,%2027%20Oct%202003%2014:50:18' +
-            '%20GMT%c4%8d%c4%8aContent­Type:%20text/html%c4%8d%c4%8a%c4%8' +
-            'd%c4%8a%3chtml%3eGotcha!%3c/html%3e';
+const str =
+  '/welcome?lang=bar%c4%8d%c4%8aContent­Length:%200%c4%8d%c4%8a%c' +
+  '4%8d%c4%8aHTTP/1.1%20200%20OK%c4%8d%c4%8aContent­Length:%202' +
+  '0%c4%8d%c4%8aLast­Modified:%20Mon,%2027%20Oct%202003%2014:50:18' +
+  '%20GMT%c4%8d%c4%8aContent­Type:%20text/html%c4%8d%c4%8a%c4%8' +
+  'd%c4%8a%3chtml%3eGotcha!%3c/html%3e';
 
 // Response splitting example, credit: Сковорода Никита Андреевич (@ChALkeR)
 const x = 'fooഊSet-Cookie: foo=barഊഊ<script>alert("Hi!")</script>';
@@ -29,49 +29,56 @@ function makeUrl(headers) {
 }
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-
-  const obj = Object.create(null);
-  switch (remaining--) {
-    case 3:
-      const url = new URL(makeUrl(headers));
-      obj[':status'] = 302;
-      obj.Location = `/foo?lang=${url.searchParams.get('lang')}`;
-      break;
-    case 2:
-      obj.foo = x;
-      break;
-    case 1:
-      obj.foo = y;
-      break;
-  }
-  stream.respond(obj);
-  stream.end();
-}, 3));
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    const obj = Object.create(null);
+    switch (remaining--) {
+      case 3:
+        const url = new URL(makeUrl(headers));
+        obj[':status'] = 302;
+        obj.Location = `/foo?lang=${url.searchParams.get('lang')}`;
+        break;
+      case 2:
+        obj.foo = x;
+        break;
+      case 1:
+        obj.foo = y;
+        break;
+    }
+    stream.respond(obj);
+    stream.end();
+  }, 3)
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  function maybeClose() {
-    if (remaining === 0) {
-      server.close();
-      client.close();
+    function maybeClose() {
+      if (remaining === 0) {
+        server.close();
+        client.close();
+      }
     }
-  }
 
-  function doTest(path, key, expected) {
-    const req = client.request({ ':path': path });
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers.foo, undefined);
-      assert.strictEqual(headers.location, undefined);
-    }));
-    req.resume();
-    req.on('end', common.mustCall());
-    req.on('close', common.mustCall(maybeClose));
-  }
-
-  doTest(str, 'location', str);
-  doTest('/', 'foo', x);
-  doTest('/', 'foo', y);
+    function doTest(path, key, expected) {
+      const req = client.request({ ':path': path });
+      req.on(
+        'response',
+        common.mustCall((headers) => {
+          assert.strictEqual(headers.foo, undefined);
+          assert.strictEqual(headers.location, undefined);
+        })
+      );
+      req.resume();
+      req.on('end', common.mustCall());
+      req.on('close', common.mustCall(maybeClose));
+    }
 
-}));
+    doTest(str, 'location', str);
+    doTest('/', 'foo', x);
+    doTest('/', 'foo', y);
+  })
+);
diff --git a/test/parallel/test-http2-sent-headers.js b/test/parallel/test-http2-sent-headers.js
index 6ec674394336f2..ef3594e4aa0242 100644
--- a/test/parallel/test-http2-sent-headers.js
+++ b/test/parallel/test-http2-sent-headers.js
@@ -1,46 +1,56 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 const server = h2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  stream.additionalHeaders({ ':status': 102 });
-  assert.strictEqual(stream.sentInfoHeaders[0][':status'], 102);
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.additionalHeaders({ ':status': 102 });
+    assert.strictEqual(stream.sentInfoHeaders[0][':status'], 102);
 
-  stream.respond({ abc: 'xyz' }, { waitForTrailers: true });
-  stream.on('wantTrailers', () => {
-    stream.sendTrailers({ xyz: 'abc' });
-  });
-  assert.strictEqual(stream.sentHeaders.abc, 'xyz');
-  assert.strictEqual(stream.sentHeaders[':status'], 200);
-  assert.notStrictEqual(stream.sentHeaders.date, undefined);
-  stream.end();
-  stream.on('close', () => {
-    assert.strictEqual(stream.sentTrailers.xyz, 'abc');
-  });
-}));
+    stream.respond({ abc: 'xyz' }, { waitForTrailers: true });
+    stream.on('wantTrailers', () => {
+      stream.sendTrailers({ xyz: 'abc' });
+    });
+    assert.strictEqual(stream.sentHeaders.abc, 'xyz');
+    assert.strictEqual(stream.sentHeaders[':status'], 200);
+    assert.notStrictEqual(stream.sentHeaders.date, undefined);
+    stream.end();
+    stream.on('close', () => {
+      assert.strictEqual(stream.sentTrailers.xyz, 'abc');
+    });
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
 
-  req.on('headers', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 102);
-  }));
+    req.on(
+      'headers',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers[':status'], 102);
+      })
+    );
 
-  assert.strictEqual(req.sentHeaders[':method'], 'GET');
-  assert.strictEqual(req.sentHeaders[':authority'],
-                     `localhost:${server.address().port}`);
-  assert.strictEqual(req.sentHeaders[':scheme'], 'http');
-  assert.strictEqual(req.sentHeaders[':path'], '/');
-  req.resume();
-  req.on('close', () => {
-    server.close();
-    client.close();
-  });
-}));
+    assert.strictEqual(req.sentHeaders[':method'], 'GET');
+    assert.strictEqual(
+      req.sentHeaders[':authority'],
+      `localhost:${server.address().port}`
+    );
+    assert.strictEqual(req.sentHeaders[':scheme'], 'http');
+    assert.strictEqual(req.sentHeaders[':path'], '/');
+    req.resume();
+    req.on('close', () => {
+      server.close();
+      client.close();
+    });
+  })
+);
diff --git a/test/parallel/test-http2-serve-file.js b/test/parallel/test-http2-serve-file.js
index 7b73fe639e0cc5..c557527d9b42ef 100644
--- a/test/parallel/test-http2-serve-file.js
+++ b/test/parallel/test-http2-serve-file.js
@@ -3,8 +3,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http2 = require('http2');
@@ -13,10 +12,7 @@ const tls = require('tls');
 
 const ajs_data = fixtures.readSync('a.js', 'utf8');
 
-const {
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_STATUS
-} = http2.constants;
+const { HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = http2.constants;
 
 const key = fixtures.readKey('agent8-key.pem', 'binary');
 const cert = fixtures.readKey('agent8-cert.pem', 'binary');
@@ -40,10 +36,11 @@ server.on('stream', (stream, headers) => {
 });
 
 server.listen(0, () => {
-
   const secureContext = tls.createSecureContext({ ca });
-  const client = http2.connect(`https://localhost:${server.address().port}`,
-                               { secureContext });
+  const client = http2.connect(
+    `https://localhost:${server.address().port}`,
+    { secureContext }
+  );
 
   let remaining = 2;
   function maybeClose() {
@@ -54,26 +51,38 @@ server.listen(0, () => {
   }
 
   // Request for a file that does exist, response is 200
-  const req1 = client.request({ [HTTP2_HEADER_PATH]: '/a.js' },
-                              { endStream: true });
-  req1.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[HTTP2_HEADER_STATUS], 200);
-  }));
+  const req1 = client.request(
+    { [HTTP2_HEADER_PATH]: '/a.js' },
+    { endStream: true }
+  );
+  req1.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[HTTP2_HEADER_STATUS], 200);
+    })
+  );
   let req1_data = '';
   req1.setEncoding('utf8');
-  req1.on('data', (chunk) => req1_data += chunk);
-  req1.on('end', common.mustCall(() => {
-    assert.strictEqual(req1_data, ajs_data);
-    maybeClose();
-  }));
+  req1.on('data', (chunk) => (req1_data += chunk));
+  req1.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(req1_data, ajs_data);
+      maybeClose();
+    })
+  );
 
   // Request for a file that does not exist, response is 404
-  const req2 = client.request({ [HTTP2_HEADER_PATH]: '/does_not_exist' },
-                              { endStream: true });
-  req2.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[HTTP2_HEADER_STATUS], 404);
-  }));
+  const req2 = client.request(
+    { [HTTP2_HEADER_PATH]: '/does_not_exist' },
+    { endStream: true }
+  );
+  req2.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[HTTP2_HEADER_STATUS], 404);
+    })
+  );
   req2.on('data', common.mustNotCall());
   req2.on('end', common.mustCall(() => maybeClose()));
-
 });
diff --git a/test/parallel/test-http2-server-close-callback.js b/test/parallel/test-http2-server-close-callback.js
index f822d8a4a92d78..5b367a3d613f87 100644
--- a/test/parallel/test-http2-server-close-callback.js
+++ b/test/parallel/test-http2-server-close-callback.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const Countdown = require('../common/countdown');
 const http2 = require('http2');
@@ -16,12 +15,18 @@ const countdown = new Countdown(2, () => {
   session.destroy();
 });
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  client.on('connect', common.mustCall(() => countdown.dec()));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    client.on('connect', common.mustCall(() => countdown.dec()));
+  })
+);
 
-server.on('session', common.mustCall((s) => {
-  session = s;
-  countdown.dec();
-}));
+server.on(
+  'session',
+  common.mustCall((s) => {
+    session = s;
+    countdown.dec();
+  })
+);
diff --git a/test/parallel/test-http2-server-errors.js b/test/parallel/test-http2-server-errors.js
index bbdf312fc153d4..758bded5d39152 100644
--- a/test/parallel/test-http2-server-errors.js
+++ b/test/parallel/test-http2-server-errors.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -15,38 +14,53 @@ const h2 = require('http2');
 
   const server = h2.createServer();
 
-  server.on('stream', common.mustCall(function(stream) {
-    stream.on('error', common.mustCall(function(err) {
-      assert.strictEqual(err, expected);
-    }));
-
-    stream.resume();
-    stream.write('hello');
-
-    expected = new Error('kaboom');
-    stream.destroy(expected);
-    server.close();
-  }));
-
-  server.listen(0, common.mustCall(function() {
-    const port = server.address().port;
-
-    const url = `http://localhost:${port}`;
-    const client = h2.connect(url, common.mustCall(function() {
-      const headers = {
-        ':path': '/foobar',
-        ':method': 'GET',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`,
-      };
-      const request = client.request(headers);
-      request.on('data', common.mustCall(function(chunk) {
-        // cause an error on the server side
-        client.destroy();
-      }));
-      request.end();
-    }));
-  }));
+  server.on(
+    'stream',
+    common.mustCall(function(stream) {
+      stream.on(
+        'error',
+        common.mustCall(function(err) {
+          assert.strictEqual(err, expected);
+        })
+      );
+
+      stream.resume();
+      stream.write('hello');
+
+      expected = new Error('kaboom');
+      stream.destroy(expected);
+      server.close();
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(function() {
+      const port = server.address().port;
+
+      const url = `http://localhost:${port}`;
+      const client = h2.connect(
+        url,
+        common.mustCall(function() {
+          const headers = {
+            ':path': '/foobar',
+            ':method': 'GET',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on(
+            'data',
+            common.mustCall(function(chunk) {
+              // cause an error on the server side
+              client.destroy();
+            })
+          );
+          request.end();
+        })
+      );
+    })
+  );
 }
 
 {
@@ -54,37 +68,52 @@ const h2 = require('http2');
 
   const server = h2.createServer();
 
-  process.on('uncaughtException', common.mustCall(function(err) {
-    assert.strictEqual(err.message, 'kaboom no handler');
-  }));
-
-  server.on('stream', common.mustCall(function(stream) {
-    // there is no 'error'  handler, and this will crash
-    stream.write('hello');
-    stream.resume();
-
-    expected = new Error('kaboom no handler');
-    stream.destroy(expected);
-    server.close();
-  }));
-
-  server.listen(0, common.mustCall(function() {
-    const port = server.address().port;
-
-    const url = `http://localhost:${port}`;
-    const client = h2.connect(url, common.mustCall(function() {
-      const headers = {
-        ':path': '/foobar',
-        ':method': 'GET',
-        ':scheme': 'http',
-        ':authority': `localhost:${port}`,
-      };
-      const request = client.request(headers);
-      request.on('data', common.mustCall(function(chunk) {
-        // cause an error on the server side
-        client.destroy();
-      }));
-      request.end();
-    }));
-  }));
+  process.on(
+    'uncaughtException',
+    common.mustCall(function(err) {
+      assert.strictEqual(err.message, 'kaboom no handler');
+    })
+  );
+
+  server.on(
+    'stream',
+    common.mustCall(function(stream) {
+      // there is no 'error'  handler, and this will crash
+      stream.write('hello');
+      stream.resume();
+
+      expected = new Error('kaboom no handler');
+      stream.destroy(expected);
+      server.close();
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(function() {
+      const port = server.address().port;
+
+      const url = `http://localhost:${port}`;
+      const client = h2.connect(
+        url,
+        common.mustCall(function() {
+          const headers = {
+            ':path': '/foobar',
+            ':method': 'GET',
+            ':scheme': 'http',
+            ':authority': `localhost:${port}`
+          };
+          const request = client.request(headers);
+          request.on(
+            'data',
+            common.mustCall(function(chunk) {
+              // cause an error on the server side
+              client.destroy();
+            })
+          );
+          request.end();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http2-server-http1-client.js b/test/parallel/test-http2-server-http1-client.js
index 394993d4d72088..8726548420e5c5 100644
--- a/test/parallel/test-http2-server-http1-client.js
+++ b/test/parallel/test-http2-server-http1-client.js
@@ -3,8 +3,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http = require('http');
 const http2 = require('http2');
@@ -12,16 +11,25 @@ const { NghttpError } = require('internal/http2/util');
 
 const server = http2.createServer();
 server.on('stream', common.mustNotCall());
-server.on('session', common.mustCall((session) => {
-  session.on('close', common.mustCall());
-  session.on('error', common.expectsError({
-    code: 'ERR_HTTP2_ERROR',
-    type: NghttpError,
-    message: 'Received bad client magic byte string'
-  }));
-}));
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.on('close', common.mustCall());
+    session.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_ERROR',
+        type: NghttpError,
+        message: 'Received bad client magic byte string'
+      })
+    );
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const req = http.get(`http://localhost:${server.address().port}`);
-  req.on('error', (error) => server.close());
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.get(`http://localhost:${server.address().port}`);
+    req.on('error', (error) => server.close());
+  })
+);
diff --git a/test/parallel/test-http2-server-push-disabled.js b/test/parallel/test-http2-server-push-disabled.js
index 78b3e26ad4968b..c3375cdbd007c0 100644
--- a/test/parallel/test-http2-server-push-disabled.js
+++ b/test/parallel/test-http2-server-push-disabled.js
@@ -1,54 +1,75 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const server = http2.createServer();
 
-server.on('session', common.mustCall((session) => {
-  // Verify that the settings disabling push is received
-  session.on('remoteSettings', common.mustCall((settings) => {
-    assert.strictEqual(settings.enablePush, false);
-  }));
-}));
-
-server.on('stream', common.mustCall((stream) => {
-
-  // The client has disabled push streams, so pushAllowed must be false,
-  // and pushStream() must throw.
-  assert.strictEqual(stream.pushAllowed, false);
-
-  common.expectsError(() => {
-    stream.pushStream({
-      ':scheme': 'http',
-      ':path': '/foobar',
-      ':authority': `localhost:${server.address().port}`,
-    }, common.mustNotCall());
-  }, {
-    code: 'ERR_HTTP2_PUSH_DISABLED',
-    type: Error
-  });
-
-  stream.respond({ ':status': 200 });
-  stream.end('test');
-}));
-
-server.listen(0, common.mustCall(() => {
-  const options = { settings: { enablePush: false } };
-  const client = http2.connect(`http://localhost:${server.address().port}`,
-                               options);
-  const req = client.request({ ':path': '/' });
-
-  // Because push streams are disabled, this must not be called.
-  client.on('stream', common.mustNotCall());
-
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-  req.end();
-}));
+server.on(
+  'session',
+  common.mustCall((session) => {
+    // Verify that the settings disabling push is received
+    session.on(
+      'remoteSettings',
+      common.mustCall((settings) => {
+        assert.strictEqual(settings.enablePush, false);
+      })
+    );
+  })
+);
+
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    // The client has disabled push streams, so pushAllowed must be false,
+    // and pushStream() must throw.
+    assert.strictEqual(stream.pushAllowed, false);
+
+    common.expectsError(
+      () => {
+        stream.pushStream(
+          {
+            ':scheme': 'http',
+            ':path': '/foobar',
+            ':authority': `localhost:${server.address().port}`
+          },
+          common.mustNotCall()
+        );
+      },
+      {
+        code: 'ERR_HTTP2_PUSH_DISABLED',
+        type: Error
+      }
+    );
+
+    stream.respond({ ':status': 200 });
+    stream.end('test');
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const options = { settings: { enablePush: false } };
+    const client = http2.connect(
+      `http://localhost:${server.address().port}`,
+      options
+    );
+    const req = client.request({ ':path': '/' });
+
+    // Because push streams are disabled, this must not be called.
+    client.on('stream', common.mustNotCall());
+
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-server-push-stream-errors-args.js b/test/parallel/test-http2-server-push-stream-errors-args.js
index 24f7c9fcef9342..8dad01b69d6a88 100644
--- a/test/parallel/test-http2-server-push-stream-errors-args.js
+++ b/test/parallel/test-http2-server-push-stream-errors-args.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -10,48 +9,63 @@ const http2 = require('http2');
 // in the expected manner
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const port = server.address().port;
-
-  // Must receive a callback (function)
-  common.expectsError(
-    () => stream.pushStream({
-      ':scheme': 'http',
-      ':path': '/foobar',
-      ':authority': `localhost:${port}`,
-    }, {}, 'callback'),
-    {
-      code: 'ERR_INVALID_CALLBACK',
-      message: 'Callback must be a function'
-    }
-  );
-
-  // Must validate headers
-  common.expectsError(
-    () => stream.pushStream({ 'connection': 'test' }, {}, () => {}),
-    {
-      code: 'ERR_HTTP2_INVALID_CONNECTION_HEADERS',
-      name: 'TypeError [ERR_HTTP2_INVALID_CONNECTION_HEADERS]',
-      message: 'HTTP/1 Connection specific headers are forbidden: "connection"'
-    }
-  );
-
-  stream.end('test');
-}));
-
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const headers = { ':path': '/' };
-  const client = http2.connect(`http://localhost:${port}`);
-  const req = client.request(headers);
-  req.setEncoding('utf8');
-
-  let data = '';
-  req.on('data', common.mustCall((d) => data += d));
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(data, 'test');
-    server.close();
-    client.close();
-  }));
-  req.end();
-}));
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    const port = server.address().port;
+
+    // Must receive a callback (function)
+    common.expectsError(
+      () =>
+        stream.pushStream(
+          {
+            ':scheme': 'http',
+            ':path': '/foobar',
+            ':authority': `localhost:${port}`
+          },
+          {},
+          'callback'
+        ),
+      {
+        code: 'ERR_INVALID_CALLBACK',
+        message: 'Callback must be a function'
+      }
+    );
+
+    // Must validate headers
+    common.expectsError(
+      () => stream.pushStream({ connection: 'test' }, {}, () => {}),
+      {
+        code: 'ERR_HTTP2_INVALID_CONNECTION_HEADERS',
+        name: 'TypeError [ERR_HTTP2_INVALID_CONNECTION_HEADERS]',
+        message:
+          'HTTP/1 Connection specific headers are forbidden: "connection"'
+      }
+    );
+
+    stream.end('test');
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const headers = { ':path': '/' };
+    const client = http2.connect(`http://localhost:${port}`);
+    const req = client.request(headers);
+    req.setEncoding('utf8');
+
+    let data = '';
+    req.on('data', common.mustCall((d) => (data += d)));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(data, 'test');
+        server.close();
+        client.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-server-push-stream-errors.js b/test/parallel/test-http2-server-push-stream-errors.js
index e489cae439205e..eb739eb75effa9 100644
--- a/test/parallel/test-http2-server-push-stream-errors.js
+++ b/test/parallel/test-http2-server-push-stream-errors.js
@@ -2,15 +2,10 @@
 // Flags: --expose-internals
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const { internalBinding } = require('internal/test/binding');
-const {
-  constants,
-  Http2Stream,
-  nghttp2ErrorString
-} = internalBinding('http2');
+const { constants, Http2Stream, nghttp2ErrorString } = internalBinding('http2');
 const { NghttpError } = require('internal/http2/util');
 
 // tests error handling within pushStream
@@ -29,8 +24,9 @@ const specificTests = [
     error: {
       code: 'ERR_HTTP2_OUT_OF_STREAMS',
       type: Error,
-      message: 'No stream ID is available because ' +
-               'maximum stream ID has been reached'
+      message:
+        'No stream ID is available because ' +
+        'maximum stream ID has been reached'
     },
     type: 'stream'
   },
@@ -41,13 +37,14 @@ const specificTests = [
       type: Error
     },
     type: 'stream'
-  },
+  }
 ];
 
 const genericTests = Object.getOwnPropertyNames(constants)
-  .filter((key) => (
-    key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
-  ))
+  .filter(
+    (key) =>
+      key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
+  )
   .map((key) => ({
     ngError: constants[key],
     error: {
@@ -59,7 +56,6 @@ const genericTests = Object.getOwnPropertyNames(constants)
     type: 'stream'
   }));
 
-
 const tests = specificTests.concat(genericTests);
 
 let currentError;
@@ -68,11 +64,14 @@ let currentError;
 Http2Stream.prototype.pushPromise = () => currentError.ngError;
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  stream.pushStream({}, common.expectsError(currentError.error));
-  stream.respond();
-  stream.end();
-}, tests.length));
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    stream.pushStream({}, common.expectsError(currentError.error));
+    stream.respond();
+    stream.end();
+  }, tests.length)
+);
 
 server.listen(0, common.mustCall(() => runTest(tests.shift())));
 
@@ -86,13 +85,16 @@ function runTest(test) {
   req.resume();
   req.end();
 
-  req.on('close', common.mustCall(() => {
-    client.close();
-
-    if (!tests.length) {
-      server.close();
-    } else {
-      runTest(tests.shift());
-    }
-  }));
+  req.on(
+    'close',
+    common.mustCall(() => {
+      client.close();
+
+      if (!tests.length) {
+        server.close();
+      } else {
+        runTest(tests.shift());
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-http2-server-push-stream-head.js b/test/parallel/test-http2-server-push-stream-head.js
index 35e22c0ce3b561..ccfa66d1fc5f5e 100644
--- a/test/parallel/test-http2-server-push-stream-head.js
+++ b/test/parallel/test-http2-server-push-stream-head.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
@@ -11,62 +10,83 @@ const Countdown = require('../common/countdown');
 // - stream should end immediately (no body)
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const port = server.address().port;
-  if (headers[':path'] === '/') {
-    stream.pushStream({
-      ':scheme': 'http',
-      ':method': 'HEAD',
-      ':authority': `localhost:${port}`,
-    }, common.mustCall((err, push, headers) => {
-      assert.strictEqual(push._writableState.ended, true);
-      push.respond();
-      // cannot write to push() anymore
-      push.on('error', common.expectsError({
-        type: Error,
-        code: 'ERR_STREAM_WRITE_AFTER_END',
-        message: 'write after end'
-      }));
-      assert(!push.write('test'));
-      stream.end('test');
-    }));
-  }
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
-}));
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    const port = server.address().port;
+    if (headers[':path'] === '/') {
+      stream.pushStream(
+        {
+          ':scheme': 'http',
+          ':method': 'HEAD',
+          ':authority': `localhost:${port}`
+        },
+        common.mustCall((err, push, headers) => {
+          assert.strictEqual(push._writableState.ended, true);
+          push.respond();
+          // cannot write to push() anymore
+          push.on(
+            'error',
+            common.expectsError({
+              type: Error,
+              code: 'ERR_STREAM_WRITE_AFTER_END',
+              message: 'write after end'
+            })
+          );
+          assert(!push.write('test'));
+          stream.end('test');
+        })
+      );
+    }
+    stream.respond({
+      'content-type': 'text/html',
+      ':status': 200
+    });
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
 
-  const countdown = new Countdown(2, () => {
-    server.close();
-    client.close();
-  });
+    const countdown = new Countdown(2, () => {
+      server.close();
+      client.close();
+    });
 
-  const req = client.request();
-  req.setEncoding('utf8');
+    const req = client.request();
+    req.setEncoding('utf8');
 
-  client.on('stream', common.mustCall((stream, headers) => {
-    assert.strictEqual(headers[':method'], 'HEAD');
-    assert.strictEqual(headers[':scheme'], 'http');
-    assert.strictEqual(headers[':path'], '/');
-    assert.strictEqual(headers[':authority'], `localhost:${port}`);
-    stream.on('push', common.mustCall(() => {
-      stream.on('data', common.mustNotCall());
-      stream.on('end', common.mustCall());
-    }));
-    stream.on('close', common.mustCall(() => countdown.dec()));
-  }));
+    client.on(
+      'stream',
+      common.mustCall((stream, headers) => {
+        assert.strictEqual(headers[':method'], 'HEAD');
+        assert.strictEqual(headers[':scheme'], 'http');
+        assert.strictEqual(headers[':path'], '/');
+        assert.strictEqual(headers[':authority'], `localhost:${port}`);
+        stream.on(
+          'push',
+          common.mustCall(() => {
+            stream.on('data', common.mustNotCall());
+            stream.on('end', common.mustCall());
+          })
+        );
+        stream.on('close', common.mustCall(() => countdown.dec()));
+      })
+    );
 
-  let data = '';
+    let data = '';
 
-  req.on('data', common.mustCall((d) => data += d));
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(data, 'test');
-  }));
-  req.on('close', common.mustCall(() => countdown.dec()));
-  req.end();
-}));
+    req.on('data', common.mustCall((d) => (data += d)));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(data, 'test');
+      })
+    );
+    req.on('close', common.mustCall(() => countdown.dec()));
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-server-push-stream.js b/test/parallel/test-http2-server-push-stream.js
index 74d41ba4b9c672..e301f4ca0b1625 100644
--- a/test/parallel/test-http2-server-push-stream.js
+++ b/test/parallel/test-http2-server-push-stream.js
@@ -1,69 +1,89 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
-  const port = server.address().port;
-  if (headers[':path'] === '/') {
-    stream.pushStream({
-      ':scheme': 'http',
-      ':path': '/foobar',
-      ':authority': `localhost:${port}`,
-    }, common.mustCall((err, push, headers) => {
-      assert.ifError(err);
-      push.respond({
-        'content-type': 'text/html',
-        ':status': 200,
-        'x-push-data': 'pushed by server',
-      });
-      push.end('pushed by server data');
+server.on(
+  'stream',
+  common.mustCall((stream, headers) => {
+    const port = server.address().port;
+    if (headers[':path'] === '/') {
+      stream.pushStream(
+        {
+          ':scheme': 'http',
+          ':path': '/foobar',
+          ':authority': `localhost:${port}`
+        },
+        common.mustCall((err, push, headers) => {
+          assert.ifError(err);
+          push.respond({
+            'content-type': 'text/html',
+            ':status': 200,
+            'x-push-data': 'pushed by server'
+          });
+          push.end('pushed by server data');
 
-      common.expectsError(() => {
-        push.pushStream({}, common.mustNotCall());
-      }, {
-        code: 'ERR_HTTP2_NESTED_PUSH',
-        type: Error
-      });
+          common.expectsError(
+            () => {
+              push.pushStream({}, common.mustNotCall());
+            },
+            {
+              code: 'ERR_HTTP2_NESTED_PUSH',
+              type: Error
+            }
+          );
 
-      stream.end('test');
-    }));
-  }
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  });
-}));
+          stream.end('test');
+        })
+      );
+    }
+    stream.respond({
+      'content-type': 'text/html',
+      ':status': 200
+    });
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const headers = { ':path': '/' };
-  const client = http2.connect(`http://localhost:${port}`);
-  const req = client.request(headers);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const headers = { ':path': '/' };
+    const client = http2.connect(`http://localhost:${port}`);
+    const req = client.request(headers);
 
-  client.on('stream', common.mustCall((stream, headers) => {
-    assert.strictEqual(headers[':scheme'], 'http');
-    assert.strictEqual(headers[':path'], '/foobar');
-    assert.strictEqual(headers[':authority'], `localhost:${port}`);
-    stream.on('push', common.mustCall((headers) => {
-      assert.strictEqual(headers[':status'], 200);
-      assert.strictEqual(headers['content-type'], 'text/html');
-      assert.strictEqual(headers['x-push-data'], 'pushed by server');
-    }));
-    stream.on('aborted', common.mustNotCall());
-  }));
+    client.on(
+      'stream',
+      common.mustCall((stream, headers) => {
+        assert.strictEqual(headers[':scheme'], 'http');
+        assert.strictEqual(headers[':path'], '/foobar');
+        assert.strictEqual(headers[':authority'], `localhost:${port}`);
+        stream.on(
+          'push',
+          common.mustCall((headers) => {
+            assert.strictEqual(headers[':status'], 200);
+            assert.strictEqual(headers['content-type'], 'text/html');
+            assert.strictEqual(headers['x-push-data'], 'pushed by server');
+          })
+        );
+        stream.on('aborted', common.mustNotCall());
+      })
+    );
 
-  let data = '';
+    let data = '';
 
-  req.on('data', common.mustCall((d) => data += d));
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(data, 'test');
-    server.close();
-    client.close();
-  }));
-  req.end();
-}));
+    req.on('data', common.mustCall((d) => (data += d)));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(data, 'test');
+        server.close();
+        client.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-server-rst-before-respond.js b/test/parallel/test-http2-server-rst-before-respond.js
index e7218aaeea29af..b1ff8062b2cad6 100644
--- a/test/parallel/test-http2-server-rst-before-respond.js
+++ b/test/parallel/test-http2-server-rst-before-respond.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -14,24 +13,33 @@ server.on('stream', common.mustCall(onStream));
 function onStream(stream, headers, flags) {
   stream.close();
 
-  common.expectsError(() => {
-    stream.additionalHeaders({
-      ':status': 123,
-      'abc': 123
-    });
-  }, { code: 'ERR_HTTP2_INVALID_STREAM' });
+  common.expectsError(
+    () => {
+      stream.additionalHeaders({
+        ':status': 123,
+        abc: 123
+      });
+    },
+    { code: 'ERR_HTTP2_INVALID_STREAM' }
+  );
 }
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  req.on('headers', common.mustNotCall());
-  req.on('close', common.mustCall(() => {
-    assert.strictEqual(h2.constants.NGHTTP2_NO_ERROR, req.rstCode);
-    server.close();
-    client.close();
-  }));
-  req.on('response', common.mustNotCall());
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    req.on('headers', common.mustNotCall());
+    req.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(h2.constants.NGHTTP2_NO_ERROR, req.rstCode);
+        server.close();
+        client.close();
+      })
+    );
+    req.on('response', common.mustNotCall());
+  })
+);
diff --git a/test/parallel/test-http2-server-rst-stream.js b/test/parallel/test-http2-server-rst-stream.js
index 132c32ead600dd..63edec21424c1f 100644
--- a/test/parallel/test-http2-server-rst-stream.js
+++ b/test/parallel/test-http2-server-rst-stream.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
@@ -28,36 +27,43 @@ const server = http2.createServer();
 server.on('stream', (stream, headers) => {
   const test = tests.find((t) => t[0] === Number(headers.rstcode));
   if (test[1]) {
-    stream.on('error', common.expectsError({
-      type: Error,
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      message: `Stream closed with error code ${test[2]}`
-    }));
+    stream.on(
+      'error',
+      common.expectsError({
+        type: Error,
+        code: 'ERR_HTTP2_STREAM_ERROR',
+        message: `Stream closed with error code ${test[2]}`
+      })
+    );
   }
   stream.close(headers.rstcode | 0);
 });
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  const countdown = new Countdown(tests.length, () => {
-    client.close();
-    server.close();
-  });
+    const countdown = new Countdown(tests.length, () => {
+      client.close();
+      server.close();
+    });
 
-  tests.forEach((test) => {
-    const req = client.request({
-      ':method': 'POST',
-      'rstcode': test[0]
+    tests.forEach((test) => {
+      const req = client.request({
+        ':method': 'POST',
+        rstcode: test[0]
+      });
+      req.on(
+        'close',
+        common.mustCall(() => {
+          assert.strictEqual(req.rstCode, test[0]);
+          countdown.dec();
+        })
+      );
+      req.on('aborted', common.mustCall());
+      if (test[1]) req.on('error', common.mustCall());
+      else req.on('error', common.mustNotCall());
     });
-    req.on('close', common.mustCall(() => {
-      assert.strictEqual(req.rstCode, test[0]);
-      countdown.dec();
-    }));
-    req.on('aborted', common.mustCall());
-    if (test[1])
-      req.on('error', common.mustCall());
-    else
-      req.on('error', common.mustNotCall());
-  });
-}));
+  })
+);
diff --git a/test/parallel/test-http2-server-sessionerror.js b/test/parallel/test-http2-server-sessionerror.js
index c50352fcc35c28..e0f06967b0a70a 100644
--- a/test/parallel/test-http2-server-sessionerror.js
+++ b/test/parallel/test-http2-server-sessionerror.js
@@ -3,8 +3,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const { kSocket } = require('internal/http2/util');
 
@@ -13,39 +12,56 @@ server.on('stream', common.mustNotCall());
 
 let test = 0;
 
-server.on('session', common.mustCall((session) => {
-  switch (++test) {
-    case 1:
-      server.on('error', common.mustNotCall());
-      session.on('error', common.expectsError({
-        type: Error,
-        message: 'test'
-      }));
-      session[kSocket].emit('error', new Error('test'));
-      break;
-    case 2:
-      // If the server does not have a socketError listener,
-      // error will be silent on the server but will close
-      // the session
-      session[kSocket].emit('error', new Error('test'));
-      break;
-  }
-}, 2));
+server.on(
+  'session',
+  common.mustCall((session) => {
+    switch (++test) {
+      case 1:
+        server.on('error', common.mustNotCall());
+        session.on(
+          'error',
+          common.expectsError({
+            type: Error,
+            message: 'test'
+          })
+        );
+        session[kSocket].emit('error', new Error('test'));
+        break;
+      case 2:
+        // If the server does not have a socketError listener,
+        // error will be silent on the server but will close
+        // the session
+        session[kSocket].emit('error', new Error('test'));
+        break;
+    }
+  }, 2)
+);
 
-server.listen(0, common.mustCall(() => {
-  const url = `http://localhost:${server.address().port}`;
-  http2.connect(url)
-    .on('error', common.expectsError({
-      code: 'ERR_HTTP2_SESSION_ERROR',
-      message: 'Session closed with error code 2',
-    }))
-    .on('close', () => {
-      server.removeAllListeners('error');
-      http2.connect(url)
-        .on('error', common.expectsError({
+server.listen(
+  0,
+  common.mustCall(() => {
+    const url = `http://localhost:${server.address().port}`;
+    http2
+      .connect(url)
+      .on(
+        'error',
+        common.expectsError({
           code: 'ERR_HTTP2_SESSION_ERROR',
-          message: 'Session closed with error code 2',
-        }))
-        .on('close', () => server.close());
-    });
-}));
+          message: 'Session closed with error code 2'
+        })
+      )
+      .on('close', () => {
+        server.removeAllListeners('error');
+        http2
+          .connect(url)
+          .on(
+            'error',
+            common.expectsError({
+              code: 'ERR_HTTP2_SESSION_ERROR',
+              message: 'Session closed with error code 2'
+            })
+          )
+          .on('close', () => server.close());
+      });
+  })
+);
diff --git a/test/parallel/test-http2-server-set-header.js b/test/parallel/test-http2-server-set-header.js
index 83f373ec21b314..f0b25939ec2d02 100644
--- a/test/parallel/test-http2-server-set-header.js
+++ b/test/parallel/test-http2-server-set-header.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const body =
@@ -14,24 +13,30 @@ const server = http2.createServer((req, res) => {
   res.end(body);
 });
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const headers = { ':path': '/' };
-  const req = client.request(headers);
-  req.setEncoding('utf8');
-  req.on('response', common.mustCall(function(headers) {
-    assert.strictEqual(headers.foobar, 'baz');
-    assert.strictEqual(headers['x-powered-by'], 'node-test');
-  }));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const headers = { ':path': '/' };
+    const req = client.request(headers);
+    req.setEncoding('utf8');
+    req.on(
+      'response',
+      common.mustCall(function(headers) {
+        assert.strictEqual(headers.foobar, 'baz');
+        assert.strictEqual(headers['x-powered-by'], 'node-test');
+      })
+    );
 
-  let data = '';
-  req.on('data', (d) => data += d);
-  req.on('end', () => {
-    assert.strictEqual(body, data);
-    server.close();
-    client.close();
-  });
-  req.end();
-}));
+    let data = '';
+    req.on('data', (d) => (data += d));
+    req.on('end', () => {
+      assert.strictEqual(body, data);
+      server.close();
+      client.close();
+    });
+    req.end();
+  })
+);
 
 server.on('error', common.mustNotCall());
diff --git a/test/parallel/test-http2-server-settimeout-no-callback.js b/test/parallel/test-http2-server-settimeout-no-callback.js
index a43fbb212958c8..985392a919afba 100644
--- a/test/parallel/test-http2-server-settimeout-no-callback.js
+++ b/test/parallel/test-http2-server-settimeout-no-callback.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http2 = require('http2');
diff --git a/test/parallel/test-http2-server-shutdown-before-respond.js b/test/parallel/test-http2-server-shutdown-before-respond.js
index 33f224fc69a9d5..0270b1ca4ed7d4 100644
--- a/test/parallel/test-http2-server-shutdown-before-respond.js
+++ b/test/parallel/test-http2-server-shutdown-before-respond.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 const server = h2.createServer();
@@ -18,19 +17,28 @@ function onStream(stream, headers, flags) {
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  client.on('goaway', common.mustCall());
-  client.on('error', common.expectsError({
-    code: 'ERR_HTTP2_SESSION_ERROR'
-  }));
-
-  const req = client.request();
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_SESSION_ERROR'
-  }));
-  req.resume();
-  req.on('data', common.mustNotCall());
-  req.on('end', common.mustCall(() => server.close()));
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+
+    client.on('goaway', common.mustCall());
+    client.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_SESSION_ERROR'
+      })
+    );
+
+    const req = client.request();
+    req.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_SESSION_ERROR'
+      })
+    );
+    req.resume();
+    req.on('data', common.mustNotCall());
+    req.on('end', common.mustCall(() => server.close()));
+  })
+);
diff --git a/test/parallel/test-http2-server-shutdown-options-errors.js b/test/parallel/test-http2-server-shutdown-options-errors.js
index 9dde6660ea25ce..dce3cd55136fdf 100644
--- a/test/parallel/test-http2-server-shutdown-options-errors.js
+++ b/test/parallel/test-http2-server-shutdown-options-errors.js
@@ -1,55 +1,45 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 const server = http2.createServer();
 
-const types = [
-  true,
-  {},
-  [],
-  null,
-  new Date()
-];
+const types = [true, {}, [], null, new Date()];
 
-server.on('stream', common.mustCall((stream) => {
-  const session = stream.session;
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    const session = stream.session;
 
-  types.forEach((input) => {
-    common.expectsError(
-      () => session.goaway(input),
-      {
+    types.forEach((input) => {
+      common.expectsError(() => session.goaway(input), {
         code: 'ERR_INVALID_ARG_TYPE',
         type: TypeError,
-        message: 'The "code" argument must be of type number. Received type ' +
-                 typeof input
-      }
-    );
-    common.expectsError(
-      () => session.goaway(0, input),
-      {
+        message:
+          'The "code" argument must be of type number. Received type ' +
+          typeof input
+      });
+      common.expectsError(() => session.goaway(0, input), {
         code: 'ERR_INVALID_ARG_TYPE',
         type: TypeError,
-        message: 'The "lastStreamID" argument must be of type number. ' +
-                 `Received type ${typeof input}`
-      }
-    );
-    common.expectsError(
-      () => session.goaway(0, 0, input),
-      {
+        message:
+          'The "lastStreamID" argument must be of type number. ' +
+          `Received type ${typeof input}`
+      });
+      common.expectsError(() => session.goaway(0, 0, input), {
         code: 'ERR_INVALID_ARG_TYPE',
         type: TypeError,
-        message: 'The "opaqueData" argument must be one of type Buffer, ' +
-                 `TypedArray, or DataView. Received type ${typeof input}`
-      }
-    );
-  });
+        message:
+          'The "opaqueData" argument must be one of type Buffer, ' +
+          `TypedArray, or DataView. Received type ${typeof input}`
+      });
+    });
 
-  stream.session.destroy();
-}));
+    stream.session.destroy();
+  })
+);
 
 server.listen(
   0,
@@ -57,9 +47,12 @@ server.listen(
     const client = http2.connect(`http://localhost:${server.address().port}`);
     const req = client.request();
     req.resume();
-    req.on('close', common.mustCall(() => {
-      client.close();
-      server.close();
-    }));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
   })
 );
diff --git a/test/parallel/test-http2-server-shutdown-redundant.js b/test/parallel/test-http2-server-shutdown-redundant.js
index f47a0d2c951c86..be0e387bc072f5 100644
--- a/test/parallel/test-http2-server-shutdown-redundant.js
+++ b/test/parallel/test-http2-server-shutdown-redundant.js
@@ -1,40 +1,54 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  const session = stream.session;
-  session.goaway(1);
-  session.goaway(2);
-  stream.session.on('close', common.mustCall(() => {
-    common.expectsError(
-      () => session.goaway(3),
-      {
-        code: 'ERR_HTTP2_INVALID_SESSION',
-        type: Error
-      }
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    const session = stream.session;
+    session.goaway(1);
+    session.goaway(2);
+    stream.session.on(
+      'close',
+      common.mustCall(() => {
+        common.expectsError(() => session.goaway(3), {
+          code: 'ERR_HTTP2_INVALID_SESSION',
+          type: Error
+        });
+      })
     );
-  }));
-}));
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  client.on('error', common.expectsError({
-    code: 'ERR_HTTP2_SESSION_ERROR'
-  }));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    client.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_SESSION_ERROR'
+      })
+    );
 
-  const req = client.request();
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_SESSION_ERROR'
-  }));
-  req.resume();
-  req.on('close', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+    const req = client.request();
+    req.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_SESSION_ERROR'
+      })
+    );
+    req.resume();
+    req.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-server-socket-destroy.js b/test/parallel/test-http2-server-socket-destroy.js
index 99595aeb63004d..b023ddf8efb393 100644
--- a/test/parallel/test-http2-server-socket-destroy.js
+++ b/test/parallel/test-http2-server-socket-destroy.js
@@ -3,8 +3,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const { kSocket } = require('internal/http2/util');
@@ -36,27 +35,28 @@ function onStream(stream) {
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  // The client may have an ECONNRESET error here depending on the operating
-  // system, due mainly to differences in the timing of socket closing. Do
-  // not wrap this in a common mustCall.
-  client.on('error', (err) => {
-    if (err.code !== 'ECONNRESET')
-      throw err;
-  });
-  client.on('close', common.mustCall());
-
-  const req = client.request({ ':method': 'POST' });
-  // The client may have an ECONNRESET error here depending on the operating
-  // system, due mainly to differences in the timing of socket closing. Do
-  // not wrap this in a common mustCall.
-  req.on('error', (err) => {
-    if (err.code !== 'ECONNRESET')
-      throw err;
-  });
-
-  req.on('aborted', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall());
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    // The client may have an ECONNRESET error here depending on the operating
+    // system, due mainly to differences in the timing of socket closing. Do
+    // not wrap this in a common mustCall.
+    client.on('error', (err) => {
+      if (err.code !== 'ECONNRESET') throw err;
+    });
+    client.on('close', common.mustCall());
+
+    const req = client.request({ ':method': 'POST' });
+    // The client may have an ECONNRESET error here depending on the operating
+    // system, due mainly to differences in the timing of socket closing. Do
+    // not wrap this in a common mustCall.
+    req.on('error', (err) => {
+      if (err.code !== 'ECONNRESET') throw err;
+    });
+
+    req.on('aborted', common.mustCall());
+    req.resume();
+    req.on('end', common.mustCall());
+  })
+);
diff --git a/test/parallel/test-http2-server-startup.js b/test/parallel/test-http2-server-startup.js
index 4ebcc21c27aa8e..80b03592964d52 100644
--- a/test/parallel/test-http2-server-startup.js
+++ b/test/parallel/test-http2-server-startup.js
@@ -7,8 +7,7 @@
 const common = require('../common');
 const commonFixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http2 = require('http2');
 const tls = require('tls');
@@ -36,34 +35,50 @@ server.on('error', common.mustNotCall());
 {
   let client;
   const server = http2.createServer();
-  server.on('timeout', common.mustCall(() => {
-    server.close();
-    if (client)
-      client.end();
-  }));
+  server.on(
+    'timeout',
+    common.mustCall(() => {
+      server.close();
+      if (client) client.end();
+    })
+  );
   server.setTimeout(common.platformTimeout(1000), common.mustCall());
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    client = net.connect(port, common.mustCall());
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      client = net.connect(
+        port,
+        common.mustCall()
+      );
+    })
+  );
 }
 
 // Test the secure server socket timeout.
 {
   let client;
   const server = http2.createSecureServer(options);
-  server.on('timeout', common.mustCall(() => {
-    server.close();
-    if (client)
-      client.end();
-  }));
+  server.on(
+    'timeout',
+    common.mustCall(() => {
+      server.close();
+      if (client) client.end();
+    })
+  );
   server.setTimeout(common.platformTimeout(1000), common.mustCall());
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    client = tls.connect({
-      port: port,
-      rejectUnauthorized: false,
-      ALPNProtocols: ['h2']
-    }, common.mustCall());
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      client = tls.connect(
+        {
+          port: port,
+          rejectUnauthorized: false,
+          ALPNProtocols: ['h2']
+        },
+        common.mustCall()
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-http2-server-stream-session-destroy.js b/test/parallel/test-http2-server-stream-session-destroy.js
index 6a262e2736e4bc..dfb7050011bdd6 100644
--- a/test/parallel/test-http2-server-stream-session-destroy.js
+++ b/test/parallel/test-http2-server-stream-session-destroy.js
@@ -1,51 +1,56 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 const server = h2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  assert(stream.session);
-  stream.session.destroy();
-  assert.strictEqual(stream.session, undefined);
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    assert(stream.session);
+    stream.session.destroy();
+    assert.strictEqual(stream.session, undefined);
 
-  // Test that stream.state getter returns an empty object
-  // when the stream session has been destroyed
-  assert.deepStrictEqual({}, stream.state);
+    // Test that stream.state getter returns an empty object
+    // when the stream session has been destroyed
+    assert.deepStrictEqual({}, stream.state);
 
-  // Test that ERR_HTTP2_INVALID_STREAM is thrown while calling
-  // stream operations after the stream session has been destroyed
-  const invalidStreamError = {
-    type: Error,
-    code: 'ERR_HTTP2_INVALID_STREAM',
-    message: 'The stream has been destroyed'
-  };
-  common.expectsError(() => stream.additionalHeaders(), invalidStreamError);
-  common.expectsError(() => stream.priority(), invalidStreamError);
-  common.expectsError(() => stream.respond(), invalidStreamError);
-  common.expectsError(
-    () => stream.pushStream({}, common.mustNotCall()),
-    {
+    // Test that ERR_HTTP2_INVALID_STREAM is thrown while calling
+    // stream operations after the stream session has been destroyed
+    const invalidStreamError = {
+      type: Error,
+      code: 'ERR_HTTP2_INVALID_STREAM',
+      message: 'The stream has been destroyed'
+    };
+    common.expectsError(() => stream.additionalHeaders(), invalidStreamError);
+    common.expectsError(() => stream.priority(), invalidStreamError);
+    common.expectsError(() => stream.respond(), invalidStreamError);
+    common.expectsError(() => stream.pushStream({}, common.mustNotCall()), {
       code: 'ERR_HTTP2_PUSH_DISABLED',
       type: Error
-    }
-  );
-  stream.on('error', common.expectsError({
-    type: Error,
-    code: 'ERR_STREAM_WRITE_AFTER_END',
-    message: 'write after end'
-  }));
-  assert.strictEqual(stream.write('data'), false);
-}));
+    });
+    stream.on(
+      'error',
+      common.expectsError({
+        type: Error,
+        code: 'ERR_STREAM_WRITE_AFTER_END',
+        message: 'write after end'
+      })
+    );
+    assert.strictEqual(stream.write('data'), false);
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  req.resume();
-  req.on('end', common.mustCall());
-  req.on('close', common.mustCall(() => server.close(common.mustCall())));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    req.resume();
+    req.on('end', common.mustCall());
+    req.on('close', common.mustCall(() => server.close(common.mustCall())));
+  })
+);
diff --git a/test/parallel/test-http2-server-timeout.js b/test/parallel/test-http2-server-timeout.js
index 88fc4eab2e08c0..2c9f0e1f8c1b81 100755
--- a/test/parallel/test-http2-server-timeout.js
+++ b/test/parallel/test-http2-server-timeout.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 const server = http2.createServer();
@@ -15,11 +14,17 @@ const onServerTimeout = common.mustCall((session) => {
 server.on('stream', common.mustNotCall());
 server.once('timeout', onServerTimeout);
 
-server.listen(0, common.mustCall(() => {
-  const url = `http://localhost:${server.address().port}`;
-  const client = http2.connect(url);
-  client.on('close', common.mustCall(() => {
-    const client2 = http2.connect(url);
-    client2.on('close', common.mustCall(() => server.close()));
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const url = `http://localhost:${server.address().port}`;
+    const client = http2.connect(url);
+    client.on(
+      'close',
+      common.mustCall(() => {
+        const client2 = http2.connect(url);
+        client2.on('close', common.mustCall(() => server.close()));
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-session-gc-while-write-scheduled.js b/test/parallel/test-http2-session-gc-while-write-scheduled.js
index aef9d9571d5559..6113b570bc2f91 100644
--- a/test/parallel/test-http2-session-gc-while-write-scheduled.js
+++ b/test/parallel/test-http2-session-gc-while-write-scheduled.js
@@ -2,8 +2,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const makeDuplexPair = require('../common/duplexpair');
 const tick = require('../common/tick');
@@ -13,9 +12,12 @@ const tick = require('../common/tick');
 
 {
   // This creates a session and schedules a write (for the settings frame).
-  let client = http2.connect('http://localhost:80', {
-    createConnection: common.mustCall(() => makeDuplexPair().clientSide)
-  });
+  let client = http2.connect(
+    'http://localhost:80',
+    {
+      createConnection: common.mustCall(() => makeDuplexPair().clientSide)
+    }
+  );
 
   // First, wait for any nextTicks() and their responses
   // from the `connect()` call to run.
diff --git a/test/parallel/test-http2-session-settings.js b/test/parallel/test-http2-session-settings.js
index 6061808082519d..e14606bb5b8dfe 100644
--- a/test/parallel/test-http2-session-settings.js
+++ b/test/parallel/test-http2-session-settings.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -41,12 +40,15 @@ server.on(
 server.listen(
   0,
   common.mustCall(() => {
-    const client = h2.connect(`http://localhost:${server.address().port}`, {
-      settings: {
-        enablePush: false,
-        initialWindowSize: 123456
+    const client = h2.connect(
+      `http://localhost:${server.address().port}`,
+      {
+        settings: {
+          enablePush: false,
+          initialWindowSize: 123456
+        }
       }
-    });
+    );
 
     client.on(
       'localSettings',
@@ -68,58 +70,61 @@ server.listen(
 
     const req = client.request(headers);
 
-    req.on('ready', common.mustCall(() => {
-      // pendingSettingsAck will be true if a SETTINGS frame
-      // has been sent but we are still waiting for an acknowledgement
-      assert(client.pendingSettingsAck);
-    }));
+    req.on(
+      'ready',
+      common.mustCall(() => {
+        // pendingSettingsAck will be true if a SETTINGS frame
+        // has been sent but we are still waiting for an acknowledgement
+        assert(client.pendingSettingsAck);
+      })
+    );
 
     // State will only be valid after connect event is emitted
-    req.on('ready', common.mustCall(() => {
-      client.settings({ maxHeaderListSize: 1 }, common.mustCall());
+    req.on(
+      'ready',
+      common.mustCall(() => {
+        client.settings({ maxHeaderListSize: 1 }, common.mustCall());
 
-      // Verify valid error ranges
-      [
-        ['headerTableSize', -1],
-        ['headerTableSize', 2 ** 32],
-        ['initialWindowSize', -1],
-        ['initialWindowSize', 2 ** 32],
-        ['maxFrameSize', 16383],
-        ['maxFrameSize', 2 ** 24],
-        ['maxHeaderListSize', -1],
-        ['maxHeaderListSize', 2 ** 32]
-      ].forEach((i) => {
-        const settings = {};
-        settings[i[0]] = i[1];
-        common.expectsError(
-          () => client.settings(settings),
-          {
+        // Verify valid error ranges
+        [
+          ['headerTableSize', -1],
+          ['headerTableSize', 2 ** 32],
+          ['initialWindowSize', -1],
+          ['initialWindowSize', 2 ** 32],
+          ['maxFrameSize', 16383],
+          ['maxFrameSize', 2 ** 24],
+          ['maxHeaderListSize', -1],
+          ['maxHeaderListSize', 2 ** 32]
+        ].forEach((i) => {
+          const settings = {};
+          settings[i[0]] = i[1];
+          common.expectsError(() => client.settings(settings), {
             type: RangeError,
             code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
             message: `Invalid value for setting "${i[0]}": ${i[1]}`
-          }
-        );
-      });
+          });
+        });
 
-      // error checks for enablePush
-      [1, {}, 'test', [], null, Infinity, NaN].forEach((i) => {
-        common.expectsError(
-          () => client.settings({ enablePush: i }),
-          {
+        // error checks for enablePush
+        [1, {}, 'test', [], null, Infinity, NaN].forEach((i) => {
+          common.expectsError(() => client.settings({ enablePush: i }), {
             type: TypeError,
             code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
             message: `Invalid value for setting "enablePush": ${i}`
-          }
-        );
-      });
-    }));
+          });
+        });
+      })
+    );
 
     req.on('response', common.mustCall());
     req.resume();
-    req.on('end', common.mustCall(() => {
-      server.close();
-      client.close();
-    }));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
     req.end();
   })
 );
diff --git a/test/parallel/test-http2-session-stream-state.js b/test/parallel/test-http2-session-stream-state.js
index 612feb8cf1e2ca..316c4f6f82aa8d 100644
--- a/test/parallel/test-http2-session-stream-state.js
+++ b/test/parallel/test-http2-session-stream-state.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -11,7 +10,6 @@ const server = h2.createServer();
 server.on('stream', common.mustCall(onStream));
 
 function onStream(stream, headers, flags) {
-
   // Test Stream State.
   {
     const state = stream.state;
@@ -48,51 +46,57 @@ function onStream(stream, headers, flags) {
 
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-
-  const headers = { ':path': '/' };
-
-  const req = client.request(headers);
-
-  // State will only be valid after connect event is emitted
-  req.on('ready', common.mustCall(() => {
-
-    // Test Stream State.
-    {
-      const state = req.state;
-      assert.strictEqual(typeof state, 'object');
-      assert.strictEqual(typeof state.state, 'number');
-      assert.strictEqual(typeof state.weight, 'number');
-      assert.strictEqual(typeof state.sumDependencyWeight, 'number');
-      assert.strictEqual(typeof state.localClose, 'number');
-      assert.strictEqual(typeof state.remoteClose, 'number');
-      assert.strictEqual(typeof state.localWindowSize, 'number');
-    }
-
-    // Test Session State
-    {
-      const state = req.session.state;
-      assert.strictEqual(typeof state, 'object');
-      assert.strictEqual(typeof state.effectiveLocalWindowSize, 'number');
-      assert.strictEqual(typeof state.effectiveRecvDataLength, 'number');
-      assert.strictEqual(typeof state.nextStreamID, 'number');
-      assert.strictEqual(typeof state.localWindowSize, 'number');
-      assert.strictEqual(typeof state.lastProcStreamID, 'number');
-      assert.strictEqual(typeof state.remoteWindowSize, 'number');
-      assert.strictEqual(typeof state.outboundQueueSize, 'number');
-      assert.strictEqual(typeof state.deflateDynamicTableSize, 'number');
-      assert.strictEqual(typeof state.inflateDynamicTableSize, 'number');
-    }
-  }));
-
-  req.on('response', common.mustCall());
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-  req.end();
-
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+
+    const headers = { ':path': '/' };
+
+    const req = client.request(headers);
+
+    // State will only be valid after connect event is emitted
+    req.on(
+      'ready',
+      common.mustCall(() => {
+        // Test Stream State.
+        {
+          const state = req.state;
+          assert.strictEqual(typeof state, 'object');
+          assert.strictEqual(typeof state.state, 'number');
+          assert.strictEqual(typeof state.weight, 'number');
+          assert.strictEqual(typeof state.sumDependencyWeight, 'number');
+          assert.strictEqual(typeof state.localClose, 'number');
+          assert.strictEqual(typeof state.remoteClose, 'number');
+          assert.strictEqual(typeof state.localWindowSize, 'number');
+        }
+
+        // Test Session State
+        {
+          const state = req.session.state;
+          assert.strictEqual(typeof state, 'object');
+          assert.strictEqual(typeof state.effectiveLocalWindowSize, 'number');
+          assert.strictEqual(typeof state.effectiveRecvDataLength, 'number');
+          assert.strictEqual(typeof state.nextStreamID, 'number');
+          assert.strictEqual(typeof state.localWindowSize, 'number');
+          assert.strictEqual(typeof state.lastProcStreamID, 'number');
+          assert.strictEqual(typeof state.remoteWindowSize, 'number');
+          assert.strictEqual(typeof state.outboundQueueSize, 'number');
+          assert.strictEqual(typeof state.deflateDynamicTableSize, 'number');
+          assert.strictEqual(typeof state.inflateDynamicTableSize, 'number');
+        }
+      })
+    );
+
+    req.on('response', common.mustCall());
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-session-unref.js b/test/parallel/test-http2-session-unref.js
index 0381971c0eace5..33a266e3e5e572 100644
--- a/test/parallel/test-http2-session-unref.js
+++ b/test/parallel/test-http2-session-unref.js
@@ -6,8 +6,7 @@
 // (2) Doesn't crash
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
 const makeDuplexPair = require('../common/duplexpair');
@@ -21,40 +20,55 @@ const counter = new Countdown(3, () => server.unref());
 // - the vanilla client
 // - the destroyed client
 // - manual 'connection' event emission with generic Duplex stream
-server.on('session', common.mustCallAtLeast((session) => {
-  counter.dec();
-  session.unref();
-}, 3));
-
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-
-  // unref new client
-  {
-    const client = http2.connect(`http://localhost:${port}`);
-    client.unref();
-  }
-
-  // unref destroyed client
-  {
-    const client = http2.connect(`http://localhost:${port}`);
-
-    client.on('connect', common.mustCall(() => {
-      client.destroy();
-      client.unref();
-    }));
-  }
+server.on(
+  'session',
+  common.mustCallAtLeast((session) => {
+    counter.dec();
+    session.unref();
+  }, 3)
+);
 
-  // unref destroyed client
-  {
-    const client = http2.connect(`http://localhost:${port}`, {
-      createConnection: common.mustCall(() => clientSide)
-    });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
 
-    client.on('connect', common.mustCall(() => {
-      client.destroy();
+    // unref new client
+    {
+      const client = http2.connect(`http://localhost:${port}`);
       client.unref();
-    }));
-  }
-}));
+    }
+
+    // unref destroyed client
+    {
+      const client = http2.connect(`http://localhost:${port}`);
+
+      client.on(
+        'connect',
+        common.mustCall(() => {
+          client.destroy();
+          client.unref();
+        })
+      );
+    }
+
+    // unref destroyed client
+    {
+      const client = http2.connect(
+        `http://localhost:${port}`,
+        {
+          createConnection: common.mustCall(() => clientSide)
+        }
+      );
+
+      client.on(
+        'connect',
+        common.mustCall(() => {
+          client.destroy();
+          client.unref();
+        })
+      );
+    }
+  })
+);
 server.emit('connection', serverSide);
diff --git a/test/parallel/test-http2-settings-unsolicited-ack.js b/test/parallel/test-http2-settings-unsolicited-ack.js
index fa63e9ee3f6425..78acc848ecb49f 100644
--- a/test/parallel/test-http2-settings-unsolicited-ack.js
+++ b/test/parallel/test-http2-settings-unsolicited-ack.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http2 = require('http2');
@@ -24,27 +23,36 @@ const countdown = new Countdown(3, () => {
 });
 
 server.on('stream', common.mustNotCall());
-server.on('session', common.mustCall((session) => {
-  session.on('remoteSettings', common.mustCall(() => countdown.dec()));
-}));
-
-server.listen(0, common.mustCall(() => {
-  client = net.connect(server.address().port);
-
-  // Ensures that the clients settings frames are not sent until the
-  // servers are received, so that the first ack is actually expected.
-  client.once('data', (chunk) => {
-    // The very first chunk of data we get from the server should
-    // be a settings frame.
-    assert.deepStrictEqual(chunk.slice(0, 9), kSettings.data);
-    // The first ack is expected.
-    client.write(kSettingsAck.data, () => countdown.dec());
-    // The second one is not and will be ignored.
-    client.write(kSettingsAck.data, () => countdown.dec());
-  });
-
-  client.on('connect', common.mustCall(() => {
-    client.write(http2util.kClientMagic);
-    client.write(kSettings.data);
-  }));
-}));
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.on('remoteSettings', common.mustCall(() => countdown.dec()));
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    client = net.connect(server.address().port);
+
+    // Ensures that the clients settings frames are not sent until the
+    // servers are received, so that the first ack is actually expected.
+    client.once('data', (chunk) => {
+      // The very first chunk of data we get from the server should
+      // be a settings frame.
+      assert.deepStrictEqual(chunk.slice(0, 9), kSettings.data);
+      // The first ack is expected.
+      client.write(kSettingsAck.data, () => countdown.dec());
+      // The second one is not and will be ignored.
+      client.write(kSettingsAck.data, () => countdown.dec());
+    });
+
+    client.on(
+      'connect',
+      common.mustCall(() => {
+        client.write(http2util.kClientMagic);
+        client.write(kSettings.data);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-short-stream-client-server.js b/test/parallel/test-http2-short-stream-client-server.js
index e632b8d96b9ea9..7c70f00c560c42 100644
--- a/test/parallel/test-http2-short-stream-client-server.js
+++ b/test/parallel/test-http2-short-stream-client-server.js
@@ -1,55 +1,68 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const { Readable } = require('stream');
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.respond({
-    ':status': 200,
-    'content-type': 'text/html'
-  });
-  const input = new Readable({
-    read() {
-      this.push('test');
-      this.push(null);
-    }
-  });
-  input.pipe(stream);
-}));
-
-
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const client = http2.connect(`http://localhost:${port}`);
-
-  const req = client.request();
-
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 200);
-    assert.strictEqual(headers['content-type'], 'text/html');
-  }));
-
-  let data = '';
-
-  const notCallClose = common.mustNotCall();
-
-  setTimeout(() => {
-    req.setEncoding('utf8');
-    req.removeListener('close', notCallClose);
-    req.on('close', common.mustCall(() => {
-      server.close();
-      client.close();
-    }));
-    req.on('data', common.mustCallAtLeast((d) => data += d));
-    req.on('end', common.mustCall(() => {
-      assert.strictEqual(data, 'test');
-    }));
-  }, common.platformTimeout(100));
-
-  req.on('close', notCallClose);
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond({
+      ':status': 200,
+      'content-type': 'text/html'
+    });
+    const input = new Readable({
+      read() {
+        this.push('test');
+        this.push(null);
+      }
+    });
+    input.pipe(stream);
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const client = http2.connect(`http://localhost:${port}`);
+
+    const req = client.request();
+
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers[':status'], 200);
+        assert.strictEqual(headers['content-type'], 'text/html');
+      })
+    );
+
+    let data = '';
+
+    const notCallClose = common.mustNotCall();
+
+    setTimeout(() => {
+      req.setEncoding('utf8');
+      req.removeListener('close', notCallClose);
+      req.on(
+        'close',
+        common.mustCall(() => {
+          server.close();
+          client.close();
+        })
+      );
+      req.on('data', common.mustCallAtLeast((d) => (data += d)));
+      req.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(data, 'test');
+        })
+      );
+    }, common.platformTimeout(100));
+
+    req.on('close', notCallClose);
+  })
+);
diff --git a/test/parallel/test-http2-single-headers.js b/test/parallel/test-http2-single-headers.js
index 37eaf8b17c8f28..374956dce62c56 100644
--- a/test/parallel/test-http2-single-headers.js
+++ b/test/parallel/test-http2-single-headers.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 const server = http2.createServer();
@@ -23,29 +22,29 @@ const singles = [
 
 server.on('stream', common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-
-  singles.forEach((i) => {
-    common.expectsError(
-      () => client.request({ [i]: 'abc', [i.toUpperCase()]: 'xyz' }),
-      {
-        code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
-        type: TypeError,
-        message: `Header field "${i}" must only have a single value`
-      }
-    );
-
-    common.expectsError(
-      () => client.request({ [i]: ['abc', 'xyz'] }),
-      {
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    singles.forEach((i) => {
+      common.expectsError(
+        () => client.request({ [i]: 'abc', [i.toUpperCase()]: 'xyz' }),
+        {
+          code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
+          type: TypeError,
+          message: `Header field "${i}" must only have a single value`
+        }
+      );
+
+      common.expectsError(() => client.request({ [i]: ['abc', 'xyz'] }), {
         code: 'ERR_HTTP2_HEADER_SINGLE_VALUE',
         type: TypeError,
         message: `Header field "${i}" must only have a single value`
-      }
-    );
-  });
+      });
+    });
 
-  server.close();
-  client.close();
-}));
+    server.close();
+    client.close();
+  })
+);
diff --git a/test/parallel/test-http2-socket-proxy.js b/test/parallel/test-http2-socket-proxy.js
index 600271fdeffc2e..51bd3579d21e9b 100644
--- a/test/parallel/test-http2-socket-proxy.js
+++ b/test/parallel/test-http2-socket-proxy.js
@@ -3,8 +3,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const net = require('net');
@@ -17,106 +16,122 @@ const { kTimeout } = require('internal/timers');
 const errMsg = {
   code: 'ERR_HTTP2_NO_SOCKET_MANIPULATION',
   type: Error,
-  message: 'HTTP/2 sockets should not be directly manipulated ' +
-           '(e.g. read and written)'
+  message:
+    'HTTP/2 sockets should not be directly manipulated ' +
+    '(e.g. read and written)'
 };
 
 const server = h2.createServer();
 
-server.on('stream', common.mustCall(function(stream, headers) {
-  const socket = stream.session.socket;
-  const session = stream.session;
-
-  assert.ok(socket instanceof net.Socket);
-
-  assert.strictEqual(socket.writable, true);
-  assert.strictEqual(socket.readable, true);
-  assert.strictEqual(typeof socket.address(), 'object');
-
-  socket.setTimeout(987);
-  assert.strictEqual(session[kTimeout]._idleTimeout, 987);
-
-  // The indentation is corrected depending on the depth.
-  let inspectedTimeout = util.inspect(session[kTimeout]);
-  assert(inspectedTimeout.includes('  _idlePrev: [TimersList]'));
-  assert(inspectedTimeout.includes('  _idleNext: [TimersList]'));
-  assert(!inspectedTimeout.includes('   _idleNext: [TimersList]'));
-
-  inspectedTimeout = util.inspect([ session[kTimeout] ]);
-  assert(inspectedTimeout.includes('    _idlePrev: [TimersList]'));
-  assert(inspectedTimeout.includes('    _idleNext: [TimersList]'));
-  assert(!inspectedTimeout.includes('     _idleNext: [TimersList]'));
-
-  const inspectedTimersList = util.inspect([[ session[kTimeout]._idlePrev ]]);
-  assert(inspectedTimersList.includes('      _idlePrev: [Timeout]'));
-  assert(inspectedTimersList.includes('      _idleNext: [Timeout]'));
-  assert(!inspectedTimersList.includes('       _idleNext: [Timeout]'));
-
-  common.expectsError(() => socket.destroy, errMsg);
-  common.expectsError(() => socket.emit, errMsg);
-  common.expectsError(() => socket.end, errMsg);
-  common.expectsError(() => socket.pause, errMsg);
-  common.expectsError(() => socket.read, errMsg);
-  common.expectsError(() => socket.resume, errMsg);
-  common.expectsError(() => socket.write, errMsg);
-  common.expectsError(() => socket.setEncoding, errMsg);
-  common.expectsError(() => socket.setKeepAlive, errMsg);
-  common.expectsError(() => socket.setNoDelay, errMsg);
-
-  common.expectsError(() => (socket.destroy = undefined), errMsg);
-  common.expectsError(() => (socket.emit = undefined), errMsg);
-  common.expectsError(() => (socket.end = undefined), errMsg);
-  common.expectsError(() => (socket.pause = undefined), errMsg);
-  common.expectsError(() => (socket.read = undefined), errMsg);
-  common.expectsError(() => (socket.resume = undefined), errMsg);
-  common.expectsError(() => (socket.write = undefined), errMsg);
-  common.expectsError(() => (socket.setEncoding = undefined), errMsg);
-  common.expectsError(() => (socket.setKeepAlive = undefined), errMsg);
-  common.expectsError(() => (socket.setNoDelay = undefined), errMsg);
-
-  // Resetting the socket listeners to their own value should not throw.
-  socket.on = socket.on;  // eslint-disable-line no-self-assign
-  socket.once = socket.once;  // eslint-disable-line no-self-assign
-
-  socket.unref();
-  assert.strictEqual(socket._handle.hasRef(), false);
-  socket.ref();
-  assert.strictEqual(socket._handle.hasRef(), true);
-
-  stream.respond();
-
-  socket.writable = 0;
-  socket.readable = 0;
-  assert.strictEqual(socket.writable, 0);
-  assert.strictEqual(socket.readable, 0);
-
-  stream.end();
-
-  // Setting socket properties sets the session properties correctly.
-  const fn = () => {};
-  socket.setTimeout = fn;
-  assert.strictEqual(session.setTimeout, fn);
-
-  socket.ref = fn;
-  assert.strictEqual(session.ref, fn);
-
-  socket.unref = fn;
-  assert.strictEqual(session.unref, fn);
-
-  stream.session.on('close', common.mustCall(() => {
-    assert.strictEqual(session.socket, undefined);
-  }));
-}));
-
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const client = h2.connect(url, common.mustCall(() => {
-    const request = client.request();
-    request.on('end', common.mustCall(() => {
-      client.close();
-      server.close();
-    }));
-    request.resume();
-  }));
-}));
+server.on(
+  'stream',
+  common.mustCall(function(stream, headers) {
+    const socket = stream.session.socket;
+    const session = stream.session;
+
+    assert.ok(socket instanceof net.Socket);
+
+    assert.strictEqual(socket.writable, true);
+    assert.strictEqual(socket.readable, true);
+    assert.strictEqual(typeof socket.address(), 'object');
+
+    socket.setTimeout(987);
+    assert.strictEqual(session[kTimeout]._idleTimeout, 987);
+
+    // The indentation is corrected depending on the depth.
+    let inspectedTimeout = util.inspect(session[kTimeout]);
+    assert(inspectedTimeout.includes('  _idlePrev: [TimersList]'));
+    assert(inspectedTimeout.includes('  _idleNext: [TimersList]'));
+    assert(!inspectedTimeout.includes('   _idleNext: [TimersList]'));
+
+    inspectedTimeout = util.inspect([session[kTimeout]]);
+    assert(inspectedTimeout.includes('    _idlePrev: [TimersList]'));
+    assert(inspectedTimeout.includes('    _idleNext: [TimersList]'));
+    assert(!inspectedTimeout.includes('     _idleNext: [TimersList]'));
+
+    const inspectedTimersList = util.inspect([[session[kTimeout]._idlePrev]]);
+    assert(inspectedTimersList.includes('      _idlePrev: [Timeout]'));
+    assert(inspectedTimersList.includes('      _idleNext: [Timeout]'));
+    assert(!inspectedTimersList.includes('       _idleNext: [Timeout]'));
+
+    common.expectsError(() => socket.destroy, errMsg);
+    common.expectsError(() => socket.emit, errMsg);
+    common.expectsError(() => socket.end, errMsg);
+    common.expectsError(() => socket.pause, errMsg);
+    common.expectsError(() => socket.read, errMsg);
+    common.expectsError(() => socket.resume, errMsg);
+    common.expectsError(() => socket.write, errMsg);
+    common.expectsError(() => socket.setEncoding, errMsg);
+    common.expectsError(() => socket.setKeepAlive, errMsg);
+    common.expectsError(() => socket.setNoDelay, errMsg);
+
+    common.expectsError(() => (socket.destroy = undefined), errMsg);
+    common.expectsError(() => (socket.emit = undefined), errMsg);
+    common.expectsError(() => (socket.end = undefined), errMsg);
+    common.expectsError(() => (socket.pause = undefined), errMsg);
+    common.expectsError(() => (socket.read = undefined), errMsg);
+    common.expectsError(() => (socket.resume = undefined), errMsg);
+    common.expectsError(() => (socket.write = undefined), errMsg);
+    common.expectsError(() => (socket.setEncoding = undefined), errMsg);
+    common.expectsError(() => (socket.setKeepAlive = undefined), errMsg);
+    common.expectsError(() => (socket.setNoDelay = undefined), errMsg);
+
+    // Resetting the socket listeners to their own value should not throw.
+    socket.on = socket.on; // eslint-disable-line no-self-assign
+    socket.once = socket.once; // eslint-disable-line no-self-assign
+
+    socket.unref();
+    assert.strictEqual(socket._handle.hasRef(), false);
+    socket.ref();
+    assert.strictEqual(socket._handle.hasRef(), true);
+
+    stream.respond();
+
+    socket.writable = 0;
+    socket.readable = 0;
+    assert.strictEqual(socket.writable, 0);
+    assert.strictEqual(socket.readable, 0);
+
+    stream.end();
+
+    // Setting socket properties sets the session properties correctly.
+    const fn = () => {};
+    socket.setTimeout = fn;
+    assert.strictEqual(session.setTimeout, fn);
+
+    socket.ref = fn;
+    assert.strictEqual(session.ref, fn);
+
+    socket.unref = fn;
+    assert.strictEqual(session.unref, fn);
+
+    stream.session.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(session.socket, undefined);
+      })
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    const url = `http://localhost:${port}`;
+    const client = h2.connect(
+      url,
+      common.mustCall(() => {
+        const request = client.request();
+        request.on(
+          'end',
+          common.mustCall(() => {
+            client.close();
+            server.close();
+          })
+        );
+        request.resume();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-status-code-invalid.js b/test/parallel/test-http2-status-code-invalid.js
index 3337aad32d7f70..aac21abf673b20 100644
--- a/test/parallel/test-http2-status-code-invalid.js
+++ b/test/parallel/test-http2-status-code-invalid.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -16,26 +15,37 @@ function expectsError(code) {
   });
 }
 
-server.on('stream', common.mustCall((stream) => {
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    // Anything lower than 100 and greater than 599 is rejected
+    [99, 700, 1000].forEach((i) => {
+      assert.throws(() => stream.respond({ ':status': i }), expectsError(i));
+    });
 
-  // Anything lower than 100 and greater than 599 is rejected
-  [ 99, 700, 1000 ].forEach((i) => {
-    assert.throws(() => stream.respond({ ':status': i }), expectsError(i));
-  });
-
-  stream.respond();
-  stream.end();
-}));
+    stream.respond();
+    stream.end();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 200);
-  }));
-  req.resume();
-  req.on('end', common.mustCall(() => {
-    server.close();
-    client.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    req.on(
+      'response',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers[':status'], 200);
+      })
+    );
+    req.resume();
+    req.on(
+      'end',
+      common.mustCall(() => {
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-status-code.js b/test/parallel/test-http2-status-code.js
index d3642b4ff0217f..7042d6d25f74f5 100644
--- a/test/parallel/test-http2-status-code.js
+++ b/test/parallel/test-http2-status-code.js
@@ -1,41 +1,48 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
-const codes = [ 200, 202, 300, 400, 404, 451, 500 ];
+const codes = [200, 202, 300, 400, 404, 451, 500];
 let test = 0;
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  const status = codes[test++];
-  stream.respond({ ':status': status }, { endStream: true });
-}, 7));
-
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    const status = codes[test++];
+    stream.respond({ ':status': status }, { endStream: true });
+  }, 7)
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    let remaining = codes.length;
+    function maybeClose() {
+      if (--remaining === 0) {
+        client.close();
+        server.close();
+      }
+    }
 
-  let remaining = codes.length;
-  function maybeClose() {
-    if (--remaining === 0) {
-      client.close();
-      server.close();
+    function doTest(expected) {
+      const req = client.request();
+      req.on(
+        'response',
+        common.mustCall((headers) => {
+          assert.strictEqual(headers[':status'], expected);
+        })
+      );
+      req.resume();
+      req.on('end', common.mustCall(maybeClose));
     }
-  }
-
-  function doTest(expected) {
-    const req = client.request();
-    req.on('response', common.mustCall((headers) => {
-      assert.strictEqual(headers[':status'], expected);
-    }));
-    req.resume();
-    req.on('end', common.mustCall(maybeClose));
-  }
-
-  for (let n = 0; n < codes.length; n++)
-    doTest(codes[n]);
-}));
+
+    for (let n = 0; n < codes.length; n++) doTest(codes[n]);
+  })
+);
diff --git a/test/parallel/test-http2-stream-client.js b/test/parallel/test-http2-stream-client.js
index 3e6c6b2a8a1b5e..961efa21cdb7ba 100644
--- a/test/parallel/test-http2-stream-client.js
+++ b/test/parallel/test-http2-stream-client.js
@@ -1,28 +1,36 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const util = require('util');
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  assert.strictEqual(stream.aborted, false);
-  const insp = util.inspect(stream);
-  assert.ok(/Http2Stream { id/.test(insp));
-  assert.ok(/  state:/.test(insp));
-  assert.ok(/  readableState:/.test(insp));
-  assert.ok(/  writableState:/.test(insp));
-  stream.end('ok');
-}));
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request();
-  req.resume();
-  req.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    assert.strictEqual(stream.aborted, false);
+    const insp = util.inspect(stream);
+    assert.ok(/Http2Stream { id/.test(insp));
+    assert.ok(/  state:/.test(insp));
+    assert.ok(/  readableState:/.test(insp));
+    assert.ok(/  writableState:/.test(insp));
+    stream.end('ok');
+  })
+);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request();
+    req.resume();
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-stream-destroy-event-order.js b/test/parallel/test-http2-stream-destroy-event-order.js
index 88e4a99f99eee3..a66abe84aed408 100644
--- a/test/parallel/test-http2-stream-destroy-event-order.js
+++ b/test/parallel/test-http2-stream-destroy-event-order.js
@@ -1,29 +1,46 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 
 let client;
 let req;
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.on('error', common.mustCall(() => {
-    stream.on('close', common.mustCall(() => {
-      server.close();
-    }));
-  }));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.on(
+      'error',
+      common.mustCall(() => {
+        stream.on(
+          'close',
+          common.mustCall(() => {
+            server.close();
+          })
+        );
+      })
+    );
 
-  req.close(2);
-}));
-server.listen(0, common.mustCall(() => {
-  client = http2.connect(`http://localhost:${server.address().port}`);
-  req = client.request();
-  req.resume();
-  req.on('error', common.mustCall(() => {
-    req.on('close', common.mustCall(() => {
-      client.close();
-    }));
-  }));
-}));
+    req.close(2);
+  })
+);
+server.listen(
+  0,
+  common.mustCall(() => {
+    client = http2.connect(`http://localhost:${server.address().port}`);
+    req = client.request();
+    req.resume();
+    req.on(
+      'error',
+      common.mustCall(() => {
+        req.on(
+          'close',
+          common.mustCall(() => {
+            client.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-timeouts.js b/test/parallel/test-http2-timeouts.js
index db5822776aea5e..4e149be793e662 100644
--- a/test/parallel/test-http2-timeouts.js
+++ b/test/parallel/test-http2-timeouts.js
@@ -1,60 +1,68 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const h2 = require('http2');
 
 const server = h2.createServer();
 
 // we use the lower-level API here
-server.on('stream', common.mustCall((stream) => {
-  stream.setTimeout(1, common.mustCall(() => {
-    stream.respond({ ':status': 200 });
-    stream.end('hello world');
-  }));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.setTimeout(
+      1,
+      common.mustCall(() => {
+        stream.respond({ ':status': 200 });
+        stream.end('hello world');
+      })
+    );
 
-  // check that expected errors are thrown with wrong args
-  common.expectsError(
-    () => stream.setTimeout('100'),
-    {
+    // check that expected errors are thrown with wrong args
+    common.expectsError(() => stream.setTimeout('100'), {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError,
       message:
         'The "msecs" argument must be of type number. Received type string'
-    }
-  );
-  common.expectsError(
-    () => stream.setTimeout(0, Symbol('test')),
-    {
+    });
+    common.expectsError(() => stream.setTimeout(0, Symbol('test')), {
       code: 'ERR_INVALID_CALLBACK',
       type: TypeError,
       message: 'Callback must be a function'
-    }
-  );
-  common.expectsError(
-    () => stream.setTimeout(100, {}),
-    {
+    });
+    common.expectsError(() => stream.setTimeout(100, {}), {
       code: 'ERR_INVALID_CALLBACK',
       type: TypeError,
       message: 'Callback must be a function'
-    }
-  );
-}));
+    });
+  })
+);
 server.listen(0);
 
-server.on('listening', common.mustCall(() => {
-  const client = h2.connect(`http://localhost:${server.address().port}`);
-  client.setTimeout(1, common.mustCall(() => {
-    const req = client.request({ ':path': '/' });
-    req.setTimeout(1, common.mustCall(() => {
-      req.on('response', common.mustCall());
-      req.resume();
-      req.on('end', common.mustCall(() => {
-        server.close();
-        client.close();
-      }));
-      req.end();
-    }));
-  }));
-}));
+server.on(
+  'listening',
+  common.mustCall(() => {
+    const client = h2.connect(`http://localhost:${server.address().port}`);
+    client.setTimeout(
+      1,
+      common.mustCall(() => {
+        const req = client.request({ ':path': '/' });
+        req.setTimeout(
+          1,
+          common.mustCall(() => {
+            req.on('response', common.mustCall());
+            req.resume();
+            req.on(
+              'end',
+              common.mustCall(() => {
+                server.close();
+                client.close();
+              })
+            );
+            req.end();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-tls-disconnect.js b/test/parallel/test-http2-tls-disconnect.js
index 2e635fe1376a51..e7ac486d21268c 100644
--- a/test/parallel/test-http2-tls-disconnect.js
+++ b/test/parallel/test-http2-tls-disconnect.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const child_process = require('child_process');
 const http2 = require('http2');
@@ -20,12 +19,12 @@ const server = http2.createSecureServer({ key, cert }, (request, response) => {
 // that just requires somebody to take the time and actually do it.
 server.listen(0, () => {
   const proc = child_process.spawn('h2load', [
-    '-n', '1000',
+    '-n',
+    '1000',
     `https://localhost:${server.address().port}/`
   ]);
   proc.on('error', (err) => {
-    if (err.code === 'ENOENT')
-      common.skip('no h2load');
+    if (err.code === 'ENOENT') common.skip('no h2load');
   });
   proc.on('exit', () => server.close());
   setTimeout(() => proc.kill(2), 100);
diff --git a/test/parallel/test-http2-too-large-headers.js b/test/parallel/test-http2-too-large-headers.js
index b62a41d05f5984..c73827c47abb90 100644
--- a/test/parallel/test-http2-too-large-headers.js
+++ b/test/parallel/test-http2-too-large-headers.js
@@ -1,32 +1,37 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const assert = require('assert');
-const {
-  NGHTTP2_ENHANCE_YOUR_CALM
-} = http2.constants;
+const { NGHTTP2_ENHANCE_YOUR_CALM } = http2.constants;
 
 const server = http2.createServer({ settings: { maxHeaderListSize: 100 } });
 server.on('stream', common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  client.on('remoteSettings', () => {
-    const req = client.request({ 'foo': 'a'.repeat(1000) });
-    req.on('error', common.expectsError({
-      code: 'ERR_HTTP2_STREAM_ERROR',
-      type: Error,
-      message: 'Stream closed with error code NGHTTP2_ENHANCE_YOUR_CALM'
-    }));
-    req.on('close', common.mustCall(() => {
-      assert.strictEqual(req.rstCode, NGHTTP2_ENHANCE_YOUR_CALM);
-      server.close();
-      client.close();
-    }));
-  });
-
-}));
+    client.on('remoteSettings', () => {
+      const req = client.request({ foo: 'a'.repeat(1000) });
+      req.on(
+        'error',
+        common.expectsError({
+          code: 'ERR_HTTP2_STREAM_ERROR',
+          type: Error,
+          message: 'Stream closed with error code NGHTTP2_ENHANCE_YOUR_CALM'
+        })
+      );
+      req.on(
+        'close',
+        common.mustCall(() => {
+          assert.strictEqual(req.rstCode, NGHTTP2_ENHANCE_YOUR_CALM);
+          server.close();
+          client.close();
+        })
+      );
+    });
+  })
+);
diff --git a/test/parallel/test-http2-too-many-headers.js b/test/parallel/test-http2-too-many-headers.js
index 6c8315c80ebf2f..011e5ecb9333ba 100644
--- a/test/parallel/test-http2-too-many-headers.js
+++ b/test/parallel/test-http2-too-many-headers.js
@@ -1,13 +1,10 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const assert = require('assert');
-const {
-  NGHTTP2_ENHANCE_YOUR_CALM
-} = http2.constants;
+const { NGHTTP2_ENHANCE_YOUR_CALM } = http2.constants;
 
 // By default, the maximum number of header fields allowed per
 // block is 128, including the HTTP pseudo-header fields. The
@@ -16,19 +13,27 @@ const {
 const server = http2.createServer({ maxHeaderListPairs: 0 });
 server.on('stream', common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-  const req = client.request({ foo: 'bar' });
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code NGHTTP2_ENHANCE_YOUR_CALM'
-  }));
-  req.on('close', common.mustCall(() => {
-    assert.strictEqual(req.rstCode, NGHTTP2_ENHANCE_YOUR_CALM);
-    server.close();
-    client.close();
-  }));
-
-}));
+    const req = client.request({ foo: 'bar' });
+    req.on(
+      'error',
+      common.expectsError({
+        code: 'ERR_HTTP2_STREAM_ERROR',
+        type: Error,
+        message: 'Stream closed with error code NGHTTP2_ENHANCE_YOUR_CALM'
+      })
+    );
+    req.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(req.rstCode, NGHTTP2_ENHANCE_YOUR_CALM);
+        server.close();
+        client.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-too-many-settings.js b/test/parallel/test-http2-too-many-settings.js
index acfd73ada68416..bc74f515a28810 100644
--- a/test/parallel/test-http2-too-many-settings.js
+++ b/test/parallel/test-http2-too-many-settings.js
@@ -4,18 +4,20 @@
 // settings frames will result in an error
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
 const maxOutstandingSettings = 2;
 
 function doTest(session) {
-  session.on('error', common.expectsError({
-    code: 'ERR_HTTP2_MAX_PENDING_SETTINGS_ACK',
-    type: Error
-  }));
+  session.on(
+    'error',
+    common.expectsError({
+      code: 'ERR_HTTP2_MAX_PENDING_SETTINGS_ACK',
+      type: Error
+    })
+  );
   for (let n = 0; n < maxOutstandingSettings; n++) {
     session.settings({ enablePush: false });
     assert.strictEqual(session.pendingSettingsAck, true);
@@ -27,24 +29,35 @@ function doTest(session) {
   server.on('stream', common.mustNotCall());
   server.once('session', common.mustCall((session) => doTest(session)));
 
-  server.listen(0, common.mustCall(() => {
-    const client = h2.connect(`http://localhost:${server.address().port}`);
-    client.on('error', common.expectsError({
-      code: 'ERR_HTTP2_SESSION_ERROR',
-      message: 'Session closed with error code 2',
-    }));
-    client.on('close', common.mustCall(() => server.close()));
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const client = h2.connect(`http://localhost:${server.address().port}`);
+      client.on(
+        'error',
+        common.expectsError({
+          code: 'ERR_HTTP2_SESSION_ERROR',
+          message: 'Session closed with error code 2'
+        })
+      );
+      client.on('close', common.mustCall(() => server.close()));
+    })
+  );
 }
 
 {
   const server = h2.createServer();
   server.on('stream', common.mustNotCall());
 
-  server.listen(0, common.mustCall(() => {
-    const client = h2.connect(`http://localhost:${server.address().port}`,
-                              { maxOutstandingSettings });
-    client.on('connect', () => doTest(client));
-    client.on('close', () => server.close());
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const client = h2.connect(
+        `http://localhost:${server.address().port}`,
+        { maxOutstandingSettings }
+      );
+      client.on('connect', () => doTest(client));
+      client.on('close', () => server.close());
+    })
+  );
 }
diff --git a/test/parallel/test-http2-too-many-streams.js b/test/parallel/test-http2-too-many-streams.js
index c4ed5d52c25832..637669333b25d3 100644
--- a/test/parallel/test-http2-too-many-streams.js
+++ b/test/parallel/test-http2-too-many-streams.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const Countdown = require('../common/countdown');
 const http2 = require('http2');
@@ -14,47 +13,59 @@ const server = http2.createServer({ settings: { maxConcurrentStreams: 1 } });
 
 let c = 0;
 
-server.on('stream', common.mustCall((stream) => {
-  // Because we only allow one open stream at a time,
-  // c should never be greater than 1.
-  assert.strictEqual(++c, 1);
-  stream.respond();
-  // Force some asynchronous stuff.
-  setImmediate(() => {
-    stream.end('ok');
-    assert.strictEqual(--c, 0);
-  });
-}, 3));
-
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-
-  const countdown = new Countdown(3, common.mustCall(() => {
-    server.close();
-    client.destroy();
-  }));
-
-  client.on('remoteSettings', common.mustCall(() => {
-    assert.strictEqual(client.remoteSettings.maxConcurrentStreams, 1);
-
-    {
-      const req = client.request();
-      req.resume();
-      req.on('close', () => {
-        countdown.dec();
-
-        setImmediate(() => {
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    // Because we only allow one open stream at a time,
+    // c should never be greater than 1.
+    assert.strictEqual(++c, 1);
+    stream.respond();
+    // Force some asynchronous stuff.
+    setImmediate(() => {
+      stream.end('ok');
+      assert.strictEqual(--c, 0);
+    });
+  }, 3)
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+
+    const countdown = new Countdown(
+      3,
+      common.mustCall(() => {
+        server.close();
+        client.destroy();
+      })
+    );
+
+    client.on(
+      'remoteSettings',
+      common.mustCall(() => {
+        assert.strictEqual(client.remoteSettings.maxConcurrentStreams, 1);
+
+        {
+          const req = client.request();
+          req.resume();
+          req.on('close', () => {
+            countdown.dec();
+
+            setImmediate(() => {
+              const req = client.request();
+              req.resume();
+              req.on('close', () => countdown.dec());
+            });
+          });
+        }
+
+        {
           const req = client.request();
           req.resume();
           req.on('close', () => countdown.dec());
-        });
-      });
-    }
-
-    {
-      const req = client.request();
-      req.resume();
-      req.on('close', () => countdown.dec());
-    }
-  }));
-}));
+        }
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-trailers.js b/test/parallel/test-http2-trailers.js
index bdc0931157ad58..7ff06e3a951cce 100644
--- a/test/parallel/test-http2-trailers.js
+++ b/test/parallel/test-http2-trailers.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 const body =
@@ -16,58 +15,65 @@ const server = h2.createServer();
 server.on('stream', common.mustCall(onStream));
 
 function onStream(stream, headers, flags) {
-  stream.on('trailers', common.mustCall((headers) => {
-    assert.strictEqual(headers[trailerKey], trailerValue);
-    stream.end(body);
-  }));
-  stream.respond({
-    'content-type': 'text/html',
-    ':status': 200
-  }, { waitForTrailers: true });
+  stream.on(
+    'trailers',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[trailerKey], trailerValue);
+      stream.end(body);
+    })
+  );
+  stream.respond(
+    {
+      'content-type': 'text/html',
+      ':status': 200
+    },
+    { waitForTrailers: true }
+  );
   stream.on('wantTrailers', () => {
     stream.sendTrailers({ [trailerKey]: trailerValue });
-    common.expectsError(
-      () => stream.sendTrailers({}),
-      {
-        code: 'ERR_HTTP2_TRAILERS_ALREADY_SENT',
-        type: Error
-      }
-    );
+    common.expectsError(() => stream.sendTrailers({}), {
+      code: 'ERR_HTTP2_TRAILERS_ALREADY_SENT',
+      type: Error
+    });
   });
 
-  common.expectsError(
-    () => stream.sendTrailers({}),
-    {
-      code: 'ERR_HTTP2_TRAILERS_NOT_READY',
-      type: Error
-    }
-  );
+  common.expectsError(() => stream.sendTrailers({}), {
+    code: 'ERR_HTTP2_TRAILERS_NOT_READY',
+    type: Error
+  });
 }
 
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  const client = h2.connect(`http://localhost:${this.address().port}`);
-  const req = client.request({ ':path': '/', ':method': 'POST' },
-                             { waitForTrailers: true });
-  req.on('wantTrailers', () => {
-    req.sendTrailers({ [trailerKey]: trailerValue });
-  });
-  req.on('data', common.mustCall());
-  req.on('trailers', common.mustCall((headers) => {
-    assert.strictEqual(headers[trailerKey], trailerValue);
-  }));
-  req.on('close', common.mustCall(() => {
-    common.expectsError(
-      () => req.sendTrailers({}),
-      {
-        code: 'ERR_HTTP2_INVALID_STREAM',
-        type: Error
-      }
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const client = h2.connect(`http://localhost:${this.address().port}`);
+    const req = client.request(
+      { ':path': '/', ':method': 'POST' },
+      { waitForTrailers: true }
     );
-    server.close();
-    client.close();
-  }));
-  req.end('data');
-
-}));
+    req.on('wantTrailers', () => {
+      req.sendTrailers({ [trailerKey]: trailerValue });
+    });
+    req.on('data', common.mustCall());
+    req.on(
+      'trailers',
+      common.mustCall((headers) => {
+        assert.strictEqual(headers[trailerKey], trailerValue);
+      })
+    );
+    req.on(
+      'close',
+      common.mustCall(() => {
+        common.expectsError(() => req.sendTrailers({}), {
+          code: 'ERR_HTTP2_INVALID_STREAM',
+          type: Error
+        });
+        server.close();
+        client.close();
+      })
+    );
+    req.end('data');
+  })
+);
diff --git a/test/parallel/test-http2-unbound-socket-proxy.js b/test/parallel/test-http2-unbound-socket-proxy.js
index 18881574f2c09b..a90f07cd978b2c 100644
--- a/test/parallel/test-http2-unbound-socket-proxy.js
+++ b/test/parallel/test-http2-unbound-socket-proxy.js
@@ -1,44 +1,63 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const http2 = require('http2');
 const net = require('net');
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  stream.respond();
-  stream.end('ok');
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respond();
+    stream.end('ok');
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const socket = client.socket;
-  const req = client.request();
-  req.resume();
-  req.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const socket = client.socket;
+    const req = client.request();
+    req.resume();
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
 
-    // Tests to make sure accessing the socket proxy fails with an
-    // informative error.
-    setImmediate(common.mustCall(() => {
-      common.expectsError(() => {
-        socket.example;
-      }, {
-        code: 'ERR_HTTP2_SOCKET_UNBOUND'
-      });
-      common.expectsError(() => {
-        socket.example = 1;
-      }, {
-        code: 'ERR_HTTP2_SOCKET_UNBOUND'
-      });
-      common.expectsError(() => {
-        socket instanceof net.Socket;
-      }, {
-        code: 'ERR_HTTP2_SOCKET_UNBOUND'
-      });
-    }));
-  }));
-}));
+        // Tests to make sure accessing the socket proxy fails with an
+        // informative error.
+        setImmediate(
+          common.mustCall(() => {
+            common.expectsError(
+              () => {
+                socket.example;
+              },
+              {
+                code: 'ERR_HTTP2_SOCKET_UNBOUND'
+              }
+            );
+            common.expectsError(
+              () => {
+                socket.example = 1;
+              },
+              {
+                code: 'ERR_HTTP2_SOCKET_UNBOUND'
+              }
+            );
+            common.expectsError(
+              () => {
+                socket instanceof net.Socket;
+              },
+              {
+                code: 'ERR_HTTP2_SOCKET_UNBOUND'
+              }
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-util-asserts.js b/test/parallel/test-http2-util-asserts.js
index 136c76cc049cdd..4d76045be2eec1 100644
--- a/test/parallel/test-http2-util-asserts.js
+++ b/test/parallel/test-http2-util-asserts.js
@@ -2,42 +2,26 @@
 'use strict';
 
 const common = require('../common');
-const {
-  assertIsObject,
-  assertWithinRange,
-} = require('internal/http2/util');
+const { assertIsObject, assertWithinRange } = require('internal/http2/util');
 
-[
-  undefined,
-  {},
-  Object.create(null),
-  new Date(),
-  new (class Foo {})()
-].forEach((input) => {
-  assertIsObject(input, 'foo', 'Object');
-});
+[undefined, {}, Object.create(null), new Date(), new class Foo {}()].forEach(
+  (input) => {
+    assertIsObject(input, 'foo', 'Object');
+  }
+);
 
-[
-  1,
-  false,
-  'hello',
-  NaN,
-  Infinity,
-  [],
-  [{}]
-].forEach((input) => {
-  common.expectsError(() => assertIsObject(input, 'foo', 'Object'),
-                      {
-                        code: 'ERR_INVALID_ARG_TYPE',
-                        message: 'The "foo" argument must be of type Object. ' +
-                                 `Received type ${typeof input}`
-                      });
+[1, false, 'hello', NaN, Infinity, [], [{}]].forEach((input) => {
+  common.expectsError(() => assertIsObject(input, 'foo', 'Object'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "foo" argument must be of type Object. ' +
+      `Received type ${typeof input}`
+  });
 });
 
 assertWithinRange('foo', 1, 0, 2);
 
-common.expectsError(() => assertWithinRange('foo', 1, 2, 3),
-                    {
-                      code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-                      message: 'Invalid value for setting "foo": 1'
-                    });
+common.expectsError(() => assertWithinRange('foo', 1, 2, 3), {
+  code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+  message: 'Invalid value for setting "foo": 1'
+});
diff --git a/test/parallel/test-http2-util-headers-list.js b/test/parallel/test-http2-util-headers-list.js
index 2402e01cbf329e..ae2621f8f16ce3 100644
--- a/test/parallel/test-http2-util-headers-list.js
+++ b/test/parallel/test-http2-util-headers-list.js
@@ -5,8 +5,7 @@
 // to pass to the internal binding layer and to build a header object.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const { mapToHeaders, toHeaderObject } = require('internal/http2/util');
 const { internalBinding } = require('internal/test/binding');
@@ -92,68 +91,137 @@ const {
 
 {
   const headers = {
-    'abc': 1,
+    abc: 1,
     ':status': 200,
     ':path': 'abc',
-    'xyz': [1, '2', { toString() { return '3'; } }, 4],
-    'foo': [],
-    'BAR': [1]
+    xyz: [
+      1,
+      '2',
+      {
+        toString() {
+          return '3';
+        }
+      },
+      4
+    ],
+    foo: [],
+    BAR: [1]
   };
 
-  assert.deepStrictEqual(
-    mapToHeaders(headers),
-    [ [ ':path', 'abc', ':status', '200', 'abc', '1', 'xyz', '1', 'xyz', '2',
-        'xyz', '3', 'xyz', '4', 'bar', '1', '' ].join('\0'), 8 ]
-  );
+  assert.deepStrictEqual(mapToHeaders(headers), [
+    [
+      ':path',
+      'abc',
+      ':status',
+      '200',
+      'abc',
+      '1',
+      'xyz',
+      '1',
+      'xyz',
+      '2',
+      'xyz',
+      '3',
+      'xyz',
+      '4',
+      'bar',
+      '1',
+      ''
+    ].join('\0'),
+    8
+  ]);
 }
 
 {
   const headers = {
-    'abc': 1,
+    abc: 1,
     ':path': 'abc',
     ':status': [200],
     ':authority': [],
-    'xyz': [1, 2, 3, 4]
+    xyz: [1, 2, 3, 4]
   };
 
-  assert.deepStrictEqual(
-    mapToHeaders(headers),
-    [ [ ':status', '200', ':path', 'abc', 'abc', '1', 'xyz', '1', 'xyz', '2',
-        'xyz', '3', 'xyz', '4', '' ].join('\0'), 7 ]
-  );
+  assert.deepStrictEqual(mapToHeaders(headers), [
+    [
+      ':status',
+      '200',
+      ':path',
+      'abc',
+      'abc',
+      '1',
+      'xyz',
+      '1',
+      'xyz',
+      '2',
+      'xyz',
+      '3',
+      'xyz',
+      '4',
+      ''
+    ].join('\0'),
+    7
+  ]);
 }
 
 {
   const headers = {
-    'abc': 1,
+    abc: 1,
     ':path': 'abc',
-    'xyz': [1, 2, 3, 4],
+    xyz: [1, 2, 3, 4],
     '': 1,
     ':status': 200,
     [Symbol('test')]: 1 // Symbol keys are ignored
   };
 
-  assert.deepStrictEqual(
-    mapToHeaders(headers),
-    [ [ ':status', '200', ':path', 'abc', 'abc', '1', 'xyz', '1', 'xyz', '2',
-        'xyz', '3', 'xyz', '4', '' ].join('\0'), 7 ]
-  );
+  assert.deepStrictEqual(mapToHeaders(headers), [
+    [
+      ':status',
+      '200',
+      ':path',
+      'abc',
+      'abc',
+      '1',
+      'xyz',
+      '1',
+      'xyz',
+      '2',
+      'xyz',
+      '3',
+      'xyz',
+      '4',
+      ''
+    ].join('\0'),
+    7
+  ]);
 }
 
 {
   // Only own properties are used
-  const base = { 'abc': 1 };
+  const base = { abc: 1 };
   const headers = Object.create(base);
   headers[':path'] = 'abc';
   headers.xyz = [1, 2, 3, 4];
   headers.foo = [];
   headers[':status'] = 200;
 
-  assert.deepStrictEqual(
-    mapToHeaders(headers),
-    [ [ ':status', '200', ':path', 'abc', 'xyz', '1', 'xyz', '2', 'xyz', '3',
-        'xyz', '4', '' ].join('\0'), 6 ]
-  );
+  assert.deepStrictEqual(mapToHeaders(headers), [
+    [
+      ':status',
+      '200',
+      ':path',
+      'abc',
+      'xyz',
+      '1',
+      'xyz',
+      '2',
+      'xyz',
+      '3',
+      'xyz',
+      '4',
+      ''
+    ].join('\0'),
+    6
+  ]);
 }
 
 {
@@ -162,17 +230,17 @@ const {
   const headers = {
     'set-cookie': ['foo=bar']
   };
-  assert.deepStrictEqual(
-    mapToHeaders(headers),
-    [ [ 'set-cookie', 'foo=bar', '' ].join('\0'), 1 ]
-  );
+  assert.deepStrictEqual(mapToHeaders(headers), [
+    ['set-cookie', 'foo=bar', ''].join('\0'),
+    1
+  ]);
 }
 
 {
   // pseudo-headers are only allowed a single value
   const headers = {
     ':status': 200,
-    ':statuS': 204,
+    ':statuS': 204
   };
 
   common.expectsError({
@@ -284,36 +352,43 @@ const {
   common.expectsError({
     code: 'ERR_HTTP2_INVALID_CONNECTION_HEADERS',
     name: 'TypeError [ERR_HTTP2_INVALID_CONNECTION_HEADERS]',
-    message: 'HTTP/1 Connection specific headers are forbidden: ' +
-             `"${name.toLowerCase()}"`
+    message:
+      'HTTP/1 Connection specific headers are forbidden: ' +
+      `"${name.toLowerCase()}"`
   })(mapToHeaders({ [name]: 'abc' }));
 });
 
 common.expectsError({
   code: 'ERR_HTTP2_INVALID_CONNECTION_HEADERS',
   name: 'TypeError [ERR_HTTP2_INVALID_CONNECTION_HEADERS]',
-  message: 'HTTP/1 Connection specific headers are forbidden: ' +
-           `"${HTTP2_HEADER_TE}"`
+  message:
+    'HTTP/1 Connection specific headers are forbidden: ' +
+    `"${HTTP2_HEADER_TE}"`
 })(mapToHeaders({ [HTTP2_HEADER_TE]: ['abc'] }));
 
 common.expectsError({
   code: 'ERR_HTTP2_INVALID_CONNECTION_HEADERS',
   name: 'TypeError [ERR_HTTP2_INVALID_CONNECTION_HEADERS]',
-  message: 'HTTP/1 Connection specific headers are forbidden: ' +
-           `"${HTTP2_HEADER_TE}"`
+  message:
+    'HTTP/1 Connection specific headers are forbidden: ' +
+    `"${HTTP2_HEADER_TE}"`
 })(mapToHeaders({ [HTTP2_HEADER_TE]: ['abc', 'trailers'] }));
 
 assert(!(mapToHeaders({ te: 'trailers' }) instanceof Error));
 assert(!(mapToHeaders({ te: ['trailers'] }) instanceof Error));
 
-
 {
   const rawHeaders = [
-    ':status', '200',
-    'cookie', 'foo',
-    'set-cookie', 'sc1',
-    'age', '10',
-    'x-multi', 'first'
+    ':status',
+    '200',
+    'cookie',
+    'foo',
+    'set-cookie',
+    'sc1',
+    'age',
+    '10',
+    'x-multi',
+    'first'
   ];
   const headers = toHeaderObject(rawHeaders);
   assert.strictEqual(headers[':status'], 200);
@@ -325,16 +400,26 @@ assert(!(mapToHeaders({ te: ['trailers'] }) instanceof Error));
 
 {
   const rawHeaders = [
-    ':status', '200',
-    ':status', '400',
-    'cookie', 'foo',
-    'cookie', 'bar',
-    'set-cookie', 'sc1',
-    'set-cookie', 'sc2',
-    'age', '10',
-    'age', '20',
-    'x-multi', 'first',
-    'x-multi', 'second'
+    ':status',
+    '200',
+    ':status',
+    '400',
+    'cookie',
+    'foo',
+    'cookie',
+    'bar',
+    'set-cookie',
+    'sc1',
+    'set-cookie',
+    'sc2',
+    'age',
+    '10',
+    'age',
+    '20',
+    'x-multi',
+    'first',
+    'x-multi',
+    'second'
   ];
   const headers = toHeaderObject(rawHeaders);
   assert.strictEqual(headers[':status'], 200);
diff --git a/test/parallel/test-http2-util-nghttp2error.js b/test/parallel/test-http2-util-nghttp2error.js
index 7a9009515b3234..93a9faa2da8833 100644
--- a/test/parallel/test-http2-util-nghttp2error.js
+++ b/test/parallel/test-http2-util-nghttp2error.js
@@ -5,12 +5,15 @@ const common = require('../common');
 const { strictEqual } = require('assert');
 const { NghttpError } = require('internal/http2/util');
 
-common.expectsError(() => {
-  const err = new NghttpError(-501);
-  strictEqual(err.errno, -501);
-  throw err;
-}, {
-  code: 'ERR_HTTP2_ERROR',
-  type: NghttpError,
-  message: 'Invalid argument'
-});
+common.expectsError(
+  () => {
+    const err = new NghttpError(-501);
+    strictEqual(err.errno, -501);
+    throw err;
+  },
+  {
+    code: 'ERR_HTTP2_ERROR',
+    type: NghttpError,
+    message: 'Invalid argument'
+  }
+);
diff --git a/test/parallel/test-http2-util-update-options-buffer.js b/test/parallel/test-http2-util-update-options-buffer.js
index d9cfa0784926ae..542a0ea1f056ef 100644
--- a/test/parallel/test-http2-util-update-options-buffer.js
+++ b/test/parallel/test-http2-util-update-options-buffer.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // Test coverage for the updateOptionsBuffer method used internally
 // by the http2 implementation.
diff --git a/test/parallel/test-http2-window-size.js b/test/parallel/test-http2-window-size.js
index 164a778e1f8c54..dd88101c98dfa6 100644
--- a/test/parallel/test-http2-window-size.js
+++ b/test/parallel/test-http2-window-size.js
@@ -6,8 +6,7 @@
 // on smaller / IoT platforms in case this poses problems for these targets.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const h2 = require('http2');
 
@@ -41,48 +40,64 @@ function run(buffers, initialWindowSize) {
     });
     server.listen(0);
 
-    server.on('listening', common.mustCall(function() {
-      const port = this.address().port;
+    server.on(
+      'listening',
+      common.mustCall(function() {
+        const port = this.address().port;
 
-      const client =
-        h2.connect({
-          authority: 'localhost',
-          protocol: 'http:',
-          port
-        }, {
-          settings: {
-            initialWindowSize
-          }
-        }).on('connect', common.mustCall(() => {
-          const req = client.request({
-            ':method': 'GET',
-            ':path': '/'
-          });
-          const responses = [];
-          req.on('data', (data) => {
-            responses.push(data);
-          });
-          req.on('end', common.mustCall(() => {
-            const actualBuffer = Buffer.concat(responses);
-            assert.strictEqual(Buffer.compare(actualBuffer, expectedBuffer), 0);
-            // shut down
-            client.close();
-            server.close(() => {
-              resolve();
-            });
-          }));
-          req.end();
-        }));
-    }));
+        const client = h2
+          .connect(
+            {
+              authority: 'localhost',
+              protocol: 'http:',
+              port
+            },
+            {
+              settings: {
+                initialWindowSize
+              }
+            }
+          )
+          .on(
+            'connect',
+            common.mustCall(() => {
+              const req = client.request({
+                ':method': 'GET',
+                ':path': '/'
+              });
+              const responses = [];
+              req.on('data', (data) => {
+                responses.push(data);
+              });
+              req.on(
+                'end',
+                common.mustCall(() => {
+                  const actualBuffer = Buffer.concat(responses);
+                  assert.strictEqual(
+                    Buffer.compare(actualBuffer, expectedBuffer),
+                    0
+                  );
+                  // shut down
+                  client.close();
+                  server.close(() => {
+                    resolve();
+                  });
+                })
+              );
+              req.end();
+            })
+          );
+      })
+    );
   });
 }
 
 const bufferValueRange = [0, 1, 2, 3];
 const buffersList = [
   bufferValueRange.map((a) => Buffer.alloc(1 << 4, a)),
-  bufferValueRange.map((a) => Buffer.alloc((1 << 8) - 1, a)),
-// Specifying too large of a value causes timeouts on some platforms
-//  bufferValueRange.map((a) => Buffer.alloc(1 << 17, a))
+  bufferValueRange.map((a) => Buffer.alloc((1 << 8) - 1, a))
+  // Specifying too large of a value causes timeouts on some platforms
+  //  bufferValueRange.map((a) => Buffer.alloc(1 << 17, a))
 ];
 const initialWindowSizeList = [
   1 << 4,
diff --git a/test/parallel/test-http2-write-callbacks.js b/test/parallel/test-http2-write-callbacks.js
index eca7f00ea7e292..a84b744e5053f3 100644
--- a/test/parallel/test-http2-write-callbacks.js
+++ b/test/parallel/test-http2-write-callbacks.js
@@ -3,35 +3,52 @@
 // Verifies that write callbacks are called
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const server = http2.createServer();
 
-server.on('stream', common.mustCall((stream) => {
-  stream.write('abc', common.mustCall(() => {
-    stream.end('xyz');
-  }));
-  let actual = '';
-  stream.setEncoding('utf8');
-  stream.on('data', (chunk) => actual += chunk);
-  stream.on('end', common.mustCall(() => assert.strictEqual(actual, 'abcxyz')));
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.write(
+      'abc',
+      common.mustCall(() => {
+        stream.end('xyz');
+      })
+    );
+    let actual = '';
+    stream.setEncoding('utf8');
+    stream.on('data', (chunk) => (actual += chunk));
+    stream.on(
+      'end',
+      common.mustCall(() => assert.strictEqual(actual, 'abcxyz'))
+    );
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  const req = client.request({ ':method': 'POST' });
-  req.write('abc', common.mustCall(() => {
-    req.end('xyz');
-  }));
-  let actual = '';
-  req.setEncoding('utf8');
-  req.on('data', (chunk) => actual += chunk);
-  req.on('end', common.mustCall(() => assert.strictEqual(actual, 'abcxyz')));
-  req.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    const req = client.request({ ':method': 'POST' });
+    req.write(
+      'abc',
+      common.mustCall(() => {
+        req.end('xyz');
+      })
+    );
+    let actual = '';
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => (actual += chunk));
+    req.on('end', common.mustCall(() => assert.strictEqual(actual, 'abcxyz')));
+    req.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-http2-write-empty-string.js b/test/parallel/test-http2-write-empty-string.js
index ea591176a47251..e8604267d23b75 100644
--- a/test/parallel/test-http2-write-empty-string.js
+++ b/test/parallel/test-http2-write-empty-string.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -17,25 +16,34 @@ const server = http2.createServer(function(request, response) {
   this.close();
 });
 
-server.listen(0, common.mustCall(function() {
-  const client = http2.connect(`http://localhost:${this.address().port}`);
-  const headers = { ':path': '/' };
-  const req = client.request(headers).setEncoding('ascii');
-
-  let res = '';
-
-  req.on('response', common.mustCall(function(headers) {
-    assert.strictEqual(headers[':status'], 200);
-  }));
-
-  req.on('data', (chunk) => {
-    res += chunk;
-  });
-
-  req.on('end', common.mustCall(function() {
-    assert.strictEqual(res, '1\n2\n3\n');
-    client.close();
-  }));
-
-  req.end();
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const client = http2.connect(`http://localhost:${this.address().port}`);
+    const headers = { ':path': '/' };
+    const req = client.request(headers).setEncoding('ascii');
+
+    let res = '';
+
+    req.on(
+      'response',
+      common.mustCall(function(headers) {
+        assert.strictEqual(headers[':status'], 200);
+      })
+    );
+
+    req.on('data', (chunk) => {
+      res += chunk;
+    });
+
+    req.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(res, '1\n2\n3\n');
+        client.close();
+      })
+    );
+
+    req.end();
+  })
+);
diff --git a/test/parallel/test-http2-write-finishes-after-stream-destroy.js b/test/parallel/test-http2-write-finishes-after-stream-destroy.js
index 3b2dd4bcd4e548..0992002fd4f1e1 100644
--- a/test/parallel/test-http2-write-finishes-after-stream-destroy.js
+++ b/test/parallel/test-http2-write-finishes-after-stream-destroy.js
@@ -1,8 +1,7 @@
 // Flags: --expose-gc
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 const makeDuplexPair = require('../common/duplexpair');
@@ -17,46 +16,58 @@ process.on('exit', global.gc);
   let serverSideHttp2Stream;
   let serverSideHttp2StreamDestroyed = false;
   const server = http2.createServer();
-  server.on('stream', common.mustCall((stream, headers) => {
-    serverSideHttp2Stream = stream;
-    stream.respond({
-      'content-type': 'text/html',
-      ':status': 200
-    });
-
-    const originalWrite = serverSide._write;
-    serverSide._write = (buf, enc, cb) => {
-      if (serverSideHttp2StreamDestroyed) {
-        serverSide.destroy();
-        serverSide.write = () => {};
-      } else {
-        setImmediate(() => {
-          originalWrite.call(serverSide, buf, enc, () => setImmediate(cb));
-        });
-      }
-    };
+  server.on(
+    'stream',
+    common.mustCall((stream, headers) => {
+      serverSideHttp2Stream = stream;
+      stream.respond({
+        'content-type': 'text/html',
+        ':status': 200
+      });
+
+      const originalWrite = serverSide._write;
+      serverSide._write = (buf, enc, cb) => {
+        if (serverSideHttp2StreamDestroyed) {
+          serverSide.destroy();
+          serverSide.write = () => {};
+        } else {
+          setImmediate(() => {
+            originalWrite.call(serverSide, buf, enc, () => setImmediate(cb));
+          });
+        }
+      };
 
-    // Enough data to fit into a single *session* window,
-    // not enough data to fit into a single *stream* window.
-    stream.write(Buffer.alloc(40000));
-  }));
+      // Enough data to fit into a single *session* window,
+      // not enough data to fit into a single *stream* window.
+      stream.write(Buffer.alloc(40000));
+    })
+  );
 
   server.emit('connection', serverSide);
 
-  const client = http2.connect('http://localhost:80', {
-    createConnection: common.mustCall(() => clientSide)
-  });
+  const client = http2.connect(
+    'http://localhost:80',
+    {
+      createConnection: common.mustCall(() => clientSide)
+    }
+  );
 
   const req = client.request({ ':path': '/' });
 
-  req.on('response', common.mustCall((headers) => {
-    assert.strictEqual(headers[':status'], 200);
-  }));
+  req.on(
+    'response',
+    common.mustCall((headers) => {
+      assert.strictEqual(headers[':status'], 200);
+    })
+  );
 
-  req.on('data', common.mustCallAtLeast(() => {
-    if (!serverSideHttp2StreamDestroyed) {
-      serverSideHttp2Stream.destroy();
-      serverSideHttp2StreamDestroyed = true;
-    }
-  }));
+  req.on(
+    'data',
+    common.mustCallAtLeast(() => {
+      if (!serverSideHttp2StreamDestroyed) {
+        serverSideHttp2Stream.destroy();
+        serverSideHttp2StreamDestroyed = true;
+      }
+    })
+  );
 }
diff --git a/test/parallel/test-http2-zero-length-write.js b/test/parallel/test-http2-zero-length-write.js
index 0b50715330a1c4..3c65613ca62ba7 100644
--- a/test/parallel/test-http2-zero-length-write.js
+++ b/test/parallel/test-http2-zero-length-write.js
@@ -1,22 +1,19 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
 const { Readable } = require('stream');
 
 function getSrc() {
-  const chunks = [ '', 'asdf', '', 'foo', '', 'bar', '' ];
+  const chunks = ['', 'asdf', '', 'foo', '', 'bar', ''];
   return new Readable({
     read() {
       const chunk = chunks.shift();
-      if (chunk !== undefined)
-        this.push(chunk);
-      else
-        this.push(null);
+      if (chunk !== undefined) this.push(chunk);
+      else this.push(null);
     }
   });
 }
@@ -24,29 +21,41 @@ function getSrc() {
 const expect = 'asdffoobar';
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream) => {
-  let actual = '';
-  stream.respond();
-  stream.resume();
-  stream.setEncoding('utf8');
-  stream.on('data', (chunk) => actual += chunk);
-  stream.on('end', common.mustCall(() => {
-    getSrc().pipe(stream);
-    assert.strictEqual(actual, expect);
-  }));
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    let actual = '';
+    stream.respond();
+    stream.resume();
+    stream.setEncoding('utf8');
+    stream.on('data', (chunk) => (actual += chunk));
+    stream.on(
+      'end',
+      common.mustCall(() => {
+        getSrc().pipe(stream);
+        assert.strictEqual(actual, expect);
+      })
+    );
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
-  let actual = '';
-  const req = client.request({ ':method': 'POST' });
-  req.on('response', common.mustCall());
-  req.setEncoding('utf8');
-  req.on('data', (chunk) => actual += chunk);
-  req.on('end', common.mustCall(() => {
-    assert.strictEqual(actual, expect);
-    server.close();
-    client.close();
-  }));
-  getSrc().pipe(req);
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
+    let actual = '';
+    const req = client.request({ ':method': 'POST' });
+    req.on('response', common.mustCall());
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => (actual += chunk));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(actual, expect);
+        server.close();
+        client.close();
+      })
+    );
+    getSrc().pipe(req);
+  })
+);
diff --git a/test/parallel/test-https-agent-additional-options.js b/test/parallel/test-https-agent-additional-options.js
index 1bbff96001202b..fdb5c7d6c660a5 100644
--- a/test/parallel/test-https-agent-additional-options.js
+++ b/test/parallel/test-https-agent-additional-options.js
@@ -1,8 +1,7 @@
 // Flags: --tls-v1.1
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -26,7 +25,7 @@ function getBaseOptions(port) {
     port: port,
     ca: options.ca,
     rejectUnauthorized: true,
-    servername: 'agent1',
+    servername: 'agent1'
   };
 }
 
@@ -36,7 +35,7 @@ const updatedValues = new Map([
   ['honorCipherOrder', true],
   ['secureOptions', crypto.constants.SSL_OP_CIPHER_SERVER_PREFERENCE],
   ['secureProtocol', 'TLSv1_1_method'],
-  ['sessionIdContext', 'sessionIdContext'],
+  ['sessionIdContext', 'sessionIdContext']
 ]);
 
 function variations(iter, port, cb) {
@@ -47,42 +46,54 @@ function variations(iter, port, cb) {
     const [key, val] = value;
     return common.mustCall(function(res) {
       res.resume();
-      https.globalAgent.once('free', common.mustCall(function() {
-        https.get(
-          Object.assign({}, getBaseOptions(port), { [key]: val }),
-          variations(iter, port, cb)
-        );
-      }));
+      https.globalAgent.once(
+        'free',
+        common.mustCall(function() {
+          https.get(
+            Object.assign({}, getBaseOptions(port), { [key]: val }),
+            variations(iter, port, cb)
+          );
+        })
+      );
     });
   }
 }
 
-server.listen(0, common.mustCall(function() {
-  const port = this.address().port;
-  const globalAgent = https.globalAgent;
-  globalAgent.keepAlive = true;
-  https.get(getBaseOptions(port), variations(
-    updatedValues.entries(),
-    port,
-    common.mustCall(function(res) {
-      res.resume();
-      globalAgent.once('free', common.mustCall(function() {
-        // Verify that different keep-alived connections are created
-        // for the base call and each variation
-        const keys = Object.keys(globalAgent.freeSockets);
-        assert.strictEqual(keys.length, 1 + updatedValues.size);
-        let i = 1;
-        for (const [, value] of updatedValues) {
-          assert.ok(
-            keys[i].startsWith(value.toString() + ':') ||
-            keys[i].endsWith(':' + value.toString()) ||
-            keys[i].includes(':' + value.toString() + ':')
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = this.address().port;
+    const globalAgent = https.globalAgent;
+    globalAgent.keepAlive = true;
+    https.get(
+      getBaseOptions(port),
+      variations(
+        updatedValues.entries(),
+        port,
+        common.mustCall(function(res) {
+          res.resume();
+          globalAgent.once(
+            'free',
+            common.mustCall(function() {
+              // Verify that different keep-alived connections are created
+              // for the base call and each variation
+              const keys = Object.keys(globalAgent.freeSockets);
+              assert.strictEqual(keys.length, 1 + updatedValues.size);
+              let i = 1;
+              for (const [, value] of updatedValues) {
+                assert.ok(
+                  keys[i].startsWith(value.toString() + ':') ||
+                    keys[i].endsWith(':' + value.toString()) ||
+                    keys[i].includes(':' + value.toString() + ':')
+                );
+                i++;
+              }
+              globalAgent.destroy();
+              server.close();
+            })
           );
-          i++;
-        }
-        globalAgent.destroy();
-        server.close();
-      }));
-    })
-  ));
-}));
+        })
+      )
+    );
+  })
+);
diff --git a/test/parallel/test-https-agent-constructor.js b/test/parallel/test-https-agent-constructor.js
index 69156ba0f64de9..b42a9369aab349 100644
--- a/test/parallel/test-https-agent-constructor.js
+++ b/test/parallel/test-https-agent-constructor.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
diff --git a/test/parallel/test-https-agent-create-connection.js b/test/parallel/test-https-agent-create-connection.js
index 5dcf73cc76d6aa..42083f30346723 100644
--- a/test/parallel/test-https-agent-create-connection.js
+++ b/test/parallel/test-https-agent-create-connection.js
@@ -2,8 +2,7 @@
 
 const common = require('../common');
 const fixtures = require('../common/fixtures');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -12,7 +11,7 @@ const agent = new https.Agent();
 
 const options = {
   key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
 };
 
 const expectedHeader = /^HTTP\/1\.1 200 OK/;
@@ -21,18 +20,27 @@ const expectCertError = /^Error: unable to verify the first certificate$/;
 
 const checkRequest = (socket, server) => {
   let result = '';
-  socket.on('connect', common.mustCall((data) => {
-    socket.write('GET / HTTP/1.1\r\n\r\n');
-    socket.end();
-  }));
-  socket.on('data', common.mustCall((chunk) => {
-    result += chunk;
-  }));
-  socket.on('end', common.mustCall(() => {
-    assert(expectedHeader.test(result));
-    assert(expectedBody.test(result));
-    server.close();
-  }));
+  socket.on(
+    'connect',
+    common.mustCall((data) => {
+      socket.write('GET / HTTP/1.1\r\n\r\n');
+      socket.end();
+    })
+  );
+  socket.on(
+    'data',
+    common.mustCall((chunk) => {
+      result += chunk;
+    })
+  );
+  socket.on(
+    'end',
+    common.mustCall(() => {
+      assert(expectedHeader.test(result));
+      assert(expectedBody.test(result));
+      server.close();
+    })
+  );
 };
 
 function createServer() {
@@ -44,91 +52,115 @@ function createServer() {
 // use option connect
 {
   const server = createServer();
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const host = 'localhost';
-    const options = {
-      port: port,
-      host: host,
-      rejectUnauthorized: false,
-      _agentKey: agent.getName({ port, host })
-    };
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const host = 'localhost';
+      const options = {
+        port: port,
+        host: host,
+        rejectUnauthorized: false,
+        _agentKey: agent.getName({ port, host })
+      };
 
-    const socket = agent.createConnection(options);
-    checkRequest(socket, server);
-  }));
+      const socket = agent.createConnection(options);
+      checkRequest(socket, server);
+    })
+  );
 }
 
 // use port and option connect
 {
   const server = createServer();
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const host = 'localhost';
-    const options = {
-      rejectUnauthorized: false,
-      _agentKey: agent.getName({ port, host })
-    };
-    const socket = agent.createConnection(port, options);
-    checkRequest(socket, server);
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const host = 'localhost';
+      const options = {
+        rejectUnauthorized: false,
+        _agentKey: agent.getName({ port, host })
+      };
+      const socket = agent.createConnection(port, options);
+      checkRequest(socket, server);
+    })
+  );
 }
 
 // use port and host and option connect
 {
   const server = createServer();
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const host = 'localhost';
-    const options = {
-      rejectUnauthorized: false,
-      _agentKey: agent.getName({ port, host })
-    };
-    const socket = agent.createConnection(port, host, options);
-    checkRequest(socket, server);
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const host = 'localhost';
+      const options = {
+        rejectUnauthorized: false,
+        _agentKey: agent.getName({ port, host })
+      };
+      const socket = agent.createConnection(port, host, options);
+      checkRequest(socket, server);
+    })
+  );
 }
 
 // use port and host and option does not have agentKey
 {
   const server = createServer();
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const host = 'localhost';
-    const options = {
-      rejectUnauthorized: false,
-    };
-    const socket = agent.createConnection(port, host, options);
-    checkRequest(socket, server);
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const host = 'localhost';
+      const options = {
+        rejectUnauthorized: false
+      };
+      const socket = agent.createConnection(port, host, options);
+      checkRequest(socket, server);
+    })
+  );
 }
 
 // options is null
 {
   const server = createServer();
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const host = 'localhost';
-    const options = null;
-    const socket = agent.createConnection(port, host, options);
-    socket.on('error', common.mustCall((e) => {
-      assert(expectCertError.test(e.toString()));
-      server.close();
-    }));
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const host = 'localhost';
+      const options = null;
+      const socket = agent.createConnection(port, host, options);
+      socket.on(
+        'error',
+        common.mustCall((e) => {
+          assert(expectCertError.test(e.toString()));
+          server.close();
+        })
+      );
+    })
+  );
 }
 
 // options is undefined
 {
   const server = createServer();
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const host = 'localhost';
-    const options = undefined;
-    const socket = agent.createConnection(port, host, options);
-    socket.on('error', common.mustCall((e) => {
-      assert(expectCertError.test(e.toString()));
-      server.close();
-    }));
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const host = 'localhost';
+      const options = undefined;
+      const socket = agent.createConnection(port, host, options);
+      socket.on(
+        'error',
+        common.mustCall((e) => {
+          assert(expectCertError.test(e.toString()));
+          server.close();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-https-agent-disable-session-reuse.js b/test/parallel/test-https-agent-disable-session-reuse.js
index b3d0327f59b1ad..b622da80f6b5e9 100644
--- a/test/parallel/test-https-agent-disable-session-reuse.js
+++ b/test/parallel/test-https-agent-disable-session-reuse.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
@@ -23,35 +22,40 @@ const agent = new https.Agent({
   maxCachedSessions: 0
 });
 
-const server = https.createServer(options, function(req, res) {
-  serverRequests++;
-  res.end('ok');
-}).listen(0, function() {
-  let waiting = TOTAL_REQS;
-  function request() {
-    const options = {
-      agent: agent,
-      port: server.address().port,
-      rejectUnauthorized: false
-    };
-
-    https.request(options, function(res) {
-      clientSessions.push(res.socket.getSession());
-
-      res.resume();
-      res.on('end', function() {
-        if (--waiting !== 0)
-          return request();
-        server.close();
-      });
-    }).end();
-  }
-  request();
-});
+const server = https
+  .createServer(options, function(req, res) {
+    serverRequests++;
+    res.end('ok');
+  })
+  .listen(0, function() {
+    let waiting = TOTAL_REQS;
+    function request() {
+      const options = {
+        agent: agent,
+        port: server.address().port,
+        rejectUnauthorized: false
+      };
+
+      https
+        .request(options, function(res) {
+          clientSessions.push(res.socket.getSession());
+
+          res.resume();
+          res.on('end', function() {
+            if (--waiting !== 0) return request();
+            server.close();
+          });
+        })
+        .end();
+    }
+    request();
+  });
 
 process.on('exit', function() {
   assert.strictEqual(serverRequests, TOTAL_REQS);
   assert.strictEqual(clientSessions.length, TOTAL_REQS);
-  assert.notStrictEqual(clientSessions[0].toString('hex'),
-                        clientSessions[1].toString('hex'));
+  assert.notStrictEqual(
+    clientSessions[0].toString('hex'),
+    clientSessions[1].toString('hex')
+  );
 });
diff --git a/test/parallel/test-https-agent-getname.js b/test/parallel/test-https-agent-getname.js
index b68850f21d57ca..f0d65ccbf874f8 100644
--- a/test/parallel/test-https-agent-getname.js
+++ b/test/parallel/test-https-agent-getname.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -10,10 +9,7 @@ const https = require('https');
 const agent = new https.Agent();
 
 // empty options
-assert.strictEqual(
-  agent.getName({}),
-  'localhost:::::::::::::::::'
-);
+assert.strictEqual(agent.getName({}), 'localhost:::::::::::::::::');
 
 // pass all options arguments
 const options = {
diff --git a/test/parallel/test-https-agent-servername.js b/test/parallel/test-https-agent-servername.js
index df14d113994f89..038c6cbc828440 100644
--- a/test/parallel/test-https-agent-servername.js
+++ b/test/parallel/test-https-agent-servername.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const https = require('https');
 const fixtures = require('../common/fixtures');
@@ -13,26 +12,29 @@ const options = {
   ca: fixtures.readKey('ca1-cert.pem')
 };
 
-
 const server = https.Server(options, function(req, res) {
   res.writeHead(200);
   res.end('hello world\n');
 });
 
-
 server.listen(0, function() {
-  https.get({
-    path: '/',
-    port: this.address().port,
-    rejectUnauthorized: true,
-    servername: 'agent1',
-    ca: options.ca
-  }, function(res) {
-    res.resume();
-    console.log(res.statusCode);
-    server.close();
-  }).on('error', function(e) {
-    console.log(e.message);
-    process.exit(1);
-  });
+  https
+    .get(
+      {
+        path: '/',
+        port: this.address().port,
+        rejectUnauthorized: true,
+        servername: 'agent1',
+        ca: options.ca
+      },
+      function(res) {
+        res.resume();
+        console.log(res.statusCode);
+        server.close();
+      }
+    )
+    .on('error', function(e) {
+      console.log(e.message);
+      process.exit(1);
+    });
 });
diff --git a/test/parallel/test-https-agent-session-eviction.js b/test/parallel/test-https-agent-session-eviction.js
index 785f4737bddb27..b1dfdaace07396 100644
--- a/test/parallel/test-https-agent-session-eviction.js
+++ b/test/parallel/test-https-agent-session-eviction.js
@@ -4,13 +4,14 @@
 const common = require('../common');
 const { readKey } = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
-const { OPENSSL_VERSION_NUMBER, SSL_OP_NO_TICKET } =
-    require('crypto').constants;
+const {
+  OPENSSL_VERSION_NUMBER,
+  SSL_OP_NO_TICKET
+} = require('crypto').constants;
 
 const options = {
   key: readKey('agent1-key.pem'),
@@ -19,79 +20,98 @@ const options = {
 };
 
 // Create TLS1.2 server
-https.createServer(options, function(req, res) {
-  res.end('ohai');
-}).listen(0, function() {
-  first(this);
-});
+https
+  .createServer(options, function(req, res) {
+    res.end('ohai');
+  })
+  .listen(0, function() {
+    first(this);
+  });
 
 // Do request and let agent cache the session
 function first(server) {
   const port = server.address().port;
-  const req = https.request({
-    port: port,
-    rejectUnauthorized: false
-  }, function(res) {
-    res.resume();
+  const req = https.request(
+    {
+      port: port,
+      rejectUnauthorized: false
+    },
+    function(res) {
+      res.resume();
 
-    server.close(function() {
-      faultyServer(port);
-    });
-  });
+      server.close(function() {
+        faultyServer(port);
+      });
+    }
+  );
   req.end();
 }
 
 // Create TLS1 server
 function faultyServer(port) {
   options.secureProtocol = 'TLSv1_method';
-  https.createServer(options, function(req, res) {
-    res.end('hello faulty');
-  }).listen(port, function() {
-    second(this);
-  });
+  https
+    .createServer(options, function(req, res) {
+      res.end('hello faulty');
+    })
+    .listen(port, function() {
+      second(this);
+    });
 }
 
 // Attempt to request using cached session
 function second(server, session) {
-  const req = https.request({
-    port: server.address().port,
-    rejectUnauthorized: false
-  }, function(res) {
-    res.resume();
-  });
+  const req = https.request(
+    {
+      port: server.address().port,
+      rejectUnauthorized: false
+    },
+    function(res) {
+      res.resume();
+    }
+  );
 
   if (OPENSSL_VERSION_NUMBER >= 0x10100000) {
     // Although we have a TLS 1.2 session to offer to the TLS 1.0 server,
     // connection to the TLS 1.0 server should work.
-    req.on('response', common.mustCall(function(res) {
-      // The test is now complete for OpenSSL 1.1.0.
-      server.close();
-    }));
+    req.on(
+      'response',
+      common.mustCall(function(res) {
+        // The test is now complete for OpenSSL 1.1.0.
+        server.close();
+      })
+    );
   } else {
     // OpenSSL 1.0.x mistakenly locked versions based on the session it was
     // offering. This causes this sequent request to fail. Let it fail, but
     // test that this is mitigated on the next try by invalidating the session.
-    req.on('error', common.mustCall(function(err) {
-      assert(/wrong version number/.test(err.message));
+    req.on(
+      'error',
+      common.mustCall(function(err) {
+        assert(/wrong version number/.test(err.message));
 
-      req.on('close', function() {
-        third(server);
-      });
-    }));
+        req.on('close', function() {
+          third(server);
+        });
+      })
+    );
   }
   req.end();
 }
 
 // Try one more time - session should be evicted!
 function third(server) {
-  const req = https.request({
-    port: server.address().port,
-    rejectUnauthorized: false
-  }, function(res) {
-    res.resume();
-    assert(!req.socket.isSessionReused());
-    server.close();
-  });
+  const req = https.request(
+    {
+      port: server.address().port,
+      rejectUnauthorized: false
+    },
+    function(res) {
+      res.resume();
+      assert(!req.socket.isSessionReused());
+      server.close();
+    }
+  );
   req.on('error', common.mustNotCall());
   req.end();
 }
diff --git a/test/parallel/test-https-agent-session-reuse.js b/test/parallel/test-https-agent-session-reuse.js
index 0717a3f8165d67..62d1e689654d17 100644
--- a/test/parallel/test-https-agent-session-reuse.js
+++ b/test/parallel/test-https-agent-session-reuse.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const assert = require('assert');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const https = require('https');
 const crypto = require('crypto');
@@ -23,105 +22,119 @@ const agent = new https.Agent({
   maxCachedSessions: 1
 });
 
-const server = https.createServer(options, function(req, res) {
-  if (req.url === '/drop-key')
-    server.setTicketKeys(crypto.randomBytes(48));
-
-  serverRequests++;
-  res.end('ok');
-}).listen(0, function() {
-  const queue = [
-    {
-      name: 'first',
-
-      method: 'GET',
-      path: '/',
-      servername: 'agent1',
-      ca: ca,
-      port: this.address().port
-    },
-    {
-      name: 'first-reuse',
-
-      method: 'GET',
-      path: '/',
-      servername: 'agent1',
-      ca: ca,
-      port: this.address().port
-    },
-    {
-      name: 'cipher-change',
-
-      method: 'GET',
-      path: '/',
-      servername: 'agent1',
-
-      // Choose different cipher to use different cache entry
-      ciphers: 'AES256-SHA',
-      ca: ca,
-      port: this.address().port
-    },
-    // Change the ticket key to ensure session is updated in cache
-    {
-      name: 'before-drop',
-
-      method: 'GET',
-      path: '/drop-key',
-      servername: 'agent1',
-      ca: ca,
-      port: this.address().port
-    },
-
-    // Ticket will be updated starting from this
-    {
-      name: 'after-drop',
-
-      method: 'GET',
-      path: '/',
-      servername: 'agent1',
-      ca: ca,
-      port: this.address().port
-    },
-    {
-      name: 'after-drop-reuse',
-
-      method: 'GET',
-      path: '/',
-      servername: 'agent1',
-      ca: ca,
-      port: this.address().port
+const server = https
+  .createServer(options, function(req, res) {
+    if (req.url === '/drop-key') server.setTicketKeys(crypto.randomBytes(48));
+
+    serverRequests++;
+    res.end('ok');
+  })
+  .listen(0, function() {
+    const queue = [
+      {
+        name: 'first',
+
+        method: 'GET',
+        path: '/',
+        servername: 'agent1',
+        ca: ca,
+        port: this.address().port
+      },
+      {
+        name: 'first-reuse',
+
+        method: 'GET',
+        path: '/',
+        servername: 'agent1',
+        ca: ca,
+        port: this.address().port
+      },
+      {
+        name: 'cipher-change',
+
+        method: 'GET',
+        path: '/',
+        servername: 'agent1',
+
+        // Choose different cipher to use different cache entry
+        ciphers: 'AES256-SHA',
+        ca: ca,
+        port: this.address().port
+      },
+      // Change the ticket key to ensure session is updated in cache
+      {
+        name: 'before-drop',
+
+        method: 'GET',
+        path: '/drop-key',
+        servername: 'agent1',
+        ca: ca,
+        port: this.address().port
+      },
+
+      // Ticket will be updated starting from this
+      {
+        name: 'after-drop',
+
+        method: 'GET',
+        path: '/',
+        servername: 'agent1',
+        ca: ca,
+        port: this.address().port
+      },
+      {
+        name: 'after-drop-reuse',
+
+        method: 'GET',
+        path: '/',
+        servername: 'agent1',
+        ca: ca,
+        port: this.address().port
+      }
+    ];
+
+    function request() {
+      const options = queue.shift();
+      options.agent = agent;
+      https
+        .request(options, function(res) {
+          clientSessions[options.name] = res.socket.getSession();
+
+          res.resume();
+          res.on('end', function() {
+            if (queue.length !== 0) return request();
+            server.close();
+          });
+        })
+        .end();
     }
-  ];
-
-  function request() {
-    const options = queue.shift();
-    options.agent = agent;
-    https.request(options, function(res) {
-      clientSessions[options.name] = res.socket.getSession();
-
-      res.resume();
-      res.on('end', function() {
-        if (queue.length !== 0)
-          return request();
-        server.close();
-      });
-    }).end();
-  }
-  request();
-});
+    request();
+  });
 
 process.on('exit', function() {
   assert.strictEqual(serverRequests, 6);
-  assert.strictEqual(clientSessions.first.toString('hex'),
-                     clientSessions['first-reuse'].toString('hex'));
-  assert.notStrictEqual(clientSessions.first.toString('hex'),
-                        clientSessions['cipher-change'].toString('hex'));
-  assert.notStrictEqual(clientSessions.first.toString('hex'),
-                        clientSessions['before-drop'].toString('hex'));
-  assert.notStrictEqual(clientSessions['cipher-change'].toString('hex'),
-                        clientSessions['before-drop'].toString('hex'));
-  assert.notStrictEqual(clientSessions['before-drop'].toString('hex'),
-                        clientSessions['after-drop'].toString('hex'));
-  assert.strictEqual(clientSessions['after-drop'].toString('hex'),
-                     clientSessions['after-drop-reuse'].toString('hex'));
+  assert.strictEqual(
+    clientSessions.first.toString('hex'),
+    clientSessions['first-reuse'].toString('hex')
+  );
+  assert.notStrictEqual(
+    clientSessions.first.toString('hex'),
+    clientSessions['cipher-change'].toString('hex')
+  );
+  assert.notStrictEqual(
+    clientSessions.first.toString('hex'),
+    clientSessions['before-drop'].toString('hex')
+  );
+  assert.notStrictEqual(
+    clientSessions['cipher-change'].toString('hex'),
+    clientSessions['before-drop'].toString('hex')
+  );
+  assert.notStrictEqual(
+    clientSessions['before-drop'].toString('hex'),
+    clientSessions['after-drop'].toString('hex')
+  );
+  assert.strictEqual(
+    clientSessions['after-drop'].toString('hex'),
+    clientSessions['after-drop-reuse'].toString('hex')
+  );
 });
diff --git a/test/parallel/test-https-agent-sni.js b/test/parallel/test-https-agent-sni.js
index 80278ed2d8fe96..6d2bd10c73266b 100644
--- a/test/parallel/test-https-agent-sni.js
+++ b/test/parallel/test-https-agent-sni.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 const fixtures = require('../common/fixtures');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -36,14 +35,17 @@ server.listen(0, function() {
     maxSockets: 1
   });
   for (let j = 0; j < TOTAL; j++) {
-    https.get({
-      agent: agent,
-
-      path: '/',
-      port: this.address().port,
-      host: '127.0.0.1',
-      servername: `sni.${j}`,
-      rejectUnauthorized: false
-    }, expectResponse(j));
+    https.get(
+      {
+        agent: agent,
+
+        path: '/',
+        port: this.address().port,
+        host: '127.0.0.1',
+        servername: `sni.${j}`,
+        rejectUnauthorized: false
+      },
+      expectResponse(j)
+    );
   }
 });
diff --git a/test/parallel/test-https-agent-sockets-leak.js b/test/parallel/test-https-agent-sockets-leak.js
index 15409d33dbd86a..678c1496b35fe0 100644
--- a/test/parallel/test-https-agent-sockets-leak.js
+++ b/test/parallel/test-https-agent-sockets-leak.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const https = require('https');
 const assert = require('assert');
@@ -14,37 +13,49 @@ const options = {
   ca: fixtures.readKey('ca1-cert.pem')
 };
 
-const server = https.Server(options, common.mustCall((req, res) => {
-  res.writeHead(200);
-  res.end('https\n');
-}));
+const server = https.Server(
+  options,
+  common.mustCall((req, res) => {
+    res.writeHead(200);
+    res.end('https\n');
+  })
+);
 
 const agent = new https.Agent({
   keepAlive: false
 });
 
-server.listen(0, common.mustCall(() => {
-  https.get({
-    host: server.address().host,
-    port: server.address().port,
-    headers: { host: 'agent1' },
-    rejectUnauthorized: true,
-    ca: options.ca,
-    agent: agent
-  }, common.mustCall((res) => {
-    res.resume();
-    server.close();
-
-    // Only one entry should exist in agent.sockets pool
-    // If there are more entries in agent.sockets,
-    // removeSocket will not delete them resulting in a resource leak
-    assert.strictEqual(Object.keys(agent.sockets).length, 1);
-
-    res.req.on('close', common.mustCall(() => {
-      // To verify that no leaks occur, check that no entries
-      // exist in agent.sockets pool after both request and socket
-      // has been closed.
-      assert.strictEqual(Object.keys(agent.sockets).length, 0);
-    }));
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    https.get(
+      {
+        host: server.address().host,
+        port: server.address().port,
+        headers: { host: 'agent1' },
+        rejectUnauthorized: true,
+        ca: options.ca,
+        agent: agent
+      },
+      common.mustCall((res) => {
+        res.resume();
+        server.close();
+
+        // Only one entry should exist in agent.sockets pool
+        // If there are more entries in agent.sockets,
+        // removeSocket will not delete them resulting in a resource leak
+        assert.strictEqual(Object.keys(agent.sockets).length, 1);
+
+        res.req.on(
+          'close',
+          common.mustCall(() => {
+            // To verify that no leaks occur, check that no entries
+            // exist in agent.sockets pool after both request and socket
+            // has been closed.
+            assert.strictEqual(Object.keys(agent.sockets).length, 0);
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-https-agent.js b/test/parallel/test-https-agent.js
index 835b85e004080f..b92afb057511ba 100644
--- a/test/parallel/test-https-agent.js
+++ b/test/parallel/test-https-agent.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
@@ -34,39 +33,40 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-
 const server = https.Server(options, function(req, res) {
   res.writeHead(200);
   res.end('hello world\n');
 });
 
-
 let responses = 0;
 const N = 4;
 const M = 4;
 
-
 server.listen(0, function() {
   for (let i = 0; i < N; i++) {
     setTimeout(function() {
       for (let j = 0; j < M; j++) {
-        https.get({
-          path: '/',
-          port: server.address().port,
-          rejectUnauthorized: false
-        }, function(res) {
-          res.resume();
-          assert.strictEqual(res.statusCode, 200);
-          if (++responses === N * M) server.close();
-        }).on('error', function(e) {
-          throw e;
-        });
+        https
+          .get(
+            {
+              path: '/',
+              port: server.address().port,
+              rejectUnauthorized: false
+            },
+            function(res) {
+              res.resume();
+              assert.strictEqual(res.statusCode, 200);
+              if (++responses === N * M) server.close();
+            }
+          )
+          .on('error', function(e) {
+            throw e;
+          });
       }
     }, i);
   }
 });
 
-
 process.on('exit', function() {
   assert.strictEqual(N * M, responses);
 });
diff --git a/test/parallel/test-https-argument-of-creating.js b/test/parallel/test-https-argument-of-creating.js
index 063002840616fc..49293241d4cfd5 100644
--- a/test/parallel/test-https-argument-of-creating.js
+++ b/test/parallel/test-https-argument-of-creating.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -12,34 +11,38 @@ const dftProtocol = {};
 
 // test for immutable `opts`
 {
-  const opts = { foo: 'bar', ALPNProtocols: [ 'http/1.1' ] };
+  const opts = { foo: 'bar', ALPNProtocols: ['http/1.1'] };
   const server = https.createServer(opts);
 
-  tls.convertALPNProtocols([ 'http/1.1' ], dftProtocol);
-  assert.deepStrictEqual(opts, { foo: 'bar', ALPNProtocols: [ 'http/1.1' ] });
-  assert.strictEqual(server.ALPNProtocols.compare(dftProtocol.ALPNProtocols),
-                     0);
+  tls.convertALPNProtocols(['http/1.1'], dftProtocol);
+  assert.deepStrictEqual(opts, { foo: 'bar', ALPNProtocols: ['http/1.1'] });
+  assert.strictEqual(
+    server.ALPNProtocols.compare(dftProtocol.ALPNProtocols),
+    0
+  );
 }
 
-
 // validate that `createServer` can work with the only argument requestListener
 {
   const mustNotCall = common.mustNotCall();
   const server = https.createServer(mustNotCall);
 
-  tls.convertALPNProtocols([ 'http/1.1' ], dftProtocol);
-  assert.strictEqual(server.ALPNProtocols.compare(dftProtocol.ALPNProtocols),
-                     0);
+  tls.convertALPNProtocols(['http/1.1'], dftProtocol);
+  assert.strictEqual(
+    server.ALPNProtocols.compare(dftProtocol.ALPNProtocols),
+    0
+  );
   assert.strictEqual(server.listeners('request').length, 1);
   assert.strictEqual(server.listeners('request')[0], mustNotCall);
 }
 
-
 // validate that `createServer` can work with no arguments
 {
   const server = https.createServer();
 
-  assert.strictEqual(server.ALPNProtocols.compare(dftProtocol.ALPNProtocols),
-                     0);
+  assert.strictEqual(
+    server.ALPNProtocols.compare(dftProtocol.ALPNProtocols),
+    0
+  );
   assert.strictEqual(server.listeners('request').length, 0);
 }
diff --git a/test/parallel/test-https-byteswritten.js b/test/parallel/test-https-byteswritten.js
index 8ce0f7d8225033..da30118ae31ace 100644
--- a/test/parallel/test-https-byteswritten.js
+++ b/test/parallel/test-https-byteswritten.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 const fixtures = require('../common/fixtures');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
diff --git a/test/parallel/test-https-client-checkServerIdentity.js b/test/parallel/test-https-client-checkServerIdentity.js
index 87c9ec8229f30a..3d0857093d2db5 100644
--- a/test/parallel/test-https-client-checkServerIdentity.js
+++ b/test/parallel/test-https-client-checkServerIdentity.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -33,20 +32,28 @@ const options = {
   cert: fixtures.readKey('agent3-cert.pem')
 };
 
-const server = https.createServer(options, common.mustCall(function(req, res) {
-  res.writeHead(200);
-  res.end();
-  req.resume();
-})).listen(0, function() {
-  authorized();
-});
+const server = https
+  .createServer(
+    options,
+    common.mustCall(function(req, res) {
+      res.writeHead(200);
+      res.end();
+      req.resume();
+    })
+  )
+  .listen(0, function() {
+    authorized();
+  });
 
 function authorized() {
-  const req = https.request({
-    port: server.address().port,
-    rejectUnauthorized: true,
-    ca: [fixtures.readKey('ca2-cert.pem')]
-  }, common.mustNotCall());
+  const req = https.request(
+    {
+      port: server.address().port,
+      rejectUnauthorized: true,
+      ca: [fixtures.readKey('ca2-cert.pem')]
+    },
+    common.mustNotCall()
+  );
   req.on('error', function(err) {
     override();
   });
diff --git a/test/parallel/test-https-client-get-url.js b/test/parallel/test-https-client-get-url.js
index 5d520416fe22da..146d8d9e10dc62 100644
--- a/test/parallel/test-https-client-get-url.js
+++ b/test/parallel/test-https-client-get-url.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 const fixtures = require('../common/fixtures');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // disable strict server certificate validation by the client
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
@@ -39,21 +38,38 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = https.createServer(options, common.mustCall((req, res) => {
-  assert.strictEqual(req.method, 'GET');
-  assert.strictEqual(req.url, '/foo?bar');
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.write('hello\n');
-  res.end();
-}, 3));
+const server = https.createServer(
+  options,
+  common.mustCall((req, res) => {
+    assert.strictEqual(req.method, 'GET');
+    assert.strictEqual(req.url, '/foo?bar');
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.write('hello\n');
+    res.end();
+  }, 3)
+);
 
-server.listen(0, common.mustCall(() => {
-  const u = `https://${common.localhostIPv4}:${server.address().port}/foo?bar`;
-  https.get(u, common.mustCall(() => {
-    https.get(url.parse(u), common.mustCall(() => {
-      https.get(new URL(u), common.mustCall(() => {
-        server.close();
-      }));
-    }));
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const u = `https://${common.localhostIPv4}:${
+      server.address().port
+    }/foo?bar`;
+    https.get(
+      u,
+      common.mustCall(() => {
+        https.get(
+          url.parse(u),
+          common.mustCall(() => {
+            https.get(
+              new URL(u),
+              common.mustCall(() => {
+                server.close();
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-https-client-reject.js b/test/parallel/test-https-client-reject.js
index 729256df54ff8c..e975dbcab396e5 100644
--- a/test/parallel/test-https-client-reject.js
+++ b/test/parallel/test-https-client-reject.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
@@ -34,23 +33,31 @@ const options = {
   cert: fixtures.readSync('test_cert.pem')
 };
 
-const server = https.createServer(options, common.mustCall(function(req, res) {
-  res.writeHead(200);
-  res.end();
-  req.resume();
-}, 2)).listen(0, function() {
-  unauthorized();
-});
+const server = https
+  .createServer(
+    options,
+    common.mustCall(function(req, res) {
+      res.writeHead(200);
+      res.end();
+      req.resume();
+    }, 2)
+  )
+  .listen(0, function() {
+    unauthorized();
+  });
 
 function unauthorized() {
-  const req = https.request({
-    port: server.address().port,
-    rejectUnauthorized: false
-  }, function(res) {
-    assert(!req.socket.authorized);
-    res.resume();
-    rejectUnauthorized();
-  });
+  const req = https.request(
+    {
+      port: server.address().port,
+      rejectUnauthorized: false
+    },
+    function(res) {
+      assert(!req.socket.authorized);
+      res.resume();
+      rejectUnauthorized();
+    }
+  );
   req.on('error', function(err) {
     throw err;
   });
diff --git a/test/parallel/test-https-client-resume.js b/test/parallel/test-https-client-resume.js
index 301cb63dc70310..e34bac20fa8c7f 100644
--- a/test/parallel/test-https-client-resume.js
+++ b/test/parallel/test-https-client-resume.js
@@ -24,8 +24,7 @@
 // Cache session and close connection.  Use session on second connection.
 // ASSERT resumption.
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -38,25 +37,28 @@ const options = {
 };
 
 // create server
-const server = https.createServer(options, common.mustCall(function(req, res) {
-  res.end('Goodbye');
-}, 2));
+const server = https.createServer(
+  options,
+  common.mustCall(function(req, res) {
+    res.end('Goodbye');
+  }, 2)
+);
 
 // start listening
 server.listen(0, function() {
-
   let session1 = null;
-  const client1 = tls.connect({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, function() {
-    console.log('connect1');
-    assert.ok(!client1.isSessionReused(), 'Session *should not* be reused.');
-    session1 = client1.getSession();
-    client1.write('GET / HTTP/1.0\r\n' +
-                  'Server: 127.0.0.1\r\n' +
-                  '\r\n');
-  });
+  const client1 = tls.connect(
+    {
+      port: this.address().port,
+      rejectUnauthorized: false
+    },
+    function() {
+      console.log('connect1');
+      assert.ok(!client1.isSessionReused(), 'Session *should not* be reused.');
+      session1 = client1.getSession();
+      client1.write('GET / HTTP/1.0\r\n' + 'Server: 127.0.0.1\r\n' + '\r\n');
+    }
+  );
 
   client1.on('close', function() {
     console.log('close1');
@@ -67,13 +69,14 @@ server.listen(0, function() {
       session: session1
     };
 
-    const client2 = tls.connect(opts, function() {
-      console.log('connect2');
-      assert.ok(client2.isSessionReused(), 'Session *should* be reused.');
-      client2.write('GET / HTTP/1.0\r\n' +
-                    'Server: 127.0.0.1\r\n' +
-                    '\r\n');
-    });
+    const client2 = tls.connect(
+      opts,
+      function() {
+        console.log('connect2');
+        assert.ok(client2.isSessionReused(), 'Session *should* be reused.');
+        client2.write('GET / HTTP/1.0\r\n' + 'Server: 127.0.0.1\r\n' + '\r\n');
+      }
+    );
 
     client2.on('close', function() {
       console.log('close2');
diff --git a/test/parallel/test-https-close.js b/test/parallel/test-https-close.js
index f33754fb818940..3fd5451eebd48e 100644
--- a/test/parallel/test-https-close.js
+++ b/test/parallel/test-https-close.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const https = require('https');
diff --git a/test/parallel/test-https-connect-address-family.js b/test/parallel/test-https-connect-address-family.js
index 65cd59313f109b..b06700310bed4b 100644
--- a/test/parallel/test-https-connect-address-family.js
+++ b/test/parallel/test-https-connect-address-family.js
@@ -3,11 +3,9 @@
 // Test that the family option of https.get is honored.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.hasIPv6)
-  common.skip('no IPv6 support');
+if (!common.hasIPv6) common.skip('no IPv6 support');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -17,28 +15,40 @@ const https = require('https');
   // Test that `https` machinery passes host name, and receives IP.
   const hostAddrIPv6 = '::1';
   const HOSTNAME = 'dummy';
-  https.createServer({
-    cert: fixtures.readKey('agent1-cert.pem'),
-    key: fixtures.readKey('agent1-key.pem'),
-  }, common.mustCall(function(req, res) {
-    this.close();
-    res.end();
-  })).listen(0, hostAddrIPv6, common.mustCall(function() {
-    const options = {
-      host: HOSTNAME,
-      port: this.address().port,
-      family: 6,
-      rejectUnauthorized: false,
-      lookup: common.mustCall((addr, opt, cb) => {
-        assert.strictEqual(addr, HOSTNAME);
-        assert.strictEqual(opt.family, 6);
-        cb(null, hostAddrIPv6, opt.family);
+  https
+    .createServer(
+      {
+        cert: fixtures.readKey('agent1-cert.pem'),
+        key: fixtures.readKey('agent1-key.pem')
+      },
+      common.mustCall(function(req, res) {
+        this.close();
+        res.end();
       })
-    };
-    // Will fail with ECONNREFUSED if the address family is not honored.
-    https.get(options, common.mustCall(function() {
-      assert.strictEqual(this.socket.remoteAddress, hostAddrIPv6);
-      this.destroy();
-    }));
-  }));
+    )
+    .listen(
+      0,
+      hostAddrIPv6,
+      common.mustCall(function() {
+        const options = {
+          host: HOSTNAME,
+          port: this.address().port,
+          family: 6,
+          rejectUnauthorized: false,
+          lookup: common.mustCall((addr, opt, cb) => {
+            assert.strictEqual(addr, HOSTNAME);
+            assert.strictEqual(opt.family, 6);
+            cb(null, hostAddrIPv6, opt.family);
+          })
+        };
+        // Will fail with ECONNREFUSED if the address family is not honored.
+        https.get(
+          options,
+          common.mustCall(function() {
+            assert.strictEqual(this.socket.remoteAddress, hostAddrIPv6);
+            this.destroy();
+          })
+        );
+      })
+    );
 }
diff --git a/test/parallel/test-https-connecting-to-http.js b/test/parallel/test-https-connecting-to-http.js
index 195ad38ed44a31..b81cd321fded32 100644
--- a/test/parallel/test-https-connecting-to-http.js
+++ b/test/parallel/test-https-connecting-to-http.js
@@ -23,18 +23,23 @@
 // This tests the situation where you try to connect a https client
 // to an http server. You should get an error and exit.
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http = require('http');
 const https = require('https');
 const server = http.createServer(common.mustNotCall());
 
-server.listen(0, common.mustCall(function() {
-  const req = https.get({ port: this.address().port }, common.mustNotCall());
+server.listen(
+  0,
+  common.mustCall(function() {
+    const req = https.get({ port: this.address().port }, common.mustNotCall());
 
-  req.on('error', common.mustCall(function(e) {
-    console.log('Got expected error: ', e.message);
-    server.close();
-  }));
-}));
+    req.on(
+      'error',
+      common.mustCall(function(e) {
+        console.log('Got expected error: ', e.message);
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-https-drain.js b/test/parallel/test-https-drain.js
index 98e43b27d4cebd..6504bf05798aa0 100644
--- a/test/parallel/test-https-drain.js
+++ b/test/parallel/test-https-drain.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
@@ -44,45 +43,48 @@ const server = https.createServer(options, function(req, res) {
 
 server.listen(0, function() {
   let resumed = false;
-  const req = https.request({
-    method: 'POST',
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, function(res) {
-    let timer;
-    res.pause();
-    console.error('paused');
-    send();
-    function send() {
-      if (req.write(Buffer.allocUnsafe(bufSize))) {
+  const req = https.request(
+    {
+      method: 'POST',
+      port: this.address().port,
+      rejectUnauthorized: false
+    },
+    function(res) {
+      let timer;
+      res.pause();
+      console.error('paused');
+      send();
+      function send() {
+        if (req.write(Buffer.allocUnsafe(bufSize))) {
+          sent += bufSize;
+          assert.ok(sent < 100 * 1024 * 1024); // max 100MB
+          return process.nextTick(send);
+        }
         sent += bufSize;
-        assert.ok(sent < 100 * 1024 * 1024); // max 100MB
-        return process.nextTick(send);
+        console.error(`sent: ${sent}`);
+        resumed = true;
+        res.resume();
+        console.error('resumed');
+        timer = setTimeout(function() {
+          process.exit(1);
+        }, 1000);
       }
-      sent += bufSize;
-      console.error(`sent: ${sent}`);
-      resumed = true;
-      res.resume();
-      console.error('resumed');
-      timer = setTimeout(function() {
-        process.exit(1);
-      }, 1000);
-    }
 
-    res.on('data', function(data) {
-      assert.ok(resumed);
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      received += data.length;
-      if (received >= sent) {
-        console.error(`received: ${received}`);
-        req.end();
-        server.close();
-      }
-    });
-  });
+      res.on('data', function(data) {
+        assert.ok(resumed);
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        received += data.length;
+        if (received >= sent) {
+          console.error(`received: ${received}`);
+          req.end();
+          server.close();
+        }
+      });
+    }
+  );
   req.write('a');
   ++sent;
 });
diff --git a/test/parallel/test-https-eof-for-eom.js b/test/parallel/test-https-eof-for-eom.js
index b2f178654f6de9..1b10e8d0043d7e 100644
--- a/test/parallel/test-https-eof-for-eom.js
+++ b/test/parallel/test-https-eof-for-eom.js
@@ -29,8 +29,7 @@
 // correctly.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -42,19 +41,20 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-
 const server = tls.Server(options, function(socket) {
   console.log('2) Server got request');
-  socket.write('HTTP/1.1 200 OK\r\n' +
-               'Date: Tue, 15 Feb 2011 22:14:54 GMT\r\n' +
-               'Expires: -1\r\n' +
-               'Cache-Control: private, max-age=0\r\n' +
-               'Set-Cookie: xyz\r\n' +
-               'Set-Cookie: abc\r\n' +
-               'Server: gws\r\n' +
-               'X-XSS-Protection: 1; mode=block\r\n' +
-               'Connection: close\r\n' +
-               '\r\n');
+  socket.write(
+    'HTTP/1.1 200 OK\r\n' +
+      'Date: Tue, 15 Feb 2011 22:14:54 GMT\r\n' +
+      'Expires: -1\r\n' +
+      'Cache-Control: private, max-age=0\r\n' +
+      'Set-Cookie: xyz\r\n' +
+      'Set-Cookie: abc\r\n' +
+      'Server: gws\r\n' +
+      'X-XSS-Protection: 1; mode=block\r\n' +
+      'Connection: close\r\n' +
+      '\r\n'
+  );
 
   socket.write('hello world\n');
 
@@ -64,27 +64,36 @@ const server = tls.Server(options, function(socket) {
   }, 100);
 });
 
-server.listen(0, common.mustCall(function() {
-  console.log('1) Making Request');
-  https.get({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(function(res) {
-    let bodyBuffer = '';
+server.listen(
+  0,
+  common.mustCall(function() {
+    console.log('1) Making Request');
+    https.get(
+      {
+        port: this.address().port,
+        rejectUnauthorized: false
+      },
+      common.mustCall(function(res) {
+        let bodyBuffer = '';
 
-    server.close();
-    console.log('3) Client got response headers.');
+        server.close();
+        console.log('3) Client got response headers.');
 
-    assert.strictEqual(res.headers.server, 'gws');
+        assert.strictEqual(res.headers.server, 'gws');
 
-    res.setEncoding('utf8');
-    res.on('data', function(s) {
-      bodyBuffer += s;
-    });
+        res.setEncoding('utf8');
+        res.on('data', function(s) {
+          bodyBuffer += s;
+        });
 
-    res.on('end', common.mustCall(function() {
-      console.log('5) Client got "end" event.');
-      assert.strictEqual(bodyBuffer, 'hello world\nhello world\n');
-    }));
-  }));
-}));
+        res.on(
+          'end',
+          common.mustCall(function() {
+            console.log('5) Client got "end" event.');
+            assert.strictEqual(bodyBuffer, 'hello world\nhello world\n');
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-https-foafssl.js b/test/parallel/test-https-foafssl.js
index 4e1a8fbc4c6b30..10e2da5691e89c 100644
--- a/test/parallel/test-https-foafssl.js
+++ b/test/parallel/test-https-foafssl.js
@@ -21,11 +21,9 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -39,38 +37,47 @@ const options = {
   rejectUnauthorized: false
 };
 
-const modulus = 'A6F44A9C25791431214F5C87AF9E040177A8BB89AC803F7E09BBC3A5519F' +
-                '349CD9B9C40BE436D0AA823A94147E26C89248ADA2BE3DD4D34E8C289646' +
-                '94B2047D217B4F1299371EA93A83C89AB9440724131E65F2B0161DE9560C' +
-                'DE9C13455552B2F49CF0FB00D8D77532324913F6F80FF29D0A131D29DB06' +
-                'AFF8BE191B7920DC2DAE1C26EA82A47847A10391EF3BF6AABB3CC40FF821' +
-                '00B03A4F0FF1809278E4DDFDA7DE954ED56DC7AD9A47EEBC37D771A366FC' +
-                '60A5BCB72373BEC180649B3EFA0E9092707210B41B90032BB18BC91F2046' +
-                'EBDAF1191F4A4E26D71879C4C7867B62FCD508E8CE66E82D128A71E91580' +
-                '9FCF44E8DE774067F1DE5D70B9C03687';
+const modulus =
+  'A6F44A9C25791431214F5C87AF9E040177A8BB89AC803F7E09BBC3A5519F' +
+  '349CD9B9C40BE436D0AA823A94147E26C89248ADA2BE3DD4D34E8C289646' +
+  '94B2047D217B4F1299371EA93A83C89AB9440724131E65F2B0161DE9560C' +
+  'DE9C13455552B2F49CF0FB00D8D77532324913F6F80FF29D0A131D29DB06' +
+  'AFF8BE191B7920DC2DAE1C26EA82A47847A10391EF3BF6AABB3CC40FF821' +
+  '00B03A4F0FF1809278E4DDFDA7DE954ED56DC7AD9A47EEBC37D771A366FC' +
+  '60A5BCB72373BEC180649B3EFA0E9092707210B41B90032BB18BC91F2046' +
+  'EBDAF1191F4A4E26D71879C4C7867B62FCD508E8CE66E82D128A71E91580' +
+  '9FCF44E8DE774067F1DE5D70B9C03687';
 
 const CRLF = '\r\n';
 const body = 'hello world\n';
 let cert;
 
-const server = https.createServer(options, common.mustCall(function(req, res) {
-  console.log('got request');
+const server = https.createServer(
+  options,
+  common.mustCall(function(req, res) {
+    console.log('got request');
 
-  cert = req.connection.getPeerCertificate();
+    cert = req.connection.getPeerCertificate();
 
-  assert.strictEqual(cert.subjectaltname, 'URI:http://example.com/#me');
-  assert.strictEqual(cert.exponent, '0x10001');
-  assert.strictEqual(cert.modulus, modulus);
-  res.writeHead(200, { 'content-type': 'text/plain' });
-  res.end(body);
-}));
+    assert.strictEqual(cert.subjectaltname, 'URI:http://example.com/#me');
+    assert.strictEqual(cert.exponent, '0x10001');
+    assert.strictEqual(cert.modulus, modulus);
+    res.writeHead(200, { 'content-type': 'text/plain' });
+    res.end(body);
+  })
+);
 
 server.listen(0, function() {
-  const args = ['s_client',
-                '-quiet',
-                '-connect', `127.0.0.1:${this.address().port}`,
-                '-cert', fixtures.path('foafssl.crt'),
-                '-key', fixtures.path('foafssl.key')];
+  const args = [
+    's_client',
+    '-quiet',
+    '-connect',
+    `127.0.0.1:${this.address().port}`,
+    '-cert',
+    fixtures.path('foafssl.crt'),
+    '-key',
+    fixtures.path('foafssl.key')
+  ];
 
   const client = spawn(common.opensslCli, args);
 
diff --git a/test/parallel/test-https-host-headers.js b/test/parallel/test-https-host-headers.js
index 996b37a63385fb..fc95109b3bb711 100644
--- a/test/parallel/test-https-host-headers.js
+++ b/test/parallel/test-https-host-headers.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -20,8 +19,10 @@ function reqHandler(req, res) {
     assert.strictEqual(req.headers.host, undefined);
   } else {
     assert.strictEqual(
-      req.headers.host, `localhost:${this.address().port}`,
-      `Wrong host header for req[${req.url}]: ${req.headers.host}`);
+      req.headers.host,
+      `localhost:${this.address().port}`,
+      `Wrong host header for req[${req.url}]: ${req.headers.host}`
+    );
   }
   res.writeHead(200, {});
   res.end('ok');
@@ -34,7 +35,6 @@ function thrower(er) {
 testHttps();
 
 function testHttps() {
-
   let counter = 0;
 
   function cb(res) {
@@ -50,81 +50,131 @@ function testHttps() {
   httpsServer.listen(0, function(er) {
     console.log(`test https server listening on port ${this.address().port}`);
     assert.ifError(er);
-    https.get({
-      method: 'GET',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower);
-
-    https.request({
-      method: 'GET',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.request({
-      method: 'POST',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.request({
-      method: 'PUT',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.request({
-      method: 'DELETE',
-      path: `/${counter++}`,
-      host: 'localhost',
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.get({
-      method: 'GET',
-      path: `/setHostFalse${counter++}`,
-      host: 'localhost',
-      setHost: false,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower);
-
-    https.request({
-      method: 'GET',
-      path: `/${counter++}`,
-      host: 'localhost',
-      setHost: true,
-      // agent: false,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower).end();
-
-    https.get({
-      method: 'GET',
-      path: `/setHostFalse${counter++}`,
-      host: 'localhost',
-      setHost: 0,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower);
-
-    https.get({
-      method: 'GET',
-      path: `/setHostFalse${counter++}`,
-      host: 'localhost',
-      setHost: null,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, cb).on('error', thrower);
+    https
+      .get(
+        {
+          method: 'GET',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower);
+
+    https
+      .request(
+        {
+          method: 'GET',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower)
+      .end();
+
+    https
+      .request(
+        {
+          method: 'POST',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower)
+      .end();
+
+    https
+      .request(
+        {
+          method: 'PUT',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower)
+      .end();
+
+    https
+      .request(
+        {
+          method: 'DELETE',
+          path: `/${counter++}`,
+          host: 'localhost',
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower)
+      .end();
+
+    https
+      .get(
+        {
+          method: 'GET',
+          path: `/setHostFalse${counter++}`,
+          host: 'localhost',
+          setHost: false,
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower);
+
+    https
+      .request(
+        {
+          method: 'GET',
+          path: `/${counter++}`,
+          host: 'localhost',
+          setHost: true,
+          // agent: false,
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower)
+      .end();
+
+    https
+      .get(
+        {
+          method: 'GET',
+          path: `/setHostFalse${counter++}`,
+          host: 'localhost',
+          setHost: 0,
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower);
+
+    https
+      .get(
+        {
+          method: 'GET',
+          path: `/setHostFalse${counter++}`,
+          host: 'localhost',
+          setHost: null,
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        cb
+      )
+      .on('error', thrower);
   });
 }
diff --git a/test/parallel/test-https-localaddress-bind-error.js b/test/parallel/test-https-localaddress-bind-error.js
index 57e4dd054d78ce..09f72b2bf5c4fd 100644
--- a/test/parallel/test-https-localaddress-bind-error.js
+++ b/test/parallel/test-https-localaddress-bind-error.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -46,17 +45,30 @@ const server = https.createServer(options, function(req, res) {
   req.resume();
 });
 
-server.listen(0, '127.0.0.1', common.mustCall(function() {
-  https.request({
-    host: 'localhost',
-    port: this.address().port,
-    path: '/',
-    method: 'GET',
-    localAddress: invalidLocalAddress
-  }, function(res) {
-    assert.fail('unexpectedly got response from server');
-  }).on('error', common.mustCall(function(e) {
-    console.log(`client got error: ${e.message}`);
-    server.close();
-  })).end();
-}));
+server.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    https
+      .request(
+        {
+          host: 'localhost',
+          port: this.address().port,
+          path: '/',
+          method: 'GET',
+          localAddress: invalidLocalAddress
+        },
+        function(res) {
+          assert.fail('unexpectedly got response from server');
+        }
+      )
+      .on(
+        'error',
+        common.mustCall(function(e) {
+          console.log(`client got error: ${e.message}`);
+          server.close();
+        })
+      )
+      .end();
+  })
+);
diff --git a/test/parallel/test-https-localaddress.js b/test/parallel/test-https-localaddress.js
index 6c6cac37ccca3b..1ac09ade688df5 100644
--- a/test/parallel/test-https-localaddress.js
+++ b/test/parallel/test-https-localaddress.js
@@ -22,11 +22,9 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.hasMultiLocalhost())
-  common.skip('platform-specific test.');
+if (!common.hasMultiLocalhost()) common.skip('platform-specific test.');
 
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
diff --git a/test/parallel/test-https-max-headers-count.js b/test/parallel/test-https-max-headers-count.js
index 8c099d1e5fb841..6b822ee0515bdf 100644
--- a/test/parallel/test-https-max-headers-count.js
+++ b/test/parallel/test-https-max-headers-count.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -22,7 +21,8 @@ for (let i = 0; i < N; ++i) {
   headers[`key${i}`] = i;
 }
 
-const maxAndExpected = [ // for server
+const maxAndExpected = [
+  // for server
   [50, 50],
   [1500, 1500],
   [0, N + 2] // Host and Connection
@@ -30,44 +30,54 @@ const maxAndExpected = [ // for server
 let max = maxAndExpected[requests][0];
 let expected = maxAndExpected[requests][1];
 
-const server = https.createServer(serverOptions, common.mustCall((req, res) => {
-  assert.strictEqual(Object.keys(req.headers).length, expected);
-  if (++requests < maxAndExpected.length) {
-    max = maxAndExpected[requests][0];
-    expected = maxAndExpected[requests][1];
-    server.maxHeadersCount = max;
-  }
-  res.writeHead(200, headers);
-  res.end();
-}, 3));
+const server = https.createServer(
+  serverOptions,
+  common.mustCall((req, res) => {
+    assert.strictEqual(Object.keys(req.headers).length, expected);
+    if (++requests < maxAndExpected.length) {
+      max = maxAndExpected[requests][0];
+      expected = maxAndExpected[requests][1];
+      server.maxHeadersCount = max;
+    }
+    res.writeHead(200, headers);
+    res.end();
+  }, 3)
+);
 server.maxHeadersCount = max;
 
-server.listen(0, common.mustCall(() => {
-  const maxAndExpected = [ // for client
-    [20, 20],
-    [1200, 1200],
-    [0, N + 3] // Connection, Date and Transfer-Encoding
-  ];
-  const doRequest = common.mustCall(() => {
-    const max = maxAndExpected[responses][0];
-    const expected = maxAndExpected[responses][1];
-    const req = https.request({
-      port: server.address().port,
-      headers: headers,
-      rejectUnauthorized: false
-    }, (res) => {
-      assert.strictEqual(Object.keys(res.headers).length, expected);
-      res.on('end', () => {
-        if (++responses < maxAndExpected.length) {
-          doRequest();
-        } else {
-          server.close();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const maxAndExpected = [
+      // for client
+      [20, 20],
+      [1200, 1200],
+      [0, N + 3] // Connection, Date and Transfer-Encoding
+    ];
+    const doRequest = common.mustCall(() => {
+      const max = maxAndExpected[responses][0];
+      const expected = maxAndExpected[responses][1];
+      const req = https.request(
+        {
+          port: server.address().port,
+          headers: headers,
+          rejectUnauthorized: false
+        },
+        (res) => {
+          assert.strictEqual(Object.keys(res.headers).length, expected);
+          res.on('end', () => {
+            if (++responses < maxAndExpected.length) {
+              doRequest();
+            } else {
+              server.close();
+            }
+          });
+          res.resume();
         }
-      });
-      res.resume();
-    });
-    req.maxHeadersCount = max;
-    req.end();
-  }, 3);
-  doRequest();
-}));
+      );
+      req.maxHeadersCount = max;
+      req.end();
+    }, 3);
+    doRequest();
+  })
+);
diff --git a/test/parallel/test-https-options-boolean-check.js b/test/parallel/test-https-options-boolean-check.js
index bed5fb03253f7f..af082885c8757c 100644
--- a/test/parallel/test-https-options-boolean-check.js
+++ b/test/parallel/test-https-options-boolean-check.js
@@ -3,8 +3,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -12,13 +11,13 @@ const https = require('https');
 function toArrayBuffer(buf) {
   const ab = new ArrayBuffer(buf.length);
   const view = new Uint8Array(ab);
-  return buf.map((b, i) => view[i] = b);
+  return buf.map((b, i) => (view[i] = b));
 }
 
 function toDataView(buf) {
   const ab = new ArrayBuffer(buf.length);
   const view = new DataView(ab);
-  return buf.map((b, i) => view[i] = b);
+  return buf.map((b, i) => (view[i] = b));
 }
 
 const keyBuff = fixtures.readKey('agent1-key.pem');
@@ -83,14 +82,18 @@ const caArrDataView = toDataView(caCert);
   [true, [certBuff, certBuff2]]
 ].forEach(([key, cert, index]) => {
   const type = typeof (index === undefined ? key : key[index]);
-  assert.throws(() => {
-    https.createServer({ key, cert });
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "options.key" property must be one of type string, Buffer, ' +
-             `TypedArray, or DataView. Received type ${type}`
-  });
+  assert.throws(
+    () => {
+      https.createServer({ key, cert });
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "options.key" property must be one of type string, Buffer, ' +
+        `TypedArray, or DataView. Received type ${type}`
+    }
+  );
 });
 
 [
@@ -105,17 +108,21 @@ const caArrDataView = toDataView(caCert);
   [[keyBuff, keyBuff2], [true, certBuff2], 0],
   [[keyStr, keyStr2], [certStr, true], 1],
   [[keyStr, keyStr2], [true, false], 0],
-  [[keyStr, keyStr2], true],
+  [[keyStr, keyStr2], true]
 ].forEach(([key, cert, index]) => {
   const type = typeof (index === undefined ? cert : cert[index]);
-  assert.throws(() => {
-    https.createServer({ key, cert });
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "options.cert" property must be one of type string, Buffer,' +
-             ` TypedArray, or DataView. Received type ${type}`
-  });
+  assert.throws(
+    () => {
+      https.createServer({ key, cert });
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "options.cert" property must be one of type string, Buffer,' +
+        ` TypedArray, or DataView. Received type ${type}`
+    }
+  );
 });
 
 // Checks to ensure https.createServer works with the CA parameter
@@ -127,7 +134,7 @@ const caArrDataView = toDataView(caCert);
   [keyBuff, certBuff, [caCertStr, caCertStr2]],
   [keyBuff, certBuff, caArrBuff],
   [keyBuff, certBuff, caArrDataView],
-  [keyBuff, certBuff, false],
+  [keyBuff, certBuff, false]
 ].forEach(([key, cert, ca]) => {
   https.createServer({ key, cert, ca });
 });
@@ -142,12 +149,16 @@ const caArrDataView = toDataView(caCert);
   [keyBuff, certBuff, [caCert, true], 1]
 ].forEach(([key, cert, ca, index]) => {
   const type = typeof (index ? ca[index] : ca);
-  assert.throws(() => {
-    https.createServer({ key, cert, ca });
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "options.ca" property must be one of type string, Buffer, ' +
-             `TypedArray, or DataView. Received type ${type}`
-  });
+  assert.throws(
+    () => {
+      https.createServer({ key, cert, ca });
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "options.ca" property must be one of type string, Buffer, ' +
+        `TypedArray, or DataView. Received type ${type}`
+    }
+  );
 });
diff --git a/test/parallel/test-https-pfx.js b/test/parallel/test-https-pfx.js
index 7cf23a7dfa17f4..9254f1ff868bfd 100644
--- a/test/parallel/test-https-pfx.js
+++ b/test/parallel/test-https-pfx.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
@@ -44,22 +43,36 @@ const options = {
 
 const server = https.createServer(options, function(req, res) {
   assert.strictEqual(req.socket.authorized, false); // not a client cert
-  assert.strictEqual(req.socket.authorizationError,
-                     'DEPTH_ZERO_SELF_SIGNED_CERT');
+  assert.strictEqual(
+    req.socket.authorizationError,
+    'DEPTH_ZERO_SELF_SIGNED_CERT'
+  );
   res.writeHead(200);
   res.end('OK');
 });
 
-server.listen(0, options.host, common.mustCall(function() {
-  options.port = this.address().port;
+server.listen(
+  0,
+  options.host,
+  common.mustCall(function() {
+    options.port = this.address().port;
 
-  https.get(options, common.mustCall(function(res) {
-    let data = '';
+    https.get(
+      options,
+      common.mustCall(function(res) {
+        let data = '';
 
-    res.on('data', function(data_) { data += data_; });
-    res.on('end', common.mustCall(function() {
-      assert.strictEqual(data, 'OK');
-      server.close();
-    }));
-  }));
-}));
+        res.on('data', function(data_) {
+          data += data_;
+        });
+        res.on(
+          'end',
+          common.mustCall(function() {
+            assert.strictEqual(data, 'OK');
+            server.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-https-request-arguments.js b/test/parallel/test-https-request-arguments.js
index 9dc80094be0d2c..57ff0694fd5e1c 100644
--- a/test/parallel/test-https-request-arguments.js
+++ b/test/parallel/test-https-request-arguments.js
@@ -3,8 +3,7 @@ const common = require('../common');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const https = require('https');
 
 const options = {
diff --git a/test/parallel/test-https-resume-after-renew.js b/test/parallel/test-https-resume-after-renew.js
index 5a621e8f561829..822a1a4d365639 100644
--- a/test/parallel/test-https-resume-after-renew.js
+++ b/test/parallel/test-https-resume-after-renew.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const https = require('https');
@@ -28,25 +27,30 @@ server._sharedCreds.context.onticketkeycallback = function(name, iv, enc) {
     newIV = crypto.randomBytes(16);
   } else {
     // Renew
-    return [ 2, hmac, aes ];
+    return [2, hmac, aes];
   }
 
-  return [ 1, hmac, aes, newName, newIV ];
+  return [1, hmac, aes, newName, newIV];
 };
 
 server.listen(0, function() {
   const addr = this.address();
 
   function doReq(callback) {
-    https.request({
-      method: 'GET',
-      port: addr.port,
-      servername: 'agent1',
-      ca: options.ca
-    }, function(res) {
-      res.resume();
-      res.once('end', callback);
-    }).end();
+    https
+      .request(
+        {
+          method: 'GET',
+          port: addr.port,
+          servername: 'agent1',
+          ca: options.ca
+        },
+        function(res) {
+          res.resume();
+          res.once('end', callback);
+        }
+      )
+      .end();
   }
 
   doReq(function() {
diff --git a/test/parallel/test-https-server-options-incoming-message.js b/test/parallel/test-https-server-options-incoming-message.js
index 102ee56751b800..4724a4ed3df340 100644
--- a/test/parallel/test-https-server-options-incoming-message.js
+++ b/test/parallel/test-https-server-options-incoming-message.js
@@ -9,8 +9,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http = require('http');
@@ -22,30 +21,36 @@ class MyIncomingMessage extends http.IncomingMessage {
   }
 }
 
-const server = https.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem'),
-  ca: fixtures.readKey('ca1-cert.pem'),
-  IncomingMessage: MyIncomingMessage
-}, common.mustCall(function(req, res) {
-  assert.strictEqual(req.getUserAgent(), 'node-test');
-  res.statusCode = 200;
-  res.end();
-}));
+const server = https.createServer(
+  {
+    key: fixtures.readKey('agent1-key.pem'),
+    cert: fixtures.readKey('agent1-cert.pem'),
+    ca: fixtures.readKey('ca1-cert.pem'),
+    IncomingMessage: MyIncomingMessage
+  },
+  common.mustCall(function(req, res) {
+    assert.strictEqual(req.getUserAgent(), 'node-test');
+    res.statusCode = 200;
+    res.end();
+  })
+);
 server.listen();
 
 server.on('listening', function makeRequest() {
-  https.get({
-    port: this.address().port,
-    rejectUnauthorized: false,
-    headers: {
-      'User-Agent': 'node-test'
+  https.get(
+    {
+      port: this.address().port,
+      rejectUnauthorized: false,
+      headers: {
+        'User-Agent': 'node-test'
+      }
+    },
+    (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      res.on('end', () => {
+        server.close();
+      });
+      res.resume();
     }
-  }, (res) => {
-    assert.strictEqual(res.statusCode, 200);
-    res.on('end', () => {
-      server.close();
-    });
-    res.resume();
-  });
+  );
 });
diff --git a/test/parallel/test-https-server-options-server-response.js b/test/parallel/test-https-server-options-server-response.js
index 8745415f8b6596..2d23d4bfc81ebc 100644
--- a/test/parallel/test-https-server-options-server-response.js
+++ b/test/parallel/test-https-server-options-server-response.js
@@ -9,8 +9,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http = require('http');
@@ -22,26 +21,32 @@ class MyServerResponse extends http.ServerResponse {
   }
 }
 
-const server = https.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem'),
-  ca: fixtures.readKey('ca1-cert.pem'),
-  ServerResponse: MyServerResponse
-}, common.mustCall(function(req, res) {
-  res.status(200);
-  res.end();
-}));
+const server = https.createServer(
+  {
+    key: fixtures.readKey('agent1-key.pem'),
+    cert: fixtures.readKey('agent1-cert.pem'),
+    ca: fixtures.readKey('ca1-cert.pem'),
+    ServerResponse: MyServerResponse
+  },
+  common.mustCall(function(req, res) {
+    res.status(200);
+    res.end();
+  })
+);
 server.listen();
 
 server.on('listening', function makeRequest() {
-  https.get({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, (res) => {
-    assert.strictEqual(res.statusCode, 200);
-    res.on('end', () => {
-      server.close();
-    });
-    res.resume();
-  });
+  https.get(
+    {
+      port: this.address().port,
+      rejectUnauthorized: false
+    },
+    (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      res.on('end', () => {
+        server.close();
+      });
+      res.resume();
+    }
+  );
 });
diff --git a/test/parallel/test-https-set-timeout-server.js b/test/parallel/test-https-set-timeout-server.js
index e353f0afde5a92..4ab78efaa96491 100644
--- a/test/parallel/test-https-set-timeout-server.js
+++ b/test/parallel/test-https-set-timeout-server.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -39,8 +38,7 @@ const serverOptions = {
 };
 
 function test(fn) {
-  if (!tests.length)
-    process.nextTick(run);
+  if (!tests.length) process.nextTick(run);
   tests.push(common.mustCall(fn));
 }
 
@@ -53,18 +51,25 @@ function run() {
 
 test(function serverTimeout(cb) {
   const server = https.createServer(serverOptions);
-  server.listen(common.mustCall(() => {
-    const s = server.setTimeout(50, common.mustCall((socket) => {
-      socket.destroy();
-      server.close();
-      cb();
-    }));
-    assert.ok(s instanceof https.Server);
-    https.get({
-      port: server.address().port,
-      rejectUnauthorized: false
-    }).on('error', common.mustCall());
-  }));
+  server.listen(
+    common.mustCall(() => {
+      const s = server.setTimeout(
+        50,
+        common.mustCall((socket) => {
+          socket.destroy();
+          server.close();
+          cb();
+        })
+      );
+      assert.ok(s instanceof https.Server);
+      https
+        .get({
+          port: server.address().port,
+          rejectUnauthorized: false
+        })
+        .on('error', common.mustCall());
+    })
+  );
 });
 
 test(function serverRequestTimeout(cb) {
@@ -72,23 +77,29 @@ test(function serverRequestTimeout(cb) {
     serverOptions,
     common.mustCall((req, res) => {
       // just do nothing, we should get a timeout event.
-      const s = req.setTimeout(50, common.mustCall((socket) => {
-        socket.destroy();
-        server.close();
-        cb();
-      }));
+      const s = req.setTimeout(
+        50,
+        common.mustCall((socket) => {
+          socket.destroy();
+          server.close();
+          cb();
+        })
+      );
       assert.ok(s instanceof http.IncomingMessage);
-    }));
-  server.listen(common.mustCall(() => {
-    const req = https.request({
-      port: server.address().port,
-      method: 'POST',
-      rejectUnauthorized: false
-    });
-    req.on('error', common.mustCall());
-    req.write('Hello');
-    // req is in progress
-  }));
+    })
+  );
+  server.listen(
+    common.mustCall(() => {
+      const req = https.request({
+        port: server.address().port,
+        method: 'POST',
+        rejectUnauthorized: false
+      });
+      req.on('error', common.mustCall());
+      req.write('Hello');
+      // req is in progress
+    })
+  );
 });
 
 test(function serverResponseTimeout(cb) {
@@ -96,19 +107,27 @@ test(function serverResponseTimeout(cb) {
     serverOptions,
     common.mustCall((req, res) => {
       // just do nothing, we should get a timeout event.
-      const s = res.setTimeout(50, common.mustCall((socket) => {
-        socket.destroy();
-        server.close();
-        cb();
-      }));
+      const s = res.setTimeout(
+        50,
+        common.mustCall((socket) => {
+          socket.destroy();
+          server.close();
+          cb();
+        })
+      );
       assert.ok(s instanceof http.OutgoingMessage);
-    }));
-  server.listen(common.mustCall(() => {
-    https.get({
-      port: server.address().port,
-      rejectUnauthorized: false
-    }).on('error', common.mustCall());
-  }));
+    })
+  );
+  server.listen(
+    common.mustCall(() => {
+      https
+        .get({
+          port: server.address().port,
+          rejectUnauthorized: false
+        })
+        .on('error', common.mustCall());
+    })
+  );
 });
 
 test(function serverRequestNotTimeoutAfterEnd(cb) {
@@ -119,18 +138,26 @@ test(function serverRequestNotTimeoutAfterEnd(cb) {
       const s = req.setTimeout(50, common.mustNotCall());
       assert.ok(s instanceof http.IncomingMessage);
       res.on('timeout', common.mustCall());
-    }));
-  server.on('timeout', common.mustCall((socket) => {
-    socket.destroy();
-    server.close();
-    cb();
-  }));
-  server.listen(common.mustCall(() => {
-    https.get({
-      port: server.address().port,
-      rejectUnauthorized: false
-    }).on('error', common.mustCall());
-  }));
+    })
+  );
+  server.on(
+    'timeout',
+    common.mustCall((socket) => {
+      socket.destroy();
+      server.close();
+      cb();
+    })
+  );
+  server.listen(
+    common.mustCall(() => {
+      https
+        .get({
+          port: server.address().port,
+          rejectUnauthorized: false
+        })
+        .on('error', common.mustCall());
+    })
+  );
 });
 
 test(function serverResponseTimeoutWithPipeline(cb) {
@@ -140,8 +167,7 @@ test(function serverResponseTimeoutWithPipeline(cb) {
     assert.strictEqual(caughtTimeout, '/2');
   });
   const server = https.createServer(serverOptions, (req, res) => {
-    if (req.url === '/2')
-      secReceived = true;
+    if (req.url === '/2') secReceived = true;
     if (req.url === '/1') {
       res.end();
       return;
@@ -151,52 +177,67 @@ test(function serverResponseTimeoutWithPipeline(cb) {
     });
     assert.ok(s instanceof http.OutgoingMessage);
   });
-  server.on('timeout', common.mustCall((socket) => {
-    if (secReceived) {
-      socket.destroy();
-      server.close();
-      cb();
-    }
-  }));
-  server.listen(common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true,
-      rejectUnauthorized: false
-    };
-    const c = tls.connect(options, () => {
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-    });
-  }));
+  server.on(
+    'timeout',
+    common.mustCall((socket) => {
+      if (secReceived) {
+        socket.destroy();
+        server.close();
+        cb();
+      }
+    })
+  );
+  server.listen(
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true,
+        rejectUnauthorized: false
+      };
+      const c = tls.connect(
+        options,
+        () => {
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+        }
+      );
+    })
+  );
 });
 
 test(function idleTimeout(cb) {
   // Test that the an idle connection invokes the timeout callback.
   const server = https.createServer(serverOptions);
-  const s = server.setTimeout(50, common.mustCall((socket) => {
-    socket.destroy();
-    server.close();
-    cb();
-  }));
+  const s = server.setTimeout(
+    50,
+    common.mustCall((socket) => {
+      socket.destroy();
+      server.close();
+      cb();
+    })
+  );
   assert.ok(s instanceof https.Server);
-  server.listen(common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true,
-      rejectUnauthorized: false
-    };
-    const c = tls.connect(options, () => {
-      // ECONNRESET could happen on a heavily-loaded server.
-      c.on('error', (e) => {
-        if (e.message !== 'read ECONNRESET')
-          throw e;
-      });
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      // Keep-Alive
-    });
-  }));
+  server.listen(
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true,
+        rejectUnauthorized: false
+      };
+      const c = tls.connect(
+        options,
+        () => {
+          // ECONNRESET could happen on a heavily-loaded server.
+          c.on('error', (e) => {
+            if (e.message !== 'read ECONNRESET') throw e;
+          });
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          // Keep-Alive
+        }
+      );
+    })
+  );
 });
 
 test(function fastTimeout(cb) {
@@ -213,29 +254,38 @@ test(function fastTimeout(cb) {
     }
   }
 
-  const server = https.createServer(serverOptions, common.mustCall(
-    (req, res) => {
+  const server = https.createServer(
+    serverOptions,
+    common.mustCall((req, res) => {
       req.on('timeout', common.mustNotCall());
       res.end();
       connectionHandlerInvoked = true;
       invokeCallbackIfDone();
-    }
-  ));
-  const s = server.setTimeout(1, common.mustCall((socket) => {
-    connectionSocket = socket;
-    timeoutHandlerInvoked = true;
-    invokeCallbackIfDone();
-  }));
+    })
+  );
+  const s = server.setTimeout(
+    1,
+    common.mustCall((socket) => {
+      connectionSocket = socket;
+      timeoutHandlerInvoked = true;
+      invokeCallbackIfDone();
+    })
+  );
   assert.ok(s instanceof https.Server);
-  server.listen(common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true,
-      rejectUnauthorized: false
-    };
-    const c = tls.connect(options, () => {
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      // Keep-Alive
-    });
-  }));
+  server.listen(
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true,
+        rejectUnauthorized: false
+      };
+      const c = tls.connect(
+        options,
+        () => {
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          // Keep-Alive
+        }
+      );
+    })
+  );
 });
diff --git a/test/parallel/test-https-simple.js b/test/parallel/test-https-simple.js
index b6a7c692ebb5ae..a35d3fb122eed3 100644
--- a/test/parallel/test-https-simple.js
+++ b/test/parallel/test-https-simple.js
@@ -23,8 +23,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -53,61 +52,73 @@ const serverCallback = common.mustCall(function(req, res) {
 
 const server = https.createServer(options, serverCallback);
 
-server.listen(0, common.mustCall(() => {
-  // Do a request ignoring the unauthorized server certs
-  const port = server.address().port;
-
-  const noCertCheckOptions = {
-    hostname: '127.0.0.1',
-    port: port,
-    path: '/',
-    method: 'GET',
-    rejectUnauthorized: false
-  };
-
-  noCertCheckOptions.Agent = new https.Agent(noCertCheckOptions);
-
-  const req = https.request(noCertCheckOptions, common.mustCall((res) => {
-    let responseBody = '';
-    res.on('data', function(d) {
-      responseBody = responseBody + d;
-    });
-
-    res.on('end', common.mustCall(() => {
-      assert.strictEqual(responseBody, body);
-      testSucceeded();
-    }));
-  }));
-  req.end();
-
-  req.on('error', function(e) {
-    throw e;
-  });
-
-  // Do a request that throws error due to the invalid server certs
-  const checkCertOptions = {
-    hostname: '127.0.0.1',
-    port: port,
-    path: '/',
-    method: 'GET'
-  };
-
-  const checkCertReq = https.request(checkCertOptions, function(res) {
-    res.on('data', function() {
-      throw new Error('data should not be received');
+server.listen(
+  0,
+  common.mustCall(() => {
+    // Do a request ignoring the unauthorized server certs
+    const port = server.address().port;
+
+    const noCertCheckOptions = {
+      hostname: '127.0.0.1',
+      port: port,
+      path: '/',
+      method: 'GET',
+      rejectUnauthorized: false
+    };
+
+    noCertCheckOptions.Agent = new https.Agent(noCertCheckOptions);
+
+    const req = https.request(
+      noCertCheckOptions,
+      common.mustCall((res) => {
+        let responseBody = '';
+        res.on('data', function(d) {
+          responseBody = responseBody + d;
+        });
+
+        res.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(responseBody, body);
+            testSucceeded();
+          })
+        );
+      })
+    );
+    req.end();
+
+    req.on('error', function(e) {
+      throw e;
     });
 
-    res.on('end', function() {
-      throw new Error('connection should not be established');
+    // Do a request that throws error due to the invalid server certs
+    const checkCertOptions = {
+      hostname: '127.0.0.1',
+      port: port,
+      path: '/',
+      method: 'GET'
+    };
+
+    const checkCertReq = https.request(checkCertOptions, function(res) {
+      res.on('data', function() {
+        throw new Error('data should not be received');
+      });
+
+      res.on('end', function() {
+        throw new Error('connection should not be established');
+      });
     });
-  });
-  checkCertReq.end();
-
-  checkCertReq.on('error', common.mustCall((e) => {
-    assert.strictEqual(e.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE');
-    testSucceeded();
-  }));
-}));
+    checkCertReq.end();
+
+    checkCertReq.on(
+      'error',
+      common.mustCall((e) => {
+        assert.strictEqual(e.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE');
+        testSucceeded();
+      })
+    );
+  })
+);
 
 process.on('exit', function() {
   assert.strictEqual(successful, tests);
diff --git a/test/parallel/test-https-socket-options.js b/test/parallel/test-https-socket-options.js
index b41054d5aa0824..03d7ae61a5ca27 100644
--- a/test/parallel/test-https-socket-options.js
+++ b/test/parallel/test-https-socket-options.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const https = require('https');
@@ -44,15 +43,17 @@ const server_http = http.createServer(function(req, res) {
   res.end(body);
 });
 
-
 server_http.listen(0, function() {
-  const req = http.request({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, function(res) {
-    server_http.close();
-    res.resume();
-  });
+  const req = http.request(
+    {
+      port: this.address().port,
+      rejectUnauthorized: false
+    },
+    function(res) {
+      server_http.close();
+      res.resume();
+    }
+  );
   // These methods should exist on the request and get passed down to the socket
   req.setNoDelay(true);
   req.setTimeout(1000, () => {});
@@ -70,13 +71,16 @@ const server_https = https.createServer(options, function(req, res) {
 });
 
 server_https.listen(0, function() {
-  const req = https.request({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, function(res) {
-    server_https.close();
-    res.resume();
-  });
+  const req = https.request(
+    {
+      port: this.address().port,
+      rejectUnauthorized: false
+    },
+    function(res) {
+      server_https.close();
+      res.resume();
+    }
+  );
   // These methods should exist on the request and get passed down to the socket
   req.setNoDelay(true);
   req.setTimeout(1000, () => {});
diff --git a/test/parallel/test-https-strict.js b/test/parallel/test-https-strict.js
index 0e8f725a5db2ac..ab7d53d08316e1 100644
--- a/test/parallel/test-https-strict.js
+++ b/test/parallel/test-https-strict.js
@@ -22,17 +22,16 @@
 'use strict';
 const common = require('../common');
 const fixtures = require('../common/fixtures');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // disable strict server certificate validation by the client
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
 
 common.expectWarning(
   'Warning',
-  'Setting the NODE_TLS_REJECT_UNAUTHORIZED environment variable to \'0\' ' +
-  'makes TLS connections and HTTPS requests insecure by disabling ' +
-  'certificate verification.',
+  "Setting the NODE_TLS_REJECT_UNAUTHORIZED environment variable to '0' " +
+    'makes TLS connections and HTTPS requests insecure by disabling ' +
+    'certificate verification.',
   common.noWarnCode
 );
 
@@ -93,7 +92,6 @@ server3.listen(0, listening());
 const responseErrors = {};
 let pending = 0;
 
-
 function server(options) {
   const s = https.createServer(options, handler);
   s.requests = [];
@@ -141,24 +139,31 @@ function makeReq(path, port, error, host, ca) {
     options.headers = { host };
   }
   const req = https.get(options);
-  const server = port === server1.address().port ? server1 :
-    port === server2.address().port ? server2 :
-      port === server3.address().port ? server3 :
-        null;
+  const server =
+    port === server1.address().port
+      ? server1
+      : port === server2.address().port
+      ? server2
+      : port === server3.address().port
+      ? server3
+      : null;
   if (!server) throw new Error(`invalid port: ${port}`);
   server.expectCount++;
 
-  req.on('response', common.mustCall((res) => {
-    assert.strictEqual(res.connection.authorizationError, error);
-    responseErrors[path] = res.connection.authorizationError;
-    pending--;
-    if (pending === 0) {
-      server1.close();
-      server2.close();
-      server3.close();
-    }
-    res.resume();
-  }));
+  req.on(
+    'response',
+    common.mustCall((res) => {
+      assert.strictEqual(res.connection.authorizationError, error);
+      responseErrors[path] = res.connection.authorizationError;
+      pending--;
+      if (pending === 0) {
+        server1.close();
+        server2.close();
+        server3.close();
+      }
+      res.resume();
+    })
+  );
 }
 
 function allListening() {
@@ -169,33 +174,34 @@ function allListening() {
 
   // server1: host 'agent1', signed by ca1
   makeReq('/inv1', port1, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE');
-  makeReq('/inv1-ca1', port1, 'ERR_TLS_CERT_ALTNAME_INVALID',
-          null, ca1);
-  makeReq('/inv1-ca1ca2', port1, 'ERR_TLS_CERT_ALTNAME_INVALID',
-          null, [ca1, ca2]);
+  makeReq('/inv1-ca1', port1, 'ERR_TLS_CERT_ALTNAME_INVALID', null, ca1);
+  makeReq('/inv1-ca1ca2', port1, 'ERR_TLS_CERT_ALTNAME_INVALID', null, [
+    ca1,
+    ca2
+  ]);
   makeReq('/val1-ca1', port1, null, 'agent1', ca1);
   makeReq('/val1-ca1ca2', port1, null, 'agent1', [ca1, ca2]);
-  makeReq('/inv1-ca2', port1,
-          'UNABLE_TO_VERIFY_LEAF_SIGNATURE', 'agent1', ca2);
+  makeReq('/inv1-ca2', port1, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', 'agent1', ca2);
 
   // server2: self-signed, host = 'agent2'
   // doesn't matter that thename matches, all of these will error.
   makeReq('/inv2', port2, 'DEPTH_ZERO_SELF_SIGNED_CERT');
-  makeReq('/inv2-ca1', port2, 'DEPTH_ZERO_SELF_SIGNED_CERT',
-          'agent2', ca1);
-  makeReq('/inv2-ca1ca2', port2, 'DEPTH_ZERO_SELF_SIGNED_CERT',
-          'agent2', [ca1, ca2]);
+  makeReq('/inv2-ca1', port2, 'DEPTH_ZERO_SELF_SIGNED_CERT', 'agent2', ca1);
+  makeReq('/inv2-ca1ca2', port2, 'DEPTH_ZERO_SELF_SIGNED_CERT', 'agent2', [
+    ca1,
+    ca2
+  ]);
 
   // server3: host 'agent3', signed by ca2
   makeReq('/inv3', port3, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE');
   makeReq('/inv3-ca2', port3, 'ERR_TLS_CERT_ALTNAME_INVALID', null, ca2);
-  makeReq('/inv3-ca1ca2', port3, 'ERR_TLS_CERT_ALTNAME_INVALID',
-          null, [ca1, ca2]);
+  makeReq('/inv3-ca1ca2', port3, 'ERR_TLS_CERT_ALTNAME_INVALID', null, [
+    ca1,
+    ca2
+  ]);
   makeReq('/val3-ca2', port3, null, 'agent3', ca2);
   makeReq('/val3-ca1ca2', port3, null, 'agent3', [ca1, ca2]);
-  makeReq('/inv3-ca1', port3,
-          'UNABLE_TO_VERIFY_LEAF_SIGNATURE', 'agent1', ca1);
-
+  makeReq('/inv3-ca1', port3, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE', 'agent1', ca1);
 }
 
 process.on('exit', () => {
diff --git a/test/parallel/test-https-timeout-server-2.js b/test/parallel/test-https-timeout-server-2.js
index f4c423ec4a5b72..199d3cbd84a7a5 100644
--- a/test/parallel/test-https-timeout-server-2.js
+++ b/test/parallel/test-https-timeout-server-2.js
@@ -22,8 +22,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 
 const assert = require('assert');
diff --git a/test/parallel/test-https-timeout-server.js b/test/parallel/test-https-timeout-server.js
index ecc564192a03ba..db2288c59856ce 100644
--- a/test/parallel/test-https-timeout-server.js
+++ b/test/parallel/test-https-timeout-server.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
@@ -40,14 +39,17 @@ const options = {
 
 const server = https.createServer(options, common.mustNotCall());
 
-server.on('clientError', common.mustCall(function(err, conn) {
-  // Don't hesitate to update the asserts if the internal structure of
-  // the cleartext object ever changes. We're checking that the https.Server
-  // has closed the client connection.
-  assert.strictEqual(conn._secureEstablished, false);
-  server.close();
-  conn.destroy();
-}));
+server.on(
+  'clientError',
+  common.mustCall(function(err, conn) {
+    // Don't hesitate to update the asserts if the internal structure of
+    // the cleartext object ever changes. We're checking that the https.Server
+    // has closed the client connection.
+    assert.strictEqual(conn._secureEstablished, false);
+    server.close();
+    conn.destroy();
+  })
+);
 
 server.listen(0, function() {
   net.connect({ host: '127.0.0.1', port: this.address().port });
diff --git a/test/parallel/test-https-timeout.js b/test/parallel/test-https-timeout.js
index e034adc39d2899..00b20b313a2071 100644
--- a/test/parallel/test-https-timeout.js
+++ b/test/parallel/test-https-timeout.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const https = require('https');
@@ -34,27 +33,35 @@ const options = {
 };
 
 // a server that never replies
-const server = https.createServer(options, function() {
-  console.log('Got request.  Doing nothing.');
-}).listen(0, common.mustCall(function() {
-  const req = https.request({
-    host: 'localhost',
-    port: this.address().port,
-    path: '/',
-    method: 'GET',
-    rejectUnauthorized: false
-  });
-  req.setTimeout(10);
-  req.end();
+const server = https
+  .createServer(options, function() {
+    console.log('Got request.  Doing nothing.');
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      const req = https.request({
+        host: 'localhost',
+        port: this.address().port,
+        path: '/',
+        method: 'GET',
+        rejectUnauthorized: false
+      });
+      req.setTimeout(10);
+      req.end();
 
-  req.on('response', function() {
-    console.log('got response');
-  });
+      req.on('response', function() {
+        console.log('got response');
+      });
 
-  req.on('timeout', common.mustCall(function() {
-    console.log('timeout occurred outside');
-    req.destroy();
-    server.close();
-    process.exit(0);
-  }));
-}));
+      req.on(
+        'timeout',
+        common.mustCall(function() {
+          console.log('timeout occurred outside');
+          req.destroy();
+          server.close();
+          process.exit(0);
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-https-truncate.js b/test/parallel/test-https-truncate.js
index 1a14cf54088a30..cf5fc2994aa1b0 100644
--- a/test/parallel/test-https-truncate.js
+++ b/test/parallel/test-https-truncate.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -54,12 +53,14 @@ function httpsTest() {
   });
 }
 
-
 const test = common.mustCall(function(res) {
-  res.on('end', common.mustCall(function() {
-    assert.strictEqual(res.readableLength, 0);
-    assert.strictEqual(bytes, data.length);
-  }));
+  res.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(res.readableLength, 0);
+      assert.strictEqual(bytes, data.length);
+    })
+  );
 
   // Pause and then resume on each chunk, to ensure that there will be
   // a lone byte hanging out at the very end.
@@ -67,6 +68,8 @@ const test = common.mustCall(function(res) {
   res.on('data', function(chunk) {
     bytes += chunk.length;
     this.pause();
-    setTimeout(() => { this.resume(); }, 1);
+    setTimeout(() => {
+      this.resume();
+    }, 1);
   });
 });
diff --git a/test/parallel/test-https-unix-socket-self-signed.js b/test/parallel/test-https-unix-socket-self-signed.js
index 48207a7a22f52a..a7edab39f287c1 100644
--- a/test/parallel/test-https-unix-socket-self-signed.js
+++ b/test/parallel/test-https-unix-socket-self-signed.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
@@ -14,14 +13,20 @@ const options = {
   key: fixtures.readSync('test_key.pem')
 };
 
-const server = https.createServer(options, common.mustCall((req, res) => {
-  res.end('bye\n');
-  server.close();
-}));
+const server = https.createServer(
+  options,
+  common.mustCall((req, res) => {
+    res.end('bye\n');
+    server.close();
+  })
+);
 
-server.listen(common.PIPE, common.mustCall(() => {
-  https.get({
-    socketPath: common.PIPE,
-    rejectUnauthorized: false
-  });
-}));
+server.listen(
+  common.PIPE,
+  common.mustCall(() => {
+    https.get({
+      socketPath: common.PIPE,
+      rejectUnauthorized: false
+    });
+  })
+);
diff --git a/test/parallel/test-icu-data-dir.js b/test/parallel/test-icu-data-dir.js
index 47c955bc740fb3..19ac442b92a384 100644
--- a/test/parallel/test-icu-data-dir.js
+++ b/test/parallel/test-icu-data-dir.js
@@ -3,15 +3,14 @@ const common = require('../common');
 const os = require('os');
 
 const { hasSmallICU } = process.binding('config');
-if (!(common.hasIntl && hasSmallICU))
-  common.skip('missing Intl');
+if (!(common.hasIntl && hasSmallICU)) common.skip('missing Intl');
 
 const assert = require('assert');
 const { spawnSync } = require('child_process');
 
 const expected =
-    'could not initialize ICU (check NODE_ICU_DATA or ' +
-    `--icu-data-dir parameters)${os.EOL}`;
+  'could not initialize ICU (check NODE_ICU_DATA or ' +
+  `--icu-data-dir parameters)${os.EOL}`;
 
 {
   const child = spawnSync(process.execPath, ['--icu-data-dir=/', '-e', '0']);
diff --git a/test/parallel/test-icu-punycode.js b/test/parallel/test-icu-punycode.js
index 2501b1d86e7b88..5e58c69fd27c1a 100644
--- a/test/parallel/test-icu-punycode.js
+++ b/test/parallel/test-icu-punycode.js
@@ -2,8 +2,7 @@
 // Flags: --expose-internals
 const common = require('../common');
 
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const { internalBinding } = require('internal/test/binding');
 const icu = internalBinding('icu');
@@ -11,18 +10,27 @@ const assert = require('assert');
 
 const tests = require('../fixtures/url-idna.js');
 const fixtures = require('../common/fixtures');
-const wptToASCIITests = require(
-  fixtures.path('wpt', 'url', 'resources', 'toascii.json')
-);
+const wptToASCIITests = require(fixtures.path(
+  'wpt',
+  'url',
+  'resources',
+  'toascii.json'
+));
 
 {
   for (const [i, { ascii, unicode }] of tests.entries()) {
     assert.strictEqual(ascii, icu.toASCII(unicode), `toASCII(${i + 1})`);
     assert.strictEqual(unicode, icu.toUnicode(ascii), `toUnicode(${i + 1})`);
-    assert.strictEqual(ascii, icu.toASCII(icu.toUnicode(ascii)),
-                       `toASCII(toUnicode(${i + 1}))`);
-    assert.strictEqual(unicode, icu.toUnicode(icu.toASCII(unicode)),
-                       `toUnicode(toASCII(${i + 1}))`);
+    assert.strictEqual(
+      ascii,
+      icu.toASCII(icu.toUnicode(ascii)),
+      `toASCII(toUnicode(${i + 1}))`
+    );
+    assert.strictEqual(
+      unicode,
+      icu.toUnicode(icu.toASCII(unicode)),
+      `toUnicode(toASCII(${i + 1}))`
+    );
   }
 }
 
@@ -30,20 +38,24 @@ const wptToASCIITests = require(
   const errMessage = /^Error: Cannot convert name to ASCII$/;
 
   for (const [i, test] of wptToASCIITests.entries()) {
-    if (typeof test === 'string')
-      continue; // skip comments
+    if (typeof test === 'string') continue; // skip comments
     const { comment, input, output } = test;
     let caseComment = `case ${i + 1}`;
-    if (comment)
-      caseComment += ` (${comment})`;
+    if (comment) caseComment += ` (${comment})`;
     if (output === null) {
-      assert.throws(() => icu.toASCII(input),
-                    errMessage, `ToASCII ${caseComment}`);
+      assert.throws(
+        () => icu.toASCII(input),
+        errMessage,
+        `ToASCII ${caseComment}`
+      );
       icu.toASCII(input, true); // Should not throw.
     } else {
       assert.strictEqual(icu.toASCII(input), output, `ToASCII ${caseComment}`);
-      assert.strictEqual(icu.toASCII(input, true), output,
-                         `ToASCII ${caseComment} in lenient mode`);
+      assert.strictEqual(
+        icu.toASCII(input, true),
+        output,
+        `ToASCII ${caseComment} in lenient mode`
+      );
     }
     icu.toUnicode(input); // Should not throw.
   }
diff --git a/test/parallel/test-icu-stringwidth.js b/test/parallel/test-icu-stringwidth.js
index a66ab0ce8b1e8c..08d70a0f49768e 100644
--- a/test/parallel/test-icu-stringwidth.js
+++ b/test/parallel/test-icu-stringwidth.js
@@ -2,8 +2,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const assert = require('assert');
 const readline = require('internal/readline');
@@ -15,7 +14,7 @@ assert.strictEqual(readline.getStringWidth('a'), 1);
 assert.strictEqual(readline.getStringWidth(0x0061), 1);
 // Lo (Other Letter)
 assert.strictEqual(readline.getStringWidth('丁'), 2);
-assert.strictEqual(readline.getStringWidth(0x4E01), 2);
+assert.strictEqual(readline.getStringWidth(0x4e01), 2);
 // Surrogate pairs
 assert.strictEqual(readline.getStringWidth('\ud83d\udc78\ud83c\udfff'), 2);
 assert.strictEqual(readline.getStringWidth('👅'), 2);
@@ -30,22 +29,22 @@ assert.strictEqual(readline.getStringWidth(0x0007), 0);
 // Cc (Control): LINE FEED
 assert.strictEqual(readline.getStringWidth('\n'), 0);
 // Cf (Format): SOFT HYPHEN
-assert.strictEqual(readline.getStringWidth(0x00AD), 1);
+assert.strictEqual(readline.getStringWidth(0x00ad), 1);
 // Cf (Format): LEFT-TO-RIGHT MARK
 // Cf (Format): RIGHT-TO-LEFT MARK
 assert.strictEqual(readline.getStringWidth('\u200Ef\u200F'), 1);
 // Cn (Unassigned): Not a character
-assert.strictEqual(readline.getStringWidth(0x10FFEF), 1);
+assert.strictEqual(readline.getStringWidth(0x10ffef), 1);
 // Cn (Unassigned): Not a character (but in a CJK range)
-assert.strictEqual(readline.getStringWidth(0x3FFEF), 2);
+assert.strictEqual(readline.getStringWidth(0x3ffef), 2);
 // Mn (Nonspacing Mark): COMBINING ACUTE ACCENT
 assert.strictEqual(readline.getStringWidth(0x0301), 0);
 // Mc (Spacing Mark): BALINESE ADEG ADEG
 // Chosen as its Canonical_Combining_Class is not 0, but is not a 0-width
 // character.
-assert.strictEqual(readline.getStringWidth(0x1B44), 1);
+assert.strictEqual(readline.getStringWidth(0x1b44), 1);
 // Me (Enclosing Mark): COMBINING ENCLOSING CIRCLE
-assert.strictEqual(readline.getStringWidth(0x20DD), 0);
+assert.strictEqual(readline.getStringWidth(0x20dd), 0);
 
 // The following is an emoji sequence. In some implementations, it is
 // represented as a single glyph, in other implementations as a sequence
@@ -55,7 +54,9 @@ assert.strictEqual(readline.getStringWidth(0x20DD), 0);
 // individually.
 assert.strictEqual(readline.getStringWidth('👩‍👩‍👧‍👧'), 2);
 assert.strictEqual(
-  readline.getStringWidth('👩‍👩‍👧‍👧', { expandEmojiSequence: true }), 8);
+  readline.getStringWidth('👩‍👩‍👧‍👧', { expandEmojiSequence: true }),
+  8
+);
 
 // By default, unicode characters whose width is considered ambiguous will
 // be considered half-width. For these characters, getStringWidth will return
@@ -65,7 +66,9 @@ assert.strictEqual(
 // as 2 columns.
 assert.strictEqual(readline.getStringWidth('\u01d4'), 1);
 assert.strictEqual(
-  readline.getStringWidth('\u01d4', { ambiguousAsFullWidth: true }), 2);
+  readline.getStringWidth('\u01d4', { ambiguousAsFullWidth: true }),
+  2
+);
 
 // Control chars and combining chars are zero
 assert.strictEqual(readline.getStringWidth('\u200E\n\u220A\u20D2'), 1);
diff --git a/test/parallel/test-icu-transcode.js b/test/parallel/test-icu-transcode.js
index 07a7f07324ba5c..e399f5a9a1bcc1 100644
--- a/test/parallel/test-icu-transcode.js
+++ b/test/parallel/test-icu-transcode.js
@@ -2,8 +2,7 @@
 
 const common = require('../common');
 
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const buffer = require('buffer');
 const assert = require('assert');
@@ -11,11 +10,9 @@ const orig = Buffer.from('tést €', 'utf8');
 
 // Test Transcoding
 const tests = {
-  'latin1': [0x74, 0xe9, 0x73, 0x74, 0x20, 0x3f],
-  'ascii': [0x74, 0x3f, 0x73, 0x74, 0x20, 0x3f],
-  'ucs2': [0x74, 0x00, 0xe9, 0x00, 0x73,
-           0x00, 0x74, 0x00, 0x20, 0x00,
-           0xac, 0x20]
+  latin1: [0x74, 0xe9, 0x73, 0x74, 0x20, 0x3f],
+  ascii: [0x74, 0x3f, 0x73, 0x74, 0x20, 0x3f],
+  ucs2: [0x74, 0x00, 0xe9, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0xac, 0x20]
 };
 
 for (const test in tests) {
@@ -37,19 +34,19 @@ for (const test in tests) {
   const ucs2_to_utf8 = buffer.transcode(ucs2, 'ucs2', 'utf8');
   assert.deepStrictEqual(utf8, ucs2_to_utf8);
   assert.deepStrictEqual(ucs2, utf8_to_ucs2);
-  assert.strictEqual(ucs2_to_utf8.toString('utf8'),
-                     utf8_to_ucs2.toString('ucs2'));
+  assert.strictEqual(
+    ucs2_to_utf8.toString('utf8'),
+    utf8_to_ucs2.toString('ucs2')
+  );
 }
 
-common.expectsError(
-  () => buffer.transcode(null, 'utf8', 'ascii'),
-  {
-    type: TypeError,
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "source" argument must be one of type Buffer ' +
-             'or Uint8Array. Received type object'
-  }
-);
+common.expectsError(() => buffer.transcode(null, 'utf8', 'ascii'), {
+  type: TypeError,
+  code: 'ERR_INVALID_ARG_TYPE',
+  message:
+    'The "source" argument must be one of type Buffer ' +
+    'or Uint8Array. Received type object'
+});
 
 assert.throws(
   () => buffer.transcode(Buffer.from('a'), 'b', 'utf8'),
@@ -63,20 +60,24 @@ assert.throws(
 
 assert.deepStrictEqual(
   buffer.transcode(Buffer.from('hi', 'ascii'), 'ascii', 'utf16le'),
-  Buffer.from('hi', 'utf16le'));
+  Buffer.from('hi', 'utf16le')
+);
 assert.deepStrictEqual(
   buffer.transcode(Buffer.from('hi', 'latin1'), 'latin1', 'utf16le'),
-  Buffer.from('hi', 'utf16le'));
+  Buffer.from('hi', 'utf16le')
+);
 assert.deepStrictEqual(
   buffer.transcode(Buffer.from('hä', 'latin1'), 'latin1', 'utf16le'),
-  Buffer.from('hä', 'utf16le'));
+  Buffer.from('hä', 'utf16le')
+);
 
 // Test that Uint8Array arguments are okay.
 {
   const uint8array = new Uint8Array([...Buffer.from('hä', 'latin1')]);
   assert.deepStrictEqual(
     buffer.transcode(uint8array, 'latin1', 'utf16le'),
-    Buffer.from('hä', 'utf16le'));
+    Buffer.from('hä', 'utf16le')
+  );
 }
 
 {
diff --git a/test/parallel/test-inspect-async-hook-setup-at-inspect.js b/test/parallel/test-inspect-async-hook-setup-at-inspect.js
index 48de93c061479b..4be317a68daebb 100644
--- a/test/parallel/test-inspect-async-hook-setup-at-inspect.js
+++ b/test/parallel/test-inspect-async-hook-setup-at-inspect.js
@@ -29,33 +29,38 @@ async function waitForInitialSetup(session) {
 async function setupTimeoutForStackTrace(session) {
   console.error('[test]', 'Setting up timeout for async stack trace');
   await session.send([
-    { 'method': 'Runtime.evaluate',
-      'params': { expression: 'setupTimeoutWithBreak()' } },
-    { 'method': 'Debugger.resume' }
+    {
+      method: 'Runtime.evaluate',
+      params: { expression: 'setupTimeoutWithBreak()' }
+    },
+    { method: 'Debugger.resume' }
   ]);
 }
 
 async function checkAsyncStackTrace(session) {
   console.error('[test]', 'Verify basic properties of asyncStackTrace');
   const paused = await session.waitForBreakOnLine(8, '[eval]');
-  assert(paused.params.asyncStackTrace,
-         `${Object.keys(paused.params)} contains "asyncStackTrace" property`);
+  assert(
+    paused.params.asyncStackTrace,
+    `${Object.keys(paused.params)} contains "asyncStackTrace" property`
+  );
   assert(paused.params.asyncStackTrace.description, 'Timeout');
-  assert(paused.params.asyncStackTrace.callFrames
-           .some((frame) => frame.functionName === 'setupTimeoutWithBreak'));
+  assert(
+    paused.params.asyncStackTrace.callFrames.some(
+      (frame) => frame.functionName === 'setupTimeoutWithBreak'
+    )
+  );
 }
 
 async function runTests() {
   const instance = new NodeInstance(['--inspect=0'], script);
   const session = await instance.connectInspectorSession();
   await session.send([
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 10 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 10 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ]);
 
   await waitForInitialSetup(session);
diff --git a/test/parallel/test-inspect-support-for-node_options.js b/test/parallel/test-inspect-support-for-node_options.js
index 05c7ec24b90d30..4ed470d6f563b5 100644
--- a/test/parallel/test-inspect-support-for-node_options.js
+++ b/test/parallel/test-inspect-support-for-node_options.js
@@ -8,7 +8,6 @@ common.skipIfInspectorDisabled();
 checkForInspectSupport('--inspect');
 
 function checkForInspectSupport(flag) {
-
   const nodeOptions = JSON.stringify(flag);
   const numWorkers = 2;
   process.env.NODE_OPTIONS = flag;
@@ -22,9 +21,12 @@ function checkForInspectSupport(flag) {
       worker.disconnect();
     });
 
-    cluster.on('exit', common.mustCall((worker, code, signal) => {
-      const errMsg = `For NODE_OPTIONS ${nodeOptions}, failed to start cluster`;
-      assert.strictEqual(worker.exitedAfterDisconnect, true, errMsg);
-    }, numWorkers));
+    cluster.on(
+      'exit',
+      common.mustCall((worker, code, signal) => {
+        const errMsg = `For NODE_OPTIONS ${nodeOptions}, failed to start cluster`;
+        assert.strictEqual(worker.exitedAfterDisconnect, true, errMsg);
+      }, numWorkers)
+    );
   }
 }
diff --git a/test/parallel/test-inspector-esm.js b/test/parallel/test-inspector-esm.js
index d94f8d10bb08ca..a64af9ecc61295 100644
--- a/test/parallel/test-inspector-esm.js
+++ b/test/parallel/test-inspector-esm.js
@@ -20,46 +20,51 @@ function assertScopeValues({ result }, expected) {
 }
 
 async function testBreakpointOnStart(session) {
-  console.log('[test]',
-              'Verifying debugger stops on start (--inspect-brk option)');
+  console.log(
+    '[test]',
+    'Verifying debugger stops on start (--inspect-brk option)'
+  );
   const commands = [
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setPauseOnExceptions',
-      'params': { 'state': 'none' } },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 0 } },
-    { 'method': 'Profiler.enable' },
-    { 'method': 'Profiler.setSamplingInterval',
-      'params': { 'interval': 100 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setPauseOnExceptions', params: { state: 'none' } },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 0 } },
+    { method: 'Profiler.enable' },
+    { method: 'Profiler.setSamplingInterval', params: { interval: 100 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ];
 
   await session.send(commands);
   await session.waitForBreakOnLine(
-    0, UrlResolve(session.scriptURL().toString(), 'message.mjs'));
+    0,
+    UrlResolve(session.scriptURL().toString(), 'message.mjs')
+  );
 }
 
 async function testBreakpoint(session) {
   console.log('[test]', 'Setting a breakpoint and verifying it is hit');
   const commands = [
-    { 'method': 'Debugger.setBreakpointByUrl',
-      'params': { 'lineNumber': 7,
-                  'url': session.scriptURL(),
-                  'columnNumber': 0,
-                  'condition': ''
+    {
+      method: 'Debugger.setBreakpointByUrl',
+      params: {
+        lineNumber: 7,
+        url: session.scriptURL(),
+        columnNumber: 0,
+        condition: ''
       }
     },
-    { 'method': 'Debugger.resume' },
+    { method: 'Debugger.resume' }
   ];
   await session.send(commands);
   const { scriptSource } = await session.send({
-    'method': 'Debugger.getScriptSource',
-    'params': { 'scriptId': session.mainScriptId } });
-  assert(scriptSource && (scriptSource.includes(session.script())),
-         `Script source is wrong: ${scriptSource}`);
+    method: 'Debugger.getScriptSource',
+    params: { scriptId: session.mainScriptId }
+  });
+  assert(
+    scriptSource && scriptSource.includes(session.script()),
+    `Script source is wrong: ${scriptSource}`
+  );
 
   await session.waitForConsoleOutput('log', ['A message', 5]);
   const paused = await session.waitForBreakOnLine(7, session.scriptURL());
@@ -67,41 +72,46 @@ async function testBreakpoint(session) {
 
   console.log('[test]', 'Verify we can read current application state');
   const response = await session.send({
-    'method': 'Runtime.getProperties',
-    'params': {
-      'objectId': scopeId,
-      'ownProperties': false,
-      'accessorPropertiesOnly': false,
-      'generatePreview': true
+    method: 'Runtime.getProperties',
+    params: {
+      objectId: scopeId,
+      ownProperties: false,
+      accessorPropertiesOnly: false,
+      generatePreview: true
     }
   });
   assertScopeValues(response, { t: 1001, k: 1, message: 'A message' });
 
   let { result } = await session.send({
-    'method': 'Debugger.evaluateOnCallFrame', 'params': {
-      'callFrameId': '{"ordinal":0,"injectedScriptId":1}',
-      'expression': 'k + t',
-      'objectGroup': 'console',
-      'includeCommandLineAPI': true,
-      'silent': false,
-      'returnByValue': false,
-      'generatePreview': true
+    method: 'Debugger.evaluateOnCallFrame',
+    params: {
+      callFrameId: '{"ordinal":0,"injectedScriptId":1}',
+      expression: 'k + t',
+      objectGroup: 'console',
+      includeCommandLineAPI: true,
+      silent: false,
+      returnByValue: false,
+      generatePreview: true
     }
   });
 
   assert.strictEqual(result.value, 1002);
 
   result = (await session.send({
-    'method': 'Runtime.evaluate', 'params': {
-      'expression': '5 * 5'
+    method: 'Runtime.evaluate',
+    params: {
+      expression: '5 * 5'
     }
   })).result;
   assert.strictEqual(result.value, 25);
 }
 
 async function runTest() {
-  const child = new NodeInstance(['--inspect-brk=0', '--experimental-modules'],
-                                 '', fixtures.path('es-modules/loop.mjs'));
+  const child = new NodeInstance(
+    ['--inspect-brk=0', '--experimental-modules'],
+    '',
+    fixtures.path('es-modules/loop.mjs')
+  );
 
   const session = await child.connectInspectorSession();
   await testBreakpointOnStart(session);
diff --git a/test/parallel/test-inspector-multisession-js.js b/test/parallel/test-inspector-multisession-js.js
index 92879d3ff3a7df..dd40c8ea8a8041 100644
--- a/test/parallel/test-inspector-multisession-js.js
+++ b/test/parallel/test-inspector-multisession-js.js
@@ -23,8 +23,8 @@ async function test() {
   let session1Paused = false;
   let session2Paused = false;
 
-  session1.on('Debugger.paused', () => session1Paused = true);
-  session2.on('Debugger.paused', () => session2Paused = true);
+  session1.on('Debugger.paused', () => (session1Paused = true));
+  session2.on('Debugger.paused', () => (session2Paused = true));
 
   console.log('Connected');
 
@@ -33,14 +33,18 @@ async function test() {
   console.log('Debugger was enabled');
 
   await new Promise((resolve, reject) => {
-    session1.post('Debugger.setBreakpointByUrl', {
-      'lineNumber': 12,
-      'url': pathToFileURL(path.resolve(__dirname, __filename)).toString(),
-      'columnNumber': 0,
-      'condition': ''
-    }, (error, result) => {
-      return error ? reject(error) : resolve(result);
-    });
+    session1.post(
+      'Debugger.setBreakpointByUrl',
+      {
+        lineNumber: 12,
+        url: pathToFileURL(path.resolve(__dirname, __filename)).toString(),
+        columnNumber: 0,
+        condition: ''
+      },
+      (error, result) => {
+        return error ? reject(error) : resolve(result);
+      }
+    );
   });
   console.log('Breakpoint was set');
 
diff --git a/test/parallel/test-inspector-multisession-ws.js b/test/parallel/test-inspector-multisession-ws.js
index 02fde12e1c1c2f..59e4f4d91b5624 100644
--- a/test/parallel/test-inspector-multisession-ws.js
+++ b/test/parallel/test-inspector-multisession-ws.js
@@ -26,18 +26,14 @@ console.log('Ready');
 async function setupSession(node) {
   const session = await node.connectInspectorSession();
   await session.send([
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setPauseOnExceptions',
-      'params': { 'state': 'none' } },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 0 } },
-    { 'method': 'Profiler.enable' },
-    { 'method': 'Profiler.setSamplingInterval',
-      'params': { 'interval': 100 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setPauseOnExceptions', params: { state: 'none' } },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 0 } },
+    { method: 'Profiler.enable' },
+    { method: 'Profiler.setSamplingInterval', params: { interval: 100 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ]);
   return session;
 }
@@ -45,11 +41,13 @@ async function setupSession(node) {
 async function testSuspend(sessionA, sessionB) {
   console.log('[test]', 'Breaking in code and verifying events are fired');
   await sessionA.waitForNotification('Debugger.paused', 'Initial pause');
-  sessionA.send({ 'method': 'Debugger.resume' });
+  sessionA.send({ method: 'Debugger.resume' });
 
-  await sessionA.waitForNotification('Runtime.consoleAPICalled',
-                                     'Console output');
-  sessionA.send({ 'method': 'Debugger.pause' });
+  await sessionA.waitForNotification(
+    'Runtime.consoleAPICalled',
+    'Console output'
+  );
+  sessionA.send({ method: 'Debugger.pause' });
   return Promise.all([
     sessionA.waitForNotification('Debugger.paused', 'SessionA paused'),
     sessionB.waitForNotification('Debugger.paused', 'SessionB paused')
@@ -59,13 +57,15 @@ async function testSuspend(sessionA, sessionB) {
 async function runTest() {
   const child = new NodeInstance(undefined, script);
 
-  const [session1, session2] =
-      await Promise.all([setupSession(child), setupSession(child)]);
+  const [session1, session2] = await Promise.all([
+    setupSession(child),
+    setupSession(child)
+  ]);
   await testSuspend(session2, session1);
   console.log('[test]', 'Should shut down after both sessions disconnect');
 
   await session1.runToCompletion();
-  await session2.send({ 'method': 'Debugger.disable' });
+  await session2.send({ method: 'Debugger.disable' });
   await session2.disconnect();
   return child.expectShutdown();
 }
diff --git a/test/parallel/test-inspector-port-zero-cluster.js b/test/parallel/test-inspector-port-zero-cluster.js
index 0330f1d50e6f70..b1c09f23a136e6 100644
--- a/test/parallel/test-inspector-port-zero-cluster.js
+++ b/test/parallel/test-inspector-port-zero-cluster.js
@@ -14,37 +14,41 @@ const cluster = require('cluster');
 function serialFork() {
   return new Promise((res) => {
     const worker = cluster.fork();
-    worker.on('exit', common.mustCall((code, signal) => {
-      // code 0 is normal
-      // code 12 can happen if inspector could not bind because of a port clash
-      if (code !== 0 && code !== 12)
-        assert.fail(`code: ${code}, signal: ${signal}`);
-      const port = worker.process.spawnargs
-        .map((a) => (/=(?:.*:)?(\d{2,5})$/.exec(a) || [])[1])
-        .filter((p) => p)
-        .pop();
-      res(Number(port));
-    }));
+    worker.on(
+      'exit',
+      common.mustCall((code, signal) => {
+        // code 0 is normal
+        // code 12 can happen if inspector could not bind because of a port clash
+        if (code !== 0 && code !== 12)
+          assert.fail(`code: ${code}, signal: ${signal}`);
+        const port = worker.process.spawnargs
+          .map((a) => (/=(?:.*:)?(\d{2,5})$/.exec(a) || [])[1])
+          .filter((p) => p)
+          .pop();
+        res(Number(port));
+      })
+    );
   });
 }
 
 if (cluster.isMaster) {
   Promise.all([serialFork(), serialFork(), serialFork()])
-    .then(common.mustCall((ports) => {
-      ports.splice(0, 0, process.debugPort);
-      // 4 = [master, worker1, worker2, worker3].length()
-      assert.strictEqual(ports.length, 4);
-      assert(ports.every((port) => port > 0));
-      assert(ports.every((port) => port < 65536));
-      assert.strictEqual(ports[0] === 65535 ? 1024 : ports[0] + 1, ports[1]);
-      assert.strictEqual(ports[1] === 65535 ? 1024 : ports[1] + 1, ports[2]);
-      assert.strictEqual(ports[2] === 65535 ? 1024 : ports[2] + 1, ports[3]);
-    }))
-    .catch(
-      (err) => {
-        console.error(err);
-        process.exit(1);
-      });
+    .then(
+      common.mustCall((ports) => {
+        ports.splice(0, 0, process.debugPort);
+        // 4 = [master, worker1, worker2, worker3].length()
+        assert.strictEqual(ports.length, 4);
+        assert(ports.every((port) => port > 0));
+        assert(ports.every((port) => port < 65536));
+        assert.strictEqual(ports[0] === 65535 ? 1024 : ports[0] + 1, ports[1]);
+        assert.strictEqual(ports[1] === 65535 ? 1024 : ports[1] + 1, ports[2]);
+        assert.strictEqual(ports[2] === 65535 ? 1024 : ports[2] + 1, ports[3]);
+      })
+    )
+    .catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
 } else {
   process.exit(0);
 }
diff --git a/test/parallel/test-inspector-reported-host.js b/test/parallel/test-inspector-reported-host.js
index 142003e49f747c..f4c7ce15f50a22 100644
--- a/test/parallel/test-inspector-reported-host.js
+++ b/test/parallel/test-inspector-reported-host.js
@@ -13,7 +13,8 @@ async function test() {
   const response = await child.httpGet(null, '/json', madeUpHost);
   assert.ok(
     response[0].webSocketDebuggerUrl.startsWith(`ws://${madeUpHost}`),
-    response[0].webSocketDebuggerUrl);
+    response[0].webSocketDebuggerUrl
+  );
   child.kill();
 }
 
diff --git a/test/parallel/test-inspector-tracing-domain.js b/test/parallel/test-inspector-tracing-domain.js
index ecf15c5be97630..6c7b879e446e68 100644
--- a/test/parallel/test-inspector-tracing-domain.js
+++ b/test/parallel/test-inspector-tracing-domain.js
@@ -19,21 +19,21 @@ function compareIgnoringOrder(array1, array2) {
 function post(message, data) {
   return new Promise((resolve, reject) => {
     session.post(message, data, (err, result) => {
-      if (err)
-        reject(new Error(JSON.stringify(err)));
-      else
-        resolve(result);
+      if (err) reject(new Error(JSON.stringify(err)));
+      else resolve(result);
     });
   });
 }
 
 function generateTrace() {
-  return new Promise((resolve) => setTimeout(() => {
-    for (let i = 0; i < 1000000; i++) {
-      'test' + i;
-    }
-    resolve();
-  }, 1));
+  return new Promise((resolve) =>
+    setTimeout(() => {
+      for (let i = 0; i < 1000000; i++) {
+        'test' + i;
+      }
+      resolve();
+    }, 1)
+  );
 }
 
 async function test() {
@@ -45,19 +45,27 @@ async function test() {
   session.connect();
   let traceNotification = null;
   let tracingComplete = false;
-  session.on('NodeTracing.dataCollected', (n) => traceNotification = n);
-  session.on('NodeTracing.tracingComplete', () => tracingComplete = true);
+  session.on('NodeTracing.dataCollected', (n) => (traceNotification = n));
+  session.on('NodeTracing.tracingComplete', () => (tracingComplete = true));
   const { categories } = await post('NodeTracing.getCategories');
-  compareIgnoringOrder(['node', 'node.async', 'node.bootstrap', 'node.fs.sync',
-                        'node.perf', 'node.perf.usertiming',
-                        'node.perf.timerify', 'v8'],
-                       categories);
+  compareIgnoringOrder(
+    [
+      'node',
+      'node.async',
+      'node.bootstrap',
+      'node.fs.sync',
+      'node.perf',
+      'node.perf.usertiming',
+      'node.perf.timerify',
+      'v8'
+    ],
+    categories
+  );
 
   const traceConfig = { includedCategories: ['v8'] };
   await post('NodeTracing.start', { traceConfig });
 
-  for (let i = 0; i < 5; i++)
-    await generateTrace();
+  for (let i = 0; i < 5; i++) await generateTrace();
   JSON.stringify(await post('NodeTracing.stop', { traceConfig }));
   session.disconnect();
   assert(traceNotification.data.value.length > 0);
diff --git a/test/parallel/test-instanceof.js b/test/parallel/test-instanceof.js
index 658f1e29c7a60f..a9216d758973ae 100644
--- a/test/parallel/test-instanceof.js
+++ b/test/parallel/test-instanceof.js
@@ -3,7 +3,6 @@
 require('../common');
 const assert = require('assert');
 
-
 // Regression test for instanceof, see
 // https://github.com/nodejs/node/issues/7592
 const F = () => {};
diff --git a/test/parallel/test-internal-error-original-names.js b/test/parallel/test-internal-error-original-names.js
index 195e39b199cd4c..7aeb5483bbd970 100644
--- a/test/parallel/test-internal-error-original-names.js
+++ b/test/parallel/test-internal-error-original-names.js
@@ -11,9 +11,7 @@ require('../common');
 const assert = require('assert');
 const errors = require('internal/errors');
 
-
-errors.E('TEST_ERROR_1', 'Error for testing purposes: %s',
-         Error);
+errors.E('TEST_ERROR_1', 'Error for testing purposes: %s', Error);
 {
   const err = new errors.codes.TEST_ERROR_1('test');
   assert(err instanceof Error);
diff --git a/test/parallel/test-internal-errors.js b/test/parallel/test-internal-errors.js
index bf4688d89bd0ca..e7d38af0fcd35d 100644
--- a/test/parallel/test-internal-errors.js
+++ b/test/parallel/test-internal-errors.js
@@ -1,10 +1,7 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-const {
-  hijackStdout,
-  restoreStdout,
-} = require('../common/hijackstdio');
+const { hijackStdout, restoreStdout } = require('../common/hijackstdio');
 
 const { internalBinding } = require('internal/test/binding');
 const assert = require('assert');
@@ -14,8 +11,13 @@ const errors = require('internal/errors');
 const { inspect } = require('util');
 inspect.defaultOptions.colors = false;
 
-errors.E('TEST_ERROR_1', 'Error for testing purposes: %s',
-         Error, TypeError, RangeError);
+errors.E(
+  'TEST_ERROR_1',
+  'Error for testing purposes: %s',
+  Error,
+  TypeError,
+  RangeError
+);
 errors.E('TEST_ERROR_2', (a, b) => `${a} ${b}`, Error);
 
 {
@@ -51,96 +53,128 @@ errors.E('TEST_ERROR_2', (a, b) => `${a} ${b}`, Error);
 }
 
 {
-  assert.throws(
-    () => new errors.codes.TEST_ERROR_1(),
-    {
-      message: 'Code: TEST_ERROR_1; The provided arguments ' +
-               'length (0) does not match the required ones (1).'
-    }
-  );
+  assert.throws(() => new errors.codes.TEST_ERROR_1(), {
+    message:
+      'Code: TEST_ERROR_1; The provided arguments ' +
+      'length (0) does not match the required ones (1).'
+  });
 }
 
 // Tests for common.expectsError
-common.expectsError(() => {
-  throw new errors.codes.TEST_ERROR_1.TypeError('a');
-}, { code: 'TEST_ERROR_1' });
-common.expectsError(() => {
-  throw new errors.codes.TEST_ERROR_1.TypeError('a');
-}, { code: 'TEST_ERROR_1',
-     type: TypeError,
-     message: /^Error for testing/ });
-common.expectsError(() => {
-  throw new errors.codes.TEST_ERROR_1.TypeError('a');
-}, { code: 'TEST_ERROR_1', type: TypeError });
-common.expectsError(() => {
-  throw new errors.codes.TEST_ERROR_1.TypeError('a');
-}, {
-  code: 'TEST_ERROR_1',
-  type: TypeError,
-  message: 'Error for testing purposes: a'
-});
-
-common.expectsError(() => {
-  common.expectsError(() => {
+common.expectsError(
+  () => {
     throw new errors.codes.TEST_ERROR_1.TypeError('a');
-  }, { code: 'TEST_ERROR_1', type: RangeError });
-}, {
-  code: 'ERR_ASSERTION',
-  message: /\+   type: \[Function: TypeError]\n-   type: \[Function: RangeError]/
-});
-
-common.expectsError(() => {
-  common.expectsError(() => {
+  },
+  { code: 'TEST_ERROR_1' }
+);
+common.expectsError(
+  () => {
     throw new errors.codes.TEST_ERROR_1.TypeError('a');
-  }, { code: 'TEST_ERROR_1',
-       type: TypeError,
-       message: /^Error for testing 2/ });
-}, {
-  code: 'ERR_ASSERTION',
-  type: assert.AssertionError,
-  message: /\+   message: 'Error for testing purposes: a',\n-   message: \/\^Error/
-});
+  },
+  { code: 'TEST_ERROR_1', type: TypeError, message: /^Error for testing/ }
+);
+common.expectsError(
+  () => {
+    throw new errors.codes.TEST_ERROR_1.TypeError('a');
+  },
+  { code: 'TEST_ERROR_1', type: TypeError }
+);
+common.expectsError(
+  () => {
+    throw new errors.codes.TEST_ERROR_1.TypeError('a');
+  },
+  {
+    code: 'TEST_ERROR_1',
+    type: TypeError,
+    message: 'Error for testing purposes: a'
+  }
+);
 
-// Test ERR_INVALID_FD_TYPE
-assert.strictEqual(errors.getMessage('ERR_INVALID_FD_TYPE', ['a']),
-                   'Unsupported fd type: a');
+common.expectsError(
+  () => {
+    common.expectsError(
+      () => {
+        throw new errors.codes.TEST_ERROR_1.TypeError('a');
+      },
+      { code: 'TEST_ERROR_1', type: RangeError }
+    );
+  },
+  {
+    code: 'ERR_ASSERTION',
+    message: /\+   type: \[Function: TypeError]\n-   type: \[Function: RangeError]/
+  }
+);
 
-// Test ERR_INVALID_URL_SCHEME
-assert.strictEqual(errors.getMessage('ERR_INVALID_URL_SCHEME', ['file']),
-                   'The URL must be of scheme file');
-assert.strictEqual(errors.getMessage('ERR_INVALID_URL_SCHEME', [['file']]),
-                   'The URL must be of scheme file');
-assert.strictEqual(errors.getMessage('ERR_INVALID_URL_SCHEME',
-                                     [['http', 'ftp']]),
-                   'The URL must be one of scheme http or ftp');
-assert.strictEqual(errors.getMessage('ERR_INVALID_URL_SCHEME',
-                                     [['a', 'b', 'c']]),
-                   'The URL must be one of scheme a, b, or c');
 common.expectsError(
-  () => errors.getMessage('ERR_INVALID_URL_SCHEME', [[]]),
+  () => {
+    common.expectsError(
+      () => {
+        throw new errors.codes.TEST_ERROR_1.TypeError('a');
+      },
+      { code: 'TEST_ERROR_1', type: TypeError, message: /^Error for testing 2/ }
+    );
+  },
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
-    message: /^At least one expected value needs to be specified$/
-  });
+    message: /\+   message: 'Error for testing purposes: a',\n-   message: \/\^Error/
+  }
+);
+
+// Test ERR_INVALID_FD_TYPE
+assert.strictEqual(
+  errors.getMessage('ERR_INVALID_FD_TYPE', ['a']),
+  'Unsupported fd type: a'
+);
+
+// Test ERR_INVALID_URL_SCHEME
+assert.strictEqual(
+  errors.getMessage('ERR_INVALID_URL_SCHEME', ['file']),
+  'The URL must be of scheme file'
+);
+assert.strictEqual(
+  errors.getMessage('ERR_INVALID_URL_SCHEME', [['file']]),
+  'The URL must be of scheme file'
+);
+assert.strictEqual(
+  errors.getMessage('ERR_INVALID_URL_SCHEME', [['http', 'ftp']]),
+  'The URL must be one of scheme http or ftp'
+);
+assert.strictEqual(
+  errors.getMessage('ERR_INVALID_URL_SCHEME', [['a', 'b', 'c']]),
+  'The URL must be one of scheme a, b, or c'
+);
+common.expectsError(() => errors.getMessage('ERR_INVALID_URL_SCHEME', [[]]), {
+  code: 'ERR_ASSERTION',
+  type: assert.AssertionError,
+  message: /^At least one expected value needs to be specified$/
+});
 
 // Test ERR_MISSING_ARGS
-assert.strictEqual(errors.getMessage('ERR_MISSING_ARGS', ['name']),
-                   'The "name" argument must be specified');
-assert.strictEqual(errors.getMessage('ERR_MISSING_ARGS', ['name', 'value']),
-                   'The "name" and "value" arguments must be specified');
-assert.strictEqual(errors.getMessage('ERR_MISSING_ARGS', ['a', 'b', 'c']),
-                   'The "a", "b", and "c" arguments must be specified');
+assert.strictEqual(
+  errors.getMessage('ERR_MISSING_ARGS', ['name']),
+  'The "name" argument must be specified'
+);
+assert.strictEqual(
+  errors.getMessage('ERR_MISSING_ARGS', ['name', 'value']),
+  'The "name" and "value" arguments must be specified'
+);
+assert.strictEqual(
+  errors.getMessage('ERR_MISSING_ARGS', ['a', 'b', 'c']),
+  'The "a", "b", and "c" arguments must be specified'
+);
 
 // Test ERR_SOCKET_BAD_PORT
 assert.strictEqual(
   errors.getMessage('ERR_SOCKET_BAD_PORT', [0]),
-  'Port should be >= 0 and < 65536. Received 0.');
+  'Port should be >= 0 and < 65536. Received 0.'
+);
 
 // Test ERR_TLS_CERT_ALTNAME_INVALID
 assert.strictEqual(
   errors.getMessage('ERR_TLS_CERT_ALTNAME_INVALID', ['altname']),
-  'Hostname/IP does not match certificate\'s altnames: altname');
+  "Hostname/IP does not match certificate's altnames: altname"
+);
 
 assert.strictEqual(
   errors.getMessage('ERR_INVALID_PROTOCOL', ['bad protocol', 'http']),
@@ -170,23 +204,28 @@ assert.strictEqual(
 // Test ERR_DNS_SET_SERVERS_FAILED
 assert.strictEqual(
   errors.getMessage('ERR_DNS_SET_SERVERS_FAILED', ['err', 'servers']),
-  'c-ares failed to set servers: "err" [servers]');
+  'c-ares failed to set servers: "err" [servers]'
+);
 
 // Test ERR_ENCODING_NOT_SUPPORTED
 assert.strictEqual(
   errors.getMessage('ERR_ENCODING_NOT_SUPPORTED', ['enc']),
-  'The "enc" encoding is not supported');
+  'The "enc" encoding is not supported'
+);
 
 // Test error messages for async_hooks
 assert.strictEqual(
   errors.getMessage('ERR_ASYNC_CALLBACK', ['init']),
-  'init must be a function');
+  'init must be a function'
+);
 assert.strictEqual(
   errors.getMessage('ERR_ASYNC_TYPE', [{}]),
-  'Invalid name for async "type": [object Object]');
+  'Invalid name for async "type": [object Object]'
+);
 assert.strictEqual(
   errors.getMessage('ERR_INVALID_ASYNC_ID', ['asyncId', undefined]),
-  'Invalid asyncId value: undefined');
+  'Invalid asyncId value: undefined'
+);
 
 {
   const { kMaxLength } = internalBinding('buffer');
@@ -201,17 +240,19 @@ assert.strictEqual(
   const error = new errors.codes.ERR_INVALID_ARG_VALUE('foo', '\u0000bar');
   assert.strictEqual(
     error.message,
-    'The argument \'foo\' is invalid. Received \'\\u0000bar\''
+    "The argument 'foo' is invalid. Received '\\u0000bar'"
   );
 }
 
 {
   const error = new errors.codes.ERR_INVALID_ARG_VALUE(
-    'foo', { a: 1 }, 'must have property \'b\''
+    'foo',
+    { a: 1 },
+    "must have property 'b'"
   );
   assert.strictEqual(
     error.message,
-    'The argument \'foo\' must have property \'b\'. Received { a: 1 }'
+    "The argument 'foo' must have property 'b'. Received { a: 1 }"
   );
 }
 
@@ -250,7 +291,9 @@ assert.strictEqual(
 // browser. Note that `message` remains non-enumerable after being assigned.
 {
   let initialConsoleLog = '';
-  hijackStdout((data) => { initialConsoleLog += data; });
+  hijackStdout((data) => {
+    initialConsoleLog += data;
+  });
   const myError = new errors.codes.ERR_TLS_HANDSHAKE_TIMEOUT();
   assert.deepStrictEqual(Object.keys(myError), []);
   const initialToString = myError.toString();
@@ -260,7 +303,9 @@ assert.strictEqual(
   restoreStdout();
 
   let subsequentConsoleLog = '';
-  hijackStdout((data) => { subsequentConsoleLog += data; });
+  hijackStdout((data) => {
+    subsequentConsoleLog += data;
+  });
   myError.message = 'Fhqwhgads';
   assert.deepStrictEqual(Object.keys(myError), []);
   assert.notStrictEqual(myError.toString(), initialToString);
diff --git a/test/parallel/test-internal-fs.js b/test/parallel/test-internal-fs.js
index 2e47e2a3823a9c..0cff670b43fd27 100644
--- a/test/parallel/test-internal-fs.js
+++ b/test/parallel/test-internal-fs.js
@@ -8,7 +8,7 @@ const fs = require('internal/fs/utils');
 fs.assertEncoding();
 fs.assertEncoding('utf8');
 
-common.expectsError(
-  () => fs.assertEncoding('foo'),
-  { code: 'ERR_INVALID_OPT_VALUE_ENCODING', type: TypeError }
-);
+common.expectsError(() => fs.assertEncoding('foo'), {
+  code: 'ERR_INVALID_OPT_VALUE_ENCODING',
+  type: TypeError
+});
diff --git a/test/parallel/test-internal-module-map-asserts.js b/test/parallel/test-internal-module-map-asserts.js
index 4563fc605e0792..9dad6562f6405d 100644
--- a/test/parallel/test-internal-module-map-asserts.js
+++ b/test/parallel/test-internal-module-map-asserts.js
@@ -8,11 +8,14 @@ const ModuleMap = require('internal/modules/esm/module_map');
 // ModuleMap.get, ModuleMap.has and ModuleMap.set should only accept string
 // values as url argument.
 {
-  const errorReg = common.expectsError({
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: /^The "url" argument must be of type string/
-  }, 15);
+  const errorReg = common.expectsError(
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: /^The "url" argument must be of type string/
+    },
+    15
+  );
 
   const moduleMap = new ModuleMap();
 
@@ -30,11 +33,14 @@ const ModuleMap = require('internal/modules/esm/module_map');
 
 // ModuleMap.set, job argument should only accept ModuleJob values.
 {
-  const errorReg = common.expectsError({
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: /^The "job" argument must be of type ModuleJob/
-  }, 5);
+  const errorReg = common.expectsError(
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: /^The "job" argument must be of type ModuleJob/
+    },
+    5
+  );
 
   const moduleMap = new ModuleMap();
 
diff --git a/test/parallel/test-internal-modules-strip-shebang.js b/test/parallel/test-internal-modules-strip-shebang.js
index 6c23848a969231..37960522c7f278 100644
--- a/test/parallel/test-internal-modules-strip-shebang.js
+++ b/test/parallel/test-internal-modules-strip-shebang.js
@@ -10,5 +10,5 @@ const stripShebang = require('internal/modules/cjs/helpers').stripShebang;
   ['aa', 'aa'],
   ['#!', ''],
   ['#!bin/bash', ''],
-  ['#!bin/bash\naa', '\naa'],
+  ['#!bin/bash\naa', '\naa']
 ].forEach((i) => assert.strictEqual(stripShebang(i[0]), i[1]));
diff --git a/test/parallel/test-internal-modules.js b/test/parallel/test-internal-modules.js
index c61d957acd0542..a5d4161053347b 100644
--- a/test/parallel/test-internal-modules.js
+++ b/test/parallel/test-internal-modules.js
@@ -7,7 +7,4 @@ assert.throws(function() {
   require('internal/freelist');
 }, /^Error: Cannot find module 'internal\/freelist'$/);
 
-assert.strictEqual(
-  require(fixtures.path('internal-modules')),
-  42
-);
+assert.strictEqual(require(fixtures.path('internal-modules')), 42);
diff --git a/test/parallel/test-internal-socket-list-send.js b/test/parallel/test-internal-socket-list-send.js
index 2e69edcedffd9f..a45353d627c215 100644
--- a/test/parallel/test-internal-socket-list-send.js
+++ b/test/parallel/test-internal-socket-list-send.js
@@ -16,14 +16,19 @@ const key = 'test-key';
 
   const list = new SocketListSend(child, 'test');
 
-  list._request('msg', 'cmd', false, common.mustCall((err) => {
-    common.expectsError({
-      code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
-      type: Error,
-      message: 'Child closed before reply received'
-    })(err);
-    assert.strictEqual(child.listenerCount('internalMessage'), 0);
-  }));
+  list._request(
+    'msg',
+    'cmd',
+    false,
+    common.mustCall((err) => {
+      common.expectsError({
+        code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
+        type: Error,
+        message: 'Child closed before reply received'
+      })(err);
+      assert.strictEqual(child.listenerCount('internalMessage'), 0);
+    })
+  );
 }
 
 // Verify that the given message will be received in callback.
@@ -31,21 +36,24 @@ const key = 'test-key';
   const child = Object.assign(new EventEmitter(), {
     connected: true,
     _send: function(msg) {
-      process.nextTick(() =>
-        this.emit('internalMessage', { key, cmd: 'cmd' })
-      );
+      process.nextTick(() => this.emit('internalMessage', { key, cmd: 'cmd' }));
     }
   });
 
   const list = new SocketListSend(child, key);
 
-  list._request('msg', 'cmd', false, common.mustCall((err, msg) => {
-    assert.strictEqual(err, null);
-    assert.strictEqual(msg.cmd, 'cmd');
-    assert.strictEqual(msg.key, key);
-    assert.strictEqual(child.listenerCount('internalMessage'), 0);
-    assert.strictEqual(child.listenerCount('disconnect'), 0);
-  }));
+  list._request(
+    'msg',
+    'cmd',
+    false,
+    common.mustCall((err, msg) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(msg.cmd, 'cmd');
+      assert.strictEqual(msg.key, key);
+      assert.strictEqual(child.listenerCount('internalMessage'), 0);
+      assert.strictEqual(child.listenerCount('disconnect'), 0);
+    })
+  );
 }
 
 // Verify that an error will be received in callback when child was
@@ -53,19 +61,26 @@ const key = 'test-key';
 {
   const child = Object.assign(new EventEmitter(), {
     connected: true,
-    _send: function(msg) { process.nextTick(() => this.emit('disconnect')); }
+    _send: function(msg) {
+      process.nextTick(() => this.emit('disconnect'));
+    }
   });
 
   const list = new SocketListSend(child, key);
 
-  list._request('msg', 'cmd', false, common.mustCall((err) => {
-    common.expectsError({
-      code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
-      type: Error,
-      message: 'Child closed before reply received'
-    })(err);
-    assert.strictEqual(child.listenerCount('internalMessage'), 0);
-  }));
+  list._request(
+    'msg',
+    'cmd',
+    false,
+    common.mustCall((err) => {
+      common.expectsError({
+        code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
+        type: Error,
+        message: 'Child closed before reply received'
+      })(err);
+      assert.strictEqual(child.listenerCount('internalMessage'), 0);
+    })
+  );
 }
 
 // Verify that a "NODE_SOCKET_ALL_CLOSED" message will be received
@@ -84,13 +99,15 @@ const key = 'test-key';
 
   const list = new SocketListSend(child, key);
 
-  list.close(common.mustCall((err, msg) => {
-    assert.strictEqual(err, null);
-    assert.strictEqual(msg.cmd, 'NODE_SOCKET_ALL_CLOSED');
-    assert.strictEqual(msg.key, key);
-    assert.strictEqual(child.listenerCount('internalMessage'), 0);
-    assert.strictEqual(child.listenerCount('disconnect'), 0);
-  }));
+  list.close(
+    common.mustCall((err, msg) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(msg.cmd, 'NODE_SOCKET_ALL_CLOSED');
+      assert.strictEqual(msg.key, key);
+      assert.strictEqual(child.listenerCount('internalMessage'), 0);
+      assert.strictEqual(child.listenerCount('disconnect'), 0);
+    })
+  );
 }
 
 // Verify that the count of connections will be received in callback.
@@ -113,12 +130,14 @@ const key = 'test-key';
 
   const list = new SocketListSend(child, key);
 
-  list.getConnections(common.mustCall((err, msg) => {
-    assert.strictEqual(err, null);
-    assert.strictEqual(msg, count);
-    assert.strictEqual(child.listenerCount('internalMessage'), 0);
-    assert.strictEqual(child.listenerCount('disconnect'), 0);
-  }));
+  list.getConnections(
+    common.mustCall((err, msg) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(msg, count);
+      assert.strictEqual(child.listenerCount('internalMessage'), 0);
+      assert.strictEqual(child.listenerCount('disconnect'), 0);
+    })
+  );
 }
 
 // Verify that an error will be received in callback when child is
@@ -137,12 +156,14 @@ const key = 'test-key';
 
   const list = new SocketListSend(child, key);
 
-  list.getConnections(common.mustCall((err) => {
-    common.expectsError({
-      code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
-      type: Error,
-      message: 'Child closed before reply received'
-    })(err);
-    assert.strictEqual(child.listenerCount('internalMessage'), 0);
-  }));
+  list.getConnections(
+    common.mustCall((err) => {
+      common.expectsError({
+        code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
+        type: Error,
+        message: 'Child closed before reply received'
+      })(err);
+      assert.strictEqual(child.listenerCount('internalMessage'), 0);
+    })
+  );
 }
diff --git a/test/parallel/test-internal-util-decorate-error-stack.js b/test/parallel/test-internal-util-decorate-error-stack.js
index 40fbf1d48caf20..dbd16c1d8c55bc 100644
--- a/test/parallel/test-internal-util-decorate-error-stack.js
+++ b/test/parallel/test-internal-util-decorate-error-stack.js
@@ -36,8 +36,9 @@ function checkStack(stack) {
   assert.ok(/\n/g.test(stack));
 }
 let err;
-const badSyntaxPath =
-  fixtures.path('syntax', 'bad_syntax').replace(/\\/g, '\\\\');
+const badSyntaxPath = fixtures
+  .path('syntax', 'bad_syntax')
+  .replace(/\\/g, '\\\\');
 
 try {
   require(badSyntaxPath);
@@ -54,10 +55,7 @@ decorateErrorStack(err);
 checkStack(err.stack);
 
 // Verify that the stack is only decorated once for uncaught exceptions.
-const args = [
-  '-e',
-  `require('${badSyntaxPath}')`
-];
+const args = ['-e', `require('${badSyntaxPath}')`];
 const result = spawnSync(process.argv[0], args, { encoding: 'utf8' });
 checkStack(result.stderr);
 
@@ -78,4 +76,6 @@ decorateErrorStack(err);
 
 assert.strictEqual(err.stack, `${arrowMessage}${originalStack}`);
 assert.strictEqual(
-  binding.getHiddenValue(err, kDecoratedPrivateSymbolIndex), true);
+  binding.getHiddenValue(err, kDecoratedPrivateSymbolIndex),
+  true
+);
diff --git a/test/parallel/test-intl-v8BreakIterator.js b/test/parallel/test-intl-v8BreakIterator.js
index 257d6b2a769083..d8fda6ffd43520 100644
--- a/test/parallel/test-intl-v8BreakIterator.js
+++ b/test/parallel/test-intl-v8BreakIterator.js
@@ -3,8 +3,7 @@ const common = require('../common');
 const assert = require('assert');
 const vm = require('vm');
 
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 assert(!('v8BreakIterator' in Intl));
 assert(!vm.runInNewContext('"v8BreakIterator" in Intl'));
diff --git a/test/parallel/test-intl.js b/test/parallel/test-intl.js
index c55f554b00f55a..42f3c790c07aae 100644
--- a/test/parallel/test-intl.js
+++ b/test/parallel/test-intl.js
@@ -48,14 +48,11 @@ assert.strictEqual('ç'.toLocaleUpperCase('tr'), 'Ç');
 assert.strictEqual('ç'.toUpperCase(), 'Ç');
 
 if (!common.hasIntl) {
-  const erMsg =
-    `"Intl" object is NOT present but v8_enable_i18n_support is ${enablei18n}`;
+  const erMsg = `"Intl" object is NOT present but v8_enable_i18n_support is ${enablei18n}`;
   assert.strictEqual(enablei18n, 0, erMsg);
   common.skip('Intl tests because Intl object not present.');
 } else {
-  const erMsg =
-    `"Intl" object is present but v8_enable_i18n_support is ${
-      enablei18n}. Is this test out of date?`;
+  const erMsg = `"Intl" object is present but v8_enable_i18n_support is ${enablei18n}. Is this test out of date?`;
   assert.strictEqual(enablei18n, 1, erMsg);
 
   // Construct a new date at the beginning of Unix time
@@ -74,7 +71,8 @@ if (!common.hasIntl) {
   // If list is specified and doesn't contain 'en' then return.
   if (process.config.variables.icu_locales && !haveLocale('en')) {
     common.printSkipMessage(
-      'detailed Intl tests because English is not listed as supported.');
+      'detailed Intl tests because English is not listed as supported.'
+    );
     // Smoke test. Does it format anything, or fail?
     console.log(`Date(0) formatted to: ${dtf.format(date0)}`);
     return;
@@ -100,7 +98,7 @@ if (!common.hasIntl) {
   }
   // number format
   {
-    const numberFormat = new Intl.NumberFormat(['en']).format(12345.67890);
+    const numberFormat = new Intl.NumberFormat(['en']).format(12345.6789);
     assert.strictEqual(numberFormat, '12,345.679');
   }
   // Significant Digits
diff --git a/test/parallel/test-listen-fd-cluster.js b/test/parallel/test-listen-fd-cluster.js
index da8abd868300e3..df763009c4af12 100644
--- a/test/parallel/test-listen-fd-cluster.js
+++ b/test/parallel/test-listen-fd-cluster.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('This test is disabled on windows.');
+if (common.isWindows) common.skip('This test is disabled on windows.');
 
 const assert = require('assert');
 const http = require('http');
@@ -37,8 +36,10 @@ console.error('Cluster listen fd test', process.argv[2] || 'runner');
 //   -> master: the cluster master
 //        -> worker: the cluster worker
 switch (process.argv[2]) {
-  case 'master': return master();
-  case 'worker': return worker();
+  case 'master':
+    return master();
+  case 'worker':
+    return worker();
 }
 
 let ok;
@@ -55,69 +56,73 @@ process.on('exit', function() {
 // a more low-level approach, use child process IPC manually.
 test(function(parent, port) {
   // now make sure that we can request to the worker, then kill it.
-  http.get({
-    server: 'localhost',
-    port: port,
-    path: '/',
-  }).on('response', function(res) {
-    let s = '';
-    res.on('data', function(c) {
-      s += c.toString();
-    });
-    res.on('end', function() {
-      // kill the worker before we start doing asserts.
-      // it's really annoying when tests leave orphans!
-      parent.kill();
-      parent.on('exit', function() {
-        assert.strictEqual(s, 'hello from worker\n');
-        assert.strictEqual(res.statusCode, 200);
-        console.log('ok');
-        ok = true;
+  http
+    .get({
+      server: 'localhost',
+      port: port,
+      path: '/'
+    })
+    .on('response', function(res) {
+      let s = '';
+      res.on('data', function(c) {
+        s += c.toString();
+      });
+      res.on('end', function() {
+        // kill the worker before we start doing asserts.
+        // it's really annoying when tests leave orphans!
+        parent.kill();
+        parent.on('exit', function() {
+          assert.strictEqual(s, 'hello from worker\n');
+          assert.strictEqual(res.statusCode, 200);
+          console.log('ok');
+          ok = true;
+        });
       });
     });
-  });
 });
 
 function test(cb) {
   console.error('about to listen in parent');
-  const server = net.createServer(function(conn) {
-    console.error('connection on parent');
-    conn.end('hello from parent\n');
-  }).listen(0, function() {
-    const port = this.address().port;
-    console.error(`server listening on ${port}`);
+  const server = net
+    .createServer(function(conn) {
+      console.error('connection on parent');
+      conn.end('hello from parent\n');
+    })
+    .listen(0, function() {
+      const port = this.address().port;
+      console.error(`server listening on ${port}`);
 
-    const spawn = require('child_process').spawn;
-    const master = spawn(process.execPath, [__filename, 'master'], {
-      stdio: [ 0, 'pipe', 2, server._handle, 'ipc' ],
-      detached: true
-    });
+      const spawn = require('child_process').spawn;
+      const master = spawn(process.execPath, [__filename, 'master'], {
+        stdio: [0, 'pipe', 2, server._handle, 'ipc'],
+        detached: true
+      });
 
-    // Now close the parent, so that the master is the only thing
-    // referencing that handle.  Note that connections will still
-    // be accepted, because the master has the fd open.
-    server.close();
+      // Now close the parent, so that the master is the only thing
+      // referencing that handle.  Note that connections will still
+      // be accepted, because the master has the fd open.
+      server.close();
 
-    master.on('exit', function(code) {
-      console.error('master exited', code);
-    });
+      master.on('exit', function(code) {
+        console.error('master exited', code);
+      });
 
-    master.on('close', function() {
-      console.error('master closed');
-    });
-    console.error('master spawned');
-    master.on('message', function(msg) {
-      if (msg === 'started worker') {
-        cb(master, port);
-      }
+      master.on('close', function() {
+        console.error('master closed');
+      });
+      console.error('master spawned');
+      master.on('message', function(msg) {
+        if (msg === 'started worker') {
+          cb(master, port);
+        }
+      });
     });
-  });
 }
 
 function master() {
   console.error('in master, spawning worker');
   cluster.setupMaster({
-    args: [ 'worker' ]
+    args: ['worker']
   });
   const worker = cluster.fork();
   worker.on('message', function(msg) {
@@ -133,16 +138,17 @@ function master() {
   });
 }
 
-
 function worker() {
   console.error('worker, about to create server and listen on fd=3');
   // start a server on fd=3
-  http.createServer(function(req, res) {
-    console.error('request on worker');
-    console.error('%s %s', req.method, req.url, req.headers);
-    res.end('hello from worker\n');
-  }).listen({ fd: 3 }, function() {
-    console.error('worker listening on fd=3');
-    process.send('worker ready');
-  });
+  http
+    .createServer(function(req, res) {
+      console.error('request on worker');
+      console.error('%s %s', req.method, req.url, req.headers);
+      res.end('hello from worker\n');
+    })
+    .listen({ fd: 3 }, function() {
+      console.error('worker listening on fd=3');
+      process.send('worker ready');
+    });
 }
diff --git a/test/parallel/test-listen-fd-detached-inherit.js b/test/parallel/test-listen-fd-detached-inherit.js
index 4feb7dc3ab03dd..2727d85a37dc0e 100644
--- a/test/parallel/test-listen-fd-detached-inherit.js
+++ b/test/parallel/test-listen-fd-detached-inherit.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('This test is disabled on windows.');
+if (common.isWindows) common.skip('This test is disabled on windows.');
 
 const assert = require('assert');
 const http = require('http');
@@ -30,9 +29,12 @@ const net = require('net');
 const spawn = require('child_process').spawn;
 
 switch (process.argv[2]) {
-  case 'child': return child();
-  case 'parent': return parent();
-  default: return test();
+  case 'child':
+    return child();
+  case 'parent':
+    return parent();
+  default:
+    return test();
 }
 
 // spawn the parent, and listen for it to tell us the pid of the child.
@@ -43,7 +45,7 @@ switch (process.argv[2]) {
 // a more low-level approach, use child process IPC manually.
 function test() {
   const parent = spawn(process.execPath, [__filename, 'parent'], {
-    stdio: [ 0, 'pipe', 2 ]
+    stdio: [0, 'pipe', 2]
   });
   let json = '';
   parent.stdout.on('data', function(c) {
@@ -54,63 +56,69 @@ function test() {
     console.error('output from parent = %s', json);
     const child = JSON.parse(json);
     // now make sure that we can request to the subprocess, then kill it.
-    http.get({
-      server: 'localhost',
-      port: child.port,
-      path: '/',
-    }).on('response', function(res) {
-      let s = '';
-      res.on('data', function(c) {
-        s += c.toString();
-      });
-      res.on('end', function() {
-        // kill the subprocess before we start doing asserts.
-        // it's really annoying when tests leave orphans!
-        process.kill(child.pid, 'SIGKILL');
-        try {
-          parent.kill();
-        } catch {}
+    http
+      .get({
+        server: 'localhost',
+        port: child.port,
+        path: '/'
+      })
+      .on('response', function(res) {
+        let s = '';
+        res.on('data', function(c) {
+          s += c.toString();
+        });
+        res.on('end', function() {
+          // kill the subprocess before we start doing asserts.
+          // it's really annoying when tests leave orphans!
+          process.kill(child.pid, 'SIGKILL');
+          try {
+            parent.kill();
+          } catch {}
 
-        assert.strictEqual(s, 'hello from child\n');
-        assert.strictEqual(res.statusCode, 200);
+          assert.strictEqual(s, 'hello from child\n');
+          assert.strictEqual(res.statusCode, 200);
+        });
       });
-    });
   }
 }
 
 // Listen on port, and then pass the handle to the detached child.
 // Then output the child's pid, and immediately exit.
 function parent() {
-  const server = net.createServer(function(conn) {
-    conn.end('HTTP/1.1 403 Forbidden\r\n\r\nI got problems.\r\n');
-    throw new Error('Should not see connections on parent');
-  }).listen(0, function() {
-    console.error('server listening on %d', this.address().port);
+  const server = net
+    .createServer(function(conn) {
+      conn.end('HTTP/1.1 403 Forbidden\r\n\r\nI got problems.\r\n');
+      throw new Error('Should not see connections on parent');
+    })
+    .listen(0, function() {
+      console.error('server listening on %d', this.address().port);
 
-    const child = spawn(process.execPath, [__filename, 'child'], {
-      stdio: [ 0, 1, 2, server._handle ],
-      detached: true
-    });
+      const child = spawn(process.execPath, [__filename, 'child'], {
+        stdio: [0, 1, 2, server._handle],
+        detached: true
+      });
 
-    console.log('%j\n', { pid: child.pid, port: this.address().port });
+      console.log('%j\n', { pid: child.pid, port: this.address().port });
 
-    // Now close the parent, so that the child is the only thing
-    // referencing that handle.  Note that connections will still
-    // be accepted, because the child has the fd open, but the parent
-    // will exit gracefully.
-    server.close();
-    child.unref();
-  });
+      // Now close the parent, so that the child is the only thing
+      // referencing that handle.  Note that connections will still
+      // be accepted, because the child has the fd open, but the parent
+      // will exit gracefully.
+      server.close();
+      child.unref();
+    });
 }
 
 // Run as a child of the parent() mode.
 function child() {
   // start a server on fd=3
-  http.createServer(function(req, res) {
-    console.error('request on child');
-    console.error('%s %s', req.method, req.url, req.headers);
-    res.end('hello from child\n');
-  }).listen({ fd: 3 }, function() {
-    console.error('child listening on fd=3');
-  });
+  http
+    .createServer(function(req, res) {
+      console.error('request on child');
+      console.error('%s %s', req.method, req.url, req.headers);
+      res.end('hello from child\n');
+    })
+    .listen({ fd: 3 }, function() {
+      console.error('child listening on fd=3');
+    });
 }
diff --git a/test/parallel/test-listen-fd-detached.js b/test/parallel/test-listen-fd-detached.js
index 09d7f8b6c1a68c..637d4a11c26820 100644
--- a/test/parallel/test-listen-fd-detached.js
+++ b/test/parallel/test-listen-fd-detached.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('This test is disabled on windows.');
+if (common.isWindows) common.skip('This test is disabled on windows.');
 
 const assert = require('assert');
 const http = require('http');
@@ -30,9 +29,12 @@ const net = require('net');
 const spawn = require('child_process').spawn;
 
 switch (process.argv[2]) {
-  case 'child': return child();
-  case 'parent': return parent();
-  default: return test();
+  case 'child':
+    return child();
+  case 'parent':
+    return parent();
+  default:
+    return test();
 }
 
 // spawn the parent, and listen for it to tell us the pid of the child.
@@ -43,7 +45,7 @@ switch (process.argv[2]) {
 // a more low-level approach, use child process IPC manually.
 function test() {
   const parent = spawn(process.execPath, [__filename, 'parent'], {
-    stdio: [ 0, 'pipe', 2 ]
+    stdio: [0, 'pipe', 2]
   });
   let json = '';
   parent.stdout.on('data', function(c) {
@@ -54,60 +56,66 @@ function test() {
     console.error('output from parent = %s', json);
     const child = JSON.parse(json);
     // now make sure that we can request to the subprocess, then kill it.
-    http.get({
-      server: 'localhost',
-      port: child.port,
-      path: '/',
-    }).on('response', function(res) {
-      let s = '';
-      res.on('data', function(c) {
-        s += c.toString();
-      });
-      res.on('end', function() {
-        // kill the subprocess before we start doing asserts.
-        // it's really annoying when tests leave orphans!
-        process.kill(child.pid, 'SIGKILL');
-        try {
-          parent.kill();
-        } catch {}
+    http
+      .get({
+        server: 'localhost',
+        port: child.port,
+        path: '/'
+      })
+      .on('response', function(res) {
+        let s = '';
+        res.on('data', function(c) {
+          s += c.toString();
+        });
+        res.on('end', function() {
+          // kill the subprocess before we start doing asserts.
+          // it's really annoying when tests leave orphans!
+          process.kill(child.pid, 'SIGKILL');
+          try {
+            parent.kill();
+          } catch {}
 
-        assert.strictEqual(s, 'hello from child\n');
-        assert.strictEqual(res.statusCode, 200);
+          assert.strictEqual(s, 'hello from child\n');
+          assert.strictEqual(res.statusCode, 200);
+        });
       });
-    });
   }
 }
 
 function parent() {
-  const server = net.createServer(function(conn) {
-    console.error('connection on parent');
-    conn.end('hello from parent\n');
-  }).listen(0, function() {
-    console.error('server listening on %d', this.address().port);
+  const server = net
+    .createServer(function(conn) {
+      console.error('connection on parent');
+      conn.end('hello from parent\n');
+    })
+    .listen(0, function() {
+      console.error('server listening on %d', this.address().port);
 
-    const child = spawn(process.execPath, [__filename, 'child'], {
-      stdio: [ 'ignore', 'ignore', 'ignore', server._handle ],
-      detached: true
-    });
+      const child = spawn(process.execPath, [__filename, 'child'], {
+        stdio: ['ignore', 'ignore', 'ignore', server._handle],
+        detached: true
+      });
 
-    console.log('%j\n', { pid: child.pid, port: this.address().port });
+      console.log('%j\n', { pid: child.pid, port: this.address().port });
 
-    // Now close the parent, so that the child is the only thing
-    // referencing that handle.  Note that connections will still
-    // be accepted, because the child has the fd open, but the parent
-    // will exit gracefully.
-    server.close();
-    child.unref();
-  });
+      // Now close the parent, so that the child is the only thing
+      // referencing that handle.  Note that connections will still
+      // be accepted, because the child has the fd open, but the parent
+      // will exit gracefully.
+      server.close();
+      child.unref();
+    });
 }
 
 function child() {
   // start a server on fd=3
-  http.createServer(function(req, res) {
-    console.error('request on child');
-    console.error('%s %s', req.method, req.url, req.headers);
-    res.end('hello from child\n');
-  }).listen({ fd: 3 }, function() {
-    console.error('child listening on fd=3');
-  });
+  http
+    .createServer(function(req, res) {
+      console.error('request on child');
+      console.error('%s %s', req.method, req.url, req.headers);
+      res.end('hello from child\n');
+    })
+    .listen({ fd: 3 }, function() {
+      console.error('child listening on fd=3');
+    });
 }
diff --git a/test/parallel/test-listen-fd-ebadf.js b/test/parallel/test-listen-fd-ebadf.js
index 3ec40b5c23a1f2..e8a5b3401d1d86 100644
--- a/test/parallel/test-listen-fd-ebadf.js
+++ b/test/parallel/test-listen-fd-ebadf.js
@@ -26,7 +26,9 @@ const assert = require('assert');
 const fs = require('fs');
 const net = require('net');
 
-net.createServer(common.mustNotCall()).listen({ fd: 2 })
+net
+  .createServer(common.mustNotCall())
+  .listen({ fd: 2 })
   .on('error', common.mustCall(onError));
 
 let invalidFd = 2;
@@ -38,7 +40,9 @@ try {
   // do nothing; we now have an invalid fd
 }
 
-net.createServer(common.mustNotCall()).listen({ fd: invalidFd })
+net
+  .createServer(common.mustNotCall())
+  .listen({ fd: invalidFd })
   .on('error', common.mustCall(onError));
 
 function onError(ex) {
diff --git a/test/parallel/test-listen-fd-server.js b/test/parallel/test-listen-fd-server.js
index 7cdba8b405892a..092b88b611bf81 100644
--- a/test/parallel/test-listen-fd-server.js
+++ b/test/parallel/test-listen-fd-server.js
@@ -21,15 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('This test is disabled on windows.');
+if (common.isWindows) common.skip('This test is disabled on windows.');
 
 const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
 switch (process.argv[2]) {
-  case 'child': return child();
+  case 'child':
+    return child();
 }
 
 let ok;
@@ -45,25 +45,27 @@ process.on('exit', function() {
 // a more low-level approach, use child process IPC manually.
 test(function(child, port) {
   // now make sure that we can request to the subprocess, then kill it.
-  http.get({
-    server: 'localhost',
-    port: port,
-    path: '/',
-  }).on('response', function(res) {
-    let s = '';
-    res.on('data', function(c) {
-      s += c.toString();
-    });
-    res.on('end', function() {
-      child.kill();
-      child.on('exit', function() {
-        assert.strictEqual(s, 'hello from child\n');
-        assert.strictEqual(res.statusCode, 200);
-        console.log('ok');
-        ok = true;
+  http
+    .get({
+      server: 'localhost',
+      port: port,
+      path: '/'
+    })
+    .on('response', function(res) {
+      let s = '';
+      res.on('data', function(c) {
+        s += c.toString();
+      });
+      res.on('end', function() {
+        child.kill();
+        child.on('exit', function() {
+          assert.strictEqual(s, 'hello from child\n');
+          assert.strictEqual(res.statusCode, 200);
+          console.log('ok');
+          ok = true;
+        });
       });
     });
-  });
 });
 
 function child() {
@@ -75,40 +77,44 @@ function child() {
   });
 
   // start a server on fd=3
-  http.createServer(function(req, res) {
-    console.error('request on child');
-    console.error('%s %s', req.method, req.url, req.headers);
-    res.end('hello from child\n');
-  }).listen({ fd: 3 }, function() {
-    console.error('child listening on fd=3');
-    process.send('listening');
-  });
+  http
+    .createServer(function(req, res) {
+      console.error('request on child');
+      console.error('%s %s', req.method, req.url, req.headers);
+      res.end('hello from child\n');
+    })
+    .listen({ fd: 3 }, function() {
+      console.error('child listening on fd=3');
+      process.send('listening');
+    });
 }
 
 function test(cb) {
-  const server = net.createServer(function(conn) {
-    console.error('connection on parent');
-    conn.end('hello from parent\n');
-  }).listen(0, function() {
-    const port = this.address().port;
-    console.error('server listening on %d', port);
+  const server = net
+    .createServer(function(conn) {
+      console.error('connection on parent');
+      conn.end('hello from parent\n');
+    })
+    .listen(0, function() {
+      const port = this.address().port;
+      console.error('server listening on %d', port);
 
-    const spawn = require('child_process').spawn;
-    const child = spawn(process.execPath, [__filename, 'child'], {
-      stdio: [ 0, 1, 2, server._handle, 'ipc' ]
-    });
+      const spawn = require('child_process').spawn;
+      const child = spawn(process.execPath, [__filename, 'child'], {
+        stdio: [0, 1, 2, server._handle, 'ipc']
+      });
 
-    console.log('%j\n', { pid: child.pid });
+      console.log('%j\n', { pid: child.pid });
 
-    // Now close the parent, so that the child is the only thing
-    // referencing that handle.  Note that connections will still
-    // be accepted, because the child has the fd open.
-    server.close();
+      // Now close the parent, so that the child is the only thing
+      // referencing that handle.  Note that connections will still
+      // be accepted, because the child has the fd open.
+      server.close();
 
-    child.on('message', function(msg) {
-      if (msg === 'listening') {
-        cb(child, port);
-      }
+      child.on('message', function(msg) {
+        if (msg === 'listening') {
+          cb(child, port);
+        }
+      });
     });
-  });
 }
diff --git a/test/parallel/test-loaders-hidden-from-users.js b/test/parallel/test-loaders-hidden-from-users.js
index 0d752f5718b729..df94dfe916d8cc 100644
--- a/test/parallel/test-loaders-hidden-from-users.js
+++ b/test/parallel/test-loaders-hidden-from-users.js
@@ -7,9 +7,10 @@ const common = require('../common');
 common.expectsError(
   () => {
     require('internal/bootstrap/loaders');
-  }, {
+  },
+  {
     code: 'MODULE_NOT_FOUND',
-    message: 'Cannot find module \'internal/bootstrap/loaders\''
+    message: "Cannot find module 'internal/bootstrap/loaders'"
   }
 );
 
@@ -18,8 +19,9 @@ common.expectsError(
     const source = 'module.exports = require("internal/bootstrap/loaders")';
     process.binding('natives').owo = source;
     require('owo');
-  }, {
+  },
+  {
     code: 'MODULE_NOT_FOUND',
-    message: 'Cannot find module \'owo\''
+    message: "Cannot find module 'owo'"
   }
 );
diff --git a/test/parallel/test-memory-usage-emfile.js b/test/parallel/test-memory-usage-emfile.js
index 98496e17b099d2..3a8b63350a3c64 100644
--- a/test/parallel/test-memory-usage-emfile.js
+++ b/test/parallel/test-memory-usage-emfile.js
@@ -6,8 +6,7 @@ const fs = require('fs');
 
 const files = [];
 
-while (files.length < 256)
-  files.push(fs.openSync(__filename, 'r'));
+while (files.length < 256) files.push(fs.openSync(__filename, 'r'));
 
 const r = process.memoryUsage();
 assert.strictEqual(r.rss > 0, true);
diff --git a/test/parallel/test-microtask-queue-run-immediate.js b/test/parallel/test-microtask-queue-run-immediate.js
index 4d998cf0b8a59c..e313cfcd4117ba 100644
--- a/test/parallel/test-microtask-queue-run-immediate.js
+++ b/test/parallel/test-microtask-queue-run-immediate.js
@@ -40,7 +40,6 @@ setImmediate(function() {
   });
 });
 
-
 // no nextTick, microtask with nextTick
 setImmediate(function() {
   let called = false;
@@ -52,8 +51,6 @@ setImmediate(function() {
   });
 
   setImmediate(function() {
-    if (called)
-      done++;
+    if (called) done++;
   });
-
 });
diff --git a/test/parallel/test-microtask-queue-run.js b/test/parallel/test-microtask-queue-run.js
index 85eb770da1e0ff..79cc64fa2a1a5a 100644
--- a/test/parallel/test-microtask-queue-run.js
+++ b/test/parallel/test-microtask-queue-run.js
@@ -40,7 +40,6 @@ setTimeout(function() {
   });
 }, 0);
 
-
 // no nextTick, microtask with nextTick
 setTimeout(function() {
   let called = false;
@@ -52,8 +51,6 @@ setTimeout(function() {
   });
 
   setTimeout(function() {
-    if (called)
-      done++;
+    if (called) done++;
   }, 0);
-
 }, 0);
diff --git a/test/parallel/test-module-binding.js b/test/parallel/test-module-binding.js
index 07c4965f2204f3..6e144f59def8e6 100644
--- a/test/parallel/test-module-binding.js
+++ b/test/parallel/test-module-binding.js
@@ -9,8 +9,10 @@ const { strictEqual } = require('assert');
 
 strictEqual(internalModuleReadJSON('nosuchfile'), undefined);
 strictEqual(internalModuleReadJSON(fixtures.path('empty.txt')), undefined);
-strictEqual(internalModuleReadJSON(fixtures.path('empty-with-bom.txt')),
-            undefined);
+strictEqual(
+  internalModuleReadJSON(fixtures.path('empty-with-bom.txt')),
+  undefined
+);
 {
   const filename = fixtures.path('require-bin/package.json');
   strictEqual(internalModuleReadJSON(filename), readFileSync(filename, 'utf8'));
diff --git a/test/parallel/test-module-circular-symlinks.js b/test/parallel/test-module-circular-symlinks.js
index e8d80640df0b17..97187ede053a37 100644
--- a/test/parallel/test-module-circular-symlinks.js
+++ b/test/parallel/test-module-circular-symlinks.js
@@ -53,12 +53,21 @@ try {
   common.skip('insufficient privileges for symlinks');
 }
 
-fs.writeFileSync(path.join(tmpDir, 'index.js'),
-                 'module.exports = require(\'moduleA\');', 'utf8');
-fs.writeFileSync(path.join(moduleA, 'index.js'),
-                 'module.exports = {b: require(\'moduleB\')};', 'utf8');
-fs.writeFileSync(path.join(moduleB, 'index.js'),
-                 'module.exports = {a: require(\'moduleA\')};', 'utf8');
+fs.writeFileSync(
+  path.join(tmpDir, 'index.js'),
+  "module.exports = require('moduleA');",
+  'utf8'
+);
+fs.writeFileSync(
+  path.join(moduleA, 'index.js'),
+  "module.exports = {b: require('moduleB')};",
+  'utf8'
+);
+fs.writeFileSync(
+  path.join(moduleB, 'index.js'),
+  "module.exports = {a: require('moduleA')};",
+  'utf8'
+);
 
 // Ensure that the symlinks are not followed forever...
 const obj = require(path.join(tmpDir, 'index'));
diff --git a/test/parallel/test-module-loading-error.js b/test/parallel/test-module-loading-error.js
index f2351e708f2e93..39e11fc03894a7 100644
--- a/test/parallel/test-module-loading-error.js
+++ b/test/parallel/test-module-loading-error.js
@@ -29,8 +29,10 @@ const errorMessagesByPlatform = {
   linux: ['file too short', 'Exec format error'],
   sunos: ['unknown file type', 'not an ELF file'],
   darwin: ['file too short'],
-  aix: ['Cannot load module',
-        'Cannot run a file that does not have a valid format.']
+  aix: [
+    'Cannot load module',
+    'Cannot run a file that does not have a valid format.'
+  ]
 };
 // If we don't know a priori what the error would be, we accept anything.
 const errorMessages = errorMessagesByPlatform[process.platform] || [''];
@@ -44,14 +46,19 @@ if (common.isWindows) {
     '"(Get-UICulture).TwoLetterISOLanguageName"';
   try {
     // If MUI != 'en' we'll ignore the content of the message
-    localeOk = execSync(powerShellFindMUI).toString('utf8').trim() === 'en';
+    localeOk =
+      execSync(powerShellFindMUI)
+        .toString('utf8')
+        .trim() === 'en';
   } catch {
     // It's only a best effort try to find the MUI
   }
 }
 
 assert.throws(
-  () => { require('../fixtures/module-loading-error.node'); },
+  () => {
+    require('../fixtures/module-loading-error.node');
+  },
   (e) => {
     if (localeOk && !errorMessages.some((msg) => e.message.includes(msg)))
       return false;
@@ -62,26 +69,34 @@ assert.throws(
 const re = /^The "id" argument must be of type string\. Received type \w+$/;
 [1, false, null, undefined, {}].forEach((value) => {
   common.expectsError(
-    () => { require(value); },
+    () => {
+      require(value);
+    },
     {
       type: TypeError,
       code: 'ERR_INVALID_ARG_TYPE',
       message: re
-    });
+    }
+  );
 });
 
-
 common.expectsError(
-  () => { require(''); },
+  () => {
+    require('');
+  },
   {
     type: TypeError,
     code: 'ERR_INVALID_ARG_VALUE',
-    message: 'The argument \'id\' must be a non-empty string. Received \'\''
-  });
+    message: "The argument 'id' must be a non-empty string. Received ''"
+  }
+);
 
 common.expectsError(
-  () => { require('../fixtures/packages/is-dir'); },
+  () => {
+    require('../fixtures/packages/is-dir');
+  },
   {
     code: 'MODULE_NOT_FOUND',
-    message: 'Cannot find module \'../fixtures/packages/is-dir\''
-  });
+    message: "Cannot find module '../fixtures/packages/is-dir'"
+  }
+);
diff --git a/test/parallel/test-module-loading-globalpaths.js b/test/parallel/test-module-loading-globalpaths.js
index 284dbb0b3cd564..ebd2ceb1977f8f 100644
--- a/test/parallel/test-module-loading-globalpaths.js
+++ b/test/parallel/test-module-loading-globalpaths.js
@@ -33,9 +33,11 @@ if (process.argv[2] === 'child') {
   fs.chmodSync(testExecPath, mode);
 
   const runTest = (expectedString, env) => {
-    const child = child_process.execFileSync(testExecPath,
-                                             [ __filename, 'child' ],
-                                             { encoding: 'utf8', env: env });
+    const child = child_process.execFileSync(
+      testExecPath,
+      [__filename, 'child'],
+      { encoding: 'utf8', env: env }
+    );
     assert.strictEqual(child.trim(), expectedString);
   };
 
@@ -49,12 +51,12 @@ if (process.argv[2] === 'child') {
   const noPkgHomeDir = path.join(tmpdir.path, 'home-no-pkg');
   fs.mkdirSync(noPkgHomeDir);
   env.HOME = env.USERPROFILE = noPkgHomeDir;
-  assert.throws(
-    () => {
-      child_process.execFileSync(testExecPath, [ __filename, 'child' ],
-                                 { encoding: 'utf8', env: env });
-    },
-    new RegExp(`Cannot find module '${pkgName}'`));
+  assert.throws(() => {
+    child_process.execFileSync(testExecPath, [__filename, 'child'], {
+      encoding: 'utf8',
+      env: env
+    });
+  }, new RegExp(`Cannot find module '${pkgName}'`));
 
   // Test module in $HOME/.node_modules.
   const modHomeDir = path.join(testFixturesDir, 'home-pkg-in-node_modules');
@@ -97,8 +99,10 @@ if (process.argv[2] === 'child') {
   const localDir = path.join(testFixturesDir, 'local-pkg');
   env.HOME = env.USERPROFILE = bothHomeDir;
   env.NODE_PATH = path.join(testFixturesDir, 'node_path');
-  const child = child_process.execFileSync(testExecPath,
-                                           [ path.join(localDir, 'test.js') ],
-                                           { encoding: 'utf8', env: env });
+  const child = child_process.execFileSync(
+    testExecPath,
+    [path.join(localDir, 'test.js')],
+    { encoding: 'utf8', env: env }
+  );
   assert.strictEqual(child.trim(), 'local');
 }
diff --git a/test/parallel/test-module-main-extension-lookup.js b/test/parallel/test-module-main-extension-lookup.js
index 3d20316647c6c0..f17ddb63014e5f 100644
--- a/test/parallel/test-module-main-extension-lookup.js
+++ b/test/parallel/test-module-main-extension-lookup.js
@@ -5,7 +5,11 @@ const { execFileSync } = require('child_process');
 
 const node = process.argv[0];
 
-execFileSync(node, ['--experimental-modules',
-                    fixtures.path('es-modules', 'test-esm-ok')]);
-execFileSync(node, ['--experimental-modules',
-                    fixtures.path('es-modules', 'noext')]);
+execFileSync(node, [
+  '--experimental-modules',
+  fixtures.path('es-modules', 'test-esm-ok')
+]);
+execFileSync(node, [
+  '--experimental-modules',
+  fixtures.path('es-modules', 'noext')
+]);
diff --git a/test/parallel/test-module-main-fail.js b/test/parallel/test-module-main-fail.js
index a6457f33b659dd..e958625890a6bf 100644
--- a/test/parallel/test-module-main-fail.js
+++ b/test/parallel/test-module-main-fail.js
@@ -15,7 +15,9 @@ for (const args of flags) {
       assert(e.toString().match(/Error: Cannot find module/));
       continue;
     }
-    assert.fail('Executing node with inexistent entry point should ' +
-                `fail. Entry point: ${entryPoint}, Flags: [${args}]`);
+    assert.fail(
+      'Executing node with inexistent entry point should ' +
+        `fail. Entry point: ${entryPoint}, Flags: [${args}]`
+    );
   }
 }
diff --git a/test/parallel/test-module-main-preserve-symlinks-fail.js b/test/parallel/test-module-main-preserve-symlinks-fail.js
index b46497b625261f..71f8042db554c3 100644
--- a/test/parallel/test-module-main-preserve-symlinks-fail.js
+++ b/test/parallel/test-module-main-preserve-symlinks-fail.js
@@ -15,7 +15,9 @@ for (const args of flags) {
       assert(e.toString().match(/Error: Cannot find module/));
       continue;
     }
-    assert.fail('Executing node with inexistent entry point should ' +
-                `fail. Entry point: ${entryPoint}, Flags: [${args}]`);
+    assert.fail(
+      'Executing node with inexistent entry point should ' +
+        `fail. Entry point: ${entryPoint}, Flags: [${args}]`
+    );
   }
 }
diff --git a/test/parallel/test-module-nodemodulepaths.js b/test/parallel/test-module-nodemodulepaths.js
index c79d2e6e72c64c..cccb642f721a97 100644
--- a/test/parallel/test-module-nodemodulepaths.js
+++ b/test/parallel/test-module-nodemodulepaths.js
@@ -26,102 +26,110 @@ const assert = require('assert');
 const _module = require('module');
 
 const cases = {
-  'WIN': [{
-    file: 'C:\\Users\\hefangshi\\AppData\\Roaming\
+  WIN: [
+    {
+      file:
+        'C:\\Users\\hefangshi\\AppData\\Roaming\
 \\npm\\node_modules\\npm\\node_modules\\minimatch',
-    expect: [
-      'C:\\Users\\hefangshi\\AppData\\Roaming\
+      expect: [
+        'C:\\Users\\hefangshi\\AppData\\Roaming\
 \\npm\\node_modules\\npm\\node_modules\\minimatch\\node_modules',
-      'C:\\Users\\hefangshi\\AppData\\Roaming\
+        'C:\\Users\\hefangshi\\AppData\\Roaming\
 \\npm\\node_modules\\npm\\node_modules',
-      'C:\\Users\\hefangshi\\AppData\\Roaming\\npm\\node_modules',
-      'C:\\Users\\hefangshi\\AppData\\Roaming\\node_modules',
-      'C:\\Users\\hefangshi\\AppData\\node_modules',
-      'C:\\Users\\hefangshi\\node_modules',
-      'C:\\Users\\node_modules',
-      'C:\\node_modules'
-    ]
-  }, {
-    file: 'C:\\Users\\Rocko Artischocko\\node_stuff\\foo',
-    expect: [
-      'C:\\Users\\Rocko Artischocko\\node_stuff\\foo\\node_modules',
-      'C:\\Users\\Rocko Artischocko\\node_stuff\\node_modules',
-      'C:\\Users\\Rocko Artischocko\\node_modules',
-      'C:\\Users\\node_modules',
-      'C:\\node_modules'
-    ]
-  }, {
-    file: 'C:\\Users\\Rocko Artischocko\\node_stuff\\foo_node_modules',
-    expect: [
-      'C:\\Users\\Rocko \
+        'C:\\Users\\hefangshi\\AppData\\Roaming\\npm\\node_modules',
+        'C:\\Users\\hefangshi\\AppData\\Roaming\\node_modules',
+        'C:\\Users\\hefangshi\\AppData\\node_modules',
+        'C:\\Users\\hefangshi\\node_modules',
+        'C:\\Users\\node_modules',
+        'C:\\node_modules'
+      ]
+    },
+    {
+      file: 'C:\\Users\\Rocko Artischocko\\node_stuff\\foo',
+      expect: [
+        'C:\\Users\\Rocko Artischocko\\node_stuff\\foo\\node_modules',
+        'C:\\Users\\Rocko Artischocko\\node_stuff\\node_modules',
+        'C:\\Users\\Rocko Artischocko\\node_modules',
+        'C:\\Users\\node_modules',
+        'C:\\node_modules'
+      ]
+    },
+    {
+      file: 'C:\\Users\\Rocko Artischocko\\node_stuff\\foo_node_modules',
+      expect: [
+        'C:\\Users\\Rocko \
 Artischocko\\node_stuff\\foo_node_modules\\node_modules',
-      'C:\\Users\\Rocko Artischocko\\node_stuff\\node_modules',
-      'C:\\Users\\Rocko Artischocko\\node_modules',
-      'C:\\Users\\node_modules',
-      'C:\\node_modules'
-    ]
-  }, {
-    file: 'C:\\node_modules',
-    expect: [
-      'C:\\node_modules'
-    ]
-  }, {
-    file: 'C:\\',
-    expect: [
-      'C:\\node_modules'
-    ]
-  }],
-  'POSIX': [{
-    file: '/usr/lib/node_modules/npm/node_modules/\
+        'C:\\Users\\Rocko Artischocko\\node_stuff\\node_modules',
+        'C:\\Users\\Rocko Artischocko\\node_modules',
+        'C:\\Users\\node_modules',
+        'C:\\node_modules'
+      ]
+    },
+    {
+      file: 'C:\\node_modules',
+      expect: ['C:\\node_modules']
+    },
+    {
+      file: 'C:\\',
+      expect: ['C:\\node_modules']
+    }
+  ],
+  POSIX: [
+    {
+      file:
+        '/usr/lib/node_modules/npm/node_modules/\
 node-gyp/node_modules/glob/node_modules/minimatch',
-    expect: [
-      '/usr/lib/node_modules/npm/node_modules/\
+      expect: [
+        '/usr/lib/node_modules/npm/node_modules/\
 node-gyp/node_modules/glob/node_modules/minimatch/node_modules',
-      '/usr/lib/node_modules/npm/node_modules/\
+        '/usr/lib/node_modules/npm/node_modules/\
 node-gyp/node_modules/glob/node_modules',
-      '/usr/lib/node_modules/npm/node_modules/node-gyp/node_modules',
-      '/usr/lib/node_modules/npm/node_modules',
-      '/usr/lib/node_modules',
-      '/usr/node_modules',
-      '/node_modules'
-    ]
-  }, {
-    file: '/usr/test/lib/node_modules/npm/foo',
-    expect: [
-      '/usr/test/lib/node_modules/npm/foo/node_modules',
-      '/usr/test/lib/node_modules/npm/node_modules',
-      '/usr/test/lib/node_modules',
-      '/usr/test/node_modules',
-      '/usr/node_modules',
-      '/node_modules'
-    ]
-  }, {
-    file: '/usr/test/lib/node_modules/npm/foo_node_modules',
-    expect: [
-      '/usr/test/lib/node_modules/npm/foo_node_modules/node_modules',
-      '/usr/test/lib/node_modules/npm/node_modules',
-      '/usr/test/lib/node_modules',
-      '/usr/test/node_modules',
-      '/usr/node_modules',
-      '/node_modules'
-    ]
-  }, {
-    file: '/node_modules',
-    expect: [
-      '/node_modules'
-    ]
-  }, {
-    file: '/',
-    expect: [
-      '/node_modules'
-    ]
-  }]
+        '/usr/lib/node_modules/npm/node_modules/node-gyp/node_modules',
+        '/usr/lib/node_modules/npm/node_modules',
+        '/usr/lib/node_modules',
+        '/usr/node_modules',
+        '/node_modules'
+      ]
+    },
+    {
+      file: '/usr/test/lib/node_modules/npm/foo',
+      expect: [
+        '/usr/test/lib/node_modules/npm/foo/node_modules',
+        '/usr/test/lib/node_modules/npm/node_modules',
+        '/usr/test/lib/node_modules',
+        '/usr/test/node_modules',
+        '/usr/node_modules',
+        '/node_modules'
+      ]
+    },
+    {
+      file: '/usr/test/lib/node_modules/npm/foo_node_modules',
+      expect: [
+        '/usr/test/lib/node_modules/npm/foo_node_modules/node_modules',
+        '/usr/test/lib/node_modules/npm/node_modules',
+        '/usr/test/lib/node_modules',
+        '/usr/test/node_modules',
+        '/usr/node_modules',
+        '/node_modules'
+      ]
+    },
+    {
+      file: '/node_modules',
+      expect: ['/node_modules']
+    },
+    {
+      file: '/',
+      expect: ['/node_modules']
+    }
+  ]
 };
 
 const platformCases = common.isWindows ? cases.WIN : cases.POSIX;
 platformCases.forEach((c) => {
   const paths = _module._nodeModulePaths(c.file);
   assert.deepStrictEqual(
-    c.expect, paths,
-    `case ${c.file} failed, actual paths is ${JSON.stringify(paths)}`);
+    c.expect,
+    paths,
+    `case ${c.file} failed, actual paths is ${JSON.stringify(paths)}`
+  );
 });
diff --git a/test/parallel/test-module-readonly.js b/test/parallel/test-module-readonly.js
index 8f14d9ee18c34a..52d070e9ee25b2 100644
--- a/test/parallel/test-module-readonly.js
+++ b/test/parallel/test-module-readonly.js
@@ -25,7 +25,8 @@ fs.writeFileSync(readOnlyModFullPath, 'module.exports = 42;');
 // Removed any inherited ACEs, and any explicitly granted ACEs for the
 // current user
 cp.execSync(
-  `icacls.exe "${readOnlyModFullPath}" /inheritance:r /remove "%USERNAME%"`);
+  `icacls.exe "${readOnlyModFullPath}" /inheritance:r /remove "%USERNAME%"`
+);
 
 // Grant the current user read & execute only
 cp.execSync(`icacls.exe "${readOnlyModFullPath}" /grant "%USERNAME%":RX`);
@@ -40,7 +41,8 @@ try {
 
 // Remove the explicitly granted rights, and re-enable inheritance
 cp.execSync(
-  `icacls.exe "${readOnlyModFullPath}" /remove "%USERNAME%" /inheritance:e`);
+  `icacls.exe "${readOnlyModFullPath}" /remove "%USERNAME%" /inheritance:e`
+);
 
 // Delete the test module (note: tmpdir should get cleaned anyway)
 fs.unlinkSync(readOnlyModFullPath);
diff --git a/test/parallel/test-module-relative-lookup.js b/test/parallel/test-module-relative-lookup.js
index c5350e11facda4..f3c63b5ec7b940 100644
--- a/test/parallel/test-module-relative-lookup.js
+++ b/test/parallel/test-module-relative-lookup.js
@@ -6,9 +6,9 @@ const _module = require('module'); // avoid collision with global.module
 
 // Current directory gets highest priority for local modules
 function testFirstInPath(moduleName, isLocalModule) {
-  const assertFunction = isLocalModule ?
-    assert.strictEqual :
-    assert.notStrictEqual;
+  const assertFunction = isLocalModule
+    ? assert.strictEqual
+    : assert.notStrictEqual;
 
   const lookupResults = _module._resolveLookupPaths(moduleName);
 
diff --git a/test/parallel/test-module-require-depth.js b/test/parallel/test-module-require-depth.js
index 0a3fc2826c71f4..2adf5db1f2d81f 100644
--- a/test/parallel/test-module-require-depth.js
+++ b/test/parallel/test-module-require-depth.js
@@ -3,9 +3,7 @@
 require('../common');
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
-const {
-  requireDepth
-} = require('internal/modules/cjs/helpers');
+const { requireDepth } = require('internal/modules/cjs/helpers');
 
 // Module one loads two too so the expected depth for two is, well, two.
 assert.strictEqual(requireDepth, 0);
diff --git a/test/parallel/test-module-symlinked-peer-modules.js b/test/parallel/test-module-symlinked-peer-modules.js
index fb02a8a94d5d66..67798910c5913b 100644
--- a/test/parallel/test-module-symlinked-peer-modules.js
+++ b/test/parallel/test-module-symlinked-peer-modules.js
@@ -48,15 +48,26 @@ try {
   common.skip('insufficient privileges for symlinks');
 }
 
-fs.writeFileSync(path.join(moduleA, 'package.json'),
-                 JSON.stringify({ name: 'moduleA', main: 'index.js' }), 'utf8');
-fs.writeFileSync(path.join(moduleA, 'index.js'),
-                 'module.exports = require(\'moduleB\');', 'utf8');
-fs.writeFileSync(path.join(app, 'index.js'),
-                 '\'use strict\'; require(\'moduleA\');', 'utf8');
-fs.writeFileSync(path.join(moduleB, 'package.json'),
-                 JSON.stringify({ name: 'moduleB', main: 'index.js' }), 'utf8');
-fs.writeFileSync(path.join(moduleB, 'index.js'),
-                 'module.exports = 1;', 'utf8');
+fs.writeFileSync(
+  path.join(moduleA, 'package.json'),
+  JSON.stringify({ name: 'moduleA', main: 'index.js' }),
+  'utf8'
+);
+fs.writeFileSync(
+  path.join(moduleA, 'index.js'),
+  "module.exports = require('moduleB');",
+  'utf8'
+);
+fs.writeFileSync(
+  path.join(app, 'index.js'),
+  "'use strict'; require('moduleA');",
+  'utf8'
+);
+fs.writeFileSync(
+  path.join(moduleB, 'package.json'),
+  JSON.stringify({ name: 'moduleB', main: 'index.js' }),
+  'utf8'
+);
+fs.writeFileSync(path.join(moduleB, 'index.js'), 'module.exports = 1;', 'utf8');
 
 require(path.join(app, 'index')); // Should not throw.
diff --git a/test/parallel/test-net-access-byteswritten.js b/test/parallel/test-net-access-byteswritten.js
index c928ab27c6d146..404f662afd94fb 100644
--- a/test/parallel/test-net-access-byteswritten.js
+++ b/test/parallel/test-net-access-byteswritten.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const net = require('net');
diff --git a/test/parallel/test-net-after-close.js b/test/parallel/test-net-after-close.js
index 0750ba0f435512..cbbb7af854ce34 100644
--- a/test/parallel/test-net-after-close.js
+++ b/test/parallel/test-net-after-close.js
@@ -29,21 +29,27 @@ const server = net.createServer(function(s) {
   s.end();
 });
 
-server.listen(0, common.mustCall(function() {
-  const c = net.createConnection(this.address().port);
-  c.on('close', common.mustCall(function() {
-    console.error('connection closed');
-    assert.strictEqual(c._handle, null);
-    // Calling functions / accessing properties of a closed socket should not
-    // throw.
-    c.setNoDelay();
-    c.setKeepAlive();
-    c.bufferSize;
-    c.pause();
-    c.resume();
-    c.address();
-    c.remoteAddress;
-    c.remotePort;
-    server.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const c = net.createConnection(this.address().port);
+    c.on(
+      'close',
+      common.mustCall(function() {
+        console.error('connection closed');
+        assert.strictEqual(c._handle, null);
+        // Calling functions / accessing properties of a closed socket should not
+        // throw.
+        c.setNoDelay();
+        c.setKeepAlive();
+        c.bufferSize;
+        c.pause();
+        c.resume();
+        c.address();
+        c.remoteAddress;
+        c.remotePort;
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-better-error-messages-listen-path.js b/test/parallel/test-net-better-error-messages-listen-path.js
index 02f02d9a4826f5..00a04b3d4fff02 100644
--- a/test/parallel/test-net-better-error-messages-listen-path.js
+++ b/test/parallel/test-net-better-error-messages-listen-path.js
@@ -5,6 +5,9 @@ const net = require('net');
 const fp = '/blah/fadfa';
 const server = net.createServer(common.mustNotCall());
 server.listen(fp, common.mustNotCall());
-server.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.address, fp);
-}));
+server.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.address, fp);
+  })
+);
diff --git a/test/parallel/test-net-better-error-messages-listen.js b/test/parallel/test-net-better-error-messages-listen.js
index aa1da2d46235d5..0fb2ae288eff52 100644
--- a/test/parallel/test-net-better-error-messages-listen.js
+++ b/test/parallel/test-net-better-error-messages-listen.js
@@ -5,8 +5,11 @@ const net = require('net');
 
 const server = net.createServer(common.mustNotCall());
 server.listen(1, '1.1.1.1', common.mustNotCall());
-server.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.address, '1.1.1.1');
-  assert.strictEqual(e.port, 1);
-  assert.strictEqual(e.syscall, 'listen');
-}));
+server.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.address, '1.1.1.1');
+    assert.strictEqual(e.port, 1);
+    assert.strictEqual(e.syscall, 'listen');
+  })
+);
diff --git a/test/parallel/test-net-better-error-messages-path.js b/test/parallel/test-net-better-error-messages-path.js
index 0d16894ff83f6c..36366a353c1850 100644
--- a/test/parallel/test-net-better-error-messages-path.js
+++ b/test/parallel/test-net-better-error-messages-path.js
@@ -7,15 +7,17 @@ const net = require('net');
   const c = net.connect(fp);
 
   c.on('connect', common.mustNotCall());
-  c.on('error', common.expectsError({
-    code: 'ENOENT',
-    message: `connect ENOENT ${fp}`
-  }));
+  c.on(
+    'error',
+    common.expectsError({
+      code: 'ENOENT',
+      message: `connect ENOENT ${fp}`
+    })
+  );
 }
 
 {
-  common.expectsError(
-    () => net.createConnection({ path: {} }),
-    { code: 'ERR_INVALID_ARG_TYPE' }
-  );
+  common.expectsError(() => net.createConnection({ path: {} }), {
+    code: 'ERR_INVALID_ARG_TYPE'
+  });
 }
diff --git a/test/parallel/test-net-better-error-messages-port-hostname.js b/test/parallel/test-net-better-error-messages-port-hostname.js
index 1a8aa770b44a22..7add5f0484cff5 100644
--- a/test/parallel/test-net-better-error-messages-port-hostname.js
+++ b/test/parallel/test-net-better-error-messages-port-hostname.js
@@ -9,10 +9,7 @@ const net = require('net');
 const assert = require('assert');
 
 const { addresses } = require('../common/internet');
-const {
-  errorLookupMock,
-  mockedErrorCode
-} = require('../common/dns');
+const { errorLookupMock, mockedErrorCode } = require('../common/dns');
 
 // Using port 0 as hostname used is already invalid.
 const c = net.createConnection({
@@ -23,8 +20,11 @@ const c = net.createConnection({
 
 c.on('connect', common.mustNotCall());
 
-c.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.code, mockedErrorCode);
-  assert.strictEqual(e.port, 0);
-  assert.strictEqual(e.hostname, addresses.INVALID_HOST);
-}));
+c.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.code, mockedErrorCode);
+    assert.strictEqual(e.port, 0);
+    assert.strictEqual(e.hostname, addresses.INVALID_HOST);
+  })
+);
diff --git a/test/parallel/test-net-binary.js b/test/parallel/test-net-binary.js
index b8dbc0e8d70e8f..ebd2d51895eb20 100644
--- a/test/parallel/test-net-binary.js
+++ b/test/parallel/test-net-binary.js
@@ -80,7 +80,10 @@ process.on('exit', function() {
 
   const a = recv.split('');
 
-  const first = a.slice(0, 256).reverse().join('');
+  const first = a
+    .slice(0, 256)
+    .reverse()
+    .join('');
 
   const second = a.slice(256, 2 * 256).join('');
 
diff --git a/test/parallel/test-net-bind-twice.js b/test/parallel/test-net-bind-twice.js
index f59818a1e8a384..132862aeff6762 100644
--- a/test/parallel/test-net-bind-twice.js
+++ b/test/parallel/test-net-bind-twice.js
@@ -25,12 +25,19 @@ const assert = require('assert');
 const net = require('net');
 
 const server1 = net.createServer(common.mustNotCall());
-server1.listen(0, '127.0.0.1', common.mustCall(function() {
-  const server2 = net.createServer(common.mustNotCall());
-  server2.listen(this.address().port, '127.0.0.1', common.mustNotCall());
+server1.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    const server2 = net.createServer(common.mustNotCall());
+    server2.listen(this.address().port, '127.0.0.1', common.mustNotCall());
 
-  server2.on('error', common.mustCall(function(e) {
-    assert.strictEqual(e.code, 'EADDRINUSE');
-    server1.close();
-  }));
-}));
+    server2.on(
+      'error',
+      common.mustCall(function(e) {
+        assert.strictEqual(e.code, 'EADDRINUSE');
+        server1.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-bytes-read.js b/test/parallel/test-net-bytes-read.js
index fa6b2383b4f317..a978ba04d28813 100644
--- a/test/parallel/test-net-bytes-read.js
+++ b/test/parallel/test-net-bytes-read.js
@@ -6,33 +6,44 @@ const net = require('net');
 
 const big = Buffer.alloc(1024 * 1024);
 
-const server = net.createServer((socket) => {
-  socket.end(big);
-  server.close();
-}).listen(0, () => {
-  let prev = 0;
-
-  function checkRaise(value) {
-    assert(value > prev);
-    prev = value;
-  }
-
-  const socket = net.connect(server.address().port, () => {
-    socket.on('data', (chunk) => {
-      checkRaise(socket.bytesRead);
-    });
-
-    socket.on('end', common.mustCall(() => {
-      assert.strictEqual(socket.bytesRead, prev);
-      assert.strictEqual(big.length, prev);
-    }));
-
-    socket.on('close', common.mustCall(() => {
-      assert(!socket._handle);
-      assert.strictEqual(socket.bytesRead, prev);
-      assert.strictEqual(big.length, prev);
-    }));
-
-    socket.end();
+const server = net
+  .createServer((socket) => {
+    socket.end(big);
+    server.close();
+  })
+  .listen(0, () => {
+    let prev = 0;
+
+    function checkRaise(value) {
+      assert(value > prev);
+      prev = value;
+    }
+
+    const socket = net.connect(
+      server.address().port,
+      () => {
+        socket.on('data', (chunk) => {
+          checkRaise(socket.bytesRead);
+        });
+
+        socket.on(
+          'end',
+          common.mustCall(() => {
+            assert.strictEqual(socket.bytesRead, prev);
+            assert.strictEqual(big.length, prev);
+          })
+        );
+
+        socket.on(
+          'close',
+          common.mustCall(() => {
+            assert(!socket._handle);
+            assert.strictEqual(socket.bytesRead, prev);
+            assert.strictEqual(big.length, prev);
+          })
+        );
+
+        socket.end();
+      }
+    );
   });
-});
diff --git a/test/parallel/test-net-bytes-written-large.js b/test/parallel/test-net-bytes-written-large.js
index 79a997ec5a38f1..d50eb4e4561b99 100644
--- a/test/parallel/test-net-bytes-written-large.js
+++ b/test/parallel/test-net-bytes-written-large.js
@@ -12,56 +12,95 @@ const net = require('net');
 const N = 10000000;
 {
   // Variant 1: Write a Buffer.
-  const server = net.createServer(common.mustCall((socket) => {
-    socket.end(Buffer.alloc(N), common.mustCall(() => {
-      assert.strictEqual(socket.bytesWritten, N);
-    }));
-    assert.strictEqual(socket.bytesWritten, N);
-  })).listen(0, common.mustCall(() => {
-    const client = net.connect(server.address().port);
-    client.resume();
-    client.on('close', common.mustCall(() => {
-      assert.strictEqual(client.bytesRead, N);
-      server.close();
-    }));
-  }));
+  const server = net
+    .createServer(
+      common.mustCall((socket) => {
+        socket.end(
+          Buffer.alloc(N),
+          common.mustCall(() => {
+            assert.strictEqual(socket.bytesWritten, N);
+          })
+        );
+        assert.strictEqual(socket.bytesWritten, N);
+      })
+    )
+    .listen(
+      0,
+      common.mustCall(() => {
+        const client = net.connect(server.address().port);
+        client.resume();
+        client.on(
+          'close',
+          common.mustCall(() => {
+            assert.strictEqual(client.bytesRead, N);
+            server.close();
+          })
+        );
+      })
+    );
 }
 
 {
   // Variant 2: Write a string.
-  const server = net.createServer(common.mustCall((socket) => {
-    socket.end('a'.repeat(N), common.mustCall(() => {
-      assert.strictEqual(socket.bytesWritten, N);
-    }));
-    assert.strictEqual(socket.bytesWritten, N);
-  })).listen(0, common.mustCall(() => {
-    const client = net.connect(server.address().port);
-    client.resume();
-    client.on('close', common.mustCall(() => {
-      assert.strictEqual(client.bytesRead, N);
-      server.close();
-    }));
-  }));
+  const server = net
+    .createServer(
+      common.mustCall((socket) => {
+        socket.end(
+          'a'.repeat(N),
+          common.mustCall(() => {
+            assert.strictEqual(socket.bytesWritten, N);
+          })
+        );
+        assert.strictEqual(socket.bytesWritten, N);
+      })
+    )
+    .listen(
+      0,
+      common.mustCall(() => {
+        const client = net.connect(server.address().port);
+        client.resume();
+        client.on(
+          'close',
+          common.mustCall(() => {
+            assert.strictEqual(client.bytesRead, N);
+            server.close();
+          })
+        );
+      })
+    );
 }
 
 {
   // Variant 2: writev() with mixed data.
-  const server = net.createServer(common.mustCall((socket) => {
-    socket.cork();
-    socket.write('a'.repeat(N));
-    assert.strictEqual(socket.bytesWritten, N);
-    socket.write(Buffer.alloc(N));
-    assert.strictEqual(socket.bytesWritten, 2 * N);
-    socket.end('', common.mustCall(() => {
-      assert.strictEqual(socket.bytesWritten, 2 * N);
-    }));
-    socket.uncork();
-  })).listen(0, common.mustCall(() => {
-    const client = net.connect(server.address().port);
-    client.resume();
-    client.on('close', common.mustCall(() => {
-      assert.strictEqual(client.bytesRead, 2 * N);
-      server.close();
-    }));
-  }));
+  const server = net
+    .createServer(
+      common.mustCall((socket) => {
+        socket.cork();
+        socket.write('a'.repeat(N));
+        assert.strictEqual(socket.bytesWritten, N);
+        socket.write(Buffer.alloc(N));
+        assert.strictEqual(socket.bytesWritten, 2 * N);
+        socket.end(
+          '',
+          common.mustCall(() => {
+            assert.strictEqual(socket.bytesWritten, 2 * N);
+          })
+        );
+        socket.uncork();
+      })
+    )
+    .listen(
+      0,
+      common.mustCall(() => {
+        const client = net.connect(server.address().port);
+        client.resume();
+        client.on(
+          'close',
+          common.mustCall(() => {
+            assert.strictEqual(client.bytesRead, 2 * N);
+            server.close();
+          })
+        );
+      })
+    );
 }
diff --git a/test/parallel/test-net-can-reset-timeout.js b/test/parallel/test-net-can-reset-timeout.js
index 69f6c9288b77f7..993386ea55626d 100644
--- a/test/parallel/test-net-can-reset-timeout.js
+++ b/test/parallel/test-net-can-reset-timeout.js
@@ -26,22 +26,27 @@ const common = require('../common');
 
 const net = require('net');
 
-const server = net.createServer(common.mustCall(function(stream) {
-  stream.setTimeout(100);
-
-  stream.resume();
-
-  stream.once('timeout', common.mustCall(function() {
-    console.log('timeout');
-    // try to reset the timeout.
-    stream.write('WHAT.');
-  }));
-
-  stream.on('end', function() {
-    console.log('server side end');
-    stream.end();
-  });
-}));
+const server = net.createServer(
+  common.mustCall(function(stream) {
+    stream.setTimeout(100);
+
+    stream.resume();
+
+    stream.once(
+      'timeout',
+      common.mustCall(function() {
+        console.log('timeout');
+        // try to reset the timeout.
+        stream.write('WHAT.');
+      })
+    );
+
+    stream.on('end', function() {
+      console.log('server side end');
+      stream.end();
+    });
+  })
+);
 
 server.listen(0, function() {
   const c = net.createConnection(this.address().port);
diff --git a/test/parallel/test-net-client-bind-twice.js b/test/parallel/test-net-client-bind-twice.js
index ca7eb502d85ba5..04ab3290702ae8 100644
--- a/test/parallel/test-net-client-bind-twice.js
+++ b/test/parallel/test-net-client-bind-twice.js
@@ -7,20 +7,34 @@ const assert = require('assert');
 const net = require('net');
 
 const server1 = net.createServer(common.mustNotCall());
-server1.listen(0, common.localhostIPv4, common.mustCall(() => {
-  const server2 = net.createServer(common.mustNotCall());
-  server2.listen(0, common.localhostIPv4, common.mustCall(() => {
-    const client = net.connect({
-      host: common.localhostIPv4,
-      port: server1.address().port,
-      localAddress: common.localhostIPv4,
-      localPort: server2.address().port
-    }, common.mustNotCall());
+server1.listen(
+  0,
+  common.localhostIPv4,
+  common.mustCall(() => {
+    const server2 = net.createServer(common.mustNotCall());
+    server2.listen(
+      0,
+      common.localhostIPv4,
+      common.mustCall(() => {
+        const client = net.connect(
+          {
+            host: common.localhostIPv4,
+            port: server1.address().port,
+            localAddress: common.localhostIPv4,
+            localPort: server2.address().port
+          },
+          common.mustNotCall()
+        );
 
-    client.on('error', common.mustCall((err) => {
-      assert.strictEqual(err.code, 'EADDRINUSE');
-      server1.close();
-      server2.close();
-    }));
-  }));
-}));
+        client.on(
+          'error',
+          common.mustCall((err) => {
+            assert.strictEqual(err.code, 'EADDRINUSE');
+            server1.close();
+            server2.close();
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-connect-buffer.js b/test/parallel/test-net-connect-buffer.js
index 81dd8f0c569c71..10dec4af98b194 100644
--- a/test/parallel/test-net-connect-buffer.js
+++ b/test/parallel/test-net-connect-buffer.js
@@ -24,80 +24,86 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-const tcp = net.Server(common.mustCall((s) => {
-  tcp.close();
+const tcp = net.Server(
+  common.mustCall((s) => {
+    tcp.close();
 
-  let buf = '';
-  s.setEncoding('utf8');
-  s.on('data', function(d) {
-    buf += d;
-  });
+    let buf = '';
+    s.setEncoding('utf8');
+    s.on('data', function(d) {
+      buf += d;
+    });
 
-  s.on('end', function() {
-    console.error('SERVER: end', buf);
-    assert.strictEqual(buf, "L'État, c'est moi");
-    s.end();
-  });
-}));
+    s.on('end', function() {
+      console.error('SERVER: end', buf);
+      assert.strictEqual(buf, "L'État, c'est moi");
+      s.end();
+    });
+  })
+);
 
-tcp.listen(0, common.mustCall(function() {
-  const socket = net.Stream({ highWaterMark: 0 });
+tcp.listen(
+  0,
+  common.mustCall(function() {
+    const socket = net.Stream({ highWaterMark: 0 });
 
-  let connected = false;
-  assert.strictEqual(socket.pending, true);
-  socket.connect(this.address().port, common.mustCall(() => connected = true));
+    let connected = false;
+    assert.strictEqual(socket.pending, true);
+    socket.connect(
+      this.address().port,
+      common.mustCall(() => (connected = true))
+    );
 
-  assert.strictEqual(socket.pending, true);
-  assert.strictEqual(socket.connecting, true);
-  assert.strictEqual(socket.readyState, 'opening');
+    assert.strictEqual(socket.pending, true);
+    assert.strictEqual(socket.connecting, true);
+    assert.strictEqual(socket.readyState, 'opening');
 
-  // Make sure that anything besides a buffer or a string throws.
-  common.expectsError(() => socket.write(null),
-                      {
-                        code: 'ERR_STREAM_NULL_VALUES',
-                        type: TypeError,
-                        message: 'May not write null values to stream'
-                      });
-  [
-    true,
-    false,
-    undefined,
-    1,
-    1.0,
-    +Infinity,
-    -Infinity,
-    [],
-    {}
-  ].forEach((value) => {
-    common.expectsError(() => socket.write(value), {
-      code: 'ERR_INVALID_ARG_TYPE',
+    // Make sure that anything besides a buffer or a string throws.
+    common.expectsError(() => socket.write(null), {
+      code: 'ERR_STREAM_NULL_VALUES',
       type: TypeError,
-      message: 'The "chunk" argument must be one of type string or Buffer. ' +
-               `Received type ${typeof value}`
+      message: 'May not write null values to stream'
     });
-  });
+    [true, false, undefined, 1, 1.0, +Infinity, -Infinity, [], {}].forEach(
+      (value) => {
+        common.expectsError(() => socket.write(value), {
+          code: 'ERR_INVALID_ARG_TYPE',
+          type: TypeError,
+          message:
+            'The "chunk" argument must be one of type string or Buffer. ' +
+            `Received type ${typeof value}`
+        });
+      }
+    );
 
-  // Write a string that contains a multi-byte character sequence to test that
-  // `bytesWritten` is incremented with the # of bytes, not # of characters.
-  const a = "L'État, c'est ";
-  const b = 'moi';
+    // Write a string that contains a multi-byte character sequence to test that
+    // `bytesWritten` is incremented with the # of bytes, not # of characters.
+    const a = "L'État, c'est ";
+    const b = 'moi';
 
-  // We're still connecting at this point so the datagram is first pushed onto
-  // the connect queue. Make sure that it's not added to `bytesWritten` again
-  // when the actual write happens.
-  const r = socket.write(a, common.mustCall((er) => {
-    console.error('write cb');
-    assert.ok(connected);
-    assert.strictEqual(socket.bytesWritten, Buffer.from(a + b).length);
-    assert.strictEqual(socket.pending, false);
-  }));
-  socket.on('close', common.mustCall(() => {
-    assert.strictEqual(socket.pending, true);
-  }));
+    // We're still connecting at this point so the datagram is first pushed onto
+    // the connect queue. Make sure that it's not added to `bytesWritten` again
+    // when the actual write happens.
+    const r = socket.write(
+      a,
+      common.mustCall((er) => {
+        console.error('write cb');
+        assert.ok(connected);
+        assert.strictEqual(socket.bytesWritten, Buffer.from(a + b).length);
+        assert.strictEqual(socket.pending, false);
+      })
+    );
+    socket.on(
+      'close',
+      common.mustCall(() => {
+        assert.strictEqual(socket.pending, true);
+      })
+    );
 
-  assert.strictEqual(socket.bytesWritten, Buffer.from(a).length);
-  assert.strictEqual(r, false);
-  socket.end(b);
+    assert.strictEqual(socket.bytesWritten, Buffer.from(a).length);
+    assert.strictEqual(r, false);
+    socket.end(b);
 
-  assert.strictEqual(socket.readyState, 'opening');
-}));
+    assert.strictEqual(socket.readyState, 'opening');
+  })
+);
diff --git a/test/parallel/test-net-connect-call-socket-connect.js b/test/parallel/test-net-connect-call-socket-connect.js
index 88551889fe253c..0e02e9fc3441b1 100644
--- a/test/parallel/test-net-connect-call-socket-connect.js
+++ b/test/parallel/test-net-connect-call-socket-connect.js
@@ -28,12 +28,20 @@ Socket.prototype.connect = common.mustCall(function() {
 
 const server = net.createServer();
 
-server.listen(common.mustCall(function() {
-  const port = server.address().port;
-  const client = net.connect({ port }, common.mustCall(function() {
-    client.end();
-  }));
-  client.on('end', common.mustCall(function() {
-    server.close();
-  }));
-}));
+server.listen(
+  common.mustCall(function() {
+    const port = server.address().port;
+    const client = net.connect(
+      { port },
+      common.mustCall(function() {
+        client.end();
+      })
+    );
+    client.on(
+      'end',
+      common.mustCall(function() {
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-connect-handle-econnrefused.js b/test/parallel/test-net-connect-handle-econnrefused.js
index c1ccfc23384caf..e87db42a896ef6 100644
--- a/test/parallel/test-net-connect-handle-econnrefused.js
+++ b/test/parallel/test-net-connect-handle-econnrefused.js
@@ -27,10 +27,15 @@ const assert = require('assert');
 const server = net.createServer();
 server.listen(0);
 const port = server.address().port;
-server.close(common.mustCall(() => {
-  const c = net.createConnection(port);
-  c.on('connect', common.mustNotCall());
-  c.on('error', common.mustCall((e) => {
-    assert.strictEqual(e.code, 'ECONNREFUSED');
-  }));
-}));
+server.close(
+  common.mustCall(() => {
+    const c = net.createConnection(port);
+    c.on('connect', common.mustNotCall());
+    c.on(
+      'error',
+      common.mustCall((e) => {
+        assert.strictEqual(e.code, 'ECONNREFUSED');
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-connect-immediate-destroy.js b/test/parallel/test-net-connect-immediate-destroy.js
index 3ca58c356b44d1..2a89a44e327772 100644
--- a/test/parallel/test-net-connect-immediate-destroy.js
+++ b/test/parallel/test-net-connect-immediate-destroy.js
@@ -5,7 +5,11 @@ const net = require('net');
 const server = net.createServer();
 server.listen(0);
 const port = server.address().port;
-const socket = net.connect(port, common.localhostIPv4, common.mustNotCall());
+const socket = net.connect(
+  port,
+  common.localhostIPv4,
+  common.mustNotCall()
+);
 socket.on('error', common.mustNotCall());
 server.close();
 socket.destroy();
diff --git a/test/parallel/test-net-connect-immediate-finish.js b/test/parallel/test-net-connect-immediate-finish.js
index 27d988ab5af45f..0359b9debb43ad 100644
--- a/test/parallel/test-net-connect-immediate-finish.js
+++ b/test/parallel/test-net-connect-immediate-finish.js
@@ -36,19 +36,25 @@ const {
   mockedSysCall
 } = require('../common/dns');
 
-const client = net.connect({
-  host: addresses.INVALID_HOST,
-  port: 80, // port number doesn't matter because host name is invalid
-  lookup: common.mustCall(errorLookupMock())
-}, common.mustNotCall());
+const client = net.connect(
+  {
+    host: addresses.INVALID_HOST,
+    port: 80, // port number doesn't matter because host name is invalid
+    lookup: common.mustCall(errorLookupMock())
+  },
+  common.mustNotCall()
+);
 
-client.once('error', common.mustCall((err) => {
-  assert(err);
-  assert.strictEqual(err.code, err.errno);
-  assert.strictEqual(err.code, mockedErrorCode);
-  assert.strictEqual(err.host, err.hostname);
-  assert.strictEqual(err.host, addresses.INVALID_HOST);
-  assert.strictEqual(err.syscall, mockedSysCall);
-}));
+client.once(
+  'error',
+  common.mustCall((err) => {
+    assert(err);
+    assert.strictEqual(err.code, err.errno);
+    assert.strictEqual(err.code, mockedErrorCode);
+    assert.strictEqual(err.host, err.hostname);
+    assert.strictEqual(err.host, addresses.INVALID_HOST);
+    assert.strictEqual(err.syscall, mockedSysCall);
+  })
+);
 
 client.end();
diff --git a/test/parallel/test-net-connect-memleak.js b/test/parallel/test-net-connect-memleak.js
index 4efceee0eae138..f074d8d63739bd 100644
--- a/test/parallel/test-net-connect-memleak.js
+++ b/test/parallel/test-net-connect-memleak.js
@@ -33,7 +33,11 @@ const net = require('net');
 const server = net.createServer(common.mustCall()).listen(0);
 
 let collected = false;
-const gcListener = { ongc() { collected = true; } };
+const gcListener = {
+  ongc() {
+    collected = true;
+  }
+};
 
 {
   const gcObject = {};
@@ -45,7 +49,8 @@ const gcListener = { ongc() { collected = true; } };
       assert.strictEqual(gcObject, gcObject); // keep reference alive
       assert.strictEqual(collected, false);
       setImmediate(done, sock);
-    }));
+    })
+  );
 }
 
 function done(sock) {
diff --git a/test/parallel/test-net-connect-options-allowhalfopen.js b/test/parallel/test-net-connect-options-allowhalfopen.js
index 509b33ec4c33a8..4dd66e56b59319 100644
--- a/test/parallel/test-net-connect-options-allowhalfopen.js
+++ b/test/parallel/test-net-connect-options-allowhalfopen.js
@@ -36,24 +36,33 @@ const net = require('net');
     console.log(`'connection' ${++serverConnections} emitted on server`);
     const srvConn = serverConnections;
     socket.resume();
-    socket.on('data', common.mustCall(function socketOnData(data) {
-      this.clientId = data.toString();
-      console.log(
-        `server connection ${srvConn} is started by client ${this.clientId}`);
-    }));
+    socket.on(
+      'data',
+      common.mustCall(function socketOnData(data) {
+        this.clientId = data.toString();
+        console.log(
+          `server connection ${srvConn} is started by client ${this.clientId}`
+        );
+      })
+    );
     // 'end' on each socket must not be emitted twice
-    socket.on('end', common.mustCall(function socketOnEnd() {
-      console.log(`Server received FIN sent by client ${this.clientId}`);
-      if (++serverReceivedFIN < CLIENT_VARIANTS) return;
-      setTimeout(() => {
-        server.close();
-        console.log(`connection ${this.clientId} is closing the server:
+    socket.on(
+      'end',
+      common.mustCall(function socketOnEnd() {
+        console.log(`Server received FIN sent by client ${this.clientId}`);
+        if (++serverReceivedFIN < CLIENT_VARIANTS) return;
+        setTimeout(() => {
+          server.close();
+          console.log(
+            `connection ${this.clientId} is closing the server:
           FIN ${serverReceivedFIN} received by server,
           FIN ${clientReceivedFIN} received by client
           FIN ${clientSentFIN} sent by client,
-          FIN ${serverConnections} sent by server`.replace(/ {3,}/g, ''));
-      }, 50);
-    }, 1));
+          FIN ${serverConnections} sent by server`.replace(/ {3,}/g, '')
+          );
+        }, 50);
+      }, 1)
+    );
     socket.end();
     console.log(`Server has sent ${serverConnections} FIN`);
   }
@@ -65,34 +74,45 @@ const net = require('net');
       const client = this;
       console.log(`'connect' emitted on Client ${index}`);
       client.resume();
-      client.on('end', common.mustCall(function clientOnEnd() {
-        setTimeout(function closeServer() {
-          // when allowHalfOpen is true, client must still be writable
-          // after the server closes the connections, but not readable
-          console.log(`client ${index} received FIN`);
-          assert(!client.readable);
-          assert(client.writable);
-          assert(client.write(String(index)));
-          client.end();
-          clientSentFIN++;
+      client.on(
+        'end',
+        common.mustCall(function clientOnEnd() {
+          setTimeout(function closeServer() {
+            // when allowHalfOpen is true, client must still be writable
+            // after the server closes the connections, but not readable
+            console.log(`client ${index} received FIN`);
+            assert(!client.readable);
+            assert(client.writable);
+            assert(client.write(String(index)));
+            client.end();
+            clientSentFIN++;
+            console.log(
+              `client ${index} sent FIN, ${clientSentFIN} have been sent`
+            );
+          }, 50);
+        })
+      );
+      client.on(
+        'close',
+        common.mustCall(function clientOnClose() {
+          clientReceivedFIN++;
           console.log(
-            `client ${index} sent FIN, ${clientSentFIN} have been sent`);
-        }, 50);
-      }));
-      client.on('close', common.mustCall(function clientOnClose() {
-        clientReceivedFIN++;
-        console.log(`connection ${index} has been closed by both sides,` +
-          ` ${clientReceivedFIN} clients have closed`);
-      }));
+            `connection ${index} has been closed by both sides,` +
+              ` ${clientReceivedFIN} clients have closed`
+          );
+        })
+      );
     });
   }
 
   function serverOnClose() {
-    console.log(`Server has been closed:
+    console.log(
+      `Server has been closed:
       FIN ${serverReceivedFIN} received by server
       FIN ${clientReceivedFIN} received by client
       FIN ${clientSentFIN} sent by client
-      FIN ${serverConnections} sent by server`.replace(/ {3,}/g, ''));
+      FIN ${serverConnections} sent by server`.replace(/ {3,}/g, '')
+    );
   }
 
   function serverOnListen() {
@@ -100,18 +120,25 @@ const net = require('net');
     console.log(`Server started listening at ${host}:${port}`);
     const opts = { allowHalfOpen: true, host, port };
     // 6 variations === CLIENT_VARIANTS
-    net.connect(opts, clientOnConnect(1));
+    net.connect(
+      opts,
+      clientOnConnect(1)
+    );
     net.connect(opts).on('connect', clientOnConnect(2));
     net.createConnection(opts, clientOnConnect(3));
     net.createConnection(opts).on('connect', clientOnConnect(4));
-    new net.Socket(opts).connect(opts, clientOnConnect(5));
+    new net.Socket(opts).connect(
+      opts,
+      clientOnConnect(5)
+    );
     new net.Socket(opts).connect(opts).on('connect', clientOnConnect(6));
   }
 
   const CLIENT_VARIANTS = 6;
 
   // The trigger
-  const server = net.createServer({ allowHalfOpen: true })
+  const server = net
+    .createServer({ allowHalfOpen: true })
     .on('connection', common.mustCall(serverOnConnection, CLIENT_VARIANTS))
     .on('close', common.mustCall(serverOnClose))
     .listen(0, host, common.mustCall(serverOnListen));
diff --git a/test/parallel/test-net-connect-options-fd.js b/test/parallel/test-net-connect-options-fd.js
index 94b831bf5d2ac3..35278394531a61 100644
--- a/test/parallel/test-net-connect-options-fd.js
+++ b/test/parallel/test-net-connect-options-fd.js
@@ -17,19 +17,24 @@ function testClients(getSocketOpt, getConnectOpt, getConnectCb) {
   const cloneOptions = (index) =>
     Object.assign({}, getSocketOpt(index), getConnectOpt(index));
   return [
-    net.connect(cloneOptions(0), getConnectCb(0)),
-    net.connect(cloneOptions(1))
-      .on('connect', getConnectCb(1)),
+    net.connect(
+      cloneOptions(0),
+      getConnectCb(0)
+    ),
+    net.connect(cloneOptions(1)).on('connect', getConnectCb(1)),
     net.createConnection(cloneOptions(2), getConnectCb(2)),
-    net.createConnection(cloneOptions(3))
-      .on('connect', getConnectCb(3)),
-    new net.Socket(getSocketOpt(4)).connect(getConnectOpt(4), getConnectCb(4)),
-    new net.Socket(getSocketOpt(5)).connect(getConnectOpt(5))
+    net.createConnection(cloneOptions(3)).on('connect', getConnectCb(3)),
+    new net.Socket(getSocketOpt(4)).connect(
+      getConnectOpt(4),
+      getConnectCb(4)
+    ),
+    new net.Socket(getSocketOpt(5))
+      .connect(getConnectOpt(5))
       .on('connect', getConnectCb(5))
   ];
 }
 
-const CLIENT_VARIANTS = 6;  // Same length as array above
+const CLIENT_VARIANTS = 6; // Same length as array above
 const forAllClients = (cb) => common.mustCall(cb, CLIENT_VARIANTS);
 
 // Test Pipe fd is wrapped correctly
@@ -41,63 +46,79 @@ const forAllClients = (cb) => common.mustCall(cb, CLIENT_VARIANTS);
   let counter = 0;
   let socketCounter = 0;
   const handleMap = new Map();
-  const server = net.createServer()
-  .on('connection', forAllClients(function serverOnConnection(socket) {
-    let clientFd;
-    socket.on('data', common.mustCall(function(data) {
-      clientFd = data.toString();
-      console.error(`[Pipe]Received data from fd ${clientFd}`);
-      socket.end();
-    }));
-    socket.on('end', common.mustCall(function() {
-      counter++;
-      console.error(`[Pipe]Received end from fd ${clientFd}, total ${counter}`);
-      if (counter === CLIENT_VARIANTS) {
-        setTimeout(() => {
-          console.error(`[Pipe]Server closed by fd ${clientFd}`);
-          server.close();
-        }, 10);
-      }
-    }, 1));
-  }))
-  .on('close', function() {
-    setTimeout(() => {
-      for (const pair of handleMap) {
-        console.error(`[Pipe]Clean up handle with fd ${pair[1].fd}`);
-        pair[1].close();  // clean up handles
-      }
-    }, 10);
-  })
-  .on('error', function(err) {
-    console.error(err);
-    assert.fail(`[Pipe server]${err}`);
-  })
-  .listen({ path: serverPath }, common.mustCall(function serverOnListen() {
-    const getSocketOpt = (index) => {
-      const handle = new Pipe(PipeConstants.SOCKET);
-      const err = handle.bind(`${prefix}-client-${socketCounter++}`);
-      assert(err >= 0, String(err));
-      assert.notStrictEqual(handle.fd, -1);
-      handleMap.set(index, handle);
-      console.error(`[Pipe]Bound handle with Pipe ${handle.fd}`);
-      return { fd: handle.fd, readable: true, writable: true };
-    };
-    const getConnectOpt = () => ({
-      path: serverPath
-    });
-    const getConnectCb = (index) => common.mustCall(function clientOnConnect() {
-      // Test if it's wrapping an existing fd
-      assert(handleMap.has(index));
-      const oldHandle = handleMap.get(index);
-      assert.strictEqual(oldHandle.fd, this._handle.fd);
-      this.write(String(oldHandle.fd));
-      console.error(`[Pipe]Sending data through fd ${oldHandle.fd}`);
-      this.on('error', function(err) {
-        console.error(err);
-        assert.fail(`[Pipe Client]${err}`);
-      });
-    });
+  const server = net
+    .createServer()
+    .on(
+      'connection',
+      forAllClients(function serverOnConnection(socket) {
+        let clientFd;
+        socket.on(
+          'data',
+          common.mustCall(function(data) {
+            clientFd = data.toString();
+            console.error(`[Pipe]Received data from fd ${clientFd}`);
+            socket.end();
+          })
+        );
+        socket.on(
+          'end',
+          common.mustCall(function() {
+            counter++;
+            console.error(
+              `[Pipe]Received end from fd ${clientFd}, total ${counter}`
+            );
+            if (counter === CLIENT_VARIANTS) {
+              setTimeout(() => {
+                console.error(`[Pipe]Server closed by fd ${clientFd}`);
+                server.close();
+              }, 10);
+            }
+          }, 1)
+        );
+      })
+    )
+    .on('close', function() {
+      setTimeout(() => {
+        for (const pair of handleMap) {
+          console.error(`[Pipe]Clean up handle with fd ${pair[1].fd}`);
+          pair[1].close(); // clean up handles
+        }
+      }, 10);
+    })
+    .on('error', function(err) {
+      console.error(err);
+      assert.fail(`[Pipe server]${err}`);
+    })
+    .listen(
+      { path: serverPath },
+      common.mustCall(function serverOnListen() {
+        const getSocketOpt = (index) => {
+          const handle = new Pipe(PipeConstants.SOCKET);
+          const err = handle.bind(`${prefix}-client-${socketCounter++}`);
+          assert(err >= 0, String(err));
+          assert.notStrictEqual(handle.fd, -1);
+          handleMap.set(index, handle);
+          console.error(`[Pipe]Bound handle with Pipe ${handle.fd}`);
+          return { fd: handle.fd, readable: true, writable: true };
+        };
+        const getConnectOpt = () => ({
+          path: serverPath
+        });
+        const getConnectCb = (index) =>
+          common.mustCall(function clientOnConnect() {
+            // Test if it's wrapping an existing fd
+            assert(handleMap.has(index));
+            const oldHandle = handleMap.get(index);
+            assert.strictEqual(oldHandle.fd, this._handle.fd);
+            this.write(String(oldHandle.fd));
+            console.error(`[Pipe]Sending data through fd ${oldHandle.fd}`);
+            this.on('error', function(err) {
+              console.error(err);
+              assert.fail(`[Pipe Client]${err}`);
+            });
+          });
 
-    testClients(getSocketOpt, getConnectOpt, getConnectCb);
-  }));
+        testClients(getSocketOpt, getConnectOpt, getConnectCb);
+      })
+    );
 }
diff --git a/test/parallel/test-net-connect-options-ipv6.js b/test/parallel/test-net-connect-options-ipv6.js
index 13381074ba46b7..05714f440dda21 100644
--- a/test/parallel/test-net-connect-options-ipv6.js
+++ b/test/parallel/test-net-connect-options-ipv6.js
@@ -23,8 +23,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasIPv6)
-  common.skip('no IPv6 support');
+if (!common.hasIPv6) common.skip('no IPv6 support');
 
 const assert = require('assert');
 const net = require('net');
@@ -51,17 +50,20 @@ function tryConnect() {
     })
   };
   // No `mustCall`, since test could skip, and it's the only path to `close`.
-  const client = net.connect(connectOpt, () => {
-    client.resume();
-    client.on('end', () => {
-      // Wait for next uv tick and make sure the socket stream is writable.
-      setTimeout(function() {
-        assert(client.writable);
-        client.end();
-      }, 10);
-    });
-    client.on('close', () => server.close());
-  });
+  const client = net.connect(
+    connectOpt,
+    () => {
+      client.resume();
+      client.on('end', () => {
+        // Wait for next uv tick and make sure the socket stream is writable.
+        setTimeout(function() {
+          assert(client.writable);
+          client.end();
+        }, 10);
+      });
+      client.on('close', () => server.close());
+    }
+  );
 }
 
 server.listen(0, hostAddrIPv6, tryConnect);
diff --git a/test/parallel/test-net-connect-options-path.js b/test/parallel/test-net-connect-options-path.js
index 61de8caab15b56..3369317d1ac6fe 100644
--- a/test/parallel/test-net-connect-options-path.js
+++ b/test/parallel/test-net-connect-options-path.js
@@ -15,45 +15,82 @@ const CLIENT_VARIANTS = 12;
   const prefix = `${common.PIPE}-net-connect-options-path`;
   const serverPath = `${prefix}-server`;
   let counter = 0;
-  const server = net.createServer()
-  .on('connection', common.mustCall(function(socket) {
-    socket.end('ok');
-  }, CLIENT_VARIANTS))
-  .listen(serverPath, common.mustCall(function() {
-    const getConnectCb = () => common.mustCall(function() {
-      this.end();
-      this.on('close', common.mustCall(function() {
-        counter++;
-        if (counter === CLIENT_VARIANTS) {
-          server.close();
-        }
-      }));
-    });
+  const server = net
+    .createServer()
+    .on(
+      'connection',
+      common.mustCall(function(socket) {
+        socket.end('ok');
+      }, CLIENT_VARIANTS)
+    )
+    .listen(
+      serverPath,
+      common.mustCall(function() {
+        const getConnectCb = () =>
+          common.mustCall(function() {
+            this.end();
+            this.on(
+              'close',
+              common.mustCall(function() {
+                counter++;
+                if (counter === CLIENT_VARIANTS) {
+                  server.close();
+                }
+              })
+            );
+          });
 
-    // CLIENT_VARIANTS depends on the following code
-    net.connect(serverPath, getConnectCb()).resume();
-    net.connect(serverPath)
-      .on('connect', getConnectCb())
-      .resume();
-    net.createConnection(serverPath, getConnectCb()).resume();
-    net.createConnection(serverPath)
-      .on('connect', getConnectCb())
-      .resume();
-    new net.Socket().connect(serverPath, getConnectCb()).resume();
-    new net.Socket().connect(serverPath)
-      .on('connect', getConnectCb())
-      .resume();
-    net.connect({ path: serverPath }, getConnectCb()).resume();
-    net.connect({ path: serverPath })
-      .on('connect', getConnectCb())
-      .resume();
-    net.createConnection({ path: serverPath }, getConnectCb()).resume();
-    net.createConnection({ path: serverPath })
-      .on('connect', getConnectCb())
-      .resume();
-    new net.Socket().connect({ path: serverPath }, getConnectCb()).resume();
-    new net.Socket().connect({ path: serverPath })
-      .on('connect', getConnectCb())
-      .resume();
-  }));
+        // CLIENT_VARIANTS depends on the following code
+        net
+          .connect(
+            serverPath,
+            getConnectCb()
+          )
+          .resume();
+        net
+          .connect(serverPath)
+          .on('connect', getConnectCb())
+          .resume();
+        net.createConnection(serverPath, getConnectCb()).resume();
+        net
+          .createConnection(serverPath)
+          .on('connect', getConnectCb())
+          .resume();
+        new net.Socket()
+          .connect(
+            serverPath,
+            getConnectCb()
+          )
+          .resume();
+        new net.Socket()
+          .connect(serverPath)
+          .on('connect', getConnectCb())
+          .resume();
+        net
+          .connect(
+            { path: serverPath },
+            getConnectCb()
+          )
+          .resume();
+        net
+          .connect({ path: serverPath })
+          .on('connect', getConnectCb())
+          .resume();
+        net.createConnection({ path: serverPath }, getConnectCb()).resume();
+        net
+          .createConnection({ path: serverPath })
+          .on('connect', getConnectCb())
+          .resume();
+        new net.Socket()
+          .connect(
+            { path: serverPath },
+            getConnectCb()
+          )
+          .resume();
+        new net.Socket()
+          .connect({ path: serverPath })
+          .on('connect', getConnectCb())
+          .resume();
+      })
+    );
 }
diff --git a/test/parallel/test-net-connect-options-port.js b/test/parallel/test-net-connect-options-port.js
index afdfc2ac615ad6..c352dcb0a9579f 100644
--- a/test/parallel/test-net-connect-options-port.js
+++ b/test/parallel/test-net-connect-options-port.js
@@ -27,10 +27,13 @@ const net = require('net');
 
 // Test wrong type of ports
 {
-  const portTypeError = common.expectsError({
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError
-  }, 96);
+  const portTypeError = common.expectsError(
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError
+    },
+    96
+  );
 
   syncFailToConnect(true, portTypeError);
   syncFailToConnect(false, portTypeError);
@@ -41,10 +44,13 @@ const net = require('net');
 
 // Test out of range ports
 {
-  const portRangeError = common.expectsError({
-    code: 'ERR_SOCKET_BAD_PORT',
-    type: RangeError
-  }, 168);
+  const portRangeError = common.expectsError(
+    {
+      code: 'ERR_SOCKET_BAD_PORT',
+      type: RangeError
+    },
+    168
+  );
 
   syncFailToConnect('', portRangeError);
   syncFailToConnect(' ', portRangeError);
@@ -60,8 +66,7 @@ const net = require('net');
 {
   // connect({hint}, cb) and connect({hint})
   const hints = (dns.ADDRCONFIG | dns.V4MAPPED) + 42;
-  const hintOptBlocks = doConnect([{ hints }],
-                                  () => common.mustNotCall());
+  const hintOptBlocks = doConnect([{ hints }], () => common.mustNotCall());
   for (const fn of hintOptBlocks) {
     common.expectsError(fn, {
       code: 'ERR_INVALID_OPT_VALUE',
@@ -76,21 +81,27 @@ const net = require('net');
   const expectedConnections = 72;
   let serverConnected = 0;
 
-  const server = net.createServer(common.mustCall(function(socket) {
-    socket.end('ok');
-    if (++serverConnected === expectedConnections) {
-      server.close();
-    }
-  }, expectedConnections));
-
-  server.listen(0, 'localhost', common.mustCall(function() {
-    const port = this.address().port;
-
-    // Total connections = 3 * 4(canConnect) * 6(doConnect) = 72
-    canConnect(port);
-    canConnect(String(port));
-    canConnect(`0x${port.toString(16)}`);
-  }));
+  const server = net.createServer(
+    common.mustCall(function(socket) {
+      socket.end('ok');
+      if (++serverConnected === expectedConnections) {
+        server.close();
+      }
+    }, expectedConnections)
+  );
+
+  server.listen(
+    0,
+    'localhost',
+    common.mustCall(function() {
+      const port = this.address().port;
+
+      // Total connections = 3 * 4(canConnect) * 6(doConnect) = 72
+      canConnect(port);
+      canConnect(String(port));
+      canConnect(`0x${port.toString(16)}`);
+    })
+  );
 
   // Try connecting to random ports, but do so once the server is closed
   server.on('close', function() {
@@ -102,31 +113,31 @@ const net = require('net');
 function doConnect(args, getCb) {
   return [
     function createConnectionWithCb() {
-      return net.createConnection.apply(net, args.concat(getCb()))
-        .resume();
+      return net.createConnection.apply(net, args.concat(getCb())).resume();
     },
     function createConnectionWithoutCb() {
-      return net.createConnection.apply(net, args)
+      return net.createConnection
+        .apply(net, args)
         .on('connect', getCb())
         .resume();
     },
     function connectWithCb() {
-      return net.connect.apply(net, args.concat(getCb()))
-        .resume();
+      return net.connect.apply(net, args.concat(getCb())).resume();
     },
     function connectWithoutCb() {
-      return net.connect.apply(net, args)
+      return net.connect
+        .apply(net, args)
         .on('connect', getCb())
         .resume();
     },
     function socketConnectWithCb() {
       const socket = new net.Socket();
-      return socket.connect.apply(socket, args.concat(getCb()))
-        .resume();
+      return socket.connect.apply(socket, args.concat(getCb())).resume();
     },
     function socketConnectWithoutCb() {
       const socket = new net.Socket();
-      return socket.connect.apply(socket, args)
+      return socket.connect
+        .apply(socket, args)
         .on('connect', getCb())
         .resume();
     }
@@ -142,8 +153,9 @@ function syncFailToConnect(port, assertErr, optOnly) {
     }
 
     // connect(port, host, cb) and connect(port, host)
-    const portHostArgFunctions = doConnect([port, 'localhost'],
-                                           () => common.mustNotCall());
+    const portHostArgFunctions = doConnect([port, 'localhost'], () =>
+      common.mustNotCall()
+    );
     for (const fn of portHostArgFunctions) {
       assert.throws(fn, assertErr, `${fn.name}(${port}, 'localhost')`);
     }
@@ -155,12 +167,16 @@ function syncFailToConnect(port, assertErr, optOnly) {
   }
 
   // connect({port, host}, cb) and connect({port, host})
-  const portHostOptFunctions = doConnect([{ port: port, host: 'localhost' }],
-                                         () => common.mustNotCall());
+  const portHostOptFunctions = doConnect(
+    [{ port: port, host: 'localhost' }],
+    () => common.mustNotCall()
+  );
   for (const fn of portHostOptFunctions) {
-    assert.throws(fn,
-                  assertErr,
-                  `${fn.name}({port: ${port}, host: 'localhost'})`);
+    assert.throws(
+      fn,
+      assertErr,
+      `${fn.name}({port: ${port}, host: 'localhost'})`
+    );
   }
 }
 
@@ -193,10 +209,11 @@ function canConnect(port) {
 }
 
 function asyncFailToConnect(port) {
-  const onError = () => common.mustCall(function(err) {
-    const regexp = /^Error: connect E\w+.+$/;
-    assert(regexp.test(String(err)), String(err));
-  });
+  const onError = () =>
+    common.mustCall(function(err) {
+      const regexp = /^Error: connect E\w+.+$/;
+      assert(regexp.test(String(err)), String(err));
+    });
 
   const dont = () => common.mustNotCall();
   // connect(port, cb) and connect(port)
diff --git a/test/parallel/test-net-connect-paused-connection.js b/test/parallel/test-net-connect-paused-connection.js
index a53177ed4c7e7e..8e715d008bc686 100644
--- a/test/parallel/test-net-connect-paused-connection.js
+++ b/test/parallel/test-net-connect-paused-connection.js
@@ -24,10 +24,18 @@ const common = require('../common');
 
 const net = require('net');
 
-net.createServer(function(conn) {
-  conn.unref();
-}).listen(0, function() {
-  net.connect(this.address().port, 'localhost').pause();
+net
+  .createServer(function(conn) {
+    conn.unref();
+  })
+  .listen(0, function() {
+    net
+      .connect(
+        this.address().port,
+        'localhost'
+      )
+      .pause();
 
-  setTimeout(common.mustNotCall('expected to exit'), 1000).unref();
-}).unref();
+    setTimeout(common.mustNotCall('expected to exit'), 1000).unref();
+  })
+  .unref();
diff --git a/test/parallel/test-net-deprecated-setsimultaneousaccepts.js b/test/parallel/test-net-deprecated-setsimultaneousaccepts.js
index 3778a9650fcc8d..242ebd8180cdf1 100644
--- a/test/parallel/test-net-deprecated-setsimultaneousaccepts.js
+++ b/test/parallel/test-net-deprecated-setsimultaneousaccepts.js
@@ -1,16 +1,13 @@
 // Flags: --no-warnings
 'use strict';
 
-const {
-  expectWarning
-} = require('../common');
-const {
-  _setSimultaneousAccepts
-} = require('net');
+const { expectWarning } = require('../common');
+const { _setSimultaneousAccepts } = require('net');
 
 expectWarning(
   'DeprecationWarning',
   'net._setSimultaneousAccepts() is deprecated and will be removed.',
-  'DEP0121');
+  'DEP0121'
+);
 
 _setSimultaneousAccepts();
diff --git a/test/parallel/test-net-dns-custom-lookup.js b/test/parallel/test-net-dns-custom-lookup.js
index c7a01f5fa6faec..ef51fc48241db0 100644
--- a/test/parallel/test-net-dns-custom-lookup.js
+++ b/test/parallel/test-net-dns-custom-lookup.js
@@ -11,18 +11,27 @@ function check(addressType, cb) {
   });
 
   const address = addressType === 4 ? common.localhostIPv4 : '::1';
-  server.listen(0, address, common.mustCall(function() {
-    net.connect({
-      port: this.address().port,
-      host: 'localhost',
-      family: addressType,
-      lookup: lookup
-    }).on('lookup', common.mustCall(function(err, ip, type) {
-      assert.strictEqual(err, null);
-      assert.strictEqual(address, ip);
-      assert.strictEqual(type, addressType);
-    }));
-  }));
+  server.listen(
+    0,
+    address,
+    common.mustCall(function() {
+      net
+        .connect({
+          port: this.address().port,
+          host: 'localhost',
+          family: addressType,
+          lookup: lookup
+        })
+        .on(
+          'lookup',
+          common.mustCall(function(err, ip, type) {
+            assert.strictEqual(err, null);
+            assert.strictEqual(address, ip);
+            assert.strictEqual(type, addressType);
+          })
+        );
+    })
+  );
 
   function lookup(host, dnsopts, cb) {
     dnsopts.family = addressType;
diff --git a/test/parallel/test-net-dns-error.js b/test/parallel/test-net-dns-error.js
index bb90eafc3d95da..16b52c0ab8124c 100644
--- a/test/parallel/test-net-dns-error.js
+++ b/test/parallel/test-net-dns-error.js
@@ -28,13 +28,23 @@ const net = require('net');
 const host = '*'.repeat(64);
 const errCode = common.isOpenBSD ? 'EAI_FAIL' : 'ENOTFOUND';
 
-const socket = net.connect(42, host, common.mustNotCall());
-socket.on('error', common.mustCall(function(err) {
-  assert.strictEqual(err.code, errCode);
-}));
-socket.on('lookup', common.mustCall(function(err, ip, type) {
-  assert(err instanceof Error);
-  assert.strictEqual(err.code, errCode);
-  assert.strictEqual(ip, undefined);
-  assert.strictEqual(type, undefined);
-}));
+const socket = net.connect(
+  42,
+  host,
+  common.mustNotCall()
+);
+socket.on(
+  'error',
+  common.mustCall(function(err) {
+    assert.strictEqual(err.code, errCode);
+  })
+);
+socket.on(
+  'lookup',
+  common.mustCall(function(err, ip, type) {
+    assert(err instanceof Error);
+    assert.strictEqual(err.code, errCode);
+    assert.strictEqual(ip, undefined);
+    assert.strictEqual(type, undefined);
+  })
+);
diff --git a/test/parallel/test-net-dns-lookup-skip.js b/test/parallel/test-net-dns-lookup-skip.js
index 06dbd5932b2c08..58ead76d2af047 100644
--- a/test/parallel/test-net-dns-lookup-skip.js
+++ b/test/parallel/test-net-dns-lookup-skip.js
@@ -10,7 +10,11 @@ function check(addressType) {
 
   const address = addressType === 4 ? '127.0.0.1' : '::1';
   server.listen(0, address, function() {
-    net.connect(this.address().port, address)
+    net
+      .connect(
+        this.address().port,
+        address
+      )
       .on('lookup', common.mustNotCall());
   });
 }
diff --git a/test/parallel/test-net-dns-lookup.js b/test/parallel/test-net-dns-lookup.js
index 53052de716ee9e..f58b171c36733e 100644
--- a/test/parallel/test-net-dns-lookup.js
+++ b/test/parallel/test-net-dns-lookup.js
@@ -29,12 +29,23 @@ const server = net.createServer(function(client) {
   server.close();
 });
 
-server.listen(0, '127.0.0.1', common.mustCall(function() {
-  net.connect(this.address().port, 'localhost')
-    .on('lookup', common.mustCall(function(err, ip, type, host) {
-      assert.strictEqual(err, null);
-      assert.strictEqual(ip, '127.0.0.1');
-      assert.strictEqual(type, 4);
-      assert.strictEqual(host, 'localhost');
-    }));
-}));
+server.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    net
+      .connect(
+        this.address().port,
+        'localhost'
+      )
+      .on(
+        'lookup',
+        common.mustCall(function(err, ip, type, host) {
+          assert.strictEqual(err, null);
+          assert.strictEqual(ip, '127.0.0.1');
+          assert.strictEqual(type, 4);
+          assert.strictEqual(host, 'localhost');
+        })
+      );
+  })
+);
diff --git a/test/parallel/test-net-during-close.js b/test/parallel/test-net-during-close.js
index 7bceb64041f2cc..ca0a75bb37eee9 100644
--- a/test/parallel/test-net-during-close.js
+++ b/test/parallel/test-net-during-close.js
@@ -27,14 +27,17 @@ const server = net.createServer(function(socket) {
   socket.end();
 });
 
-server.listen(0, common.mustCall(function() {
-  const client = net.createConnection(this.address().port);
-  server.close();
-  // Server connection event has not yet fired client is still attempting to
-  // connect. Accessing properties should not throw in this case.
-  client.remoteAddress;
-  client.remoteFamily;
-  client.remotePort;
-  // Exit now, do not wait for the client error event.
-  process.exit(0);
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const client = net.createConnection(this.address().port);
+    server.close();
+    // Server connection event has not yet fired client is still attempting to
+    // connect. Accessing properties should not throw in this case.
+    client.remoteAddress;
+    client.remoteFamily;
+    client.remotePort;
+    // Exit now, do not wait for the client error event.
+    process.exit(0);
+  })
+);
diff --git a/test/parallel/test-net-eaddrinuse.js b/test/parallel/test-net-eaddrinuse.js
index 29508e4582852e..ef1dbe6329744d 100644
--- a/test/parallel/test-net-eaddrinuse.js
+++ b/test/parallel/test-net-eaddrinuse.js
@@ -24,10 +24,8 @@ require('../common');
 const assert = require('assert');
 const net = require('net');
 
-const server1 = net.createServer(function(socket) {
-});
-const server2 = net.createServer(function(socket) {
-});
+const server1 = net.createServer(function(socket) {});
+const server2 = net.createServer(function(socket) {});
 server1.listen(0, function() {
   server2.on('error', function(error) {
     assert.strictEqual(error.message.includes('EADDRINUSE'), true);
diff --git a/test/parallel/test-net-end-close.js b/test/parallel/test-net-end-close.js
index b488f16510f7cf..8f1137aa5e5005 100644
--- a/test/parallel/test-net-end-close.js
+++ b/test/parallel/test-net-end-close.js
@@ -32,5 +32,5 @@ s.on('close', () => {
 });
 
 process.on('exit', () => {
-  assert.deepStrictEqual(events, [ 'end', 'close' ]);
+  assert.deepStrictEqual(events, ['end', 'close']);
 });
diff --git a/test/parallel/test-net-end-without-connect.js b/test/parallel/test-net-end-without-connect.js
index 98cf49768a2a26..55807783c75b35 100644
--- a/test/parallel/test-net-end-without-connect.js
+++ b/test/parallel/test-net-end-without-connect.js
@@ -24,4 +24,4 @@ require('../common');
 const net = require('net');
 
 const sock = new net.Socket();
-sock.end();  // Should not throw.
+sock.end(); // Should not throw.
diff --git a/test/parallel/test-net-error-twice.js b/test/parallel/test-net-error-twice.js
index 4c2839d372fcb4..e0cb633c52f254 100644
--- a/test/parallel/test-net-error-twice.js
+++ b/test/parallel/test-net-error-twice.js
@@ -37,25 +37,27 @@ function ready() {
   }
 }
 
-const srv = net.createServer(function onConnection(conn) {
-  conn.on('error', function(err) {
-    errs.push(err);
-    if (errs.length > 1 && errs[0] === errs[1])
-      assert.fail('Should not emit the same error twice');
-  });
-  conn.on('close', function() {
-    srv.unref();
-  });
-  serverSocket = conn;
-  ready();
-}).listen(0, function() {
-  const client = net.connect({ port: this.address().port });
-
-  client.on('connect', function() {
-    clientSocket = client;
+const srv = net
+  .createServer(function onConnection(conn) {
+    conn.on('error', function(err) {
+      errs.push(err);
+      if (errs.length > 1 && errs[0] === errs[1])
+        assert.fail('Should not emit the same error twice');
+    });
+    conn.on('close', function() {
+      srv.unref();
+    });
+    serverSocket = conn;
     ready();
+  })
+  .listen(0, function() {
+    const client = net.connect({ port: this.address().port });
+
+    client.on('connect', function() {
+      clientSocket = client;
+      ready();
+    });
   });
-});
 
 process.on('exit', function() {
   console.log(errs);
diff --git a/test/parallel/test-net-internal.js b/test/parallel/test-net-internal.js
index 309b56d4d9aafc..bafe414f2b4412 100644
--- a/test/parallel/test-net-internal.js
+++ b/test/parallel/test-net-internal.js
@@ -6,7 +6,7 @@ require('../common');
 const assert = require('assert');
 const isLegalPort = require('internal/net').isLegalPort;
 
-for (let n = 0; n <= 0xFFFF; n++) {
+for (let n = 0; n <= 0xffff; n++) {
   assert(isLegalPort(n));
   assert(isLegalPort(String(n)));
   assert(`0x${n.toString(16)}`);
@@ -14,7 +14,27 @@ for (let n = 0; n <= 0xFFFF; n++) {
   assert(`0b${n.toString(2)}`);
 }
 
-const bad = [-1, 'a', {}, [], false, true, 0xFFFF + 1, Infinity,
-             -Infinity, NaN, undefined, null, '', ' ', 1.1, '0x',
-             '-0x1', '-0o1', '-0b1', '0o', '0b'];
+const bad = [
+  -1,
+  'a',
+  {},
+  [],
+  false,
+  true,
+  0xffff + 1,
+  Infinity,
+  -Infinity,
+  NaN,
+  undefined,
+  null,
+  '',
+  ' ',
+  1.1,
+  '0x',
+  '-0x1',
+  '-0o1',
+  '-0b1',
+  '0o',
+  '0b'
+];
 bad.forEach((i) => assert(!isLegalPort(i)));
diff --git a/test/parallel/test-net-isip.js b/test/parallel/test-net-isip.js
index e9a8749aaee412..833cada22787ff 100644
--- a/test/parallel/test-net-isip.js
+++ b/test/parallel/test-net-isip.js
@@ -28,8 +28,10 @@ assert.strictEqual(net.isIP('127.0.0.1'), 4);
 assert.strictEqual(net.isIP('x127.0.0.1'), 0);
 assert.strictEqual(net.isIP('example.com'), 0);
 assert.strictEqual(net.isIP('0000:0000:0000:0000:0000:0000:0000:0000'), 6);
-assert.strictEqual(net.isIP('0000:0000:0000:0000:0000:0000:0000:0000::0000'),
-                   0);
+assert.strictEqual(
+  net.isIP('0000:0000:0000:0000:0000:0000:0000:0000::0000'),
+  0
+);
 assert.strictEqual(net.isIP('1050:0:0:0:5:600:300c:326b'), 6);
 assert.strictEqual(net.isIP('2001:252:0:1::2008:6'), 6);
 assert.strictEqual(net.isIP('2001:dead:beef:1::2008:6'), 6);
@@ -57,8 +59,10 @@ assert.strictEqual(net.isIP(null), 0);
 assert.strictEqual(net.isIP(123), 0);
 assert.strictEqual(net.isIP(true), 0);
 assert.strictEqual(net.isIP({}), 0);
-assert.strictEqual(net.isIP({ toString: () => '::2001:252:1:255.255.255.255' }),
-                   6);
+assert.strictEqual(
+  net.isIP({ toString: () => '::2001:252:1:255.255.255.255' }),
+  6
+);
 assert.strictEqual(net.isIP({ toString: () => '127.0.0.1' }), 4);
 assert.strictEqual(net.isIP({ toString: () => 'bla' }), 0);
 
@@ -71,9 +75,12 @@ assert.strictEqual(net.isIPv4(null), false);
 assert.strictEqual(net.isIPv4(123), false);
 assert.strictEqual(net.isIPv4(true), false);
 assert.strictEqual(net.isIPv4({}), false);
-assert.strictEqual(net.isIPv4({
-  toString: () => '::2001:252:1:255.255.255.255'
-}), false);
+assert.strictEqual(
+  net.isIPv4({
+    toString: () => '::2001:252:1:255.255.255.255'
+  }),
+  false
+);
 assert.strictEqual(net.isIPv4({ toString: () => '127.0.0.1' }), true);
 assert.strictEqual(net.isIPv4({ toString: () => 'bla' }), false);
 
@@ -86,8 +93,11 @@ assert.strictEqual(net.isIPv6(null), false);
 assert.strictEqual(net.isIPv6(123), false);
 assert.strictEqual(net.isIPv6(true), false);
 assert.strictEqual(net.isIPv6({}), false);
-assert.strictEqual(net.isIPv6({
-  toString: () => '::2001:252:1:255.255.255.255'
-}), true);
+assert.strictEqual(
+  net.isIPv6({
+    toString: () => '::2001:252:1:255.255.255.255'
+  }),
+  true
+);
 assert.strictEqual(net.isIPv6({ toString: () => '127.0.0.1' }), false);
 assert.strictEqual(net.isIPv6({ toString: () => 'bla' }), false);
diff --git a/test/parallel/test-net-keepalive.js b/test/parallel/test-net-keepalive.js
index 49331abf040a30..f2a06a9d17d7ac 100644
--- a/test/parallel/test-net-keepalive.js
+++ b/test/parallel/test-net-keepalive.js
@@ -28,14 +28,17 @@ let serverConnection;
 let clientConnection;
 const echoServer = net.createServer(function(connection) {
   serverConnection = connection;
-  setTimeout(common.mustCall(function() {
-    // make sure both connections are still open
-    assert.strictEqual(serverConnection.readyState, 'open');
-    assert.strictEqual(clientConnection.readyState, 'open');
-    serverConnection.end();
-    clientConnection.end();
-    echoServer.close();
-  }, 1), common.platformTimeout(100));
+  setTimeout(
+    common.mustCall(function() {
+      // make sure both connections are still open
+      assert.strictEqual(serverConnection.readyState, 'open');
+      assert.strictEqual(clientConnection.readyState, 'open');
+      serverConnection.end();
+      clientConnection.end();
+      echoServer.close();
+    }, 1),
+    common.platformTimeout(100)
+  );
   connection.setTimeout(0);
   assert.notStrictEqual(connection.setKeepAlive, undefined);
   // send a keepalive packet after 50 ms
diff --git a/test/parallel/test-net-large-string.js b/test/parallel/test-net-large-string.js
index 93c0d41612a115..1082f60b39a0fa 100644
--- a/test/parallel/test-net-large-string.js
+++ b/test/parallel/test-net-large-string.js
@@ -28,18 +28,23 @@ const kPoolSize = 40 * 1024;
 const data = 'あ'.repeat(kPoolSize);
 const encoding = 'UTF-8';
 
-const server = net.createServer(common.mustCall(function(socket) {
-  let receivedSize = 0;
+const server = net.createServer(
+  common.mustCall(function(socket) {
+    let receivedSize = 0;
 
-  socket.setEncoding(encoding);
-  socket.on('data', function(data) {
-    receivedSize += data.length;
-  });
-  socket.on('end', common.mustCall(function() {
-    assert.strictEqual(receivedSize, kPoolSize);
-    socket.end();
-  }));
-}));
+    socket.setEncoding(encoding);
+    socket.on('data', function(data) {
+      receivedSize += data.length;
+    });
+    socket.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(receivedSize, kPoolSize);
+        socket.end();
+      })
+    );
+  })
+);
 
 server.listen(0, function() {
   const client = net.createConnection(this.address().port);
diff --git a/test/parallel/test-net-listen-after-destroying-stdin.js b/test/parallel/test-net-listen-after-destroying-stdin.js
index 5a4c8f4f65c55f..bda21b7eb6569d 100644
--- a/test/parallel/test-net-listen-after-destroying-stdin.js
+++ b/test/parallel/test-net-listen-after-destroying-stdin.js
@@ -8,12 +8,13 @@ const net = require('net');
 
 process.stdin.destroy();
 
-const server = net.createServer(common.mustCall(function(socket) {
-  console.log('accepted');
-  socket.end();
-  server.close();
-}));
-
+const server = net.createServer(
+  common.mustCall(function(socket) {
+    console.log('accepted');
+    socket.end();
+    server.close();
+  })
+);
 
 server.listen(0, function() {
   console.log('listening...');
diff --git a/test/parallel/test-net-listen-close-server.js b/test/parallel/test-net-listen-close-server.js
index 99d7111ebabe55..2ff775bb757d3d 100644
--- a/test/parallel/test-net-listen-close-server.js
+++ b/test/parallel/test-net-listen-close-server.js
@@ -23,8 +23,7 @@
 const common = require('../common');
 const net = require('net');
 
-const server = net.createServer(function(socket) {
-});
+const server = net.createServer(function(socket) {});
 server.listen(0, common.mustNotCall());
 server.on('error', common.mustNotCall());
 server.close();
diff --git a/test/parallel/test-net-listen-error.js b/test/parallel/test-net-listen-error.js
index 05ca799d3e7351..83c5d56ff46be0 100644
--- a/test/parallel/test-net-listen-error.js
+++ b/test/parallel/test-net-listen-error.js
@@ -23,7 +23,6 @@
 const common = require('../common');
 const net = require('net');
 
-const server = net.createServer(function(socket) {
-});
+const server = net.createServer(function(socket) {});
 server.listen(1, '1.1.1.1', common.mustNotCall()); // EACCES or EADDRNOTAVAIL
 server.on('error', common.mustCall());
diff --git a/test/parallel/test-net-listen-exclusive-random-ports.js b/test/parallel/test-net-listen-exclusive-random-ports.js
index 681e1236cc919a..6ba3641f316751 100644
--- a/test/parallel/test-net-listen-exclusive-random-ports.js
+++ b/test/parallel/test-net-listen-exclusive-random-ports.js
@@ -9,13 +9,19 @@ if (cluster.isMaster) {
   const worker1 = cluster.fork();
 
   worker1.on('message', function(port1) {
-    assert.strictEqual(port1, port1 | 0,
-                       `first worker could not listen on port ${port1}`);
+    assert.strictEqual(
+      port1,
+      port1 | 0,
+      `first worker could not listen on port ${port1}`
+    );
     const worker2 = cluster.fork();
 
     worker2.on('message', function(port2) {
-      assert.strictEqual(port2, port2 | 0,
-                         `second worker could not listen on port ${port2}`);
+      assert.strictEqual(
+        port2,
+        port2 | 0,
+        `second worker could not listen on port ${port2}`
+      );
       assert.notStrictEqual(port1, port2, 'ports should not be equal');
       worker1.kill();
       worker2.kill();
@@ -28,10 +34,13 @@ if (cluster.isMaster) {
     process.send(err.code);
   });
 
-  server.listen({
-    port: 0,
-    exclusive: true
-  }, function() {
-    process.send(server.address().port);
-  });
+  server.listen(
+    {
+      port: 0,
+      exclusive: true
+    },
+    function() {
+      process.send(server.address().port);
+    }
+  );
 }
diff --git a/test/parallel/test-net-listen-fd0.js b/test/parallel/test-net-listen-fd0.js
index c9ba56b5aef035..37d355b5721114 100644
--- a/test/parallel/test-net-listen-fd0.js
+++ b/test/parallel/test-net-listen-fd0.js
@@ -25,9 +25,13 @@ const assert = require('assert');
 const net = require('net');
 
 // This should fail with an async EINVAL error, not throw an exception
-net.createServer(common.mustNotCall())
+net
+  .createServer(common.mustNotCall())
   .listen({ fd: 0 })
-  .on('error', common.mustCall(function(e) {
-    assert(e instanceof Error);
-    assert(['EINVAL', 'ENOTSOCK'].includes(e.code));
-  }));
+  .on(
+    'error',
+    common.mustCall(function(e) {
+      assert(e instanceof Error);
+      assert(['EINVAL', 'ENOTSOCK'].includes(e.code));
+    })
+  );
diff --git a/test/parallel/test-net-listen-invalid-port.js b/test/parallel/test-net-listen-invalid-port.js
index d07bc9fafa8f56..074e0702d3fa37 100644
--- a/test/parallel/test-net-listen-invalid-port.js
+++ b/test/parallel/test-net-listen-invalid-port.js
@@ -19,25 +19,34 @@ net.Server().listen(0, function() {
 });
 
 // The first argument is a configuration object
-common.expectsError(() => {
-  net.Server().listen({ port: invalidPort }, common.mustNotCall());
-}, {
-  code: 'ERR_SOCKET_BAD_PORT',
-  type: RangeError
-});
+common.expectsError(
+  () => {
+    net.Server().listen({ port: invalidPort }, common.mustNotCall());
+  },
+  {
+    code: 'ERR_SOCKET_BAD_PORT',
+    type: RangeError
+  }
+);
 
 // The first argument is the port, no IP given.
-common.expectsError(() => {
-  net.Server().listen(invalidPort, common.mustNotCall());
-}, {
-  code: 'ERR_SOCKET_BAD_PORT',
-  type: RangeError
-});
+common.expectsError(
+  () => {
+    net.Server().listen(invalidPort, common.mustNotCall());
+  },
+  {
+    code: 'ERR_SOCKET_BAD_PORT',
+    type: RangeError
+  }
+);
 
 // The first argument is the port, the second an IP.
-common.expectsError(() => {
-  net.Server().listen(invalidPort, '0.0.0.0', common.mustNotCall());
-}, {
-  code: 'ERR_SOCKET_BAD_PORT',
-  type: RangeError
-});
+common.expectsError(
+  () => {
+    net.Server().listen(invalidPort, '0.0.0.0', common.mustNotCall());
+  },
+  {
+    code: 'ERR_SOCKET_BAD_PORT',
+    type: RangeError
+  }
+);
diff --git a/test/parallel/test-net-listening.js b/test/parallel/test-net-listening.js
index 8f2880b0bfedc2..e766596285c643 100644
--- a/test/parallel/test-net-listening.js
+++ b/test/parallel/test-net-listening.js
@@ -7,10 +7,15 @@ const server = net.createServer();
 
 assert.strictEqual(server.listening, false);
 
-server.listen(0, common.mustCall(() => {
-  assert.strictEqual(server.listening, true);
+server.listen(
+  0,
+  common.mustCall(() => {
+    assert.strictEqual(server.listening, true);
 
-  server.close(common.mustCall(() => {
-    assert.strictEqual(server.listening, false);
-  }));
-}));
+    server.close(
+      common.mustCall(() => {
+        assert.strictEqual(server.listening, false);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-local-address-port.js b/test/parallel/test-net-local-address-port.js
index dfd7ef359b71d2..95adf8446e7b52 100644
--- a/test/parallel/test-net-local-address-port.js
+++ b/test/parallel/test-net-local-address-port.js
@@ -24,18 +24,22 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-const server = net.createServer(common.mustCall(function(socket) {
-  assert.strictEqual(socket.localAddress, common.localhostIPv4);
-  assert.strictEqual(socket.localPort, this.address().port);
-  socket.on('end', function() {
-    server.close();
-  });
-  socket.resume();
-}));
+const server = net.createServer(
+  common.mustCall(function(socket) {
+    assert.strictEqual(socket.localAddress, common.localhostIPv4);
+    assert.strictEqual(socket.localPort, this.address().port);
+    socket.on('end', function() {
+      server.close();
+    });
+    socket.resume();
+  })
+);
 
 server.listen(0, common.localhostIPv4, function() {
-  const client = net.createConnection(this.address()
-                    .port, common.localhostIPv4);
+  const client = net.createConnection(
+    this.address().port,
+    common.localhostIPv4
+  );
   client.on('connect', function() {
     client.end();
   });
diff --git a/test/parallel/test-net-localerror.js b/test/parallel/test-net-localerror.js
index 91a7b38c3ef661..824be212677226 100644
--- a/test/parallel/test-net-localerror.js
+++ b/test/parallel/test-net-localerror.js
@@ -24,20 +24,25 @@ const common = require('../common');
 const net = require('net');
 
 const connect = (opts, code, type) => {
-  common.expectsError(
-    () => net.connect(opts),
-    { code, type }
-  );
+  common.expectsError(() => net.connect(opts), { code, type });
 };
 
-connect({
-  host: 'localhost',
-  port: 0,
-  localAddress: 'foobar',
-}, 'ERR_INVALID_IP_ADDRESS', TypeError);
+connect(
+  {
+    host: 'localhost',
+    port: 0,
+    localAddress: 'foobar'
+  },
+  'ERR_INVALID_IP_ADDRESS',
+  TypeError
+);
 
-connect({
-  host: 'localhost',
-  port: 0,
-  localPort: 'foobar',
-}, 'ERR_INVALID_ARG_TYPE', TypeError);
+connect(
+  {
+    host: 'localhost',
+    port: 0,
+    localPort: 'foobar'
+  },
+  'ERR_INVALID_ARG_TYPE',
+  TypeError
+);
diff --git a/test/parallel/test-net-normalize-args.js b/test/parallel/test-net-normalize-args.js
index 4677b396e25890..27a9569240958f 100644
--- a/test/parallel/test-net-normalize-args.js
+++ b/test/parallel/test-net-normalize-args.js
@@ -25,34 +25,43 @@ validateNormalizedArgs([{ port: 1234 }, assert.fail], res);
 {
   const server = net.createServer(common.mustNotCall('should not connect'));
 
-  server.listen(common.mustCall(() => {
-    const possibleErrors = ['ECONNREFUSED', 'EADDRNOTAVAIL'];
-    const port = server.address().port;
-    const socket = new net.Socket();
-
-    socket.on('error', common.mustCall((err) => {
-      assert(possibleErrors.includes(err.code));
-      assert(possibleErrors.includes(err.errno));
-      assert.strictEqual(err.syscall, 'connect');
-      server.close();
-    }));
+  server.listen(
+    common.mustCall(() => {
+      const possibleErrors = ['ECONNREFUSED', 'EADDRNOTAVAIL'];
+      const port = server.address().port;
+      const socket = new net.Socket();
+
+      socket.on(
+        'error',
+        common.mustCall((err) => {
+          assert(possibleErrors.includes(err.code));
+          assert(possibleErrors.includes(err.errno));
+          assert.strictEqual(err.syscall, 'connect');
+          server.close();
+        })
+      );
 
-    socket.connect([{ port }, assert.fail]);
-  }));
+      socket.connect([{ port }, assert.fail]);
+    })
+  );
 }
 
 // Connecting to the server should succeed with a normalized array.
 {
-  const server = net.createServer(common.mustCall((connection) => {
-    connection.end();
-    server.close();
-  }));
-
-  server.listen(common.mustCall(() => {
-    const port = server.address().port;
-    const socket = new net.Socket();
-    const args = net._normalizeArgs([{ port }, common.mustCall()]);
-
-    socket.connect(args);
-  }));
+  const server = net.createServer(
+    common.mustCall((connection) => {
+      connection.end();
+      server.close();
+    })
+  );
+
+  server.listen(
+    common.mustCall(() => {
+      const port = server.address().port;
+      const socket = new net.Socket();
+      const args = net._normalizeArgs([{ port }, common.mustCall()]);
+
+      socket.connect(args);
+    })
+  );
 }
diff --git a/test/parallel/test-net-options-lookup.js b/test/parallel/test-net-options-lookup.js
index 007be66f4516bb..9121b3f299de55 100644
--- a/test/parallel/test-net-options-lookup.js
+++ b/test/parallel/test-net-options-lookup.js
@@ -12,12 +12,15 @@ function connectThrows(input) {
     lookup: input
   };
 
-  common.expectsError(() => {
-    net.connect(opts);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError
-  });
+  common.expectsError(
+    () => {
+      net.connect(opts);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError
+    }
+  );
 }
 
 connectDoesNotThrow(() => {});
diff --git a/test/parallel/test-net-pause-resume-connecting.js b/test/parallel/test-net-pause-resume-connecting.js
index 920522b7604556..f17a079511b581 100644
--- a/test/parallel/test-net-pause-resume-connecting.js
+++ b/test/parallel/test-net-pause-resume-connecting.js
@@ -28,14 +28,12 @@ let connections = 0;
 let dataEvents = 0;
 let conn;
 
-
 // Server
 const server = net.createServer(function(conn) {
   connections++;
   conn.end('This was the year he fell to pieces.');
 
-  if (connections === 5)
-    server.close();
+  if (connections === 5) server.close();
 });
 
 server.listen(0, function() {
@@ -44,21 +42,18 @@ server.listen(0, function() {
   conn.resume();
   conn.on('data', onDataOk);
 
-
   // Client 2
   conn = net.createConnection(this.address().port, 'localhost');
   conn.pause();
   conn.resume();
   conn.on('data', onDataOk);
 
-
   // Client 3
   conn = net.createConnection(this.address().port, 'localhost');
   conn.pause();
   conn.on('data', common.mustNotCall());
   scheduleTearDown(conn);
 
-
   // Client 4
   conn = net.createConnection(this.address().port, 'localhost');
   conn.resume();
@@ -66,7 +61,6 @@ server.listen(0, function() {
   conn.resume();
   conn.on('data', onDataOk);
 
-
   // Client 5
   conn = net.createConnection(this.address().port, 'localhost');
   conn.resume();
@@ -87,7 +81,6 @@ server.listen(0, function() {
   }
 });
 
-
 // Exit sanity checks
 process.on('exit', function() {
   assert.strictEqual(connections, 5);
diff --git a/test/parallel/test-net-pingpong.js b/test/parallel/test-net-pingpong.js
index 4ab36fc23957b5..6c9e80820cf01c 100644
--- a/test/parallel/test-net-pingpong.js
+++ b/test/parallel/test-net-pingpong.js
@@ -39,92 +39,117 @@ function pingPongTest(port, host) {
     assert.strictEqual(socket.server, server);
     assert.strictEqual(
       server,
-      server.getConnections(common.mustCall(function(err, connections) {
-        assert.ifError(err);
-        assert.strictEqual(connections, 1);
-      }))
+      server.getConnections(
+        common.mustCall(function(err, connections) {
+          assert.ifError(err);
+          assert.strictEqual(connections, 1);
+        })
+      )
     );
 
     socket.setNoDelay();
     socket.timeout = 0;
 
     socket.setEncoding('utf8');
-    socket.on('data', common.mustCall(function(data) {
-      // Since we never queue data (we're always waiting for the PING
-      // before sending a pong) the writeQueueSize should always be less
-      // than one message.
-      assert.ok(socket.bufferSize >= 0 && socket.bufferSize <= 4);
-
-      assert.strictEqual(socket.writable, true);
-      assert.strictEqual(socket.readable, true);
-      assert.ok(count <= N);
-      assert.strictEqual(data, 'PING');
-
-      socket.write('PONG', common.mustCall(function() {
-        sentPongs++;
-      }));
-    }, N + 1));
-
-    socket.on('end', common.mustCall(function() {
-      assert.strictEqual(socket.allowHalfOpen, true);
-      assert.strictEqual(socket.writable, true); // because allowHalfOpen
-      assert.strictEqual(socket.readable, false);
-      socket.end();
-    }));
+    socket.on(
+      'data',
+      common.mustCall(function(data) {
+        // Since we never queue data (we're always waiting for the PING
+        // before sending a pong) the writeQueueSize should always be less
+        // than one message.
+        assert.ok(socket.bufferSize >= 0 && socket.bufferSize <= 4);
+
+        assert.strictEqual(socket.writable, true);
+        assert.strictEqual(socket.readable, true);
+        assert.ok(count <= N);
+        assert.strictEqual(data, 'PING');
+
+        socket.write(
+          'PONG',
+          common.mustCall(function() {
+            sentPongs++;
+          })
+        );
+      }, N + 1)
+    );
+
+    socket.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(socket.allowHalfOpen, true);
+        assert.strictEqual(socket.writable, true); // because allowHalfOpen
+        assert.strictEqual(socket.readable, false);
+        socket.end();
+      })
+    );
 
     socket.on('error', common.mustNotCall());
 
-    socket.on('close', common.mustCall(function() {
-      assert.strictEqual(socket.writable, false);
-      assert.strictEqual(socket.readable, false);
-      socket.server.close();
-    }));
+    socket.on(
+      'close',
+      common.mustCall(function() {
+        assert.strictEqual(socket.writable, false);
+        assert.strictEqual(socket.readable, false);
+        socket.server.close();
+      })
+    );
   }
 
-
-  server.listen(port, host, common.mustCall(function() {
-    if (this.address().port)
-      port = this.address().port;
-
-    const client = net.createConnection(port, host);
-
-    client.setEncoding('ascii');
-    client.on('connect', common.mustCall(function() {
-      assert.strictEqual(client.readable, true);
-      assert.strictEqual(client.writable, true);
-      client.write('PING');
-    }));
-
-    client.on('data', common.mustCall(function(data) {
-      assert.strictEqual(data, 'PONG');
-      count += 1;
-
-      if (sent_final_ping) {
-        assert.strictEqual(client.writable, false);
-        assert.strictEqual(client.readable, true);
-        return;
-      } else {
-        assert.strictEqual(client.writable, true);
-        assert.strictEqual(client.readable, true);
-      }
-
-      if (count < N) {
-        client.write('PING');
-      } else {
-        sent_final_ping = true;
-        client.write('PING');
-        client.end();
-      }
-    }, N + 1));
-
-    client.on('close', common.mustCall(function() {
-      assert.strictEqual(count, N + 1);
-      assert.strictEqual(sentPongs, N + 1);
-      assert.strictEqual(sent_final_ping, true);
-    }));
-
-    client.on('error', common.mustNotCall());
-  }));
+  server.listen(
+    port,
+    host,
+    common.mustCall(function() {
+      if (this.address().port) port = this.address().port;
+
+      const client = net.createConnection(port, host);
+
+      client.setEncoding('ascii');
+      client.on(
+        'connect',
+        common.mustCall(function() {
+          assert.strictEqual(client.readable, true);
+          assert.strictEqual(client.writable, true);
+          client.write('PING');
+        })
+      );
+
+      client.on(
+        'data',
+        common.mustCall(function(data) {
+          assert.strictEqual(data, 'PONG');
+          count += 1;
+
+          if (sent_final_ping) {
+            assert.strictEqual(client.writable, false);
+            assert.strictEqual(client.readable, true);
+            return;
+          } else {
+            assert.strictEqual(client.writable, true);
+            assert.strictEqual(client.readable, true);
+          }
+
+          if (count < N) {
+            client.write('PING');
+          } else {
+            sent_final_ping = true;
+            client.write('PING');
+            client.end();
+          }
+        }, N + 1)
+      );
+
+      client.on(
+        'close',
+        common.mustCall(function() {
+          assert.strictEqual(count, N + 1);
+          assert.strictEqual(sentPongs, N + 1);
+          assert.strictEqual(sent_final_ping, true);
+        })
+      );
+
+      client.on('error', common.mustNotCall());
+    })
+  );
 }
 
 /* All are run at once, so run on different ports */
@@ -133,5 +158,4 @@ tmpdir.refresh();
 pingPongTest(common.PIPE);
 pingPongTest(0);
 pingPongTest(0, 'localhost');
-if (common.hasIPv6)
-  pingPongTest(0, '::1');
+if (common.hasIPv6) pingPongTest(0, '::1');
diff --git a/test/parallel/test-net-pipe-connect-errors.js b/test/parallel/test-net-pipe-connect-errors.js
index 8db452669991f0..be91eeccc9dc94 100644
--- a/test/parallel/test-net-pipe-connect-errors.js
+++ b/test/parallel/test-net-pipe-connect-errors.js
@@ -60,37 +60,50 @@ const notSocketClient = net.createConnection(emptyTxt, function() {
   assert.fail('connection callback should not run');
 });
 
-notSocketClient.on('error', common.mustCall(function(err) {
-  assert(err.code === 'ENOTSOCK' || err.code === 'ECONNREFUSED',
-         `received ${err.code} instead of ENOTSOCK or ECONNREFUSED`);
-}));
-
+notSocketClient.on(
+  'error',
+  common.mustCall(function(err) {
+    assert(
+      err.code === 'ENOTSOCK' || err.code === 'ECONNREFUSED',
+      `received ${err.code} instead of ENOTSOCK or ECONNREFUSED`
+    );
+  })
+);
 
 // Trying to connect to not-existing socket should result in ENOENT error
 const noEntSocketClient = net.createConnection('no-ent-file', function() {
   assert.fail('connection to non-existent socket, callback should not run');
 });
 
-noEntSocketClient.on('error', common.mustCall(function(err) {
-  assert.strictEqual(err.code, 'ENOENT');
-}));
-
+noEntSocketClient.on(
+  'error',
+  common.mustCall(function(err) {
+    assert.strictEqual(err.code, 'ENOENT');
+  })
+);
 
 // On Windows or when running as root, a chmod has no effect on named pipes
 if (!common.isWindows && process.getuid() !== 0) {
   // Trying to connect to a socket one has no access to should result in EACCES
   const accessServer = net.createServer(
-    common.mustNotCall('server callback should not run'));
-  accessServer.listen(common.PIPE, common.mustCall(function() {
-    fs.chmodSync(common.PIPE, 0);
+    common.mustNotCall('server callback should not run')
+  );
+  accessServer.listen(
+    common.PIPE,
+    common.mustCall(function() {
+      fs.chmodSync(common.PIPE, 0);
 
-    const accessClient = net.createConnection(common.PIPE, function() {
-      assert.fail('connection should get EACCES, callback should not run');
-    });
+      const accessClient = net.createConnection(common.PIPE, function() {
+        assert.fail('connection should get EACCES, callback should not run');
+      });
 
-    accessClient.on('error', common.mustCall(function(err) {
-      assert.strictEqual(err.code, 'EACCES');
-      accessServer.close();
-    }));
-  }));
+      accessClient.on(
+        'error',
+        common.mustCall(function(err) {
+          assert.strictEqual(err.code, 'EACCES');
+          accessServer.close();
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-net-reconnect.js b/test/parallel/test-net-reconnect.js
index eb6b0728478a91..1a0bff726d25df 100644
--- a/test/parallel/test-net-reconnect.js
+++ b/test/parallel/test-net-reconnect.js
@@ -74,10 +74,9 @@ server.listen(0, function() {
   client.on('close', function(had_error) {
     console.log('CLIENT disconnect');
     assert.strictEqual(had_error, false);
-    if (disconnect_count++ < N)
-      client.connect(server.address().port); // reconnect
-    else
-      server.close();
+    if (disconnect_count++ < N) client.connect(server.address().port);
+    // reconnect
+    else server.close();
   });
 });
 
diff --git a/test/parallel/test-net-remote-address-port.js b/test/parallel/test-net-remote-address-port.js
index 094206f85df34d..fc7f3d44c20db9 100644
--- a/test/parallel/test-net-remote-address-port.js
+++ b/test/parallel/test-net-remote-address-port.js
@@ -27,26 +27,28 @@ const net = require('net');
 
 let conns_closed = 0;
 
-const remoteAddrCandidates = [ common.localhostIPv4 ];
+const remoteAddrCandidates = [common.localhostIPv4];
 if (common.hasIPv6) remoteAddrCandidates.push('::ffff:127.0.0.1');
 
 const remoteFamilyCandidates = ['IPv4'];
 if (common.hasIPv6) remoteFamilyCandidates.push('IPv6');
 
-const server = net.createServer(common.mustCall(function(socket) {
-  assert.ok(remoteAddrCandidates.includes(socket.remoteAddress));
-  assert.ok(remoteFamilyCandidates.includes(socket.remoteFamily));
-  assert.ok(socket.remotePort);
-  assert.notStrictEqual(socket.remotePort, this.address().port);
-  socket.on('end', function() {
-    if (++conns_closed === 2) server.close();
-  });
-  socket.on('close', function() {
+const server = net.createServer(
+  common.mustCall(function(socket) {
     assert.ok(remoteAddrCandidates.includes(socket.remoteAddress));
     assert.ok(remoteFamilyCandidates.includes(socket.remoteFamily));
-  });
-  socket.resume();
-}, 2));
+    assert.ok(socket.remotePort);
+    assert.notStrictEqual(socket.remotePort, this.address().port);
+    socket.on('end', function() {
+      if (++conns_closed === 2) server.close();
+    });
+    socket.on('close', function() {
+      assert.ok(remoteAddrCandidates.includes(socket.remoteAddress));
+      assert.ok(remoteFamilyCandidates.includes(socket.remoteFamily));
+    });
+    socket.resume();
+  }, 2)
+);
 
 server.listen(0, 'localhost', function() {
   const client = net.createConnection(this.address().port, 'localhost');
diff --git a/test/parallel/test-net-server-call-listen-multiple-times.js b/test/parallel/test-net-server-call-listen-multiple-times.js
index 4b1a8d07334ac2..7733e1c987df50 100644
--- a/test/parallel/test-net-server-call-listen-multiple-times.js
+++ b/test/parallel/test-net-server-call-listen-multiple-times.js
@@ -9,17 +9,24 @@ const net = require('net');
   const server = net.Server();
 
   // Run some server in order to simulate EADDRINUSE error.
-  dummyServer.listen(common.mustCall(() => {
-    // Try to listen used port.
-    server.listen(dummyServer.address().port);
-  }));
-
-  server.on('error', common.mustCall((e) => {
-    server.listen(common.mustCall(() => {
-      dummyServer.close();
-      server.close();
-    }));
-  }));
+  dummyServer.listen(
+    common.mustCall(() => {
+      // Try to listen used port.
+      server.listen(dummyServer.address().port);
+    })
+  );
+
+  server.on(
+    'error',
+    common.mustCall((e) => {
+      server.listen(
+        common.mustCall(() => {
+          dummyServer.close();
+          server.close();
+        })
+      );
+    })
+  );
 }
 
 // Second test. Check that second listen call throws an error.
@@ -39,8 +46,10 @@ const net = require('net');
 {
   const server = net.Server();
 
-  server.listen(common.mustCall(() => {
-    server.close();
-    server.listen(common.mustCall(() => server.close()));
-  }));
+  server.listen(
+    common.mustCall(() => {
+      server.close();
+      server.listen(common.mustCall(() => server.close()));
+    })
+  );
 }
diff --git a/test/parallel/test-net-server-close.js b/test/parallel/test-net-server-close.js
index 89bfddd38a70d2..a372549cafb9f5 100644
--- a/test/parallel/test-net-server-close.js
+++ b/test/parallel/test-net-server-close.js
@@ -45,7 +45,9 @@ const server = net.createServer(function(c) {
 
   if (sockets.length === 2) {
     assert.strictEqual(server.close(), server);
-    sockets.forEach(function(c) { c.destroy(); });
+    sockets.forEach(function(c) {
+      c.destroy();
+    });
   }
 });
 
@@ -53,7 +55,10 @@ server.on('close', function() {
   events.push('server');
 });
 
-assert.strictEqual(server, server.listen(0, function() {
-  net.createConnection(this.address().port);
-  net.createConnection(this.address().port);
-}));
+assert.strictEqual(
+  server,
+  server.listen(0, function() {
+    net.createConnection(this.address().port);
+    net.createConnection(this.address().port);
+  })
+);
diff --git a/test/parallel/test-net-server-connections-child-null.js b/test/parallel/test-net-server-connections-child-null.js
index 46084404c87661..c1d4edeeccf656 100644
--- a/test/parallel/test-net-server-connections-child-null.js
+++ b/test/parallel/test-net-server-connections-child-null.js
@@ -5,19 +5,15 @@ const fork = require('child_process').fork;
 const net = require('net');
 
 if (process.argv[2] === 'child') {
-
   process.on('message', (msg, socket) => {
     socket.end('goodbye');
   });
 
   process.send('hello');
-
 } else {
-
   const child = fork(process.argv[1], ['child']);
 
   const runTest = common.mustCall(() => {
-
     const server = net.createServer();
 
     // server.connections should start as 0
@@ -29,17 +25,23 @@ if (process.argv[2] === 'child') {
       child.kill();
     });
 
-    server.listen(0, common.mustCall(() => {
-      const connect = net.connect(server.address().port);
-
-      connect.on('close', common.mustCall(() => {
-        // now server.connections should be null
-        assert.strictEqual(server.connections, null);
-        server.close();
-      }));
-
-      connect.resume();
-    }));
+    server.listen(
+      0,
+      common.mustCall(() => {
+        const connect = net.connect(server.address().port);
+
+        connect.on(
+          'close',
+          common.mustCall(() => {
+            // now server.connections should be null
+            assert.strictEqual(server.connections, null);
+            server.close();
+          })
+        );
+
+        connect.resume();
+      })
+    );
   });
 
   child.on('message', runTest);
diff --git a/test/parallel/test-net-server-connections.js b/test/parallel/test-net-server-connections.js
index 9e1213ada558c3..561948af1803ea 100644
--- a/test/parallel/test-net-server-connections.js
+++ b/test/parallel/test-net-server-connections.js
@@ -27,8 +27,9 @@ const net = require('net');
 
 const server = new net.Server();
 
-const expectedWarning = 'Server.connections property is deprecated. ' +
-                        'Use Server.getConnections method instead.';
+const expectedWarning =
+  'Server.connections property is deprecated. ' +
+  'Use Server.getConnections method instead.';
 
 common.expectWarning('DeprecationWarning', expectedWarning, 'DEP0020');
 
diff --git a/test/parallel/test-net-server-listen-handle.js b/test/parallel/test-net-server-listen-handle.js
index 0d59bd76cad8a8..eee2e34040fb45 100644
--- a/test/parallel/test-net-server-listen-handle.js
+++ b/test/parallel/test-net-server-listen-handle.js
@@ -53,10 +53,14 @@ function randomHandle(type) {
     assert.fail(`unable to bind ${handleName}: ${getSystemErrorName(errno)}`);
   }
 
-  if (!common.isWindows) {  // fd doesn't work on windows
+  if (!common.isWindows) {
+    // fd doesn't work on windows
     // err >= 0 but fd = -1, should not happen
-    assert.notStrictEqual(handle.fd, -1,
-                          `Bound ${handleName} has fd -1 and errno ${errno}`);
+    assert.notStrictEqual(
+      handle.fd,
+      -1,
+      `Bound ${handleName} has fd -1 and errno ${errno}`
+    );
   }
   return handle;
 }
@@ -64,12 +68,12 @@ function randomHandle(type) {
 // Not a public API, used by child_process
 {
   // Test listen(tcp)
-  net.createServer()
+  net
+    .createServer()
     .listen(randomHandle('tcp'))
     .on('listening', closeServer());
   // Test listen(tcp, cb)
-  net.createServer()
-    .listen(randomHandle('tcp'), closeServer());
+  net.createServer().listen(randomHandle('tcp'), closeServer());
 }
 
 function randomPipes(number) {
@@ -81,76 +85,91 @@ function randomPipes(number) {
 }
 
 // Not a public API, used by child_process
-if (!common.isWindows) {  // Windows doesn't support {fd: <n>}
-  const handles = randomPipes(2);  // generate pipes in advance
+if (!common.isWindows) {
+  // Windows doesn't support {fd: <n>}
+  const handles = randomPipes(2); // generate pipes in advance
   // Test listen(pipe)
-  net.createServer()
+  net
+    .createServer()
     .listen(handles[0])
     .on('listening', closePipeServer(handles[0]));
   // Test listen(pipe, cb)
-  net.createServer()
-    .listen(handles[1], closePipeServer(handles[1]));
+  net.createServer().listen(handles[1], closePipeServer(handles[1]));
 }
 
 {
   // Test listen({handle: tcp}, cb)
-  net.createServer()
-    .listen({ handle: randomHandle('tcp') }, closeServer());
+  net.createServer().listen({ handle: randomHandle('tcp') }, closeServer());
   // Test listen({handle: tcp})
-  net.createServer()
+  net
+    .createServer()
     .listen({ handle: randomHandle('tcp') })
     .on('listening', closeServer());
   // Test listen({_handle: tcp}, cb)
-  net.createServer()
-    .listen({ _handle: randomHandle('tcp') }, closeServer());
+  net.createServer().listen({ _handle: randomHandle('tcp') }, closeServer());
   // Test listen({_handle: tcp})
-  net.createServer()
+  net
+    .createServer()
     .listen({ _handle: randomHandle('tcp') })
     .on('listening', closeServer());
 }
 
-if (!common.isWindows) {  // Windows doesn't support {fd: <n>}
+if (!common.isWindows) {
+  // Windows doesn't support {fd: <n>}
   // Test listen({fd: tcp.fd}, cb)
-  net.createServer()
-    .listen({ fd: randomHandle('tcp').fd }, closeServer());
+  net.createServer().listen({ fd: randomHandle('tcp').fd }, closeServer());
   // Test listen({fd: tcp.fd})
-  net.createServer()
+  net
+    .createServer()
     .listen({ fd: randomHandle('tcp').fd })
     .on('listening', closeServer());
 }
 
-if (!common.isWindows) {  // Windows doesn't support {fd: <n>}
-  const handles = randomPipes(6);  // generate pipes in advance
+if (!common.isWindows) {
+  // Windows doesn't support {fd: <n>}
+  const handles = randomPipes(6); // generate pipes in advance
   // Test listen({handle: pipe}, cb)
-  net.createServer()
+  net
+    .createServer()
     .listen({ handle: handles[0] }, closePipeServer(handles[0]));
   // Test listen({handle: pipe})
-  net.createServer()
+  net
+    .createServer()
     .listen({ handle: handles[1] })
     .on('listening', closePipeServer(handles[1]));
   // Test listen({_handle: pipe}, cb)
-  net.createServer()
+  net
+    .createServer()
     .listen({ _handle: handles[2] }, closePipeServer(handles[2]));
   // Test listen({_handle: pipe})
-  net.createServer()
+  net
+    .createServer()
     .listen({ _handle: handles[3] })
     .on('listening', closePipeServer(handles[3]));
   // Test listen({fd: pipe.fd}, cb)
-  net.createServer()
-    .listen({ fd: handles[4].fd }, closePipeServer(handles[4]));
+  net.createServer().listen({ fd: handles[4].fd }, closePipeServer(handles[4]));
   // Test listen({fd: pipe.fd})
-  net.createServer()
+  net
+    .createServer()
     .listen({ fd: handles[5].fd })
     .on('listening', closePipeServer(handles[5]));
 }
 
-if (!common.isWindows) {  // Windows doesn't support {fd: <n>}
+if (!common.isWindows) {
+  // Windows doesn't support {fd: <n>}
   // Test invalid fd
   const fd = fs.openSync(__filename, 'r');
-  net.createServer()
+  net
+    .createServer()
     .listen({ fd }, common.mustNotCall())
-    .on('error', common.mustCall(function(err) {
-      assert.strictEqual(String(err), 'Error: listen EINVAL: invalid argument');
-      this.close();
-    }));
+    .on(
+      'error',
+      common.mustCall(function(err) {
+        assert.strictEqual(
+          String(err),
+          'Error: listen EINVAL: invalid argument'
+        );
+        this.close();
+      })
+    );
 }
diff --git a/test/parallel/test-net-server-listen-options.js b/test/parallel/test-net-server-listen-options.js
index 6c783c95dcaebd..813837dd9f8712 100644
--- a/test/parallel/test-net-server-listen-options.js
+++ b/test/parallel/test-net-server-listen-options.js
@@ -3,17 +3,27 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-function close() { this.close(); }
+function close() {
+  this.close();
+}
 
 {
   // Test listen()
-  net.createServer().listen().on('listening', common.mustCall(close));
+  net
+    .createServer()
+    .listen()
+    .on('listening', common.mustCall(close));
   // Test listen(cb)
   net.createServer().listen(common.mustCall(close));
   // Test listen(port)
-  net.createServer().listen(0).on('listening', common.mustCall(close));
+  net
+    .createServer()
+    .listen(0)
+    .on('listening', common.mustCall(close));
   // Test listen({port})
-  net.createServer().listen({ port: 0 })
+  net
+    .createServer()
+    .listen({ port: 0 })
     .on('listening', common.mustCall(close));
 }
 
@@ -47,8 +57,9 @@ const listenOnPort = [
   }
   // In listen(options, cb), port takes precedence over path
   assert.throws(() => {
-    net.createServer().listen({ port: -1, path: common.PIPE },
-                              common.mustNotCall());
+    net
+      .createServer()
+      .listen({ port: -1, path: common.PIPE }, common.mustNotCall());
   }, assertPort());
 }
 
@@ -58,21 +69,21 @@ const listenOnPort = [
       net.createServer().listen(options, common.mustNotCall());
     };
 
-    if (typeof options === 'object' &&
-      !(('port' in options) || ('path' in options))) {
-      common.expectsError(fn,
-                          {
-                            code: 'ERR_INVALID_ARG_VALUE',
-                            type: TypeError,
-                            message: /^The argument 'options' must have the property "port" or "path"\. Received .+$/,
-                          });
+    if (
+      typeof options === 'object' &&
+      !('port' in options || 'path' in options)
+    ) {
+      common.expectsError(fn, {
+        code: 'ERR_INVALID_ARG_VALUE',
+        type: TypeError,
+        message: /^The argument 'options' must have the property "port" or "path"\. Received .+$/
+      });
     } else {
-      common.expectsError(fn,
-                          {
-                            code: 'ERR_INVALID_OPT_VALUE',
-                            type: TypeError,
-                            message: /^The value "{.*}" is invalid for option "options"(?:\. .+)?$/,
-                          });
+      common.expectsError(fn, {
+        code: 'ERR_INVALID_OPT_VALUE',
+        type: TypeError,
+        message: /^The value "{.*}" is invalid for option "options"(?:\. .+)?$/
+      });
     }
   }
 
diff --git a/test/parallel/test-net-server-listen-path.js b/test/parallel/test-net-server-listen-path.js
index cc7c6678b04224..c23341e77e840f 100644
--- a/test/parallel/test-net-server-listen-path.js
+++ b/test/parallel/test-net-server-listen-path.js
@@ -24,7 +24,8 @@ function randomPipePath() {
 // Test listen(path)
 {
   const handlePath = randomPipePath();
-  net.createServer()
+  net
+    .createServer()
     .listen(handlePath)
     .on('listening', closeServer());
 }
@@ -32,7 +33,8 @@ function randomPipePath() {
 // Test listen({path})
 {
   const handlePath = randomPipePath();
-  net.createServer()
+  net
+    .createServer()
     .listen({ path: handlePath })
     .on('listening', closeServer());
 }
@@ -40,34 +42,34 @@ function randomPipePath() {
 // Test listen(path, cb)
 {
   const handlePath = randomPipePath();
-  net.createServer()
-    .listen(handlePath, closeServer());
+  net.createServer().listen(handlePath, closeServer());
 }
 
 // Test listen(path, cb)
 {
   const handlePath = randomPipePath();
-  net.createServer()
-    .listen({ path: handlePath }, closeServer());
+  net.createServer().listen({ path: handlePath }, closeServer());
 }
 
 // Test pipe chmod
 {
   const handlePath = randomPipePath();
 
-  const srv = net.createServer()
-    .listen({
+  const srv = net.createServer().listen(
+    {
       path: handlePath,
       readableAll: true,
       writableAll: true
-    }, common.mustCall(() => {
+    },
+    common.mustCall(() => {
       if (process.platform !== 'win32') {
         const mode = fs.statSync(handlePath).mode;
         assert.notStrictEqual(mode & fs.constants.S_IROTH, 0);
         assert.notStrictEqual(mode & fs.constants.S_IWOTH, 0);
       }
       srv.close();
-    }));
+    })
+  );
 }
 
 // Test should emit "error" events when listening fails.
@@ -76,16 +78,21 @@ function randomPipePath() {
   const srv1 = net.createServer().listen({ path: handlePath }, () => {
     // As the handlePath is in use, binding to the same address again should
     // make the server emit an 'EADDRINUSE' error.
-    const srv2 = net.createServer()
-      .listen({
+    const srv2 = net.createServer().listen(
+      {
         path: handlePath,
-        writableAll: true,
-      }, common.mustNotCall());
+        writableAll: true
+      },
+      common.mustNotCall()
+    );
 
-    srv2.on('error', common.mustCall((err) => {
-      srv1.close();
-      assert.strictEqual(err.code, 'EADDRINUSE');
-      assert(/^listen EADDRINUSE: address already in use/.test(err.message));
-    }));
+    srv2.on(
+      'error',
+      common.mustCall((err) => {
+        srv1.close();
+        assert.strictEqual(err.code, 'EADDRINUSE');
+        assert(/^listen EADDRINUSE: address already in use/.test(err.message));
+      })
+    );
   });
 }
diff --git a/test/parallel/test-net-server-max-connections.js b/test/parallel/test-net-server-max-connections.js
index 705c99b7b9737a..3fb53934e60865 100644
--- a/test/parallel/test-net-server-max-connections.js
+++ b/test/parallel/test-net-server-max-connections.js
@@ -33,10 +33,14 @@ const N = 20;
 let closes = 0;
 const waits = [];
 
-const server = net.createServer(common.mustCall(function(connection) {
-  connection.write('hello');
-  waits.push(function() { connection.end(); });
-}, N / 2));
+const server = net.createServer(
+  common.mustCall(function(connection) {
+    connection.write('hello');
+    waits.push(function() {
+      connection.end();
+    });
+  }, N / 2)
+);
 
 server.listen(0, function() {
   makeConnection(0);
@@ -44,7 +48,6 @@ server.listen(0, function() {
 
 server.maxConnections = N / 2;
 
-
 function makeConnection(index) {
   const c = net.createConnection(server.address().port);
   let gotData = false;
@@ -68,23 +71,31 @@ function makeConnection(index) {
       if (closes === N / 2) {
         let cb;
         console.error('calling wait callback.');
-        while (cb = waits.shift()) {
+        while ((cb = waits.shift())) {
           cb();
         }
         server.close();
       }
 
       if (index < server.maxConnections) {
-        assert.strictEqual(gotData, true,
-                           `${index} didn't get data, but should have`);
+        assert.strictEqual(
+          gotData,
+          true,
+          `${index} didn't get data, but should have`
+        );
       } else {
-        assert.strictEqual(gotData, false,
-                           `${index} got data, but shouldn't have`);
+        assert.strictEqual(
+          gotData,
+          false,
+          `${index} got data, but shouldn't have`
+        );
       }
     });
   });
 
-  c.on('end', function() { c.end(); });
+  c.on('end', function() {
+    c.end();
+  });
 
   c.on('data', function(b) {
     gotData = true;
@@ -94,14 +105,13 @@ function makeConnection(index) {
   c.on('error', function(e) {
     // Retry if SmartOS and ECONNREFUSED. See
     // https://github.com/nodejs/node/issues/2663.
-    if (common.isSunOS && (e.code === 'ECONNREFUSED')) {
+    if (common.isSunOS && e.code === 'ECONNREFUSED') {
       c.connect(server.address().port);
     }
     console.error(`error ${index}: ${e}`);
   });
 }
 
-
 process.on('exit', function() {
   assert.strictEqual(closes, N);
 });
diff --git a/test/parallel/test-net-server-options.js b/test/parallel/test-net-server-options.js
index 2275d9f859b409..e380a9ca6755e3 100644
--- a/test/parallel/test-net-server-options.js
+++ b/test/parallel/test-net-server-options.js
@@ -2,14 +2,22 @@
 const common = require('../common');
 const net = require('net');
 
-common.expectsError(function() { net.createServer('path'); },
-                    {
-                      code: 'ERR_INVALID_ARG_TYPE',
-                      type: TypeError
-                    });
+common.expectsError(
+  function() {
+    net.createServer('path');
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }
+);
 
-common.expectsError(function() { net.createServer(0); },
-                    {
-                      code: 'ERR_INVALID_ARG_TYPE',
-                      type: TypeError
-                    });
+common.expectsError(
+  function() {
+    net.createServer(0);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }
+);
diff --git a/test/parallel/test-net-server-pause-on-connect.js b/test/parallel/test-net-server-pause-on-connect.js
index 59c39e8816cc5c..be7d8e694009e5 100644
--- a/test/parallel/test-net-server-pause-on-connect.js
+++ b/test/parallel/test-net-server-pause-on-connect.js
@@ -27,7 +27,6 @@ const msg = 'test';
 let stopped = true;
 let server1Sock;
 
-
 const server1ConnHandler = (socket) => {
   socket.on('data', function(data) {
     if (stopped) {
diff --git a/test/parallel/test-net-server-simultaneous-accepts-produce-warning-once.js b/test/parallel/test-net-server-simultaneous-accepts-produce-warning-once.js
index ffca38f603b2a9..f5de01ccf95dc9 100644
--- a/test/parallel/test-net-server-simultaneous-accepts-produce-warning-once.js
+++ b/test/parallel/test-net-server-simultaneous-accepts-produce-warning-once.js
@@ -6,7 +6,8 @@ const net = require('net');
 expectWarning(
   'DeprecationWarning',
   'net._setSimultaneousAccepts() is deprecated and will be removed.',
-  'DEP0121');
+  'DEP0121'
+);
 
 net._setSimultaneousAccepts();
 net._setSimultaneousAccepts();
diff --git a/test/parallel/test-net-server-try-ports.js b/test/parallel/test-net-server-try-ports.js
index 12e8e91be16db6..58bdee3b8a2579 100644
--- a/test/parallel/test-net-server-try-ports.js
+++ b/test/parallel/test-net-server-try-ports.js
@@ -30,16 +30,25 @@ const server1 = net.Server();
 
 const server2 = net.Server();
 
-server2.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.code, 'EADDRINUSE');
+server2.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.code, 'EADDRINUSE');
 
-  server2.listen(0, common.mustCall(function() {
-    server1.close();
-    server2.close();
-  }));
-}));
+    server2.listen(
+      0,
+      common.mustCall(function() {
+        server1.close();
+        server2.close();
+      })
+    );
+  })
+);
 
-server1.listen(0, common.mustCall(function() {
-  // This should make server2 emit EADDRINUSE
-  server2.listen(this.address().port);
-}));
+server1.listen(
+  0,
+  common.mustCall(function() {
+    // This should make server2 emit EADDRINUSE
+    server2.listen(this.address().port);
+  })
+);
diff --git a/test/parallel/test-net-settimeout.js b/test/parallel/test-net-settimeout.js
index 581e27ec327d62..92d3e67c3299ca 100644
--- a/test/parallel/test-net-settimeout.js
+++ b/test/parallel/test-net-settimeout.js
@@ -29,9 +29,11 @@ const assert = require('assert');
 
 const T = 100;
 
-const server = net.createServer(common.mustCall((c) => {
-  c.write('hello');
-}));
+const server = net.createServer(
+  common.mustCall((c) => {
+    c.write('hello');
+  })
+);
 
 server.listen(0, function() {
   const socket = net.createConnection(this.address().port, 'localhost');
@@ -39,12 +41,15 @@ server.listen(0, function() {
   const s = socket.setTimeout(T, common.mustNotCall());
   assert.ok(s instanceof net.Socket);
 
-  socket.on('data', common.mustCall(() => {
-    setTimeout(function() {
-      socket.destroy();
-      server.close();
-    }, T * 2);
-  }));
+  socket.on(
+    'data',
+    common.mustCall(() => {
+      setTimeout(function() {
+        socket.destroy();
+        server.close();
+      }, T * 2);
+    })
+  );
 
   socket.setTimeout(0);
 });
diff --git a/test/parallel/test-net-socket-byteswritten.js b/test/parallel/test-net-socket-byteswritten.js
index b7b7af89e215db..27a9d99c407302 100644
--- a/test/parallel/test-net-socket-byteswritten.js
+++ b/test/parallel/test-net-socket-byteswritten.js
@@ -8,28 +8,37 @@ const server = net.createServer(function(socket) {
   socket.end();
 });
 
-server.listen(0, common.mustCall(function() {
-  const socket = net.connect(server.address().port);
+server.listen(
+  0,
+  common.mustCall(function() {
+    const socket = net.connect(server.address().port);
 
-  // Cork the socket, then write twice; this should cause a writev, which
-  // previously caused an err in the bytesWritten count.
-  socket.cork();
+    // Cork the socket, then write twice; this should cause a writev, which
+    // previously caused an err in the bytesWritten count.
+    socket.cork();
 
-  socket.write('one');
-  socket.write(Buffer.from('twø', 'utf8'));
+    socket.write('one');
+    socket.write(Buffer.from('twø', 'utf8'));
 
-  socket.uncork();
+    socket.uncork();
 
-  // one = 3 bytes, twø = 4 bytes
-  assert.strictEqual(socket.bytesWritten, 3 + 4);
-
-  socket.on('connect', common.mustCall(function() {
-    assert.strictEqual(socket.bytesWritten, 3 + 4);
-  }));
-
-  socket.on('end', common.mustCall(function() {
+    // one = 3 bytes, twø = 4 bytes
     assert.strictEqual(socket.bytesWritten, 3 + 4);
 
-    server.close();
-  }));
-}));
+    socket.on(
+      'connect',
+      common.mustCall(function() {
+        assert.strictEqual(socket.bytesWritten, 3 + 4);
+      })
+    );
+
+    socket.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(socket.bytesWritten, 3 + 4);
+
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-socket-close-after-end.js b/test/parallel/test-net-socket-close-after-end.js
index 06bf55f89d6e50..ea0d6f6d335483 100644
--- a/test/parallel/test-net-socket-close-after-end.js
+++ b/test/parallel/test-net-socket-close-after-end.js
@@ -24,8 +24,10 @@ server.on('connection', (socket) => {
   socket.end('foo');
 });
 
-server.listen(common.mustCall(() => {
-  const socket = net.createConnection(server.address().port, () => {
-    socket.end('foo');
-  });
-}));
+server.listen(
+  common.mustCall(() => {
+    const socket = net.createConnection(server.address().port, () => {
+      socket.end('foo');
+    });
+  })
+);
diff --git a/test/parallel/test-net-socket-connect-without-cb.js b/test/parallel/test-net-socket-connect-without-cb.js
index 468b29a3a486d7..b539571df7414e 100644
--- a/test/parallel/test-net-socket-connect-without-cb.js
+++ b/test/parallel/test-net-socket-connect-without-cb.js
@@ -6,15 +6,25 @@ const common = require('../common');
 
 const net = require('net');
 
-const server = net.createServer(common.mustCall(function(conn) {
-  conn.end();
-  server.close();
-})).listen(0, common.mustCall(function() {
-  const client = new net.Socket();
+const server = net
+  .createServer(
+    common.mustCall(function(conn) {
+      conn.end();
+      server.close();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const client = new net.Socket();
 
-  client.on('connect', common.mustCall(function() {
-    client.end();
-  }));
+      client.on(
+        'connect',
+        common.mustCall(function() {
+          client.end();
+        })
+      );
 
-  client.connect(server.address());
-}));
+      client.connect(server.address());
+    })
+  );
diff --git a/test/parallel/test-net-socket-connecting.js b/test/parallel/test-net-socket-connecting.js
index 21aa261192c17d..60caee7bb2b130 100644
--- a/test/parallel/test-net-socket-connecting.js
+++ b/test/parallel/test-net-socket-connecting.js
@@ -3,19 +3,24 @@ require('../common');
 const assert = require('assert');
 const net = require('net');
 
-const server = net.createServer((conn) => {
-  conn.end();
-  server.close();
-}).listen(0, () => {
-  const client = net.connect(server.address().port, () => {
-    assert.strictEqual(client.connecting, false);
+const server = net
+  .createServer((conn) => {
+    conn.end();
+    server.close();
+  })
+  .listen(0, () => {
+    const client = net.connect(
+      server.address().port,
+      () => {
+        assert.strictEqual(client.connecting, false);
+
+        // Legacy getter
+        assert.strictEqual(client._connecting, false);
+        client.end();
+      }
+    );
+    assert.strictEqual(client.connecting, true);
 
     // Legacy getter
-    assert.strictEqual(client._connecting, false);
-    client.end();
+    assert.strictEqual(client._connecting, true);
   });
-  assert.strictEqual(client.connecting, true);
-
-  // Legacy getter
-  assert.strictEqual(client._connecting, true);
-});
diff --git a/test/parallel/test-net-socket-constructor.js b/test/parallel/test-net-socket-constructor.js
index 90b0907f488a9a..234d06ad551701 100644
--- a/test/parallel/test-net-socket-constructor.js
+++ b/test/parallel/test-net-socket-constructor.js
@@ -5,13 +5,19 @@ const assert = require('assert');
 const cluster = require('cluster');
 const net = require('net');
 
-common.expectsError(() => {
-  new net.Socket({ fd: -1 });
-}, { code: 'ERR_OUT_OF_RANGE' });
+common.expectsError(
+  () => {
+    new net.Socket({ fd: -1 });
+  },
+  { code: 'ERR_OUT_OF_RANGE' }
+);
 
-common.expectsError(() => {
-  new net.Socket({ fd: 'foo' });
-}, { code: 'ERR_INVALID_ARG_TYPE' });
+common.expectsError(
+  () => {
+    new net.Socket({ fd: 'foo' });
+  },
+  { code: 'ERR_INVALID_ARG_TYPE' }
+);
 
 function test(sock, readable, writable) {
   let socket;
@@ -29,34 +35,47 @@ function test(sock, readable, writable) {
 if (cluster.isMaster) {
   test(undefined, false, false);
 
-  const server = net.createServer(common.mustCall((socket) => {
-    socket.unref();
-    test(socket, true, true);
-    test({ handle: socket._handle }, false, false);
-    test({ handle: socket._handle, readable: true, writable: true },
-         true, true);
-    server.close();
-  }));
-
-  server.listen(common.mustCall(() => {
-    const { port } = server.address();
-    const socket = net.connect(port, common.mustCall(() => {
+  const server = net.createServer(
+    common.mustCall((socket) => {
+      socket.unref();
       test(socket, true, true);
-      socket.end();
-    }));
+      test({ handle: socket._handle }, false, false);
+      test(
+        { handle: socket._handle, readable: true, writable: true },
+        true,
+        true
+      );
+      server.close();
+    })
+  );
+
+  server.listen(
+    common.mustCall(() => {
+      const { port } = server.address();
+      const socket = net.connect(
+        port,
+        common.mustCall(() => {
+          test(socket, true, true);
+          socket.end();
+        })
+      );
 
-    test(socket, false, true);
-  }));
+      test(socket, false, true);
+    })
+  );
 
   cluster.setupMaster({
     stdio: ['pipe', 'pipe', 'pipe', 'ipc', 'pipe', 'pipe', 'pipe']
   });
 
   const worker = cluster.fork();
-  worker.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  }));
+  worker.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 } else {
   test(4, false, false);
   test({ fd: 5 }, false, false);
diff --git a/test/parallel/test-net-socket-destroy-send.js b/test/parallel/test-net-socket-destroy-send.js
index aa587fc2e16896..183295e807ac0e 100644
--- a/test/parallel/test-net-socket-destroy-send.js
+++ b/test/parallel/test-net-socket-destroy-send.js
@@ -5,24 +5,36 @@ const net = require('net');
 const assert = require('assert');
 
 const server = net.createServer();
-server.listen(0, common.mustCall(function() {
-  const port = server.address().port;
-  const conn = net.createConnection(port);
+server.listen(
+  0,
+  common.mustCall(function() {
+    const port = server.address().port;
+    const conn = net.createConnection(port);
 
-  conn.on('connect', common.mustCall(function() {
-    // Test destroy returns this, even on multiple calls when it short-circuits.
-    assert.strictEqual(conn, conn.destroy().destroy());
-    conn.on('error', common.expectsError({
-      code: 'ERR_STREAM_DESTROYED',
-      message: 'Cannot call write after a stream was destroyed',
-      type: Error
-    }));
+    conn.on(
+      'connect',
+      common.mustCall(function() {
+        // Test destroy returns this, even on multiple calls when it short-circuits.
+        assert.strictEqual(conn, conn.destroy().destroy());
+        conn.on(
+          'error',
+          common.expectsError({
+            code: 'ERR_STREAM_DESTROYED',
+            message: 'Cannot call write after a stream was destroyed',
+            type: Error
+          })
+        );
 
-    conn.write(Buffer.from('kaboom'), common.expectsError({
-      code: 'ERR_STREAM_DESTROYED',
-      message: 'Cannot call write after a stream was destroyed',
-      type: Error
-    }));
-    server.close();
-  }));
-}));
+        conn.write(
+          Buffer.from('kaboom'),
+          common.expectsError({
+            code: 'ERR_STREAM_DESTROYED',
+            message: 'Cannot call write after a stream was destroyed',
+            type: Error
+          })
+        );
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-socket-destroy-twice.js b/test/parallel/test-net-socket-destroy-twice.js
index 1029d7b2980ea2..8277fb25cdaf7c 100644
--- a/test/parallel/test-net-socket-destroy-twice.js
+++ b/test/parallel/test-net-socket-destroy-twice.js
@@ -28,9 +28,12 @@ server.listen(0);
 const port = server.address().port;
 const conn = net.createConnection(port);
 
-conn.on('error', common.mustCall(() => {
-  conn.destroy();
-}));
+conn.on(
+  'error',
+  common.mustCall(() => {
+    conn.destroy();
+  })
+);
 
 conn.on('close', common.mustCall());
 server.close();
diff --git a/test/parallel/test-net-socket-end-before-connect.js b/test/parallel/test-net-socket-end-before-connect.js
index d40c90620e4153..814feac3e36e03 100644
--- a/test/parallel/test-net-socket-end-before-connect.js
+++ b/test/parallel/test-net-socket-end-before-connect.js
@@ -6,8 +6,10 @@ const net = require('net');
 
 const server = net.createServer();
 
-server.listen(common.mustCall(() => {
-  const socket = net.createConnection(server.address().port);
-  socket.on('close', common.mustCall(() => server.close()));
-  socket.end();
-}));
+server.listen(
+  common.mustCall(() => {
+    const socket = net.createConnection(server.address().port);
+    socket.on('close', common.mustCall(() => server.close()));
+    socket.end();
+  })
+);
diff --git a/test/parallel/test-net-socket-local-address.js b/test/parallel/test-net-socket-local-address.js
index e80731bc78fb0a..e1a471faa5455a 100644
--- a/test/parallel/test-net-socket-local-address.js
+++ b/test/parallel/test-net-socket-local-address.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 // skip test in FreeBSD jails
-if (common.inFreeBSDJail)
-  common.skip('In a FreeBSD jail');
+if (common.inFreeBSDJail) common.skip('In a FreeBSD jail');
 
 const assert = require('assert');
 const net = require('net');
@@ -16,11 +15,14 @@ const server = net.createServer((socket) => {
   socket.end();
 });
 
-server.on('close', common.mustCall(() => {
-  // client and server should agree on the ports used
-  assert.deepStrictEqual(serverRemotePorts, clientLocalPorts);
-  assert.strictEqual(conns, 2);
-}));
+server.on(
+  'close',
+  common.mustCall(() => {
+    // client and server should agree on the ports used
+    assert.deepStrictEqual(serverRemotePorts, clientLocalPorts);
+    assert.strictEqual(conns, 2);
+  })
+);
 
 server.listen(0, common.localhostIPv4, connect);
 
@@ -34,8 +36,12 @@ function connect() {
   client.once('close', connect);
   assert.strictEqual(
     client,
-    client.connect(server.address().port, common.localhostIPv4, () => {
-      clientLocalPorts.push(client.localPort);
-    })
+    client.connect(
+      server.address().port,
+      common.localhostIPv4,
+      () => {
+        clientLocalPorts.push(client.localPort);
+      }
+    )
   );
 }
diff --git a/test/parallel/test-net-socket-ready-without-cb.js b/test/parallel/test-net-socket-ready-without-cb.js
index 1ad5db4760dc1e..00482eabb19a04 100644
--- a/test/parallel/test-net-socket-ready-without-cb.js
+++ b/test/parallel/test-net-socket-ready-without-cb.js
@@ -6,15 +6,25 @@ const common = require('../common');
 
 const net = require('net');
 
-const server = net.createServer(common.mustCall(function(conn) {
-  conn.end();
-  server.close();
-})).listen(0, common.mustCall(function() {
-  const client = new net.Socket();
+const server = net
+  .createServer(
+    common.mustCall(function(conn) {
+      conn.end();
+      server.close();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const client = new net.Socket();
 
-  client.on('ready', common.mustCall(function() {
-    client.end();
-  }));
+      client.on(
+        'ready',
+        common.mustCall(function() {
+          client.end();
+        })
+      );
 
-  client.connect(server.address());
-}));
+      client.connect(server.address());
+    })
+  );
diff --git a/test/parallel/test-net-socket-timeout-unref.js b/test/parallel/test-net-socket-timeout-unref.js
index ae6bde49ab60cd..15fc166bc41605 100644
--- a/test/parallel/test-net-socket-timeout-unref.js
+++ b/test/parallel/test-net-socket-timeout-unref.js
@@ -39,18 +39,21 @@ const delays = [8, 5, 3, 6, 2, 4];
 
 delays.forEach(function(T) {
   const socket = net.createConnection(server.address().port, 'localhost');
-  socket.on('connect', common.mustCall(function() {
-    if (++connections === delays.length) {
-      sockets.forEach(function(s) {
-        s.socket.setTimeout(s.timeout, function() {
-          s.socket.destroy();
-          throw new Error('socket timed out unexpectedly');
+  socket.on(
+    'connect',
+    common.mustCall(function() {
+      if (++connections === delays.length) {
+        sockets.forEach(function(s) {
+          s.socket.setTimeout(s.timeout, function() {
+            s.socket.destroy();
+            throw new Error('socket timed out unexpectedly');
+          });
+
+          s.socket.unref();
         });
-
-        s.socket.unref();
-      });
-    }
-  }));
+      }
+    })
+  );
 
   sockets.push({ socket: socket, timeout: T * 1000 });
 });
diff --git a/test/parallel/test-net-socket-timeout.js b/test/parallel/test-net-socket-timeout.js
index 2826b1dd76f146..c8ab2cf3f2ddd8 100644
--- a/test/parallel/test-net-socket-timeout.js
+++ b/test/parallel/test-net-socket-timeout.js
@@ -27,22 +27,37 @@ const assert = require('assert');
 // Verify that invalid delays throw
 const s = new net.Socket();
 const nonNumericDelays = [
-  '100', true, false, undefined, null, '', {}, () => {}, []
+  '100',
+  true,
+  false,
+  undefined,
+  null,
+  '',
+  {},
+  () => {},
+  []
 ];
 const badRangeDelays = [-0.001, -1, -Infinity, Infinity, NaN];
 const validDelays = [0, 0.001, 1, 1e6];
 
-
 for (let i = 0; i < nonNumericDelays.length; i++) {
-  assert.throws(function() {
-    s.setTimeout(nonNumericDelays[i], () => {});
-  }, TypeError, nonNumericDelays[i]);
+  assert.throws(
+    function() {
+      s.setTimeout(nonNumericDelays[i], () => {});
+    },
+    TypeError,
+    nonNumericDelays[i]
+  );
 }
 
 for (let i = 0; i < badRangeDelays.length; i++) {
-  assert.throws(function() {
-    s.setTimeout(badRangeDelays[i], () => {});
-  }, RangeError, badRangeDelays[i]);
+  assert.throws(
+    function() {
+      s.setTimeout(badRangeDelays[i], () => {});
+    },
+    RangeError,
+    badRangeDelays[i]
+  );
 }
 
 for (let i = 0; i < validDelays.length; i++) {
@@ -50,10 +65,16 @@ for (let i = 0; i < validDelays.length; i++) {
 }
 
 const server = net.Server();
-server.listen(0, common.mustCall(function() {
-  const socket = net.createConnection(this.address().port);
-  socket.setTimeout(1, common.mustCall(function() {
-    socket.destroy();
-    server.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const socket = net.createConnection(this.address().port);
+    socket.setTimeout(
+      1,
+      common.mustCall(function() {
+        socket.destroy();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-net-socket-write-after-close.js b/test/parallel/test-net-socket-write-after-close.js
index e3593a3a09a146..0f3c98f850a968 100644
--- a/test/parallel/test-net-socket-write-after-close.js
+++ b/test/parallel/test-net-socket-write-after-close.js
@@ -6,37 +6,53 @@ const net = require('net');
 {
   const server = net.createServer();
 
-  server.listen(common.mustCall(() => {
-    const port = server.address().port;
-    const client = net.connect({ port }, common.mustCall(() => {
-      client.on('error', common.mustCall((err) => {
-        server.close();
-        assert.strictEqual(err.constructor, Error);
-        assert.strictEqual(err.message, 'write EBADF');
-      }));
-      client._handle.close();
-      client.write('foo');
-    }));
-  }));
+  server.listen(
+    common.mustCall(() => {
+      const port = server.address().port;
+      const client = net.connect(
+        { port },
+        common.mustCall(() => {
+          client.on(
+            'error',
+            common.mustCall((err) => {
+              server.close();
+              assert.strictEqual(err.constructor, Error);
+              assert.strictEqual(err.message, 'write EBADF');
+            })
+          );
+          client._handle.close();
+          client.write('foo');
+        })
+      );
+    })
+  );
 }
 
 {
   const server = net.createServer();
 
-  server.listen(common.mustCall(() => {
-    const port = server.address().port;
-    const client = net.connect({ port }, common.mustCall(() => {
-      client.on('error', common.expectsError({
-        code: 'ERR_SOCKET_CLOSED',
-        message: 'Socket is closed',
-        type: Error
-      }));
+  server.listen(
+    common.mustCall(() => {
+      const port = server.address().port;
+      const client = net.connect(
+        { port },
+        common.mustCall(() => {
+          client.on(
+            'error',
+            common.expectsError({
+              code: 'ERR_SOCKET_CLOSED',
+              message: 'Socket is closed',
+              type: Error
+            })
+          );
 
-      server.close();
+          server.close();
 
-      client._handle.close();
-      client._handle = null;
-      client.write('foo');
-    }));
-  }));
+          client._handle.close();
+          client._handle = null;
+          client.write('foo');
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-net-socket-write-error.js b/test/parallel/test-net-socket-write-error.js
index 800d6020da4cbe..6185619441a45d 100644
--- a/test/parallel/test-net-socket-write-error.js
+++ b/test/parallel/test-net-socket-write-error.js
@@ -6,14 +6,14 @@ const net = require('net');
 const server = net.createServer().listen(0, connectToServer);
 
 function connectToServer() {
-  const client = net.createConnection(this.address().port, () => {
-    common.expectsError(() => client.write(1337),
-                        {
-                          code: 'ERR_INVALID_ARG_TYPE',
-                          type: TypeError
-                        });
+  const client = net
+    .createConnection(this.address().port, () => {
+      common.expectsError(() => client.write(1337), {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError
+      });
 
-    client.end();
-  })
-  .on('end', () => server.close());
+      client.end();
+    })
+    .on('end', () => server.close());
 }
diff --git a/test/parallel/test-net-stream.js b/test/parallel/test-net-stream.js
index 4e7e06bfcf2546..b3bb512766df45 100644
--- a/test/parallel/test-net-stream.js
+++ b/test/parallel/test-net-stream.js
@@ -40,33 +40,36 @@ assert.strictEqual(s.server.connections, 9);
 s.destroy();
 assert.strictEqual(s.server.connections, 9);
 
-const SIZE = 2E6;
+const SIZE = 2e6;
 const N = 10;
 const buf = Buffer.alloc(SIZE, 'a');
 
-const server = net.createServer(function(socket) {
-  socket.setNoDelay();
+const server = net
+  .createServer(function(socket) {
+    socket.setNoDelay();
 
-  socket.on('error', function(err) {
-    socket.destroy();
-  }).on('close', function() {
-    server.close();
-  });
-
-  for (let i = 0; i < N; ++i) {
-    socket.write(buf, () => {});
-  }
-  socket.end();
+    socket
+      .on('error', function(err) {
+        socket.destroy();
+      })
+      .on('close', function() {
+        server.close();
+      });
 
-}).listen(0, function() {
-  const conn = net.connect(this.address().port);
-  conn.on('data', function(buf) {
-    assert.strictEqual(conn, conn.pause());
-    setTimeout(function() {
-      conn.destroy();
-    }, 20);
+    for (let i = 0; i < N; ++i) {
+      socket.write(buf, () => {});
+    }
+    socket.end();
+  })
+  .listen(0, function() {
+    const conn = net.connect(this.address().port);
+    conn.on('data', function(buf) {
+      assert.strictEqual(conn, conn.pause());
+      setTimeout(function() {
+        conn.destroy();
+      }, 20);
+    });
   });
-});
 
 process.on('exit', function() {
   assert.strictEqual(server.connections, 0);
diff --git a/test/parallel/test-net-sync-cork.js b/test/parallel/test-net-sync-cork.js
index 3872f5f96944fc..7959822191f0d1 100644
--- a/test/parallel/test-net-sync-cork.js
+++ b/test/parallel/test-net-sync-cork.js
@@ -33,9 +33,11 @@ process.on('exit', function() {
 function handle(socket) {
   socket.resume();
 
-  socket.on('error', function(err) {
-    socket.destroy();
-  }).on('close', function() {
-    server.close();
-  });
+  socket
+    .on('error', function(err) {
+      socket.destroy();
+    })
+    .on('close', function() {
+      server.close();
+    });
 }
diff --git a/test/parallel/test-net-timeout-no-handle.js b/test/parallel/test-net-timeout-no-handle.js
index 539f661cae8414..8684bb65d56555 100644
--- a/test/parallel/test-net-timeout-no-handle.js
+++ b/test/parallel/test-net-timeout-no-handle.js
@@ -7,9 +7,12 @@ const assert = require('assert');
 const socket = new net.Socket();
 socket.setTimeout(common.platformTimeout(50));
 
-socket.on('timeout', common.mustCall(() => {
-  assert.strictEqual(socket._handle, null);
-}));
+socket.on(
+  'timeout',
+  common.mustCall(() => {
+    assert.strictEqual(socket._handle, null);
+  })
+);
 
 socket.on('connect', common.mustNotCall());
 
diff --git a/test/parallel/test-net-write-after-close.js b/test/parallel/test-net-write-after-close.js
index f17273f9417a2a..5928e227d68eb2 100644
--- a/test/parallel/test-net-write-after-close.js
+++ b/test/parallel/test-net-write-after-close.js
@@ -26,26 +26,37 @@ const net = require('net');
 
 let serverSocket;
 
-const server = net.createServer(common.mustCall(function(socket) {
-  serverSocket = socket;
+const server = net.createServer(
+  common.mustCall(function(socket) {
+    serverSocket = socket;
 
-  socket.resume();
+    socket.resume();
 
-  socket.on('error', common.mustCall(function(error) {
-    console.error('received error as expected, closing server', error);
-    server.close();
-  }));
-}));
+    socket.on(
+      'error',
+      common.mustCall(function(error) {
+        console.error('received error as expected, closing server', error);
+        server.close();
+      })
+    );
+  })
+);
 
 server.listen(0, function() {
-  const client = net.connect(this.address().port, function() {
-    // client.end() will close both the readable and writable side
-    // of the duplex because allowHalfOpen defaults to false.
-    // Then 'end' will be emitted when it receives a FIN packet from
-    // the other side.
-    client.on('end', common.mustCall(() => {
-      serverSocket.write('test', common.mustCall());
-    }));
-    client.end();
-  });
+  const client = net.connect(
+    this.address().port,
+    function() {
+      // client.end() will close both the readable and writable side
+      // of the duplex because allowHalfOpen defaults to false.
+      // Then 'end' will be emitted when it receives a FIN packet from
+      // the other side.
+      client.on(
+        'end',
+        common.mustCall(() => {
+          serverSocket.write('test', common.mustCall());
+        })
+      );
+      client.end();
+    }
+  );
 });
diff --git a/test/parallel/test-net-write-connect-write.js b/test/parallel/test-net-write-connect-write.js
index 1f09b04f17ef26..44bf33367246f2 100644
--- a/test/parallel/test-net-write-connect-write.js
+++ b/test/parallel/test-net-write-connect-write.js
@@ -24,23 +24,31 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-const server = net.createServer(function(socket) {
-  socket.pipe(socket);
-}).listen(0, common.mustCall(function() {
-  const conn = net.connect(this.address().port);
-  let received = '';
+const server = net
+  .createServer(function(socket) {
+    socket.pipe(socket);
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      const conn = net.connect(this.address().port);
+      let received = '';
 
-  conn.setEncoding('utf8');
-  conn.write('before');
-  conn.on('connect', function() {
-    conn.write(' after');
-  });
-  conn.on('data', function(buf) {
-    received += buf;
-    conn.end();
-  });
-  conn.on('end', common.mustCall(function() {
-    server.close();
-    assert.strictEqual(received, 'before after');
-  }));
-}));
+      conn.setEncoding('utf8');
+      conn.write('before');
+      conn.on('connect', function() {
+        conn.write(' after');
+      });
+      conn.on('data', function(buf) {
+        received += buf;
+        conn.end();
+      });
+      conn.on(
+        'end',
+        common.mustCall(function() {
+          server.close();
+          assert.strictEqual(received, 'before after');
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-net-write-fully-async-buffer.js b/test/parallel/test-net-write-fully-async-buffer.js
index 207ae24f6a32d0..8190085ac9a187 100644
--- a/test/parallel/test-net-write-fully-async-buffer.js
+++ b/test/parallel/test-net-write-fully-async-buffer.js
@@ -9,26 +9,36 @@ const net = require('net');
 
 const data = Buffer.alloc(1000000);
 
-const server = net.createServer(common.mustCall(function(conn) {
-  conn.resume();
-})).listen(0, common.mustCall(function() {
-  const conn = net.createConnection(this.address().port, common.mustCall(() => {
-    let count = 0;
+const server = net
+  .createServer(
+    common.mustCall(function(conn) {
+      conn.resume();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const conn = net.createConnection(
+        this.address().port,
+        common.mustCall(() => {
+          let count = 0;
 
-    function writeLoop() {
-      if (count++ === 200) {
-        conn.destroy();
-        server.close();
-        return;
-      }
+          function writeLoop() {
+            if (count++ === 200) {
+              conn.destroy();
+              server.close();
+              return;
+            }
 
-      while (conn.write(Buffer.from(data)));
-      global.gc(true);
-      // The buffer allocated above should still be alive.
-    }
+            while (conn.write(Buffer.from(data)));
+            global.gc(true);
+            // The buffer allocated above should still be alive.
+          }
 
-    conn.on('drain', writeLoop);
+          conn.on('drain', writeLoop);
 
-    writeLoop();
-  }));
-}));
+          writeLoop();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-net-write-fully-async-hex-string.js b/test/parallel/test-net-write-fully-async-hex-string.js
index f3115d8d2f795e..7f98483111ddc4 100644
--- a/test/parallel/test-net-write-fully-async-hex-string.js
+++ b/test/parallel/test-net-write-fully-async-hex-string.js
@@ -7,26 +7,36 @@ const net = require('net');
 
 const data = Buffer.alloc(1000000).toString('hex');
 
-const server = net.createServer(common.mustCall(function(conn) {
-  conn.resume();
-})).listen(0, common.mustCall(function() {
-  const conn = net.createConnection(this.address().port, common.mustCall(() => {
-    let count = 0;
+const server = net
+  .createServer(
+    common.mustCall(function(conn) {
+      conn.resume();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const conn = net.createConnection(
+        this.address().port,
+        common.mustCall(() => {
+          let count = 0;
 
-    function writeLoop() {
-      if (count++ === 20) {
-        conn.destroy();
-        server.close();
-        return;
-      }
+          function writeLoop() {
+            if (count++ === 20) {
+              conn.destroy();
+              server.close();
+              return;
+            }
 
-      while (conn.write(data, 'hex'));
-      global.gc(true);
-      // The buffer allocated inside the .write() call should still be alive.
-    }
+            while (conn.write(data, 'hex'));
+            global.gc(true);
+            // The buffer allocated inside the .write() call should still be alive.
+          }
 
-    conn.on('drain', writeLoop);
+          conn.on('drain', writeLoop);
 
-    writeLoop();
-  }));
-}));
+          writeLoop();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-net-write-slow.js b/test/parallel/test-net-write-slow.js
index cf2d5790d93174..9b94bc764d8fee 100644
--- a/test/parallel/test-net-write-slow.js
+++ b/test/parallel/test-net-write-slow.js
@@ -24,40 +24,47 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-const SIZE = 2E5;
+const SIZE = 2e5;
 const N = 10;
 let flushed = 0;
 let received = 0;
 const buf = Buffer.alloc(SIZE, 'a');
 
-const server = net.createServer(function(socket) {
-  socket.setNoDelay();
-  socket.setTimeout(9999);
-  socket.on('timeout', function() {
-    assert.fail(`flushed: ${flushed}, received: ${received}/${SIZE * N}`);
-  });
-
-  for (let i = 0; i < N; ++i) {
-    socket.write(buf, function() {
-      ++flushed;
-      if (flushed === N) {
-        socket.setTimeout(0);
-      }
+const server = net
+  .createServer(function(socket) {
+    socket.setNoDelay();
+    socket.setTimeout(9999);
+    socket.on('timeout', function() {
+      assert.fail(`flushed: ${flushed}, received: ${received}/${SIZE * N}`);
     });
-  }
-  socket.end();
 
-}).listen(0, common.mustCall(function() {
-  const conn = net.connect(this.address().port);
-  conn.on('data', function(buf) {
-    received += buf.length;
-    conn.pause();
-    setTimeout(function() {
-      conn.resume();
-    }, 20);
-  });
-  conn.on('end', common.mustCall(function() {
-    server.close();
-    assert.strictEqual(received, SIZE * N);
-  }));
-}));
+    for (let i = 0; i < N; ++i) {
+      socket.write(buf, function() {
+        ++flushed;
+        if (flushed === N) {
+          socket.setTimeout(0);
+        }
+      });
+    }
+    socket.end();
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      const conn = net.connect(this.address().port);
+      conn.on('data', function(buf) {
+        received += buf.length;
+        conn.pause();
+        setTimeout(function() {
+          conn.resume();
+        }, 20);
+      });
+      conn.on(
+        'end',
+        common.mustCall(function() {
+          server.close();
+          assert.strictEqual(received, SIZE * N);
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-next-tick-fixed-queue-regression.js b/test/parallel/test-next-tick-fixed-queue-regression.js
index 1fe82d02b10907..52ec4fd4c2af4a 100644
--- a/test/parallel/test-next-tick-fixed-queue-regression.js
+++ b/test/parallel/test-next-tick-fixed-queue-regression.js
@@ -10,8 +10,7 @@ const common = require('../common');
 
 process.nextTick(() => {
   Promise.resolve(1).then(() => {
-    for (let i = 0; i < 2047; i++)
-      process.nextTick(common.mustCall());
+    for (let i = 0; i < 2047; i++) process.nextTick(common.mustCall());
     const immediate = setImmediate(common.mustNotCall());
     process.nextTick(common.mustCall(() => clearImmediate(immediate)));
   });
diff --git a/test/parallel/test-next-tick-ordering.js b/test/parallel/test-next-tick-ordering.js
index 9ae212cb7f3fbe..f4d6e60789b419 100644
--- a/test/parallel/test-next-tick-ordering.js
+++ b/test/parallel/test-next-tick-ordering.js
@@ -45,7 +45,6 @@ for (i = 0; i < N; i += 1) {
 
 console.log('Running from main.');
 
-
 process.on('exit', function() {
   assert.strictEqual(done[0], 'nextTick');
   /* Disabling this test. I don't think we can ensure the order
diff --git a/test/parallel/test-next-tick.js b/test/parallel/test-next-tick.js
index 47823f45bcf7e2..afbe269602049c 100644
--- a/test/parallel/test-next-tick.js
+++ b/test/parallel/test-next-tick.js
@@ -24,39 +24,66 @@ const common = require('../common');
 
 const assert = require('assert');
 
-process.nextTick(common.mustCall(function() {
-  process.nextTick(common.mustCall(function() {
-    process.nextTick(common.mustCall());
-  }));
-}));
+process.nextTick(
+  common.mustCall(function() {
+    process.nextTick(
+      common.mustCall(function() {
+        process.nextTick(common.mustCall());
+      })
+    );
+  })
+);
 
-setTimeout(common.mustCall(function() {
-  process.nextTick(common.mustCall());
-}), 50);
+setTimeout(
+  common.mustCall(function() {
+    process.nextTick(common.mustCall());
+  }),
+  50
+);
 
 process.nextTick(common.mustCall());
 
 const obj = {};
 
-process.nextTick(function(a, b) {
-  assert.strictEqual(a, 42);
-  assert.strictEqual(b, obj);
-  assert.strictEqual(this, undefined);
-}, 42, obj);
-
-process.nextTick((a, b) => {
-  assert.strictEqual(a, 42);
-  assert.strictEqual(b, obj);
-  assert.deepStrictEqual(this, {});
-}, 42, obj);
-
-process.nextTick(function() {
-  assert.strictEqual(this, undefined);
-}, 1, 2, 3, 4);
-
-process.nextTick(() => {
-  assert.deepStrictEqual(this, {});
-}, 1, 2, 3, 4);
+process.nextTick(
+  function(a, b) {
+    assert.strictEqual(a, 42);
+    assert.strictEqual(b, obj);
+    assert.strictEqual(this, undefined);
+  },
+  42,
+  obj
+);
+
+process.nextTick(
+  (a, b) => {
+    assert.strictEqual(a, 42);
+    assert.strictEqual(b, obj);
+    assert.deepStrictEqual(this, {});
+  },
+  42,
+  obj
+);
+
+process.nextTick(
+  function() {
+    assert.strictEqual(this, undefined);
+  },
+  1,
+  2,
+  3,
+  4
+);
+
+process.nextTick(
+  () => {
+    assert.deepStrictEqual(this, {});
+  },
+  1,
+  2,
+  3,
+  4
+);
 
 process.on('exit', function() {
   process.nextTick(common.mustNotCall());
diff --git a/test/parallel/test-npm-install.js b/test/parallel/test-npm-install.js
index dc9f60b799e0f6..1bf93cf719559e 100644
--- a/test/parallel/test-npm-install.js
+++ b/test/parallel/test-npm-install.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const path = require('path');
 const exec = require('child_process').exec;
@@ -40,13 +39,17 @@ const env = Object.assign({}, process.env, {
   PATH: path.dirname(process.execPath),
   NPM_CONFIG_PREFIX: path.join(npmSandbox, 'npm-prefix'),
   NPM_CONFIG_TMP: path.join(npmSandbox, 'npm-tmp'),
-  HOME: path.join(npmSandbox, 'home'),
+  HOME: path.join(npmSandbox, 'home')
 });
 
-exec(`${process.execPath} ${npmPath} install`, {
-  cwd: installDir,
-  env: env
-}, common.mustCall(handleExit));
+exec(
+  `${process.execPath} ${npmPath} install`,
+  {
+    cwd: installDir,
+    env: env
+  },
+  common.mustCall(handleExit)
+);
 
 function handleExit(error, stdout, stderr) {
   const code = error ? error.code : 0;
diff --git a/test/parallel/test-openssl-ca-options.js b/test/parallel/test-openssl-ca-options.js
index b51b0ecf698035..6ea6f853e0fd7e 100644
--- a/test/parallel/test-openssl-ca-options.js
+++ b/test/parallel/test-openssl-ca-options.js
@@ -2,29 +2,35 @@
 // This test checks the usage of --use-bundled-ca and --use-openssl-ca arguments
 // to verify that both are not used at the same time.
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const os = require('os');
 const childProcess = require('child_process');
 const result = childProcess.spawnSync(
   process.execPath,
-  [ '--use-bundled-ca', '--use-openssl-ca', '-p', 'process.version' ],
+  ['--use-bundled-ca', '--use-openssl-ca', '-p', 'process.version'],
   { encoding: 'utf8' }
 );
 
-assert.strictEqual(result.stderr, `${process.execPath
-}: either --use-openssl-ca or --use-bundled-ca can be used, not both${os.EOL}`
+assert.strictEqual(
+  result.stderr,
+  `${
+    process.execPath
+  }: either --use-openssl-ca or --use-bundled-ca can be used, not both${os.EOL}`
 );
 assert.strictEqual(result.status, 9);
 
 const useBundledCA = childProcess.spawnSync(process.execPath, [
   '--use-bundled-ca',
-  '-p', 'process.version']);
+  '-p',
+  'process.version'
+]);
 assert.strictEqual(useBundledCA.status, 0);
 
 const useOpenSSLCA = childProcess.spawnSync(process.execPath, [
   '--use-openssl-ca',
-  '-p', 'process.version']);
+  '-p',
+  'process.version'
+]);
 assert.strictEqual(useOpenSSLCA.status, 0);
diff --git a/test/parallel/test-os-eol.js b/test/parallel/test-os-eol.js
index 412751a151b9a2..85dd9fbe12ca55 100644
--- a/test/parallel/test-os-eol.js
+++ b/test/parallel/test-os-eol.js
@@ -10,7 +10,9 @@ assert.strictEqual(os.EOL, eol);
 
 // Test that the `Error` is a `TypeError` but do not check the message as it
 // varies between different JavaScript engines.
-assert.throws(function() { os.EOL = 123; }, TypeError);
+assert.throws(function() {
+  os.EOL = 123;
+}, TypeError);
 
 const foo = 'foo';
 Object.defineProperties(os, {
diff --git a/test/parallel/test-os-homedir-no-envvar.js b/test/parallel/test-os-homedir-no-envvar.js
index 2f9b1b47a70477..2d78887e297231 100644
--- a/test/parallel/test-os-homedir-no-envvar.js
+++ b/test/parallel/test-os-homedir-no-envvar.js
@@ -5,22 +5,17 @@ const cp = require('child_process');
 const os = require('os');
 const path = require('path');
 
-
 if (process.argv[2] === 'child') {
-  if (common.isWindows)
-    assert.strictEqual(process.env.USERPROFILE, undefined);
-  else
-    assert.strictEqual(process.env.HOME, undefined);
+  if (common.isWindows) assert.strictEqual(process.env.USERPROFILE, undefined);
+  else assert.strictEqual(process.env.HOME, undefined);
 
   const home = os.homedir();
 
   assert.strictEqual(typeof home, 'string');
   assert(home.includes(path.sep));
 } else {
-  if (common.isWindows)
-    delete process.env.USERPROFILE;
-  else
-    delete process.env.HOME;
+  if (common.isWindows) delete process.env.USERPROFILE;
+  else delete process.env.HOME;
 
   const child = cp.spawnSync(process.execPath, [__filename, 'child'], {
     env: process.env
diff --git a/test/parallel/test-os-process-priority.js b/test/parallel/test-os-process-priority.js
index 05686e6c77083a..e4dc51f259e38a 100644
--- a/test/parallel/test-os-process-priority.js
+++ b/test/parallel/test-os-process-priority.js
@@ -53,12 +53,15 @@ assert.strictEqual(typeof PRIORITY_HIGHEST, 'number');
 
 // Test priority type validation.
 [null, true, false, 'foo', {}, [], /x/].forEach((priority) => {
-  common.expectsError(() => {
-    os.setPriority(0, priority);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: /The "priority" argument must be of type number\./
-  });
+  common.expectsError(
+    () => {
+      os.setPriority(0, priority);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /The "priority" argument must be of type number\./
+    }
+  );
 });
 
 // Test priority range validation.
@@ -71,12 +74,15 @@ assert.strictEqual(typeof PRIORITY_HIGHEST, 'number');
   PRIORITY_HIGHEST - 1,
   PRIORITY_LOW + 1
 ].forEach((priority) => {
-  common.expectsError(() => {
-    os.setPriority(0, priority);
-  }, {
-    code: 'ERR_OUT_OF_RANGE',
-    message: /The value of "priority" is out of range\./
-  });
+  common.expectsError(
+    () => {
+      os.setPriority(0, priority);
+    },
+    {
+      code: 'ERR_OUT_OF_RANGE',
+      message: /The value of "priority" is out of range\./
+    }
+  );
 });
 
 // Verify that valid values work.
@@ -88,8 +94,7 @@ for (let i = PRIORITY_HIGHEST; i <= PRIORITY_LOW; i++) {
     // The current user might not have sufficient permissions to set this
     // specific priority level. Skip this priority, but keep trying lower
     // priorities.
-    if (err.info.code === 'EACCES')
-      continue;
+    if (err.info.code === 'EACCES') continue;
 
     assert(err);
   }
@@ -105,7 +110,6 @@ for (let i = PRIORITY_HIGHEST; i <= PRIORITY_LOW; i++) {
   checkPriority(process.pid, i);
 }
 
-
 function checkPriority(pid, expected) {
   const priority = os.getPriority(pid);
 
@@ -128,6 +132,5 @@ function checkPriority(pid, expected) {
     assert.strictEqual(priority, PRIORITY_NORMAL);
   else if (expected < PRIORITY_LOW)
     assert.strictEqual(priority, PRIORITY_BELOW_NORMAL);
-  else
-    assert.strictEqual(priority, PRIORITY_LOW);
+  else assert.strictEqual(priority, PRIORITY_LOW);
 }
diff --git a/test/parallel/test-os-userinfo-handles-getter-errors.js b/test/parallel/test-os-userinfo-handles-getter-errors.js
index 146ab6c812379f..50f29f207aa807 100644
--- a/test/parallel/test-os-userinfo-handles-getter-errors.js
+++ b/test/parallel/test-os-userinfo-handles-getter-errors.js
@@ -13,6 +13,10 @@ const script = `os.userInfo({
 })`;
 
 const node = process.execPath;
-execFile(node, [ '-e', script ], common.mustCall((err, stdout, stderr) => {
-  assert(stderr.includes('Error: xyz'), 'userInfo crashes');
-}));
+execFile(
+  node,
+  ['-e', script],
+  common.mustCall((err, stdout, stderr) => {
+    assert(stderr.includes('Error: xyz'), 'userInfo crashes');
+  })
+);
diff --git a/test/parallel/test-os.js b/test/parallel/test-os.js
index 9b86d3af8b263e..b1b9d97cea99ab 100644
--- a/test/parallel/test-os.js
+++ b/test/parallel/test-os.js
@@ -31,8 +31,12 @@ const is = {
     assert(!Number.isNaN(value), `${key} should not be NaN`);
     assert.strictEqual(typeof value, 'number');
   },
-  string: (value) => { assert.strictEqual(typeof value, 'string'); },
-  array: (value) => { assert.ok(Array.isArray(value)); },
+  string: (value) => {
+    assert.strictEqual(typeof value, 'string');
+  },
+  array: (value) => {
+    assert.ok(Array.isArray(value));
+  },
   object: (value) => {
     assert.strictEqual(typeof value, 'object');
     assert.notStrictEqual(value, null);
@@ -40,8 +44,7 @@ const is = {
 };
 
 const flatten = (arr) =>
-  arr.reduce((acc, c) =>
-    acc.concat(Array.isArray(c) ? flatten(c) : c), []);
+  arr.reduce((acc, c) => acc.concat(Array.isArray(c) ? flatten(c) : c), []);
 
 process.env.TMPDIR = '/tmpdir';
 process.env.TMP = '/tmp';
@@ -110,8 +113,7 @@ const release = os.release();
 is.string(release);
 assert.ok(release.length > 0);
 // TODO: Check format on more than just AIX
-if (common.isAIX)
-  assert.ok(/^\d+\.\d+$/.test(release));
+if (common.isAIX) assert.ok(/^\d+\.\d+$/.test(release));
 
 const platform = os.platform();
 is.string(platform);
@@ -132,44 +134,48 @@ const interfaces = os.networkInterfaces();
 switch (platform) {
   case 'linux': {
     const filter = (e) =>
-      e.address === '127.0.0.1' &&
-      e.netmask === '255.0.0.0';
+      e.address === '127.0.0.1' && e.netmask === '255.0.0.0';
 
     const actual = interfaces.lo.filter(filter);
-    const expected = [{
-      address: '127.0.0.1',
-      netmask: '255.0.0.0',
-      family: 'IPv4',
-      mac: '00:00:00:00:00:00',
-      internal: true,
-      cidr: '127.0.0.1/8'
-    }];
+    const expected = [
+      {
+        address: '127.0.0.1',
+        netmask: '255.0.0.0',
+        family: 'IPv4',
+        mac: '00:00:00:00:00:00',
+        internal: true,
+        cidr: '127.0.0.1/8'
+      }
+    ];
     assert.deepStrictEqual(actual, expected);
     break;
   }
   case 'win32': {
-    const filter = (e) =>
-      e.address === '127.0.0.1';
+    const filter = (e) => e.address === '127.0.0.1';
 
     const actual = interfaces['Loopback Pseudo-Interface 1'].filter(filter);
-    const expected = [{
-      address: '127.0.0.1',
-      netmask: '255.0.0.0',
-      family: 'IPv4',
-      mac: '00:00:00:00:00:00',
-      internal: true,
-      cidr: '127.0.0.1/8'
-    }];
+    const expected = [
+      {
+        address: '127.0.0.1',
+        netmask: '255.0.0.0',
+        family: 'IPv4',
+        mac: '00:00:00:00:00:00',
+        internal: true,
+        cidr: '127.0.0.1/8'
+      }
+    ];
     assert.deepStrictEqual(actual, expected);
     break;
   }
 }
-const netmaskToCIDRSuffixMap = new Map(Object.entries({
-  '255.0.0.0': 8,
-  '255.255.255.0': 24,
-  'ffff:ffff:ffff:ffff::': 64,
-  'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff': 128
-}));
+const netmaskToCIDRSuffixMap = new Map(
+  Object.entries({
+    '255.0.0.0': 8,
+    '255.255.255.0': 24,
+    'ffff:ffff:ffff:ffff::': 64,
+    'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff': 128
+  })
+);
 
 flatten(Object.values(interfaces))
   .map((v) => ({ v, mask: netmaskToCIDRSuffixMap.get(v.netmask) }))
diff --git a/test/parallel/test-outgoing-message-pipe.js b/test/parallel/test-outgoing-message-pipe.js
index 7cfe3687ecc8a7..eb5c842de4751a 100644
--- a/test/parallel/test-outgoing-message-pipe.js
+++ b/test/parallel/test-outgoing-message-pipe.js
@@ -6,7 +6,9 @@ const OutgoingMessage = require('_http_outgoing').OutgoingMessage;
 
 const outgoingMessage = new OutgoingMessage();
 common.expectsError(
-  () => { outgoingMessage.pipe(outgoingMessage); },
+  () => {
+    outgoingMessage.pipe(outgoingMessage);
+  },
   {
     code: 'ERR_STREAM_CANNOT_PIPE',
     type: Error
diff --git a/test/parallel/test-path-basename.js b/test/parallel/test-path-basename.js
index 6b64e40b7eca7a..2fecec81336938 100644
--- a/test/parallel/test-path-basename.js
+++ b/test/parallel/test-path-basename.js
@@ -55,8 +55,10 @@ assert.strictEqual(path.win32.basename('C:foo'), 'foo');
 assert.strictEqual(path.win32.basename('file:stream'), 'file:stream');
 
 // On unix a backslash is just treated as any other character.
-assert.strictEqual(path.posix.basename('\\dir\\basename.ext'),
-                   '\\dir\\basename.ext');
+assert.strictEqual(
+  path.posix.basename('\\dir\\basename.ext'),
+  '\\dir\\basename.ext'
+);
 assert.strictEqual(path.posix.basename('\\basename.ext'), '\\basename.ext');
 assert.strictEqual(path.posix.basename('basename.ext'), 'basename.ext');
 assert.strictEqual(path.posix.basename('basename.ext\\'), 'basename.ext\\');
@@ -66,5 +68,7 @@ assert.strictEqual(path.posix.basename('foo'), 'foo');
 // POSIX filenames may include control characters
 // c.f. http://www.dwheeler.com/essays/fixing-unix-linux-filenames.html
 const controlCharFilename = `Icon${String.fromCharCode(13)}`;
-assert.strictEqual(path.posix.basename(`/a/b/${controlCharFilename}`),
-                   controlCharFilename);
+assert.strictEqual(
+  path.posix.basename(`/a/b/${controlCharFilename}`),
+  controlCharFilename
+);
diff --git a/test/parallel/test-path-dirname.js b/test/parallel/test-path-dirname.js
index 6ecb5c93b4db74..a1018b82c6c025 100644
--- a/test/parallel/test-path-dirname.js
+++ b/test/parallel/test-path-dirname.js
@@ -3,8 +3,10 @@ const common = require('../common');
 const assert = require('assert');
 const path = require('path');
 
-assert.strictEqual(path.dirname(__filename).substr(-13),
-                   common.isWindows ? 'test\\parallel' : 'test/parallel');
+assert.strictEqual(
+  path.dirname(__filename).substr(-13),
+  common.isWindows ? 'test\\parallel' : 'test/parallel'
+);
 
 assert.strictEqual(path.posix.dirname('/a/b/'), '/a');
 assert.strictEqual(path.posix.dirname('/a/b'), '/a');
@@ -35,18 +37,27 @@ assert.strictEqual(path.win32.dirname('c:foo\\bar\\'), 'c:foo');
 assert.strictEqual(path.win32.dirname('c:foo\\bar\\baz'), 'c:foo\\bar');
 assert.strictEqual(path.win32.dirname('file:stream'), '.');
 assert.strictEqual(path.win32.dirname('dir\\file:stream'), 'dir');
-assert.strictEqual(path.win32.dirname('\\\\unc\\share'),
-                   '\\\\unc\\share');
-assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo'),
-                   '\\\\unc\\share\\');
-assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\'),
-                   '\\\\unc\\share\\');
-assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar'),
-                   '\\\\unc\\share\\foo');
-assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar\\'),
-                   '\\\\unc\\share\\foo');
-assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar\\baz'),
-                   '\\\\unc\\share\\foo\\bar');
+assert.strictEqual(path.win32.dirname('\\\\unc\\share'), '\\\\unc\\share');
+assert.strictEqual(
+  path.win32.dirname('\\\\unc\\share\\foo'),
+  '\\\\unc\\share\\'
+);
+assert.strictEqual(
+  path.win32.dirname('\\\\unc\\share\\foo\\'),
+  '\\\\unc\\share\\'
+);
+assert.strictEqual(
+  path.win32.dirname('\\\\unc\\share\\foo\\bar'),
+  '\\\\unc\\share\\foo'
+);
+assert.strictEqual(
+  path.win32.dirname('\\\\unc\\share\\foo\\bar\\'),
+  '\\\\unc\\share\\foo'
+);
+assert.strictEqual(
+  path.win32.dirname('\\\\unc\\share\\foo\\bar\\baz'),
+  '\\\\unc\\share\\foo\\bar'
+);
 assert.strictEqual(path.win32.dirname('/a/b/'), '/a');
 assert.strictEqual(path.win32.dirname('/a/b'), '/a');
 assert.strictEqual(path.win32.dirname('/a'), '/');
diff --git a/test/parallel/test-path-extname.js b/test/parallel/test-path-extname.js
index 47b327d370d78e..88ef2c6be6e1b2 100644
--- a/test/parallel/test-path-extname.js
+++ b/test/parallel/test-path-extname.js
@@ -49,7 +49,7 @@ const slashRE = /\//g;
   ['file/', ''],
   ['file//', ''],
   ['file./', '.'],
-  ['file.//', '.'],
+  ['file.//', '.']
 ].forEach((test) => {
   const expected = test[1];
   [path.posix.extname, path.win32.extname].forEach((extname) => {
@@ -62,18 +62,22 @@ const slashRE = /\//g;
       os = 'posix';
     }
     const actual = extname(input);
-    const message = `path.${os}.extname(${JSON.stringify(input)})\n  expect=${
-      JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
-    if (actual !== expected)
-      failures.push(`\n${message}`);
+    const message = `path.${os}.extname(${JSON.stringify(
+      input
+    )})\n  expect=${JSON.stringify(expected)}\n  actual=${JSON.stringify(
+      actual
+    )}`;
+    if (actual !== expected) failures.push(`\n${message}`);
   });
   {
     const input = `C:${test[0].replace(slashRE, '\\')}`;
     const actual = path.win32.extname(input);
-    const message = `path.win32.extname(${JSON.stringify(input)})\n  expect=${
-      JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
-    if (actual !== expected)
-      failures.push(`\n${message}`);
+    const message = `path.win32.extname(${JSON.stringify(
+      input
+    )})\n  expect=${JSON.stringify(expected)}\n  actual=${JSON.stringify(
+      actual
+    )}`;
+    if (actual !== expected) failures.push(`\n${message}`);
   }
 });
 assert.strictEqual(failures.length, 0, failures.join(''));
diff --git a/test/parallel/test-path-join.js b/test/parallel/test-path-join.js
index 691ba98f9bc095..1b23fa91d18bdd 100644
--- a/test/parallel/test-path-join.js
+++ b/test/parallel/test-path-join.js
@@ -7,55 +7,57 @@ const failures = [];
 const backslashRE = /\\/g;
 
 const joinTests = [
-  [ [path.posix.join, path.win32.join],
+  [
+    [path.posix.join, path.win32.join],
     // arguments                     result
-    [[['.', 'x/b', '..', '/b/c.js'], 'x/b/c.js'],
-     [[], '.'],
-     [['/.', 'x/b', '..', '/b/c.js'], '/x/b/c.js'],
-     [['/foo', '../../../bar'], '/bar'],
-     [['foo', '../../../bar'], '../../bar'],
-     [['foo/', '../../../bar'], '../../bar'],
-     [['foo/x', '../../../bar'], '../bar'],
-     [['foo/x', './bar'], 'foo/x/bar'],
-     [['foo/x/', './bar'], 'foo/x/bar'],
-     [['foo/x/', '.', 'bar'], 'foo/x/bar'],
-     [['./'], './'],
-     [['.', './'], './'],
-     [['.', '.', '.'], '.'],
-     [['.', './', '.'], '.'],
-     [['.', '/./', '.'], '.'],
-     [['.', '/////./', '.'], '.'],
-     [['.'], '.'],
-     [['', '.'], '.'],
-     [['', 'foo'], 'foo'],
-     [['foo', '/bar'], 'foo/bar'],
-     [['', '/foo'], '/foo'],
-     [['', '', '/foo'], '/foo'],
-     [['', '', 'foo'], 'foo'],
-     [['foo', ''], 'foo'],
-     [['foo/', ''], 'foo/'],
-     [['foo', '', '/bar'], 'foo/bar'],
-     [['./', '..', '/foo'], '../foo'],
-     [['./', '..', '..', '/foo'], '../../foo'],
-     [['.', '..', '..', '/foo'], '../../foo'],
-     [['', '..', '..', '/foo'], '../../foo'],
-     [['/'], '/'],
-     [['/', '.'], '/'],
-     [['/', '..'], '/'],
-     [['/', '..', '..'], '/'],
-     [[''], '.'],
-     [['', ''], '.'],
-     [[' /foo'], ' /foo'],
-     [[' ', 'foo'], ' /foo'],
-     [[' ', '.'], ' '],
-     [[' ', '/'], ' /'],
-     [[' ', ''], ' '],
-     [['/', 'foo'], '/foo'],
-     [['/', '/foo'], '/foo'],
-     [['/', '//foo'], '/foo'],
-     [['/', '', '/foo'], '/foo'],
-     [['', '/', 'foo'], '/foo'],
-     [['', '/', '/foo'], '/foo']
+    [
+      [['.', 'x/b', '..', '/b/c.js'], 'x/b/c.js'],
+      [[], '.'],
+      [['/.', 'x/b', '..', '/b/c.js'], '/x/b/c.js'],
+      [['/foo', '../../../bar'], '/bar'],
+      [['foo', '../../../bar'], '../../bar'],
+      [['foo/', '../../../bar'], '../../bar'],
+      [['foo/x', '../../../bar'], '../bar'],
+      [['foo/x', './bar'], 'foo/x/bar'],
+      [['foo/x/', './bar'], 'foo/x/bar'],
+      [['foo/x/', '.', 'bar'], 'foo/x/bar'],
+      [['./'], './'],
+      [['.', './'], './'],
+      [['.', '.', '.'], '.'],
+      [['.', './', '.'], '.'],
+      [['.', '/./', '.'], '.'],
+      [['.', '/////./', '.'], '.'],
+      [['.'], '.'],
+      [['', '.'], '.'],
+      [['', 'foo'], 'foo'],
+      [['foo', '/bar'], 'foo/bar'],
+      [['', '/foo'], '/foo'],
+      [['', '', '/foo'], '/foo'],
+      [['', '', 'foo'], 'foo'],
+      [['foo', ''], 'foo'],
+      [['foo/', ''], 'foo/'],
+      [['foo', '', '/bar'], 'foo/bar'],
+      [['./', '..', '/foo'], '../foo'],
+      [['./', '..', '..', '/foo'], '../../foo'],
+      [['.', '..', '..', '/foo'], '../../foo'],
+      [['', '..', '..', '/foo'], '../../foo'],
+      [['/'], '/'],
+      [['/', '.'], '/'],
+      [['/', '..'], '/'],
+      [['/', '..', '..'], '/'],
+      [[''], '.'],
+      [['', ''], '.'],
+      [[' /foo'], ' /foo'],
+      [[' ', 'foo'], ' /foo'],
+      [[' ', '.'], ' '],
+      [[' ', '/'], ' /'],
+      [[' ', ''], ' '],
+      [['/', 'foo'], '/foo'],
+      [['/', '/foo'], '/foo'],
+      [['/', '//foo'], '/foo'],
+      [['/', '', '/foo'], '/foo'],
+      [['', '/', 'foo'], '/foo'],
+      [['', '/', '/foo'], '/foo']
     ]
   ]
 ];
@@ -63,59 +65,57 @@ const joinTests = [
 // Windows-specific join tests
 joinTests.push([
   path.win32.join,
-  joinTests[0][1].slice(0).concat(
-    [// arguments                     result
-      // UNC path expected
-      [['//foo/bar'], '\\\\foo\\bar\\'],
-      [['\\/foo/bar'], '\\\\foo\\bar\\'],
-      [['\\\\foo/bar'], '\\\\foo\\bar\\'],
-      // UNC path expected - server and share separate
-      [['//foo', 'bar'], '\\\\foo\\bar\\'],
-      [['//foo/', 'bar'], '\\\\foo\\bar\\'],
-      [['//foo', '/bar'], '\\\\foo\\bar\\'],
-      // UNC path expected - questionable
-      [['//foo', '', 'bar'], '\\\\foo\\bar\\'],
-      [['//foo/', '', 'bar'], '\\\\foo\\bar\\'],
-      [['//foo/', '', '/bar'], '\\\\foo\\bar\\'],
-      // UNC path expected - even more questionable
-      [['', '//foo', 'bar'], '\\\\foo\\bar\\'],
-      [['', '//foo/', 'bar'], '\\\\foo\\bar\\'],
-      [['', '//foo/', '/bar'], '\\\\foo\\bar\\'],
-      // No UNC path expected (no double slash in first component)
-      [['\\', 'foo/bar'], '\\foo\\bar'],
-      [['\\', '/foo/bar'], '\\foo\\bar'],
-      [['', '/', '/foo/bar'], '\\foo\\bar'],
-      // No UNC path expected (no non-slashes in first component -
-      // questionable)
-      [['//', 'foo/bar'], '\\foo\\bar'],
-      [['//', '/foo/bar'], '\\foo\\bar'],
-      [['\\\\', '/', '/foo/bar'], '\\foo\\bar'],
-      [['//'], '/'],
-      // No UNC path expected (share name missing - questionable).
-      [['//foo'], '\\foo'],
-      [['//foo/'], '\\foo\\'],
-      [['//foo', '/'], '\\foo\\'],
-      [['//foo', '', '/'], '\\foo\\'],
-      // No UNC path expected (too many leading slashes - questionable)
-      [['///foo/bar'], '\\foo\\bar'],
-      [['////foo', 'bar'], '\\foo\\bar'],
-      [['\\\\\\/foo/bar'], '\\foo\\bar'],
-      // Drive-relative vs drive-absolute paths. This merely describes the
-      // status quo, rather than being obviously right
-      [['c:'], 'c:.'],
-      [['c:.'], 'c:.'],
-      [['c:', ''], 'c:.'],
-      [['', 'c:'], 'c:.'],
-      [['c:.', '/'], 'c:.\\'],
-      [['c:.', 'file'], 'c:file'],
-      [['c:', '/'], 'c:\\'],
-      [['c:', 'file'], 'c:\\file']
-    ]
-  )
+  joinTests[0][1].slice(0).concat([
+    // arguments                     result
+    // UNC path expected
+    [['//foo/bar'], '\\\\foo\\bar\\'],
+    [['\\/foo/bar'], '\\\\foo\\bar\\'],
+    [['\\\\foo/bar'], '\\\\foo\\bar\\'],
+    // UNC path expected - server and share separate
+    [['//foo', 'bar'], '\\\\foo\\bar\\'],
+    [['//foo/', 'bar'], '\\\\foo\\bar\\'],
+    [['//foo', '/bar'], '\\\\foo\\bar\\'],
+    // UNC path expected - questionable
+    [['//foo', '', 'bar'], '\\\\foo\\bar\\'],
+    [['//foo/', '', 'bar'], '\\\\foo\\bar\\'],
+    [['//foo/', '', '/bar'], '\\\\foo\\bar\\'],
+    // UNC path expected - even more questionable
+    [['', '//foo', 'bar'], '\\\\foo\\bar\\'],
+    [['', '//foo/', 'bar'], '\\\\foo\\bar\\'],
+    [['', '//foo/', '/bar'], '\\\\foo\\bar\\'],
+    // No UNC path expected (no double slash in first component)
+    [['\\', 'foo/bar'], '\\foo\\bar'],
+    [['\\', '/foo/bar'], '\\foo\\bar'],
+    [['', '/', '/foo/bar'], '\\foo\\bar'],
+    // No UNC path expected (no non-slashes in first component -
+    // questionable)
+    [['//', 'foo/bar'], '\\foo\\bar'],
+    [['//', '/foo/bar'], '\\foo\\bar'],
+    [['\\\\', '/', '/foo/bar'], '\\foo\\bar'],
+    [['//'], '/'],
+    // No UNC path expected (share name missing - questionable).
+    [['//foo'], '\\foo'],
+    [['//foo/'], '\\foo\\'],
+    [['//foo', '/'], '\\foo\\'],
+    [['//foo', '', '/'], '\\foo\\'],
+    // No UNC path expected (too many leading slashes - questionable)
+    [['///foo/bar'], '\\foo\\bar'],
+    [['////foo', 'bar'], '\\foo\\bar'],
+    [['\\\\\\/foo/bar'], '\\foo\\bar'],
+    // Drive-relative vs drive-absolute paths. This merely describes the
+    // status quo, rather than being obviously right
+    [['c:'], 'c:.'],
+    [['c:.'], 'c:.'],
+    [['c:', ''], 'c:.'],
+    [['', 'c:'], 'c:.'],
+    [['c:.', '/'], 'c:.\\'],
+    [['c:.', 'file'], 'c:file'],
+    [['c:', '/'], 'c:\\'],
+    [['c:', 'file'], 'c:\\file']
+  ])
 ]);
 joinTests.forEach((test) => {
-  if (!Array.isArray(test[0]))
-    test[0] = [test[0]];
+  if (!Array.isArray(test[0])) test[0] = [test[0]];
   test[0].forEach((join) => {
     test[1].forEach((test) => {
       const actual = join.apply(null, test[0]);
@@ -131,9 +131,11 @@ joinTests.forEach((test) => {
       } else {
         os = 'posix';
       }
-      const message =
-        `path.${os}.join(${test[0].map(JSON.stringify).join(',')})\n  expect=${
-          JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+      const message = `path.${os}.join(${test[0]
+        .map(JSON.stringify)
+        .join(',')})\n  expect=${JSON.stringify(
+        expected
+      )}\n  actual=${JSON.stringify(actual)}`;
       if (actual !== expected && actualAlt !== expected)
         failures.push(`\n${message}`);
     });
diff --git a/test/parallel/test-path-makelong.js b/test/parallel/test-path-makelong.js
index 01c81b47502f4e..aa31a790c586f3 100644
--- a/test/parallel/test-path-makelong.js
+++ b/test/parallel/test-path-makelong.js
@@ -29,18 +29,23 @@ if (common.isWindows) {
   const file = fixtures.path('a.js');
   const resolvedFile = path.resolve(file);
 
-  assert.strictEqual(path.toNamespacedPath(file),
-                     `\\\\?\\${resolvedFile}`);
-  assert.strictEqual(path.toNamespacedPath(`\\\\?\\${file}`),
-                     `\\\\?\\${resolvedFile}`);
-  assert.strictEqual(path.toNamespacedPath(
-    '\\\\someserver\\someshare\\somefile'),
-                     '\\\\?\\UNC\\someserver\\someshare\\somefile');
-  assert.strictEqual(path.toNamespacedPath(
-    '\\\\?\\UNC\\someserver\\someshare\\somefile'),
-                     '\\\\?\\UNC\\someserver\\someshare\\somefile');
-  assert.strictEqual(path.toNamespacedPath('\\\\.\\pipe\\somepipe'),
-                     '\\\\.\\pipe\\somepipe');
+  assert.strictEqual(path.toNamespacedPath(file), `\\\\?\\${resolvedFile}`);
+  assert.strictEqual(
+    path.toNamespacedPath(`\\\\?\\${file}`),
+    `\\\\?\\${resolvedFile}`
+  );
+  assert.strictEqual(
+    path.toNamespacedPath('\\\\someserver\\someshare\\somefile'),
+    '\\\\?\\UNC\\someserver\\someshare\\somefile'
+  );
+  assert.strictEqual(
+    path.toNamespacedPath('\\\\?\\UNC\\someserver\\someshare\\somefile'),
+    '\\\\?\\UNC\\someserver\\someshare\\somefile'
+  );
+  assert.strictEqual(
+    path.toNamespacedPath('\\\\.\\pipe\\somepipe'),
+    '\\\\.\\pipe\\somepipe'
+  );
 }
 
 assert.strictEqual(path.toNamespacedPath(null), null);
@@ -60,23 +65,34 @@ assert.strictEqual(path.posix.toNamespacedPath(emptyObj), emptyObj);
 if (common.isWindows) {
   // These tests cause resolve() to insert the cwd, so we cannot test them from
   // non-Windows platforms (easily)
-  assert.strictEqual(path.win32.toNamespacedPath('foo\\bar').toLowerCase(),
-                     `\\\\?\\${process.cwd().toLowerCase()}\\foo\\bar`);
-  assert.strictEqual(path.win32.toNamespacedPath('foo/bar').toLowerCase(),
-                     `\\\\?\\${process.cwd().toLowerCase()}\\foo\\bar`);
+  assert.strictEqual(
+    path.win32.toNamespacedPath('foo\\bar').toLowerCase(),
+    `\\\\?\\${process.cwd().toLowerCase()}\\foo\\bar`
+  );
+  assert.strictEqual(
+    path.win32.toNamespacedPath('foo/bar').toLowerCase(),
+    `\\\\?\\${process.cwd().toLowerCase()}\\foo\\bar`
+  );
   const currentDeviceLetter = path.parse(process.cwd()).root.substring(0, 2);
   assert.strictEqual(
     path.win32.toNamespacedPath(currentDeviceLetter).toLowerCase(),
-    `\\\\?\\${process.cwd().toLowerCase()}`);
-  assert.strictEqual(path.win32.toNamespacedPath('C').toLowerCase(),
-                     `\\\\?\\${process.cwd().toLowerCase()}\\c`);
+    `\\\\?\\${process.cwd().toLowerCase()}`
+  );
+  assert.strictEqual(
+    path.win32.toNamespacedPath('C').toLowerCase(),
+    `\\\\?\\${process.cwd().toLowerCase()}\\c`
+  );
 }
 assert.strictEqual(path.win32.toNamespacedPath('C:\\foo'), '\\\\?\\C:\\foo');
 assert.strictEqual(path.win32.toNamespacedPath('C:/foo'), '\\\\?\\C:\\foo');
-assert.strictEqual(path.win32.toNamespacedPath('\\\\foo\\bar'),
-                   '\\\\?\\UNC\\foo\\bar\\');
-assert.strictEqual(path.win32.toNamespacedPath('//foo//bar'),
-                   '\\\\?\\UNC\\foo\\bar\\');
+assert.strictEqual(
+  path.win32.toNamespacedPath('\\\\foo\\bar'),
+  '\\\\?\\UNC\\foo\\bar\\'
+);
+assert.strictEqual(
+  path.win32.toNamespacedPath('//foo//bar'),
+  '\\\\?\\UNC\\foo\\bar\\'
+);
 assert.strictEqual(path.win32.toNamespacedPath('\\\\?\\foo'), '\\\\?\\foo');
 assert.strictEqual(path.win32.toNamespacedPath(null), null);
 assert.strictEqual(path.win32.toNamespacedPath(true), true);
diff --git a/test/parallel/test-path-normalize.js b/test/parallel/test-path-normalize.js
index e1d3b9ce1e6c02..f8f314dcea9a8d 100644
--- a/test/parallel/test-path-normalize.js
+++ b/test/parallel/test-path-normalize.js
@@ -3,19 +3,25 @@ require('../common');
 const assert = require('assert');
 const path = require('path');
 
-assert.strictEqual(path.win32.normalize('./fixtures///b/../b/c.js'),
-                   'fixtures\\b\\c.js');
+assert.strictEqual(
+  path.win32.normalize('./fixtures///b/../b/c.js'),
+  'fixtures\\b\\c.js'
+);
 assert.strictEqual(path.win32.normalize('/foo/../../../bar'), '\\bar');
 assert.strictEqual(path.win32.normalize('a//b//../b'), 'a\\b');
 assert.strictEqual(path.win32.normalize('a//b//./c'), 'a\\b\\c');
 assert.strictEqual(path.win32.normalize('a//b//.'), 'a\\b');
-assert.strictEqual(path.win32.normalize('//server/share/dir/file.ext'),
-                   '\\\\server\\share\\dir\\file.ext');
+assert.strictEqual(
+  path.win32.normalize('//server/share/dir/file.ext'),
+  '\\\\server\\share\\dir\\file.ext'
+);
 assert.strictEqual(path.win32.normalize('/a/b/c/../../../x/y/z'), '\\x\\y\\z');
 assert.strictEqual(path.win32.normalize('C:'), 'C:.');
 assert.strictEqual(path.win32.normalize('C:..\\abc'), 'C:..\\abc');
-assert.strictEqual(path.win32.normalize('C:..\\..\\abc\\..\\def'),
-                   'C:..\\..\\def');
+assert.strictEqual(
+  path.win32.normalize('C:..\\..\\abc\\..\\def'),
+  'C:..\\..\\def'
+);
 assert.strictEqual(path.win32.normalize('C:\\.'), 'C:\\');
 assert.strictEqual(path.win32.normalize('file:stream'), 'file:stream');
 assert.strictEqual(path.win32.normalize('bar\\foo..\\..\\'), 'bar\\');
@@ -23,14 +29,22 @@ assert.strictEqual(path.win32.normalize('bar\\foo..\\..'), 'bar');
 assert.strictEqual(path.win32.normalize('bar\\foo..\\..\\baz'), 'bar\\baz');
 assert.strictEqual(path.win32.normalize('bar\\foo..\\'), 'bar\\foo..\\');
 assert.strictEqual(path.win32.normalize('bar\\foo..'), 'bar\\foo..');
-assert.strictEqual(path.win32.normalize('..\\foo..\\..\\..\\bar'),
-                   '..\\..\\bar');
-assert.strictEqual(path.win32.normalize('..\\...\\..\\.\\...\\..\\..\\bar'),
-                   '..\\..\\bar');
-assert.strictEqual(path.win32.normalize('../../../foo/../../../bar'),
-                   '..\\..\\..\\..\\..\\bar');
-assert.strictEqual(path.win32.normalize('../../../foo/../../../bar/../../'),
-                   '..\\..\\..\\..\\..\\..\\');
+assert.strictEqual(
+  path.win32.normalize('..\\foo..\\..\\..\\bar'),
+  '..\\..\\bar'
+);
+assert.strictEqual(
+  path.win32.normalize('..\\...\\..\\.\\...\\..\\..\\bar'),
+  '..\\..\\bar'
+);
+assert.strictEqual(
+  path.win32.normalize('../../../foo/../../../bar'),
+  '..\\..\\..\\..\\..\\bar'
+);
+assert.strictEqual(
+  path.win32.normalize('../../../foo/../../../bar/../../'),
+  '..\\..\\..\\..\\..\\..\\'
+);
 assert.strictEqual(
   path.win32.normalize('../foobar/barfoo/foo/../../../bar/../../'),
   '..\\..\\'
@@ -41,8 +55,10 @@ assert.strictEqual(
 );
 assert.strictEqual(path.win32.normalize('foo/bar\\baz'), 'foo\\bar\\baz');
 
-assert.strictEqual(path.posix.normalize('./fixtures///b/../b/c.js'),
-                   'fixtures/b/c.js');
+assert.strictEqual(
+  path.posix.normalize('./fixtures///b/../b/c.js'),
+  'fixtures/b/c.js'
+);
 assert.strictEqual(path.posix.normalize('/foo/../../../bar'), '/bar');
 assert.strictEqual(path.posix.normalize('a//b//../b'), 'a/b');
 assert.strictEqual(path.posix.normalize('a//b//./c'), 'a/b/c');
@@ -55,12 +71,18 @@ assert.strictEqual(path.posix.normalize('bar/foo../../baz'), 'bar/baz');
 assert.strictEqual(path.posix.normalize('bar/foo../'), 'bar/foo../');
 assert.strictEqual(path.posix.normalize('bar/foo..'), 'bar/foo..');
 assert.strictEqual(path.posix.normalize('../foo../../../bar'), '../../bar');
-assert.strictEqual(path.posix.normalize('../.../.././.../../../bar'),
-                   '../../bar');
-assert.strictEqual(path.posix.normalize('../../../foo/../../../bar'),
-                   '../../../../../bar');
-assert.strictEqual(path.posix.normalize('../../../foo/../../../bar/../../'),
-                   '../../../../../../');
+assert.strictEqual(
+  path.posix.normalize('../.../.././.../../../bar'),
+  '../../bar'
+);
+assert.strictEqual(
+  path.posix.normalize('../../../foo/../../../bar'),
+  '../../../../../bar'
+);
+assert.strictEqual(
+  path.posix.normalize('../../../foo/../../../bar/../../'),
+  '../../../../../../'
+);
 assert.strictEqual(
   path.posix.normalize('../foobar/barfoo/foo/../../../bar/../../'),
   '../../'
diff --git a/test/parallel/test-path-parse-format.js b/test/parallel/test-path-parse-format.js
index c50093301f1edf..5167747d93b3c1 100644
--- a/test/parallel/test-path-parse-format.js
+++ b/test/parallel/test-path-parse-format.js
@@ -39,20 +39,20 @@ const winPaths = [
   ['C:..', 'C:'],
   ['C:abc', 'C:'],
   ['C:\\', 'C:\\'],
-  ['C:\\abc', 'C:\\' ],
+  ['C:\\abc', 'C:\\'],
   ['', ''],
 
   // unc
   ['\\\\server\\share\\file_path', '\\\\server\\share\\'],
-  ['\\\\server two\\shared folder\\file path.zip',
-   '\\\\server two\\shared folder\\'],
+  [
+    '\\\\server two\\shared folder\\file path.zip',
+    '\\\\server two\\shared folder\\'
+  ],
   ['\\\\teela\\admin$\\system32', '\\\\teela\\admin$\\'],
   ['\\\\?\\UNC\\server\\share', '\\\\?\\UNC\\']
 ];
 
-const winSpecialCaseParseTests = [
-  ['/foo/bar', { root: '/' }],
-];
+const winSpecialCaseParseTests = [['/foo/bar', { root: '/' }]];
 
 const winSpecialCaseFormatTests = [
   [{ dir: 'some\\dir' }, 'some\\dir\\'],
@@ -98,10 +98,13 @@ const unixSpecialCaseFormatTests = [
   [{}, '']
 ];
 
-const expectedMessage = common.expectsError({
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError
-}, 18);
+const expectedMessage = common.expectsError(
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  },
+  18
+);
 
 const errors = [
   { method: 'parse', input: [null], message: expectedMessage },
@@ -112,7 +115,7 @@ const errors = [
   { method: 'format', input: [null], message: expectedMessage },
   { method: 'format', input: [''], message: expectedMessage },
   { method: 'format', input: [true], message: expectedMessage },
-  { method: 'format', input: [1], message: expectedMessage },
+  { method: 'format', input: [1], message: expectedMessage }
 ];
 
 checkParseFormat(path.win32, winPaths);
@@ -125,30 +128,39 @@ checkFormat(path.posix, unixSpecialCaseFormatTests);
 
 // Test removal of trailing path separators
 const trailingTests = [
-  [ path.win32.parse,
-    [['.\\', { root: '', dir: '', base: '.', ext: '', name: '.' }],
-     ['\\\\', { root: '\\', dir: '\\', base: '', ext: '', name: '' }],
-     ['\\\\', { root: '\\', dir: '\\', base: '', ext: '', name: '' }],
-     ['c:\\foo\\\\\\',
-      { root: 'c:\\', dir: 'c:\\', base: 'foo', ext: '', name: 'foo' }],
-     ['D:\\foo\\\\\\bar.baz',
-      { root: 'D:\\',
-        dir: 'D:\\foo\\\\',
-        base: 'bar.baz',
-        ext: '.baz',
-        name: 'bar'
-      }
-     ]
+  [
+    path.win32.parse,
+    [
+      ['.\\', { root: '', dir: '', base: '.', ext: '', name: '.' }],
+      ['\\\\', { root: '\\', dir: '\\', base: '', ext: '', name: '' }],
+      ['\\\\', { root: '\\', dir: '\\', base: '', ext: '', name: '' }],
+      [
+        'c:\\foo\\\\\\',
+        { root: 'c:\\', dir: 'c:\\', base: 'foo', ext: '', name: 'foo' }
+      ],
+      [
+        'D:\\foo\\\\\\bar.baz',
+        {
+          root: 'D:\\',
+          dir: 'D:\\foo\\\\',
+          base: 'bar.baz',
+          ext: '.baz',
+          name: 'bar'
+        }
+      ]
     ]
   ],
-  [ path.posix.parse,
-    [['./', { root: '', dir: '', base: '.', ext: '', name: '.' }],
-     ['//', { root: '/', dir: '/', base: '', ext: '', name: '' }],
-     ['///', { root: '/', dir: '/', base: '', ext: '', name: '' }],
-     ['/foo///', { root: '/', dir: '/', base: 'foo', ext: '', name: 'foo' }],
-     ['/foo///bar.baz',
-      { root: '/', dir: '/foo//', base: 'bar.baz', ext: '.baz', name: 'bar' }
-     ]
+  [
+    path.posix.parse,
+    [
+      ['./', { root: '', dir: '', base: '.', ext: '', name: '.' }],
+      ['//', { root: '/', dir: '/', base: '', ext: '', name: '' }],
+      ['///', { root: '/', dir: '/', base: '', ext: '', name: '' }],
+      ['/foo///', { root: '/', dir: '/', base: 'foo', ext: '', name: 'foo' }],
+      [
+        '/foo///bar.baz',
+        { root: '/', dir: '/foo//', base: 'bar.baz', ext: '.baz', name: 'bar' }
+      ]
     ]
   ]
 ];
@@ -159,11 +171,14 @@ trailingTests.forEach(function(test) {
   test[1].forEach(function(test) {
     const actual = parse(test[0]);
     const expected = test[1];
-    const message = `path.${os}.parse(${JSON.stringify(test[0])})\n  expect=${
-      JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+    const message = `path.${os}.parse(${JSON.stringify(
+      test[0]
+    )})\n  expect=${JSON.stringify(expected)}\n  actual=${JSON.stringify(
+      actual
+    )}`;
     const actualKeys = Object.keys(actual);
     const expectedKeys = Object.keys(expected);
-    let failed = (actualKeys.length !== expectedKeys.length);
+    let failed = actualKeys.length !== expectedKeys.length;
     if (!failed) {
       for (let i = 0; i < actualKeys.length; ++i) {
         const key = actualKeys[i];
@@ -173,8 +188,7 @@ trailingTests.forEach(function(test) {
         }
       }
     }
-    if (failed)
-      failures.push(`\n${message}`);
+    if (failed) failures.push(`\n${message}`);
   });
 });
 assert.strictEqual(failures.length, 0, failures.join(''));
@@ -221,13 +235,17 @@ function checkFormat(path, testCases) {
   });
 
   [null, undefined, 1, true, false, 'string'].forEach((pathObject) => {
-    common.expectsError(() => {
-      path.format(pathObject);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "pathObject" argument must be of type Object. ' +
-               `Received type ${typeof pathObject}`
-    });
+    common.expectsError(
+      () => {
+        path.format(pathObject);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "pathObject" argument must be of type Object. ' +
+          `Received type ${typeof pathObject}`
+      }
+    );
   });
 }
diff --git a/test/parallel/test-path-relative.js b/test/parallel/test-path-relative.js
index bd2c3f75a52dd2..1fcf01a9a2d031 100644
--- a/test/parallel/test-path-relative.js
+++ b/test/parallel/test-path-relative.js
@@ -6,48 +6,56 @@ const path = require('path');
 const failures = [];
 
 const relativeTests = [
-  [ path.win32.relative,
+  [
+    path.win32.relative,
     // arguments                     result
-    [['c:/blah\\blah', 'd:/games', 'd:\\games'],
-     ['c:/aaaa/bbbb', 'c:/aaaa', '..'],
-     ['c:/aaaa/bbbb', 'c:/cccc', '..\\..\\cccc'],
-     ['c:/aaaa/bbbb', 'c:/aaaa/bbbb', ''],
-     ['c:/aaaa/bbbb', 'c:/aaaa/cccc', '..\\cccc'],
-     ['c:/aaaa/', 'c:/aaaa/cccc', 'cccc'],
-     ['c:/', 'c:\\aaaa\\bbbb', 'aaaa\\bbbb'],
-     ['c:/aaaa/bbbb', 'd:\\', 'd:\\'],
-     ['c:/AaAa/bbbb', 'c:/aaaa/bbbb', ''],
-     ['c:/aaaaa/', 'c:/aaaa/cccc', '..\\aaaa\\cccc'],
-     ['C:\\foo\\bar\\baz\\quux', 'C:\\', '..\\..\\..\\..'],
-     ['C:\\foo\\test', 'C:\\foo\\test\\bar\\package.json', 'bar\\package.json'],
-     ['C:\\foo\\bar\\baz-quux', 'C:\\foo\\bar\\baz', '..\\baz'],
-     ['C:\\foo\\bar\\baz', 'C:\\foo\\bar\\baz-quux', '..\\baz-quux'],
-     ['\\\\foo\\bar', '\\\\foo\\bar\\baz', 'baz'],
-     ['\\\\foo\\bar\\baz', '\\\\foo\\bar', '..'],
-     ['\\\\foo\\bar\\baz-quux', '\\\\foo\\bar\\baz', '..\\baz'],
-     ['\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz-quux', '..\\baz-quux'],
-     ['C:\\baz-quux', 'C:\\baz', '..\\baz'],
-     ['C:\\baz', 'C:\\baz-quux', '..\\baz-quux'],
-     ['\\\\foo\\baz-quux', '\\\\foo\\baz', '..\\baz'],
-     ['\\\\foo\\baz', '\\\\foo\\baz-quux', '..\\baz-quux'],
-     ['C:\\baz', '\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz'],
-     ['\\\\foo\\bar\\baz', 'C:\\baz', 'C:\\baz']
+    [
+      ['c:/blah\\blah', 'd:/games', 'd:\\games'],
+      ['c:/aaaa/bbbb', 'c:/aaaa', '..'],
+      ['c:/aaaa/bbbb', 'c:/cccc', '..\\..\\cccc'],
+      ['c:/aaaa/bbbb', 'c:/aaaa/bbbb', ''],
+      ['c:/aaaa/bbbb', 'c:/aaaa/cccc', '..\\cccc'],
+      ['c:/aaaa/', 'c:/aaaa/cccc', 'cccc'],
+      ['c:/', 'c:\\aaaa\\bbbb', 'aaaa\\bbbb'],
+      ['c:/aaaa/bbbb', 'd:\\', 'd:\\'],
+      ['c:/AaAa/bbbb', 'c:/aaaa/bbbb', ''],
+      ['c:/aaaaa/', 'c:/aaaa/cccc', '..\\aaaa\\cccc'],
+      ['C:\\foo\\bar\\baz\\quux', 'C:\\', '..\\..\\..\\..'],
+      [
+        'C:\\foo\\test',
+        'C:\\foo\\test\\bar\\package.json',
+        'bar\\package.json'
+      ],
+      ['C:\\foo\\bar\\baz-quux', 'C:\\foo\\bar\\baz', '..\\baz'],
+      ['C:\\foo\\bar\\baz', 'C:\\foo\\bar\\baz-quux', '..\\baz-quux'],
+      ['\\\\foo\\bar', '\\\\foo\\bar\\baz', 'baz'],
+      ['\\\\foo\\bar\\baz', '\\\\foo\\bar', '..'],
+      ['\\\\foo\\bar\\baz-quux', '\\\\foo\\bar\\baz', '..\\baz'],
+      ['\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz-quux', '..\\baz-quux'],
+      ['C:\\baz-quux', 'C:\\baz', '..\\baz'],
+      ['C:\\baz', 'C:\\baz-quux', '..\\baz-quux'],
+      ['\\\\foo\\baz-quux', '\\\\foo\\baz', '..\\baz'],
+      ['\\\\foo\\baz', '\\\\foo\\baz-quux', '..\\baz-quux'],
+      ['C:\\baz', '\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz'],
+      ['\\\\foo\\bar\\baz', 'C:\\baz', 'C:\\baz']
     ]
   ],
-  [ path.posix.relative,
+  [
+    path.posix.relative,
     // arguments          result
-    [['/var/lib', '/var', '..'],
-     ['/var/lib', '/bin', '../../bin'],
-     ['/var/lib', '/var/lib', ''],
-     ['/var/lib', '/var/apache', '../apache'],
-     ['/var/', '/var/lib', 'lib'],
-     ['/', '/var/lib', 'var/lib'],
-     ['/foo/test', '/foo/test/bar/package.json', 'bar/package.json'],
-     ['/Users/a/web/b/test/mails', '/Users/a/web/b', '../..'],
-     ['/foo/bar/baz-quux', '/foo/bar/baz', '../baz'],
-     ['/foo/bar/baz', '/foo/bar/baz-quux', '../baz-quux'],
-     ['/baz-quux', '/baz', '../baz'],
-     ['/baz', '/baz-quux', '../baz-quux']
+    [
+      ['/var/lib', '/var', '..'],
+      ['/var/lib', '/bin', '../../bin'],
+      ['/var/lib', '/var/lib', ''],
+      ['/var/lib', '/var/apache', '../apache'],
+      ['/var/', '/var/lib', 'lib'],
+      ['/', '/var/lib', 'var/lib'],
+      ['/foo/test', '/foo/test/bar/package.json', 'bar/package.json'],
+      ['/Users/a/web/b/test/mails', '/Users/a/web/b', '../..'],
+      ['/foo/bar/baz-quux', '/foo/bar/baz', '../baz'],
+      ['/foo/bar/baz', '/foo/bar/baz-quux', '../baz-quux'],
+      ['/baz-quux', '/baz', '../baz'],
+      ['/baz', '/baz-quux', '../baz-quux']
     ]
   ]
 ];
@@ -57,11 +65,13 @@ relativeTests.forEach((test) => {
     const actual = relative(test[0], test[1]);
     const expected = test[2];
     const os = relative === path.win32.relative ? 'win32' : 'posix';
-    const message = `path.${os}.relative(${
-      test.slice(0, 2).map(JSON.stringify).join(',')})\n  expect=${
-      JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
-    if (actual !== expected)
-      failures.push(`\n${message}`);
+    const message = `path.${os}.relative(${test
+      .slice(0, 2)
+      .map(JSON.stringify)
+      .join(',')})\n  expect=${JSON.stringify(
+      expected
+    )}\n  actual=${JSON.stringify(actual)}`;
+    if (actual !== expected) failures.push(`\n${message}`);
   });
 });
 assert.strictEqual(failures.length, 0, failures.join(''));
diff --git a/test/parallel/test-path-resolve.js b/test/parallel/test-path-resolve.js
index abbbf4dd5f47b4..d766920de7f9bb 100644
--- a/test/parallel/test-path-resolve.js
+++ b/test/parallel/test-path-resolve.js
@@ -10,31 +10,37 @@ const slashRE = /\//g;
 const backslashRE = /\\/g;
 
 const resolveTests = [
-  [ path.win32.resolve,
+  [
+    path.win32.resolve,
     // arguments                               result
-    [[['c:/blah\\blah', 'd:/games', 'c:../a'], 'c:\\blah\\a'],
-     [['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe'], 'd:\\e.exe'],
-     [['c:/ignore', 'c:/some/file'], 'c:\\some\\file'],
-     [['d:/ignore', 'd:some/dir//'], 'd:\\ignore\\some\\dir'],
-     [['.'], process.cwd()],
-     [['//server/share', '..', 'relative\\'], '\\\\server\\share\\relative'],
-     [['c:/', '//'], 'c:\\'],
-     [['c:/', '//dir'], 'c:\\dir'],
-     [['c:/', '//server/share'], '\\\\server\\share\\'],
-     [['c:/', '//server//share'], '\\\\server\\share\\'],
-     [['c:/', '///some//dir'], 'c:\\some\\dir'],
-     [['C:\\foo\\tmp.3\\', '..\\tmp.3\\cycles\\root.js'],
-      'C:\\foo\\tmp.3\\cycles\\root.js']
+    [
+      [['c:/blah\\blah', 'd:/games', 'c:../a'], 'c:\\blah\\a'],
+      [['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe'], 'd:\\e.exe'],
+      [['c:/ignore', 'c:/some/file'], 'c:\\some\\file'],
+      [['d:/ignore', 'd:some/dir//'], 'd:\\ignore\\some\\dir'],
+      [['.'], process.cwd()],
+      [['//server/share', '..', 'relative\\'], '\\\\server\\share\\relative'],
+      [['c:/', '//'], 'c:\\'],
+      [['c:/', '//dir'], 'c:\\dir'],
+      [['c:/', '//server/share'], '\\\\server\\share\\'],
+      [['c:/', '//server//share'], '\\\\server\\share\\'],
+      [['c:/', '///some//dir'], 'c:\\some\\dir'],
+      [
+        ['C:\\foo\\tmp.3\\', '..\\tmp.3\\cycles\\root.js'],
+        'C:\\foo\\tmp.3\\cycles\\root.js'
+      ]
     ]
   ],
-  [ path.posix.resolve,
+  [
+    path.posix.resolve,
     // arguments                    result
-    [[['/var/lib', '../', 'file/'], '/var/file'],
-     [['/var/lib', '/../', 'file/'], '/file'],
-     [['a/b/c/', '../../..'], process.cwd()],
-     [['.'], process.cwd()],
-     [['/some/dir', '.', '/absolute/'], '/absolute'],
-     [['/foo/tmp.3/', '../tmp.3/cycles/root.js'], '/foo/tmp.3/cycles/root.js']
+    [
+      [['/var/lib', '../', 'file/'], '/var/file'],
+      [['/var/lib', '/../', 'file/'], '/file'],
+      [['a/b/c/', '../../..'], process.cwd()],
+      [['.'], process.cwd()],
+      [['/some/dir', '.', '/absolute/'], '/absolute'],
+      [['/foo/tmp.3/', '../tmp.3/cycles/root.js'], '/foo/tmp.3/cycles/root.js']
     ]
   ]
 ];
@@ -50,9 +56,11 @@ resolveTests.forEach((test) => {
       actualAlt = actual.replace(slashRE, '\\');
 
     const expected = test[1];
-    const message =
-      `path.${os}.resolve(${test[0].map(JSON.stringify).join(',')})\n  expect=${
-        JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+    const message = `path.${os}.resolve(${test[0]
+      .map(JSON.stringify)
+      .join(',')})\n  expect=${JSON.stringify(
+      expected
+    )}\n  actual=${JSON.stringify(actual)}`;
     if (actual !== expected && actualAlt !== expected)
       failures.push(`\n${message}`);
   });
@@ -64,8 +72,10 @@ if (common.isWindows) {
   // See https://github.com/nodejs/node/issues/7215
   const currentDriveLetter = path.parse(process.cwd()).root.substring(0, 2);
   const resolveFixture = fixtures.path('path-resolve.js');
-  const spawnResult = child.spawnSync(
-    process.argv[0], [resolveFixture, currentDriveLetter]);
+  const spawnResult = child.spawnSync(process.argv[0], [
+    resolveFixture,
+    currentDriveLetter
+  ]);
   const resolvedPath = spawnResult.stdout.toString().trim();
   assert.strictEqual(resolvedPath.toLowerCase(), process.cwd().toLowerCase());
 }
diff --git a/test/parallel/test-path.js b/test/parallel/test-path.js
index ca10665b26ffc1..b4e334c3932147 100644
--- a/test/parallel/test-path.js
+++ b/test/parallel/test-path.js
@@ -30,9 +30,12 @@ const typeErrorTests = [true, false, 7, null, {}, undefined, [], NaN];
 function fail(fn) {
   const args = Array.from(arguments).slice(1);
 
-  common.expectsError(() => {
-    fn.apply(null, args);
-  }, { code: 'ERR_INVALID_ARG_TYPE', type: TypeError });
+  common.expectsError(
+    () => {
+      fn.apply(null, args);
+    },
+    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
+  );
 }
 
 typeErrorTests.forEach((test) => {
@@ -67,7 +70,5 @@ assert.strictEqual(path.win32.delimiter, ';');
 // posix
 assert.strictEqual(path.posix.delimiter, ':');
 
-if (common.isWindows)
-  assert.strictEqual(path, path.win32);
-else
-  assert.strictEqual(path, path.posix);
+if (common.isWindows) assert.strictEqual(path, path.win32);
+else assert.strictEqual(path, path.posix);
diff --git a/test/parallel/test-pending-deprecation.js b/test/parallel/test-pending-deprecation.js
index bb11d84bcc0aec..113d8bdbb2b7f7 100644
--- a/test/parallel/test-pending-deprecation.js
+++ b/test/parallel/test-pending-deprecation.js
@@ -14,8 +14,10 @@ const config = process.binding('config');
 const fork = require('child_process').fork;
 
 function message(name) {
-  return `${name} did not set the process.binding('config').` +
-         'pendingDeprecation flag.';
+  return (
+    `${name} did not set the process.binding('config').` +
+    'pendingDeprecation flag.'
+  );
 }
 
 switch (process.argv[2]) {
@@ -32,23 +34,32 @@ switch (process.argv[2]) {
     fork(__filename, ['switch'], {
       execArgv: ['--pending-deprecation'],
       silent: true
-    }).on('exit', common.mustCall((code) => {
-      assert.strictEqual(code, 0, message('--pending-deprecation'));
-    }));
+    }).on(
+      'exit',
+      common.mustCall((code) => {
+        assert.strictEqual(code, 0, message('--pending-deprecation'));
+      })
+    );
 
     // Test the --pending_deprecation command line switch.
     fork(__filename, ['switch'], {
       execArgv: ['--pending_deprecation'],
       silent: true
-    }).on('exit', common.mustCall((code) => {
-      assert.strictEqual(code, 0, message('--pending_deprecation'));
-    }));
+    }).on(
+      'exit',
+      common.mustCall((code) => {
+        assert.strictEqual(code, 0, message('--pending_deprecation'));
+      })
+    );
 
     // Test the NODE_PENDING_DEPRECATION environment var.
     fork(__filename, ['env'], {
       env: Object.assign({}, process.env, { NODE_PENDING_DEPRECATION: 1 }),
       silent: true
-    }).on('exit', common.mustCall((code) => {
-      assert.strictEqual(code, 0, message('NODE_PENDING_DEPRECATION'));
-    }));
+    }).on(
+      'exit',
+      common.mustCall((code) => {
+        assert.strictEqual(code, 0, message('NODE_PENDING_DEPRECATION'));
+      })
+    );
 }
diff --git a/test/parallel/test-performance-function.js b/test/parallel/test-performance-function.js
index 98b381e649b203..25b51f9d13fbcb 100644
--- a/test/parallel/test-performance-function.js
+++ b/test/parallel/test-performance-function.js
@@ -3,25 +3,24 @@
 const common = require('../common');
 const assert = require('assert');
 
-const {
-  performance,
-  PerformanceObserver
-} = require('perf_hooks');
+const { performance, PerformanceObserver } = require('perf_hooks');
 
 {
   // Intentional non-op. Do not wrap in common.mustCall();
   const n = performance.timerify(() => {});
 
-  const obs = new PerformanceObserver(common.mustCall((list) => {
-    const entries = list.getEntries();
-    const entry = entries[0];
-    assert(entry);
-    assert.strictEqual(entry.name, 'performance.timerify');
-    assert.strictEqual(entry.entryType, 'function');
-    assert.strictEqual(typeof entry.duration, 'number');
-    assert.strictEqual(typeof entry.startTime, 'number');
-    obs.disconnect();
-  }));
+  const obs = new PerformanceObserver(
+    common.mustCall((list) => {
+      const entries = list.getEntries();
+      const entry = entries[0];
+      assert(entry);
+      assert.strictEqual(entry.name, 'performance.timerify');
+      assert.strictEqual(entry.entryType, 'function');
+      assert.strictEqual(typeof entry.duration, 'number');
+      assert.strictEqual(typeof entry.startTime, 'number');
+      obs.disconnect();
+    })
+  );
   obs.observe({ entryTypes: ['function'] });
   n();
 }
@@ -42,18 +41,20 @@ const {
   class N {}
   const n = performance.timerify(N);
 
-  const obs = new PerformanceObserver(common.mustCall((list) => {
-    const entries = list.getEntries();
-    const entry = entries[0];
-    assert.strictEqual(entry[0], 1);
-    assert.strictEqual(entry[1], 'abc');
-    assert(entry);
-    assert.strictEqual(entry.name, 'N');
-    assert.strictEqual(entry.entryType, 'function');
-    assert.strictEqual(typeof entry.duration, 'number');
-    assert.strictEqual(typeof entry.startTime, 'number');
-    obs.disconnect();
-  }));
+  const obs = new PerformanceObserver(
+    common.mustCall((list) => {
+      const entries = list.getEntries();
+      const entry = entries[0];
+      assert.strictEqual(entry[0], 1);
+      assert.strictEqual(entry[1], 'abc');
+      assert(entry);
+      assert.strictEqual(entry.name, 'N');
+      assert.strictEqual(entry.entryType, 'function');
+      assert.strictEqual(typeof entry.duration, 'number');
+      assert.strictEqual(typeof entry.startTime, 'number');
+      obs.disconnect();
+    })
+  );
   obs.observe({ entryTypes: ['function'] });
 
   new n(1, 'abc');
@@ -61,13 +62,13 @@ const {
 
 {
   [1, {}, [], null, undefined, Infinity].forEach((input) => {
-    common.expectsError(() => performance.timerify(input),
-                        {
-                          code: 'ERR_INVALID_ARG_TYPE',
-                          type: TypeError,
-                          message: 'The "fn" argument must be of type ' +
-                                   `Function. Received type ${typeof input}`
-                        });
+    common.expectsError(() => performance.timerify(input), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "fn" argument must be of type ' +
+        `Function. Received type ${typeof input}`
+    });
   });
 }
 
diff --git a/test/parallel/test-performance-gc.js b/test/parallel/test-performance-gc.js
index d071cddbcf0b51..b4935875023efa 100644
--- a/test/parallel/test-performance-gc.js
+++ b/test/parallel/test-performance-gc.js
@@ -3,10 +3,7 @@
 
 const common = require('../common');
 const assert = require('assert');
-const {
-  PerformanceObserver,
-  constants
-} = require('perf_hooks');
+const { PerformanceObserver, constants } = require('perf_hooks');
 
 const {
   NODE_PERFORMANCE_GC_MAJOR,
@@ -24,16 +21,18 @@ const kinds = [
 
 // Adding an observer should force at least one gc to appear
 {
-  const obs = new PerformanceObserver(common.mustCallAtLeast((list) => {
-    const entry = list.getEntries()[0];
-    assert(entry);
-    assert.strictEqual(entry.name, 'gc');
-    assert.strictEqual(entry.entryType, 'gc');
-    assert(kinds.includes(entry.kind));
-    assert.strictEqual(typeof entry.startTime, 'number');
-    assert.strictEqual(typeof entry.duration, 'number');
-    obs.disconnect();
-  }));
+  const obs = new PerformanceObserver(
+    common.mustCallAtLeast((list) => {
+      const entry = list.getEntries()[0];
+      assert(entry);
+      assert.strictEqual(entry.name, 'gc');
+      assert.strictEqual(entry.entryType, 'gc');
+      assert(kinds.includes(entry.kind));
+      assert.strictEqual(typeof entry.startTime, 'number');
+      assert.strictEqual(typeof entry.duration, 'number');
+      obs.disconnect();
+    })
+  );
   obs.observe({ entryTypes: ['gc'] });
   global.gc();
   // Keep the event loop alive to witness the GC async callback happen.
diff --git a/test/parallel/test-performanceobserver.js b/test/parallel/test-performanceobserver.js
index 06c1281666bfd5..479bfda68c3aab 100644
--- a/test/parallel/test-performanceobserver.js
+++ b/test/parallel/test-performanceobserver.js
@@ -5,21 +5,15 @@ const common = require('../common');
 const Countdown = require('../common/countdown');
 const assert = require('assert');
 const { internalBinding } = require('internal/test/binding');
-const {
-  observerCounts: counts
-} = internalBinding('performance');
-const {
-  performance,
-  PerformanceObserver,
-  constants
-} = require('perf_hooks');
+const { observerCounts: counts } = internalBinding('performance');
+const { performance, PerformanceObserver, constants } = require('perf_hooks');
 
 const {
   NODE_PERFORMANCE_ENTRY_TYPE_NODE,
   NODE_PERFORMANCE_ENTRY_TYPE_MARK,
   NODE_PERFORMANCE_ENTRY_TYPE_MEASURE,
   NODE_PERFORMANCE_ENTRY_TYPE_GC,
-  NODE_PERFORMANCE_ENTRY_TYPE_FUNCTION,
+  NODE_PERFORMANCE_ENTRY_TYPE_FUNCTION
 } = constants;
 
 assert.strictEqual(counts[NODE_PERFORMANCE_ENTRY_TYPE_NODE], 0);
@@ -30,47 +24,42 @@ assert.strictEqual(counts[NODE_PERFORMANCE_ENTRY_TYPE_FUNCTION], 0);
 
 {
   [1, null, undefined, {}, [], Infinity].forEach((i) => {
-    common.expectsError(() => new PerformanceObserver(i),
-                        {
-                          code: 'ERR_INVALID_CALLBACK',
-                          type: TypeError,
-                          message: 'Callback must be a function'
-                        });
+    common.expectsError(() => new PerformanceObserver(i), {
+      code: 'ERR_INVALID_CALLBACK',
+      type: TypeError,
+      message: 'Callback must be a function'
+    });
   });
   const observer = new PerformanceObserver(common.mustNotCall());
 
   [1, null, undefined].forEach((input) => {
-    common.expectsError(
-      () => observer.observe(input),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        type: TypeError,
-        message: 'The "options" argument must be of type Object. ' +
-                 `Received type ${typeof input}`
-      });
+    common.expectsError(() => observer.observe(input), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "options" argument must be of type Object. ' +
+        `Received type ${typeof input}`
+    });
   });
 
   [1, undefined, null, {}, Infinity].forEach((i) => {
-    common.expectsError(() => observer.observe({ entryTypes: i }),
-                        {
-                          code: 'ERR_INVALID_OPT_VALUE',
-                          type: TypeError,
-                          message: 'The value "[object Object]" is invalid ' +
-                                   'for option "entryTypes"'
-                        });
+    common.expectsError(() => observer.observe({ entryTypes: i }), {
+      code: 'ERR_INVALID_OPT_VALUE',
+      type: TypeError,
+      message:
+        'The value "[object Object]" is invalid ' + 'for option "entryTypes"'
+    });
   });
 }
 
 // Test Non-Buffered
 {
-  const observer =
-    new PerformanceObserver(common.mustCall(callback, 3));
+  const observer = new PerformanceObserver(common.mustCall(callback, 3));
 
-  const countdown =
-    new Countdown(3, () => {
-      observer.disconnect();
-      assert.strictEqual(counts[NODE_PERFORMANCE_ENTRY_TYPE_MARK], 0);
-    });
+  const countdown = new Countdown(3, () => {
+    observer.disconnect();
+    assert.strictEqual(counts[NODE_PERFORMANCE_ENTRY_TYPE_MARK], 0);
+  });
 
   function callback(list, obs) {
     assert.strictEqual(obs, observer);
@@ -86,11 +75,9 @@ assert.strictEqual(counts[NODE_PERFORMANCE_ENTRY_TYPE_FUNCTION], 0);
   performance.mark('test3');
 }
 
-
 // Test Buffered
 {
-  const observer =
-    new PerformanceObserver(common.mustCall(callback, 1));
+  const observer = new PerformanceObserver(common.mustCall(callback, 1));
   assert.strictEqual(counts[NODE_PERFORMANCE_ENTRY_TYPE_MARK], 0);
 
   function callback(list, obs) {
diff --git a/test/parallel/test-pipe-address.js b/test/parallel/test-pipe-address.js
index 3550434932e934..15b0fab9e600c8 100644
--- a/test/parallel/test-pipe-address.js
+++ b/test/parallel/test-pipe-address.js
@@ -7,7 +7,10 @@ const server = net.createServer(common.mustNotCall());
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-server.listen(common.PIPE, common.mustCall(function() {
-  assert.strictEqual(server.address(), common.PIPE);
-  server.close();
-}));
+server.listen(
+  common.PIPE,
+  common.mustCall(function() {
+    assert.strictEqual(server.address(), common.PIPE);
+    server.close();
+  })
+);
diff --git a/test/parallel/test-pipe-file-to-http.js b/test/parallel/test-pipe-file-to-http.js
index 3d326a77a49bc7..92d9cfbc1796cd 100644
--- a/test/parallel/test-pipe-file-to-http.js
+++ b/test/parallel/test-pipe-file-to-http.js
@@ -69,9 +69,12 @@ function makeRequest() {
 
   const s = fs.ReadStream(filename);
   s.pipe(req);
-  s.on('close', common.mustCall((err) => {
-    assert.ifError(err);
-  }));
+  s.on(
+    'close',
+    common.mustCall((err) => {
+      assert.ifError(err);
+    })
+  );
 
   req.on('response', function(res) {
     res.resume();
diff --git a/test/parallel/test-pipe-head.js b/test/parallel/test-pipe-head.js
index cb3d183fcdff20..58acbf2fc79d24 100644
--- a/test/parallel/test-pipe-head.js
+++ b/test/parallel/test-pipe-head.js
@@ -10,8 +10,11 @@ const script = fixtures.path('print-10-lines.js');
 
 const cmd = `"${nodePath}" "${script}" | head -2`;
 
-exec(cmd, common.mustCall(function(err, stdout, stderr) {
-  assert.ifError(err);
-  const lines = stdout.split('\n');
-  assert.strictEqual(lines.length, 3);
-}));
+exec(
+  cmd,
+  common.mustCall(function(err, stdout, stderr) {
+    assert.ifError(err);
+    const lines = stdout.split('\n');
+    assert.strictEqual(lines.length, 3);
+  })
+);
diff --git a/test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js b/test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js
index c6191a906b32d6..ad3530031fa6ec 100644
--- a/test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js
+++ b/test/parallel/test-pipe-outgoing-message-data-emitted-after-ended.js
@@ -9,28 +9,40 @@ const stream = require('stream');
 
 class MyStream extends stream {}
 
-const server = http.createServer(common.mustCall(function(req, res) {
-  const myStream = new MyStream();
-  myStream.pipe(res);
+const server = http.createServer(
+  common.mustCall(function(req, res) {
+    const myStream = new MyStream();
+    myStream.pipe(res);
 
-  process.nextTick(common.mustCall(() => {
-    res.end();
-    myStream.emit('data', 'some data');
-    res.on('error', common.expectsError({
-      code: 'ERR_STREAM_WRITE_AFTER_END',
-      type: Error
-    }));
+    process.nextTick(
+      common.mustCall(() => {
+        res.end();
+        myStream.emit('data', 'some data');
+        res.on(
+          'error',
+          common.expectsError({
+            code: 'ERR_STREAM_WRITE_AFTER_END',
+            type: Error
+          })
+        );
 
-    process.nextTick(common.mustCall(() => server.close()));
-  }));
-}));
+        process.nextTick(common.mustCall(() => server.close()));
+      })
+    );
+  })
+);
 
 server.listen(0);
 
-server.on('listening', common.mustCall(function() {
-  http.request({
-    port: server.address().port,
-    method: 'GET',
-    path: '/'
-  }).end();
-}));
+server.on(
+  'listening',
+  common.mustCall(function() {
+    http
+      .request({
+        port: server.address().port,
+        method: 'GET',
+        path: '/'
+      })
+      .end();
+  })
+);
diff --git a/test/parallel/test-pipe-stream.js b/test/parallel/test-pipe-stream.js
index c697530c0d5d81..828fee64bfdba7 100644
--- a/test/parallel/test-pipe-stream.js
+++ b/test/parallel/test-pipe-stream.js
@@ -22,9 +22,12 @@ function test(clazz, cb) {
       throw err;
     });
 
-    conn.connect(common.PIPE, function() {
-      conn.write('PING', 'utf-8');
-    });
+    conn.connect(
+      common.PIPE,
+      function() {
+        conn.write('PING', 'utf-8');
+      }
+    );
 
     conn.on('data', function(data) {
       assert.strictEqual(data.toString(), 'PONG');
diff --git a/test/parallel/test-pipe-writev.js b/test/parallel/test-pipe-writev.js
index 5e5b42e6a78d88..e7038a9a01f171 100644
--- a/test/parallel/test-pipe-writev.js
+++ b/test/parallel/test-pipe-writev.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (common.isWindows)
-  common.skip('Unix-specific test');
+if (common.isWindows) common.skip('Unix-specific test');
 
 const assert = require('assert');
 const net = require('net');
@@ -35,9 +34,12 @@ server.listen(common.PIPE, () => {
     throw err;
   });
 
-  client.on('data', common.mustCall((data) => {
-    assert.strictEqual(data.toString(), 'ping');
-  }));
+  client.on(
+    'data',
+    common.mustCall((data) => {
+      assert.strictEqual(data.toString(), 'ping');
+    })
+  );
 
   client.on('end', () => {
     server.close();
diff --git a/test/parallel/test-preload.js b/test/parallel/test-preload.js
index 8a2b56666d6bf0..27ddcada5bee42 100644
--- a/test/parallel/test-preload.js
+++ b/test/parallel/test-preload.js
@@ -3,8 +3,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 // Refs: https://github.com/nodejs/node/pull/2253
-if (common.isSunOS)
-  common.skip('unreliable on SunOS');
+if (common.isSunOS) common.skip('unreliable on SunOS');
 if (!common.isMainThread)
   common.skip('process.chdir is not available in Workers');
 
@@ -28,11 +27,13 @@ const fixtureD = fixtures.path('define-global.js');
 const fixtureThrows = fixtures.path('throws_error4.js');
 
 // test preloading a single module works
-childProcess.exec(`"${nodeBinary}" ${preloadOption([fixtureA])} "${fixtureB}"`,
-                  function(err, stdout, stderr) {
-                    assert.ifError(err);
-                    assert.strictEqual(stdout, 'A\nB\n');
-                  });
+childProcess.exec(
+  `"${nodeBinary}" ${preloadOption([fixtureA])} "${fixtureB}"`,
+  function(err, stdout, stderr) {
+    assert.ifError(err);
+    assert.strictEqual(stdout, 'A\nB\n');
+  }
+);
 
 // test preloading multiple modules works
 childProcess.exec(
@@ -65,11 +66,9 @@ childProcess.exec(
 );
 
 // test that preload can be used with stdin
-const stdinProc = childProcess.spawn(
-  nodeBinary,
-  ['--require', fixtureA],
-  { stdio: 'pipe' }
-);
+const stdinProc = childProcess.spawn(nodeBinary, ['--require', fixtureA], {
+  stdio: 'pipe'
+});
 stdinProc.stdin.end("console.log('hello');");
 let stdinStdout = '';
 stdinProc.stdout.on('data', function(d) {
@@ -81,11 +80,9 @@ stdinProc.on('close', function(code) {
 });
 
 // test that preload can be used with repl
-const replProc = childProcess.spawn(
-  nodeBinary,
-  ['-i', '--require', fixtureA],
-  { stdio: 'pipe' }
-);
+const replProc = childProcess.spawn(nodeBinary, ['-i', '--require', fixtureA], {
+  stdio: 'pipe'
+});
 replProc.stdin.end('.exit\n');
 let replStdout = '';
 replProc.stdout.on('data', function(d) {
@@ -93,18 +90,16 @@ replProc.stdout.on('data', function(d) {
 });
 replProc.on('close', function(code) {
   assert.strictEqual(code, 0);
-  const output = [
-    'A',
-    '> '
-  ].join('\n');
+  const output = ['A', '> '].join('\n');
   assert.strictEqual(replStdout, output);
 });
 
 // test that preload placement at other points in the cmdline
 // also test that duplicated preload only gets loaded once
 childProcess.exec(
-  `"${nodeBinary}" ${preloadOption([fixtureA])}-e "console.log('hello');" ${
-    preloadOption([fixtureA, fixtureB])}`,
+  `"${nodeBinary}" ${preloadOption([
+    fixtureA
+  ])}-e "console.log('hello');" ${preloadOption([fixtureA, fixtureB])}`,
   function(err, stdout, stderr) {
     assert.ifError(err);
     assert.strictEqual(stdout, 'A\nB\nhello\n');
@@ -124,8 +119,9 @@ interactive.stdin.write('a\n');
 interactive.stdin.write('process.exit()\n');
 
 childProcess.exec(
-  `"${nodeBinary}" --require "${fixtures.path('cluster-preload.js')}" "${
-    fixtures.path('cluster-preload-test.js')}"`,
+  `"${nodeBinary}" --require "${fixtures.path(
+    'cluster-preload.js'
+  )}" "${fixtures.path('cluster-preload-test.js')}"`,
   function(err, stdout, stderr) {
     assert.ifError(err);
     assert.ok(/worker terminated with code 43/.test(stdout));
@@ -156,7 +152,7 @@ if (common.isWindows) {
 process.chdir(fixtures.fixturesDir);
 childProcess.exec(
   `"${nodeBinary}" --expose_natives_as=v8natives --require ` +
-     `"${fixtures.path('cluster-preload.js')}" cluster-preload-test.js`,
+    `"${fixtures.path('cluster-preload.js')}" cluster-preload-test.js`,
   function(err, stdout, stderr) {
     assert.ifError(err);
     assert.ok(/worker terminated with code 43/.test(stdout));
diff --git a/test/parallel/test-priority-queue.js b/test/parallel/test-priority-queue.js
index f8526e6521c24b..c121778eab5499 100644
--- a/test/parallel/test-priority-queue.js
+++ b/test/parallel/test-priority-queue.js
@@ -9,8 +9,7 @@ const PriorityQueue = require('internal/priority_queue');
 {
   // Checks that the queue is fundamentally correct.
   const queue = new PriorityQueue();
-  for (let i = 15; i > 0; i--)
-    queue.insert(i);
+  for (let i = 15; i > 0; i--) queue.insert(i);
 
   for (let i = 1; i < 16; i++) {
     assert.strictEqual(queue.peek(), i);
@@ -20,8 +19,7 @@ const PriorityQueue = require('internal/priority_queue');
   assert.strictEqual(queue.shift(), undefined);
 
   // Reverse the order.
-  for (let i = 1; i < 16; i++)
-    queue.insert(i);
+  for (let i = 1; i < 16; i++) queue.insert(i);
 
   for (let i = 1; i < 16; i++) {
     assert.strictEqual(queue.shift(), i);
@@ -33,8 +31,7 @@ const PriorityQueue = require('internal/priority_queue');
 {
   // Checks that the queue is capable of resizing and fitting more elements.
   const queue = new PriorityQueue();
-  for (let i = 2048; i > 0; i--)
-    queue.insert(i);
+  for (let i = 2048; i > 0; i--) queue.insert(i);
 
   for (let i = 1; i < 2049; i++) {
     assert.strictEqual(queue.shift(), i);
@@ -46,19 +43,16 @@ const PriorityQueue = require('internal/priority_queue');
 {
   // Checks that remove works as expected.
   const queue = new PriorityQueue();
-  for (let i = 16; i > 0; i--)
-    queue.insert(i);
+  for (let i = 16; i > 0; i--) queue.insert(i);
 
   const removed = [5, 10, 15];
-  for (const id of removed)
-    assert(queue.remove(id));
+  for (const id of removed) assert(queue.remove(id));
 
   assert(!queue.remove(100));
   assert(!queue.remove(-100));
 
   for (let i = 1; i < 17; i++) {
-    if (removed.indexOf(i) < 0)
-      assert.strictEqual(queue.shift(), i);
+    if (removed.indexOf(i) < 0) assert.strictEqual(queue.shift(), i);
   }
 
   assert.strictEqual(queue.shift(), undefined);
@@ -67,8 +61,7 @@ const PriorityQueue = require('internal/priority_queue');
 {
   // Make a max heap with a custom sort function.
   const queue = new PriorityQueue((a, b) => b - a);
-  for (let i = 1; i < 17; i++)
-    queue.insert(i);
+  for (let i = 1; i < 17; i++) queue.insert(i);
 
   for (let i = 16; i > 0; i--) {
     assert.strictEqual(queue.shift(), i);
@@ -82,11 +75,13 @@ const PriorityQueue = require('internal/priority_queue');
   // a custom sorting function. In addition, add a setPosition function
   // as 2nd param which provides a reference to the node in the heap
   // and allows speedy deletions.
-  const queue = new PriorityQueue((a, b) => {
-    return a.value - b.value;
-  }, (node, pos) => (node.position = pos));
-  for (let i = 1; i < 17; i++)
-    queue.insert({ value: i, position: null });
+  const queue = new PriorityQueue(
+    (a, b) => {
+      return a.value - b.value;
+    },
+    (node, pos) => (node.position = pos)
+  );
+  for (let i = 1; i < 17; i++) queue.insert({ value: i, position: null });
 
   for (let i = 1; i < 17; i++) {
     assert.strictEqual(queue.peek().value, i);
@@ -97,9 +92,12 @@ const PriorityQueue = require('internal/priority_queue');
 }
 
 {
-  const queue = new PriorityQueue((a, b) => {
-    return a.value - b.value;
-  }, (node, pos) => (node.position = pos));
+  const queue = new PriorityQueue(
+    (a, b) => {
+      return a.value - b.value;
+    },
+    (node, pos) => (node.position = pos)
+  );
 
   queue.insert({ value: 1, position: null });
   queue.insert({ value: 2, position: null });
@@ -132,12 +130,14 @@ const PriorityQueue = require('internal/priority_queue');
   assert.strictEqual(queue.shift(), undefined);
 }
 
-
 {
   // Checks that removeAt respects binary heap properties
-  const queue = new PriorityQueue((a, b) => {
-    return a.value - b.value;
-  }, (node, pos) => (node.position = pos));
+  const queue = new PriorityQueue(
+    (a, b) => {
+      return a.value - b.value;
+    },
+    (node, pos) => (node.position = pos)
+  );
 
   const i3 = { value: 3, position: null };
   const i7 = { value: 7, position: null };
diff --git a/test/parallel/test-process-assert.js b/test/parallel/test-process-assert.js
index 74792eebb7bd2f..60deab61330ac1 100644
--- a/test/parallel/test-process-assert.js
+++ b/test/parallel/test-process-assert.js
@@ -9,17 +9,23 @@ common.expectWarning(
 );
 
 assert.strictEqual(process.assert(1, 'error'), undefined);
-common.expectsError(() => {
-  process.assert(undefined, 'errorMessage');
-}, {
-  code: 'ERR_ASSERTION',
-  type: Error,
-  message: 'errorMessage'
-});
-common.expectsError(() => {
-  process.assert(false);
-}, {
-  code: 'ERR_ASSERTION',
-  type: Error,
-  message: 'assertion error'
-});
+common.expectsError(
+  () => {
+    process.assert(undefined, 'errorMessage');
+  },
+  {
+    code: 'ERR_ASSERTION',
+    type: Error,
+    message: 'errorMessage'
+  }
+);
+common.expectsError(
+  () => {
+    process.assert(false);
+  },
+  {
+    code: 'ERR_ASSERTION',
+    type: Error,
+    message: 'assertion error'
+  }
+);
diff --git a/test/parallel/test-process-beforeexit.js b/test/parallel/test-process-beforeexit.js
index d197d943a4b07d..4c1b9ade270fcc 100644
--- a/test/parallel/test-process-beforeexit.js
+++ b/test/parallel/test-process-beforeexit.js
@@ -26,24 +26,33 @@ const net = require('net');
 process.once('beforeExit', common.mustCall(tryImmediate));
 
 function tryImmediate() {
-  setImmediate(common.mustCall(() => {
-    process.once('beforeExit', common.mustCall(tryTimer));
-  }));
+  setImmediate(
+    common.mustCall(() => {
+      process.once('beforeExit', common.mustCall(tryTimer));
+    })
+  );
 }
 
 function tryTimer() {
-  setTimeout(common.mustCall(() => {
-    process.once('beforeExit', common.mustCall(tryListen));
-  }), 1);
+  setTimeout(
+    common.mustCall(() => {
+      process.once('beforeExit', common.mustCall(tryListen));
+    }),
+    1
+  );
 }
 
 function tryListen() {
-  net.createServer()
+  net
+    .createServer()
     .listen(0)
-    .on('listening', common.mustCall(function() {
-      this.close();
-      process.once('beforeExit', common.mustCall(tryRepeatedTimer));
-    }));
+    .on(
+      'listening',
+      common.mustCall(function() {
+        this.close();
+        process.once('beforeExit', common.mustCall(tryRepeatedTimer));
+      })
+    );
 }
 
 // test that a function invoked from the beforeExit handler can use a timer
@@ -53,8 +62,7 @@ function tryRepeatedTimer() {
   const N = 5;
   let n = 0;
   const repeatedTimer = common.mustCall(function() {
-    if (++n < N)
-      setTimeout(repeatedTimer, 1);
+    if (++n < N) setTimeout(repeatedTimer, 1);
   }, N);
   setTimeout(repeatedTimer, 1);
 }
diff --git a/test/parallel/test-process-binding.js b/test/parallel/test-process-binding.js
index 05bb0e6aa07d41..e4b6121c17da0a 100644
--- a/test/parallel/test-process-binding.js
+++ b/test/parallel/test-process-binding.js
@@ -4,11 +4,8 @@ require('../common');
 const assert = require('assert');
 const { internalBinding } = require('internal/test/binding');
 
-assert.throws(
-  function() {
-    process.binding('test');
-  },
-  /No such module: test/
-);
+assert.throws(function() {
+  process.binding('test');
+}, /No such module: test/);
 
 internalBinding('buffer');
diff --git a/test/parallel/test-process-chdir.js b/test/parallel/test-process-chdir.js
index e66d366fb7874f..e89d889d40729b 100644
--- a/test/parallel/test-process-chdir.js
+++ b/test/parallel/test-process-chdir.js
@@ -33,12 +33,18 @@ process.chdir(dir);
 assert.strictEqual(process.cwd().normalize(), dir.normalize());
 
 process.chdir('..');
-assert.strictEqual(process.cwd().normalize(),
-                   path.resolve(tmpdir.path).normalize());
+assert.strictEqual(
+  process.cwd().normalize(),
+  path.resolve(tmpdir.path).normalize()
+);
 
 const err = {
   code: 'ERR_INVALID_ARG_TYPE',
   message: /The "directory" argument must be of type string/
 };
-common.expectsError(function() { process.chdir({}); }, err);
-common.expectsError(function() { process.chdir(); }, err);
+common.expectsError(function() {
+  process.chdir({});
+}, err);
+common.expectsError(function() {
+  process.chdir();
+}, err);
diff --git a/test/parallel/test-process-config.js b/test/parallel/test-process-config.js
index 05f4ca915a5524..6a3aafb578d9da 100644
--- a/test/parallel/test-process-config.js
+++ b/test/parallel/test-process-config.js
@@ -45,7 +45,10 @@ if (!fs.existsSync(configPath)) {
 let config = fs.readFileSync(configPath, 'utf8');
 
 // Clean up comment at the first line.
-config = config.split('\n').slice(1).join('\n');
+config = config
+  .split('\n')
+  .slice(1)
+  .join('\n');
 config = config.replace(/"/g, '\\"');
 config = config.replace(/'/g, '"');
 config = JSON.parse(config, function(key, value) {
diff --git a/test/parallel/test-process-cpuUsage.js b/test/parallel/test-process-cpuUsage.js
index 0b1d53978cac5c..7fbb413e9a59fe 100644
--- a/test/parallel/test-process-cpuUsage.js
+++ b/test/parallel/test-process-cpuUsage.js
@@ -33,46 +33,32 @@ for (let i = 0; i < 10; i++) {
 }
 
 // Ensure that an invalid shape for the previous value argument throws an error.
-assert.throws(
-  () => process.cpuUsage(1),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "prevValue" argument must be of type object. ' +
-             'Received type number'
-  }
-);
+assert.throws(() => process.cpuUsage(1), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+  message:
+    'The "prevValue" argument must be of type object. ' + 'Received type number'
+});
 
 // Check invalid types.
-[
-  {},
-  { user: 'a' },
-  { user: null, system: 'c' },
-].forEach((value) => {
-  assert.throws(
-    () => process.cpuUsage(value),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "prevValue.user" property must be of type number. ' +
-               `Received type ${typeof value.user}`
-    }
-  );
+[{}, { user: 'a' }, { user: null, system: 'c' }].forEach((value) => {
+  assert.throws(() => process.cpuUsage(value), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message:
+      'The "prevValue.user" property must be of type number. ' +
+      `Received type ${typeof value.user}`
+  });
 });
 
-[
-  { user: 3, system: 'b' },
-  { user: 3, system: null }
-].forEach((value) => {
-  assert.throws(
-    () => process.cpuUsage(value),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "prevValue.system" property must be of type number. ' +
-               `Received type ${typeof value.system}`
-    }
-  );
+[{ user: 3, system: 'b' }, { user: 3, system: null }].forEach((value) => {
+  assert.throws(() => process.cpuUsage(value), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+    message:
+      'The "prevValue.system" property must be of type number. ' +
+      `Received type ${typeof value.system}`
+  });
 });
 
 // Check invalid values.
@@ -80,30 +66,25 @@ assert.throws(
   { user: -1, system: 2 },
   { user: Number.POSITIVE_INFINITY, system: 4 }
 ].forEach((value) => {
-  assert.throws(
-    () => process.cpuUsage(value),
-    {
-      code: 'ERR_INVALID_OPT_VALUE',
-      name: 'RangeError [ERR_INVALID_OPT_VALUE]',
-      message: `The value "${value.user}" is invalid ` +
-               'for option "prevValue.user"'
-    }
-  );
+  assert.throws(() => process.cpuUsage(value), {
+    code: 'ERR_INVALID_OPT_VALUE',
+    name: 'RangeError [ERR_INVALID_OPT_VALUE]',
+    message:
+      `The value "${value.user}" is invalid ` + 'for option "prevValue.user"'
+  });
 });
 
 [
   { user: 3, system: -2 },
   { user: 5, system: Number.NEGATIVE_INFINITY }
 ].forEach((value) => {
-  assert.throws(
-    () => process.cpuUsage(value),
-    {
-      code: 'ERR_INVALID_OPT_VALUE',
-      name: 'RangeError [ERR_INVALID_OPT_VALUE]',
-      message: `The value "${value.system}" is invalid ` +
-               'for option "prevValue.system"'
-    }
-  );
+  assert.throws(() => process.cpuUsage(value), {
+    code: 'ERR_INVALID_OPT_VALUE',
+    name: 'RangeError [ERR_INVALID_OPT_VALUE]',
+    message:
+      `The value "${value.system}" is invalid ` +
+      'for option "prevValue.system"'
+  });
 });
 
 // Ensure that the return value is the expected shape.
diff --git a/test/parallel/test-process-emit-warning-from-native.js b/test/parallel/test-process-emit-warning-from-native.js
index 530b7a24047b92..354a3103260016 100644
--- a/test/parallel/test-process-emit-warning-from-native.js
+++ b/test/parallel/test-process-emit-warning-from-native.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const assert = require('assert');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 if (common.hasFipsCrypto)
   common.skip('crypto.createCipher() is not supported in FIPS mode');
 
@@ -12,9 +11,7 @@ const key = '0123456789';
 
 {
   common.expectWarning({
-    DeprecationWarning: [
-      ['crypto.createCipher is deprecated.', 'DEP0106']
-    ],
+    DeprecationWarning: [['crypto.createCipher is deprecated.', 'DEP0106']],
     Warning: [
       ['Use Cipheriv for counter mode of aes-256-gcm', common.noWarnCode]
     ]
@@ -28,7 +25,9 @@ const realEmitWarning = process.emitWarning;
 
 {
   // It's a good idea to make this overridable from userland.
-  process.emitWarning = () => { throw new Error('foo'); };
+  process.emitWarning = () => {
+    throw new Error('foo');
+  };
   assert.throws(() => {
     crypto.createCipher('aes-256-gcm', key);
   }, /^Error: foo$/);
@@ -36,7 +35,9 @@ const realEmitWarning = process.emitWarning;
 
 {
   Object.defineProperty(process, 'emitWarning', {
-    get() { throw new Error('bar'); },
+    get() {
+      throw new Error('bar');
+    },
     configurable: true
   });
   assert.throws(() => {
diff --git a/test/parallel/test-process-emit.js b/test/parallel/test-process-emit.js
index 8c2ad675cf8c62..4b32b2dbbe4925 100644
--- a/test/parallel/test-process-emit.js
+++ b/test/parallel/test-process-emit.js
@@ -3,17 +3,26 @@ const common = require('../common');
 const assert = require('assert');
 const sym = Symbol();
 
-process.on('normal', common.mustCall((data) => {
-  assert.strictEqual(data, 'normalData');
-}));
+process.on(
+  'normal',
+  common.mustCall((data) => {
+    assert.strictEqual(data, 'normalData');
+  })
+);
 
-process.on(sym, common.mustCall((data) => {
-  assert.strictEqual(data, 'symbolData');
-}));
+process.on(
+  sym,
+  common.mustCall((data) => {
+    assert.strictEqual(data, 'symbolData');
+  })
+);
 
-process.on('SIGPIPE', common.mustCall((data) => {
-  assert.strictEqual(data, 'signalData');
-}));
+process.on(
+  'SIGPIPE',
+  common.mustCall((data) => {
+    assert.strictEqual(data, 'signalData');
+  })
+);
 
 process.emit('normal', 'normalData');
 process.emit(sym, 'symbolData');
diff --git a/test/parallel/test-process-emitwarning.js b/test/parallel/test-process-emitwarning.js
index e51d391a7bd1ea..5799481e80f244 100644
--- a/test/parallel/test-process-emitwarning.js
+++ b/test/parallel/test-process-emitwarning.js
@@ -10,13 +10,16 @@ const testCode = 'CODE001';
 const testDetail = 'Some detail';
 const testType = 'CustomWarning';
 
-process.on('warning', common.mustCall((warning) => {
-  assert(warning);
-  assert(/^(?:Warning|CustomWarning)/.test(warning.name));
-  assert.strictEqual(warning.message, testMsg);
-  if (warning.code) assert.strictEqual(warning.code, testCode);
-  if (warning.detail) assert.strictEqual(warning.detail, testDetail);
-}, 15));
+process.on(
+  'warning',
+  common.mustCall((warning) => {
+    assert(warning);
+    assert(/^(?:Warning|CustomWarning)/.test(warning.name));
+    assert.strictEqual(warning.message, testMsg);
+    if (warning.code) assert.strictEqual(warning.code, testCode);
+    if (warning.detail) assert.strictEqual(warning.detail, testDetail);
+  }, 15)
+);
 
 class CustomWarning extends Error {
   constructor() {
@@ -74,8 +77,8 @@ process.emitWarning(warningThrowToString);
   [undefined, 'foo', 'bar'],
   [undefined]
 ].forEach((args) => {
-  common.expectsError(
-    () => process.emitWarning(...args),
-    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
-  );
+  common.expectsError(() => process.emitWarning(...args), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
diff --git a/test/parallel/test-process-env-allowed-flags.js b/test/parallel/test-process-env-allowed-flags.js
index 13bc8a4a019c67..0b691cb3d7e392 100644
--- a/test/parallel/test-process-env-allowed-flags.js
+++ b/test/parallel/test-process-env-allowed-flags.js
@@ -15,12 +15,12 @@ require('../common');
     '-r',
     'r',
     '--stack-trace-limit=100',
-    '--stack-trace-limit=-=xX_nodejs_Xx=-',
-  ].concat(process.config.variables.v8_enable_inspector ? [
-    '--inspect-brk',
-    'inspect-brk',
-    '--inspect_brk',
-  ] : []);
+    '--stack-trace-limit=-=xX_nodejs_Xx=-'
+  ].concat(
+    process.config.variables.v8_enable_inspector
+      ? ['--inspect-brk', 'inspect-brk', '--inspect_brk']
+      : []
+  );
 
   const badFlags = [
     'INSPECT-BRK',
@@ -51,15 +51,19 @@ require('../common');
 // assert all "canonical" flags begin with dash(es)
 {
   process.allowedNodeEnvironmentFlags.forEach((flag) => {
-    assert(/^--?[a-z0-9._-]+$/.test(flag),
-           `Unexpected format for flag ${flag}`);
+    assert(
+      /^--?[a-z0-9._-]+$/.test(flag),
+      `Unexpected format for flag ${flag}`
+    );
   });
 }
 
 // assert immutability of process.allowedNodeEnvironmentFlags
 {
-  assert.strictEqual(Object.isFrozen(process.allowedNodeEnvironmentFlags),
-                     true);
+  assert.strictEqual(
+    Object.isFrozen(process.allowedNodeEnvironmentFlags),
+    true
+  );
 
   process.allowedNodeEnvironmentFlags.add('foo');
   assert.strictEqual(process.allowedNodeEnvironmentFlags.has('foo'), false);
diff --git a/test/parallel/test-process-env-deprecation.js b/test/parallel/test-process-env-deprecation.js
index 68817b320b4717..508936539585a0 100644
--- a/test/parallel/test-process-env-deprecation.js
+++ b/test/parallel/test-process-env-deprecation.js
@@ -7,8 +7,8 @@ const assert = require('assert');
 common.expectWarning(
   'DeprecationWarning',
   'Assigning any value other than a string, number, or boolean to a ' +
-  'process.env property is deprecated. Please make sure to convert the value ' +
-  'to a string before setting process.env with it.',
+    'process.env property is deprecated. Please make sure to convert the value ' +
+    'to a string before setting process.env with it.',
   'DEP0104'
 );
 
diff --git a/test/parallel/test-process-env.js b/test/parallel/test-process-env.js
index 51cc637d06e5c4..3b86994b61b87f 100644
--- a/test/parallel/test-process-env.js
+++ b/test/parallel/test-process-env.js
@@ -38,8 +38,10 @@ if (process.argv[2] === 'you-are-the-child') {
 {
   const spawn = require('child_process').spawn;
 
-  assert.strictEqual(Object.prototype.hasOwnProperty,
-                     process.env.hasOwnProperty);
+  assert.strictEqual(
+    Object.prototype.hasOwnProperty,
+    process.env.hasOwnProperty
+  );
   const has = process.env.hasOwnProperty('hasOwnProperty');
   assert.strictEqual(has, false);
 
@@ -55,16 +57,19 @@ if (process.argv[2] === 'you-are-the-child') {
   assert.strictEqual('NODE_PROCESS_ENV_DELETED' in process.env, false);
 
   const child = spawn(process.argv[0], [process.argv[1], 'you-are-the-child']);
-  child.stdout.on('data', function(data) { console.log(data.toString()); });
-  child.stderr.on('data', function(data) { console.log(data.toString()); });
+  child.stdout.on('data', function(data) {
+    console.log(data.toString());
+  });
+  child.stderr.on('data', function(data) {
+    console.log(data.toString());
+  });
   child.on('exit', function(statusCode) {
     if (statusCode !== 0) {
-      process.exit(statusCode);  // failed assertion in child process
+      process.exit(statusCode); // failed assertion in child process
     }
   });
 }
 
-
 // delete should return true except for non-configurable properties
 // https://github.com/nodejs/node/issues/7960
 delete process.env.NON_EXISTING_VARIABLE;
diff --git a/test/parallel/test-process-euid-egid.js b/test/parallel/test-process-euid-egid.js
index 5639163bf31c13..28a71e9b4c2b45 100644
--- a/test/parallel/test-process-euid-egid.js
+++ b/test/parallel/test-process-euid-egid.js
@@ -13,20 +13,28 @@ if (common.isWindows || !common.isMainThread) {
   return;
 }
 
-assert.throws(() => {
-  process.seteuid({});
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  message: 'The "id" argument must be one of type number or string. ' +
-    'Received type object'
-});
+assert.throws(
+  () => {
+    process.seteuid({});
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "id" argument must be one of type number or string. ' +
+      'Received type object'
+  }
+);
 
-assert.throws(() => {
-  process.seteuid('fhqwhgadshgnsdhjsdbkhsdabkfabkveyb');
-}, {
-  code: 'ERR_UNKNOWN_CREDENTIAL',
-  message: 'User identifier does not exist: fhqwhgadshgnsdhjsdbkhsdabkfabkveyb'
-});
+assert.throws(
+  () => {
+    process.seteuid('fhqwhgadshgnsdhjsdbkhsdabkfabkveyb');
+  },
+  {
+    code: 'ERR_UNKNOWN_CREDENTIAL',
+    message:
+      'User identifier does not exist: fhqwhgadshgnsdhjsdbkhsdabkfabkveyb'
+  }
+);
 
 // If we're not running as super user...
 if (process.getuid() !== 0) {
diff --git a/test/parallel/test-process-exception-capture-errors.js b/test/parallel/test-process-exception-capture-errors.js
index d2f5b8617725f4..b374526269ceb2 100644
--- a/test/parallel/test-process-exception-capture-errors.js
+++ b/test/parallel/test-process-exception-capture-errors.js
@@ -1,15 +1,13 @@
 'use strict';
 const common = require('../common');
 
-common.expectsError(
-  () => process.setUncaughtExceptionCaptureCallback(42),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "fn" argument must be one of type Function or null. ' +
-             'Received type number'
-  }
-);
+common.expectsError(() => process.setUncaughtExceptionCaptureCallback(42), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "fn" argument must be one of type Function or null. ' +
+    'Received type number'
+});
 
 process.setUncaughtExceptionCaptureCallback(common.mustNotCall());
 
diff --git a/test/parallel/test-process-exception-capture-should-abort-on-uncaught-setflagsfromstring.js b/test/parallel/test-process-exception-capture-should-abort-on-uncaught-setflagsfromstring.js
index de14177b45a609..f33d6ffa634a54 100644
--- a/test/parallel/test-process-exception-capture-should-abort-on-uncaught-setflagsfromstring.js
+++ b/test/parallel/test-process-exception-capture-should-abort-on-uncaught-setflagsfromstring.js
@@ -7,7 +7,9 @@ assert.strictEqual(process.hasUncaughtExceptionCaptureCallback(), false);
 
 v8.setFlagsFromString('--abort-on-uncaught-exception');
 // This should make the process not crash even though the flag was passed.
-process.setUncaughtExceptionCaptureCallback(common.mustCall((err) => {
-  assert.strictEqual(err.message, 'foo');
-}));
+process.setUncaughtExceptionCaptureCallback(
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foo');
+  })
+);
 throw new Error('foo');
diff --git a/test/parallel/test-process-exception-capture-should-abort-on-uncaught.js b/test/parallel/test-process-exception-capture-should-abort-on-uncaught.js
index f9e685a86ea2e6..79bdbbbce5196b 100644
--- a/test/parallel/test-process-exception-capture-should-abort-on-uncaught.js
+++ b/test/parallel/test-process-exception-capture-should-abort-on-uncaught.js
@@ -6,7 +6,9 @@ const assert = require('assert');
 assert.strictEqual(process.hasUncaughtExceptionCaptureCallback(), false);
 
 // This should make the process not crash even though the flag was passed.
-process.setUncaughtExceptionCaptureCallback(common.mustCall((err) => {
-  assert.strictEqual(err.message, 'foo');
-}));
+process.setUncaughtExceptionCaptureCallback(
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foo');
+  })
+);
 throw new Error('foo');
diff --git a/test/parallel/test-process-exception-capture.js b/test/parallel/test-process-exception-capture.js
index c84d3459e2318f..56f37dde394d26 100644
--- a/test/parallel/test-process-exception-capture.js
+++ b/test/parallel/test-process-exception-capture.js
@@ -6,8 +6,10 @@ const assert = require('assert');
 assert.strictEqual(process.hasUncaughtExceptionCaptureCallback(), false);
 
 // This should make the process not crash even though the flag was passed.
-process.setUncaughtExceptionCaptureCallback(common.mustCall((err) => {
-  assert.strictEqual(err.message, 'foo');
-}));
+process.setUncaughtExceptionCaptureCallback(
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foo');
+  })
+);
 process.on('uncaughtException', common.mustNotCall());
 throw new Error('foo');
diff --git a/test/parallel/test-process-execpath.js b/test/parallel/test-process-execpath.js
index 68aef90b303449..b02b83a40891c4 100644
--- a/test/parallel/test-process-execpath.js
+++ b/test/parallel/test-process-execpath.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('symlinks are weird on windows');
+if (common.isWindows) common.skip('symlinks are weird on windows');
 
 const assert = require('assert');
 const child_process = require('child_process');
diff --git a/test/parallel/test-process-exit-code.js b/test/parallel/test-process-exit-code.js
index 9059b0b5c22487..cab34889359c7e 100644
--- a/test/parallel/test-process-exit-code.js
+++ b/test/parallel/test-process-exit-code.js
@@ -41,13 +41,15 @@ function parent() {
   const { spawn } = require('child_process');
   const node = process.execPath;
   const f = __filename;
-  const option = { stdio: [ 0, 1, 'ignore' ] };
+  const option = { stdio: [0, 1, 'ignore'] };
 
   const test = (arg, name = 'child', exit) => {
     spawn(node, [f, arg], option).on('exit', (code) => {
       assert.strictEqual(
-        code, exit,
-        `wrong exit for ${arg}-${name}\nexpected:${exit} but got:${code}`);
+        code,
+        exit,
+        `wrong exit for ${arg}-${name}\nexpected:${exit} but got:${code}`
+      );
       console.log(`ok - ${arg} exited with ${exit}`);
     });
   };
diff --git a/test/parallel/test-process-exit-from-before-exit.js b/test/parallel/test-process-exit-from-before-exit.js
index 7f20c22f0ba11a..60918216e05e90 100644
--- a/test/parallel/test-process-exit-from-before-exit.js
+++ b/test/parallel/test-process-exit-from-before-exit.js
@@ -23,8 +23,11 @@
 const common = require('../common');
 const assert = require('assert');
 
-process.on('beforeExit', common.mustCall(function() {
-  setTimeout(common.mustNotCall(), 5);
-  process.exit(0);  // Should execute immediately even if we schedule new work.
-  assert.fail();
-}));
+process.on(
+  'beforeExit',
+  common.mustCall(function() {
+    setTimeout(common.mustNotCall(), 5);
+    process.exit(0); // Should execute immediately even if we schedule new work.
+    assert.fail();
+  })
+);
diff --git a/test/parallel/test-process-exit-handler.js b/test/parallel/test-process-exit-handler.js
index d74e320fe63082..248a68e45afba5 100644
--- a/test/parallel/test-process-exit-handler.js
+++ b/test/parallel/test-process-exit-handler.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.isMainThread)
-  common.skip('execArgv does not affect Workers');
+if (!common.isMainThread) common.skip('execArgv does not affect Workers');
 
 // This test ensures that no asynchronous operations are performed in the 'exit'
 // handler.
@@ -10,5 +9,5 @@ if (!common.isMainThread)
 
 process.on('exit', () => {
   setTimeout(() => process.abort(), 0); // Should not run.
-  for (const start = Date.now(); Date.now() - start < 10;);
+  for (const start = Date.now(); Date.now() - start < 10; );
 });
diff --git a/test/parallel/test-process-external-stdio-close-spawn.js b/test/parallel/test-process-external-stdio-close-spawn.js
index 93d7f795bd74ce..7352e6ff7f5f56 100644
--- a/test/parallel/test-process-external-stdio-close-spawn.js
+++ b/test/parallel/test-process-external-stdio-close-spawn.js
@@ -5,14 +5,17 @@ const assert = require('assert');
 const cp = require('child_process');
 
 if (process.argv[2] === 'child') {
-  process.on('message', common.mustCall((msg) => {
-    assert.strictEqual(msg, 'go');
-    // the following console.log is an integral part
-    // of the test. If this regress, this call will
-    // cause the process to exit with 1
-    console.log('logging should not cause a crash');
-    process.disconnect();
-  }));
+  process.on(
+    'message',
+    common.mustCall((msg) => {
+      assert.strictEqual(msg, 'go');
+      // the following console.log is an integral part
+      // of the test. If this regress, this call will
+      // cause the process to exit with 1
+      console.log('logging should not cause a crash');
+      process.disconnect();
+    })
+  );
 } else {
   // Passing '--inspect', '--inspect-brk' to child.spawn enables
   // the debugger. This test was added to help debug the fork-based
@@ -21,10 +24,13 @@ if (process.argv[2] === 'child') {
     stdio: ['pipe', 'pipe', 'pipe', 'ipc']
   });
 
-  child.on('close', common.mustCall((exitCode, signal) => {
-    assert.strictEqual(exitCode, 0);
-    assert.strictEqual(signal, null);
-  }));
+  child.on(
+    'close',
+    common.mustCall((exitCode, signal) => {
+      assert.strictEqual(exitCode, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 
   child.stdout.destroy();
   child.send('go');
diff --git a/test/parallel/test-process-external-stdio-close.js b/test/parallel/test-process-external-stdio-close.js
index 067a75ec93492a..a58f561240d86e 100644
--- a/test/parallel/test-process-external-stdio-close.js
+++ b/test/parallel/test-process-external-stdio-close.js
@@ -5,21 +5,27 @@ const assert = require('assert');
 const cp = require('child_process');
 
 if (process.argv[2] === 'child') {
-  process.on('message', common.mustCall((msg) => {
-    assert.strictEqual(msg, 'go');
-    // the following console.log is an integral part
-    // of the test. If this regress, this call will
-    // cause the process to exit with 1
-    console.log('logging should not cause a crash');
-    process.disconnect();
-  }));
+  process.on(
+    'message',
+    common.mustCall((msg) => {
+      assert.strictEqual(msg, 'go');
+      // the following console.log is an integral part
+      // of the test. If this regress, this call will
+      // cause the process to exit with 1
+      console.log('logging should not cause a crash');
+      process.disconnect();
+    })
+  );
 } else {
   const child = cp.fork(__filename, ['child'], { silent: true });
 
-  child.on('close', common.mustCall((exitCode, signal) => {
-    assert.strictEqual(exitCode, 0);
-    assert.strictEqual(signal, null);
-  }));
+  child.on(
+    'close',
+    common.mustCall((exitCode, signal) => {
+      assert.strictEqual(exitCode, 0);
+      assert.strictEqual(signal, null);
+    })
+  );
 
   child.stdout.destroy();
   child.send('go');
diff --git a/test/parallel/test-process-getactivehandles.js b/test/parallel/test-process-getactivehandles.js
index 2db3da3c563e6e..1c69ee9d61e2c9 100644
--- a/test/parallel/test-process-getactivehandles.js
+++ b/test/parallel/test-process-getactivehandles.js
@@ -8,27 +8,28 @@ const connections = [];
 const clients = [];
 let clients_counter = 0;
 
-const server = net.createServer(function listener(c) {
-  connections.push(c);
-}).listen(0, makeConnection);
-
+const server = net
+  .createServer(function listener(c) {
+    connections.push(c);
+  })
+  .listen(0, makeConnection);
 
 function makeConnection() {
   if (clients_counter >= NUM) return;
-  net.connect(server.address().port, function connected() {
-    clientConnected(this);
-    makeConnection();
-  });
+  net.connect(
+    server.address().port,
+    function connected() {
+      clientConnected(this);
+      makeConnection();
+    }
+  );
 }
 
-
 function clientConnected(client) {
   clients.push(client);
-  if (++clients_counter >= NUM)
-    checkAll();
+  if (++clients_counter >= NUM) checkAll();
 }
 
-
 function checkAll() {
   const handles = process._getActiveHandles();
 
diff --git a/test/parallel/test-process-getactiverequests.js b/test/parallel/test-process-getactiverequests.js
index 41883d35aa7dbc..a8f27bbadf5694 100644
--- a/test/parallel/test-process-getactiverequests.js
+++ b/test/parallel/test-process-getactiverequests.js
@@ -4,7 +4,6 @@ require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
-for (let i = 0; i < 12; i++)
-  fs.open(__filename, 'r', () => {});
+for (let i = 0; i < 12; i++) fs.open(__filename, 'r', () => {});
 
 assert.strictEqual(process._getActiveRequests().length, 12);
diff --git a/test/parallel/test-process-getgroups.js b/test/parallel/test-process-getgroups.js
index 3479cf7028b28b..5b909c6944785f 100644
--- a/test/parallel/test-process-getgroups.js
+++ b/test/parallel/test-process-getgroups.js
@@ -24,8 +24,7 @@ const common = require('../common');
 
 // Check `id -G` and `process.getgroups()` return same groups.
 
-if (common.isOSX)
-  common.skip('Output of `id -G` is unreliable on Darwin.');
+if (common.isOSX) common.skip('Output of `id -G` is unreliable on Darwin.');
 
 const assert = require('assert');
 const exec = require('child_process').exec;
diff --git a/test/parallel/test-process-hrtime.js b/test/parallel/test-process-hrtime.js
index 81e50ccb7f85f0..c16b19c7b5e8a2 100644
--- a/test/parallel/test-process-hrtime.js
+++ b/test/parallel/test-process-hrtime.js
@@ -33,34 +33,46 @@ validateTuple(tuple);
 validateTuple(process.hrtime(tuple));
 
 // Test that only an Array may be passed to process.hrtime()
-common.expectsError(() => {
-  process.hrtime(1);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "time" argument must be of type Array. Received type number'
-});
-common.expectsError(() => {
-  process.hrtime([]);
-}, {
-  code: 'ERR_OUT_OF_RANGE',
-  type: RangeError,
-  message: 'The value of "time" is out of range. It must be 2. Received 0'
-});
-common.expectsError(() => {
-  process.hrtime([1]);
-}, {
-  code: 'ERR_OUT_OF_RANGE',
-  type: RangeError,
-  message: 'The value of "time" is out of range. It must be 2. Received 1'
-});
-common.expectsError(() => {
-  process.hrtime([1, 2, 3]);
-}, {
-  code: 'ERR_OUT_OF_RANGE',
-  type: RangeError,
-  message: 'The value of "time" is out of range. It must be 2. Received 3'
-});
+common.expectsError(
+  () => {
+    process.hrtime(1);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message: 'The "time" argument must be of type Array. Received type number'
+  }
+);
+common.expectsError(
+  () => {
+    process.hrtime([]);
+  },
+  {
+    code: 'ERR_OUT_OF_RANGE',
+    type: RangeError,
+    message: 'The value of "time" is out of range. It must be 2. Received 0'
+  }
+);
+common.expectsError(
+  () => {
+    process.hrtime([1]);
+  },
+  {
+    code: 'ERR_OUT_OF_RANGE',
+    type: RangeError,
+    message: 'The value of "time" is out of range. It must be 2. Received 1'
+  }
+);
+common.expectsError(
+  () => {
+    process.hrtime([1, 2, 3]);
+  },
+  {
+    code: 'ERR_OUT_OF_RANGE',
+    type: RangeError,
+    message: 'The value of "time" is out of range. It must be 2. Received 3'
+  }
+);
 
 function validateTuple(tuple) {
   assert(Array.isArray(tuple));
diff --git a/test/parallel/test-process-kill-null.js b/test/parallel/test-process-kill-null.js
index 88fc677454c941..3b8e4ab9120104 100644
--- a/test/parallel/test-process-kill-null.js
+++ b/test/parallel/test-process-kill-null.js
@@ -28,15 +28,21 @@ const cat = spawn('cat');
 
 assert.ok(process.kill(cat.pid, 0));
 
-cat.on('exit', mustCall(function() {
-  assert.throws(function() {
-    process.kill(cat.pid, 0);
-  }, Error);
-}));
+cat.on(
+  'exit',
+  mustCall(function() {
+    assert.throws(function() {
+      process.kill(cat.pid, 0);
+    }, Error);
+  })
+);
 
-cat.stdout.on('data', mustCall(function() {
-  process.kill(cat.pid, 'SIGKILL');
-}));
+cat.stdout.on(
+  'data',
+  mustCall(function() {
+    process.kill(cat.pid, 'SIGKILL');
+  })
+);
 
 // EPIPE when null sig fails
 cat.stdin.write('test');
diff --git a/test/parallel/test-process-kill-pid.js b/test/parallel/test-process-kill-pid.js
index e69be183fb7469..abdfcea4a7e100 100644
--- a/test/parallel/test-process-kill-pid.js
+++ b/test/parallel/test-process-kill-pid.js
@@ -42,8 +42,9 @@ const assert = require('assert');
   assert.throws(() => process.kill(val), {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "pid" argument must be of type number. ' +
-             `Received type ${typeof val}`
+    message:
+      'The "pid" argument must be of type number. ' +
+      `Received type ${typeof val}`
   });
 });
 
diff --git a/test/parallel/test-process-next-tick.js b/test/parallel/test-process-next-tick.js
index 59de0da42d3962..2920f1c434fafc 100644
--- a/test/parallel/test-process-next-tick.js
+++ b/test/parallel/test-process-next-tick.js
@@ -38,10 +38,9 @@ process.on('exit', function() {
 });
 
 [null, 1, 'test', {}, [], Infinity, true].forEach((i) => {
-  common.expectsError(() => process.nextTick(i),
-                      {
-                        code: 'ERR_INVALID_CALLBACK',
-                        type: TypeError,
-                        message: 'Callback must be a function'
-                      });
+  common.expectsError(() => process.nextTick(i), {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError,
+    message: 'Callback must be a function'
+  });
 });
diff --git a/test/parallel/test-process-no-deprecation.js b/test/parallel/test-process-no-deprecation.js
index bcda99de25069d..570fb776bd9522 100644
--- a/test/parallel/test-process-no-deprecation.js
+++ b/test/parallel/test-process-no-deprecation.js
@@ -18,15 +18,20 @@ process.addListener('warning', listener);
 process.emitWarning('Something is deprecated.', 'DeprecationWarning');
 
 // The warning would be emitted in the next tick, so continue after that.
-process.nextTick(common.mustCall(() => {
-  // Check that deprecations can be re-enabled.
-  process.noDeprecation = false;
-  process.removeListener('warning', listener);
-
-  process.addListener('warning', common.mustCall((warning) => {
-    assert.strictEqual(warning.name, 'DeprecationWarning');
-    assert.strictEqual(warning.message, 'Something else is deprecated.');
-  }));
-
-  process.emitWarning('Something else is deprecated.', 'DeprecationWarning');
-}));
+process.nextTick(
+  common.mustCall(() => {
+    // Check that deprecations can be re-enabled.
+    process.noDeprecation = false;
+    process.removeListener('warning', listener);
+
+    process.addListener(
+      'warning',
+      common.mustCall((warning) => {
+        assert.strictEqual(warning.name, 'DeprecationWarning');
+        assert.strictEqual(warning.message, 'Something else is deprecated.');
+      })
+    );
+
+    process.emitWarning('Something else is deprecated.', 'DeprecationWarning');
+  })
+);
diff --git a/test/parallel/test-process-raw-debug.js b/test/parallel/test-process-raw-debug.js
index 090525e18c5d3e..49ed867a0bd267 100644
--- a/test/parallel/test-process-raw-debug.js
+++ b/test/parallel/test-process-raw-debug.js
@@ -51,10 +51,13 @@ function parent() {
     console.log('ok - got expected message');
   });
 
-  child.on('exit', common.mustCall(function(c) {
-    assert(!c);
-    console.log('ok - child exited nicely');
-  }));
+  child.on(
+    'exit',
+    common.mustCall(function(c) {
+      assert(!c);
+      console.log('ok - child exited nicely');
+    })
+  );
 }
 
 function child() {
diff --git a/test/parallel/test-process-redirect-warnings-env.js b/test/parallel/test-process-redirect-warnings-env.js
index 5031152a48baf0..3ecdf76c09cae4 100644
--- a/test/parallel/test-process-redirect-warnings-env.js
+++ b/test/parallel/test-process-redirect-warnings-env.js
@@ -18,11 +18,18 @@ tmpdir.refresh();
 const warnmod = require.resolve(fixtures.path('warnings.js'));
 const warnpath = path.join(tmpdir.path, 'warnings.txt');
 
-fork(warnmod, { env: Object.assign({}, process.env,
-                                   { NODE_REDIRECT_WARNINGS: warnpath }) })
-  .on('exit', common.mustCall(() => {
-    fs.readFile(warnpath, 'utf8', common.mustCall((err, data) => {
-      assert.ifError(err);
-      assert(/\(node:\d+\) Warning: a bad practice warning/.test(data));
-    }));
-  }));
+fork(warnmod, {
+  env: Object.assign({}, process.env, { NODE_REDIRECT_WARNINGS: warnpath })
+}).on(
+  'exit',
+  common.mustCall(() => {
+    fs.readFile(
+      warnpath,
+      'utf8',
+      common.mustCall((err, data) => {
+        assert.ifError(err);
+        assert(/\(node:\d+\) Warning: a bad practice warning/.test(data));
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-process-redirect-warnings.js b/test/parallel/test-process-redirect-warnings.js
index b4f55fa8345409..9bff2d73b78fb5 100644
--- a/test/parallel/test-process-redirect-warnings.js
+++ b/test/parallel/test-process-redirect-warnings.js
@@ -18,10 +18,16 @@ tmpdir.refresh();
 const warnmod = fixtures.path('warnings.js');
 const warnpath = path.join(tmpdir.path, 'warnings.txt');
 
-fork(warnmod, { execArgv: [`--redirect-warnings=${warnpath}`] })
-  .on('exit', common.mustCall(() => {
-    fs.readFile(warnpath, 'utf8', common.mustCall((err, data) => {
-      assert.ifError(err);
-      assert(/\(node:\d+\) Warning: a bad practice warning/.test(data));
-    }));
-  }));
+fork(warnmod, { execArgv: [`--redirect-warnings=${warnpath}`] }).on(
+  'exit',
+  common.mustCall(() => {
+    fs.readFile(
+      warnpath,
+      'utf8',
+      common.mustCall((err, data) => {
+        assert.ifError(err);
+        assert(/\(node:\d+\) Warning: a bad practice warning/.test(data));
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-process-remove-all-signal-listeners.js b/test/parallel/test-process-remove-all-signal-listeners.js
index 759820c2dc56d4..9e4ac917dfd528 100644
--- a/test/parallel/test-process-remove-all-signal-listeners.js
+++ b/test/parallel/test-process-remove-all-signal-listeners.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (common.isWindows)
-  common.skip('Win32 does not support signals.');
+if (common.isWindows) common.skip('Win32 does not support signals.');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
@@ -13,9 +12,12 @@ if (process.argv[2] !== '--do-test') {
   process.env.DOTEST = 'y';
   const child = spawn(process.execPath, [__filename, '--do-test']);
 
-  child.once('exit', common.mustCall(function(code, signal) {
-    assert.strictEqual(signal, 'SIGINT');
-  }));
+  child.once(
+    'exit',
+    common.mustCall(function(code, signal) {
+      assert.strictEqual(signal, 'SIGINT');
+    })
+  );
 
   return;
 }
diff --git a/test/parallel/test-process-setgroups.js b/test/parallel/test-process-setgroups.js
index a85d6683164a26..481ab88a099fa5 100644
--- a/test/parallel/test-process-setgroups.js
+++ b/test/parallel/test-process-setgroups.js
@@ -14,8 +14,9 @@ assert.throws(
   {
     code: 'ERR_INVALID_ARG_TYPE',
     name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-    message: 'The "groups" argument must be of type Array. ' +
-             'Received type undefined'
+    message:
+      'The "groups" argument must be of type Array. ' +
+      'Received type undefined'
   }
 );
 
@@ -26,8 +27,9 @@ assert.throws(
   {
     code: 'ERR_OUT_OF_RANGE',
     name: 'RangeError [ERR_OUT_OF_RANGE]',
-    message: 'The value of "groups[1]" is out of range. ' +
-              'It must be >= 0 && < 4294967296. Received -1'
+    message:
+      'The value of "groups[1]" is out of range. ' +
+      'It must be >= 0 && < 4294967296. Received -1'
   }
 );
 
@@ -39,16 +41,21 @@ assert.throws(
     {
       code: 'ERR_INVALID_ARG_TYPE',
       name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-      message: 'The "groups[0]" argument must be ' +
-               'one of type number or string. ' +
-               `Received type ${typeof val}`
+      message:
+        'The "groups[0]" argument must be ' +
+        'one of type number or string. ' +
+        `Received type ${typeof val}`
     }
   );
 });
 
-assert.throws(() => {
-  process.setgroups([1, 'fhqwhgadshgnsdhjsdbkhsdabkfabkveyb']);
-}, {
-  code: 'ERR_UNKNOWN_CREDENTIAL',
-  message: 'Group identifier does not exist: fhqwhgadshgnsdhjsdbkhsdabkfabkveyb'
-});
+assert.throws(
+  () => {
+    process.setgroups([1, 'fhqwhgadshgnsdhjsdbkhsdabkfabkveyb']);
+  },
+  {
+    code: 'ERR_UNKNOWN_CREDENTIAL',
+    message:
+      'Group identifier does not exist: fhqwhgadshgnsdhjsdbkhsdabkfabkveyb'
+  }
+);
diff --git a/test/parallel/test-process-title-cli.js b/test/parallel/test-process-title-cli.js
index b6160fed1d0390..60d143d8d9b847 100644
--- a/test/parallel/test-process-title-cli.js
+++ b/test/parallel/test-process-title-cli.js
@@ -3,8 +3,7 @@
 
 const common = require('../common');
 
-if (common.isSunOS)
-  common.skip(`Unsupported platform [${process.platform}]`);
+if (common.isSunOS) common.skip(`Unsupported platform [${process.platform}]`);
 
 const assert = require('assert');
 
diff --git a/test/parallel/test-process-uid-gid.js b/test/parallel/test-process-uid-gid.js
index 456cba7f4dc027..41c9c724a2d17b 100644
--- a/test/parallel/test-process-uid-gid.js
+++ b/test/parallel/test-process-uid-gid.js
@@ -35,20 +35,28 @@ if (common.isWindows || !common.isMainThread) {
   return;
 }
 
-assert.throws(() => {
-  process.setuid({});
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  message: 'The "id" argument must be one of type ' +
-    'number or string. Received type object'
-});
+assert.throws(
+  () => {
+    process.setuid({});
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "id" argument must be one of type ' +
+      'number or string. Received type object'
+  }
+);
 
-assert.throws(() => {
-  process.setuid('fhqwhgadshgnsdhjsdbkhsdabkfabkveyb');
-}, {
-  code: 'ERR_UNKNOWN_CREDENTIAL',
-  message: 'User identifier does not exist: fhqwhgadshgnsdhjsdbkhsdabkfabkveyb'
-});
+assert.throws(
+  () => {
+    process.setuid('fhqwhgadshgnsdhjsdbkhsdabkfabkveyb');
+  },
+  {
+    code: 'ERR_UNKNOWN_CREDENTIAL',
+    message:
+      'User identifier does not exist: fhqwhgadshgnsdhjsdbkhsdabkfabkveyb'
+  }
+);
 
 // If we're not running as super user...
 if (process.getuid() !== 0) {
@@ -56,15 +64,13 @@ if (process.getuid() !== 0) {
   process.getgid();
   process.getuid();
 
-  assert.throws(
-    () => { process.setgid('nobody'); },
-    /(?:EPERM, .+|Group identifier does not exist: nobody)$/
-  );
+  assert.throws(() => {
+    process.setgid('nobody');
+  }, /(?:EPERM, .+|Group identifier does not exist: nobody)$/);
 
-  assert.throws(
-    () => { process.setuid('nobody'); },
-    /(?:EPERM, .+|User identifier does not exist: nobody)$/
-  );
+  assert.throws(() => {
+    process.setuid('nobody');
+  }, /(?:EPERM, .+|User identifier does not exist: nobody)$/);
   return;
 }
 
diff --git a/test/parallel/test-process-umask.js b/test/parallel/test-process-umask.js
index b1e0c08bcbd352..f4e45d1b91b1e1 100644
--- a/test/parallel/test-process-umask.js
+++ b/test/parallel/test-process-umask.js
@@ -43,20 +43,28 @@ assert.strictEqual(process.umask(), old);
 // 2. If the test fails, process.umask() will return 0
 assert.strictEqual(process.umask(), old);
 
-assert.throws(() => {
-  process.umask({});
-}, {
-  code: 'ERR_INVALID_ARG_VALUE',
-  message: 'The argument \'mask\' must be a 32-bit unsigned integer ' +
-           'or an octal string. Received {}'
-});
+assert.throws(
+  () => {
+    process.umask({});
+  },
+  {
+    code: 'ERR_INVALID_ARG_VALUE',
+    message:
+      "The argument 'mask' must be a 32-bit unsigned integer " +
+      'or an octal string. Received {}'
+  }
+);
 
 ['123x', 'abc', '999'].forEach((value) => {
-  assert.throws(() => {
-    process.umask(value);
-  }, {
-    code: 'ERR_INVALID_ARG_VALUE',
-    message: 'The argument \'mask\' must be a 32-bit unsigned integer ' +
-             `or an octal string. Received '${value}'`
-  });
+  assert.throws(
+    () => {
+      process.umask(value);
+    },
+    {
+      code: 'ERR_INVALID_ARG_VALUE',
+      message:
+        "The argument 'mask' must be a 32-bit unsigned integer " +
+        `or an octal string. Received '${value}'`
+    }
+  );
 });
diff --git a/test/parallel/test-process-versions.js b/test/parallel/test-process-versions.js
index ba7b9e70b2a9b8..6e55fd0741627e 100644
--- a/test/parallel/test-process-versions.js
+++ b/test/parallel/test-process-versions.js
@@ -2,8 +2,16 @@
 const common = require('../common');
 const assert = require('assert');
 
-const expected_keys = ['ares', 'modules', 'node',
-                       'uv', 'v8', 'zlib', 'nghttp2', 'napi'];
+const expected_keys = [
+  'ares',
+  'modules',
+  'node',
+  'uv',
+  'v8',
+  'zlib',
+  'nghttp2',
+  'napi'
+];
 
 if (common.hasCrypto) {
   expected_keys.push('openssl');
@@ -17,7 +25,8 @@ if (common.hasIntl) {
 }
 
 expected_keys.push(
-  process.versions.llhttp === undefined ? 'http_parser' : 'llhttp');
+  process.versions.llhttp === undefined ? 'http_parser' : 'llhttp'
+);
 
 expected_keys.sort();
 const actual_keys = Object.keys(process.versions).sort();
@@ -27,14 +36,22 @@ assert.deepStrictEqual(actual_keys, expected_keys);
 const commonTemplate = /^\d+\.\d+\.\d+(?:-.*)?$/;
 
 assert(commonTemplate.test(process.versions.ares));
-assert(commonTemplate.test(process.versions.llhttp === undefined ?
-  process.versions.http_parser : process.versions.llhttp));
+assert(
+  commonTemplate.test(
+    process.versions.llhttp === undefined
+      ? process.versions.http_parser
+      : process.versions.llhttp
+  )
+);
 assert(commonTemplate.test(process.versions.node));
 assert(commonTemplate.test(process.versions.uv));
 assert(commonTemplate.test(process.versions.zlib));
 
-assert(/^\d+\.\d+\.\d+(?:\.\d+)?-node\.\d+(?: \(candidate\))?$/
-  .test(process.versions.v8));
+assert(
+  /^\d+\.\d+\.\d+(?:\.\d+)?-node\.\d+(?: \(candidate\))?$/.test(
+    process.versions.v8
+  )
+);
 assert(/^\d+$/.test(process.versions.modules));
 
 if (common.hasCrypto) {
diff --git a/test/parallel/test-process-warning.js b/test/parallel/test-process-warning.js
index e4538ddc084722..8148b9028230b1 100644
--- a/test/parallel/test-process-warning.js
+++ b/test/parallel/test-process-warning.js
@@ -1,10 +1,7 @@
 'use strict';
 
 const common = require('../common');
-const {
-  hijackStderr,
-  restoreStderr
-} = require('../common/hijackstdio');
+const { hijackStderr, restoreStderr } = require('../common/hijackstdio');
 const assert = require('assert');
 
 function test1() {
@@ -28,9 +25,12 @@ function test3() {
   restoreStderr();
   // Type defaults to warning when the second argument is an object
   process.emitWarning('test', {});
-  process.once('warning', common.mustCall((warning) => {
-    assert.strictEqual(warning.name, 'Warning');
-  }));
+  process.once(
+    'warning',
+    common.mustCall((warning) => {
+      assert.strictEqual(warning.name, 'Warning');
+    })
+  );
   setImmediate(test4);
 }
 
@@ -40,7 +40,8 @@ function test4() {
   process.throwDeprecation = true;
   assert.throws(
     () => process.emitWarning('test', 'DeprecationWarning'),
-    /^DeprecationWarning: test$/);
+    /^DeprecationWarning: test$/
+  );
   process.throwDeprecation = false;
   setImmediate(test5);
 }
diff --git a/test/parallel/test-promise-swallowed-event.js b/test/parallel/test-promise-swallowed-event.js
index 144d732c20668b..3472712c90c5e2 100644
--- a/test/parallel/test-promise-swallowed-event.js
+++ b/test/parallel/test-promise-swallowed-event.js
@@ -22,9 +22,11 @@ const p2 = new Promise((resolve, reject) => {
   reject(rejectPromise);
   resolve(swallowedResolve2);
   reject(rejection2);
-}).catch(common.mustCall((exception) => {
-  assert.strictEqual(exception, rejectPromise);
-}));
+}).catch(
+  common.mustCall((exception) => {
+    assert.strictEqual(exception, rejectPromise);
+  })
+);
 
 const expected = [
   'resolve',
diff --git a/test/parallel/test-promises-unhandled-proxy-rejections.js b/test/parallel/test-promises-unhandled-proxy-rejections.js
index 83062e9520165b..e166862d776070 100644
--- a/test/parallel/test-promises-unhandled-proxy-rejections.js
+++ b/test/parallel/test-promises-unhandled-proxy-rejections.js
@@ -3,40 +3,49 @@ const common = require('../common');
 
 common.disableCrashOnUnhandledRejection();
 
-const expectedDeprecationWarning = ['Unhandled promise rejections are ' +
-                                   'deprecated. In the future, promise ' +
-                                   'rejections that are not handled will ' +
-                                   'terminate the Node.js process with a ' +
-                                   'non-zero exit code.', 'DEP0018'];
-const expectedPromiseWarning = ['Unhandled promise rejection. ' +
-  'This error originated either by throwing ' +
-  'inside of an async function without a catch ' +
-  'block, or by rejecting a promise which was ' +
-  'not handled with .catch(). (rejection id: 1)', common.noWarnCode];
+const expectedDeprecationWarning = [
+  'Unhandled promise rejections are ' +
+    'deprecated. In the future, promise ' +
+    'rejections that are not handled will ' +
+    'terminate the Node.js process with a ' +
+    'non-zero exit code.',
+  'DEP0018'
+];
+const expectedPromiseWarning = [
+  'Unhandled promise rejection. ' +
+    'This error originated either by throwing ' +
+    'inside of an async function without a catch ' +
+    'block, or by rejecting a promise which was ' +
+    'not handled with .catch(). (rejection id: 1)',
+  common.noWarnCode
+];
 
 function throwErr() {
   throw new Error('Error from proxy');
 }
 
-const thorny = new Proxy({}, {
-  getPrototypeOf: throwErr,
-  setPrototypeOf: throwErr,
-  isExtensible: throwErr,
-  preventExtensions: throwErr,
-  getOwnPropertyDescriptor: throwErr,
-  defineProperty: throwErr,
-  has: throwErr,
-  get: throwErr,
-  set: throwErr,
-  deleteProperty: throwErr,
-  ownKeys: throwErr,
-  apply: throwErr,
-  construct: throwErr
-});
+const thorny = new Proxy(
+  {},
+  {
+    getPrototypeOf: throwErr,
+    setPrototypeOf: throwErr,
+    isExtensible: throwErr,
+    preventExtensions: throwErr,
+    getOwnPropertyDescriptor: throwErr,
+    defineProperty: throwErr,
+    has: throwErr,
+    get: throwErr,
+    set: throwErr,
+    deleteProperty: throwErr,
+    ownKeys: throwErr,
+    apply: throwErr,
+    construct: throwErr
+  }
+);
 
 common.expectWarning({
   DeprecationWarning: expectedDeprecationWarning,
-  UnhandledPromiseRejectionWarning: expectedPromiseWarning,
+  UnhandledPromiseRejectionWarning: expectedPromiseWarning
 });
 
 // ensure this doesn't crash
diff --git a/test/parallel/test-promises-unhandled-rejections.js b/test/parallel/test-promises-unhandled-rejections.js
index 93ac186a3b45f6..27edf5d81a607e 100644
--- a/test/parallel/test-promises-unhandled-rejections.js
+++ b/test/parallel/test-promises-unhandled-rejections.js
@@ -13,9 +13,9 @@ const asyncTest = (function() {
   let currentTest = null;
 
   function fail(error) {
-    const stack = currentTest ?
-      `${error.stack}\nFrom previous event:\n${currentTest.stack}` :
-      error.stack;
+    const stack = currentTest
+      ? `${error.stack}\nFrom previous event:\n${currentTest.stack}`
+      : error.stack;
 
     if (currentTest)
       process.stderr.write(`'${currentTest.description}' failed\n\n`);
@@ -44,7 +44,10 @@ const asyncTest = (function() {
   }
 
   return function asyncTest(description, fn) {
-    const stack = new Error().stack.split('\n').slice(1).join('\n');
+    const stack = new Error().stack
+      .split('\n')
+      .slice(1)
+      .join('\n');
     asyncTestQueue.push({
       action: fn,
       stack: stack,
@@ -63,7 +66,6 @@ const asyncTest = (function() {
       setTimeout(nextAsyncTest, 10);
     }
   };
-
 })();
 
 function setupException(fn) {
@@ -108,137 +110,160 @@ function onUnhandledFail(done) {
   }, 10);
 }
 
-asyncTest('synchronously rejected promise should trigger' +
-          ' unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-  });
-  Promise.reject(e);
-});
-
-asyncTest('synchronously rejected promise should trigger' +
-          ' unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-  });
-  new Promise(function(_, reject) {
-    reject(e);
-  });
-});
+asyncTest(
+  'synchronously rejected promise should trigger' + ' unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+    });
+    Promise.reject(e);
+  }
+);
 
-asyncTest('Promise rejected after setImmediate should trigger' +
-          ' unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-  });
-  new Promise(function(_, reject) {
-    setImmediate(function() {
+asyncTest(
+  'synchronously rejected promise should trigger' + ' unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+    });
+    new Promise(function(_, reject) {
       reject(e);
     });
-  });
-});
+  }
+);
 
-asyncTest('Promise rejected after setTimeout(,1) should trigger' +
-          ' unhandled rejection', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-  });
-  new Promise(function(_, reject) {
-    setTimeout(function() {
-      reject(e);
-    }, 1);
-  });
-});
+asyncTest(
+  'Promise rejected after setImmediate should trigger' + ' unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+    });
+    new Promise(function(_, reject) {
+      setImmediate(function() {
+        reject(e);
+      });
+    });
+  }
+);
 
-asyncTest('Catching a promise rejection after setImmediate is not' +
-          ' soon enough to stop unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-  });
-  let _reject;
-  const promise = new Promise(function(_, reject) {
-    _reject = reject;
-  });
-  _reject(e);
-  setImmediate(function() {
-    promise.then(assert.fail, function() {});
-  });
-});
-
-asyncTest('When re-throwing new errors in a promise catch, only the' +
-          ' re-thrown error should hit unhandledRejection', function(done) {
-  const e = new Error();
-  const e2 = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e2);
-    assert.strictEqual(promise, promise2);
-  });
-  const promise2 = Promise.reject(e).then(assert.fail, function(reason) {
-    assert.strictEqual(reason, e);
-    throw e2;
-  });
-});
-
-asyncTest('Test params of unhandledRejection for a synchronously-rejected ' +
-          'promise', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-    assert.strictEqual(promise, promise);
-  });
-  Promise.reject(e);
-});
-
-asyncTest('When re-throwing new errors in a promise catch, only the ' +
-          're-thrown error should hit unhandledRejection: original promise' +
-          ' rejected async with setTimeout(,1)', function(done) {
-  const e = new Error();
-  const e2 = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e2);
-    assert.strictEqual(promise, promise2);
-  });
-  const promise2 = new Promise(function(_, reject) {
-    setTimeout(function() {
-      reject(e);
-    }, 1);
-  }).then(assert.fail, function(reason) {
-    assert.strictEqual(reason, e);
-    throw e2;
-  });
-});
-
-asyncTest('When re-throwing new errors in a promise catch, only the re-thrown' +
-          ' error should hit unhandledRejection: promise catch attached a' +
-          ' process.nextTick after rejection', function(done) {
-  const e = new Error();
-  const e2 = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e2);
-    assert.strictEqual(promise, promise2);
-  });
-  const promise = new Promise(function(_, reject) {
-    setTimeout(function() {
-      reject(e);
-      process.nextTick(function() {
-        promise2 = promise.then(assert.fail, function(reason) {
-          assert.strictEqual(reason, e);
-          throw e2;
+asyncTest(
+  'Promise rejected after setTimeout(,1) should trigger' +
+    ' unhandled rejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+    });
+    new Promise(function(_, reject) {
+      setTimeout(function() {
+        reject(e);
+      }, 1);
+    });
+  }
+);
+
+asyncTest(
+  'Catching a promise rejection after setImmediate is not' +
+    ' soon enough to stop unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+    });
+    let _reject;
+    const promise = new Promise(function(_, reject) {
+      _reject = reject;
+    });
+    _reject(e);
+    setImmediate(function() {
+      promise.then(assert.fail, function() {});
+    });
+  }
+);
+
+asyncTest(
+  'When re-throwing new errors in a promise catch, only the' +
+    ' re-thrown error should hit unhandledRejection',
+  function(done) {
+    const e = new Error();
+    const e2 = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e2);
+      assert.strictEqual(promise, promise2);
+    });
+    const promise2 = Promise.reject(e).then(assert.fail, function(reason) {
+      assert.strictEqual(reason, e);
+      throw e2;
+    });
+  }
+);
+
+asyncTest(
+  'Test params of unhandledRejection for a synchronously-rejected ' + 'promise',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+      assert.strictEqual(promise, promise);
+    });
+    Promise.reject(e);
+  }
+);
+
+asyncTest(
+  'When re-throwing new errors in a promise catch, only the ' +
+    're-thrown error should hit unhandledRejection: original promise' +
+    ' rejected async with setTimeout(,1)',
+  function(done) {
+    const e = new Error();
+    const e2 = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e2);
+      assert.strictEqual(promise, promise2);
+    });
+    const promise2 = new Promise(function(_, reject) {
+      setTimeout(function() {
+        reject(e);
+      }, 1);
+    }).then(assert.fail, function(reason) {
+      assert.strictEqual(reason, e);
+      throw e2;
+    });
+  }
+);
+
+asyncTest(
+  'When re-throwing new errors in a promise catch, only the re-thrown' +
+    ' error should hit unhandledRejection: promise catch attached a' +
+    ' process.nextTick after rejection',
+  function(done) {
+    const e = new Error();
+    const e2 = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e2);
+      assert.strictEqual(promise, promise2);
+    });
+    const promise = new Promise(function(_, reject) {
+      setTimeout(function() {
+        reject(e);
+        process.nextTick(function() {
+          promise2 = promise.then(assert.fail, function(reason) {
+            assert.strictEqual(reason, e);
+            throw e2;
+          });
         });
-      });
-    }, 1);
-  });
-  let promise2;
-});
+      }, 1);
+    });
+    let promise2;
+  }
+);
 
 asyncTest(
   'unhandledRejection should not be triggered if a promise catch is' +
-  ' attached synchronously upon the promise\'s creation',
+    " attached synchronously upon the promise's creation",
   function(done) {
     const e = new Error();
     onUnhandledFail(done);
@@ -248,7 +273,7 @@ asyncTest(
 
 asyncTest(
   'unhandledRejection should not be triggered if a promise catch is' +
-  ' attached synchronously upon the promise\'s creation',
+    " attached synchronously upon the promise's creation",
   function(done) {
     const e = new Error();
     onUnhandledFail(done);
@@ -258,115 +283,145 @@ asyncTest(
   }
 );
 
-asyncTest('Attaching a promise catch in a process.nextTick is soon enough to' +
-          ' prevent unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
-  const promise = Promise.reject(e);
-  process.nextTick(function() {
-    promise.then(assert.fail, function() {});
-  });
-});
-
-asyncTest('Attaching a promise catch in a process.nextTick is soon enough to' +
-          ' prevent unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
-  const promise = new Promise(function(_, reject) {
-    reject(e);
-  });
-  process.nextTick(function() {
-    promise.then(assert.fail, function() {});
-  });
-});
+asyncTest(
+  'Attaching a promise catch in a process.nextTick is soon enough to' +
+    ' prevent unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
+    const promise = Promise.reject(e);
+    process.nextTick(function() {
+      promise.then(assert.fail, function() {});
+    });
+  }
+);
+
+asyncTest(
+  'Attaching a promise catch in a process.nextTick is soon enough to' +
+    ' prevent unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
+    const promise = new Promise(function(_, reject) {
+      reject(e);
+    });
+    process.nextTick(function() {
+      promise.then(assert.fail, function() {});
+    });
+  }
+);
 
-asyncTest('While inside setImmediate, catching a rejected promise derived ' +
-          'from returning a rejected promise in a fulfillment handler ' +
-          'prevents unhandledRejection', function(done) {
-  onUnhandledFail(done);
+asyncTest(
+  'While inside setImmediate, catching a rejected promise derived ' +
+    'from returning a rejected promise in a fulfillment handler ' +
+    'prevents unhandledRejection',
+  function(done) {
+    onUnhandledFail(done);
 
-  setImmediate(function() {
-    // reproduces on first tick and inside of setImmediate
-    Promise
-      .resolve('resolve')
-      .then(function() {
-        return Promise.reject('reject');
-      }).catch(function(e) {});
-  });
-});
+    setImmediate(function() {
+      // reproduces on first tick and inside of setImmediate
+      Promise.resolve('resolve')
+        .then(function() {
+          return Promise.reject('reject');
+        })
+        .catch(function(e) {});
+    });
+  }
+);
 
 // State adaptation tests
-asyncTest('catching a promise which is asynchronously rejected (via ' +
-          'resolution to an asynchronously-rejected promise) prevents' +
-          ' unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
-  Promise.resolve().then(function() {
-    return new Promise(function(_, reject) {
-      setTimeout(function() {
-        reject(e);
-      }, 1);
+asyncTest(
+  'catching a promise which is asynchronously rejected (via ' +
+    'resolution to an asynchronously-rejected promise) prevents' +
+    ' unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
+    Promise.resolve()
+      .then(function() {
+        return new Promise(function(_, reject) {
+          setTimeout(function() {
+            reject(e);
+          }, 1);
+        });
+      })
+      .then(assert.fail, function(reason) {
+        assert.strictEqual(reason, e);
+      });
+  }
+);
+
+asyncTest(
+  'Catching a rejected promise derived from throwing in a' +
+    ' fulfillment handler prevents unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
+    Promise.resolve()
+      .then(function() {
+        throw e;
+      })
+      .then(assert.fail, function(reason) {
+        assert.strictEqual(reason, e);
+      });
+  }
+);
+
+asyncTest(
+  'Catching a rejected promise derived from returning a' +
+    ' synchronously-rejected promise in a fulfillment handler' +
+    ' prevents unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
+    Promise.resolve()
+      .then(function() {
+        return Promise.reject(e);
+      })
+      .then(assert.fail, function(reason) {
+        assert.strictEqual(reason, e);
+      });
+  }
+);
+
+asyncTest(
+  'A rejected promise derived from returning an' +
+    ' asynchronously-rejected promise in a fulfillment handler' +
+    ' does trigger unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+      assert.strictEqual(promise, _promise);
     });
-  }).then(assert.fail, function(reason) {
-    assert.strictEqual(reason, e);
-  });
-});
-
-asyncTest('Catching a rejected promise derived from throwing in a' +
-          ' fulfillment handler prevents unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
-  Promise.resolve().then(function() {
-    throw e;
-  }).then(assert.fail, function(reason) {
-    assert.strictEqual(reason, e);
-  });
-});
-
-asyncTest('Catching a rejected promise derived from returning a' +
-          ' synchronously-rejected promise in a fulfillment handler' +
-          ' prevents unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
-  Promise.resolve().then(function() {
-    return Promise.reject(e);
-  }).then(assert.fail, function(reason) {
-    assert.strictEqual(reason, e);
-  });
-});
-
-asyncTest('A rejected promise derived from returning an' +
-          ' asynchronously-rejected promise in a fulfillment handler' +
-          ' does trigger unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-    assert.strictEqual(promise, _promise);
-  });
-  const _promise = Promise.resolve().then(function() {
-    return new Promise(function(_, reject) {
-      setTimeout(function() {
-        reject(e);
-      }, 1);
+    const _promise = Promise.resolve().then(function() {
+      return new Promise(function(_, reject) {
+        setTimeout(function() {
+          reject(e);
+        }, 1);
+      });
     });
-  });
-});
-
-asyncTest('A rejected promise derived from throwing in a fulfillment handler' +
-          ' does trigger unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-    assert.strictEqual(promise, _promise);
-  });
-  const _promise = Promise.resolve().then(function() {
-    throw e;
-  });
-});
+  }
+);
+
+asyncTest(
+  'A rejected promise derived from throwing in a fulfillment handler' +
+    ' does trigger unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+      assert.strictEqual(promise, _promise);
+    });
+    const _promise = Promise.resolve().then(function() {
+      throw e;
+    });
+  }
+);
 
 asyncTest(
   'A rejected promise derived from returning a synchronously-rejected' +
-  ' promise in a fulfillment handler does trigger unhandledRejection',
+    ' promise in a fulfillment handler does trigger unhandledRejection',
   function(done) {
     const e = new Error();
     onUnhandledSucceed(done, function(reason, promise) {
@@ -380,16 +435,19 @@ asyncTest(
 );
 
 // Combinations with Promise.all
-asyncTest('Catching the Promise.all() of a collection that includes a ' +
-          'rejected promise prevents unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
-  Promise.all([Promise.reject(e)]).then(assert.fail, function() {});
-});
+asyncTest(
+  'Catching the Promise.all() of a collection that includes a ' +
+    'rejected promise prevents unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
+    Promise.all([Promise.reject(e)]).then(assert.fail, function() {});
+  }
+);
 
 asyncTest(
   'Catching the Promise.all() of a collection that includes a ' +
-  'nextTick-async rejected promise prevents unhandledRejection',
+    'nextTick-async rejected promise prevents unhandledRejection',
   function(done) {
     const e = new Error();
     onUnhandledFail(done);
@@ -405,69 +463,57 @@ asyncTest(
   }
 );
 
-asyncTest('Failing to catch the Promise.all() of a collection that includes' +
-          ' a rejected promise triggers unhandledRejection for the returned' +
-          ' promise, not the passed promise', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-    assert.strictEqual(promise, p);
-  });
-  const p = Promise.all([Promise.reject(e)]);
-});
-
-asyncTest('Waiting setTimeout(, 10) to catch a promise causes an' +
-          ' unhandledRejection + rejectionHandled pair', function(done) {
-  clean();
-  const unhandledPromises = [];
-  const e = new Error();
-  process.on('unhandledRejection', function(reason, promise) {
-    assert.strictEqual(reason, e);
-    unhandledPromises.push(promise);
-  });
-  process.on('rejectionHandled', function(promise) {
-    assert.strictEqual(unhandledPromises.length, 1);
-    assert.strictEqual(unhandledPromises[0], promise);
-    assert.strictEqual(promise, thePromise);
-    done();
-  });
-
-  const thePromise = new Promise(function() {
-    throw e;
-  });
-  setTimeout(function() {
-    thePromise.then(assert.fail, function(reason) {
+asyncTest(
+  'Failing to catch the Promise.all() of a collection that includes' +
+    ' a rejected promise triggers unhandledRejection for the returned' +
+    ' promise, not the passed promise',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
       assert.strictEqual(reason, e);
+      assert.strictEqual(promise, p);
     });
-  }, 10);
-});
-
-asyncTest('Waiting for some combination of process.nextTick + promise' +
-          ' microtasks to attach a catch handler is still soon enough to' +
-          ' prevent unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
+    const p = Promise.all([Promise.reject(e)]);
+  }
+);
 
+asyncTest(
+  'Waiting setTimeout(, 10) to catch a promise causes an' +
+    ' unhandledRejection + rejectionHandled pair',
+  function(done) {
+    clean();
+    const unhandledPromises = [];
+    const e = new Error();
+    process.on('unhandledRejection', function(reason, promise) {
+      assert.strictEqual(reason, e);
+      unhandledPromises.push(promise);
+    });
+    process.on('rejectionHandled', function(promise) {
+      assert.strictEqual(unhandledPromises.length, 1);
+      assert.strictEqual(unhandledPromises[0], promise);
+      assert.strictEqual(promise, thePromise);
+      done();
+    });
 
-  const a = Promise.reject(e);
-  process.nextTick(function() {
-    Promise.resolve().then(function() {
-      process.nextTick(function() {
-        Promise.resolve().then(function() {
-          a.catch(function() {});
-        });
-      });
+    const thePromise = new Promise(function() {
+      throw e;
     });
-  });
-});
+    setTimeout(function() {
+      thePromise.then(assert.fail, function(reason) {
+        assert.strictEqual(reason, e);
+      });
+    }, 10);
+  }
+);
 
-asyncTest('Waiting for some combination of process.nextTick + promise' +
-          ' microtasks to attach a catch handler is still soon enough to ' +
-          'prevent unhandledRejection: inside setImmediate', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
+asyncTest(
+  'Waiting for some combination of process.nextTick + promise' +
+    ' microtasks to attach a catch handler is still soon enough to' +
+    ' prevent unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
 
-  setImmediate(function() {
     const a = Promise.reject(e);
     process.nextTick(function() {
       Promise.resolve().then(function() {
@@ -478,52 +524,80 @@ asyncTest('Waiting for some combination of process.nextTick + promise' +
         });
       });
     });
-  });
-});
+  }
+);
 
-asyncTest('Waiting for some combination of process.nextTick + promise ' +
-          'microtasks to attach a catch handler is still soon enough to ' +
-          'prevent unhandledRejection: inside setTimeout', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
+asyncTest(
+  'Waiting for some combination of process.nextTick + promise' +
+    ' microtasks to attach a catch handler is still soon enough to ' +
+    'prevent unhandledRejection: inside setImmediate',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
 
-  setTimeout(function() {
-    const a = Promise.reject(e);
-    process.nextTick(function() {
-      Promise.resolve().then(function() {
-        process.nextTick(function() {
-          Promise.resolve().then(function() {
-            a.catch(function() {});
+    setImmediate(function() {
+      const a = Promise.reject(e);
+      process.nextTick(function() {
+        Promise.resolve().then(function() {
+          process.nextTick(function() {
+            Promise.resolve().then(function() {
+              a.catch(function() {});
+            });
           });
         });
       });
     });
-  }, 0);
-});
+  }
+);
 
-asyncTest('Waiting for some combination of promise microtasks + ' +
-          'process.nextTick to attach a catch handler is still soon enough' +
-          ' to prevent unhandledRejection', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
+asyncTest(
+  'Waiting for some combination of process.nextTick + promise ' +
+    'microtasks to attach a catch handler is still soon enough to ' +
+    'prevent unhandledRejection: inside setTimeout',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
+
+    setTimeout(function() {
+      const a = Promise.reject(e);
+      process.nextTick(function() {
+        Promise.resolve().then(function() {
+          process.nextTick(function() {
+            Promise.resolve().then(function() {
+              a.catch(function() {});
+            });
+          });
+        });
+      });
+    }, 0);
+  }
+);
 
+asyncTest(
+  'Waiting for some combination of promise microtasks + ' +
+    'process.nextTick to attach a catch handler is still soon enough' +
+    ' to prevent unhandledRejection',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
 
-  const a = Promise.reject(e);
-  Promise.resolve().then(function() {
-    process.nextTick(function() {
-      Promise.resolve().then(function() {
-        process.nextTick(function() {
-          a.catch(function() {});
+    const a = Promise.reject(e);
+    Promise.resolve().then(function() {
+      process.nextTick(function() {
+        Promise.resolve().then(function() {
+          process.nextTick(function() {
+            a.catch(function() {});
+          });
         });
       });
     });
-  });
-});
+  }
+);
 
 asyncTest(
   'Waiting for some combination of promise microtasks +' +
-  ' process.nextTick to attach a catch handler is still soon enough' +
-  ' to prevent unhandledRejection: inside setImmediate',
+    ' process.nextTick to attach a catch handler is still soon enough' +
+    ' to prevent unhandledRejection: inside setImmediate',
   function(done) {
     const e = new Error();
     onUnhandledFail(done);
@@ -543,87 +617,99 @@ asyncTest(
   }
 );
 
-asyncTest('Waiting for some combination of promise microtasks +' +
-          ' process.nextTick to attach a catch handler is still soon enough' +
-          ' to prevent unhandledRejection: inside setTimeout', function(done) {
-  const e = new Error();
-  onUnhandledFail(done);
+asyncTest(
+  'Waiting for some combination of promise microtasks +' +
+    ' process.nextTick to attach a catch handler is still soon enough' +
+    ' to prevent unhandledRejection: inside setTimeout',
+  function(done) {
+    const e = new Error();
+    onUnhandledFail(done);
 
-  setTimeout(function() {
-    const a = Promise.reject(e);
-    Promise.resolve().then(function() {
-      process.nextTick(function() {
-        Promise.resolve().then(function() {
-          process.nextTick(function() {
-            a.catch(function() {});
+    setTimeout(function() {
+      const a = Promise.reject(e);
+      Promise.resolve().then(function() {
+        process.nextTick(function() {
+          Promise.resolve().then(function() {
+            process.nextTick(function() {
+              a.catch(function() {});
+            });
           });
         });
       });
+    }, 0);
+  }
+);
+
+asyncTest(
+  'setImmediate + promise microtasks is too late to attach a catch' +
+    ' handler; unhandledRejection will be triggered in that case.' +
+    ' (setImmediate before promise creation/rejection)',
+  function(done) {
+    const e = new Error();
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, e);
+      assert.strictEqual(promise, p);
+    });
+    const p = Promise.reject(e);
+    setImmediate(function() {
+      Promise.resolve().then(function() {
+        p.catch(function() {});
+      });
     });
-  }, 0);
-});
+  }
+);
 
-asyncTest('setImmediate + promise microtasks is too late to attach a catch' +
-          ' handler; unhandledRejection will be triggered in that case.' +
-          ' (setImmediate before promise creation/rejection)', function(done) {
-  const e = new Error();
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, e);
-    assert.strictEqual(promise, p);
-  });
-  const p = Promise.reject(e);
-  setImmediate(function() {
-    Promise.resolve().then(function() {
-      p.catch(function() {});
+asyncTest(
+  'setImmediate + promise microtasks is too late to attach a catch' +
+    ' handler; unhandledRejection will be triggered in that case' +
+    ' (setImmediate before promise creation/rejection)',
+  function(done) {
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, undefined);
+      assert.strictEqual(promise, p);
     });
-  });
-});
-
-asyncTest('setImmediate + promise microtasks is too late to attach a catch' +
-          ' handler; unhandledRejection will be triggered in that case' +
-          ' (setImmediate before promise creation/rejection)', function(done) {
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, undefined);
-    assert.strictEqual(promise, p);
-  });
-  setImmediate(function() {
-    Promise.resolve().then(function() {
+    setImmediate(function() {
       Promise.resolve().then(function() {
         Promise.resolve().then(function() {
           Promise.resolve().then(function() {
-            p.catch(function() {});
+            Promise.resolve().then(function() {
+              p.catch(function() {});
+            });
           });
         });
       });
     });
-  });
-  const p = Promise.reject();
-});
-
-asyncTest('setImmediate + promise microtasks is too late to attach a catch' +
-          ' handler; unhandledRejection will be triggered in that case' +
-          ' (setImmediate after promise creation/rejection)', function(done) {
-  onUnhandledSucceed(done, function(reason, promise) {
-    assert.strictEqual(reason, undefined);
-    assert.strictEqual(promise, p);
-  });
-  const p = Promise.reject();
-  setImmediate(function() {
-    Promise.resolve().then(function() {
+    const p = Promise.reject();
+  }
+);
+
+asyncTest(
+  'setImmediate + promise microtasks is too late to attach a catch' +
+    ' handler; unhandledRejection will be triggered in that case' +
+    ' (setImmediate after promise creation/rejection)',
+  function(done) {
+    onUnhandledSucceed(done, function(reason, promise) {
+      assert.strictEqual(reason, undefined);
+      assert.strictEqual(promise, p);
+    });
+    const p = Promise.reject();
+    setImmediate(function() {
       Promise.resolve().then(function() {
         Promise.resolve().then(function() {
           Promise.resolve().then(function() {
-            p.catch(function() {});
+            Promise.resolve().then(function() {
+              p.catch(function() {});
+            });
           });
         });
       });
     });
-  });
-});
+  }
+);
 
 asyncTest(
   'Promise unhandledRejection handler does not interfere with domain' +
-  ' error handlers being given exceptions thrown from nextTick.',
+    ' error handlers being given exceptions thrown from nextTick.',
   function(done) {
     const d = domain.create();
     let domainReceivedError;
@@ -645,57 +731,65 @@ asyncTest(
   }
 );
 
-asyncTest('nextTick is immediately scheduled when called inside an event' +
-          ' handler', function(done) {
-  clean();
-  const e = new Error('error');
-  process.on('unhandledRejection', function(reason, promise) {
-    const order = [];
-    process.nextTick(function() {
-      order.push(1);
+asyncTest(
+  'nextTick is immediately scheduled when called inside an event' + ' handler',
+  function(done) {
+    clean();
+    const e = new Error('error');
+    process.on('unhandledRejection', function(reason, promise) {
+      const order = [];
+      process.nextTick(function() {
+        order.push(1);
+      });
+      setTimeout(function() {
+        order.push(2);
+        assert.deepStrictEqual([1, 2], order);
+        done();
+      }, 1);
     });
-    setTimeout(function() {
-      order.push(2);
-      assert.deepStrictEqual([1, 2], order);
+    Promise.reject(e);
+  }
+);
+
+asyncTest(
+  'Throwing an error inside a rejectionHandled handler goes to' +
+    ' unhandledException, and does not cause .catch() to throw an ' +
+    'exception',
+  function(done) {
+    clean();
+    const e = new Error();
+    const e2 = new Error();
+    const tearDownException = setupException(function(err) {
+      assert.strictEqual(err, e2);
+      tearDownException();
       done();
+    });
+    process.on('rejectionHandled', function() {
+      throw e2;
+    });
+    const p = Promise.reject(e);
+    setTimeout(function() {
+      try {
+        p.catch(function() {});
+      } catch {
+        done(new Error('fail'));
+      }
     }, 1);
-  });
-  Promise.reject(e);
-});
-
-asyncTest('Throwing an error inside a rejectionHandled handler goes to' +
-          ' unhandledException, and does not cause .catch() to throw an ' +
-          'exception', function(done) {
-  clean();
-  const e = new Error();
-  const e2 = new Error();
-  const tearDownException = setupException(function(err) {
-    assert.strictEqual(err, e2);
-    tearDownException();
-    done();
-  });
-  process.on('rejectionHandled', function() {
-    throw e2;
-  });
-  const p = Promise.reject(e);
-  setTimeout(function() {
-    try {
-      p.catch(function() {});
-    } catch {
-      done(new Error('fail'));
-    }
-  }, 1);
-});
+  }
+);
 
-asyncTest('Rejected promise inside unhandledRejection allows nextTick loop' +
-          ' to proceed first', function(done) {
-  clean();
-  Promise.reject(0);
-  let didCall = false;
-  process.on('unhandledRejection', () => {
-    assert(!didCall);
-    didCall = true;
-    const promise = Promise.reject(0);
-    process.nextTick(() => promise.catch(() => done()));
-  });
-});
+asyncTest(
+  'Rejected promise inside unhandledRejection allows nextTick loop' +
+    ' to proceed first',
+  function(done) {
+    clean();
+    Promise.reject(0);
+    let didCall = false;
+    process.on('unhandledRejection', () => {
+      assert(!didCall);
+      didCall = true;
+      const promise = Promise.reject(0);
+      process.nextTick(() => promise.catch(() => done()));
+    });
+  }
+);
diff --git a/test/parallel/test-promises-unhandled-symbol-rejections.js b/test/parallel/test-promises-unhandled-symbol-rejections.js
index 2102de81918bd7..9171a5d2d34708 100644
--- a/test/parallel/test-promises-unhandled-symbol-rejections.js
+++ b/test/parallel/test-promises-unhandled-symbol-rejections.js
@@ -4,23 +4,29 @@ const common = require('../common');
 common.disableCrashOnUnhandledRejection();
 
 const expectedValueWarning = ['Symbol()', common.noWarnCode];
-const expectedDeprecationWarning = ['Unhandled promise rejections are ' +
-                                   'deprecated. In the future, promise ' +
-                                   'rejections that are not handled will ' +
-                                   'terminate the Node.js process with a ' +
-                                   'non-zero exit code.', 'DEP0018'];
-const expectedPromiseWarning = ['Unhandled promise rejection. ' +
-  'This error originated either by throwing ' +
-  'inside of an async function without a catch ' +
-  'block, or by rejecting a promise which was ' +
-  'not handled with .catch(). (rejection id: 1)', common.noWarnCode];
+const expectedDeprecationWarning = [
+  'Unhandled promise rejections are ' +
+    'deprecated. In the future, promise ' +
+    'rejections that are not handled will ' +
+    'terminate the Node.js process with a ' +
+    'non-zero exit code.',
+  'DEP0018'
+];
+const expectedPromiseWarning = [
+  'Unhandled promise rejection. ' +
+    'This error originated either by throwing ' +
+    'inside of an async function without a catch ' +
+    'block, or by rejecting a promise which was ' +
+    'not handled with .catch(). (rejection id: 1)',
+  common.noWarnCode
+];
 
 common.expectWarning({
   DeprecationWarning: expectedDeprecationWarning,
   UnhandledPromiseRejectionWarning: [
     expectedPromiseWarning,
     expectedValueWarning
-  ],
+  ]
 });
 
 // ensure this doesn't crash
diff --git a/test/parallel/test-promises-warning-on-unhandled-rejection.js b/test/parallel/test-promises-warning-on-unhandled-rejection.js
index ba420157e72bbd..1804c5614cc4b2 100644
--- a/test/parallel/test-promises-warning-on-unhandled-rejection.js
+++ b/test/parallel/test-promises-warning-on-unhandled-rejection.js
@@ -11,46 +11,54 @@ common.disableCrashOnUnhandledRejection();
 
 let b = 0;
 
-process.on('warning', common.mustCall((warning) => {
-  switch (b++) {
-    case 0:
-      // String rejection error displayed
-      assert.strictEqual(warning.message, 'This was rejected');
-      break;
-    case 1:
-      // Warning about rejection not being handled (will be next tick)
-      assert.strictEqual(warning.name, 'UnhandledPromiseRejectionWarning');
-      assert(
-        /Unhandled promise rejection/.test(warning.message),
-        'Expected warning message to contain "Unhandled promise rejection" ' +
-        'but did not. Had "' + warning.message + '" instead.'
-      );
-      break;
-    case 2:
-      // One time deprecation warning, first unhandled rejection
-      assert.strictEqual(warning.name, 'DeprecationWarning');
-      break;
-    case 3:
-      // Number rejection error displayed. Note it's been stringified
-      assert.strictEqual(warning.message, '42');
-      break;
-    case 4:
-      // Unhandled rejection warning (won't be handled next tick)
-      assert.strictEqual(warning.name, 'UnhandledPromiseRejectionWarning');
-      assert(
-        /Unhandled promise rejection/.test(warning.message),
-        'Expected warning message to contain "Unhandled promise rejection" ' +
-        'but did not. Had "' + warning.message + '" instead.'
-      );
-      break;
-    case 5:
-      // Rejection handled asynchronously.
-      assert.strictEqual(warning.name, 'PromiseRejectionHandledWarning');
-      assert(/Promise rejection was handled asynchronously/
-        .test(warning.message));
-  }
-}, 6));
+process.on(
+  'warning',
+  common.mustCall((warning) => {
+    switch (b++) {
+      case 0:
+        // String rejection error displayed
+        assert.strictEqual(warning.message, 'This was rejected');
+        break;
+      case 1:
+        // Warning about rejection not being handled (will be next tick)
+        assert.strictEqual(warning.name, 'UnhandledPromiseRejectionWarning');
+        assert(
+          /Unhandled promise rejection/.test(warning.message),
+          'Expected warning message to contain "Unhandled promise rejection" ' +
+            'but did not. Had "' +
+            warning.message +
+            '" instead.'
+        );
+        break;
+      case 2:
+        // One time deprecation warning, first unhandled rejection
+        assert.strictEqual(warning.name, 'DeprecationWarning');
+        break;
+      case 3:
+        // Number rejection error displayed. Note it's been stringified
+        assert.strictEqual(warning.message, '42');
+        break;
+      case 4:
+        // Unhandled rejection warning (won't be handled next tick)
+        assert.strictEqual(warning.name, 'UnhandledPromiseRejectionWarning');
+        assert(
+          /Unhandled promise rejection/.test(warning.message),
+          'Expected warning message to contain "Unhandled promise rejection" ' +
+            'but did not. Had "' +
+            warning.message +
+            '" instead.'
+        );
+        break;
+      case 5:
+        // Rejection handled asynchronously.
+        assert.strictEqual(warning.name, 'PromiseRejectionHandledWarning');
+        assert(
+          /Promise rejection was handled asynchronously/.test(warning.message)
+        );
+    }
+  }, 6)
+);
 
 const p = Promise.reject('This was rejected'); // Reject with a string
-setImmediate(common.mustCall(() => p.catch(() => { })));
+setImmediate(common.mustCall(() => p.catch(() => {})));
 Promise.reject(42); // Reject with a number
diff --git a/test/parallel/test-punycode.js b/test/parallel/test-punycode.js
index 9f7f772e17b0fe..97886b870d1ed6 100644
--- a/test/parallel/test-punycode.js
+++ b/test/parallel/test-punycode.js
@@ -62,7 +62,8 @@ const tests = [
   // (A) Arabic (Egyptian)
   {
     encoded: 'egbpdaj6bu4bxfgehfvwxn',
-    decoded: '\u0644\u064A\u0647\u0645\u0627\u0628\u062A\u0643\u0644\u0645' +
+    decoded:
+      '\u0644\u064A\u0647\u0645\u0627\u0628\u062A\u0643\u0644\u0645' +
       '\u0648\u0634\u0639\u0631\u0628\u064A\u061F'
   },
 
@@ -81,21 +82,24 @@ const tests = [
   // (D) Czech: Pro<ccaron>prost<ecaron>nemluv<iacute><ccaron>esky
   {
     encoded: 'Proprostnemluvesky-uyb24dma41a',
-    decoded: '\u0050\u0072\u006F\u010D\u0070\u0072\u006F\u0073\u0074\u011B' +
+    decoded:
+      '\u0050\u0072\u006F\u010D\u0070\u0072\u006F\u0073\u0074\u011B' +
       '\u006E\u0065\u006D\u006C\u0075\u0076\u00ED\u010D\u0065\u0073\u006B\u0079'
   },
 
   // (E) Hebrew
   {
     encoded: '4dbcagdahymbxekheh6e0a7fei0b',
-    decoded: '\u05DC\u05DE\u05D4\u05D4\u05DD\u05E4\u05E9\u05D5\u05D8\u05DC' +
+    decoded:
+      '\u05DC\u05DE\u05D4\u05D4\u05DD\u05E4\u05E9\u05D5\u05D8\u05DC' +
       '\u05D0\u05DE\u05D3\u05D1\u05E8\u05D9\u05DD\u05E2\u05D1\u05E8\u05D9\u05EA'
   },
 
   // (F) Hindi (Devanagari)
   {
     encoded: 'i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd',
-    decoded: '\u092F\u0939\u0932\u094B\u0917\u0939\u093F\u0928\u094D\u0926' +
+    decoded:
+      '\u092F\u0939\u0932\u094B\u0917\u0939\u093F\u0928\u094D\u0926' +
       '\u0940\u0915\u094D\u092F\u094B\u0902\u0928\u0939\u0940\u0902\u092C' +
       '\u094B\u0932\u0938\u0915\u0924\u0947\u0939\u0948\u0902'
   },
@@ -103,15 +107,18 @@ const tests = [
   // (G) Japanese (kanji and hiragana)
   {
     encoded: 'n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa',
-    decoded: '\u306A\u305C\u307F\u3093\u306A\u65E5\u672C\u8A9E\u3092\u8A71' +
+    decoded:
+      '\u306A\u305C\u307F\u3093\u306A\u65E5\u672C\u8A9E\u3092\u8A71' +
       '\u3057\u3066\u304F\u308C\u306A\u3044\u306E\u304B'
   },
 
   // (H) Korean (Hangul syllables)
   {
-    encoded: '989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879' +
+    encoded:
+      '989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879' +
       'ccm6fea98c',
-    decoded: '\uC138\uACC4\uC758\uBAA8\uB4E0\uC0AC\uB78C\uB4E4\uC774\uD55C' +
+    decoded:
+      '\uC138\uACC4\uC758\uBAA8\uB4E0\uC0AC\uB78C\uB4E4\uC774\uD55C' +
       '\uAD6D\uC5B4\uB97C\uC774\uD574\uD55C\uB2E4\uBA74\uC5BC\uB9C8\uB098' +
       '\uC88B\uC744\uAE4C'
   },
@@ -119,7 +126,8 @@ const tests = [
   // (I) Russian (Cyrillic)
   {
     encoded: 'b1abfaaepdrnnbgefbadotcwatmq2g4l',
-    decoded: '\u043F\u043E\u0447\u0435\u043C\u0443\u0436\u0435\u043E\u043D' +
+    decoded:
+      '\u043F\u043E\u0447\u0435\u043C\u0443\u0436\u0435\u043E\u043D' +
       '\u0438\u043D\u0435\u0433\u043E\u0432\u043E\u0440\u044F\u0442\u043F' +
       '\u043E\u0440\u0443\u0441\u0441\u043A\u0438'
   },
@@ -127,7 +135,8 @@ const tests = [
   // (J) Spanish: Porqu<eacute>nopuedensimplementehablarenEspa<ntilde>ol
   {
     encoded: 'PorqunopuedensimplementehablarenEspaol-fmd56a',
-    decoded: '\u0050\u006F\u0072\u0071\u0075\u00E9\u006E\u006F\u0070\u0075' +
+    decoded:
+      '\u0050\u006F\u0072\u0071\u0075\u00E9\u006E\u006F\u0070\u0075' +
       '\u0065\u0064\u0065\u006E\u0073\u0069\u006D\u0070\u006C\u0065\u006D' +
       '\u0065\u006E\u0074\u0065\u0068\u0061\u0062\u006C\u0061\u0072\u0065' +
       '\u006E\u0045\u0073\u0070\u0061\u00F1\u006F\u006C'
@@ -137,7 +146,8 @@ const tests = [
   // <ecirchookabove>ch<ihookabove>n<oacute>iti<ecircacute>ngVi<ecircdotbelow>t
   {
     encoded: 'TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g',
-    decoded: '\u0054\u1EA1\u0069\u0073\u0061\u006F\u0068\u1ECD\u006B\u0068' +
+    decoded:
+      '\u0054\u1EA1\u0069\u0073\u0061\u006F\u0068\u1ECD\u006B\u0068' +
       '\u00F4\u006E\u0067\u0074\u0068\u1EC3\u0063\u0068\u1EC9\u006E\u00F3' +
       '\u0069\u0074\u0069\u1EBF\u006E\u0067\u0056\u0069\u1EC7\u0074'
   },
@@ -151,7 +161,8 @@ const tests = [
   // (M) <amuro><namie>-with-SUPER-MONKEYS
   {
     encoded: '-with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n',
-    decoded: '\u5B89\u5BA4\u5948\u7F8E\u6075\u002D\u0077\u0069\u0074\u0068' +
+    decoded:
+      '\u5B89\u5BA4\u5948\u7F8E\u6075\u002D\u0077\u0069\u0074\u0068' +
       '\u002D\u0053\u0055\u0050\u0045\u0052\u002D\u004D\u004F\u004E\u004B' +
       '\u0045\u0059\u0053'
   },
@@ -159,7 +170,8 @@ const tests = [
   // (N) Hello-Another-Way-<sorezore><no><basho>
   {
     encoded: 'Hello-Another-Way--fc4qua05auwb3674vfr0b',
-    decoded: '\u0048\u0065\u006C\u006C\u006F\u002D\u0041\u006E\u006F\u0074' +
+    decoded:
+      '\u0048\u0065\u006C\u006C\u006F\u002D\u0041\u006E\u006F\u0074' +
       '\u0068\u0065\u0072\u002D\u0057\u0061\u0079\u002D\u305D\u308C\u305E' +
       '\u308C\u306E\u5834\u6240'
   },
@@ -173,7 +185,8 @@ const tests = [
   // (P) Maji<de>Koi<suru>5<byou><mae>
   {
     encoded: 'MajiKoi5-783gue6qz075azm5e',
-    decoded: '\u004D\u0061\u006A\u0069\u3067\u004B\u006F\u0069\u3059\u308B' +
+    decoded:
+      '\u004D\u0061\u006A\u0069\u3067\u004B\u006F\u0069\u3059\u308B' +
       '\u0035\u79D2\u524D'
   },
 
@@ -192,8 +205,8 @@ const tests = [
   // (S) -> $1.00 <-
   {
     encoded: '-> $1.00 <--',
-    decoded: '\u002D\u003E\u0020\u0024\u0031\u002E\u0030\u0030\u0020\u003C' +
-      '\u002D'
+    decoded:
+      '\u002D\u003E\u0020\u0024\u0031\u002E\u0030\u0030\u0020\u003C' + '\u002D'
   }
 ];
 
@@ -207,30 +220,24 @@ const handleError = (error, name) => {
 
 const regexNonASCII = /[^\x20-\x7E]/;
 const testBattery = {
-  encode: (test) => assert.strictEqual(
-    punycode.encode(test.decoded),
-    test.encoded
-  ),
-  decode: (test) => assert.strictEqual(
-    punycode.decode(test.encoded),
-    test.decoded
-  ),
-  toASCII: (test) => assert.strictEqual(
-    punycode.toASCII(test.decoded),
-    regexNonASCII.test(test.decoded) ?
-      `xn--${test.encoded}` :
-      test.decoded
-  ),
-  toUnicode: (test) => assert.strictEqual(
-    punycode.toUnicode(
-      regexNonASCII.test(test.decoded) ?
-        `xn--${test.encoded}` :
-        test.decoded
+  encode: (test) =>
+    assert.strictEqual(punycode.encode(test.decoded), test.encoded),
+  decode: (test) =>
+    assert.strictEqual(punycode.decode(test.encoded), test.decoded),
+  toASCII: (test) =>
+    assert.strictEqual(
+      punycode.toASCII(test.decoded),
+      regexNonASCII.test(test.decoded) ? `xn--${test.encoded}` : test.decoded
     ),
-    regexNonASCII.test(test.decoded) ?
-      test.decoded.toLowerCase() :
-      test.decoded
-  )
+  toUnicode: (test) =>
+    assert.strictEqual(
+      punycode.toUnicode(
+        regexNonASCII.test(test.decoded) ? `xn--${test.encoded}` : test.decoded
+      ),
+      regexNonASCII.test(test.decoded)
+        ? test.decoded.toLowerCase()
+        : test.decoded
+    )
 };
 
 tests.forEach((testCase) => {
@@ -246,20 +253,24 @@ tests.forEach((testCase) => {
 // BMP code point
 assert.strictEqual(punycode.ucs2.encode([0x61]), 'a');
 // supplementary code point (surrogate pair)
-assert.strictEqual(punycode.ucs2.encode([0x1D306]), '\uD834\uDF06');
+assert.strictEqual(punycode.ucs2.encode([0x1d306]), '\uD834\uDF06');
 // high surrogate
-assert.strictEqual(punycode.ucs2.encode([0xD800]), '\uD800');
+assert.strictEqual(punycode.ucs2.encode([0xd800]), '\uD800');
 // high surrogate followed by non-surrogates
-assert.strictEqual(punycode.ucs2.encode([0xD800, 0x61, 0x62]), '\uD800ab');
+assert.strictEqual(punycode.ucs2.encode([0xd800, 0x61, 0x62]), '\uD800ab');
 // low surrogate
-assert.strictEqual(punycode.ucs2.encode([0xDC00]), '\uDC00');
+assert.strictEqual(punycode.ucs2.encode([0xdc00]), '\uDC00');
 // low surrogate followed by non-surrogates
-assert.strictEqual(punycode.ucs2.encode([0xDC00, 0x61, 0x62]), '\uDC00ab');
+assert.strictEqual(punycode.ucs2.encode([0xdc00, 0x61, 0x62]), '\uDC00ab');
 
 assert.strictEqual(errors, 0);
 
 // test map domain
-assert.strictEqual(punycode.toASCII('Bücher@日本語.com'),
-                   'Bücher@xn--wgv71a119e.com');
-assert.strictEqual(punycode.toUnicode('Bücher@xn--wgv71a119e.com'),
-                   'Bücher@日本語.com');
+assert.strictEqual(
+  punycode.toASCII('Bücher@日本語.com'),
+  'Bücher@xn--wgv71a119e.com'
+);
+assert.strictEqual(
+  punycode.toUnicode('Bücher@xn--wgv71a119e.com'),
+  'Bücher@日本語.com'
+);
diff --git a/test/parallel/test-querystring-escape.js b/test/parallel/test-querystring-escape.js
index 25a800a09a684c..003587e6d8a10f 100644
--- a/test/parallel/test-querystring-escape.js
+++ b/test/parallel/test-querystring-escape.js
@@ -10,18 +10,17 @@ assert.deepStrictEqual(qs.escape({}), '%5Bobject%20Object%5D');
 assert.deepStrictEqual(qs.escape([5, 10]), '5%2C10');
 assert.deepStrictEqual(qs.escape('Ŋōđĕ'), '%C5%8A%C5%8D%C4%91%C4%95');
 assert.deepStrictEqual(qs.escape('testŊōđĕ'), 'test%C5%8A%C5%8D%C4%91%C4%95');
-assert.deepStrictEqual(qs.escape(`${String.fromCharCode(0xD800 + 1)}test`),
-                       '%F0%90%91%B4est');
-
-common.expectsError(
-  () => qs.escape(String.fromCharCode(0xD800 + 1)),
-  {
-    code: 'ERR_INVALID_URI',
-    type: URIError,
-    message: 'URI malformed'
-  }
+assert.deepStrictEqual(
+  qs.escape(`${String.fromCharCode(0xd800 + 1)}test`),
+  '%F0%90%91%B4est'
 );
 
+common.expectsError(() => qs.escape(String.fromCharCode(0xd800 + 1)), {
+  code: 'ERR_INVALID_URI',
+  type: URIError,
+  message: 'URI malformed'
+});
+
 // using toString for objects
 assert.strictEqual(
   qs.escape({ test: 5, toString: () => 'test', valueOf: () => 10 }),
diff --git a/test/parallel/test-querystring-multichar-separator.js b/test/parallel/test-querystring-multichar-separator.js
index 720733b1e29eb2..55a236723bbd6d 100644
--- a/test/parallel/test-querystring-multichar-separator.js
+++ b/test/parallel/test-querystring-multichar-separator.js
@@ -5,21 +5,28 @@ const qs = require('querystring');
 
 function check(actual, expected) {
   assert(!(actual instanceof Object));
-  assert.deepStrictEqual(Object.keys(actual).sort(),
-                         Object.keys(expected).sort());
+  assert.deepStrictEqual(
+    Object.keys(actual).sort(),
+    Object.keys(expected).sort()
+  );
   Object.keys(expected).forEach(function(key) {
     assert.deepStrictEqual(actual[key], expected[key]);
   });
 }
 
-check(qs.parse('foo=>bar&&bar=>baz', '&&', '=>'),
-      { foo: 'bar', bar: 'baz' });
+check(qs.parse('foo=>bar&&bar=>baz', '&&', '=>'), { foo: 'bar', bar: 'baz' });
 
-check(qs.stringify({ foo: 'bar', bar: 'baz' }, '&&', '=>'),
-      'foo=>bar&&bar=>baz');
+check(
+  qs.stringify({ foo: 'bar', bar: 'baz' }, '&&', '=>'),
+  'foo=>bar&&bar=>baz'
+);
 
-check(qs.parse('foo==>bar, bar==>baz', ', ', '==>'),
-      { foo: 'bar', bar: 'baz' });
+check(qs.parse('foo==>bar, bar==>baz', ', ', '==>'), {
+  foo: 'bar',
+  bar: 'baz'
+});
 
-check(qs.stringify({ foo: 'bar', bar: 'baz' }, ', ', '==>'),
-      'foo==>bar, bar==>baz');
+check(
+  qs.stringify({ foo: 'bar', bar: 'baz' }, ', ', '==>'),
+  'foo==>bar, bar==>baz'
+);
diff --git a/test/parallel/test-querystring.js b/test/parallel/test-querystring.js
index b5a4a599c3b59d..7c724148954d31 100644
--- a/test/parallel/test-querystring.js
+++ b/test/parallel/test-querystring.js
@@ -38,64 +38,75 @@ function createWithNoPrototype(properties) {
 // {{{
 // [ wonkyQS, canonicalQS, obj ]
 const qsTestCases = [
-  ['__proto__=1',
-   '__proto__=1',
-   createWithNoPrototype([{ key: '__proto__', value: '1' }])],
-  ['__defineGetter__=asdf',
-   '__defineGetter__=asdf',
-   JSON.parse('{"__defineGetter__":"asdf"}')],
-  ['foo=918854443121279438895193',
-   'foo=918854443121279438895193',
-   { 'foo': '918854443121279438895193' }],
-  ['foo=bar', 'foo=bar', { 'foo': 'bar' }],
-  ['foo=bar&foo=quux', 'foo=bar&foo=quux', { 'foo': ['bar', 'quux'] }],
-  ['foo=1&bar=2', 'foo=1&bar=2', { 'foo': '1', 'bar': '2' }],
-  ['my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F',
-   'my%20weird%20field=q1!2%22\'w%245%267%2Fz8)%3F',
-   { 'my weird field': 'q1!2"\'w$5&7/z8)?' }],
+  [
+    '__proto__=1',
+    '__proto__=1',
+    createWithNoPrototype([{ key: '__proto__', value: '1' }])
+  ],
+  [
+    '__defineGetter__=asdf',
+    '__defineGetter__=asdf',
+    JSON.parse('{"__defineGetter__":"asdf"}')
+  ],
+  [
+    'foo=918854443121279438895193',
+    'foo=918854443121279438895193',
+    { foo: '918854443121279438895193' }
+  ],
+  ['foo=bar', 'foo=bar', { foo: 'bar' }],
+  ['foo=bar&foo=quux', 'foo=bar&foo=quux', { foo: ['bar', 'quux'] }],
+  ['foo=1&bar=2', 'foo=1&bar=2', { foo: '1', bar: '2' }],
+  [
+    'my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F',
+    "my%20weird%20field=q1!2%22'w%245%267%2Fz8)%3F",
+    { 'my weird field': 'q1!2"\'w$5&7/z8)?' }
+  ],
   ['foo%3Dbaz=bar', 'foo%3Dbaz=bar', { 'foo=baz': 'bar' }],
-  ['foo=baz=bar', 'foo=baz%3Dbar', { 'foo': 'baz=bar' }],
-  ['str=foo&arr=1&arr=2&arr=3&somenull=&undef=',
-   'str=foo&arr=1&arr=2&arr=3&somenull=&undef=',
-   { 'str': 'foo',
-     'arr': ['1', '2', '3'],
-     'somenull': '',
-     'undef': '' }],
+  ['foo=baz=bar', 'foo=baz%3Dbar', { foo: 'baz=bar' }],
+  [
+    'str=foo&arr=1&arr=2&arr=3&somenull=&undef=',
+    'str=foo&arr=1&arr=2&arr=3&somenull=&undef=',
+    { str: 'foo', arr: ['1', '2', '3'], somenull: '', undef: '' }
+  ],
   [' foo = bar ', '%20foo%20=%20bar%20', { ' foo ': ' bar ' }],
-  ['foo=%zx', 'foo=%25zx', { 'foo': '%zx' }],
-  ['foo=%EF%BF%BD', 'foo=%EF%BF%BD', { 'foo': '\ufffd' }],
+  ['foo=%zx', 'foo=%25zx', { foo: '%zx' }],
+  ['foo=%EF%BF%BD', 'foo=%EF%BF%BD', { foo: '\ufffd' }],
   // See: https://github.com/joyent/node/issues/1707
-  ['hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz',
-   'hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz',
-   { hasOwnProperty: 'x',
-     toString: 'foo',
-     valueOf: 'bar',
-     __defineGetter__: 'baz' }],
+  [
+    'hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz',
+    'hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz',
+    {
+      hasOwnProperty: 'x',
+      toString: 'foo',
+      valueOf: 'bar',
+      __defineGetter__: 'baz'
+    }
+  ],
   // See: https://github.com/joyent/node/issues/3058
   ['foo&bar=baz', 'foo=&bar=baz', { foo: '', bar: 'baz' }],
   ['a=b&c&d=e', 'a=b&c=&d=e', { a: 'b', c: '', d: 'e' }],
   ['a=b&c=&d=e', 'a=b&c=&d=e', { a: 'b', c: '', d: 'e' }],
-  ['a=b&=c&d=e', 'a=b&=c&d=e', { 'a': 'b', '': 'c', 'd': 'e' }],
-  ['a=b&=&c=d', 'a=b&=&c=d', { 'a': 'b', '': '', 'c': 'd' }],
+  ['a=b&=c&d=e', 'a=b&=c&d=e', { a: 'b', '': 'c', d: 'e' }],
+  ['a=b&=&c=d', 'a=b&=&c=d', { a: 'b', '': '', c: 'd' }],
   ['&&foo=bar&&', 'foo=bar', { foo: 'bar' }],
   ['&', '', {}],
   ['&&&&', '', {}],
   ['&=&', '=', { '': '' }],
-  ['&=&=', '=&=', { '': [ '', '' ] }],
+  ['&=&=', '=&=', { '': ['', ''] }],
   ['=', '=', { '': '' }],
   ['+', '%20=', { ' ': '' }],
   ['+=', '%20=', { ' ': '' }],
   ['+&', '%20=', { ' ': '' }],
   ['=+', '=%20', { '': ' ' }],
   ['+=&', '%20=', { ' ': '' }],
-  ['a&&b', 'a=&b=', { 'a': '', 'b': '' }],
-  ['a=a&&b=b', 'a=a&b=b', { 'a': 'a', 'b': 'b' }],
-  ['&a', 'a=', { 'a': '' }],
+  ['a&&b', 'a=&b=', { a: '', b: '' }],
+  ['a=a&&b=b', 'a=a&b=b', { a: 'a', b: 'b' }],
+  ['&a', 'a=', { a: '' }],
   ['&=', '=', { '': '' }],
-  ['a&a&', 'a=&a=', { a: [ '', '' ] }],
-  ['a&a&a&', 'a=&a=&a=', { a: [ '', '', '' ] }],
-  ['a&a&a&a&', 'a=&a=&a=&a=', { a: [ '', '', '', '' ] }],
-  ['a=&a=value&a=', 'a=&a=value&a=', { a: [ '', 'value', '' ] }],
+  ['a&a&', 'a=&a=', { a: ['', ''] }],
+  ['a&a&a&', 'a=&a=&a=', { a: ['', '', ''] }],
+  ['a&a&a&a&', 'a=&a=&a=&a=', { a: ['', '', '', ''] }],
+  ['a=&a=value&a=', 'a=&a=value&a=', { a: ['', 'value', ''] }],
   ['foo+bar=baz+quux', 'foo%20bar=baz%20quux', { 'foo bar': 'baz quux' }],
   ['+foo=+bar', '%20foo=%20bar', { ' foo': ' bar' }],
   ['a+', 'a%20=', { 'a ': '' }],
@@ -112,13 +123,15 @@ const qsTestCases = [
 
 // [ wonkyQS, canonicalQS, obj ]
 const qsColonTestCases = [
-  ['foo:bar', 'foo:bar', { 'foo': 'bar' }],
-  ['foo:bar;foo:quux', 'foo:bar;foo:quux', { 'foo': ['bar', 'quux'] }],
-  ['foo:1&bar:2;baz:quux',
-   'foo:1%26bar%3A2;baz:quux',
-   { 'foo': '1&bar:2', 'baz': 'quux' }],
+  ['foo:bar', 'foo:bar', { foo: 'bar' }],
+  ['foo:bar;foo:quux', 'foo:bar;foo:quux', { foo: ['bar', 'quux'] }],
+  [
+    'foo:1&bar:2;baz:quux',
+    'foo:1%26bar%3A2;baz:quux',
+    { foo: '1&bar:2', baz: 'quux' }
+  ],
   ['foo%3Abaz:bar', 'foo%3Abaz:bar', { 'foo:baz': 'bar' }],
-  ['foo:baz:bar', 'foo:baz%3Abar', { 'foo': 'baz:bar' }]
+  ['foo:baz:bar', 'foo:baz%3Abar', { foo: 'baz:bar' }]
 ];
 
 // [wonkyObj, qs, canonicalObj]
@@ -126,24 +139,20 @@ function extendedFunction() {}
 extendedFunction.prototype = { a: 'b' };
 const qsWeirdObjects = [
   // eslint-disable-next-line node-core/no-unescaped-regexp-dot
-  [{ regexp: /./g }, 'regexp=', { 'regexp': '' }],
+  [{ regexp: /./g }, 'regexp=', { regexp: '' }],
   // eslint-disable-next-line node-core/no-unescaped-regexp-dot
-  [{ regexp: new RegExp('.', 'g') }, 'regexp=', { 'regexp': '' }],
-  [{ fn: () => {} }, 'fn=', { 'fn': '' }],
-  [{ fn: new Function('') }, 'fn=', { 'fn': '' }],
-  [{ math: Math }, 'math=', { 'math': '' }],
-  [{ e: extendedFunction }, 'e=', { 'e': '' }],
-  [{ d: new Date() }, 'd=', { 'd': '' }],
-  [{ d: Date }, 'd=', { 'd': '' }],
-  [
-    { f: new Boolean(false), t: new Boolean(true) },
-    'f=&t=',
-    { 'f': '', 't': '' }
-  ],
-  [{ f: false, t: true }, 'f=false&t=true', { 'f': 'false', 't': 'true' }],
-  [{ n: null }, 'n=', { 'n': '' }],
-  [{ nan: NaN }, 'nan=', { 'nan': '' }],
-  [{ inf: Infinity }, 'inf=', { 'inf': '' }],
+  [{ regexp: new RegExp('.', 'g') }, 'regexp=', { regexp: '' }],
+  [{ fn: () => {} }, 'fn=', { fn: '' }],
+  [{ fn: new Function('') }, 'fn=', { fn: '' }],
+  [{ math: Math }, 'math=', { math: '' }],
+  [{ e: extendedFunction }, 'e=', { e: '' }],
+  [{ d: new Date() }, 'd=', { d: '' }],
+  [{ d: Date }, 'd=', { d: '' }],
+  [{ f: new Boolean(false), t: new Boolean(true) }, 'f=&t=', { f: '', t: '' }],
+  [{ f: false, t: true }, 'f=false&t=true', { f: 'false', t: 'true' }],
+  [{ n: null }, 'n=', { n: '' }],
+  [{ nan: NaN }, 'nan=', { nan: '' }],
+  [{ inf: Infinity }, 'inf=', { inf: '' }],
   [{ a: [], b: [] }, '', {}]
 ];
 // }}}
@@ -153,32 +162,41 @@ const foreignObject = vm.runInNewContext('({"foo": ["bar", "baz"]})');
 
 const qsNoMungeTestCases = [
   ['', {}],
-  ['foo=bar&foo=baz', { 'foo': ['bar', 'baz'] }],
+  ['foo=bar&foo=baz', { foo: ['bar', 'baz'] }],
   ['foo=bar&foo=baz', foreignObject],
-  ['blah=burp', { 'blah': 'burp' }],
-  ['a=!-._~\'()*', { 'a': '!-._~\'()*' }],
-  ['a=abcdefghijklmnopqrstuvwxyz', { 'a': 'abcdefghijklmnopqrstuvwxyz' }],
-  ['a=ABCDEFGHIJKLMNOPQRSTUVWXYZ', { 'a': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' }],
-  ['a=0123456789', { 'a': '0123456789' }],
-  ['gragh=1&gragh=3&goo=2', { 'gragh': ['1', '3'], 'goo': '2' }],
-  ['frappucino=muffin&goat%5B%5D=scone&pond=moose',
-   { 'frappucino': 'muffin', 'goat[]': 'scone', 'pond': 'moose' }],
-  ['trololol=yes&lololo=no', { 'trololol': 'yes', 'lololo': 'no' }]
+  ['blah=burp', { blah: 'burp' }],
+  ["a=!-._~'()*", { a: "!-._~'()*" }],
+  ['a=abcdefghijklmnopqrstuvwxyz', { a: 'abcdefghijklmnopqrstuvwxyz' }],
+  ['a=ABCDEFGHIJKLMNOPQRSTUVWXYZ', { a: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' }],
+  ['a=0123456789', { a: '0123456789' }],
+  ['gragh=1&gragh=3&goo=2', { gragh: ['1', '3'], goo: '2' }],
+  [
+    'frappucino=muffin&goat%5B%5D=scone&pond=moose',
+    { frappucino: 'muffin', 'goat[]': 'scone', pond: 'moose' }
+  ],
+  ['trololol=yes&lololo=no', { trololol: 'yes', lololo: 'no' }]
 ];
 
 const qsUnescapeTestCases = [
-  ['there is nothing to unescape here',
-   'there is nothing to unescape here'],
-  ['there%20are%20several%20spaces%20that%20need%20to%20be%20unescaped',
-   'there are several spaces that need to be unescaped'],
-  ['there%2Qare%0-fake%escaped values in%%%%this%9Hstring',
-   'there%2Qare%0-fake%escaped values in%%%%this%9Hstring'],
-  ['%20%21%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%2F%30%31%32%33%34%35%36%37',
-   ' !"#$%&\'()*+,-./01234567']
+  ['there is nothing to unescape here', 'there is nothing to unescape here'],
+  [
+    'there%20are%20several%20spaces%20that%20need%20to%20be%20unescaped',
+    'there are several spaces that need to be unescaped'
+  ],
+  [
+    'there%2Qare%0-fake%escaped values in%%%%this%9Hstring',
+    'there%2Qare%0-fake%escaped values in%%%%this%9Hstring'
+  ],
+  [
+    '%20%21%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%2F%30%31%32%33%34%35%36%37',
+    ' !"#$%&\'()*+,-./01234567'
+  ]
 ];
 
-assert.strictEqual(qs.parse('id=918854443121279438895193').id,
-                   '918854443121279438895193');
+assert.strictEqual(
+  qs.parse('id=918854443121279438895193').id,
+  '918854443121279438895193'
+);
 
 function check(actual, expected, input) {
   assert(!(actual instanceof Object));
@@ -186,17 +204,19 @@ function check(actual, expected, input) {
   const expectedKeys = Object.keys(expected).sort();
   let msg;
   if (typeof input === 'string') {
-    msg = `Input: ${inspect(input)}\n` +
-          `Actual keys: ${inspect(actualKeys)}\n` +
-          `Expected keys: ${inspect(expectedKeys)}`;
+    msg =
+      `Input: ${inspect(input)}\n` +
+      `Actual keys: ${inspect(actualKeys)}\n` +
+      `Expected keys: ${inspect(expectedKeys)}`;
   }
   assert.deepStrictEqual(actualKeys, expectedKeys, msg);
   expectedKeys.forEach((key) => {
     if (typeof input === 'string') {
-      msg = `Input: ${inspect(input)}\n` +
-            `Key: ${inspect(key)}\n` +
-            `Actual value: ${inspect(actual[key])}\n` +
-            `Expected value: ${inspect(expected[key])}`;
+      msg =
+        `Input: ${inspect(input)}\n` +
+        `Key: ${inspect(key)}\n` +
+        `Actual value: ${inspect(actual[key])}\n` +
+        `Expected value: ${inspect(expected[key])}`;
     } else {
       msg = undefined;
     }
@@ -226,10 +246,13 @@ qsNoMungeTestCases.forEach((testCase) => {
 // test the nested qs-in-qs case
 {
   const f = qs.parse('a=b&q=x%3Dy%26y%3Dz');
-  check(f, createWithNoPrototype([
-    { key: 'a', value: 'b' },
-    { key: 'q', value: 'x=y&y=z' }
-  ]));
+  check(
+    f,
+    createWithNoPrototype([
+      { key: 'a', value: 'b' },
+      { key: 'q', value: 'x=y&y=z' }
+    ])
+  );
 
   f.q = qs.parse(f.q);
   const expectedInternal = createWithNoPrototype([
@@ -242,10 +265,13 @@ qsNoMungeTestCases.forEach((testCase) => {
 // nested in colon
 {
   const f = qs.parse('a:b;q:x%3Ay%3By%3Az', ';', ':');
-  check(f, createWithNoPrototype([
-    { key: 'a', value: 'b' },
-    { key: 'q', value: 'x:y;y:z' }
-  ]));
+  check(
+    f,
+    createWithNoPrototype([
+      { key: 'a', value: 'b' },
+      { key: 'q', value: 'x:y;y:z' }
+    ])
+  );
   f.q = qs.parse(f.q, ';', ':');
   const expectedInternal = createWithNoPrototype([
     { key: 'x', value: 'y' },
@@ -270,14 +296,11 @@ qsWeirdObjects.forEach((testCase) => {
 });
 
 // invalid surrogate pair throws URIError
-common.expectsError(
-  () => qs.stringify({ foo: '\udc00' }),
-  {
-    code: 'ERR_INVALID_URI',
-    type: URIError,
-    message: 'URI malformed'
-  }
-);
+common.expectsError(() => qs.stringify({ foo: '\udc00' }), {
+  code: 'ERR_INVALID_URI',
+  type: URIError,
+  message: 'URI malformed'
+});
 
 // coerce numbers to string
 assert.strictEqual(qs.stringify({ foo: 0 }), 'foo=0');
@@ -303,13 +326,21 @@ qs.parse(undefined); // Should not throw.
 
 // nested in colon
 {
-  const f = qs.stringify({
-    a: 'b',
-    q: qs.stringify({
-      x: 'y',
-      y: 'z'
-    }, ';', ':')
-  }, ';', ':');
+  const f = qs.stringify(
+    {
+      a: 'b',
+      q: qs.stringify(
+        {
+          x: 'y',
+          y: 'z'
+        },
+        ';',
+        ':'
+      )
+    },
+    ';',
+    ':'
+  );
   assert.strictEqual(f, 'a:b;q:x%3Ay%3By%3Az');
 }
 
@@ -331,12 +362,14 @@ check(qs.parse('a', null, []), { '': 'a' });
 // Test limiting
 assert.strictEqual(
   Object.keys(qs.parse('a=1&b=1&c=1', null, null, { maxKeys: 1 })).length,
-  1);
+  1
+);
 
 // Test limiting with a case that starts from `&`
 assert.strictEqual(
   Object.keys(qs.parse('&a', null, null, { maxKeys: 1 })).length,
-  0);
+  0
+);
 
 // Test removing limit
 {
@@ -349,15 +382,17 @@ assert.strictEqual(
 
     assert.strictEqual(
       Object.keys(qs.parse(url, null, null, { maxKeys: 0 })).length,
-      2000);
+      2000
+    );
   }
 
   testUnlimitedKeys();
 }
 
 {
-  const b = qs.unescapeBuffer('%d3%f2Ug%1f6v%24%5e%98%cb' +
-    '%0d%ac%a2%2f%9d%eb%d8%a2%e6');
+  const b = qs.unescapeBuffer(
+    '%d3%f2Ug%1f6v%24%5e%98%cb' + '%0d%ac%a2%2f%9d%eb%d8%a2%e6'
+  );
   // <Buffer d3 f2 55 67 1f 36 76 24 5e 98 cb 0d ac a2 2f 9d eb d8 a2 e6>
   assert.strictEqual(b[0], 0xd3);
   assert.strictEqual(b[1], 0xf2);
@@ -400,10 +435,12 @@ check(qs.parse('%\u0100=%\u0101'), { '%Ā': '%ā' });
 
   check(
     qs.parse('a=a&b=b&c=c', null, null, { decodeURIComponent: demoDecode }),
-    { aa: 'aa', bb: 'bb', cc: 'cc' });
+    { aa: 'aa', bb: 'bb', cc: 'cc' }
+  );
   check(
     qs.parse('a=a&b=b&c=c', null, '==', { decodeURIComponent: (str) => str }),
-    { 'a=a': '', 'b=b': '', 'c=c': '' });
+    { 'a=a': '', 'b=b': '', 'c=c': '' }
+  );
 }
 
 // Test QueryString.unescape
@@ -412,8 +449,9 @@ check(qs.parse('%\u0100=%\u0101'), { '%Ā': '%ā' });
     throw new Error('To jump to the catch scope');
   }
 
-  check(qs.parse('a=a', null, null, { decodeURIComponent: errDecode }),
-        { a: 'a' });
+  check(qs.parse('a=a', null, null, { decodeURIComponent: errDecode }), {
+    a: 'a'
+  });
 }
 
 // Test custom encode
@@ -425,7 +463,8 @@ check(qs.parse('%\u0100=%\u0101'), { '%Ā': '%ā' });
   const obj = { aa: 'aa', bb: 'bb', cc: 'cc' };
   assert.strictEqual(
     qs.stringify(obj, null, null, { encodeURIComponent: demoEncode }),
-    'a=a&b=b&c=c');
+    'a=a&b=b&c=c'
+  );
 }
 
 // Test QueryString.unescapeBuffer
@@ -442,7 +481,8 @@ qsUnescapeTestCases.forEach((testCase) => {
   };
   check(
     qs.parse('foo=bor'),
-    createWithNoPrototype([{ key: 'f__', value: 'b_r' }]));
+    createWithNoPrototype([{ key: 'f__', value: 'b_r' }])
+  );
   qs.unescape = prevUnescape;
 }
 // test separator and "equals" parsing order
diff --git a/test/parallel/test-queue-microtask.js b/test/parallel/test-queue-microtask.js
index f0eb4364258cc1..0e96c7d307d147 100644
--- a/test/parallel/test-queue-microtask.js
+++ b/test/parallel/test-queue-microtask.js
@@ -5,30 +5,34 @@ const assert = require('assert');
 
 assert.strictEqual(typeof queueMicrotask, 'function');
 
-[
-  undefined,
-  null,
-  0,
-  'x = 5',
-].forEach((t) => {
-  assert.throws(common.mustCall(() => {
-    queueMicrotask(t);
-  }), {
-    code: 'ERR_INVALID_ARG_TYPE',
-  });
+[undefined, null, 0, 'x = 5'].forEach((t) => {
+  assert.throws(
+    common.mustCall(() => {
+      queueMicrotask(t);
+    }),
+    {
+      code: 'ERR_INVALID_ARG_TYPE'
+    }
+  );
 });
 
 {
   let called = false;
-  queueMicrotask(common.mustCall(() => {
-    called = true;
-  }));
+  queueMicrotask(
+    common.mustCall(() => {
+      called = true;
+    })
+  );
   assert.strictEqual(called, false);
 }
 
-queueMicrotask(common.mustCall(function() {
-  assert.strictEqual(arguments.length, 0);
-}), 'x', 'y');
+queueMicrotask(
+  common.mustCall(function() {
+    assert.strictEqual(arguments.length, 0);
+  }),
+  'x',
+  'y'
+);
 
 {
   const q = [];
@@ -36,9 +40,11 @@ queueMicrotask(common.mustCall(function() {
   queueMicrotask(common.mustCall(() => q.push('b')));
   Promise.reject().catch(() => q.push('c'));
 
-  queueMicrotask(common.mustCall(() => {
-    assert.deepStrictEqual(q, ['a', 'b', 'c']);
-  }));
+  queueMicrotask(
+    common.mustCall(() => {
+      assert.deepStrictEqual(q, ['a', 'b', 'c']);
+    })
+  );
 }
 
 const eq = [];
@@ -50,11 +56,15 @@ process.on('exit', () => {
   assert.strictEqual(eq.length, 2);
   assert.strictEqual(eq[0].message, 'E1');
   assert.strictEqual(
-    eq[1].message, 'Class constructor  cannot be invoked without \'new\'');
+    eq[1].message,
+    "Class constructor  cannot be invoked without 'new'"
+  );
 });
 
-queueMicrotask(common.mustCall(() => {
-  throw new Error('E1');
-}));
+queueMicrotask(
+  common.mustCall(() => {
+    throw new Error('E1');
+  })
+);
 
 queueMicrotask(class {});
diff --git a/test/parallel/test-readable-single-end.js b/test/parallel/test-readable-single-end.js
index 0969d49aa48e98..8e74b07a635960 100644
--- a/test/parallel/test-readable-single-end.js
+++ b/test/parallel/test-readable-single-end.js
@@ -7,7 +7,7 @@ const { Readable } = require('stream');
 // event when stream has ended (only 1 event signalling about end)
 
 const r = new Readable({
-  read: () => {},
+  read: () => {}
 });
 
 r.push(null);
diff --git a/test/parallel/test-readline-csi.js b/test/parallel/test-readline-csi.js
index 25d5a5eb6e79d7..8ad3c3c2aecd43 100644
--- a/test/parallel/test-readline-csi.js
+++ b/test/parallel/test-readline-csi.js
@@ -54,7 +54,7 @@ assert.deepStrictEqual(writable.data, CSI.kClearLine);
   [1, 1, '\x1b[1C\x1b[1B'],
   [-1, 1, '\x1b[1D\x1b[1B'],
   [-1, -1, '\x1b[1D\x1b[1A'],
-  [1, -1, '\x1b[1C\x1b[1A'],
+  [1, -1, '\x1b[1C\x1b[1A']
 ].forEach((set) => {
   writable.data = '';
   readline.moveCursor(writable, set[0], set[1]);
@@ -74,13 +74,11 @@ readline.cursorTo(writable, 'a', 'b');
 assert.strictEqual(writable.data, '');
 
 writable.data = '';
-common.expectsError(
-  () => readline.cursorTo(writable, 'a', 1),
-  {
-    type: TypeError,
-    code: 'ERR_INVALID_CURSOR_POS',
-    message: 'Cannot set cursor row without setting its column'
-  });
+common.expectsError(() => readline.cursorTo(writable, 'a', 1), {
+  type: TypeError,
+  code: 'ERR_INVALID_CURSOR_POS',
+  message: 'Cannot set cursor row without setting its column'
+});
 assert.strictEqual(writable.data, '');
 
 writable.data = '';
diff --git a/test/parallel/test-readline-interface-escapecodetimeout.js b/test/parallel/test-readline-interface-escapecodetimeout.js
index 0e25423e8550c0..a128b50fe26674 100644
--- a/test/parallel/test-readline-interface-escapecodetimeout.js
+++ b/test/parallel/test-readline-interface-escapecodetimeout.js
@@ -25,22 +25,20 @@ class FakeInput extends EventEmitter {
   rli.close();
 }
 
-[
-  null,
-  {},
-  NaN,
-  '50'
-].forEach((invalidInput) => {
-  common.expectsError(() => {
-    const fi = new FakeInput();
-    const rli = new readline.Interface({
-      input: fi,
-      output: fi,
-      escapeCodeTimeout: invalidInput
-    });
-    rli.close();
-  }, {
-    type: TypeError,
-    code: 'ERR_INVALID_OPT_VALUE'
-  });
+[null, {}, NaN, '50'].forEach((invalidInput) => {
+  common.expectsError(
+    () => {
+      const fi = new FakeInput();
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        escapeCodeTimeout: invalidInput
+      });
+      rli.close();
+    },
+    {
+      type: TypeError,
+      code: 'ERR_INVALID_OPT_VALUE'
+    }
+  );
 });
diff --git a/test/parallel/test-readline-interface.js b/test/parallel/test-readline-interface.js
index ec553832c42d68..2016d60895ca5d 100644
--- a/test/parallel/test-readline-interface.js
+++ b/test/parallel/test-readline-interface.js
@@ -84,13 +84,16 @@ function isWarned(emitter) {
   rli.close();
 }
 
-[ true, false ].forEach(function(terminal) {
+[true, false].forEach(function(terminal) {
   // disable history
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal, historySize: 0 }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal,
+      historySize: 0
+    });
     assert.strictEqual(rli.historySize, 0);
 
     fi.emit('data', 'asdf\n');
@@ -101,9 +104,11 @@ function isWarned(emitter) {
   // default history size 30
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     assert.strictEqual(rli.historySize, 30);
 
     fi.emit('data', 'asdf\n');
@@ -114,9 +119,11 @@ function isWarned(emitter) {
   // sending a full line
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     let called = false;
     rli.on('line', function(line) {
       called = true;
@@ -129,9 +136,11 @@ function isWarned(emitter) {
   // sending a blank line
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     let called = false;
     rli.on('line', function(line) {
       called = true;
@@ -157,9 +166,11 @@ function isWarned(emitter) {
   // sending a single character with no newline and then a newline
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     let called = false;
     rli.on('line', function(line) {
       called = true;
@@ -175,9 +186,11 @@ function isWarned(emitter) {
   // sending multiple newlines at once
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     const expectedLines = ['foo', 'bar', 'baz'];
     let callCount = 0;
     rli.on('line', function(line) {
@@ -192,9 +205,11 @@ function isWarned(emitter) {
   // sending multiple newlines at once that does not end with a new line
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     const expectedLines = ['foo', 'bar', 'baz', 'bat'];
     let callCount = 0;
     rli.on('line', function(line) {
@@ -210,9 +225,11 @@ function isWarned(emitter) {
   // line and a `end` event
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     const expectedLines = ['foo', 'bar', 'baz', ''];
     let callCount = 0;
     rli.on('line', function(line) {
@@ -234,9 +251,11 @@ function isWarned(emitter) {
   // \r should behave like \n when alone
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: true }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: true
+    });
     const expectedLines = ['foo', 'bar', 'baz', 'bat'];
     let callCount = 0;
     rli.on('line', function(line) {
@@ -251,10 +270,12 @@ function isWarned(emitter) {
   // \r at start of input should output blank line
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: true }
-    );
-    const expectedLines = ['', 'foo' ];
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: true
+    });
+    const expectedLines = ['', 'foo'];
     let callCount = 0;
     rli.on('line', function(line) {
       assert.strictEqual(line, expectedLines[callCount]);
@@ -281,11 +302,14 @@ function isWarned(emitter) {
       callCount++;
     });
     fi.emit('data', '\r');
-    setTimeout(common.mustCall(() => {
-      fi.emit('data', '\n');
-      assert.strictEqual(callCount, 2);
-      rli.close();
-    }), delay * 2);
+    setTimeout(
+      common.mustCall(() => {
+        fi.emit('data', '\n');
+        assert.strictEqual(callCount, 2);
+        rli.close();
+      }),
+      delay * 2
+    );
   }
 
   // set crlfDelay to `Infinity` is allowed
@@ -304,20 +328,25 @@ function isWarned(emitter) {
       callCount++;
     });
     fi.emit('data', '\r');
-    setTimeout(common.mustCall(() => {
-      fi.emit('data', '\n');
-      assert.strictEqual(callCount, 1);
-      rli.close();
-    }), delay);
+    setTimeout(
+      common.mustCall(() => {
+        fi.emit('data', '\n');
+        assert.strictEqual(callCount, 1);
+        rli.close();
+      }),
+      delay
+    );
   }
 
   // \t when there is no completer function should behave like an ordinary
   // character
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: true }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: true
+    });
     let called = false;
     rli.on('line', function(line) {
       assert.strictEqual(line, '\t');
@@ -357,46 +386,61 @@ function isWarned(emitter) {
   // constructor throws if completer is not a function or undefined
   {
     const fi = new FakeInput();
-    common.expectsError(function() {
-      readline.createInterface({
-        input: fi,
-        completer: 'string is not valid'
-      });
-    }, {
-      type: TypeError,
-      code: 'ERR_INVALID_OPT_VALUE'
-    });
+    common.expectsError(
+      function() {
+        readline.createInterface({
+          input: fi,
+          completer: 'string is not valid'
+        });
+      },
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE'
+      }
+    );
   }
 
   // constructor throws if historySize is not a positive number
   {
     const fi = new FakeInput();
-    common.expectsError(function() {
-      readline.createInterface({
-        input: fi, historySize: 'not a number'
-      });
-    }, {
-      type: RangeError,
-      code: 'ERR_INVALID_OPT_VALUE'
-    });
+    common.expectsError(
+      function() {
+        readline.createInterface({
+          input: fi,
+          historySize: 'not a number'
+        });
+      },
+      {
+        type: RangeError,
+        code: 'ERR_INVALID_OPT_VALUE'
+      }
+    );
 
-    common.expectsError(function() {
-      readline.createInterface({
-        input: fi, historySize: -1
-      });
-    }, {
-      type: RangeError,
-      code: 'ERR_INVALID_OPT_VALUE'
-    });
+    common.expectsError(
+      function() {
+        readline.createInterface({
+          input: fi,
+          historySize: -1
+        });
+      },
+      {
+        type: RangeError,
+        code: 'ERR_INVALID_OPT_VALUE'
+      }
+    );
 
-    common.expectsError(function() {
-      readline.createInterface({
-        input: fi, historySize: NaN
-      });
-    }, {
-      type: RangeError,
-      code: 'ERR_INVALID_OPT_VALUE'
-    });
+    common.expectsError(
+      function() {
+        readline.createInterface({
+          input: fi,
+          historySize: NaN
+        });
+      },
+      {
+        type: RangeError,
+        code: 'ERR_INVALID_OPT_VALUE'
+      }
+    );
   }
 
   // duplicate lines are removed from history when
@@ -476,9 +520,11 @@ function isWarned(emitter) {
   {
     const buf = Buffer.from('☮', 'utf8');
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     let callCount = 0;
     rli.on('line', function(line) {
       callCount++;
@@ -497,9 +543,11 @@ function isWarned(emitter) {
   // check that nothing fails if 'keypress' event throws.
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: true }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: true
+    });
     const keys = [];
     fi.on('keypress', function(key) {
       keys.push(key);
@@ -509,7 +557,7 @@ function isWarned(emitter) {
     });
     try {
       fi.emit('data', 'fooX');
-    } catch { }
+    } catch {}
     fi.emit('data', 'bar');
     assert.strictEqual(keys.join(''), 'fooXbar');
     rli.close();
@@ -518,9 +566,11 @@ function isWarned(emitter) {
   // calling readline without `new`
   {
     const fi = new FakeInput();
-    const rli = readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     let called = false;
     rli.on('line', function(line) {
       called = true;
@@ -535,9 +585,11 @@ function isWarned(emitter) {
   {
     let called = false;
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: fi, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal
+    });
     rli.question('foo?', function(answer) {
       called = true;
       assert.strictEqual(answer, 'bar');
@@ -551,9 +603,12 @@ function isWarned(emitter) {
     // history is bound
     {
       const fi = new FakeInput();
-      const rli = new readline.Interface(
-        { input: fi, output: fi, terminal, historySize: 2 }
-      );
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        terminal,
+        historySize: 2
+      });
       const lines = ['line 1', 'line 2', 'line 3'];
       fi.emit('data', lines.join('\n') + '\n');
       assert.strictEqual(rli.history.length, 2);
@@ -563,9 +618,11 @@ function isWarned(emitter) {
     // question
     {
       const fi = new FakeInput();
-      const rli = new readline.Interface(
-        { input: fi, output: fi, terminal: terminal }
-      );
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        terminal: terminal
+      });
       const expectedLines = ['foo'];
       rli.question(expectedLines[0], function() {
         rli.close();
@@ -579,9 +636,11 @@ function isWarned(emitter) {
     // sending a multi-line question
     {
       const fi = new FakeInput();
-      const rli = new readline.Interface(
-        { input: fi, output: fi, terminal: terminal }
-      );
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        terminal: terminal
+      });
       const expectedLines = ['foo', 'bar'];
       rli.question(expectedLines.join('\n'), function() {
         rli.close();
@@ -685,41 +744,46 @@ function isWarned(emitter) {
         { ctrl: true, name: 'w' },
         { ctrl: true, name: 'backspace' },
         { meta: true, name: 'backspace' }
-      ]
-        .forEach((deleteWordLeftKey) => {
-          let fi = new FakeInput();
-          let rli = new readline.Interface({
-            input: fi,
-            output: fi,
-            prompt: '',
-            terminal: terminal
-          });
-          fi.emit('data', 'the quick brown fox');
-          fi.emit('keypress', '.', { ctrl: true, name: 'left' });
-          rli.on('line', common.mustCall((line) => {
+      ].forEach((deleteWordLeftKey) => {
+        let fi = new FakeInput();
+        let rli = new readline.Interface({
+          input: fi,
+          output: fi,
+          prompt: '',
+          terminal: terminal
+        });
+        fi.emit('data', 'the quick brown fox');
+        fi.emit('keypress', '.', { ctrl: true, name: 'left' });
+        rli.on(
+          'line',
+          common.mustCall((line) => {
             assert.strictEqual(line, 'the quick fox');
-          }));
-          fi.emit('keypress', '.', deleteWordLeftKey);
-          fi.emit('data', '\n');
-          rli.close();
-
-          // No effect if pressed at beginning of line
-          fi = new FakeInput();
-          rli = new readline.Interface({
-            input: fi,
-            output: fi,
-            prompt: '',
-            terminal: terminal
-          });
-          fi.emit('data', 'the quick brown fox');
-          fi.emit('keypress', '.', { ctrl: true, name: 'a' });
-          rli.on('line', common.mustCall((line) => {
-            assert.strictEqual(line, 'the quick brown fox');
-          }));
-          fi.emit('keypress', '.', deleteWordLeftKey);
-          fi.emit('data', '\n');
-          rli.close();
+          })
+        );
+        fi.emit('keypress', '.', deleteWordLeftKey);
+        fi.emit('data', '\n');
+        rli.close();
+
+        // No effect if pressed at beginning of line
+        fi = new FakeInput();
+        rli = new readline.Interface({
+          input: fi,
+          output: fi,
+          prompt: '',
+          terminal: terminal
         });
+        fi.emit('data', 'the quick brown fox');
+        fi.emit('keypress', '.', { ctrl: true, name: 'a' });
+        rli.on(
+          'line',
+          common.mustCall((line) => {
+            assert.strictEqual(line, 'the quick brown fox');
+          })
+        );
+        fi.emit('keypress', '.', deleteWordLeftKey);
+        fi.emit('data', '\n');
+        rli.close();
+      });
     }
 
     {
@@ -728,41 +792,46 @@ function isWarned(emitter) {
         { ctrl: true, name: 'delete' },
         { meta: true, name: 'delete' },
         { meta: true, name: 'd' }
-      ]
-        .forEach((deleteWordRightKey) => {
-          let fi = new FakeInput();
-          let rli = new readline.Interface({
-            input: fi,
-            output: fi,
-            prompt: '',
-            terminal: terminal
-          });
-          fi.emit('data', 'the quick brown fox');
-          fi.emit('keypress', '.', { ctrl: true, name: 'left' });
-          fi.emit('keypress', '.', { ctrl: true, name: 'left' });
-          rli.on('line', common.mustCall((line) => {
+      ].forEach((deleteWordRightKey) => {
+        let fi = new FakeInput();
+        let rli = new readline.Interface({
+          input: fi,
+          output: fi,
+          prompt: '',
+          terminal: terminal
+        });
+        fi.emit('data', 'the quick brown fox');
+        fi.emit('keypress', '.', { ctrl: true, name: 'left' });
+        fi.emit('keypress', '.', { ctrl: true, name: 'left' });
+        rli.on(
+          'line',
+          common.mustCall((line) => {
             assert.strictEqual(line, 'the quick fox');
-          }));
-          fi.emit('keypress', '.', deleteWordRightKey);
-          fi.emit('data', '\n');
-          rli.close();
-
-          // No effect if pressed at end of line
-          fi = new FakeInput();
-          rli = new readline.Interface({
-            input: fi,
-            output: fi,
-            prompt: '',
-            terminal: terminal
-          });
-          fi.emit('data', 'the quick brown fox');
-          rli.on('line', common.mustCall((line) => {
-            assert.strictEqual(line, 'the quick brown fox');
-          }));
-          fi.emit('keypress', '.', deleteWordRightKey);
-          fi.emit('data', '\n');
-          rli.close();
+          })
+        );
+        fi.emit('keypress', '.', deleteWordRightKey);
+        fi.emit('data', '\n');
+        rli.close();
+
+        // No effect if pressed at end of line
+        fi = new FakeInput();
+        rli = new readline.Interface({
+          input: fi,
+          output: fi,
+          prompt: '',
+          terminal: terminal
         });
+        fi.emit('data', 'the quick brown fox');
+        rli.on(
+          'line',
+          common.mustCall((line) => {
+            assert.strictEqual(line, 'the quick brown fox');
+          })
+        );
+        fi.emit('keypress', '.', deleteWordRightKey);
+        fi.emit('data', '\n');
+        rli.close();
+      });
     }
 
     // deleteLeft
@@ -784,9 +853,12 @@ function isWarned(emitter) {
       cursorPos = rli._getCursorPos();
       assert.strictEqual(cursorPos.rows, 0);
       assert.strictEqual(cursorPos.cols, 18);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, 'the quick brown fo');
-      }));
+      rli.on(
+        'line',
+        common.mustCall((line) => {
+          assert.strictEqual(line, 'the quick brown fo');
+        })
+      );
       fi.emit('data', '\n');
       rli.close();
     }
@@ -813,14 +885,16 @@ function isWarned(emitter) {
       cursorPos = rli._getCursorPos();
       assert.strictEqual(cursorPos.rows, 0);
       assert.strictEqual(cursorPos.cols, 0);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, 'he quick brown fox');
-      }));
+      rli.on(
+        'line',
+        common.mustCall((line) => {
+          assert.strictEqual(line, 'he quick brown fox');
+        })
+      );
       fi.emit('data', '\n');
       rli.close();
     }
 
-
     // deleteLineLeft
     {
       const fi = new FakeInput();
@@ -840,9 +914,12 @@ function isWarned(emitter) {
       cursorPos = rli._getCursorPos();
       assert.strictEqual(cursorPos.rows, 0);
       assert.strictEqual(cursorPos.cols, 0);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '');
-      }));
+      rli.on(
+        'line',
+        common.mustCall((line) => {
+          assert.strictEqual(line, '');
+        })
+      );
       fi.emit('data', '\n');
       rli.close();
     }
@@ -869,9 +946,12 @@ function isWarned(emitter) {
       cursorPos = rli._getCursorPos();
       assert.strictEqual(cursorPos.rows, 0);
       assert.strictEqual(cursorPos.cols, 0);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, '');
-      }));
+      rli.on(
+        'line',
+        common.mustCall((line) => {
+          assert.strictEqual(line, '');
+        })
+      );
       fi.emit('data', '\n');
       rli.close();
     }
@@ -908,9 +988,12 @@ function isWarned(emitter) {
       const cursorPos = rli._getCursorPos();
       assert.strictEqual(cursorPos.rows, 0);
       assert.strictEqual(cursorPos.cols, 6);
-      rli.on('line', common.mustCall((line) => {
-        assert.strictEqual(line, 'line 3');
-      }));
+      rli.on(
+        'line',
+        common.mustCall((line) => {
+          assert.strictEqual(line, 'line 3');
+        })
+      );
       fi.emit('data', '\n');
       rli.close();
     }
@@ -922,14 +1005,22 @@ function isWarned(emitter) {
   });
 
   // wide characters should be treated as two columns.
-  assert.strictEqual(internalReadline.isFullWidthCodePoint('a'.charCodeAt(0)),
-                     false);
-  assert.strictEqual(internalReadline.isFullWidthCodePoint('あ'.charCodeAt(0)),
-                     true);
-  assert.strictEqual(internalReadline.isFullWidthCodePoint('谢'.charCodeAt(0)),
-                     true);
-  assert.strictEqual(internalReadline.isFullWidthCodePoint('고'.charCodeAt(0)),
-                     true);
+  assert.strictEqual(
+    internalReadline.isFullWidthCodePoint('a'.charCodeAt(0)),
+    false
+  );
+  assert.strictEqual(
+    internalReadline.isFullWidthCodePoint('あ'.charCodeAt(0)),
+    true
+  );
+  assert.strictEqual(
+    internalReadline.isFullWidthCodePoint('谢'.charCodeAt(0)),
+    true
+  );
+  assert.strictEqual(
+    internalReadline.isFullWidthCodePoint('고'.charCodeAt(0)),
+    true
+  );
   assert.strictEqual(internalReadline.isFullWidthCodePoint(0x1f251), true);
   assert.strictEqual(internalReadline.getStringWidth('abcde'), 5);
   assert.strictEqual(internalReadline.getStringWidth('古池や'), 6);
@@ -951,16 +1042,19 @@ function isWarned(emitter) {
     internalReadline.stripVTControlCharacters('\u001b[31m\u001b[39m'),
     ''
   );
+  assert.strictEqual(internalReadline.stripVTControlCharacters('> '), '> ');
   assert.strictEqual(
-    internalReadline.stripVTControlCharacters('> '),
-    '> '
+    internalReadline.getStringWidth('\u001b[31m> \u001b[39m'),
+    2
+  );
+  assert.strictEqual(
+    internalReadline.getStringWidth('\u001b[31m> \u001b[39m> '),
+    4
+  );
+  assert.strictEqual(
+    internalReadline.getStringWidth('\u001b[31m\u001b[39m'),
+    0
   );
-  assert.strictEqual(internalReadline
-    .getStringWidth('\u001b[31m> \u001b[39m'), 2);
-  assert.strictEqual(internalReadline
-    .getStringWidth('\u001b[31m> \u001b[39m> '), 4);
-  assert.strictEqual(internalReadline
-    .getStringWidth('\u001b[31m\u001b[39m'), 0);
   assert.strictEqual(internalReadline.getStringWidth('> '), 2);
 
   {
@@ -982,9 +1076,11 @@ function isWarned(emitter) {
   // can create a new readline Interface with a null output argument
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      { input: fi, output: null, terminal: terminal }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: null,
+      terminal: terminal
+    });
 
     let called = false;
     rli.on('line', function(line) {
@@ -1004,9 +1100,9 @@ function isWarned(emitter) {
   }
 
   {
-    const expected = terminal ?
-      ['\u001b[1G', '\u001b[0J', '$ ', '\u001b[3G'] :
-      ['$ '];
+    const expected = terminal
+      ? ['\u001b[1G', '\u001b[0J', '$ ', '\u001b[3G']
+      : ['$ '];
 
     let counter = 0;
     const output = new Writable({
@@ -1036,21 +1132,19 @@ function isWarned(emitter) {
 // CPU stress.
 const crlfDelay = Infinity;
 
-[ true, false ].forEach(function(terminal) {
+[true, false].forEach(function(terminal) {
   // sending multiple newlines at once that does not end with a new line
   // and a `end` event(last line is)
 
   // \r\n should emit one line event, not two
   {
     const fi = new FakeInput();
-    const rli = new readline.Interface(
-      {
-        input: fi,
-        output: fi,
-        terminal: terminal,
-        crlfDelay
-      }
-    );
+    const rli = new readline.Interface({
+      input: fi,
+      output: fi,
+      terminal: terminal,
+      crlfDelay
+    });
     const expectedLines = ['foo', 'bar', 'baz', 'bat'];
     let callCount = 0;
     rli.on('line', function(line) {
@@ -1099,10 +1193,13 @@ const crlfDelay = Infinity;
     let callCount = 0;
     rli.on('line', () => callCount++);
     fi.emit('data', '\r');
-    setTimeout(common.mustCall(() => {
-      fi.emit('data', '\n');
-      assert.strictEqual(callCount, 1);
-      rli.close();
-    }), delay);
+    setTimeout(
+      common.mustCall(() => {
+        fi.emit('data', '\n');
+        assert.strictEqual(callCount, 1);
+        rli.close();
+      }),
+      delay
+    );
   }
 });
diff --git a/test/parallel/test-readline-keys.js b/test/parallel/test-readline-keys.js
index b1c88e2acee157..fcf1c492863884 100644
--- a/test/parallel/test-readline-keys.js
+++ b/test/parallel/test-readline-keys.js
@@ -10,7 +10,6 @@ function extend(k) {
   return Object.assign({ ctrl: false, meta: false, shift: false }, k);
 }
 
-
 const fi = new FakeInput();
 const fo = new FakeInput();
 new Interface({ input: fi, output: fo, terminal: true });
@@ -20,14 +19,13 @@ fi.on('keypress', (s, k) => {
   keys.push(k);
 });
 
-
 function addTest(sequences, expectedKeys) {
   if (!Array.isArray(sequences)) {
-    sequences = [ sequences ];
+    sequences = [sequences];
   }
 
   if (!Array.isArray(expectedKeys)) {
-    expectedKeys = [ expectedKeys ];
+    expectedKeys = [expectedKeys];
   }
 
   expectedKeys = expectedKeys.map(extend);
@@ -49,16 +47,19 @@ function addTest(sequences, expectedKeys) {
 //      (addKeyIntervalTest(..)(noop)))()
 // where noop is a terminal function(() => {}).
 
-const addKeyIntervalTest = (sequences, expectedKeys, interval = 550,
-                            assertDelay = 550) => {
+const addKeyIntervalTest = (
+  sequences,
+  expectedKeys,
+  interval = 550,
+  assertDelay = 550
+) => {
   const fn = common.mustCall((next) => () => {
-
     if (!Array.isArray(sequences)) {
-      sequences = [ sequences ];
+      sequences = [sequences];
     }
 
     if (!Array.isArray(expectedKeys)) {
-      expectedKeys = [ expectedKeys ];
+      expectedKeys = [expectedKeys];
     }
 
     expectedKeys = expectedKeys.map(extend);
@@ -88,14 +89,14 @@ addTest('io.JS', [
   { name: 'o', sequence: 'o' },
   { name: undefined, sequence: '.' },
   { name: 'j', sequence: 'J', shift: true },
-  { name: 's', sequence: 'S', shift: true },
+  { name: 's', sequence: 'S', shift: true }
 ]);
 
 // named characters
 addTest('\n\r\t', [
   { name: 'enter', sequence: '\n' },
   { name: 'return', sequence: '\r' },
-  { name: 'tab', sequence: '\t' },
+  { name: 'tab', sequence: '\t' }
 ]);
 
 // space and backspace
@@ -106,19 +107,19 @@ addTest('\b\x7f\x1b\b\x1b\x7f\x1b\x1b  \x1b ', [
   { name: 'backspace', sequence: '\x1b\x7f', meta: true },
   { name: 'space', sequence: '\x1b\x1b ', meta: true },
   { name: 'space', sequence: ' ' },
-  { name: 'space', sequence: '\x1b ', meta: true },
+  { name: 'space', sequence: '\x1b ', meta: true }
 ]);
 
 // escape key
 addTest('\x1b\x1b\x1b', [
-  { name: 'escape', sequence: '\x1b\x1b\x1b', meta: true },
+  { name: 'escape', sequence: '\x1b\x1b\x1b', meta: true }
 ]);
 
 // control keys
 addTest('\x01\x0b\x10', [
   { name: 'a', sequence: '\x01', ctrl: true },
   { name: 'k', sequence: '\x0b', ctrl: true },
-  { name: 'p', sequence: '\x10', ctrl: true },
+  { name: 'p', sequence: '\x10', ctrl: true }
 ]);
 
 // alt keys
@@ -126,7 +127,7 @@ addTest('a\x1baA\x1bA', [
   { name: 'a', sequence: 'a' },
   { name: 'a', sequence: '\x1ba', meta: true },
   { name: 'a', sequence: 'A', shift: true },
-  { name: 'a', sequence: '\x1bA', meta: true, shift: true },
+  { name: 'a', sequence: '\x1bA', meta: true, shift: true }
 ]);
 
 // xterm/gnome ESC O letter
@@ -134,7 +135,7 @@ addTest('\x1bOP\x1bOQ\x1bOR\x1bOS', [
   { name: 'f1', sequence: '\x1bOP', code: 'OP' },
   { name: 'f2', sequence: '\x1bOQ', code: 'OQ' },
   { name: 'f3', sequence: '\x1bOR', code: 'OR' },
-  { name: 'f4', sequence: '\x1bOS', code: 'OS' },
+  { name: 'f4', sequence: '\x1bOS', code: 'OS' }
 ]);
 
 // xterm/rxvt ESC [ number ~ */
@@ -142,7 +143,7 @@ addTest('\x1b[11~\x1b[12~\x1b[13~\x1b[14~', [
   { name: 'f1', sequence: '\x1b[11~', code: '[11~' },
   { name: 'f2', sequence: '\x1b[12~', code: '[12~' },
   { name: 'f3', sequence: '\x1b[13~', code: '[13~' },
-  { name: 'f4', sequence: '\x1b[14~', code: '[14~' },
+  { name: 'f4', sequence: '\x1b[14~', code: '[14~' }
 ]);
 
 // from Cygwin and used in libuv
@@ -151,7 +152,7 @@ addTest('\x1b[[A\x1b[[B\x1b[[C\x1b[[D\x1b[[E', [
   { name: 'f2', sequence: '\x1b[[B', code: '[[B' },
   { name: 'f3', sequence: '\x1b[[C', code: '[[C' },
   { name: 'f4', sequence: '\x1b[[D', code: '[[D' },
-  { name: 'f5', sequence: '\x1b[[E', code: '[[E' },
+  { name: 'f5', sequence: '\x1b[[E', code: '[[E' }
 ]);
 
 // common
@@ -163,7 +164,7 @@ addTest('\x1b[15~\x1b[17~\x1b[18~\x1b[19~\x1b[20~\x1b[21~\x1b[23~\x1b[24~', [
   { name: 'f9', sequence: '\x1b[20~', code: '[20~' },
   { name: 'f10', sequence: '\x1b[21~', code: '[21~' },
   { name: 'f11', sequence: '\x1b[23~', code: '[23~' },
-  { name: 'f12', sequence: '\x1b[24~', code: '[24~' },
+  { name: 'f12', sequence: '\x1b[24~', code: '[24~' }
 ]);
 
 // xterm ESC [ letter
@@ -174,7 +175,7 @@ addTest('\x1b[A\x1b[B\x1b[C\x1b[D\x1b[E\x1b[F\x1b[H', [
   { name: 'left', sequence: '\x1b[D', code: '[D' },
   { name: 'clear', sequence: '\x1b[E', code: '[E' },
   { name: 'end', sequence: '\x1b[F', code: '[F' },
-  { name: 'home', sequence: '\x1b[H', code: '[H' },
+  { name: 'home', sequence: '\x1b[H', code: '[H' }
 ]);
 
 // xterm/gnome ESC O letter
@@ -185,13 +186,13 @@ addTest('\x1bOA\x1bOB\x1bOC\x1bOD\x1bOE\x1bOF\x1bOH', [
   { name: 'left', sequence: '\x1bOD', code: 'OD' },
   { name: 'clear', sequence: '\x1bOE', code: 'OE' },
   { name: 'end', sequence: '\x1bOF', code: 'OF' },
-  { name: 'home', sequence: '\x1bOH', code: 'OH' },
+  { name: 'home', sequence: '\x1bOH', code: 'OH' }
 ]);
 
 // old xterm shift-arrows
 addTest('\x1bO2A\x1bO2B', [
   { name: 'up', sequence: '\x1bO2A', code: 'OA', shift: true },
-  { name: 'down', sequence: '\x1bO2B', code: 'OB', shift: true },
+  { name: 'down', sequence: '\x1bO2B', code: 'OB', shift: true }
 ]);
 
 // xterm/rxvt ESC [ number ~
@@ -201,19 +202,19 @@ addTest('\x1b[1~\x1b[2~\x1b[3~\x1b[4~\x1b[5~\x1b[6~', [
   { name: 'delete', sequence: '\x1b[3~', code: '[3~' },
   { name: 'end', sequence: '\x1b[4~', code: '[4~' },
   { name: 'pageup', sequence: '\x1b[5~', code: '[5~' },
-  { name: 'pagedown', sequence: '\x1b[6~', code: '[6~' },
+  { name: 'pagedown', sequence: '\x1b[6~', code: '[6~' }
 ]);
 
 // putty
 addTest('\x1b[[5~\x1b[[6~', [
   { name: 'pageup', sequence: '\x1b[[5~', code: '[[5~' },
-  { name: 'pagedown', sequence: '\x1b[[6~', code: '[[6~' },
+  { name: 'pagedown', sequence: '\x1b[[6~', code: '[[6~' }
 ]);
 
 // rxvt
 addTest('\x1b[7~\x1b[8~', [
   { name: 'home', sequence: '\x1b[7~', code: '[7~' },
-  { name: 'end', sequence: '\x1b[8~', code: '[8~' },
+  { name: 'end', sequence: '\x1b[8~', code: '[8~' }
 ]);
 
 // gnome terminal
@@ -221,42 +222,45 @@ addTest('\x1b[A\x1b[B\x1b[2A\x1b[2B', [
   { name: 'up', sequence: '\x1b[A', code: '[A' },
   { name: 'down', sequence: '\x1b[B', code: '[B' },
   { name: 'up', sequence: '\x1b[2A', code: '[A', shift: true },
-  { name: 'down', sequence: '\x1b[2B', code: '[B', shift: true },
+  { name: 'down', sequence: '\x1b[2B', code: '[B', shift: true }
 ]);
 
 // rxvt keys with modifiers
 // eslint-disable-next-line max-len
-addTest('\x1b[20~\x1b[2$\x1b[2^\x1b[3$\x1b[3^\x1b[5$\x1b[5^\x1b[6$\x1b[6^\x1b[7$\x1b[7^\x1b[8$\x1b[8^', [
-  { name: 'f9', sequence: '\x1b[20~', code: '[20~' },
-  { name: 'insert', sequence: '\x1b[2$', code: '[2$', shift: true },
-  { name: 'insert', sequence: '\x1b[2^', code: '[2^', ctrl: true },
-  { name: 'delete', sequence: '\x1b[3$', code: '[3$', shift: true },
-  { name: 'delete', sequence: '\x1b[3^', code: '[3^', ctrl: true },
-  { name: 'pageup', sequence: '\x1b[5$', code: '[5$', shift: true },
-  { name: 'pageup', sequence: '\x1b[5^', code: '[5^', ctrl: true },
-  { name: 'pagedown', sequence: '\x1b[6$', code: '[6$', shift: true },
-  { name: 'pagedown', sequence: '\x1b[6^', code: '[6^', ctrl: true },
-  { name: 'home', sequence: '\x1b[7$', code: '[7$', shift: true },
-  { name: 'home', sequence: '\x1b[7^', code: '[7^', ctrl: true },
-  { name: 'end', sequence: '\x1b[8$', code: '[8$', shift: true },
-  { name: 'end', sequence: '\x1b[8^', code: '[8^', ctrl: true },
-]);
+addTest(
+  '\x1b[20~\x1b[2$\x1b[2^\x1b[3$\x1b[3^\x1b[5$\x1b[5^\x1b[6$\x1b[6^\x1b[7$\x1b[7^\x1b[8$\x1b[8^',
+  [
+    { name: 'f9', sequence: '\x1b[20~', code: '[20~' },
+    { name: 'insert', sequence: '\x1b[2$', code: '[2$', shift: true },
+    { name: 'insert', sequence: '\x1b[2^', code: '[2^', ctrl: true },
+    { name: 'delete', sequence: '\x1b[3$', code: '[3$', shift: true },
+    { name: 'delete', sequence: '\x1b[3^', code: '[3^', ctrl: true },
+    { name: 'pageup', sequence: '\x1b[5$', code: '[5$', shift: true },
+    { name: 'pageup', sequence: '\x1b[5^', code: '[5^', ctrl: true },
+    { name: 'pagedown', sequence: '\x1b[6$', code: '[6$', shift: true },
+    { name: 'pagedown', sequence: '\x1b[6^', code: '[6^', ctrl: true },
+    { name: 'home', sequence: '\x1b[7$', code: '[7$', shift: true },
+    { name: 'home', sequence: '\x1b[7^', code: '[7^', ctrl: true },
+    { name: 'end', sequence: '\x1b[8$', code: '[8$', shift: true },
+    { name: 'end', sequence: '\x1b[8^', code: '[8^', ctrl: true }
+  ]
+);
 
 // misc
 addTest('\x1b[Z', [
-  { name: 'tab', sequence: '\x1b[Z', code: '[Z', shift: true },
+  { name: 'tab', sequence: '\x1b[Z', code: '[Z', shift: true }
 ]);
 
 // xterm + modifiers
 addTest('\x1b[20;5~\x1b[6;5^', [
   { name: 'f9', sequence: '\x1b[20;5~', code: '[20~', ctrl: true },
-  { name: 'pagedown', sequence: '\x1b[6;5^', code: '[6^', ctrl: true },
+  { name: 'pagedown', sequence: '\x1b[6;5^', code: '[6^', ctrl: true }
 ]);
 
 addTest('\x1b[H\x1b[5H\x1b[1;5H', [
   { name: 'home', sequence: '\x1b[H', code: '[H' },
   { name: 'home', sequence: '\x1b[5H', code: '[H', ctrl: true },
-  { name: 'home', sequence: '\x1b[1;5H', code: '[H', ctrl: true },
+  { name: 'home', sequence: '\x1b[1;5H', code: '[H', ctrl: true }
 ]);
 
 // escape sequences broken into multiple data chunks
@@ -264,7 +268,7 @@ addTest('\x1b[D\x1b[C\x1b[D\x1b[C'.split(''), [
   { name: 'left', sequence: '\x1b[D', code: '[D' },
   { name: 'right', sequence: '\x1b[C', code: '[C' },
   { name: 'left', sequence: '\x1b[D', code: '[D' },
-  { name: 'right', sequence: '\x1b[C', code: '[C' },
+  { name: 'right', sequence: '\x1b[C', code: '[C' }
 ]);
 
 // escape sequences mixed with regular ones
@@ -274,7 +278,7 @@ addTest('\x1b[DD\x1b[2DD\x1b[2^D', [
   { name: 'left', sequence: '\x1b[2D', code: '[D', shift: true },
   { name: 'd', sequence: 'D', shift: true },
   { name: 'insert', sequence: '\x1b[2^', code: '[2^', ctrl: true },
-  { name: 'd', sequence: 'D', shift: true },
+  { name: 'd', sequence: 'D', shift: true }
 ]);
 
 // color sequences
@@ -282,7 +286,7 @@ addTest('\x1b[31ma\x1b[39ma', [
   { name: 'undefined', sequence: '\x1b[31m', code: '[31m' },
   { name: 'a', sequence: 'a' },
   { name: 'undefined', sequence: '\x1b[39m', code: '[39m' },
-  { name: 'a', sequence: 'a' },
+  { name: 'a', sequence: 'a' }
 ]);
 
 // rxvt keys with modifiers
@@ -291,7 +295,7 @@ addTest('\x1b[a\x1b[b\x1b[c\x1b[d\x1b[e', [
   { name: 'down', sequence: '\x1b[b', code: '[b', shift: true },
   { name: 'right', sequence: '\x1b[c', code: '[c', shift: true },
   { name: 'left', sequence: '\x1b[d', code: '[d', shift: true },
-  { name: 'clear', sequence: '\x1b[e', code: '[e', shift: true },
+  { name: 'clear', sequence: '\x1b[e', code: '[e', shift: true }
 ]);
 
 addTest('\x1bOa\x1bOb\x1bOc\x1bOd\x1bOe', [
@@ -299,7 +303,7 @@ addTest('\x1bOa\x1bOb\x1bOc\x1bOd\x1bOe', [
   { name: 'down', sequence: '\x1bOb', code: 'Ob', ctrl: true },
   { name: 'right', sequence: '\x1bOc', code: 'Oc', ctrl: true },
   { name: 'left', sequence: '\x1bOd', code: 'Od', ctrl: true },
-  { name: 'clear', sequence: '\x1bOe', code: 'Oe', ctrl: true },
+  { name: 'clear', sequence: '\x1bOe', code: 'Oe', ctrl: true }
 ]);
 
 // Reduce array of addKeyIntervalTest(..) right to left
@@ -316,7 +320,9 @@ const runKeyIntervalTests = [
     { name: 'escape', sequence: '\x1b', meta: true },
     { name: 'escape', sequence: '\x1b', meta: true }
   ])
-].reverse().reduce((acc, fn) => fn(acc), () => {});
+]
+  .reverse()
+  .reduce((acc, fn) => fn(acc), () => {});
 
 // run key interval tests one after another
 runKeyIntervalTests();
diff --git a/test/parallel/test-readline-position.js b/test/parallel/test-readline-position.js
index 4e1114418eb380..f5c54c82bd2668 100644
--- a/test/parallel/test-readline-position.js
+++ b/test/parallel/test-readline-position.js
@@ -14,22 +14,18 @@ const ctrlU = { ctrl: true, name: 'u' };
     prompt: ''
   });
 
-  const tests = [
-    [1, 'a'],
-    [2, 'ab'],
-    [2, '丁']
-  ];
+  const tests = [[1, 'a'], [2, 'ab'], [2, '丁']];
 
   // The non-ICU JS implementation of character width calculation is only aware
   // of the wide/narrow distinction. Only test these more advanced cases when
   // ICU is available.
   if (process.binding('config').hasIntl) {
     tests.push(
-      [0, '\u0301'],   // COMBINING ACUTE ACCENT
-      [1, 'a\u0301'],  // á
-      [0, '\u20DD'],   // COMBINING ENCLOSING CIRCLE
+      [0, '\u0301'], // COMBINING ACUTE ACCENT
+      [1, 'a\u0301'], // á
+      [0, '\u20DD'], // COMBINING ENCLOSING CIRCLE
       [2, 'a\u20DDb'], // a⃝b
-      [0, '\u200E']    // LEFT-TO-RIGHT MARK
+      [0, '\u200E'] // LEFT-TO-RIGHT MARK
     );
   }
 
diff --git a/test/parallel/test-readline-reopen.js b/test/parallel/test-readline-reopen.js
index dead22d81ac961..b574ad7feb3289 100644
--- a/test/parallel/test-readline-reopen.js
+++ b/test/parallel/test-readline-reopen.js
@@ -21,10 +21,12 @@ rl1.on('line', common.mustCall(rl1OnLine));
 
 // Write a line plus the first byte of a UTF-8 multibyte character to make sure
 // that it doesn’t get lost when closing the readline instance.
-input.write(Buffer.concat([
-  Buffer.from('foo\n'),
-  Buffer.from([ 0xe2 ])  // Exactly one third of a ☃ snowman.
-]));
+input.write(
+  Buffer.concat([
+    Buffer.from('foo\n'),
+    Buffer.from([0xe2]) // Exactly one third of a ☃ snowman.
+  ])
+);
 
 function rl1OnLine(line) {
   assert.strictEqual(line, 'foo');
@@ -35,10 +37,13 @@ function rl1OnLine(line) {
     terminal: true
   });
 
-  rl2.on('line', common.mustCall((line) => {
-    assert.strictEqual(line, '☃bar');
-    rl2.close();
-  }));
+  rl2.on(
+    'line',
+    common.mustCall((line) => {
+      assert.strictEqual(line, '☃bar');
+      rl2.close();
+    })
+  );
   input.write(Buffer.from([0x98, 0x83])); // The rest of the ☃ snowman.
   input.write('bar\n');
 }
diff --git a/test/parallel/test-readline-set-raw-mode.js b/test/parallel/test-readline-set-raw-mode.js
index db42a5a9495a9e..b7e1340762a5b4 100644
--- a/test/parallel/test-readline-set-raw-mode.js
+++ b/test/parallel/test-readline-set-raw-mode.js
@@ -54,7 +54,6 @@ assert(rawModeCalled);
 assert(resumeCalled);
 assert(!pauseCalled);
 
-
 // pause() should call *not* call setRawMode()
 rawModeCalled = false;
 resumeCalled = false;
@@ -64,7 +63,6 @@ assert(!rawModeCalled);
 assert(!resumeCalled);
 assert(pauseCalled);
 
-
 // resume() should *not* call setRawMode()
 rawModeCalled = false;
 resumeCalled = false;
@@ -74,7 +72,6 @@ assert(!rawModeCalled);
 assert(resumeCalled);
 assert(!pauseCalled);
 
-
 // close() should call setRawMode(false)
 expectedRawMode = false;
 rawModeCalled = false;
diff --git a/test/parallel/test-readline-undefined-columns.js b/test/parallel/test-readline-undefined-columns.js
index 40fe2c16d609e9..83ff8af2dcbb04 100644
--- a/test/parallel/test-readline-undefined-columns.js
+++ b/test/parallel/test-readline-undefined-columns.js
@@ -26,17 +26,19 @@ oStream.on('data', function(data) {
   output += data;
 });
 
-oStream.on('end', common.mustCall(() => {
-  const expect = 'process.stdout\r\n' +
-                 'process.stdin\r\n' +
-                 'process.stderr';
-  assert(new RegExp(expect).test(output));
-}));
+oStream.on(
+  'end',
+  common.mustCall(() => {
+    const expect =
+      'process.stdout\r\n' + 'process.stdin\r\n' + 'process.stderr';
+    assert(new RegExp(expect).test(output));
+  })
+);
 
 iStream.write('process.s\t');
 
-assert(/process\.std\b/.test(output));  // Completion works.
-assert(!/stdout/.test(output));  // Completion doesn’t show all results yet.
+assert(/process\.std\b/.test(output)); // Completion works.
+assert(!/stdout/.test(output)); // Completion doesn’t show all results yet.
 
 iStream.write('\t');
 oStream.end();
diff --git a/test/parallel/test-readline.js b/test/parallel/test-readline.js
index d464fdc440c58b..5808e4753ca053 100644
--- a/test/parallel/test-readline.js
+++ b/test/parallel/test-readline.js
@@ -11,9 +11,12 @@ const assert = require('assert');
     input: input
   });
 
-  rl.on('line', common.mustCall((data) => {
-    assert.strictEqual(data, 'abc');
-  }));
+  rl.on(
+    'line',
+    common.mustCall((data) => {
+      assert.strictEqual(data, 'abc');
+    })
+  );
 
   input.end('abc');
 }
@@ -37,9 +40,12 @@ const assert = require('assert');
     input: input
   });
 
-  rl.on('line', common.mustCall((data) => {
-    assert.strictEqual(data, 'abc');
-  }));
+  rl.on(
+    'line',
+    common.mustCall((data) => {
+      assert.strictEqual(data, 'abc');
+    })
+  );
 
   input.write('abc\n');
 }
@@ -57,7 +63,7 @@ const assert = require('assert');
   const key = {
     xterm: {
       home: ['\x1b[H', { ctrl: true, name: 'a' }],
-      end: ['\x1b[F', { ctrl: true, name: 'e' }],
+      end: ['\x1b[F', { ctrl: true, name: 'e' }]
     },
     gnome: {
       home: ['\x1bOH', { ctrl: true, name: 'a' }],
@@ -79,7 +85,6 @@ const assert = require('assert');
     rl.write.apply(rl, key.end);
     assert.strictEqual(rl.cursor, 3);
   });
-
 }
 
 {
@@ -93,7 +98,7 @@ const assert = require('assert');
     xterm: {
       home: ['\x1b[H', { ctrl: true, name: 'a' }],
       metab: ['\x1bb', { meta: true, name: 'b' }],
-      metaf: ['\x1bf', { meta: true, name: 'f' }],
+      metaf: ['\x1bf', { meta: true, name: 'f' }]
     }
   };
 
@@ -111,7 +116,7 @@ const assert = require('assert');
     { cursor: 8, key: key.xterm.metab },
     { cursor: 7, key: key.xterm.metab },
     { cursor: 4, key: key.xterm.metab },
-    { cursor: 0, key: key.xterm.metab },
+    { cursor: 0, key: key.xterm.metab }
   ].forEach(function(action) {
     rl.write.apply(rl, action.key);
     assert.strictEqual(rl.cursor, action.cursor);
@@ -134,14 +139,9 @@ const assert = require('assert');
 
   rl.write('foo bar.hop/zoo');
   rl.write.apply(rl, key.xterm.home);
-  [
-    'bar.hop/zoo',
-    '.hop/zoo',
-    'hop/zoo',
-    '/zoo',
-    'zoo',
-    ''
-  ].forEach(function(expectedLine) {
+  ['bar.hop/zoo', '.hop/zoo', 'hop/zoo', '/zoo', 'zoo', ''].forEach(function(
+    expectedLine
+  ) {
     rl.write.apply(rl, key.xterm.metad);
     assert.strictEqual(rl.cursor, 0);
     assert.strictEqual(rl.line, expectedLine);
diff --git a/test/parallel/test-ref-unref-return.js b/test/parallel/test-ref-unref-return.js
index aec2fff5ce2271..7f9bcfefa322b5 100644
--- a/test/parallel/test-ref-unref-return.js
+++ b/test/parallel/test-ref-unref-return.js
@@ -4,9 +4,9 @@ const assert = require('assert');
 const net = require('net');
 const dgram = require('dgram');
 
-assert.ok((new net.Server()).ref() instanceof net.Server);
-assert.ok((new net.Server()).unref() instanceof net.Server);
-assert.ok((new net.Socket()).ref() instanceof net.Socket);
-assert.ok((new net.Socket()).unref() instanceof net.Socket);
-assert.ok((new dgram.Socket('udp4')).ref() instanceof dgram.Socket);
-assert.ok((new dgram.Socket('udp6')).unref() instanceof dgram.Socket);
+assert.ok(new net.Server().ref() instanceof net.Server);
+assert.ok(new net.Server().unref() instanceof net.Server);
+assert.ok(new net.Socket().ref() instanceof net.Socket);
+assert.ok(new net.Socket().unref() instanceof net.Socket);
+assert.ok(new dgram.Socket('udp4').ref() instanceof dgram.Socket);
+assert.ok(new dgram.Socket('udp6').unref() instanceof dgram.Socket);
diff --git a/test/parallel/test-regression-object-prototype.js b/test/parallel/test-regression-object-prototype.js
index 821c2af584ae3b..b3cf3887225144 100644
--- a/test/parallel/test-regression-object-prototype.js
+++ b/test/parallel/test-regression-object-prototype.js
@@ -22,7 +22,6 @@
 /* eslint-disable node-core/required-modules */
 'use strict';
 
-Object.prototype.xadsadsdasasdxx = function() {
-};
+Object.prototype.xadsadsdasasdxx = function() {};
 
 console.log('puts after');
diff --git a/test/parallel/test-repl-autolibs.js b/test/parallel/test-repl-autolibs.js
index f069d8bf409799..72681e8a43c753 100644
--- a/test/parallel/test-repl-autolibs.js
+++ b/test/parallel/test-repl-autolibs.js
@@ -36,10 +36,11 @@ function test1() {
   putIn.write = function(data) {
     gotWrite = true;
     if (data.length) {
-
       // inspect output matches repl output
-      assert.strictEqual(data,
-                         `${util.inspect(require('fs'), null, 2, false)}\n`);
+      assert.strictEqual(
+        data,
+        `${util.inspect(require('fs'), null, 2, false)}\n`
+      );
       // globally added lib matches required lib
       assert.strictEqual(global.fs, require('fs'));
       test2();
diff --git a/test/parallel/test-repl-definecommand.js b/test/parallel/test-repl-definecommand.js
index efa22ed56f740f..d1c0b8b3dc407f 100644
--- a/test/parallel/test-repl-definecommand.js
+++ b/test/parallel/test-repl-definecommand.js
@@ -35,16 +35,26 @@ r.defineCommand('say2', function() {
 });
 
 inputStream.write('.help\n');
-assert(/\n\.say1     help for say1\n/.test(output),
-       'help for say1 not present');
+assert(
+  /\n\.say1     help for say1\n/.test(output),
+  'help for say1 not present'
+);
 assert(/\n\.say2\n/.test(output), 'help for say2 not present');
 inputStream.write('.say1 node developer\n');
-assert.ok(output.startsWith('hello node developer\n'),
-          `say1 output starts incorrectly: "${output}"`);
-assert.ok(output.includes('> '),
-          `say1 output does not include prompt: "${output}"`);
+assert.ok(
+  output.startsWith('hello node developer\n'),
+  `say1 output starts incorrectly: "${output}"`
+);
+assert.ok(
+  output.includes('> '),
+  `say1 output does not include prompt: "${output}"`
+);
 inputStream.write('.say2 node developer\n');
-assert.ok(output.startsWith('hello from say2\n'),
-          `say2 output starts incorrectly: "${output}"`);
-assert.ok(output.includes('> '),
-          `say2 output does not include prompt: "${output}"`);
+assert.ok(
+  output.startsWith('hello from say2\n'),
+  `say2 output starts incorrectly: "${output}"`
+);
+assert.ok(
+  output.includes('> '),
+  `say2 output does not include prompt: "${output}"`
+);
diff --git a/test/parallel/test-repl-domain.js b/test/parallel/test-repl-domain.js
index ce6da4bedb9e28..d20e17b7f4a967 100644
--- a/test/parallel/test-repl-domain.js
+++ b/test/parallel/test-repl-domain.js
@@ -41,5 +41,5 @@ putIn.write = function(data) {
 
 putIn.run([
   'require("domain").create().on("error", function() { console.log("OK") })' +
-  '.run(function() { throw new Error("threw") })'
+    '.run(function() { throw new Error("threw") })'
 ]);
diff --git a/test/parallel/test-repl-editor.js b/test/parallel/test-repl-editor.js
index 5afbf2540d8403..d5e04aafa7edab 100644
--- a/test/parallel/test-repl-editor.js
+++ b/test/parallel/test-repl-editor.js
@@ -15,11 +15,12 @@ function run({ input, output, event, checkTerminalCodes = true }) {
   const stream = new ArrayStream();
   let found = '';
 
-  stream.write = (msg) => found += msg.replace('\r', '');
+  stream.write = (msg) => (found += msg.replace('\r', ''));
 
-  let expected = `${terminalCode}.editor\n` +
-                 '// Entering editor mode (^D to finish, ^C to cancel)\n' +
-                 `${input}${output}\n${terminalCode}`;
+  let expected =
+    `${terminalCode}.editor\n` +
+    '// Entering editor mode (^D to finish, ^C to cancel)\n' +
+    `${input}${output}\n${terminalCode}`;
 
   const replServer = repl.start({
     prompt: '> ',
@@ -67,7 +68,7 @@ const tests = [
     input: '',
     output: '',
     checkTerminalCodes: false,
-    event: null,
+    event: null
   }
 ];
 
@@ -78,7 +79,9 @@ function testCodeAlignment({ input, cursor = 0, line = '' }) {
   const stream = new ArrayStream();
   const outputStream = new ArrayStream();
 
-  stream.write = () => { throw new Error('Writing not allowed!'); };
+  stream.write = () => {
+    throw new Error('Writing not allowed!');
+  };
 
   const replServer = repl.start({
     prompt: '> ',
diff --git a/test/parallel/test-repl-empty.js b/test/parallel/test-repl-empty.js
index 44281f117f0bba..7b168696b36f53 100644
--- a/test/parallel/test-repl-empty.js
+++ b/test/parallel/test-repl-empty.js
@@ -10,7 +10,7 @@ const repl = require('repl');
     eval: common.mustCall((cmd, context) => {
       // Assertions here will not cause the test to exit with an error code
       // so set a boolean that is checked later instead.
-      evalCalledWithExpectedArgs = (cmd === '\n');
+      evalCalledWithExpectedArgs = cmd === '\n';
     })
   };
 
diff --git a/test/parallel/test-repl-end-emits-exit.js b/test/parallel/test-repl-end-emits-exit.js
index d01be957d3990b..d9c82600ff3a5d 100644
--- a/test/parallel/test-repl-end-emits-exit.js
+++ b/test/parallel/test-repl-end-emits-exit.js
@@ -71,6 +71,5 @@ process.on('exit', function() {
   assert.strictEqual(regularExit, 1);
 });
 
-
 // start
 testTerminalMode();
diff --git a/test/parallel/test-repl-envvars.js b/test/parallel/test-repl-envvars.js
index d6a45a664fa3b7..8f08dd451789da 100644
--- a/test/parallel/test-repl-envvars.js
+++ b/test/parallel/test-repl-envvars.js
@@ -47,10 +47,16 @@ function run(test) {
   REPL.createInternalRepl(env, opts, function(err, repl) {
     assert.ifError(err);
 
-    assert.strictEqual(expected.terminal, repl.terminal,
-                       `Expected ${inspect(expected)} with ${inspect(env)}`);
-    assert.strictEqual(expected.useColors, repl.useColors,
-                       `Expected ${inspect(expected)} with ${inspect(env)}`);
+    assert.strictEqual(
+      expected.terminal,
+      repl.terminal,
+      `Expected ${inspect(expected)} with ${inspect(env)}`
+    );
+    assert.strictEqual(
+      expected.useColors,
+      repl.useColors,
+      `Expected ${inspect(expected)} with ${inspect(env)}`
+    );
     repl.close();
   });
 }
diff --git a/test/parallel/test-repl-eval.js b/test/parallel/test-repl-eval.js
index d775423fb74a52..1239fe28b3feaf 100644
--- a/test/parallel/test-repl-eval.js
+++ b/test/parallel/test-repl-eval.js
@@ -10,8 +10,8 @@ const repl = require('repl');
     eval: common.mustCall((cmd, context) => {
       // Assertions here will not cause the test to exit with an error code
       // so set a boolean that is checked later instead.
-      evalCalledWithExpectedArgs = (cmd === 'function f() {}\n' &&
-                                    context.foo === 'bar');
+      evalCalledWithExpectedArgs =
+        cmd === 'function f() {}\n' && context.foo === 'bar';
     })
   };
 
diff --git a/test/parallel/test-repl-history-perm.js b/test/parallel/test-repl-history-perm.js
index 03ce1435d9ba4e..72d95a03a38bef 100644
--- a/test/parallel/test-repl-history-perm.js
+++ b/test/parallel/test-repl-history-perm.js
@@ -7,9 +7,11 @@
 const common = require('../common');
 
 if (common.isWindows) {
-  common.skip('Win32 uses ACLs for file permissions, ' +
-              'modes are always 0666 and says nothing about group/other ' +
-              'read access.');
+  common.skip(
+    'Win32 uses ACLs for file permissions, ' +
+      'modes are always 0666 and says nothing about group/other ' +
+      'read access.'
+  );
 }
 
 const assert = require('assert');
@@ -42,8 +44,10 @@ const checkResults = common.mustCall(function(err, r) {
   const stat = fs.statSync(replHistoryPath);
   const fileMode = stat.mode & 0o777;
   assert.strictEqual(
-    fileMode, 0o600,
-    `REPL history file should be mode 0600 but was 0${fileMode.toString(8)}`);
+    fileMode,
+    0o600,
+    `REPL history file should be mode 0600 but was 0${fileMode.toString(8)}`
+  );
 });
 
 repl.createInternalRepl(
diff --git a/test/parallel/test-repl-inspector.js b/test/parallel/test-repl-inspector.js
index acec99208bcf02..e71a835cd5f5a0 100644
--- a/test/parallel/test-repl-inspector.js
+++ b/test/parallel/test-repl-inspector.js
@@ -19,9 +19,12 @@ const testMe = repl.start('', putIn);
 
 putIn.run(['const myVariable = 42']);
 
-testMe.complete('myVar', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [['myVariable'], 'myVar']);
-}));
+testMe.complete(
+  'myVar',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, [['myVariable'], 'myVar']);
+  })
+);
 
 putIn.run([
   'const inspector = require("inspector")',
@@ -31,5 +34,8 @@ putIn.run([
   'session.disconnect()'
 ]);
 
-assert(output.includes(
-  "null { result: { type: 'number', value: 2, description: '2' } }"));
+assert(
+  output.includes(
+    "null { result: { type: 'number', value: 2, description: '2' } }"
+  )
+);
diff --git a/test/parallel/test-repl-load-multiline.js b/test/parallel/test-repl-load-multiline.js
index 87b866c01be165..9b9a4cacb8964d 100644
--- a/test/parallel/test-repl-load-multiline.js
+++ b/test/parallel/test-repl-load-multiline.js
@@ -24,7 +24,7 @@ let accum = '';
 const inputStream = new ArrayStream();
 const outputStream = new ArrayStream();
 
-outputStream.write = (data) => accum += data.replace('\r', '');
+outputStream.write = (data) => (accum += data.replace('\r', ''));
 
 const r = repl.start({
   prompt: '',
diff --git a/test/parallel/test-repl-mode.js b/test/parallel/test-repl-mode.js
index df84d86a3c8dc3..98f675a936794e 100644
--- a/test/parallel/test-repl-mode.js
+++ b/test/parallel/test-repl-mode.js
@@ -4,11 +4,7 @@ const assert = require('assert');
 const Stream = require('stream');
 const repl = require('repl');
 
-const tests = [
-  testSloppyMode,
-  testStrictMode,
-  testAutoMode
-];
+const tests = [testSloppyMode, testStrictMode, testAutoMode];
 
 tests.forEach(function(test) {
   test();
@@ -29,8 +25,9 @@ function testStrictMode() {
   const cli = initRepl(repl.REPL_MODE_STRICT);
 
   cli.input.emit('data', 'x = 3\n');
-  assert.ok(/ReferenceError: x is not defined/.test(
-    cli.output.accumulator.join('')));
+  assert.ok(
+    /ReferenceError: x is not defined/.test(cli.output.accumulator.join(''))
+  );
   cli.output.accumulator.length = 0;
 
   cli.input.emit('data', 'let y = 3\n');
diff --git a/test/parallel/test-repl-multiline.js b/test/parallel/test-repl-multiline.js
index f789c06bf39378..f46179447e4e47 100644
--- a/test/parallel/test-repl-multiline.js
+++ b/test/parallel/test-repl-multiline.js
@@ -8,7 +8,9 @@ const outputStream = new ArrayStream();
 const input = ['var foo = {', '};', 'foo;'];
 let output = '';
 
-outputStream.write = (data) => { output += data.replace('\r', ''); };
+outputStream.write = (data) => {
+  output += data.replace('\r', '');
+};
 
 const r = repl.start({
   prompt: '',
@@ -18,19 +20,22 @@ const r = repl.start({
   useColors: false
 });
 
-r.on('exit', common.mustCall(() => {
-  const actual = output.split('\n');
+r.on(
+  'exit',
+  common.mustCall(() => {
+    const actual = output.split('\n');
 
-  // Validate the output, which contains terminal escape codes.
-  assert.strictEqual(actual.length, 6);
-  assert.ok(actual[0].endsWith(input[0]));
-  assert.ok(actual[1].includes('... '));
-  assert.ok(actual[1].endsWith(input[1]));
-  assert.strictEqual(actual[2], 'undefined');
-  assert.ok(actual[3].endsWith(input[2]));
-  assert.strictEqual(actual[4], '{}');
-  // Ignore the last line, which is nothing but escape codes.
-}));
+    // Validate the output, which contains terminal escape codes.
+    assert.strictEqual(actual.length, 6);
+    assert.ok(actual[0].endsWith(input[0]));
+    assert.ok(actual[1].includes('... '));
+    assert.ok(actual[1].endsWith(input[1]));
+    assert.strictEqual(actual[2], 'undefined');
+    assert.ok(actual[3].endsWith(input[2]));
+    assert.strictEqual(actual[4], '{}');
+    // Ignore the last line, which is nothing but escape codes.
+  })
+);
 
 inputStream.run(input);
 r.close();
diff --git a/test/parallel/test-repl-options.js b/test/parallel/test-repl-options.js
index 8d9f8e5b0703c4..6974efc8681b2e 100644
--- a/test/parallel/test-repl-options.js
+++ b/test/parallel/test-repl-options.js
@@ -89,10 +89,11 @@ assert.strictEqual(r2.rli.output, r2.outputStream);
 assert.strictEqual(r2.rli.terminal, false);
 
 // 3, breakEvalOnSigint and eval supplied together should cause a throw
-const r3 = () => repl.start({
-  breakEvalOnSigint: true,
-  eval: true
-});
+const r3 = () =>
+  repl.start({
+    breakEvalOnSigint: true,
+    eval: true
+  });
 
 common.expectsError(r3, {
   code: 'ERR_INVALID_REPL_EVAL_CONFIG',
diff --git a/test/parallel/test-repl-persistent-history.js b/test/parallel/test-repl-persistent-history.js
index 32bab3c8ed9f83..6818e15c2154c2 100644
--- a/test/parallel/test-repl-persistent-history.js
+++ b/test/parallel/test-repl-persistent-history.js
@@ -48,7 +48,6 @@ class ActionStream extends stream.Stream {
 }
 ActionStream.prototype.readable = true;
 
-
 // Mock keys
 const UP = { name: 'up' };
 const ENTER = { name: 'enter' };
@@ -60,17 +59,22 @@ const historyPath = path.join(tmpdir.path, '.fixture_copy_repl_history');
 const historyPathFail = fixtures.path('nonexistent_folder', 'filename');
 const defaultHistoryPath = path.join(tmpdir.path, '.node_repl_history');
 const emptyHiddenHistoryPath = fixtures.path('.empty-hidden-repl-history-file');
-const devNullHistoryPath = path.join(tmpdir.path,
-                                     '.dev-null-repl-history-file');
+const devNullHistoryPath = path.join(
+  tmpdir.path,
+  '.dev-null-repl-history-file'
+);
 // Common message bits
 const prompt = '> ';
-const replDisabled = '\nPersistent history support disabled. Set the ' +
-                     'NODE_REPL_HISTORY environment\nvariable to a valid, ' +
-                     'user-writable path to enable.\n';
-const homedirErr = '\nError: Could not get the home directory.\n' +
-                   'REPL session history will not be persisted.\n';
-const replFailedRead = '\nError: Could not open history file.\n' +
-                       'REPL session history will not be persisted.\n';
+const replDisabled =
+  '\nPersistent history support disabled. Set the ' +
+  'NODE_REPL_HISTORY environment\nvariable to a valid, ' +
+  'user-writable path to enable.\n';
+const homedirErr =
+  '\nError: Could not get the home directory.\n' +
+  'REPL session history will not be persisted.\n';
+const replFailedRead =
+  '\nError: Could not open history file.\n' +
+  'REPL session history will not be persisted.\n';
 
 const tests = [
   {
@@ -90,32 +94,31 @@ const tests = [
   },
   {
     env: {},
-    test: [UP, '\'42\'', ENTER],
-    expected: [prompt, '\'', '4', '2', '\'', '\'42\'\n', prompt, prompt],
+    test: [UP, "'42'", ENTER],
+    expected: [prompt, "'", '4', '2', "'", "'42'\n", prompt, prompt],
     clean: false
   },
-  { // Requires the above test case
+  {
+    // Requires the above test case
     env: {},
     test: [UP, UP, ENTER],
-    expected: [prompt, `${prompt}'42'`, '\'42\'\n', prompt]
+    expected: [prompt, `${prompt}'42'`, "'42'\n", prompt]
   },
   {
-    env: { NODE_REPL_HISTORY: historyPath,
-           NODE_REPL_HISTORY_SIZE: 1 },
+    env: { NODE_REPL_HISTORY: historyPath, NODE_REPL_HISTORY_SIZE: 1 },
     test: [UP, UP, CLEAR],
     expected: [prompt, `${prompt}'you look fabulous today'`, prompt]
   },
   {
-    env: { NODE_REPL_HISTORY: historyPathFail,
-           NODE_REPL_HISTORY_SIZE: 1 },
+    env: { NODE_REPL_HISTORY: historyPathFail, NODE_REPL_HISTORY_SIZE: 1 },
     test: [UP],
     expected: [prompt, replFailedRead, prompt, replDisabled, prompt]
   },
-  { // Tests multiline history
+  {
+    // Tests multiline history
     env: {},
     test: ['{', '}', UP, CLEAR],
-    expected: [prompt, '{', '... ', '}', '{}\n',
-               prompt, `${prompt}{}`, prompt],
+    expected: [prompt, '{', '... ', '}', '{}\n', prompt, `${prompt}{}`, prompt],
     clean: false
   },
   {
@@ -133,14 +136,14 @@ const tests = [
   },
   {
     before: function before() {
-      if (!common.isWindows)
-        fs.symlinkSync('/dev/null', devNullHistoryPath);
+      if (!common.isWindows) fs.symlinkSync('/dev/null', devNullHistoryPath);
     },
     env: { NODE_REPL_HISTORY: devNullHistoryPath },
     test: [UP],
     expected: [prompt]
   },
-  { // Make sure this is always the last test, since we change os.homedir()
+  {
+    // Make sure this is always the last test, since we change os.homedir()
     before: function before() {
       // Mock os.homedir() failure
       os.homedir = function() {
@@ -154,7 +157,6 @@ const tests = [
 ];
 const numtests = tests.length;
 
-
 function cleanupTmpFile() {
   try {
     // Write over the file, clearing any history
@@ -168,7 +170,8 @@ function cleanupTmpFile() {
 
 // Copy our fixture to the tmp directory
 fs.createReadStream(historyFixturePath)
-  .pipe(fs.createWriteStream(historyPath)).on('unpipe', () => runTest());
+  .pipe(fs.createWriteStream(historyPath))
+  .on('unpipe', () => runTest());
 
 const runTestWrap = common.mustCall(runTest, numtests);
 
@@ -195,56 +198,60 @@ function runTest(assertCleaned) {
 
   if (before) before();
 
-  REPL.createInternalRepl(env, {
-    input: new ActionStream(),
-    output: new stream.Writable({
-      write(chunk, _, next) {
-        const output = chunk.toString();
+  REPL.createInternalRepl(
+    env,
+    {
+      input: new ActionStream(),
+      output: new stream.Writable({
+        write(chunk, _, next) {
+          const output = chunk.toString();
 
-        // Ignore escapes and blank lines
-        if (output.charCodeAt(0) === 27 || /^[\r\n]+$/.test(output))
-          return next();
+          // Ignore escapes and blank lines
+          if (output.charCodeAt(0) === 27 || /^[\r\n]+$/.test(output))
+            return next();
 
-        try {
-          assert.strictEqual(output, expected.shift());
-        } catch (err) {
-          console.error(`Failed test # ${numtests - tests.length}`);
-          throw err;
+          try {
+            assert.strictEqual(output, expected.shift());
+          } catch (err) {
+            console.error(`Failed test # ${numtests - tests.length}`);
+            throw err;
+          }
+          next();
         }
-        next();
+      }),
+      prompt: prompt,
+      useColors: false,
+      terminal: true
+    },
+    function(err, repl) {
+      if (err) {
+        console.error(`Failed test # ${numtests - tests.length}`);
+        throw err;
       }
-    }),
-    prompt: prompt,
-    useColors: false,
-    terminal: true
-  }, function(err, repl) {
-    if (err) {
-      console.error(`Failed test # ${numtests - tests.length}`);
-      throw err;
-    }
 
-    repl.once('close', () => {
-      if (repl._flushing) {
-        repl.once('flushHistory', onClose);
-        return;
-      }
+      repl.once('close', () => {
+        if (repl._flushing) {
+          repl.once('flushHistory', onClose);
+          return;
+        }
 
-      onClose();
-    });
+        onClose();
+      });
 
-    function onClose() {
-      const cleaned = clean === false ? false : cleanupTmpFile();
+      function onClose() {
+        const cleaned = clean === false ? false : cleanupTmpFile();
 
-      try {
-        // Ensure everything that we expected was output
-        assert.strictEqual(expected.length, 0);
-        setImmediate(runTestWrap, cleaned);
-      } catch (err) {
-        console.error(`Failed test # ${numtests - tests.length}`);
-        throw err;
+        try {
+          // Ensure everything that we expected was output
+          assert.strictEqual(expected.length, 0);
+          setImmediate(runTestWrap, cleaned);
+        } catch (err) {
+          console.error(`Failed test # ${numtests - tests.length}`);
+          throw err;
+        }
       }
-    }
 
-    repl.inputStream.run(test);
-  });
+      repl.inputStream.run(test);
+    }
+  );
 }
diff --git a/test/parallel/test-repl-preprocess-top-level-await.js b/test/parallel/test-repl-preprocess-top-level-await.js
index 2a173b7339b8c7..8fe4c3a626ff12 100644
--- a/test/parallel/test-repl-preprocess-top-level-await.js
+++ b/test/parallel/test-repl-preprocess-top-level-await.js
@@ -10,57 +10,66 @@ const { processTopLevelAwait } = require('internal/repl/await');
 // https://cs.chromium.org/chromium/src/third_party/WebKit/LayoutTests/http/tests/inspector-unit/preprocess-top-level-awaits.js?rcl=358caaba5e763e71c4abb9ada2d9cd8b1188cac9
 
 const testCases = [
-  [ '0',
-    null ],
-  [ 'await 0',
-    '(async () => { return (await 0) })()' ],
-  [ 'await 0;',
-    '(async () => { return (await 0); })()' ],
-  [ '(await 0)',
-    '(async () => { return ((await 0)) })()' ],
-  [ '(await 0);',
-    '(async () => { return ((await 0)); })()' ],
-  [ 'async function foo() { await 0; }',
-    null ],
-  [ 'async () => await 0',
-    null ],
-  [ 'class A { async method() { await 0 } }',
-    null ],
-  [ 'await 0; return 0;',
-    null ],
-  [ 'var a = await 1',
-    '(async () => { void (a = await 1) })()' ],
-  [ 'let a = await 1',
-    '(async () => { void (a = await 1) })()' ],
-  [ 'const a = await 1',
-    '(async () => { void (a = await 1) })()' ],
-  [ 'for (var i = 0; i < 1; ++i) { await i }',
-    '(async () => { for (void (i = 0); i < 1; ++i) { await i } })()' ],
-  [ 'for (let i = 0; i < 1; ++i) { await i }',
-    '(async () => { for (let i = 0; i < 1; ++i) { await i } })()' ],
-  [ 'var {a} = {a:1}, [b] = [1], {c:{d}} = {c:{d: await 1}}',
+  ['0', null],
+  ['await 0', '(async () => { return (await 0) })()'],
+  ['await 0;', '(async () => { return (await 0); })()'],
+  ['(await 0)', '(async () => { return ((await 0)) })()'],
+  ['(await 0);', '(async () => { return ((await 0)); })()'],
+  ['async function foo() { await 0; }', null],
+  ['async () => await 0', null],
+  ['class A { async method() { await 0 } }', null],
+  ['await 0; return 0;', null],
+  ['var a = await 1', '(async () => { void (a = await 1) })()'],
+  ['let a = await 1', '(async () => { void (a = await 1) })()'],
+  ['const a = await 1', '(async () => { void (a = await 1) })()'],
+  [
+    'for (var i = 0; i < 1; ++i) { await i }',
+    '(async () => { for (void (i = 0); i < 1; ++i) { await i } })()'
+  ],
+  [
+    'for (let i = 0; i < 1; ++i) { await i }',
+    '(async () => { for (let i = 0; i < 1; ++i) { await i } })()'
+  ],
+  [
+    'var {a} = {a:1}, [b] = [1], {c:{d}} = {c:{d: await 1}}',
     '(async () => { void ( ({a} = {a:1}), ([b] = [1]), ' +
-        '({c:{d}} = {c:{d: await 1}})) })()' ],
+      '({c:{d}} = {c:{d: await 1}})) })()'
+  ],
   /* eslint-disable no-template-curly-in-string */
-  [ 'console.log(`${(await { a: 1 }).a}`)',
-    '(async () => { return (console.log(`${(await { a: 1 }).a}`)) })()' ],
+  [
+    'console.log(`${(await { a: 1 }).a}`)',
+    '(async () => { return (console.log(`${(await { a: 1 }).a}`)) })()'
+  ],
   /* eslint-enable no-template-curly-in-string */
-  [ 'await 0; function foo() {}',
-    '(async () => { await 0; foo=function foo() {} })()' ],
-  [ 'await 0; class Foo {}',
-    '(async () => { await 0; Foo=class Foo {} })()' ],
-  [ 'if (await true) { function foo() {} }',
-    '(async () => { if (await true) { foo=function foo() {} } })()' ],
-  [ 'if (await true) { class Foo{} }',
-    '(async () => { if (await true) { class Foo{} } })()' ],
-  [ 'if (await true) { var a = 1; }',
-    '(async () => { if (await true) { void (a = 1); } })()' ],
-  [ 'if (await true) { let a = 1; }',
-    '(async () => { if (await true) { let a = 1; } })()' ],
-  [ 'var a = await 1; let b = 2; const c = 3;',
-    '(async () => { void (a = await 1); void (b = 2); void (c = 3); })()' ],
-  [ 'let o = await 1, p',
-    '(async () => { void ( (o = await 1), (p=undefined)) })()' ]
+  [
+    'await 0; function foo() {}',
+    '(async () => { await 0; foo=function foo() {} })()'
+  ],
+  ['await 0; class Foo {}', '(async () => { await 0; Foo=class Foo {} })()'],
+  [
+    'if (await true) { function foo() {} }',
+    '(async () => { if (await true) { foo=function foo() {} } })()'
+  ],
+  [
+    'if (await true) { class Foo{} }',
+    '(async () => { if (await true) { class Foo{} } })()'
+  ],
+  [
+    'if (await true) { var a = 1; }',
+    '(async () => { if (await true) { void (a = 1); } })()'
+  ],
+  [
+    'if (await true) { let a = 1; }',
+    '(async () => { if (await true) { let a = 1; } })()'
+  ],
+  [
+    'var a = await 1; let b = 2; const c = 3;',
+    '(async () => { void (a = await 1); void (b = 2); void (c = 3); })()'
+  ],
+  [
+    'let o = await 1, p',
+    '(async () => { void ( (o = await 1), (p=undefined)) })()'
+  ]
 ];
 
 for (const [input, expected] of testCases) {
diff --git a/test/parallel/test-repl-pretty-custom-stack.js b/test/parallel/test-repl-pretty-custom-stack.js
index 3c758fb2f2ef13..9b8aa064b41522 100644
--- a/test/parallel/test-repl-pretty-custom-stack.js
+++ b/test/parallel/test-repl-pretty-custom-stack.js
@@ -5,14 +5,13 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const repl = require('repl');
 
-
 function run({ command, expected }) {
   let accum = '';
 
   const inputStream = new ArrayStream();
   const outputStream = new ArrayStream();
 
-  outputStream.write = (data) => accum += data.replace('\r', '');
+  outputStream.write = (data) => (accum += data.replace('\r', ''));
 
   const r = repl.start({
     prompt: '',
@@ -29,8 +28,7 @@ function run({ command, expected }) {
 
 const origPrepareStackTrace = Error.prepareStackTrace;
 Error.prepareStackTrace = (err, stack) => {
-  if (err instanceof SyntaxError)
-    return err.toString();
+  if (err instanceof SyntaxError) return err.toString();
   stack.push(err);
   return stack.reverse().join('--->\n');
 };
@@ -46,15 +44,16 @@ const tests = [
   {
     // test .load for a file that throws
     command: `.load ${fixtures.path('repl-pretty-stack.js')}`,
-    expected: 'Error: Whoops!--->\nrepl:9:24--->\nd (repl:12:3)--->\nc ' +
-              '(repl:9:3)--->\nb (repl:6:3)--->\na (repl:3:3)\n'
+    expected:
+      'Error: Whoops!--->\nrepl:9:24--->\nd (repl:12:3)--->\nc ' +
+      '(repl:9:3)--->\nb (repl:6:3)--->\na (repl:3:3)\n'
   },
   {
     command: 'let x y;',
     expected: 'let x y;\n      ^\n\nSyntaxError: Unexpected identifier\n'
   },
   {
-    command: 'throw new Error(\'Whoops!\')',
+    command: "throw new Error('Whoops!')",
     expected: 'Error: Whoops!\n'
   },
   {
@@ -63,7 +62,7 @@ const tests = [
   },
   // test anonymous IIFE
   {
-    command: '(function() { throw new Error(\'Whoops!\'); })()',
+    command: "(function() { throw new Error('Whoops!'); })()",
     expected: 'Error: Whoops!--->\nrepl:1:21\n'
   }
 ];
diff --git a/test/parallel/test-repl-pretty-stack.js b/test/parallel/test-repl-pretty-stack.js
index f4754d315df44f..fe3c19dc2ac1ac 100644
--- a/test/parallel/test-repl-pretty-stack.js
+++ b/test/parallel/test-repl-pretty-stack.js
@@ -5,14 +5,13 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const repl = require('repl');
 
-
 function run({ command, expected }) {
   let accum = '';
 
   const inputStream = new ArrayStream();
   const outputStream = new ArrayStream();
 
-  outputStream.write = (data) => accum += data.replace('\r', '');
+  outputStream.write = (data) => (accum += data.replace('\r', ''));
 
   const r = repl.start({
     prompt: '',
@@ -31,15 +30,16 @@ const tests = [
   {
     // test .load for a file that throws
     command: `.load ${fixtures.path('repl-pretty-stack.js')}`,
-    expected: 'Error: Whoops!\n    at repl:9:24\n    at d (repl:12:3)\n    ' +
-              'at c (repl:9:3)\n    at b (repl:6:3)\n    at a (repl:3:3)\n'
+    expected:
+      'Error: Whoops!\n    at repl:9:24\n    at d (repl:12:3)\n    ' +
+      'at c (repl:9:3)\n    at b (repl:6:3)\n    at a (repl:3:3)\n'
   },
   {
     command: 'let x y;',
     expected: 'let x y;\n      ^\n\nSyntaxError: Unexpected identifier\n\n'
   },
   {
-    command: 'throw new Error(\'Whoops!\')',
+    command: "throw new Error('Whoops!')",
     expected: 'Error: Whoops!\n'
   },
   {
@@ -48,7 +48,7 @@ const tests = [
   },
   // test anonymous IIFE
   {
-    command: '(function() { throw new Error(\'Whoops!\'); })()',
+    command: "(function() { throw new Error('Whoops!'); })()",
     expected: 'Error: Whoops!\n    at repl:1:21\n'
   }
 ];
diff --git a/test/parallel/test-repl-require-context.js b/test/parallel/test-repl-require-context.js
index 84896783211ab4..f1a47a948411ee 100644
--- a/test/parallel/test-repl-require-context.js
+++ b/test/parallel/test-repl-require-context.js
@@ -12,10 +12,13 @@ child.stdout.on('data', (data) => {
   output += data;
 });
 
-child.on('exit', common.mustCall(() => {
-  const results = output.replace(/^> /mg, '').split('\n');
-  assert.deepStrictEqual(results, ['undefined', 'true', 'true', '']);
-}));
+child.on(
+  'exit',
+  common.mustCall(() => {
+    const results = output.replace(/^> /gm, '').split('\n');
+    assert.deepStrictEqual(results, ['undefined', 'true', 'true', '']);
+  })
+);
 
 child.stdin.write('const isObject = (obj) => obj.constructor === Object;\n');
 child.stdin.write('isObject({});\n');
diff --git a/test/parallel/test-repl-require.js b/test/parallel/test-repl-require.js
index 818fca7431fa94..cb56235c4b94cb 100644
--- a/test/parallel/test-repl-require.js
+++ b/test/parallel/test-repl-require.js
@@ -27,12 +27,12 @@ server.listen(options, function() {
   options.port = this.address().port;
   const conn = net.connect(options);
   conn.setEncoding('utf8');
-  conn.on('data', (data) => answer += data);
+  conn.on('data', (data) => (answer += data));
   conn.write('require("baz")\nrequire("./baz")\n.exit\n');
 });
 
 process.on('exit', function() {
   assert.strictEqual(/Cannot find module/.test(answer), false);
   assert.strictEqual(/Error/.test(answer), false);
-  assert.strictEqual(answer, '\'eye catcher\'\n\'perhaps I work\'\n');
+  assert.strictEqual(answer, "'eye catcher'\n'perhaps I work'\n");
 });
diff --git a/test/parallel/test-repl-reset-event.js b/test/parallel/test-repl-reset-event.js
index 1f1347547e95f8..dd88894c6a2933 100644
--- a/test/parallel/test-repl-reset-event.js
+++ b/test/parallel/test-repl-reset-event.js
@@ -38,19 +38,28 @@ function testReset(cb) {
     useGlobal: false
   });
   r.context.foo = 42;
-  r.on('reset', common.mustCall(function(context) {
-    assert(!!context, 'REPL did not emit a context with reset event');
-    assert.strictEqual(context, r.context, 'REPL emitted incorrect context. ' +
-    `context is ${util.inspect(context)}, expected ${util.inspect(r.context)}`);
-    assert.strictEqual(
-      context.foo,
-      undefined,
-      'REPL emitted the previous context and is not using global as context. ' +
-      `context.foo is ${context.foo}, expected undefined.`
-    );
-    context.foo = 42;
-    cb();
-  }));
+  r.on(
+    'reset',
+    common.mustCall(function(context) {
+      assert(!!context, 'REPL did not emit a context with reset event');
+      assert.strictEqual(
+        context,
+        r.context,
+        'REPL emitted incorrect context. ' +
+          `context is ${util.inspect(context)}, expected ${util.inspect(
+            r.context
+          )}`
+      );
+      assert.strictEqual(
+        context.foo,
+        undefined,
+        'REPL emitted the previous context and is not using global as context. ' +
+          `context.foo is ${context.foo}, expected undefined.`
+      );
+      context.foo = 42;
+      cb();
+    })
+  );
   r.resetContext();
 }
 
@@ -61,14 +70,17 @@ function testResetGlobal() {
     useGlobal: true
   });
   r.context.foo = 42;
-  r.on('reset', common.mustCall(function(context) {
-    assert.strictEqual(
-      context.foo,
-      42,
-      '"foo" property is different from REPL using global as context. ' +
-      `context.foo is ${context.foo}, expected 42.`
-    );
-  }));
+  r.on(
+    'reset',
+    common.mustCall(function(context) {
+      assert.strictEqual(
+        context.foo,
+        42,
+        '"foo" property is different from REPL using global as context. ' +
+          `context.foo is ${context.foo}, expected 42.`
+      );
+    })
+  );
   r.resetContext();
 }
 
diff --git a/test/parallel/test-repl-save-load.js b/test/parallel/test-repl-save-load.js
index 7ca0e9c0164056..97230381501f7d 100644
--- a/test/parallel/test-repl-save-load.js
+++ b/test/parallel/test-repl-save-load.js
@@ -36,11 +36,7 @@ const works = [['inner.one'], 'inner.o'];
 const putIn = new ArrayStream();
 const testMe = repl.start('', putIn);
 
-
-const testFile = [
-  'var top = function() {',
-  'var inner = {one:1};'
-];
+const testFile = ['var top = function() {', 'var inner = {one:1};'];
 const saveFileName = join(tmpdir.path, 'test.save.js');
 
 // input some data
@@ -50,16 +46,14 @@ putIn.run(testFile);
 putIn.run([`.save ${saveFileName}`]);
 
 // the file should have what I wrote
-assert.strictEqual(fs.readFileSync(saveFileName, 'utf8'),
-                   `${testFile.join('\n')}\n`);
+assert.strictEqual(
+  fs.readFileSync(saveFileName, 'utf8'),
+  `${testFile.join('\n')}\n`
+);
 
 {
   // save .editor mode code
-  const cmds = [
-    'function testSave() {',
-    'return "saved";',
-    '}'
-  ];
+  const cmds = ['function testSave() {', 'return "saved";', '}'];
   const putIn = new ArrayStream();
   const replServer = repl.start('', putIn);
 
@@ -69,8 +63,10 @@ assert.strictEqual(fs.readFileSync(saveFileName, 'utf8'),
 
   putIn.run([`.save ${saveFileName}`]);
   replServer.close();
-  assert.strictEqual(fs.readFileSync(saveFileName, 'utf8'),
-                     `${cmds.join('\n')}\n`);
+  assert.strictEqual(
+    fs.readFileSync(saveFileName, 'utf8'),
+    `${cmds.join('\n')}\n`
+  );
 }
 
 // make sure that the REPL data is "correct"
diff --git a/test/parallel/test-repl-setprompt.js b/test/parallel/test-repl-setprompt.js
index d9eb85be145734..abb28fed7d36cd 100644
--- a/test/parallel/test-repl-setprompt.js
+++ b/test/parallel/test-repl-setprompt.js
@@ -27,7 +27,7 @@ const os = require('os');
 
 const args = [
   '-e',
-  'var e = new (require("repl")).REPLServer("foo.. "); e.context.e = e;',
+  'var e = new (require("repl")).REPLServer("foo.. "); e.context.e = e;'
 ];
 
 const p = 'bar.. ';
@@ -37,7 +37,9 @@ const child = spawn(process.execPath, args);
 child.stdout.setEncoding('utf8');
 
 let data = '';
-child.stdout.on('data', function(d) { data += d; });
+child.stdout.on('data', function(d) {
+  data += d;
+});
 
 child.stdin.end(`e.setPrompt("${p}");${os.EOL}`);
 
diff --git a/test/parallel/test-repl-sigint-nested-eval.js b/test/parallel/test-repl-sigint-nested-eval.js
index 28e4d44b235cde..d858ccea10e20f 100644
--- a/test/parallel/test-repl-sigint-nested-eval.js
+++ b/test/parallel/test-repl-sigint-nested-eval.js
@@ -11,7 +11,7 @@ const assert = require('assert');
 const spawn = require('child_process').spawn;
 
 process.env.REPL_TEST_PPID = process.pid;
-const child = spawn(process.execPath, [ '-i' ], {
+const child = spawn(process.execPath, ['-i'], {
   stdio: [null, null, 2]
 });
 
@@ -21,19 +21,30 @@ child.stdout.on('data', function(c) {
   stdout += c;
 });
 
-child.stdout.once('data', common.mustCall(() => {
-  process.on('SIGUSR2', common.mustCall(() => {
-    process.kill(child.pid, 'SIGINT');
-    child.stdout.once('data', common.mustCall(() => {
-      // Make sure REPL still works.
-      child.stdin.end('"foobar"\n');
-    }));
-  }));
+child.stdout.once(
+  'data',
+  common.mustCall(() => {
+    process.on(
+      'SIGUSR2',
+      common.mustCall(() => {
+        process.kill(child.pid, 'SIGINT');
+        child.stdout.once(
+          'data',
+          common.mustCall(() => {
+            // Make sure REPL still works.
+            child.stdin.end('"foobar"\n');
+          })
+        );
+      })
+    );
 
-  child.stdin.write('process.kill(+process.env.REPL_TEST_PPID, "SIGUSR2");' +
-                    'vm.runInThisContext("while(true){}", ' +
-                    '{ breakOnSigint: true });\n');
-}));
+    child.stdin.write(
+      'process.kill(+process.env.REPL_TEST_PPID, "SIGUSR2");' +
+        'vm.runInThisContext("while(true){}", ' +
+        '{ breakOnSigint: true });\n'
+    );
+  })
+);
 
 child.on('close', function(code) {
   const expected = 'Script execution was interrupted by `SIGINT`';
diff --git a/test/parallel/test-repl-sigint.js b/test/parallel/test-repl-sigint.js
index 8ad0b2f5c2c853..706c9d51673149 100644
--- a/test/parallel/test-repl-sigint.js
+++ b/test/parallel/test-repl-sigint.js
@@ -11,7 +11,7 @@ const assert = require('assert');
 const spawn = require('child_process').spawn;
 
 process.env.REPL_TEST_PPID = process.pid;
-const child = spawn(process.execPath, [ '-i' ], {
+const child = spawn(process.execPath, ['-i'], {
   stdio: [null, null, 2]
 });
 
@@ -21,19 +21,30 @@ child.stdout.on('data', function(c) {
   stdout += c;
 });
 
-child.stdout.once('data', common.mustCall(() => {
-  process.on('SIGUSR2', common.mustCall(() => {
-    process.kill(child.pid, 'SIGINT');
-    child.stdout.once('data', common.mustCall(() => {
-      // Make sure state from before the interruption is still available.
-      child.stdin.end('a*2*3*7\n');
-    }));
-  }));
+child.stdout.once(
+  'data',
+  common.mustCall(() => {
+    process.on(
+      'SIGUSR2',
+      common.mustCall(() => {
+        process.kill(child.pid, 'SIGINT');
+        child.stdout.once(
+          'data',
+          common.mustCall(() => {
+            // Make sure state from before the interruption is still available.
+            child.stdin.end('a*2*3*7\n');
+          })
+        );
+      })
+    );
 
-  child.stdin.write('a = 1001;' +
-                    'process.kill(+process.env.REPL_TEST_PPID, "SIGUSR2");' +
-                    'while(true){}\n');
-}));
+    child.stdin.write(
+      'a = 1001;' +
+        'process.kill(+process.env.REPL_TEST_PPID, "SIGUSR2");' +
+        'while(true){}\n'
+    );
+  })
+);
 
 child.on('close', function(code) {
   assert.strictEqual(code, 0);
diff --git a/test/parallel/test-repl-syntax-error-stack.js b/test/parallel/test-repl-syntax-error-stack.js
index 2794ded4924a97..ad0f6306a2aae6 100644
--- a/test/parallel/test-repl-syntax-error-stack.js
+++ b/test/parallel/test-repl-syntax-error-stack.js
@@ -17,16 +17,14 @@ ArrayStream.prototype.write = function(output) {
   // displays the line of code (`var foo bar;`) that is causing a problem.
   // ChakraCore does not display the line of code but includes `;` in the phrase
   // `Expected ';' `.
-  if (/;/.test(output))
-    found = true;
+  if (/;/.test(output)) found = true;
 };
 
 const putIn = new ArrayStream();
 repl.start('', putIn);
 let file = fixtures.path('syntax', 'bad_syntax');
 
-if (common.isWindows)
-  file = file.replace(/\\/g, '\\\\');
+if (common.isWindows) file = file.replace(/\\/g, '\\\\');
 
 putIn.run(['.clear']);
 putIn.run([`require('${file}');`]);
diff --git a/test/parallel/test-repl-tab-complete-crash.js b/test/parallel/test-repl-tab-complete-crash.js
index 95dfe0bd4c4e13..59b6b66d06ba52 100644
--- a/test/parallel/test-repl-tab-complete-crash.js
+++ b/test/parallel/test-repl-tab-complete-crash.js
@@ -14,15 +14,21 @@ const testMe = repl.start('', putIn);
 // Tab-completion should be empty
 putIn.run(['.clear']);
 putIn.run(['function () {']);
-testMe.complete('arguments.', common.mustCall((err, completions) => {
-  assert.strictEqual(err, null);
-  assert.deepStrictEqual(completions, [[], 'arguments.']);
-}));
+testMe.complete(
+  'arguments.',
+  common.mustCall((err, completions) => {
+    assert.strictEqual(err, null);
+    assert.deepStrictEqual(completions, [[], 'arguments.']);
+  })
+);
 
 putIn.run(['.clear']);
 putIn.run(['function () {']);
 putIn.run(['undef;']);
-testMe.complete('undef.', common.mustCall((err, completions) => {
-  assert.strictEqual(err, null);
-  assert.deepStrictEqual(completions, [[], 'undef.']);
-}));
+testMe.complete(
+  'undef.',
+  common.mustCall((err, completions) => {
+    assert.strictEqual(err, null);
+    assert.deepStrictEqual(completions, [[], 'undef.']);
+  })
+);
diff --git a/test/parallel/test-repl-tab-complete-no-warn.js b/test/parallel/test-repl-tab-complete-no-warn.js
index cef2026dfba853..58d0a1332fb193 100644
--- a/test/parallel/test-repl-tab-complete-no-warn.js
+++ b/test/parallel/test-repl-tab-complete-no-warn.js
@@ -5,8 +5,7 @@ const ArrayStream = require('../common/arraystream');
 const repl = require('repl');
 const DEFAULT_MAX_LISTENERS = require('events').defaultMaxListeners;
 
-ArrayStream.prototype.write = () => {
-};
+ArrayStream.prototype.write = () => {};
 
 const putIn = new ArrayStream();
 const testMe = repl.start('', putIn);
diff --git a/test/parallel/test-repl-tab-complete.js b/test/parallel/test-repl-tab-complete.js
index 378072ecb8c3e7..d46acbd45e2099 100644
--- a/test/parallel/test-repl-tab-complete.js
+++ b/test/parallel/test-repl-tab-complete.js
@@ -23,10 +23,7 @@
 
 const common = require('../common');
 const ArrayStream = require('../common/arraystream');
-const {
-  hijackStderr,
-  restoreStderr
-} = require('../common/hijackstdio');
+const { hijackStderr, restoreStderr } = require('../common/hijackstdio');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const hasInspector = process.config.variables.v8_enable_inspector === 1;
@@ -59,42 +56,41 @@ testMe._domain.on('error', function(err) {
 
 // Tab Complete will not break in an object literal
 putIn.run(['.clear']);
-putIn.run([
-  'var inner = {',
-  'one:1'
-]);
+putIn.run(['var inner = {', 'one:1']);
 testMe.complete('inner.o', getNoResultsFunction());
 
-testMe.complete('console.lo', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, [['console.log'], 'console.lo']);
-}));
+testMe.complete(
+  'console.lo',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, [['console.log'], 'console.lo']);
+  })
+);
 
 // Tab Complete will return globally scoped variables
 putIn.run(['};']);
-testMe.complete('inner.o', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, works);
-}));
+testMe.complete(
+  'inner.o',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, works);
+  })
+);
 
 putIn.run(['.clear']);
 
 // Tab Complete will not break in an ternary operator with ()
-putIn.run([
-  'var inner = ( true ',
-  '?',
-  '{one: 1} : '
-]);
+putIn.run(['var inner = ( true ', '?', '{one: 1} : ']);
 testMe.complete('inner.o', getNoResultsFunction());
 
 putIn.run(['.clear']);
 
 // Tab Complete will return a simple local variable
-putIn.run([
-  'var top = function() {',
-  'var inner = {one:1};'
-]);
-testMe.complete('inner.o', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, works);
-}));
+putIn.run(['var top = function() {', 'var inner = {one:1};']);
+testMe.complete(
+  'inner.o',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, works);
+  })
+);
 
 // When you close the function scope tab complete will not return the
 // locally scoped variable
@@ -104,29 +100,25 @@ testMe.complete('inner.o', getNoResultsFunction());
 putIn.run(['.clear']);
 
 // Tab Complete will return a complex local variable
-putIn.run([
-  'var top = function() {',
-  'var inner = {',
-  ' one:1',
-  '};'
-]);
-testMe.complete('inner.o', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, works);
-}));
+putIn.run(['var top = function() {', 'var inner = {', ' one:1', '};']);
+testMe.complete(
+  'inner.o',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, works);
+  })
+);
 
 putIn.run(['.clear']);
 
 // Tab Complete will return a complex local variable even if the function
 // has parameters
-putIn.run([
-  'var top = function(one, two) {',
-  'var inner = {',
-  ' one:1',
-  '};'
-]);
-testMe.complete('inner.o', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, works);
-}));
+putIn.run(['var top = function(one, two) {', 'var inner = {', ' one:1', '};']);
+testMe.complete(
+  'inner.o',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, works);
+  })
+);
 
 putIn.run(['.clear']);
 
@@ -139,9 +131,12 @@ putIn.run([
   ' one:1',
   '};'
 ]);
-testMe.complete('inner.o', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, works);
-}));
+testMe.complete(
+  'inner.o',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, works);
+  })
+);
 
 putIn.run(['.clear']);
 
@@ -154,9 +149,12 @@ putIn.run([
   ' one:1',
   '};'
 ]);
-testMe.complete('inner.o', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, works);
-}));
+testMe.complete(
+  'inner.o',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, works);
+  })
+);
 
 putIn.run(['.clear']);
 
@@ -188,12 +186,13 @@ testMe.complete('inner.o', getNoResultsFunction());
 putIn.run(['.clear']);
 
 // make sure tab completion works on non-Objects
-putIn.run([
-  'var str = "test";'
-]);
-testMe.complete('str.len', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, [['str.length'], 'str.len']);
-}));
+putIn.run(['var str = "test";']);
+testMe.complete(
+  'str.len',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, [['str.length'], 'str.len']);
+  })
+);
 
 putIn.run(['.clear']);
 
@@ -202,16 +201,22 @@ const spaceTimeout = setTimeout(function() {
   throw new Error('timeout');
 }, 1000);
 
-testMe.complete(' ', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, [[], undefined]);
-  clearTimeout(spaceTimeout);
-}));
+testMe.complete(
+  ' ',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, [[], undefined]);
+    clearTimeout(spaceTimeout);
+  })
+);
 
 // tab completion should pick up the global "toString" object, and
 // any other properties up the "global" object's prototype chain
-testMe.complete('toSt', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, [['toString'], 'toSt']);
-}));
+testMe.complete(
+  'toSt',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, [['toString'], 'toSt']);
+  })
+);
 
 // own properties should shadow properties on the prototype
 putIn.run(['.clear']);
@@ -223,39 +228,50 @@ putIn.run([
   'y.a = 3;',
   'y.c = 4;'
 ]);
-testMe.complete('y.', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, [['y.b', '', 'y.a', 'y.c'], 'y.']);
-}));
+testMe.complete(
+  'y.',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, [['y.b', '', 'y.a', 'y.c'], 'y.']);
+  })
+);
 
 // Tab complete provides built in libs for require()
 putIn.run(['.clear']);
 
-testMe.complete('require(\'', common.mustCall(function(error, data) {
-  assert.strictEqual(error, null);
-  repl._builtinLibs.forEach(function(lib) {
-    assert(data[0].includes(lib), `${lib} not found`);
-  });
-}));
-
-testMe.complete('require(\'n', common.mustCall(function(error, data) {
-  assert.strictEqual(error, null);
-  assert.strictEqual(data.length, 2);
-  assert.strictEqual(data[1], 'n');
-  assert(data[0].includes('net'));
-  // It's possible to pick up non-core modules too
-  data[0].forEach(function(completion) {
-    if (completion)
-      assert(/^n/.test(completion));
-  });
-}));
+testMe.complete(
+  "require('",
+  common.mustCall(function(error, data) {
+    assert.strictEqual(error, null);
+    repl._builtinLibs.forEach(function(lib) {
+      assert(data[0].includes(lib), `${lib} not found`);
+    });
+  })
+);
+
+testMe.complete(
+  "require('n",
+  common.mustCall(function(error, data) {
+    assert.strictEqual(error, null);
+    assert.strictEqual(data.length, 2);
+    assert.strictEqual(data[1], 'n');
+    assert(data[0].includes('net'));
+    // It's possible to pick up non-core modules too
+    data[0].forEach(function(completion) {
+      if (completion) assert(/^n/.test(completion));
+    });
+  })
+);
 
 {
   const expected = ['@nodejsscope', '@nodejsscope/'];
   putIn.run(['.clear']);
-  testMe.complete('require(\'@nodejs', common.mustCall((err, data) => {
-    assert.strictEqual(err, null);
-    assert.deepStrictEqual(data, [expected, '@nodejs']);
-  }));
+  testMe.complete(
+    "require('@nodejs",
+    common.mustCall((err, data) => {
+      assert.strictEqual(err, null);
+      assert.deepStrictEqual(data, [expected, '@nodejs']);
+    })
+  );
 }
 
 // Test tab completion for require() relative to the current directory
@@ -265,54 +281,71 @@ testMe.complete('require(\'n', common.mustCall(function(error, data) {
   const cwd = process.cwd();
   process.chdir(__dirname);
 
-  ['require(\'.', 'require(".'].forEach((input) => {
-    testMe.complete(input, common.mustCall((err, data) => {
-      assert.strictEqual(err, null);
-      assert.strictEqual(data.length, 2);
-      assert.strictEqual(data[1], '.');
-      assert.strictEqual(data[0].length, 2);
-      assert.ok(data[0].includes('./'));
-      assert.ok(data[0].includes('../'));
-    }));
+  ["require('.", 'require(".'].forEach((input) => {
+    testMe.complete(
+      input,
+      common.mustCall((err, data) => {
+        assert.strictEqual(err, null);
+        assert.strictEqual(data.length, 2);
+        assert.strictEqual(data[1], '.');
+        assert.strictEqual(data[0].length, 2);
+        assert.ok(data[0].includes('./'));
+        assert.ok(data[0].includes('../'));
+      })
+    );
   });
 
-  ['require(\'..', 'require("..'].forEach((input) => {
-    testMe.complete(input, common.mustCall((err, data) => {
-      assert.strictEqual(err, null);
-      assert.deepStrictEqual(data, [['../'], '..']);
-    }));
+  ["require('..", 'require("..'].forEach((input) => {
+    testMe.complete(
+      input,
+      common.mustCall((err, data) => {
+        assert.strictEqual(err, null);
+        assert.deepStrictEqual(data, [['../'], '..']);
+      })
+    );
   });
 
   ['./', './test-'].forEach((path) => {
     [`require('${path}`, `require("${path}`].forEach((input) => {
-      testMe.complete(input, common.mustCall((err, data) => {
-        assert.strictEqual(err, null);
-        assert.strictEqual(data.length, 2);
-        assert.strictEqual(data[1], path);
-        assert.ok(data[0].includes('./test-repl-tab-complete'));
-      }));
+      testMe.complete(
+        input,
+        common.mustCall((err, data) => {
+          assert.strictEqual(err, null);
+          assert.strictEqual(data.length, 2);
+          assert.strictEqual(data[1], path);
+          assert.ok(data[0].includes('./test-repl-tab-complete'));
+        })
+      );
     });
   });
 
   ['../parallel/', '../parallel/test-'].forEach((path) => {
     [`require('${path}`, `require("${path}`].forEach((input) => {
-      testMe.complete(input, common.mustCall((err, data) => {
-        assert.strictEqual(err, null);
-        assert.strictEqual(data.length, 2);
-        assert.strictEqual(data[1], path);
-        assert.ok(data[0].includes('../parallel/test-repl-tab-complete'));
-      }));
+      testMe.complete(
+        input,
+        common.mustCall((err, data) => {
+          assert.strictEqual(err, null);
+          assert.strictEqual(data.length, 2);
+          assert.strictEqual(data[1], path);
+          assert.ok(data[0].includes('../parallel/test-repl-tab-complete'));
+        })
+      );
     });
   });
 
   {
     const path = '../fixtures/repl-folder-extensions/f';
-    testMe.complete(`require('${path}`, common.mustCall((err, data) => {
-      assert.ifError(err);
-      assert.strictEqual(data.length, 2);
-      assert.strictEqual(data[1], path);
-      assert.ok(data[0].includes('../fixtures/repl-folder-extensions/foo.js'));
-    }));
+    testMe.complete(
+      `require('${path}`,
+      common.mustCall((err, data) => {
+        assert.ifError(err);
+        assert.strictEqual(data.length, 2);
+        assert.strictEqual(data[1], path);
+        assert.ok(
+          data[0].includes('../fixtures/repl-folder-extensions/foo.js')
+        );
+      })
+    );
   }
 
   process.chdir(cwd);
@@ -321,12 +354,13 @@ testMe.complete('require(\'n', common.mustCall(function(error, data) {
 // Make sure tab completion works on context properties
 putIn.run(['.clear']);
 
-putIn.run([
-  'var custom = "test";'
-]);
-testMe.complete('cus', common.mustCall(function(error, data) {
-  assert.deepStrictEqual(data, [['custom'], 'cus']);
-}));
+putIn.run(['var custom = "test";']);
+testMe.complete(
+  'cus',
+  common.mustCall(function(error, data) {
+    assert.deepStrictEqual(data, [['custom'], 'cus']);
+  })
+);
 
 // Make sure tab completion doesn't crash REPL with half-baked proxy objects.
 // See: https://github.com/nodejs/node/issues/2119
@@ -336,30 +370,39 @@ putIn.run([
   'var proxy = new Proxy({}, {ownKeys: () => { throw new Error(); }});'
 ]);
 
-testMe.complete('proxy.', common.mustCall(function(error, data) {
-  assert.strictEqual(error, null);
-  assert(Array.isArray(data));
-}));
+testMe.complete(
+  'proxy.',
+  common.mustCall(function(error, data) {
+    assert.strictEqual(error, null);
+    assert(Array.isArray(data));
+  })
+);
 
 // Make sure tab completion does not include integer members of an Array
 putIn.run(['.clear']);
 
 putIn.run(['var ary = [1,2,3];']);
-testMe.complete('ary.', common.mustCall(function(error, data) {
-  assert.strictEqual(data[0].includes('ary.0'), false);
-  assert.strictEqual(data[0].includes('ary.1'), false);
-  assert.strictEqual(data[0].includes('ary.2'), false);
-}));
+testMe.complete(
+  'ary.',
+  common.mustCall(function(error, data) {
+    assert.strictEqual(data[0].includes('ary.0'), false);
+    assert.strictEqual(data[0].includes('ary.1'), false);
+    assert.strictEqual(data[0].includes('ary.2'), false);
+  })
+);
 
 // Make sure tab completion does not include integer keys in an object
 putIn.run(['.clear']);
 putIn.run(['var obj = {1:"a","1a":"b",a:"b"};']);
 
-testMe.complete('obj.', common.mustCall(function(error, data) {
-  assert.strictEqual(data[0].includes('obj.1'), false);
-  assert.strictEqual(data[0].includes('obj.1a'), false);
-  assert(data[0].includes('obj.a'));
-}));
+testMe.complete(
+  'obj.',
+  common.mustCall(function(error, data) {
+    assert.strictEqual(data[0].includes('obj.1'), false);
+    assert.strictEqual(data[0].includes('obj.1a'), false);
+    assert(data[0].includes('obj.a'));
+  })
+);
 
 // Don't try to complete results of non-simple expressions
 putIn.run(['.clear']);
@@ -371,31 +414,43 @@ testMe.complete('a().b.', getNoResultsFunction());
 putIn.run(['.clear']);
 putIn.run(['var obj = {1:"a","1a":"b",a:"b"};']);
 
-testMe.complete(' obj.', common.mustCall((error, data) => {
-  assert.strictEqual(data[0].includes('obj.1'), false);
-  assert.strictEqual(data[0].includes('obj.1a'), false);
-  assert(data[0].includes('obj.a'));
-}));
+testMe.complete(
+  ' obj.',
+  common.mustCall((error, data) => {
+    assert.strictEqual(data[0].includes('obj.1'), false);
+    assert.strictEqual(data[0].includes('obj.1a'), false);
+    assert(data[0].includes('obj.a'));
+  })
+);
 
 // Works inside assignments
 putIn.run(['.clear']);
 
-testMe.complete('var log = console.lo', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [['console.log'], 'console.lo']);
-}));
+testMe.complete(
+  'var log = console.lo',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, [['console.log'], 'console.lo']);
+  })
+);
 
 // tab completion for defined commands
 putIn.run(['.clear']);
 
-testMe.complete('.b', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [['break'], 'b']);
-}));
+testMe.complete(
+  '.b',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, [['break'], 'b']);
+  })
+);
 putIn.run(['.clear']);
 putIn.run(['var obj = {"hello, world!": "some string", "key": 123}']);
-testMe.complete('obj.', common.mustCall((error, data) => {
-  assert.strictEqual(data[0].includes('obj.hello, world!'), false);
-  assert(data[0].includes('obj.key'));
-}));
+testMe.complete(
+  'obj.',
+  common.mustCall((error, data) => {
+    assert.strictEqual(data[0].includes('obj.hello, world!'), false);
+    assert(data[0].includes('obj.key'));
+  })
+);
 
 [
   Array,
@@ -410,7 +465,7 @@ testMe.complete('obj.', common.mustCall((error, data) => {
   Int16Array,
   Int32Array,
   Float32Array,
-  Float64Array,
+  Float64Array
 ].forEach((type) => {
   putIn.run(['.clear']);
 
@@ -427,23 +482,23 @@ testMe.complete('obj.', common.mustCall((error, data) => {
   }
 
   hijackStderr(common.mustNotCall());
-  testMe.complete('ele.', common.mustCall((err, data) => {
-    restoreStderr();
-    assert.ifError(err);
+  testMe.complete(
+    'ele.',
+    common.mustCall((err, data) => {
+      restoreStderr();
+      assert.ifError(err);
 
-    const ele = (type === Array) ?
-      [] :
-      (type === Buffer ?
-        Buffer.alloc(0) :
-        new type(0));
+      const ele =
+        type === Array ? [] : type === Buffer ? Buffer.alloc(0) : new type(0);
 
-    assert.strictEqual(data[0].includes('ele.biu'), true);
+      assert.strictEqual(data[0].includes('ele.biu'), true);
 
-    data[0].forEach((key) => {
-      if (!key || key === 'ele.biu') return;
-      assert.notStrictEqual(ele[key.substr(4)], undefined);
-    });
-  }));
+      data[0].forEach((key) => {
+        if (!key || key === 'ele.biu') return;
+        assert.notStrictEqual(ele[key.substr(4)], undefined);
+      });
+    })
+  );
 });
 
 // check Buffer.prototype.length not crashing.
@@ -457,15 +512,20 @@ const testNonGlobal = repl.start({
   useGlobal: false
 });
 
-const builtins = [['Infinity', '', 'Int16Array', 'Int32Array',
-                   'Int8Array'], 'I'];
+const builtins = [
+  ['Infinity', '', 'Int16Array', 'Int32Array', 'Int8Array'],
+  'I'
+];
 
 if (common.hasIntl) {
   builtins[0].push('Intl');
 }
-testNonGlobal.complete('I', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, builtins);
-}));
+testNonGlobal.complete(
+  'I',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, builtins);
+  })
+);
 
 // To test custom completer function.
 // Sync mode.
@@ -483,20 +543,20 @@ const testCustomCompleterSyncMode = repl.start({
 
 // On empty line should output all the custom completions
 // without complete anything.
-testCustomCompleterSyncMode.complete('', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [
-    customCompletions,
-    ''
-  ]);
-}));
+testCustomCompleterSyncMode.complete(
+  '',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, [customCompletions, '']);
+  })
+);
 
 // On `a` should output `aaa aa1 aa2` and complete until `aa`.
-testCustomCompleterSyncMode.complete('a', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [
-    'aaa aa1 aa2'.split(' '),
-    'a'
-  ]);
-}));
+testCustomCompleterSyncMode.complete(
+  'a',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, ['aaa aa1 aa2'.split(' '), 'a']);
+  })
+);
 
 // To test custom completer function.
 // Async mode.
@@ -513,20 +573,20 @@ const testCustomCompleterAsyncMode = repl.start({
 
 // On empty line should output all the custom completions
 // without complete anything.
-testCustomCompleterAsyncMode.complete('', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [
-    customCompletions,
-    ''
-  ]);
-}));
+testCustomCompleterAsyncMode.complete(
+  '',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, [customCompletions, '']);
+  })
+);
 
 // On `a` should output `aaa aa1 aa2` and complete until `aa`.
-testCustomCompleterAsyncMode.complete('a', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [
-    'aaa aa1 aa2'.split(' '),
-    'a'
-  ]);
-}));
+testCustomCompleterAsyncMode.complete(
+  'a',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, ['aaa aa1 aa2'.split(' '), 'a']);
+  })
+);
 
 // tab completion in editor mode
 const editorStream = new ArrayStream();
@@ -539,34 +599,46 @@ const editor = repl.start({
 editorStream.run(['.clear']);
 editorStream.run(['.editor']);
 
-editor.completer('Uin', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [['Uint'], 'Uin']);
-}));
+editor.completer(
+  'Uin',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, [['Uint'], 'Uin']);
+  })
+);
 
 editorStream.run(['.clear']);
 editorStream.run(['.editor']);
 
-editor.completer('var log = console.l', common.mustCall((error, data) => {
-  assert.deepStrictEqual(data, [['console.log'], 'console.l']);
-}));
+editor.completer(
+  'var log = console.l',
+  common.mustCall((error, data) => {
+    assert.deepStrictEqual(data, [['console.log'], 'console.l']);
+  })
+);
 
 {
   // tab completion of lexically scoped variables
   const stream = new ArrayStream();
   const testRepl = repl.start({ stream });
 
-  stream.run([`
+  stream.run([
+    `
     let lexicalLet = true;
     const lexicalConst = true;
     class lexicalKlass {}
-  `]);
+  `
+  ]);
 
   ['Let', 'Const', 'Klass'].forEach((type) => {
     const query = `lexical${type[0]}`;
-    const expected = hasInspector ? [[`lexical${type}`], query] :
-      [[], `lexical${type[0]}`];
-    testRepl.complete(query, common.mustCall((error, data) => {
-      assert.deepStrictEqual(data, expected);
-    }));
+    const expected = hasInspector
+      ? [[`lexical${type}`], query]
+      : [[], `lexical${type[0]}`];
+    testRepl.complete(
+      query,
+      common.mustCall((error, data) => {
+        assert.deepStrictEqual(data, expected);
+      })
+    );
   });
 }
diff --git a/test/parallel/test-repl-tab.js b/test/parallel/test-repl-tab.js
index 0ebc9490771598..8b91e238f76757 100644
--- a/test/parallel/test-repl-tab.js
+++ b/test/parallel/test-repl-tab.js
@@ -6,8 +6,12 @@ const zlib = require('zlib');
 
 // just use builtin stream inherited from Duplex
 const putIn = zlib.createGzip();
-const testMe = repl.start('', putIn, function(cmd, context, filename,
-                                              callback) {
+const testMe = repl.start('', putIn, function(
+  cmd,
+  context,
+  filename,
+  callback
+) {
   callback(null, cmd);
 });
 
diff --git a/test/parallel/test-repl-top-level-await.js b/test/parallel/test-repl-top-level-await.js
index c6717a2120f45c..e8a9c6f986c116 100644
--- a/test/parallel/test-repl-top-level-await.js
+++ b/test/parallel/test-repl-top-level-await.js
@@ -82,56 +82,63 @@ async function ordinaryTests() {
     'function koo() { return Promise.resolve(4); }'
   ]);
   const testCases = [
-    [ 'await Promise.resolve(0)', '0' ],
-    [ '{ a: await Promise.resolve(1) }', '{ a: 1 }' ],
-    [ '_', '{ a: 1 }' ],
-    [ 'let { a, b } = await Promise.resolve({ a: 1, b: 2 }), f = 5;',
-      'undefined' ],
-    [ 'a', '1' ],
-    [ 'b', '2' ],
-    [ 'f', '5' ],
-    [ 'let c = await Promise.resolve(2)', 'undefined' ],
-    [ 'c', '2' ],
-    [ 'let d;', 'undefined' ],
-    [ 'd', 'undefined' ],
-    [ 'let [i, { abc: { k } }] = [0, { abc: { k: 1 } }];', 'undefined' ],
-    [ 'i', '0' ],
-    [ 'k', '1' ],
-    [ 'var l = await Promise.resolve(2);', 'undefined' ],
-    [ 'l', '2' ],
-    [ 'foo(await koo())', '4' ],
-    [ '_', '4' ],
-    [ 'const m = foo(await koo());', 'undefined' ],
-    [ 'm', '4' ],
-    [ 'const n = foo(await\nkoo());', 'undefined' ],
-    [ 'n', '4' ],
+    ['await Promise.resolve(0)', '0'],
+    ['{ a: await Promise.resolve(1) }', '{ a: 1 }'],
+    ['_', '{ a: 1 }'],
+    [
+      'let { a, b } = await Promise.resolve({ a: 1, b: 2 }), f = 5;',
+      'undefined'
+    ],
+    ['a', '1'],
+    ['b', '2'],
+    ['f', '5'],
+    ['let c = await Promise.resolve(2)', 'undefined'],
+    ['c', '2'],
+    ['let d;', 'undefined'],
+    ['d', 'undefined'],
+    ['let [i, { abc: { k } }] = [0, { abc: { k: 1 } }];', 'undefined'],
+    ['i', '0'],
+    ['k', '1'],
+    ['var l = await Promise.resolve(2);', 'undefined'],
+    ['l', '2'],
+    ['foo(await koo())', '4'],
+    ['_', '4'],
+    ['const m = foo(await koo());', 'undefined'],
+    ['m', '4'],
+    ['const n = foo(await\nkoo());', 'undefined'],
+    ['n', '4'],
     // eslint-disable-next-line no-template-curly-in-string
-    [ '`status: ${(await Promise.resolve({ status: 200 })).status}`',
-      "'status: 200'"],
-    [ 'for (let i = 0; i < 2; ++i) await i', 'undefined' ],
-    [ 'for (let i = 0; i < 2; ++i) { await i }', 'undefined' ],
-    [ 'await 0', '0' ],
-    [ 'await 0; function foo() {}', 'undefined' ],
-    [ 'foo', '[Function: foo]' ],
-    [ 'class Foo {}; await 1;', '1' ],
-    [ 'Foo', '[Function: Foo]' ],
-    [ 'if (await true) { function bar() {}; }', 'undefined' ],
-    [ 'bar', '[Function: bar]' ],
-    [ 'if (await true) { class Bar {}; }', 'undefined' ],
-    [ 'Bar', 'ReferenceError: Bar is not defined', { line: 0 } ],
-    [ 'await 0; function* gen(){}', 'undefined' ],
-    [ 'for (var i = 0; i < 10; ++i) { await i; }', 'undefined' ],
-    [ 'i', '10' ],
-    [ 'for (let j = 0; j < 5; ++j) { await j; }', 'undefined' ],
-    [ 'j', 'ReferenceError: j is not defined', { line: 0 } ],
-    [ 'gen', '[GeneratorFunction: gen]' ],
-    [ 'return 42; await 5;', 'SyntaxError: Illegal return statement',
-      { line: 3 } ],
-    [ 'let o = await 1, p', 'undefined' ],
-    [ 'p', 'undefined' ],
-    [ 'let q = 1, s = await 2', 'undefined' ],
-    [ 's', '2' ],
-    [ 'for await (let i of [1,2,3]) console.log(i)', 'undefined', { line: 3 } ]
+    [
+      '`status: ${(await Promise.resolve({ status: 200 })).status}`',
+      "'status: 200'"
+    ],
+    ['for (let i = 0; i < 2; ++i) await i', 'undefined'],
+    ['for (let i = 0; i < 2; ++i) { await i }', 'undefined'],
+    ['await 0', '0'],
+    ['await 0; function foo() {}', 'undefined'],
+    ['foo', '[Function: foo]'],
+    ['class Foo {}; await 1;', '1'],
+    ['Foo', '[Function: Foo]'],
+    ['if (await true) { function bar() {}; }', 'undefined'],
+    ['bar', '[Function: bar]'],
+    ['if (await true) { class Bar {}; }', 'undefined'],
+    ['Bar', 'ReferenceError: Bar is not defined', { line: 0 }],
+    ['await 0; function* gen(){}', 'undefined'],
+    ['for (var i = 0; i < 10; ++i) { await i; }', 'undefined'],
+    ['i', '10'],
+    ['for (let j = 0; j < 5; ++j) { await j; }', 'undefined'],
+    ['j', 'ReferenceError: j is not defined', { line: 0 }],
+    ['gen', '[GeneratorFunction: gen]'],
+    [
+      'return 42; await 5;',
+      'SyntaxError: Illegal return statement',
+      { line: 3 }
+    ],
+    ['let o = await 1, p', 'undefined'],
+    ['p', 'undefined'],
+    ['let q = 1, s = await 2', 'undefined'],
+    ['s', '2'],
+    ['for await (let i of [1,2,3]) console.log(i)', 'undefined', { line: 3 }]
   ];
 
   for (const [input, expected, options = {}] of testCases) {
@@ -155,15 +162,15 @@ async function ctrlCTest() {
   ]);
 
   console.log('Testing Ctrl+C');
-  assert.deepStrictEqual(await runAndWait([
-    'await timeout(100000)',
-    { ctrl: true, name: 'c' }
-  ]), [
-    'await timeout(100000)\r',
-    'Error [ERR_SCRIPT_EXECUTION_INTERRUPTED]: ' +
-      'Script execution was interrupted by `SIGINT`',
-    PROMPT
-  ]);
+  assert.deepStrictEqual(
+    await runAndWait(['await timeout(100000)', { ctrl: true, name: 'c' }]),
+    [
+      'await timeout(100000)\r',
+      'Error [ERR_SCRIPT_EXECUTION_INTERRUPTED]: ' +
+        'Script execution was interrupted by `SIGINT`',
+      PROMPT
+    ]
+  );
 }
 
 async function main() {
diff --git a/test/parallel/test-repl-underscore.js b/test/parallel/test-repl-underscore.js
index 7e7cabeda74433..9afbb4cca8e843 100644
--- a/test/parallel/test-repl-underscore.js
+++ b/test/parallel/test-repl-underscore.js
@@ -146,7 +146,7 @@ function testResetContextGlobal() {
     'Expression assignment to _ now disabled.',
     '10',
     '10',
-    '10',
+    '10'
   ]);
 
   // delete globals leaked by REPL when `useGlobal` is `true`
@@ -194,14 +194,12 @@ function testError() {
       'Error: baz',
       /setImmediate/,
       /^    at/,
-      /^    at/,
+      /^    at/
     ];
     for (const line of lines) {
       const expected = expectedLines.shift();
-      if (typeof expected === 'string')
-        assert.strictEqual(line, expected);
-      else
-        assert(expected.test(line), `${line} should match ${expected}`);
+      if (typeof expected === 'string') assert.strictEqual(line, expected);
+      else assert(expected.test(line), `${line} should match ${expected}`);
     }
     assert.strictEqual(expectedLines.length, 0);
 
diff --git a/test/parallel/test-repl-unexpected-token-recoverable.js b/test/parallel/test-repl-unexpected-token-recoverable.js
index 652c17d8f8ac59..9923f53e55d691 100644
--- a/test/parallel/test-repl-unexpected-token-recoverable.js
+++ b/test/parallel/test-repl-unexpected-token-recoverable.js
@@ -7,7 +7,7 @@ const assert = require('assert');
 
 const spawn = require('child_process').spawn;
 // use -i to force node into interactive mode, despite stdout not being a TTY
-const args = [ '-i' ];
+const args = ['-i'];
 const child = spawn(process.execPath, args);
 
 const input = 'var foo = "bar\\\nbaz"';
diff --git a/test/parallel/test-repl-use-global.js b/test/parallel/test-repl-use-global.js
index 947adc7f255035..36922e1c49540d 100644
--- a/test/parallel/test-repl-use-global.js
+++ b/test/parallel/test-repl-use-global.js
@@ -10,13 +10,12 @@ const assert = require('assert');
 // Array of [useGlobal, expectedResult] pairs
 const globalTestCases = [
   [false, 'undefined'],
-  [true, '\'tacos\''],
+  [true, "'tacos'"],
   [undefined, 'undefined']
 ];
 
 const globalTest = (useGlobal, cb, output) => (err, repl) => {
-  if (err)
-    return cb(err);
+  if (err) return cb(err);
 
   let str = '';
   output.on('data', (data) => (str += data));
@@ -29,10 +28,14 @@ const globalTest = (useGlobal, cb, output) => (err, repl) => {
 
 // Test how the global object behaves in each state for useGlobal
 for (const [option, expected] of globalTestCases) {
-  runRepl(option, globalTest, common.mustCall((err, output) => {
-    assert.ifError(err);
-    assert.strictEqual(output, expected);
-  }));
+  runRepl(
+    option,
+    globalTest,
+    common.mustCall((err, output) => {
+      assert.ifError(err);
+      assert.strictEqual(output, expected);
+    })
+  );
 }
 
 // Test how shadowing the process object via `let`
@@ -44,8 +47,7 @@ for (const [option, expected] of globalTestCases) {
 //
 const processTestCases = [false, undefined];
 const processTest = (useGlobal, cb, output) => (err, repl) => {
-  if (err)
-    return cb(err);
+  if (err) return cb(err);
 
   let str = '';
   output.on('data', (data) => (str += data));
@@ -58,10 +60,14 @@ const processTest = (useGlobal, cb, output) => (err, repl) => {
 };
 
 for (const option of processTestCases) {
-  runRepl(option, processTest, common.mustCall((err, output) => {
-    assert.ifError(err);
-    assert.strictEqual(output, 'undefined\n42');
-  }));
+  runRepl(
+    option,
+    processTest,
+    common.mustCall((err, output) => {
+      assert.ifError(err);
+      assert.strictEqual(output, 'undefined\n42');
+    })
+  );
 }
 
 function runRepl(useGlobal, testFunc, cb) {
@@ -79,5 +85,6 @@ function runRepl(useGlobal, testFunc, cb) {
   repl.createInternalRepl(
     process.env,
     opts,
-    testFunc(useGlobal, cb, opts.output));
+    testFunc(useGlobal, cb, opts.output)
+  );
 }
diff --git a/test/parallel/test-repl.js b/test/parallel/test-repl.js
index f8261dedd98974..92289a2bba7e2b 100644
--- a/test/parallel/test-repl.js
+++ b/test/parallel/test-repl.js
@@ -39,23 +39,22 @@ global.invoke_me = function(arg) {
 };
 
 // Helpers for describing the expected output:
-const kArrow = /^ *\^+ *$/;  // Arrow of ^ pointing to syntax error location
-const kSource = Symbol('kSource');  // Placeholder standing for input readback
+const kArrow = /^ *\^+ *$/; // Arrow of ^ pointing to syntax error location
+const kSource = Symbol('kSource'); // Placeholder standing for input readback
 
 async function runReplTests(socket, prompt, tests) {
   let lineBuffer = '';
 
   for (const { send, expect } of tests) {
     // expect can be a single line or multiple lines
-    const expectedLines = Array.isArray(expect) ? expect : [ expect ];
+    const expectedLines = Array.isArray(expect) ? expect : [expect];
 
     console.error('out:', JSON.stringify(send));
     socket.write(`${send}\n`);
 
     for (let expectedLine of expectedLines) {
       // special value: kSource refers to last sent source text
-      if (expectedLine === kSource)
-        expectedLine = send;
+      if (expectedLine === kSource) expectedLine = send;
 
       while (!lineBuffer.includes('\n')) {
         lineBuffer += await event(socket, 'data');
@@ -88,8 +87,10 @@ async function runReplTests(socket, prompt, tests) {
       if (typeof expectedLine === 'string') {
         assert.strictEqual(actualLine, expectedLine);
       } else {
-        assert(expectedLine.test(actualLine),
-               `${actualLine} match ${expectedLine}`);
+        assert(
+          expectedLine.test(actualLine),
+          `${actualLine} match ${expectedLine}`
+        );
       }
     }
   }
@@ -109,7 +110,7 @@ const unixTests = [
   },
   {
     send: 'invoke_me(987)',
-    expect: '\'invoked 987\''
+    expect: "'invoked 987'"
   },
   {
     send: 'a = 12345',
@@ -131,7 +132,7 @@ const strictModeTests = [
 const errorTests = [
   // Uncaught error throws and prints out
   {
-    send: 'throw new Error(\'test error\');',
+    send: "throw new Error('test error');",
     expect: 'Error: test error'
   },
   {
@@ -170,7 +171,7 @@ const errorTests = [
   },
   {
     send: '+ ".2"}`',
-    expect: '\'io.js 1.0.2\''
+    expect: "'io.js 1.0.2'"
   },
   {
     send: '`io.js ${',
@@ -178,7 +179,7 @@ const errorTests = [
   },
   {
     send: '"1.0" + ".2"}`',
-    expect: '\'io.js 1.0.2\''
+    expect: "'io.js 1.0.2'"
   },
   // Dot prefix in multiline commands aren't treated as commands
   {
@@ -187,7 +188,7 @@ const errorTests = [
   },
   {
     send: '.charAt(0))',
-    expect: '\'a\''
+    expect: "'a'"
   },
   // Floating point numbers are not interpreted as REPL commands.
   {
@@ -202,23 +203,23 @@ const errorTests = [
   // Can parse valid JSON
   {
     send: 'JSON.parse(\'{"valid": "json"}\');',
-    expect: '{ valid: \'json\' }'
+    expect: "{ valid: 'json' }"
   },
   // invalid input to JSON.parse error is special case of syntax error,
   // should throw
   {
-    send: 'JSON.parse(\'{invalid: \\\'json\\\'}\');',
+    send: "JSON.parse('{invalid: \\'json\\'}');",
     expect: [/^SyntaxError: /, '']
   },
   // end of input to JSON.parse error is special case of syntax error,
   // should throw
   {
-    send: 'JSON.parse(\'066\');',
+    send: "JSON.parse('066');",
     expect: [/^SyntaxError: /, '']
   },
   // should throw
   {
-    send: 'JSON.parse(\'{\');',
+    send: "JSON.parse('{');",
     expect: [/^SyntaxError: /, '']
   },
   // invalid RegExps are a special case of syntax error,
@@ -236,63 +237,27 @@ const errorTests = [
   // strict mode syntax errors should be caught (GH-5178)
   {
     send: '(function() { "use strict"; return 0755; })()',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   {
     send: '(function(a, a, b) { "use strict"; return a + b + c; })()',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   {
     send: '(function() { "use strict"; with (this) {} })()',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   {
     send: '(function() { "use strict"; var x; delete x; })()',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   {
     send: '(function() { "use strict"; eval = 17; })()',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   {
     send: '(function() { "use strict"; if (true) function f() { } })()',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   // Named functions can be used:
   {
@@ -374,7 +339,7 @@ const errorTests = [
   },
   {
     send: 'url.format("http://google.com")',
-    expect: '\'http://google.com/\''
+    expect: "'http://google.com/'"
   },
   {
     send: 'var path = 42; path',
@@ -395,18 +360,12 @@ const errorTests = [
   // fail when we are not inside a String and a line continuation is used
   {
     send: '[] \\',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   // do not fail when a String is created with line continuation
   {
-    send: '\'the\\\nfourth\\\neye\'',
-    expect: ['... ... \'thefourtheye\'']
+    send: "'the\\\nfourth\\\neye'",
+    expect: ["... ... 'thefourtheye'"]
   },
   // Don't fail when a partial String is created and line continuation is used
   // with whitespace characters at the end of the string. We are to ignore it.
@@ -418,22 +377,22 @@ const errorTests = [
   },
   // multiline strings preserve whitespace characters in them
   {
-    send: '\'the \\\n   fourth\t\t\\\n  eye  \'',
-    expect: '... ... \'the    fourth\\t\\t  eye  \''
+    send: "'the \\\n   fourth\t\t\\\n  eye  '",
+    expect: "... ... 'the    fourth\\t\\t  eye  '"
   },
   // more than one multiline strings also should preserve whitespace chars
   {
-    send: '\'the \\\n   fourth\' +  \'\t\t\\\n  eye  \'',
-    expect: '... ... \'the    fourth\\t\\t  eye  \''
+    send: "'the \\\n   fourth' +  '\t\t\\\n  eye  '",
+    expect: "... ... 'the    fourth\\t\\t  eye  '"
   },
   // using REPL commands within a string literal should still work
   {
-    send: '\'\\\n.break',
+    send: "'\\\n.break",
     expect: '... ' + prompt_unix
   },
   // using REPL command "help" within a string literal should still work
   {
-    send: '\'thefourth\\\n.help\neye\'',
+    send: "'thefourth\\\n.help\neye'",
     expect: [
       /\.break/,
       /\.clear/,
@@ -452,33 +411,33 @@ const errorTests = [
   },
   // empty lines in the string literals should not affect the string
   {
-    send: '\'the\\\n\\\nfourtheye\'\n',
-    expect: '... ... \'thefourtheye\''
+    send: "'the\\\n\\\nfourtheye'\n",
+    expect: "... ... 'thefourtheye'"
   },
   // Regression test for https://github.com/nodejs/node/issues/597
   {
-    send: '/(.)(.)(.)(.)(.)(.)(.)(.)(.)/.test(\'123456789\')\n',
+    send: "/(.)(.)(.)(.)(.)(.)(.)(.)(.)/.test('123456789')\n",
     expect: 'true'
   },
   // the following test's result depends on the RegExp's match from the above
   {
-    send: 'RegExp.$1\nRegExp.$2\nRegExp.$3\nRegExp.$4\nRegExp.$5\n' +
-          'RegExp.$6\nRegExp.$7\nRegExp.$8\nRegExp.$9\n',
-    expect: ['\'1\'', '\'2\'', '\'3\'', '\'4\'', '\'5\'', '\'6\'',
-             '\'7\'', '\'8\'', '\'9\'']
+    send:
+      'RegExp.$1\nRegExp.$2\nRegExp.$3\nRegExp.$4\nRegExp.$5\n' +
+      'RegExp.$6\nRegExp.$7\nRegExp.$8\nRegExp.$9\n',
+    expect: ["'1'", "'2'", "'3'", "'4'", "'5'", "'6'", "'7'", "'8'", "'9'"]
   },
   // regression tests for https://github.com/nodejs/node/issues/2749
   {
-    send: 'function x() {\nreturn \'\\n\';\n }',
+    send: "function x() {\nreturn '\\n';\n }",
     expect: '... ... undefined'
   },
   {
-    send: 'function x() {\nreturn \'\\\\\';\n }',
+    send: "function x() {\nreturn '\\\\';\n }",
     expect: '... ... undefined'
   },
   // regression tests for https://github.com/nodejs/node/issues/3421
   {
-    send: 'function x() {\n//\'\n }',
+    send: "function x() {\n//'\n }",
     expect: '... ... undefined'
   },
   {
@@ -486,7 +445,7 @@ const errorTests = [
     expect: '... ... undefined'
   },
   {
-    send: 'function x() {//\'\n }',
+    send: "function x() {//'\n }",
     expect: '... undefined'
   },
   {
@@ -511,18 +470,18 @@ const errorTests = [
   },
   {
     send: '"//"',
-    expect: '\'//\''
+    expect: "'//'"
   },
   {
     send: '"data /*with*/ comment"',
-    expect: '\'data /*with*/ comment\''
+    expect: "'data /*with*/ comment'"
   },
   {
-    send: 'function x(/*fn\'s optional params*/) {}',
+    send: "function x(/*fn's optional params*/) {}",
     expect: 'undefined'
   },
   {
-    send: '/* \'\n"\n\'"\'\n*/',
+    send: "/* '\n\"\n'\"'\n*/",
     expect: '... ... ... undefined'
   },
   // REPL should get a normal require() function, not one that allows
@@ -562,44 +521,26 @@ const errorTests = [
   // or block comment. https://github.com/nodejs/node/issues/3611
   {
     send: 'a = 3.5e',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   // Mitigate https://github.com/nodejs/node/issues/548
   {
     send: 'function name(){ return "node"; };name()',
-    expect: '\'node\''
+    expect: "'node'"
   },
   {
     send: 'function name(){ return "nodejs"; };name()',
-    expect: '\'nodejs\''
+    expect: "'nodejs'"
   },
   // Avoid emitting repl:line-number for SyntaxError
   {
     send: 'a = 3.5e',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   // Avoid emitting stack trace
   {
     send: 'a = 3.5e',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
 
   // https://github.com/nodejs/node/issues/9850
@@ -652,7 +593,7 @@ const errorTests = [
   // Newline within template string maintains whitespace.
   {
     send: '`foo \n`',
-    expect: '... \'foo \\n\''
+    expect: "... 'foo \\n'"
   },
   // Whitespace is not evaluated.
   {
@@ -662,13 +603,7 @@ const errorTests = [
   // Do not parse `...[]` as a REPL keyword
   {
     send: '...[]',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   // bring back the repl to prompt
   {
@@ -677,33 +612,15 @@ const errorTests = [
   },
   {
     send: 'console.log("Missing comma in arg list" process.version)',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   {
     send: 'x = {\nfield\n{',
-    expect: [
-      '... ... {',
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: ['... ... {', kArrow, '', /^SyntaxError: /, '']
   },
   {
     send: '(2 + 3))',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
   },
   {
     send: 'if (typeof process === "object"); {',
@@ -715,14 +632,8 @@ const errorTests = [
   },
   {
     send: '} else {',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
-  },
+    expect: [kSource, kArrow, '', /^SyntaxError: /, '']
+  }
 ];
 
 const tcpTests = [
@@ -732,7 +643,7 @@ const tcpTests = [
   },
   {
     send: 'invoke_me(333)',
-    expect: '\'invoked 333\''
+    expect: "'invoked 333'"
   },
   {
     send: 'a += 1',
@@ -746,7 +657,7 @@ const tcpTests = [
 
 (async function() {
   {
-    const [ socket, replServer ] = await startUnixRepl();
+    const [socket, replServer] = await startUnixRepl();
 
     await runReplTests(socket, prompt_unix, unixTests);
     await runReplTests(socket, prompt_unix, errorTests);
@@ -756,7 +667,7 @@ const tcpTests = [
     socket.end();
   }
   {
-    const [ socket ] = await startTCPRepl();
+    const [socket] = await startTCPRepl();
 
     await runReplTests(socket, prompt_tcp, tcpTests);
 
@@ -768,79 +679,107 @@ const tcpTests = [
 function startTCPRepl() {
   let resolveSocket, resolveReplServer;
 
-  const server = net.createServer(common.mustCall((socket) => {
-    assert.strictEqual(server, socket.server);
-
-    socket.on('end', common.mustCall(() => {
-      socket.end();
-    }));
-
-    resolveReplServer(repl.start(prompt_tcp, socket));
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    const client = net.createConnection(server.address().port);
-
-    client.setEncoding('utf8');
-
-    client.on('connect', common.mustCall(() => {
-      assert.strictEqual(client.readable, true);
-      assert.strictEqual(client.writable, true);
-
-      resolveSocket(client);
-    }));
-
-    client.on('close', common.mustCall(() => {
-      server.close();
-    }));
-  }));
+  const server = net.createServer(
+    common.mustCall((socket) => {
+      assert.strictEqual(server, socket.server);
+
+      socket.on(
+        'end',
+        common.mustCall(() => {
+          socket.end();
+        })
+      );
+
+      resolveReplServer(repl.start(prompt_tcp, socket));
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const client = net.createConnection(server.address().port);
+
+      client.setEncoding('utf8');
+
+      client.on(
+        'connect',
+        common.mustCall(() => {
+          assert.strictEqual(client.readable, true);
+          assert.strictEqual(client.writable, true);
+
+          resolveSocket(client);
+        })
+      );
+
+      client.on(
+        'close',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+    })
+  );
 
   return Promise.all([
-    new Promise((resolve) => resolveSocket = resolve),
-    new Promise((resolve) => resolveReplServer = resolve)
+    new Promise((resolve) => (resolveSocket = resolve)),
+    new Promise((resolve) => (resolveReplServer = resolve))
   ]);
 }
 
 function startUnixRepl() {
   let resolveSocket, resolveReplServer;
 
-  const server = net.createServer(common.mustCall((socket) => {
-    assert.strictEqual(server, socket.server);
-
-    socket.on('end', common.mustCall(() => {
-      socket.end();
-    }));
-
-    const replServer = repl.start({
-      prompt: prompt_unix,
-      input: socket,
-      output: socket,
-      useGlobal: true
-    });
-    replServer.context.message = message;
-    resolveReplServer(replServer);
-  }));
-
-  server.listen(common.PIPE, common.mustCall(() => {
-    const client = net.createConnection(common.PIPE);
-
-    client.setEncoding('utf8');
-
-    client.on('connect', common.mustCall(() => {
-      assert.strictEqual(client.readable, true);
-      assert.strictEqual(client.writable, true);
-
-      resolveSocket(client);
-    }));
-
-    client.on('close', common.mustCall(() => {
-      server.close();
-    }));
-  }));
+  const server = net.createServer(
+    common.mustCall((socket) => {
+      assert.strictEqual(server, socket.server);
+
+      socket.on(
+        'end',
+        common.mustCall(() => {
+          socket.end();
+        })
+      );
+
+      const replServer = repl.start({
+        prompt: prompt_unix,
+        input: socket,
+        output: socket,
+        useGlobal: true
+      });
+      replServer.context.message = message;
+      resolveReplServer(replServer);
+    })
+  );
+
+  server.listen(
+    common.PIPE,
+    common.mustCall(() => {
+      const client = net.createConnection(common.PIPE);
+
+      client.setEncoding('utf8');
+
+      client.on(
+        'connect',
+        common.mustCall(() => {
+          assert.strictEqual(client.readable, true);
+          assert.strictEqual(client.writable, true);
+
+          resolveSocket(client);
+        })
+      );
+
+      client.on(
+        'close',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+    })
+  );
 
   return Promise.all([
-    new Promise((resolve) => resolveSocket = resolve),
-    new Promise((resolve) => resolveReplServer = resolve)
+    new Promise((resolve) => (resolveSocket = resolve)),
+    new Promise((resolve) => (resolveReplServer = resolve))
   ]);
 }
 
diff --git a/test/parallel/test-require-cache.js b/test/parallel/test-require-cache.js
index 7b62ab57648a2f..28caaec71a522b 100644
--- a/test/parallel/test-require-cache.js
+++ b/test/parallel/test-require-cache.js
@@ -33,7 +33,6 @@ const assert = require('assert');
   assert.strictEqual(require(relativePath), fakeModule);
 }
 
-
 {
   const relativePath = 'fs';
   const fakeModule = {};
diff --git a/test/parallel/test-require-deps-deprecation.js b/test/parallel/test-require-deps-deprecation.js
index 5bee24a5db19ce..4a35f4894d261e 100644
--- a/test/parallel/test-require-deps-deprecation.js
+++ b/test/parallel/test-require-deps-deprecation.js
@@ -21,15 +21,18 @@ const deprecatedModules = [
 
 // Newly added deps that do not have a deprecation wrapper around it would
 // throw an error, but no warning would be emitted.
-const deps = [
-  'acorn/dist/acorn',
-  'acorn/dist/walk'
-];
+const deps = ['acorn/dist/acorn', 'acorn/dist/walk'];
 
-common.expectWarning('DeprecationWarning', deprecatedModules.map((m) => {
-  return [`Requiring Node.js-bundled '${m}' module is deprecated. ` +
-         'Please install the necessary module locally.', 'DEP0084'];
-}));
+common.expectWarning(
+  'DeprecationWarning',
+  deprecatedModules.map((m) => {
+    return [
+      `Requiring Node.js-bundled '${m}' module is deprecated. ` +
+        'Please install the necessary module locally.',
+      'DEP0084'
+    ];
+  })
+);
 
 for (const m of deprecatedModules) {
   try {
diff --git a/test/parallel/test-require-exceptions.js b/test/parallel/test-require-exceptions.js
index 132bffed0f6529..d76c1faee674a5 100644
--- a/test/parallel/test-require-exceptions.js
+++ b/test/parallel/test-require-exceptions.js
@@ -44,12 +44,15 @@ assertExists('/module-require/not-found/node_modules/module1/package.json');
 assertModuleNotFound('/module-require/not-found/trailingSlash');
 
 function assertModuleNotFound(path) {
-  assert.throws(function() {
-    require(fixtures.path(path));
-  }, function(e) {
-    assert.strictEqual(e.code, 'MODULE_NOT_FOUND');
-    return true;
-  });
+  assert.throws(
+    function() {
+      require(fixtures.path(path));
+    },
+    function(e) {
+      assert.strictEqual(e.code, 'MODULE_NOT_FOUND');
+      return true;
+    }
+  );
 }
 
 function assertExists(fixture) {
diff --git a/test/parallel/test-require-extension-over-directory.js b/test/parallel/test-require-extension-over-directory.js
index cc896d7b61b090..a1ae832f12580f 100644
--- a/test/parallel/test-require-extension-over-directory.js
+++ b/test/parallel/test-require-extension-over-directory.js
@@ -5,14 +5,16 @@ const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const path = require('path');
 
-const fixturesRequire = require(
-  fixtures.path('module-extension-over-directory', 'inner'));
+const fixturesRequire = require(fixtures.path(
+  'module-extension-over-directory',
+  'inner'
+));
 
 assert.strictEqual(
   fixturesRequire,
   require(fixtures.path('module-extension-over-directory', 'inner.js')),
   'test-require-extension-over-directory failed to import fixture' +
-  ' requirements'
+    ' requirements'
 );
 
 const fakePath = [
@@ -26,5 +28,5 @@ assert.strictEqual(
   fixturesRequireDir,
   require(fixtures.path('module-extension-over-directory', 'inner/')),
   'test-require-extension-over-directory failed to import fixture' +
-  ' requirements'
+    ' requirements'
 );
diff --git a/test/parallel/test-require-extensions-same-filename-as-dir-trailing-slash.js b/test/parallel/test-require-extensions-same-filename-as-dir-trailing-slash.js
index f79f07a45d9de4..0f7244238e4368 100644
--- a/test/parallel/test-require-extensions-same-filename-as-dir-trailing-slash.js
+++ b/test/parallel/test-require-extensions-same-filename-as-dir-trailing-slash.js
@@ -25,12 +25,13 @@ require('../common');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 
-const content =
-  require(fixtures.path('json-with-directory-name-module',
-                        'module-stub',
-                        'one-trailing-slash',
-                        'two',
-                        'three.js'));
+const content = require(fixtures.path(
+  'json-with-directory-name-module',
+  'module-stub',
+  'one-trailing-slash',
+  'two',
+  'three.js'
+));
 
 assert.notStrictEqual(content.rocko, 'artischocko');
 assert.strictEqual(content, 'hello from module-stub!');
diff --git a/test/parallel/test-require-extensions-same-filename-as-dir.js b/test/parallel/test-require-extensions-same-filename-as-dir.js
index 1084d1d4581329..9c546dc6aee595 100644
--- a/test/parallel/test-require-extensions-same-filename-as-dir.js
+++ b/test/parallel/test-require-extensions-same-filename-as-dir.js
@@ -24,9 +24,13 @@ require('../common');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 
-const content = require(fixtures.path('json-with-directory-name-module',
-                                      'module-stub', 'one', 'two',
-                                      'three.js'));
+const content = require(fixtures.path(
+  'json-with-directory-name-module',
+  'module-stub',
+  'one',
+  'two',
+  'three.js'
+));
 
 assert.notStrictEqual(content.rocko, 'artischocko');
 assert.strictEqual(content, 'hello from module-stub!');
diff --git a/test/parallel/test-require-invalid-package.js b/test/parallel/test-require-invalid-package.js
index 669ea54e52b442..351997cb6a3ca0 100644
--- a/test/parallel/test-require-invalid-package.js
+++ b/test/parallel/test-require-invalid-package.js
@@ -3,6 +3,6 @@
 const common = require('../common');
 
 // Should be an invalid package path.
-common.expectsError(() => require('package.json'),
-                    { code: 'MODULE_NOT_FOUND' }
-);
+common.expectsError(() => require('package.json'), {
+  code: 'MODULE_NOT_FOUND'
+});
diff --git a/test/parallel/test-require-json.js b/test/parallel/test-require-json.js
index e8c7b05bab8a57..c09c257a976e1e 100644
--- a/test/parallel/test-require-json.js
+++ b/test/parallel/test-require-json.js
@@ -29,5 +29,6 @@ try {
 } catch (err) {
   assert.ok(
     /test[/\\]fixtures[/\\]invalid\.json: /.test(err.message),
-    `require() json error should include path: ${err.message}`);
+    `require() json error should include path: ${err.message}`
+  );
 }
diff --git a/test/parallel/test-require-long-path.js b/test/parallel/test-require-long-path.js
index 548a0b5425df39..63709423524c03 100644
--- a/test/parallel/test-require-long-path.js
+++ b/test/parallel/test-require-long-path.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.isWindows)
-  common.skip('this test is Windows-specific.');
+if (!common.isWindows) common.skip('this test is Windows-specific.');
 
 const fs = require('fs');
 const path = require('path');
diff --git a/test/parallel/test-require-resolve.js b/test/parallel/test-require-resolve.js
index 2ffcc711854a87..27fd0c8a7f2f9b 100644
--- a/test/parallel/test-require-resolve.js
+++ b/test/parallel/test-require-resolve.js
@@ -26,10 +26,12 @@ const assert = require('assert');
 
 assert.strictEqual(
   require.resolve(fixtures.path('a')).toLowerCase(),
-  fixtures.path('a.js').toLowerCase());
+  fixtures.path('a.js').toLowerCase()
+);
 assert.strictEqual(
   require.resolve(fixtures.path('nested-index', 'one')).toLowerCase(),
-  fixtures.path('nested-index', 'one', 'index.js').toLowerCase());
+  fixtures.path('nested-index', 'one', 'index.js').toLowerCase()
+);
 assert.strictEqual(require.resolve('path'), 'path');
 
 // Test configurable resolve() paths.
@@ -39,16 +41,22 @@ require(fixtures.path('resolve-paths', 'default', 'verify-paths.js'));
 const re = /^The "request" argument must be of type string\. Received type \w+$/;
 [1, false, null, undefined, {}].forEach((value) => {
   common.expectsError(
-    () => { require.resolve(value); },
+    () => {
+      require.resolve(value);
+    },
     {
       code: 'ERR_INVALID_ARG_TYPE',
       message: re
-    });
+    }
+  );
 
   common.expectsError(
-    () => { require.resolve.paths(value); },
+    () => {
+      require.resolve.paths(value);
+    },
     {
       code: 'ERR_INVALID_ARG_TYPE',
       message: re
-    });
+    }
+  );
 });
diff --git a/test/parallel/test-require-symlink.js b/test/parallel/test-require-symlink.js
index c73fdcd41e6efa..105eaf7bd86de2 100644
--- a/test/parallel/test-require-symlink.js
+++ b/test/parallel/test-require-symlink.js
@@ -2,8 +2,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.canCreateSymLink())
-  common.skip('insufficient privileges');
+if (!common.canCreateSymLink()) common.skip('insufficient privileges');
 if (!common.isMainThread)
   common.skip('process.chdir is not available in Workers');
 
@@ -45,11 +44,13 @@ copyDir(fixtureSource, tmpDirTarget);
 // path.
 process.chdir(tmpdir.path);
 
-const linkDir = path.join(dirName,
-                          'node_modules',
-                          'dep1',
-                          'node_modules',
-                          'dep2');
+const linkDir = path.join(
+  dirName,
+  'node_modules',
+  'dep1',
+  'node_modules',
+  'dep2'
+);
 
 const linkTarget = path.join('..', '..', 'dep2');
 
diff --git a/test/parallel/test-require-unicode.js b/test/parallel/test-require-unicode.js
index 530ff3bb56c3d0..d2be3f9be42957 100644
--- a/test/parallel/test-require-unicode.js
+++ b/test/parallel/test-require-unicode.js
@@ -11,7 +11,9 @@ tmpdir.refresh();
 const dirname = path.join(tmpdir.path, '\u4e2d\u6587\u76ee\u5f55');
 fs.mkdirSync(dirname);
 fs.writeFileSync(path.join(dirname, 'file.js'), 'module.exports = 42;');
-fs.writeFileSync(path.join(dirname, 'package.json'),
-                 JSON.stringify({ name: 'test', main: 'file.js' }));
+fs.writeFileSync(
+  path.join(dirname, 'package.json'),
+  JSON.stringify({ name: 'test', main: 'file.js' })
+);
 assert.strictEqual(require(dirname), 42);
 assert.strictEqual(require(path.join(dirname, 'file.js')), 42);
diff --git a/test/parallel/test-setproctitle.js b/test/parallel/test-setproctitle.js
index e5f6858f786ba3..f5de15212773c9 100644
--- a/test/parallel/test-setproctitle.js
+++ b/test/parallel/test-setproctitle.js
@@ -3,8 +3,7 @@
 const common = require('../common');
 
 // FIXME add sunos support
-if (common.isSunOS)
-  common.skip(`Unsupported platform [${process.platform}]`);
+if (common.isSunOS) common.skip(`Unsupported platform [${process.platform}]`);
 if (!common.isMainThread)
   common.skip('Setting the process title from Workers is not supported');
 
@@ -22,23 +21,25 @@ process.title = title;
 assert.strictEqual(process.title, title);
 
 // Test setting the title but do not try to run `ps` on Windows.
-if (common.isWindows)
-  common.skip('Windows does not have "ps" utility');
+if (common.isWindows) common.skip('Windows does not have "ps" utility');
 
 // To pass this test on alpine, since Busybox `ps` does not
 // support `-p` switch, use `ps -o` and `grep` instead.
-const cmd = common.isLinux ?
-  `ps -o pid,args | grep '${process.pid} ${title}' | grep -v grep` :
-  `ps -p ${process.pid} -o args=`;
-
-exec(cmd, common.mustCall((error, stdout, stderr) => {
-  assert.ifError(error);
-  assert.strictEqual(stderr, '');
-
-  // freebsd always add ' (procname)' to the process title
-  if (common.isFreeBSD || common.isOpenBSD)
-    title += ` (${path.basename(process.execPath)})`;
-
-  // omitting trailing whitespace and \n
-  assert.strictEqual(stdout.replace(/\s+$/, '').endsWith(title), true);
-}));
+const cmd = common.isLinux
+  ? `ps -o pid,args | grep '${process.pid} ${title}' | grep -v grep`
+  : `ps -p ${process.pid} -o args=`;
+
+exec(
+  cmd,
+  common.mustCall((error, stdout, stderr) => {
+    assert.ifError(error);
+    assert.strictEqual(stderr, '');
+
+    // freebsd always add ' (procname)' to the process title
+    if (common.isFreeBSD || common.isOpenBSD)
+      title += ` (${path.basename(process.execPath)})`;
+
+    // omitting trailing whitespace and \n
+    assert.strictEqual(stdout.replace(/\s+$/, '').endsWith(title), true);
+  })
+);
diff --git a/test/parallel/test-sigint-infinite-loop.js b/test/parallel/test-sigint-infinite-loop.js
index 30eb98ecb8a265..d0deb50f2a918b 100644
--- a/test/parallel/test-sigint-infinite-loop.js
+++ b/test/parallel/test-sigint-infinite-loop.js
@@ -24,10 +24,13 @@ c.stdout.on('data', function(s) {
   }
 });
 
-c.on('exit', common.mustCall(function(code) {
-  assert.ok(code !== 0);
-  console.log('killed infinite-loop.js');
-}));
+c.on(
+  'exit',
+  common.mustCall(function(code) {
+    assert.ok(code !== 0);
+    console.log('killed infinite-loop.js');
+  })
+);
 
 process.on('exit', function() {
   assert.ok(sentKill);
diff --git a/test/parallel/test-signal-args.js b/test/parallel/test-signal-args.js
index 7b72ed6dcb92d5..105ba7e25c2fcd 100644
--- a/test/parallel/test-signal-args.js
+++ b/test/parallel/test-signal-args.js
@@ -8,15 +8,21 @@ if (common.isWindows)
 if (!common.isMainThread)
   common.skip('No signal handling available in Workers');
 
-process.once('SIGINT', common.mustCall((signal) => {
-  assert.strictEqual(signal, 'SIGINT');
-}));
+process.once(
+  'SIGINT',
+  common.mustCall((signal) => {
+    assert.strictEqual(signal, 'SIGINT');
+  })
+);
 
 process.kill(process.pid, 'SIGINT');
 
-process.once('SIGTERM', common.mustCall((signal) => {
-  assert.strictEqual(signal, 'SIGTERM');
-}));
+process.once(
+  'SIGTERM',
+  common.mustCall((signal) => {
+    assert.strictEqual(signal, 'SIGTERM');
+  })
+);
 
 process.kill(process.pid, 'SIGTERM');
 
diff --git a/test/parallel/test-signal-handler.js b/test/parallel/test-signal-handler.js
index 05ec4e7f73faf5..d2344113fd3cbf 100644
--- a/test/parallel/test-signal-handler.js
+++ b/test/parallel/test-signal-handler.js
@@ -32,12 +32,15 @@ console.log(`process.pid: ${process.pid}`);
 
 process.on('SIGUSR1', common.mustCall());
 
-process.on('SIGUSR1', common.mustCall(function() {
-  setTimeout(function() {
-    console.log('End.');
-    process.exit(0);
-  }, 5);
-}));
+process.on(
+  'SIGUSR1',
+  common.mustCall(function() {
+    setTimeout(function() {
+      console.log('End.');
+      process.exit(0);
+    }, 5);
+  })
+);
 
 let i = 0;
 setInterval(function() {
diff --git a/test/parallel/test-signal-unregister.js b/test/parallel/test-signal-unregister.js
index 2c4d3129426bbb..afe07f98640116 100644
--- a/test/parallel/test-signal-unregister.js
+++ b/test/parallel/test-signal-unregister.js
@@ -8,7 +8,10 @@ const child = spawn(process.argv[0], [fixtures.path('should_exit.js')]);
 child.stdout.once('data', function() {
   child.kill('SIGINT');
 });
-child.on('exit', common.mustCall(function(exitCode, signalCode) {
-  assert.strictEqual(exitCode, null);
-  assert.strictEqual(signalCode, 'SIGINT');
-}));
+child.on(
+  'exit',
+  common.mustCall(function(exitCode, signalCode) {
+    assert.strictEqual(exitCode, null);
+    assert.strictEqual(signalCode, 'SIGINT');
+  })
+);
diff --git a/test/parallel/test-socket-address.js b/test/parallel/test-socket-address.js
index ccffc5300bbe19..f631e3687bdace 100644
--- a/test/parallel/test-socket-address.js
+++ b/test/parallel/test-socket-address.js
@@ -7,11 +7,13 @@ const net = require('net');
 // returns an error number, an error is thrown.
 
 const server = net.createServer({});
-server.listen(0, common.mustCall(function() {
-  server._handle.getsockname = function(out) {
-    return -1;
-  };
-  assert.throws(() => this.address(),
-                /^Error: address [\w|\s-\d]+$/);
-  server.close();
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    server._handle.getsockname = function(out) {
+      return -1;
+    };
+    assert.throws(() => this.address(), /^Error: address [\w|\s-\d]+$/);
+    server.close();
+  })
+);
diff --git a/test/parallel/test-socket-write-after-fin.js b/test/parallel/test-socket-write-after-fin.js
index 2551d3f54f651f..c99b29c65f5952 100644
--- a/test/parallel/test-socket-write-after-fin.js
+++ b/test/parallel/test-socket-write-after-fin.js
@@ -4,37 +4,48 @@ const assert = require('assert');
 const net = require('net');
 const expected = 'hello1hello2hello3\nbye';
 
-const server = net.createServer({
-  allowHalfOpen: true
-}, common.mustCall(function(sock) {
-  let serverData = '';
+const server = net.createServer(
+  {
+    allowHalfOpen: true
+  },
+  common.mustCall(function(sock) {
+    let serverData = '';
 
-  sock.setEncoding('utf8');
-  sock.on('data', function(c) {
-    serverData += c;
-  });
-  sock.on('end', common.mustCall(function() {
-    assert.strictEqual(serverData, expected);
-    sock.end(serverData);
-    server.close();
-  }));
-}));
-server.listen(0, common.mustCall(function() {
-  const sock = net.connect(this.address().port);
-  let clientData = '';
+    sock.setEncoding('utf8');
+    sock.on('data', function(c) {
+      serverData += c;
+    });
+    sock.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(serverData, expected);
+        sock.end(serverData);
+        server.close();
+      })
+    );
+  })
+);
+server.listen(
+  0,
+  common.mustCall(function() {
+    const sock = net.connect(this.address().port);
+    let clientData = '';
 
-  sock.setEncoding('utf8');
-  sock.on('data', function(c) {
-    clientData += c;
-  });
+    sock.setEncoding('utf8');
+    sock.on('data', function(c) {
+      clientData += c;
+    });
 
-  sock.on('end', common.mustCall(function() {
-    assert.strictEqual(clientData, expected);
-  }));
+    sock.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(clientData, expected);
+      })
+    );
 
-  sock.write('hello1');
-  sock.write('hello2');
-  sock.write('hello3\n');
-  assert.strictEqual(sock.end('bye'), sock);
-
-}));
+    sock.write('hello1');
+    sock.write('hello2');
+    sock.write('hello3\n');
+    assert.strictEqual(sock.end('bye'), sock);
+  })
+);
diff --git a/test/parallel/test-spawn-cmd-named-pipe.js b/test/parallel/test-spawn-cmd-named-pipe.js
index 30d0ec2c263fcb..171176d38a4a52 100644
--- a/test/parallel/test-spawn-cmd-named-pipe.js
+++ b/test/parallel/test-spawn-cmd-named-pipe.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 // This test is intended for Windows only
-if (!common.isWindows)
-  common.skip('this test is Windows-specific.');
+if (!common.isWindows) common.skip('this test is Windows-specific.');
 
 const assert = require('assert');
 
@@ -17,8 +16,7 @@ if (!process.argv[2]) {
   const stdoutPipeName = `\\\\.\\pipe\\${pipeNamePrefix}.stdout`;
 
   const stdinPipeServer = net.createServer(function(c) {
-    c.on('end', common.mustCall(function() {
-    }));
+    c.on('end', common.mustCall(function() {}));
     c.end('hello');
   });
   stdinPipeServer.listen(stdinPipeName);
@@ -29,22 +27,34 @@ if (!process.argv[2]) {
     c.on('data', function(x) {
       output.push(x);
     });
-    c.on('end', common.mustCall(function() {
-      assert.strictEqual(output.join(''), 'hello');
-    }));
+    c.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(output.join(''), 'hello');
+      })
+    );
   });
   stdoutPipeServer.listen(stdoutPipeName);
 
-  const args =
-    [`"${__filename}"`, 'child', '<', stdinPipeName, '>', stdoutPipeName];
+  const args = [
+    `"${__filename}"`,
+    'child',
+    '<',
+    stdinPipeName,
+    '>',
+    stdoutPipeName
+  ];
 
   const child = spawn(`"${process.execPath}"`, args, { shell: true });
 
-  child.on('exit', common.mustCall(function(exitCode) {
-    stdinPipeServer.close();
-    stdoutPipeServer.close();
-    assert.strictEqual(exitCode, 0);
-  }));
+  child.on(
+    'exit',
+    common.mustCall(function(exitCode) {
+      stdinPipeServer.close();
+      stdoutPipeServer.close();
+      assert.strictEqual(exitCode, 0);
+    })
+  );
 } else {
   // child
   process.stdin.pipe(process.stdout);
diff --git a/test/parallel/test-stdin-child-proc.js b/test/parallel/test-stdin-child-proc.js
index bbb6a29cd724c9..87ba32ff299084 100644
--- a/test/parallel/test-stdin-child-proc.js
+++ b/test/parallel/test-stdin-child-proc.js
@@ -5,11 +5,13 @@ const common = require('../common');
 const assert = require('assert');
 const child_process = require('child_process');
 const path = require('path');
-const cp = child_process.spawn(
-  process.execPath,
-  [path.resolve(__dirname, 'test-stdin-pause-resume.js')]
-);
+const cp = child_process.spawn(process.execPath, [
+  path.resolve(__dirname, 'test-stdin-pause-resume.js')
+]);
 
-cp.on('exit', common.mustCall((code) => {
-  assert.strictEqual(code, 0);
-}));
+cp.on(
+  'exit',
+  common.mustCall((code) => {
+    assert.strictEqual(code, 0);
+  })
+);
diff --git a/test/parallel/test-stdin-from-file.js b/test/parallel/test-stdin-from-file.js
index f4fcb32edbfde5..aa7103d57c8067 100644
--- a/test/parallel/test-stdin-from-file.js
+++ b/test/parallel/test-stdin-from-file.js
@@ -12,18 +12,18 @@ const tmpFile = join(tmpdir.path, 'stdin.txt');
 
 const cmd = `"${process.argv[0]}" "${stdoutScript}" < "${tmpFile}"`;
 
-const string = 'abc\nümlaut.\nsomething else\n' +
-               '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，' +
-               '疆域包括今天中国的广东、广西两省区的大部份地区，福建省、湖南、贵州、' +
-               '云南的一小部份地区和越南的北部。南越国是秦朝灭亡后，' +
-               '由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。前196年和前179年，' +
-               '南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
-               '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
-               '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，' +
-               '采用封建制和郡县制并存的制度，' +
-               '它的建立保证了秦末乱世岭南地区社会秩序的稳定，' +
-               '有效的改善了岭南地区落后的政治、##济现状。\n';
-
+const string =
+  'abc\nümlaut.\nsomething else\n' +
+  '南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，' +
+  '疆域包括今天中国的广东、广西两省区的大部份地区，福建省、湖南、贵州、' +
+  '云南的一小部份地区和越南的北部。南越国是秦朝灭亡后，' +
+  '由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。前196年和前179年，' +
+  '南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，' +
+  '南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，' +
+  '历经五代君主。南越国是岭南地区的第一个有记载的政权国家，' +
+  '采用封建制和郡县制并存的制度，' +
+  '它的建立保证了秦末乱世岭南地区社会秩序的稳定，' +
+  '有效的改善了岭南地区落后的政治、##济现状。\n';
 
 tmpdir.refresh();
 
@@ -31,10 +31,13 @@ console.log(`${cmd}\n\n`);
 
 fs.writeFileSync(tmpFile, string);
 
-childProcess.exec(cmd, common.mustCall(function(err, stdout, stderr) {
-  fs.unlinkSync(tmpFile);
+childProcess.exec(
+  cmd,
+  common.mustCall(function(err, stdout, stderr) {
+    fs.unlinkSync(tmpFile);
 
-  assert.ifError(err);
-  assert.strictEqual(stdout, `hello world\r\n${string}`);
-  assert.strictEqual(stderr, '');
-}));
+    assert.ifError(err);
+    assert.strictEqual(stdout, `hello world\r\n${string}`);
+    assert.strictEqual(stderr, '');
+  })
+);
diff --git a/test/parallel/test-stdin-pipe-large.js b/test/parallel/test-stdin-pipe-large.js
index 5f4a2f10c8dd6d..1854b67d0c7d27 100644
--- a/test/parallel/test-stdin-pipe-large.js
+++ b/test/parallel/test-stdin-pipe-large.js
@@ -17,7 +17,10 @@ let readBytes = 0;
 
 child.stdin.end(Buffer.alloc(expectedBytes));
 
-child.stdout.on('data', (chunk) => readBytes += chunk.length);
-child.stdout.on('end', common.mustCall(() => {
-  assert.strictEqual(readBytes, expectedBytes);
-}));
+child.stdout.on('data', (chunk) => (readBytes += chunk.length));
+child.stdout.on(
+  'end',
+  common.mustCall(() => {
+    assert.strictEqual(readBytes, expectedBytes);
+  })
+);
diff --git a/test/parallel/test-stdin-script-child-option.js b/test/parallel/test-stdin-script-child-option.js
index 5526d66f3f2807..150d29b6c07e4f 100644
--- a/test/parallel/test-stdin-script-child-option.js
+++ b/test/parallel/test-stdin-script-child-option.js
@@ -11,7 +11,10 @@ child.stdin.end('console.log(process.argv[2])');
 
 let actual = '';
 child.stdout.setEncoding('utf8');
-child.stdout.on('data', (chunk) => actual += chunk);
-child.stdout.on('end', common.mustCall(() => {
-  assert.strictEqual(actual.trim(), expected);
-}));
+child.stdout.on('data', (chunk) => (actual += chunk));
+child.stdout.on(
+  'end',
+  common.mustCall(() => {
+    assert.strictEqual(actual.trim(), expected);
+  })
+);
diff --git a/test/parallel/test-stdin-script-child.js b/test/parallel/test-stdin-script-child.js
index 06adc9e113eda7..ae7c9fbc5805c5 100644
--- a/test/parallel/test-stdin-script-child.js
+++ b/test/parallel/test-stdin-script-child.js
@@ -19,13 +19,21 @@ for (const args of [[], ['-']]) {
 
   child.stderr.setEncoding('utf8');
   child.stderr.on('data', function(c) {
-    console.error(`> ${c.trim().split('\n').join('\n> ')}`);
+    console.error(
+      `> ${c
+        .trim()
+        .split('\n')
+        .join('\n> ')}`
+    );
   });
 
-  child.on('close', common.mustCall(function(c) {
-    assert.strictEqual(c, 0);
-    assert.strictEqual(found, wanted);
-  }));
+  child.on(
+    'close',
+    common.mustCall(function(c) {
+      assert.strictEqual(c, 0);
+      assert.strictEqual(found, wanted);
+    })
+  );
 
   setTimeout(function() {
     child.stdin.end('console.log(process.pid)');
diff --git a/test/parallel/test-stdio-closed.js b/test/parallel/test-stdio-closed.js
index c21bbc2eac12b7..ad009cb43d669a 100644
--- a/test/parallel/test-stdio-closed.js
+++ b/test/parallel/test-stdio-closed.js
@@ -15,9 +15,12 @@ if (common.isWindows) {
   const python = process.env.PYTHON || 'python';
   const script = fixtures.path('spawn_closed_stdio.py');
   const proc = spawn(python, [script, process.execPath, __filename, 'child']);
-  proc.on('exit', common.mustCall(function(exitCode) {
-    assert.strictEqual(exitCode, 0);
-  }));
+  proc.on(
+    'exit',
+    common.mustCall(function(exitCode) {
+      assert.strictEqual(exitCode, 0);
+    })
+  );
   return;
 }
 
@@ -30,6 +33,9 @@ if (process.argv[2] === 'child') {
 const cmd = `"${process.execPath}" "${__filename}" child 1>&- 2>&-`;
 const proc = spawn('/bin/sh', ['-c', cmd], { stdio: 'inherit' });
 
-proc.on('exit', common.mustCall(function(exitCode) {
-  assert.strictEqual(exitCode, 0);
-}));
+proc.on(
+  'exit',
+  common.mustCall(function(exitCode) {
+    assert.strictEqual(exitCode, 0);
+  })
+);
diff --git a/test/parallel/test-stdio-pipe-access.js b/test/parallel/test-stdio-pipe-access.js
index e8f8131d1f19e8..1acaf2ad6e26ed 100644
--- a/test/parallel/test-stdio-pipe-access.js
+++ b/test/parallel/test-stdio-pipe-access.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.isMainThread)
-  common.skip("Workers don't have process-like stdio");
+if (!common.isMainThread) common.skip("Workers don't have process-like stdio");
 
 // Test if Node handles accessing process.stdin if it is a redirected
 // pipe without deadlocking
@@ -13,23 +12,21 @@ const who = process.argv.length <= 2 ? 'runner' : process.argv[2];
 switch (who) {
   case 'runner':
     for (let num = 0; num < numTries; ++num) {
-      spawnSync(process.argv0,
-                [process.argv[1], 'parent'],
-                { 'stdio': 'inherit' });
+      spawnSync(process.argv0, [process.argv[1], 'parent'], {
+        stdio: 'inherit'
+      });
     }
     break;
   case 'parent':
-    const middle = spawn(process.argv0,
-                         [process.argv[1], 'middle'],
-                         { 'stdio': 'pipe' });
+    const middle = spawn(process.argv0, [process.argv[1], 'middle'], {
+      stdio: 'pipe'
+    });
     middle.stdout.on('data', () => {});
     break;
   case 'middle':
-    spawn(process.argv0,
-          [process.argv[1], 'bottom'],
-          { 'stdio': [ process.stdin,
-                       process.stdout,
-                       process.stderr ] });
+    spawn(process.argv0, [process.argv[1], 'bottom'], {
+      stdio: [process.stdin, process.stdout, process.stderr]
+    });
     break;
   case 'bottom':
     process.stdin;
diff --git a/test/parallel/test-stdio-pipe-redirect.js b/test/parallel/test-stdio-pipe-redirect.js
index fbde6ef8085457..e66b859a985503 100644
--- a/test/parallel/test-stdio-pipe-redirect.js
+++ b/test/parallel/test-stdio-pipe-redirect.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.isMainThread)
-  common.skip("Workers don't have process-like stdio");
+if (!common.isMainThread) common.skip("Workers don't have process-like stdio");
 
 // Test if Node handles redirecting one child process stdout to another
 // process stdin without crashing.
@@ -15,10 +14,10 @@ const who = process.argv.length <= 2 ? 'parent' : process.argv[2];
 switch (who) {
   case 'parent':
     const consumer = spawn(process.argv0, [process.argv[1], 'consumer'], {
-      stdio: ['pipe', 'ignore', 'inherit'],
+      stdio: ['pipe', 'ignore', 'inherit']
     });
     const producer = spawn(process.argv0, [process.argv[1], 'producer'], {
-      stdio: ['pipe', consumer.stdin, 'inherit'],
+      stdio: ['pipe', consumer.stdin, 'inherit']
     });
     process.stdin.on('data', () => {});
     producer.on('exit', process.exit);
diff --git a/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js b/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js
index 7cd4b90c008a2f..d212dcfb95480a 100644
--- a/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js
+++ b/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js
@@ -2,10 +2,8 @@
 require('../common');
 const assert = require('assert');
 
-if (process.argv[2] === 'child')
-  process.stdout.end('foo');
-else
-  parent();
+if (process.argv[2] === 'child') process.stdout.end('foo');
+else parent();
 
 function parent() {
   const spawn = require('child_process').spawn;
diff --git a/test/parallel/test-stdout-close-catch.js b/test/parallel/test-stdout-close-catch.js
index 6c0db3ea904a7d..2ead5da1f58316 100644
--- a/test/parallel/test-stdout-close-catch.js
+++ b/test/parallel/test-stdout-close-catch.js
@@ -6,10 +6,11 @@ const fixtures = require('../common/fixtures');
 
 const testScript = fixtures.path('catch-stdout-error.js');
 
-const cmd = `${JSON.stringify(process.execPath)} ` +
-            `${JSON.stringify(testScript)} | ` +
-            `${JSON.stringify(process.execPath)} ` +
-            '-pe "process.stdin.on(\'data\' , () => process.exit(1))"';
+const cmd =
+  `${JSON.stringify(process.execPath)} ` +
+  `${JSON.stringify(testScript)} | ` +
+  `${JSON.stringify(process.execPath)} ` +
+  '-pe "process.stdin.on(\'data\' , () => process.exit(1))"';
 
 const child = child_process.exec(cmd);
 let output = '';
@@ -23,15 +24,17 @@ child.stderr.on('data', function(c) {
   output += c;
 });
 
+child.on(
+  'close',
+  common.mustCall(function(code) {
+    try {
+      output = JSON.parse(output);
+    } catch {
+      console.error(output);
+      process.exit(1);
+    }
 
-child.on('close', common.mustCall(function(code) {
-  try {
-    output = JSON.parse(output);
-  } catch {
-    console.error(output);
-    process.exit(1);
-  }
-
-  assert.deepStrictEqual(output, outputExpect);
-  console.log('ok');
-}));
+    assert.deepStrictEqual(output, outputExpect);
+    console.log('ok');
+  })
+);
diff --git a/test/parallel/test-stdout-close-unref.js b/test/parallel/test-stdout-close-unref.js
index 6caee5093cf8eb..77bf8c9004f9d0 100644
--- a/test/parallel/test-stdout-close-unref.js
+++ b/test/parallel/test-stdout-close-unref.js
@@ -26,7 +26,7 @@ const spawn = require('child_process').spawn;
 if (process.argv[2] === 'child') {
   process.stdin.resume();
   process.stdin._handle.close();
-  process.stdin._handle.unref();  // Should not segfault.
+  process.stdin._handle.unref(); // Should not segfault.
   process.stdin.on('error', common.mustCall());
   return;
 }
@@ -36,7 +36,9 @@ if (process.argv[2] === 'child') {
 const proc = spawn(process.execPath, [__filename, 'child'], { stdio: 'pipe' });
 
 proc.stderr.pipe(process.stderr);
-proc.on('exit', common.mustCall(function(exitCode) {
-  if (exitCode !== 0)
-    process.exitCode = exitCode;
-}));
+proc.on(
+  'exit',
+  common.mustCall(function(exitCode) {
+    if (exitCode !== 0) process.exitCode = exitCode;
+  })
+);
diff --git a/test/parallel/test-stdout-stderr-reading.js b/test/parallel/test-stdout-stderr-reading.js
index 6466366a4f07cb..1f77bf4cb3ef6c 100644
--- a/test/parallel/test-stdout-stderr-reading.js
+++ b/test/parallel/test-stdout-stderr-reading.js
@@ -7,17 +7,13 @@ const net = require('net');
 const read = net.Socket.prototype.read;
 
 net.Socket.prototype.read = function() {
-  if (this.fd === 1)
-    throw new Error('reading from stdout!');
-  if (this.fd === 2)
-    throw new Error('reading from stderr!');
+  if (this.fd === 1) throw new Error('reading from stdout!');
+  if (this.fd === 2) throw new Error('reading from stderr!');
   return read.apply(this, arguments);
 };
 
-if (process.argv[2] === 'child')
-  child();
-else
-  parent();
+if (process.argv[2] === 'child') child();
+else parent();
 
 function parent() {
   const spawn = require('child_process').spawn;
@@ -33,12 +29,15 @@ function parent() {
   c1.stderr.on('data', function(chunk) {
     console.error(`c1err: ${chunk.split('\n').join('\nc1err: ')}`);
   });
-  c1.on('close', common.mustCall(function(code, signal) {
-    assert(!code);
-    assert(!signal);
-    assert.strictEqual(c1out, 'ok\n');
-    console.log('ok');
-  }));
+  c1.on(
+    'close',
+    common.mustCall(function(code, signal) {
+      assert(!code);
+      assert(!signal);
+      assert.strictEqual(c1out, 'ok\n');
+      console.log('ok');
+    })
+  );
 
   const c2 = spawn(node, ['-e', 'console.log("ok")']);
   let c2out = '';
@@ -50,12 +49,15 @@ function parent() {
   c1.stderr.on('data', function(chunk) {
     console.error(`c1err: ${chunk.split('\n').join('\nc1err: ')}`);
   });
-  c2.on('close', common.mustCall(function(code, signal) {
-    assert(!code);
-    assert(!signal);
-    assert.strictEqual(c2out, 'ok\n');
-    console.log('ok');
-  }));
+  c2.on(
+    'close',
+    common.mustCall(function(code, signal) {
+      assert(!code);
+      assert(!signal);
+      assert.strictEqual(c2out, 'ok\n');
+      console.log('ok');
+    })
+  );
 }
 
 function child() {
diff --git a/test/parallel/test-stdout-to-file.js b/test/parallel/test-stdout-to-file.js
index f23bbea279d324..12fabaebeb3f9f 100644
--- a/test/parallel/test-stdout-to-file.js
+++ b/test/parallel/test-stdout-to-file.js
@@ -15,7 +15,8 @@ tmpdir.refresh();
 
 function test(size, useBuffer, cb) {
   const cmd = `"${process.argv[0]}" "${
-    useBuffer ? scriptBuffer : scriptString}" ${size} > "${tmpFile}"`;
+    useBuffer ? scriptBuffer : scriptString
+  }" ${size} > "${tmpFile}"`;
 
   try {
     fs.unlinkSync(tmpFile);
@@ -23,24 +24,35 @@ function test(size, useBuffer, cb) {
 
   console.log(`${size} chars to ${tmpFile}...`);
 
-  childProcess.exec(cmd, common.mustCall(function(err) {
-    assert.ifError(err);
-    console.log('done!');
+  childProcess.exec(
+    cmd,
+    common.mustCall(function(err) {
+      assert.ifError(err);
+      console.log('done!');
 
-    const stat = fs.statSync(tmpFile);
+      const stat = fs.statSync(tmpFile);
 
-    console.log(`${tmpFile} has ${stat.size} bytes`);
+      console.log(`${tmpFile} has ${stat.size} bytes`);
 
-    assert.strictEqual(size, stat.size);
-    fs.unlinkSync(tmpFile);
+      assert.strictEqual(size, stat.size);
+      fs.unlinkSync(tmpFile);
 
-    cb();
-  }));
+      cb();
+    })
+  );
 }
 
-test(1024 * 1024, false, common.mustCall(function() {
-  console.log('Done printing with string');
-  test(1024 * 1024, true, common.mustCall(function() {
-    console.log('Done printing with buffer');
-  }));
-}));
+test(
+  1024 * 1024,
+  false,
+  common.mustCall(function() {
+    console.log('Done printing with string');
+    test(
+      1024 * 1024,
+      true,
+      common.mustCall(function() {
+        console.log('Done printing with buffer');
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-stream-auto-destroy.js b/test/parallel/test-stream-auto-destroy.js
index 2a1a5190debb57..193af8d4b637ed 100644
--- a/test/parallel/test-stream-auto-destroy.js
+++ b/test/parallel/test-stream-auto-destroy.js
@@ -18,13 +18,19 @@ const assert = require('assert');
 
   r.resume();
 
-  r.on('end', common.mustCall(() => {
-    ended = true;
-  }));
-
-  r.on('close', common.mustCall(() => {
-    assert(ended);
-  }));
+  r.on(
+    'end',
+    common.mustCall(() => {
+      ended = true;
+    })
+  );
+
+  r.on(
+    'close',
+    common.mustCall(() => {
+      assert(ended);
+    })
+  );
 }
 
 {
@@ -42,13 +48,19 @@ const assert = require('assert');
   w.write('world');
   w.end();
 
-  w.on('finish', common.mustCall(() => {
-    finished = true;
-  }));
-
-  w.on('close', common.mustCall(() => {
-    assert(finished);
-  }));
+  w.on(
+    'finish',
+    common.mustCall(() => {
+      finished = true;
+    })
+  );
+
+  w.on(
+    'close',
+    common.mustCall(() => {
+      assert(finished);
+    })
+  );
 }
 
 {
@@ -69,18 +81,27 @@ const assert = require('assert');
 
   t.resume();
 
-  t.on('end', common.mustCall(() => {
-    ended = true;
-  }));
-
-  t.on('finish', common.mustCall(() => {
-    finished = true;
-  }));
-
-  t.on('close', common.mustCall(() => {
-    assert(ended);
-    assert(finished);
-  }));
+  t.on(
+    'end',
+    common.mustCall(() => {
+      ended = true;
+    })
+  );
+
+  t.on(
+    'finish',
+    common.mustCall(() => {
+      finished = true;
+    })
+  );
+
+  t.on(
+    'close',
+    common.mustCall(() => {
+      assert(ended);
+      assert(finished);
+    })
+  );
 }
 
 {
diff --git a/test/parallel/test-stream-base-prototype-accessors-enumerability.js b/test/parallel/test-stream-base-prototype-accessors-enumerability.js
index d060a0cb84ce50..126bd381571c80 100644
--- a/test/parallel/test-stream-base-prototype-accessors-enumerability.js
+++ b/test/parallel/test-stream-base-prototype-accessors-enumerability.js
@@ -17,5 +17,7 @@ const TTY = internalBinding('tty_wrap').TTY;
   assert.strictEqual(TTY.prototype.propertyIsEnumerable('bytesRead'), false);
   assert.strictEqual(TTY.prototype.propertyIsEnumerable('fd'), false);
   assert.strictEqual(
-    TTY.prototype.propertyIsEnumerable('_externalStream'), false);
+    TTY.prototype.propertyIsEnumerable('_externalStream'),
+    false
+  );
 }
diff --git a/test/parallel/test-stream-base-typechecking.js b/test/parallel/test-stream-base-typechecking.js
index a8652dc06357cc..a05a995cf723af 100644
--- a/test/parallel/test-stream-base-typechecking.js
+++ b/test/parallel/test-stream-base-typechecking.js
@@ -2,16 +2,25 @@
 const common = require('../common');
 const net = require('net');
 
-const server = net.createServer().listen(0, common.mustCall(() => {
-  const client = net.connect(server.address().port, common.mustCall(() => {
-    common.expectsError(() => {
-      client.write('broken', 'buffer');
-    }, {
-      type: TypeError,
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: 'Second argument must be a buffer'
-    });
-    client.destroy();
-    server.close();
-  }));
-}));
+const server = net.createServer().listen(
+  0,
+  common.mustCall(() => {
+    const client = net.connect(
+      server.address().port,
+      common.mustCall(() => {
+        common.expectsError(
+          () => {
+            client.write('broken', 'buffer');
+          },
+          {
+            type: TypeError,
+            code: 'ERR_INVALID_ARG_TYPE',
+            message: 'Second argument must be a buffer'
+          }
+        );
+        client.destroy();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-stream-big-packet.js b/test/parallel/test-stream-big-packet.js
index 0dca3391961a93..7e5ecdf18ea1cf 100644
--- a/test/parallel/test-stream-big-packet.js
+++ b/test/parallel/test-stream-big-packet.js
@@ -41,7 +41,10 @@ const s2 = new stream.PassThrough();
 const s3 = new TestStream();
 s1.pipe(s3);
 // Don't let s2 auto close which may close s3
-s2.pipe(s3, { end: false });
+s2.pipe(
+  s3,
+  { end: false }
+);
 
 // We must write a buffer larger than highWaterMark
 const big = Buffer.alloc(s1.writableHighWaterMark + 1, 'x');
diff --git a/test/parallel/test-stream-destroy-event-order.js b/test/parallel/test-stream-destroy-event-order.js
index a88fff820dedb9..1ca1ee0d77431a 100644
--- a/test/parallel/test-stream-destroy-event-order.js
+++ b/test/parallel/test-stream-destroy-event-order.js
@@ -11,14 +11,20 @@ const rs = new Readable({
 let closed = false;
 let errored = false;
 
-rs.on('close', common.mustCall(() => {
-  closed = true;
-  assert(errored);
-}));
+rs.on(
+  'close',
+  common.mustCall(() => {
+    closed = true;
+    assert(errored);
+  })
+);
 
-rs.on('error', common.mustCall((err) => {
-  errored = true;
-  assert(!closed);
-}));
+rs.on(
+  'error',
+  common.mustCall((err) => {
+    errored = true;
+    assert(!closed);
+  })
+);
 
 rs.destroy(new Error('kaboom'));
diff --git a/test/parallel/test-stream-duplex-destroy.js b/test/parallel/test-stream-duplex-destroy.js
index 854d29ffc13049..dd43634e4a679a 100644
--- a/test/parallel/test-stream-duplex-destroy.js
+++ b/test/parallel/test-stream-duplex-destroy.js
@@ -7,7 +7,9 @@ const { inherits } = require('util');
 
 {
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     read() {}
   });
 
@@ -23,7 +25,9 @@ const { inherits } = require('util');
 
 {
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     read() {}
   });
   duplex.resume();
@@ -32,9 +36,12 @@ const { inherits } = require('util');
 
   duplex.on('end', common.mustNotCall());
   duplex.on('finish', common.mustNotCall());
-  duplex.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  duplex.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   duplex.destroy(expected);
   assert.strictEqual(duplex.destroyed, true);
@@ -42,7 +49,9 @@ const { inherits } = require('util');
 
 {
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     read() {}
   });
 
@@ -54,9 +63,12 @@ const { inherits } = require('util');
   const expected = new Error('kaboom');
 
   duplex.on('finish', common.mustNotCall('no finish event'));
-  duplex.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  duplex.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   duplex.destroy(expected);
   assert.strictEqual(duplex.destroyed, true);
@@ -65,7 +77,9 @@ const { inherits } = require('util');
 {
   const expected = new Error('kaboom');
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     read() {},
     destroy: common.mustCall(function(err, cb) {
       assert.strictEqual(err, expected);
@@ -87,7 +101,9 @@ const { inherits } = require('util');
 
 {
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     read() {}
   });
 
@@ -102,7 +118,9 @@ const { inherits } = require('util');
 
 {
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     read() {}
   });
   duplex.resume();
@@ -132,7 +150,9 @@ const { inherits } = require('util');
 
 {
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     read() {}
   });
 
@@ -145,9 +165,12 @@ const { inherits } = require('util');
 
   duplex.on('finish', common.mustNotCall('no finish event'));
   duplex.on('end', common.mustNotCall('no end event'));
-  duplex.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  duplex.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   duplex.destroy();
   assert.strictEqual(duplex.destroyed, true);
@@ -155,7 +178,9 @@ const { inherits } = require('util');
 
 {
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     read() {},
     allowHalfOpen: true
   });
@@ -170,8 +195,10 @@ const { inherits } = require('util');
 
 {
   const duplex = new Duplex({
-    write(chunk, enc, cb) { cb(); },
-    read() {},
+    write(chunk, enc, cb) {
+      cb();
+    },
+    read() {}
   });
 
   duplex.destroyed = true;
diff --git a/test/parallel/test-stream-end-paused.js b/test/parallel/test-stream-end-paused.js
index f29c82f532c22b..c1324fbb65da0e 100644
--- a/test/parallel/test-stream-end-paused.js
+++ b/test/parallel/test-stream-end-paused.js
@@ -39,10 +39,13 @@ stream.on('data', function() {
 });
 stream.pause();
 
-setTimeout(common.mustCall(function() {
-  stream.on('end', common.mustCall());
-  stream.resume();
-}), 1);
+setTimeout(
+  common.mustCall(function() {
+    stream.on('end', common.mustCall());
+    stream.resume();
+  }),
+  1
+);
 
 process.on('exit', function() {
   assert(calledRead);
diff --git a/test/parallel/test-stream-finished.js b/test/parallel/test-stream-finished.js
index fe87f246327a3a..2ce47f6de811a9 100644
--- a/test/parallel/test-stream-finished.js
+++ b/test/parallel/test-stream-finished.js
@@ -11,9 +11,12 @@ const { promisify } = require('util');
     read() {}
   });
 
-  finished(rs, common.mustCall((err) => {
-    assert(!err, 'no error');
-  }));
+  finished(
+    rs,
+    common.mustCall((err) => {
+      assert(!err, 'no error');
+    })
+  );
 
   rs.push(null);
   rs.resume();
@@ -26,9 +29,12 @@ const { promisify } = require('util');
     }
   });
 
-  finished(ws, common.mustCall((err) => {
-    assert(!err, 'no error');
-  }));
+  finished(
+    ws,
+    common.mustCall((err) => {
+      assert(!err, 'no error');
+    })
+  );
 
   ws.end();
 }
@@ -51,11 +57,14 @@ const { promisify } = require('util');
     finish = true;
   });
 
-  finished(tr, common.mustCall((err) => {
-    assert(!err, 'no error');
-    assert(finish);
-    assert(ended);
-  }));
+  finished(
+    tr,
+    common.mustCall((err) => {
+      assert(!err, 'no error');
+      assert(finish);
+      assert(ended);
+    })
+  );
 
   tr.end();
   tr.resume();
@@ -91,17 +100,23 @@ const { promisify } = require('util');
 {
   const rs = fs.createReadStream('file-does-not-exist');
 
-  finished(rs, common.expectsError({
-    code: 'ENOENT'
-  }));
+  finished(
+    rs,
+    common.expectsError({
+      code: 'ENOENT'
+    })
+  );
 }
 
 {
   const rs = new Readable();
 
-  finished(rs, common.mustCall((err) => {
-    assert(!err, 'no error');
-  }));
+  finished(
+    rs,
+    common.mustCall((err) => {
+      assert(!err, 'no error');
+    })
+  );
 
   rs.push(null);
   rs.emit('close'); // should not trigger an error
@@ -111,9 +126,12 @@ const { promisify } = require('util');
 {
   const rs = new Readable();
 
-  finished(rs, common.mustCall((err) => {
-    assert(err, 'premature close error');
-  }));
+  finished(
+    rs,
+    common.mustCall((err) => {
+      assert(err, 'premature close error');
+    })
+  );
 
   rs.emit('close'); // should trigger error
   rs.push(null);
@@ -126,27 +144,18 @@ const { promisify } = require('util');
     read() {}
   });
 
-  assert.throws(
-    () => finished(rs, 'foo'),
-    {
-      name: /ERR_INVALID_ARG_TYPE/,
-      message: /callback/
-    }
-  );
-  assert.throws(
-    () => finished(rs, 'foo', () => {}),
-    {
-      name: /ERR_INVALID_ARG_TYPE/,
-      message: /opts/
-    }
-  );
-  assert.throws(
-    () => finished(rs, {}, 'foo'),
-    {
-      name: /ERR_INVALID_ARG_TYPE/,
-      message: /callback/
-    }
-  );
+  assert.throws(() => finished(rs, 'foo'), {
+    name: /ERR_INVALID_ARG_TYPE/,
+    message: /callback/
+  });
+  assert.throws(() => finished(rs, 'foo', () => {}), {
+    name: /ERR_INVALID_ARG_TYPE/,
+    message: /opts/
+  });
+  assert.throws(() => finished(rs, {}, 'foo'), {
+    name: /ERR_INVALID_ARG_TYPE/,
+    message: /callback/
+  });
 
   finished(rs, null, common.mustCall());
 
diff --git a/test/parallel/test-stream-inheritance.js b/test/parallel/test-stream-inheritance.js
index a687ea9da054c9..1f3fdc0e3e5a54 100644
--- a/test/parallel/test-stream-inheritance.js
+++ b/test/parallel/test-stream-inheritance.js
@@ -37,10 +37,7 @@ function CustomWritable() {
     this instanceof CustomWritable,
     `${this} does not inherit from CustomWritable`
   );
-  assert.ok(
-    this instanceof Writable,
-    `${this} does not inherit from Writable`
-  );
+  assert.ok(this instanceof Writable, `${this} does not inherit from Writable`);
 }
 
 Object.setPrototypeOf(CustomWritable, Writable);
@@ -48,14 +45,11 @@ Object.setPrototypeOf(CustomWritable.prototype, Writable.prototype);
 
 new CustomWritable();
 
-common.expectsError(
-  CustomWritable,
-  {
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    message: 'undefined does not inherit from CustomWritable'
-  }
-);
+common.expectsError(CustomWritable, {
+  code: 'ERR_ASSERTION',
+  type: assert.AssertionError,
+  message: 'undefined does not inherit from CustomWritable'
+});
 
 class OtherCustomWritable extends Writable {}
 
diff --git a/test/parallel/test-stream-objectmode-undefined.js b/test/parallel/test-stream-objectmode-undefined.js
index 64b960f92b4995..2845cd5ea90db4 100644
--- a/test/parallel/test-stream-objectmode-undefined.js
+++ b/test/parallel/test-stream-objectmode-undefined.js
@@ -12,9 +12,12 @@ const { Readable, Writable, Transform } = require('stream');
     })
   });
 
-  stream.on('data', common.mustCall((chunk) => {
-    assert.strictEqual(chunk, undefined);
-  }));
+  stream.on(
+    'data',
+    common.mustCall((chunk) => {
+      assert.strictEqual(chunk, undefined);
+    })
+  );
 }
 
 {
@@ -36,9 +39,12 @@ const { Readable, Writable, Transform } = require('stream');
     })
   });
 
-  stream.on('data', common.mustCall((chunk) => {
-    assert.strictEqual(chunk, undefined);
-  }));
+  stream.on(
+    'data',
+    common.mustCall((chunk) => {
+      assert.strictEqual(chunk, undefined);
+    })
+  );
 
   stream.write(undefined);
 }
diff --git a/test/parallel/test-stream-once-readable-pipe.js b/test/parallel/test-stream-once-readable-pipe.js
index e8f4e9422db401..68d95057330198 100644
--- a/test/parallel/test-stream-once-readable-pipe.js
+++ b/test/parallel/test-stream-once-readable-pipe.js
@@ -13,12 +13,12 @@ const { Readable, Writable } = require('stream');
     write: (chunk, env, callback) => {
       receivedData += chunk;
       callback();
-    },
+    }
   });
 
   const data = ['foo', 'bar', 'baz'];
   const r = new Readable({
-    read: () => {},
+    read: () => {}
   });
 
   r.once('readable', common.mustCall());
@@ -29,9 +29,12 @@ const { Readable, Writable } = require('stream');
   r.push(data[2]);
   r.push(null);
 
-  w.on('finish', common.mustCall(() => {
-    assert.strictEqual(receivedData, data.join(''));
-  }));
+  w.on(
+    'finish',
+    common.mustCall(() => {
+      assert.strictEqual(receivedData, data.join(''));
+    })
+  );
 }
 
 {
@@ -40,12 +43,12 @@ const { Readable, Writable } = require('stream');
     write: (chunk, env, callback) => {
       receivedData += chunk;
       callback();
-    },
+    }
   });
 
   const data = ['foo', 'bar', 'baz'];
   const r = new Readable({
-    read: () => {},
+    read: () => {}
   });
 
   r.pipe(w);
@@ -55,7 +58,10 @@ const { Readable, Writable } = require('stream');
   r.push(null);
   r.once('readable', common.mustCall());
 
-  w.on('finish', common.mustCall(() => {
-    assert.strictEqual(receivedData, data.join(''));
-  }));
+  w.on(
+    'finish',
+    common.mustCall(() => {
+      assert.strictEqual(receivedData, data.join(''));
+    })
+  );
 }
diff --git a/test/parallel/test-stream-pipe-after-end.js b/test/parallel/test-stream-pipe-after-end.js
index d0d0a19bd6074a..28a16d0237ccd3 100644
--- a/test/parallel/test-stream-pipe-after-end.js
+++ b/test/parallel/test-stream-pipe-after-end.js
@@ -32,8 +32,7 @@ class TestReadable extends Readable {
   }
 
   _read() {
-    if (this._ended)
-      this.emit('error', new Error('_read called twice'));
+    if (this._ended) this.emit('error', new Error('_read called twice'));
     this._ended = true;
     this.push(null);
   }
@@ -59,12 +58,15 @@ const piper = new TestReadable();
 // pushes EOF null, and length=0, so this will trigger 'end'
 piper.read();
 
-setTimeout(common.mustCall(function() {
-  ender.on('end', common.mustCall());
-  const c = ender.read();
-  assert.strictEqual(c, null);
+setTimeout(
+  common.mustCall(function() {
+    ender.on('end', common.mustCall());
+    const c = ender.read();
+    assert.strictEqual(c, null);
 
-  const w = new TestWritable();
-  w.on('finish', common.mustCall());
-  piper.pipe(w);
-}), 1);
+    const w = new TestWritable();
+    w.on('finish', common.mustCall());
+    piper.pipe(w);
+  }),
+  1
+);
diff --git a/test/parallel/test-stream-pipe-await-drain-manual-resume.js b/test/parallel/test-stream-pipe-await-drain-manual-resume.js
index 37acead9969443..651d7b74b26b9a 100644
--- a/test/parallel/test-stream-pipe-await-drain-manual-resume.js
+++ b/test/parallel/test-stream-pipe-await-drain-manual-resume.js
@@ -14,10 +14,8 @@ let isCurrentlyBufferingWrites = true;
 const queue = [];
 
 writable._write = (chunk, encoding, cb) => {
-  if (isCurrentlyBufferingWrites)
-    queue.push({ chunk, cb });
-  else
-    cb();
+  if (isCurrentlyBufferingWrites) queue.push({ chunk, cb });
+  else cb();
 };
 
 const readable = new stream.Readable({
@@ -26,49 +24,59 @@ const readable = new stream.Readable({
 
 readable.pipe(writable);
 
-readable.once('pause', common.mustCall(() => {
-  assert.strictEqual(
-    readable._readableState.awaitDrain,
-    1,
-    'Expected awaitDrain to equal 1 but instead got ' +
-    `${readable._readableState.awaitDrain}`
-  );
-  // First pause, resume manually. The next write() to writable will still
-  // return false, because chunks are still being buffered, so it will increase
-  // the awaitDrain counter again.
-
-  process.nextTick(common.mustCall(() => {
-    readable.resume();
-  }));
-
-  readable.once('pause', common.mustCall(() => {
+readable.once(
+  'pause',
+  common.mustCall(() => {
     assert.strictEqual(
       readable._readableState.awaitDrain,
       1,
-      '.resume() should not reset the counter but instead got ' +
-      `${readable._readableState.awaitDrain}`
+      'Expected awaitDrain to equal 1 but instead got ' +
+        `${readable._readableState.awaitDrain}`
     );
-    // Second pause, handle all chunks from now on. Once all callbacks that
-    // are currently queued up are handled, the awaitDrain drain counter should
-    // fall back to 0 and all chunks that are pending on the readable side
-    // should be flushed.
-    isCurrentlyBufferingWrites = false;
-    for (const queued of queue)
-      queued.cb();
-  }));
-}));
+    // First pause, resume manually. The next write() to writable will still
+    // return false, because chunks are still being buffered, so it will increase
+    // the awaitDrain counter again.
 
-readable.push(Buffer.alloc(100));  // Fill the writable HWM, first 'pause'.
-readable.push(Buffer.alloc(100));  // Second 'pause'.
-readable.push(Buffer.alloc(100));  // Should get through to the writable.
+    process.nextTick(
+      common.mustCall(() => {
+        readable.resume();
+      })
+    );
+
+    readable.once(
+      'pause',
+      common.mustCall(() => {
+        assert.strictEqual(
+          readable._readableState.awaitDrain,
+          1,
+          '.resume() should not reset the counter but instead got ' +
+            `${readable._readableState.awaitDrain}`
+        );
+        // Second pause, handle all chunks from now on. Once all callbacks that
+        // are currently queued up are handled, the awaitDrain drain counter should
+        // fall back to 0 and all chunks that are pending on the readable side
+        // should be flushed.
+        isCurrentlyBufferingWrites = false;
+        for (const queued of queue) queued.cb();
+      })
+    );
+  })
+);
+
+readable.push(Buffer.alloc(100)); // Fill the writable HWM, first 'pause'.
+readable.push(Buffer.alloc(100)); // Second 'pause'.
+readable.push(Buffer.alloc(100)); // Should get through to the writable.
 readable.push(null);
 
-writable.on('finish', common.mustCall(() => {
-  assert.strictEqual(
-    readable._readableState.awaitDrain,
-    0,
-    'awaitDrain should equal 0 after all chunks are written but instead got' +
-    `${readable._readableState.awaitDrain}`
-  );
-  // Everything okay, all chunks were written.
-}));
+writable.on(
+  'finish',
+  common.mustCall(() => {
+    assert.strictEqual(
+      readable._readableState.awaitDrain,
+      0,
+      'awaitDrain should equal 0 after all chunks are written but instead got' +
+        `${readable._readableState.awaitDrain}`
+    );
+    // Everything okay, all chunks were written.
+  })
+);
diff --git a/test/parallel/test-stream-pipe-await-drain-push-while-write.js b/test/parallel/test-stream-pipe-await-drain-push-while-write.js
index d14ad46cb066ec..37320bb655dacc 100644
--- a/test/parallel/test-stream-pipe-await-drain-push-while-write.js
+++ b/test/parallel/test-stream-pipe-await-drain-push-while-write.js
@@ -5,12 +5,10 @@ const assert = require('assert');
 
 const writable = new stream.Writable({
   write: common.mustCall(function(chunk, encoding, cb) {
-    assert.strictEqual(
-      readable._readableState.awaitDrain,
-      0
-    );
+    assert.strictEqual(readable._readableState.awaitDrain, 0);
 
-    if (chunk.length === 32 * 1024) { // first chunk
+    if (chunk.length === 32 * 1024) {
+      // first chunk
       readable.push(Buffer.alloc(34 * 1024)); // above hwm
       // We should check if awaitDrain counter is increased in the next
       // tick, because awaitDrain is incremented after this method finished
diff --git a/test/parallel/test-stream-pipe-await-drain.js b/test/parallel/test-stream-pipe-await-drain.js
index 53cf54940d34e1..972fbaaeb541c6 100644
--- a/test/parallel/test-stream-pipe-await-drain.js
+++ b/test/parallel/test-stream-pipe-await-drain.js
@@ -27,7 +27,7 @@ writer1.once('chunk-received', function() {
     reader._readableState.awaitDrain,
     0,
     'awaitDrain initial value should be 0, actual is ' +
-    reader._readableState.awaitDrain
+      reader._readableState.awaitDrain
   );
   setImmediate(function() {
     // This one should *not* get through to writer1 because writer2 is not
@@ -42,7 +42,7 @@ writer2._write = common.mustCall(function(chunk, encoding, cb) {
     reader._readableState.awaitDrain,
     1,
     'awaitDrain should be 1 after first push, actual is ' +
-    reader._readableState.awaitDrain
+      reader._readableState.awaitDrain
   );
   // Not calling cb here to "simulate" slow stream.
   // This should be called exactly once, since the first .write() call
@@ -54,7 +54,7 @@ writer3._write = common.mustCall(function(chunk, encoding, cb) {
     reader._readableState.awaitDrain,
     2,
     'awaitDrain should be 2 after second push, actual is ' +
-    reader._readableState.awaitDrain
+      reader._readableState.awaitDrain
   );
   // Not calling cb here to "simulate" slow stream.
   // This should be called exactly once, since the first .write() call
diff --git a/test/parallel/test-stream-pipe-cleanup.js b/test/parallel/test-stream-pipe-cleanup.js
index ac0a72a1da416b..9532c6fd4c0fa0 100644
--- a/test/parallel/test-stream-pipe-cleanup.js
+++ b/test/parallel/test-stream-pipe-cleanup.js
@@ -94,9 +94,9 @@ w = new Writable();
 const d = new Duplex();
 r.pipe(d); // pipeline A
 d.pipe(w); // pipeline B
-assert.strictEqual(r.listeners('end').length, 2);   // A.onend, A.cleanup
+assert.strictEqual(r.listeners('end').length, 2); // A.onend, A.cleanup
 assert.strictEqual(r.listeners('close').length, 2); // A.onclose, A.cleanup
-assert.strictEqual(d.listeners('end').length, 2);   // B.onend, B.cleanup
+assert.strictEqual(d.listeners('end').length, 2); // B.onend, B.cleanup
 // A.cleanup, B.onclose, B.cleanup
 assert.strictEqual(d.listeners('close').length, 3);
 assert.strictEqual(w.listeners('end').length, 0);
@@ -107,7 +107,7 @@ assert.strictEqual(d.endCalls, 1);
 assert.strictEqual(w.endCalls, 0);
 assert.strictEqual(r.listeners('end').length, 0);
 assert.strictEqual(r.listeners('close').length, 0);
-assert.strictEqual(d.listeners('end').length, 2);   // B.onend, B.cleanup
+assert.strictEqual(d.listeners('end').length, 2); // B.onend, B.cleanup
 assert.strictEqual(d.listeners('close').length, 2); // B.onclose, B.cleanup
 assert.strictEqual(w.listeners('end').length, 0);
 assert.strictEqual(w.listeners('close').length, 1); // B.cleanup
diff --git a/test/parallel/test-stream-pipe-error-handling.js b/test/parallel/test-stream-pipe-error-handling.js
index e725465e079682..ab451d0d07e994 100644
--- a/test/parallel/test-stream-pipe-error-handling.js
+++ b/test/parallel/test-stream-pipe-error-handling.js
@@ -67,12 +67,15 @@ const Stream = require('stream').Stream;
   let removed = false;
 
   r._read = common.mustCall(function() {
-    setTimeout(common.mustCall(function() {
-      assert(removed);
-      assert.throws(function() {
-        w.emit('error', new Error('fail'));
-      }, /^Error: fail$/);
-    }), 1);
+    setTimeout(
+      common.mustCall(function() {
+        assert(removed);
+        assert.throws(function() {
+          w.emit('error', new Error('fail'));
+        }, /^Error: fail$/);
+      }),
+      1
+    );
   });
 
   w.on('error', myOnError);
@@ -94,10 +97,13 @@ const Stream = require('stream').Stream;
   let removed = false;
 
   r._read = common.mustCall(function() {
-    setTimeout(common.mustCall(function() {
-      assert(removed);
-      w.emit('error', new Error('fail'));
-    }), 1);
+    setTimeout(
+      common.mustCall(function() {
+        assert(removed);
+        w.emit('error', new Error('fail'));
+      }),
+      1
+    );
   });
 
   w.on('error', common.mustCall());
diff --git a/test/parallel/test-stream-pipe-flow-after-unpipe.js b/test/parallel/test-stream-pipe-flow-after-unpipe.js
index 048b7ea5e53163..3ea51678ad1e86 100644
--- a/test/parallel/test-stream-pipe-flow-after-unpipe.js
+++ b/test/parallel/test-stream-pipe-flow-after-unpipe.js
@@ -20,10 +20,12 @@ const ws = new Writable({
 });
 
 let chunks = 0;
-rs.on('data', common.mustCallAtLeast(() => {
-  chunks++;
-  if (chunks >= 20)
-    rs.pause();  // Finish this test.
-}));
+rs.on(
+  'data',
+  common.mustCallAtLeast(() => {
+    chunks++;
+    if (chunks >= 20) rs.pause(); // Finish this test.
+  })
+);
 
 rs.pipe(ws);
diff --git a/test/parallel/test-stream-pipe-flow.js b/test/parallel/test-stream-pipe-flow.js
index 1f8564182a3107..44909ccb58cfbd 100644
--- a/test/parallel/test-stream-pipe-flow.js
+++ b/test/parallel/test-stream-pipe-flow.js
@@ -8,8 +8,7 @@ const { Readable, Writable, PassThrough } = require('stream');
   const rs = new Readable({
     objectMode: true,
     read: () => {
-      if (ticks-- > 0)
-        return process.nextTick(() => rs.push({}));
+      if (ticks-- > 0) return process.nextTick(() => rs.push({}));
       rs.push({});
       rs.push(null);
     }
diff --git a/test/parallel/test-stream-pipe-manual-resume.js b/test/parallel/test-stream-pipe-manual-resume.js
index 08269acfd3b015..3fd51bb5cfc0f4 100644
--- a/test/parallel/test-stream-pipe-manual-resume.js
+++ b/test/parallel/test-stream-pipe-manual-resume.js
@@ -11,10 +11,8 @@ function test(throwCodeInbetween) {
   const rs = stream.Readable({
     objectMode: true,
     read: common.mustCallAtLeast(() => {
-      if (--counter >= 0)
-        rs.push({ counter });
-      else
-        rs.push(null);
+      if (--counter >= 0) rs.push({ counter });
+      else rs.push(null);
     }, n)
   });
 
diff --git a/test/parallel/test-stream-pipe-multiple-pipes.js b/test/parallel/test-stream-pipe-multiple-pipes.js
index 890c274b9d9f51..50be3d86bfc969 100644
--- a/test/parallel/test-stream-pipe-multiple-pipes.js
+++ b/test/parallel/test-stream-pipe-multiple-pipes.js
@@ -21,7 +21,6 @@ for (let i = 0; i < 5; i++) {
   target.on('pipe', common.mustCall());
   readable.pipe(target);
 
-
   writables.push(target);
 }
 
@@ -31,21 +30,26 @@ readable.push(input);
 
 // The pipe() calls will postpone emission of the 'resume' event using nextTick,
 // so no data will be available to the writable streams until then.
-process.nextTick(common.mustCall(() => {
-  for (const target of writables) {
-    assert.deepStrictEqual(target.output, [input]);
-
-    target.on('unpipe', common.mustCall());
-    readable.unpipe(target);
-  }
-
-  readable.push('something else'); // This does not get through.
-  readable.push(null);
-  readable.resume(); // Make sure the 'end' event gets emitted.
-}));
-
-readable.on('end', common.mustCall(() => {
-  for (const target of writables) {
-    assert.deepStrictEqual(target.output, [input]);
-  }
-}));
+process.nextTick(
+  common.mustCall(() => {
+    for (const target of writables) {
+      assert.deepStrictEqual(target.output, [input]);
+
+      target.on('unpipe', common.mustCall());
+      readable.unpipe(target);
+    }
+
+    readable.push('something else'); // This does not get through.
+    readable.push(null);
+    readable.resume(); // Make sure the 'end' event gets emitted.
+  })
+);
+
+readable.on(
+  'end',
+  common.mustCall(() => {
+    for (const target of writables) {
+      assert.deepStrictEqual(target.output, [input]);
+    }
+  })
+);
diff --git a/test/parallel/test-stream-pipe-unpipe-streams.js b/test/parallel/test-stream-pipe-unpipe-streams.js
index 49e02bea9cb695..58ea144684c022 100644
--- a/test/parallel/test-stream-pipe-unpipe-streams.js
+++ b/test/parallel/test-stream-pipe-unpipe-streams.js
@@ -49,7 +49,8 @@ assert.strictEqual(source._readableState.pipes, null);
 
     srcCheckEventNames.forEach((eventName) => {
       assert.strictEqual(
-        source.listenerCount(eventName), 0,
+        source.listenerCount(eventName),
+        0,
         `source's '${eventName}' event listeners not removed`
       );
     });
@@ -61,21 +62,22 @@ assert.strictEqual(source._readableState.pipes, null);
 
     const unpipeChecker = common.mustCall(() => {
       assert.deepStrictEqual(
-        dest.listeners('unpipe'), [unpipeChecker],
+        dest.listeners('unpipe'),
+        [unpipeChecker],
         `destination{${currentDestId}} should have a 'unpipe' event ` +
-        'listener which is `unpipeChecker`'
+          'listener which is `unpipeChecker`'
       );
       dest.removeListener('unpipe', unpipeChecker);
       destCheckEventNames.forEach((eventName) => {
         assert.strictEqual(
-          dest.listenerCount(eventName), 0,
+          dest.listenerCount(eventName),
+          0,
           `destination{${currentDestId}}'s '${eventName}' event ` +
-          'listeners not removed'
+            'listeners not removed'
         );
       });
 
-      if (--destCount === 0)
-        checkSrcCleanup();
+      if (--destCount === 0) checkSrcCleanup();
     });
 
     dest.on('unpipe', unpipeChecker);
diff --git a/test/parallel/test-stream-pipeline.js b/test/parallel/test-stream-pipeline.js
index 84fb01fe0dd48e..63167a194d5d0f 100644
--- a/test/parallel/test-stream-pipeline.js
+++ b/test/parallel/test-stream-pipeline.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const { Stream, Writable, Readable, Transform, pipeline } = require('stream');
 const assert = require('assert');
 const http = require('http');
@@ -12,11 +11,7 @@ const { promisify } = require('util');
 {
   let finished = false;
   const processed = [];
-  const expected = [
-    Buffer.from('a'),
-    Buffer.from('b'),
-    Buffer.from('c')
-  ];
+  const expected = [Buffer.from('a'), Buffer.from('b'), Buffer.from('c')];
 
   const read = new Readable({
     read() {}
@@ -38,11 +33,15 @@ const { promisify } = require('util');
   }
   read.push(null);
 
-  pipeline(read, write, common.mustCall((err) => {
-    assert.ok(!err, 'no error');
-    assert.ok(finished);
-    assert.deepStrictEqual(processed, expected);
-  }));
+  pipeline(
+    read,
+    write,
+    common.mustCall((err) => {
+      assert.ok(!err, 'no error');
+      assert.ok(finished);
+      assert.deepStrictEqual(processed, expected);
+    })
+  );
 }
 
 {
@@ -75,9 +74,13 @@ const { promisify } = require('util');
   read.push('data');
   setImmediate(() => read.destroy());
 
-  pipeline(read, write, common.mustCall((err) => {
-    assert.ok(err, 'should have an error');
-  }));
+  pipeline(
+    read,
+    write,
+    common.mustCall((err) => {
+      assert.ok(err, 'should have an error');
+    })
+  );
 }
 
 {
@@ -94,9 +97,13 @@ const { promisify } = require('util');
   read.push('data');
   setImmediate(() => read.destroy(new Error('kaboom')));
 
-  const dst = pipeline(read, write, common.mustCall((err) => {
-    assert.deepStrictEqual(err, new Error('kaboom'));
-  }));
+  const dst = pipeline(
+    read,
+    write,
+    common.mustCall((err) => {
+      assert.deepStrictEqual(err, new Error('kaboom'));
+    })
+  );
 
   assert.strictEqual(dst, write);
 }
@@ -122,9 +129,14 @@ const { promisify } = require('util');
   transform.on('close', common.mustCall());
   write.on('close', common.mustCall());
 
-  const dst = pipeline(read, transform, write, common.mustCall((err) => {
-    assert.deepStrictEqual(err, new Error('kaboom'));
-  }));
+  const dst = pipeline(
+    read,
+    transform,
+    write,
+    common.mustCall((err) => {
+      assert.deepStrictEqual(err, new Error('kaboom'));
+    })
+  );
 
   assert.strictEqual(dst, write);
 
@@ -152,13 +164,13 @@ const { promisify } = require('util');
     req.on('response', (res) => {
       const buf = [];
       res.on('data', (data) => buf.push(data));
-      res.on('end', common.mustCall(() => {
-        assert.deepStrictEqual(
-          Buffer.concat(buf),
-          Buffer.from('hello')
-        );
-        server.close();
-      }));
+      res.on(
+        'end',
+        common.mustCall(() => {
+          assert.deepStrictEqual(Buffer.concat(buf), Buffer.from('hello'));
+          server.close();
+        })
+      );
     });
   });
 }
@@ -233,10 +245,14 @@ const { promisify } = require('util');
 
     req.end();
     req.on('response', (res) => {
-      pipeline(res, badSink, common.mustCall((err) => {
-        assert.deepStrictEqual(err, new Error('kaboom'));
-        server.close();
-      }));
+      pipeline(
+        res,
+        badSink,
+        common.mustCall((err) => {
+          assert.deepStrictEqual(err, new Error('kaboom'));
+          server.close();
+        })
+      );
     });
   });
 }
@@ -261,9 +277,13 @@ const { promisify } = require('util');
       }
     });
 
-    pipeline(rs, req, common.mustCall(() => {
-      server.close();
-    }));
+    pipeline(
+      rs,
+      req,
+      common.mustCall(() => {
+        server.close();
+      })
+    );
 
     req.on('response', (res) => {
       let cnt = 10;
@@ -291,10 +311,14 @@ const { promisify } = require('util');
       }
     });
 
-    pipeline(rs, req, common.mustCall((err) => {
-      server.close();
-      client.close();
-    }));
+    pipeline(
+      rs,
+      req,
+      common.mustCall((err) => {
+        server.close();
+        client.close();
+      })
+    );
 
     let cnt = 10;
     req.on('data', (data) => {
@@ -362,10 +386,7 @@ const { promisify } = require('util');
     oldStream.emit('end');
   };
 
-  const expected = [
-    Buffer.from('hello'),
-    Buffer.from('world')
-  ];
+  const expected = [Buffer.from('hello'), Buffer.from('world')];
 
   const rs = new Readable({
     read() {
@@ -504,8 +525,7 @@ const { promisify } = require('util');
     }
   });
 
-  assert.throws(
-    () => pipeline(read, transform, write),
-    { code: 'ERR_INVALID_CALLBACK' }
-  );
+  assert.throws(() => pipeline(read, transform, write), {
+    code: 'ERR_INVALID_CALLBACK'
+  });
 }
diff --git a/test/parallel/test-stream-preprocess.js b/test/parallel/test-stream-preprocess.js
index d42c2fd63ef52f..a9752dc32ca252 100644
--- a/test/parallel/test-stream-preprocess.js
+++ b/test/parallel/test-stream-preprocess.js
@@ -16,45 +16,72 @@ const modelDataFirstCharacter = modelData[0];
 const lineCount = modelData.match(/\n/g).length;
 
 // Ensure both without-bom and with-bom test files are textwise equal.
-assert.strictEqual(fixtures.readSync('file-to-read-with-bom.txt', 'utf8'),
-                   `${BOM}${modelData}`
+assert.strictEqual(
+  fixtures.readSync('file-to-read-with-bom.txt', 'utf8'),
+  `${BOM}${modelData}`
 );
 
 // An unjustified BOM stripping with a non-BOM character unshifted to a stream.
-const inputWithoutBOM =
-  fs.createReadStream(fixtures.path('file-to-read-without-bom.txt'), 'utf8');
-
-inputWithoutBOM.once('readable', common.mustCall(() => {
-  const maybeBOM = inputWithoutBOM.read(1);
-  assert.strictEqual(maybeBOM, modelDataFirstCharacter);
-  assert.notStrictEqual(maybeBOM, BOM);
-
-  inputWithoutBOM.unshift(maybeBOM);
-
-  let streamedData = '';
-  rl.createInterface({
-    input: inputWithoutBOM,
-  }).on('line', common.mustCall((line) => {
-    streamedData += `${line}\n`;
-  }, lineCount)).on('close', common.mustCall(() => {
-    assert.strictEqual(streamedData, modelData);
-  }));
-}));
+const inputWithoutBOM = fs.createReadStream(
+  fixtures.path('file-to-read-without-bom.txt'),
+  'utf8'
+);
+
+inputWithoutBOM.once(
+  'readable',
+  common.mustCall(() => {
+    const maybeBOM = inputWithoutBOM.read(1);
+    assert.strictEqual(maybeBOM, modelDataFirstCharacter);
+    assert.notStrictEqual(maybeBOM, BOM);
+
+    inputWithoutBOM.unshift(maybeBOM);
+
+    let streamedData = '';
+    rl.createInterface({
+      input: inputWithoutBOM
+    })
+      .on(
+        'line',
+        common.mustCall((line) => {
+          streamedData += `${line}\n`;
+        }, lineCount)
+      )
+      .on(
+        'close',
+        common.mustCall(() => {
+          assert.strictEqual(streamedData, modelData);
+        })
+      );
+  })
+);
 
 // A justified BOM stripping.
-const inputWithBOM =
-  fs.createReadStream(fixtures.path('file-to-read-with-bom.txt'), 'utf8');
-
-inputWithBOM.once('readable', common.mustCall(() => {
-  const maybeBOM = inputWithBOM.read(1);
-  assert.strictEqual(maybeBOM, BOM);
-
-  let streamedData = '';
-  rl.createInterface({
-    input: inputWithBOM,
-  }).on('line', common.mustCall((line) => {
-    streamedData += `${line}\n`;
-  }, lineCount)).on('close', common.mustCall(() => {
-    assert.strictEqual(streamedData, modelData);
-  }));
-}));
+const inputWithBOM = fs.createReadStream(
+  fixtures.path('file-to-read-with-bom.txt'),
+  'utf8'
+);
+
+inputWithBOM.once(
+  'readable',
+  common.mustCall(() => {
+    const maybeBOM = inputWithBOM.read(1);
+    assert.strictEqual(maybeBOM, BOM);
+
+    let streamedData = '';
+    rl.createInterface({
+      input: inputWithBOM
+    })
+      .on(
+        'line',
+        common.mustCall((line) => {
+          streamedData += `${line}\n`;
+        }, lineCount)
+      )
+      .on(
+        'close',
+        common.mustCall(() => {
+          assert.strictEqual(streamedData, modelData);
+        })
+      );
+  })
+);
diff --git a/test/parallel/test-stream-push-strings.js b/test/parallel/test-stream-push-strings.js
index d582c8add005a5..0e48736c8ed87e 100644
--- a/test/parallel/test-stream-push-strings.js
+++ b/test/parallel/test-stream-push-strings.js
@@ -55,11 +55,10 @@ const ms = new MyStream();
 const results = [];
 ms.on('readable', function() {
   let chunk;
-  while (null !== (chunk = ms.read()))
-    results.push(String(chunk));
+  while (null !== (chunk = ms.read())) results.push(String(chunk));
 });
 
-const expect = [ 'first chunksecond to last chunk', 'last chunk' ];
+const expect = ['first chunksecond to last chunk', 'last chunk'];
 process.on('exit', function() {
   assert.strictEqual(ms._chunks, -1);
   assert.deepStrictEqual(results, expect);
diff --git a/test/parallel/test-stream-readable-async-iterators.js b/test/parallel/test-stream-readable-async-iterators.js
index 83540de9defea3..35ee49bbd1bf4a 100644
--- a/test/parallel/test-stream-readable-async-iterators.js
+++ b/test/parallel/test-stream-readable-async-iterators.js
@@ -7,11 +7,13 @@ const assert = require('assert');
 async function tests() {
   {
     const AsyncIteratorPrototype = Object.getPrototypeOf(
-      Object.getPrototypeOf(async function* () {}).prototype);
+      Object.getPrototypeOf(async function*() {}).prototype
+    );
     const rs = new Readable({});
     assert.strictEqual(
       Object.getPrototypeOf(Object.getPrototypeOf(rs[Symbol.asyncIterator]())),
-      AsyncIteratorPrototype);
+      AsyncIteratorPrototype
+    );
   }
 
   await (async function() {
@@ -41,10 +43,16 @@ async function tests() {
     for (let i = 0; i < max; i++) {
       values.push(iter.next());
     }
-    Promise.all(values).then(common.mustCall((values) => {
-      values.forEach(common.mustCall(
-        (item, i) => assert.strictEqual(item.value, 'hello-' + i), 5));
-    }));
+    Promise.all(values).then(
+      common.mustCall((values) => {
+        values.forEach(
+          common.mustCall(
+            (item, i) => assert.strictEqual(item.value, 'hello-' + i),
+            5
+          )
+        );
+      })
+    );
 
     readable.push('hello-0');
     readable.push('hello-1');
@@ -77,8 +85,12 @@ async function tests() {
 
     let k = 0;
     const results1 = await Promise.all(values);
-    results1.forEach(common.mustCall(
-      (item) => assert.strictEqual(item.value, 'hello-' + k++), 3));
+    results1.forEach(
+      common.mustCall(
+        (item) => assert.strictEqual(item.value, 'hello-' + k++),
+        3
+      )
+    );
 
     values = [];
     for (let i = 0; i < 2; i++) {
@@ -90,8 +102,12 @@ async function tests() {
     readable.push(null);
 
     const results2 = await Promise.all(values);
-    results2.forEach(common.mustCall(
-      (item) => assert.strictEqual(item.value, 'hello-' + k++), 2));
+    results2.forEach(
+      common.mustCall(
+        (item) => assert.strictEqual(item.value, 'hello-' + k++),
+        2
+      )
+    );
 
     const last = await iter.next();
     assert.strictEqual(last.done, true);
@@ -123,13 +139,19 @@ async function tests() {
 
     const resolved = await Promise.all(values);
 
-    resolved.forEach(common.mustCall(
-      (item, i) => assert.strictEqual(item.value, 'hello-' + i), max));
+    resolved.forEach(
+      common.mustCall(
+        (item, i) => assert.strictEqual(item.value, 'hello-' + i),
+        max
+      )
+    );
 
     errors.forEach((promise) => {
-      promise.catch(common.mustCall((err) => {
-        assert.strictEqual(err.message, 'kaboom');
-      }));
+      promise.catch(
+        common.mustCall((err) => {
+          assert.strictEqual(err.message, 'kaboom');
+        })
+      );
     });
 
     readable.destroy(new Error('kaboom'));
@@ -182,7 +204,8 @@ async function tests() {
     let err;
     try {
       // eslint-disable-next-line no-unused-vars
-      for await (const k of readable) {}
+      for await (const k of readable) {
+      }
     } catch (e) {
       err = e;
     }
@@ -349,9 +372,13 @@ async function tests() {
 
     const passthrough = new PassThrough();
     const err = new Error('kaboom');
-    pipeline(readable, passthrough, common.mustCall((e) => {
-      assert.strictEqual(e, err);
-    }));
+    pipeline(
+      readable,
+      passthrough,
+      common.mustCall((e) => {
+        assert.strictEqual(e, err);
+      })
+    );
     readable.destroy(err);
     try {
       await readable[Symbol.asyncIterator]().next();
diff --git a/test/parallel/test-stream-readable-destroy.js b/test/parallel/test-stream-readable-destroy.js
index 026aa8ca1603b8..c2dcec8d153d99 100644
--- a/test/parallel/test-stream-readable-destroy.js
+++ b/test/parallel/test-stream-readable-destroy.js
@@ -27,9 +27,12 @@ const { inherits } = require('util');
 
   read.on('end', common.mustNotCall('no end event'));
   read.on('close', common.mustCall());
-  read.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  read.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   read.destroy(expected);
   assert.strictEqual(read.destroyed, true);
@@ -49,9 +52,12 @@ const { inherits } = require('util');
 
   read.on('end', common.mustNotCall('no end event'));
   read.on('close', common.mustCall());
-  read.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  read.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   read.destroy(expected);
   assert.strictEqual(read.destroyed, true);
@@ -131,9 +137,12 @@ const { inherits } = require('util');
   });
 
   read.on('end', common.mustNotCall('no end event'));
-  read.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  read.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   read.destroy();
   assert.strictEqual(read.destroyed, true);
@@ -175,9 +184,12 @@ const { inherits } = require('util');
   const expected = new Error('kaboom');
 
   read.on('close', common.mustCall());
-  read.destroy(expected, common.mustCall(function(err) {
-    assert.strictEqual(expected, err);
-  }));
+  read.destroy(
+    expected,
+    common.mustCall(function(err) {
+      assert.strictEqual(expected, err);
+    })
+  );
 }
 
 {
diff --git a/test/parallel/test-stream-readable-emittedReadable.js b/test/parallel/test-stream-readable-emittedReadable.js
index 5b9affc59fbbf2..44201d7413a1b6 100644
--- a/test/parallel/test-stream-readable-emittedReadable.js
+++ b/test/parallel/test-stream-readable-emittedReadable.js
@@ -11,45 +11,59 @@ const readable = new Readable({
 assert.strictEqual(readable._readableState.emittedReadable, false);
 
 const expected = [Buffer.from('foobar'), Buffer.from('quo'), null];
-readable.on('readable', common.mustCall(() => {
-  // emittedReadable should be true when the readable event is emitted
-  assert.strictEqual(readable._readableState.emittedReadable, true);
-  assert.deepStrictEqual(readable.read(), expected.shift());
-  // emittedReadable is reset to false during read()
-  assert.strictEqual(readable._readableState.emittedReadable, false);
-}, 3));
+readable.on(
+  'readable',
+  common.mustCall(() => {
+    // emittedReadable should be true when the readable event is emitted
+    assert.strictEqual(readable._readableState.emittedReadable, true);
+    assert.deepStrictEqual(readable.read(), expected.shift());
+    // emittedReadable is reset to false during read()
+    assert.strictEqual(readable._readableState.emittedReadable, false);
+  }, 3)
+);
 
 // When the first readable listener is just attached,
 // emittedReadable should be false
 assert.strictEqual(readable._readableState.emittedReadable, false);
 
 // These trigger a single 'readable', as things are batched up
-process.nextTick(common.mustCall(() => {
-  readable.push('foo');
-}));
-process.nextTick(common.mustCall(() => {
-  readable.push('bar');
-}));
+process.nextTick(
+  common.mustCall(() => {
+    readable.push('foo');
+  })
+);
+process.nextTick(
+  common.mustCall(() => {
+    readable.push('bar');
+  })
+);
 
 // these triggers two readable events
-setImmediate(common.mustCall(() => {
-  readable.push('quo');
-  process.nextTick(common.mustCall(() => {
-    readable.push(null);
-  }));
-}));
+setImmediate(
+  common.mustCall(() => {
+    readable.push('quo');
+    process.nextTick(
+      common.mustCall(() => {
+        readable.push(null);
+      })
+    );
+  })
+);
 
 const noRead = new Readable({
   read: () => {}
 });
 
-noRead.on('readable', common.mustCall(() => {
-  // emittedReadable should be true when the readable event is emitted
-  assert.strictEqual(noRead._readableState.emittedReadable, true);
-  noRead.read(0);
-  // emittedReadable is not reset during read(0)
-  assert.strictEqual(noRead._readableState.emittedReadable, true);
-}));
+noRead.on(
+  'readable',
+  common.mustCall(() => {
+    // emittedReadable should be true when the readable event is emitted
+    assert.strictEqual(noRead._readableState.emittedReadable, true);
+    noRead.read(0);
+    // emittedReadable is not reset during read(0)
+    assert.strictEqual(noRead._readableState.emittedReadable, true);
+  })
+);
 
 noRead.push('foo');
 noRead.push(null);
@@ -58,16 +72,21 @@ const flowing = new Readable({
   read: () => {}
 });
 
-flowing.on('data', common.mustCall(() => {
-  // When in flowing mode, emittedReadable is always false.
-  assert.strictEqual(flowing._readableState.emittedReadable, false);
-  flowing.read();
-  assert.strictEqual(flowing._readableState.emittedReadable, false);
-}, 3));
+flowing.on(
+  'data',
+  common.mustCall(() => {
+    // When in flowing mode, emittedReadable is always false.
+    assert.strictEqual(flowing._readableState.emittedReadable, false);
+    flowing.read();
+    assert.strictEqual(flowing._readableState.emittedReadable, false);
+  }, 3)
+);
 
 flowing.push('foooo');
 flowing.push('bar');
 flowing.push('quo');
-process.nextTick(common.mustCall(() => {
-  flowing.push(null);
-}));
+process.nextTick(
+  common.mustCall(() => {
+    flowing.push(null);
+  })
+);
diff --git a/test/parallel/test-stream-readable-event.js b/test/parallel/test-stream-readable-event.js
index 06fac7dc8bd125..8d9625bcc5f70a 100644
--- a/test/parallel/test-stream-readable-event.js
+++ b/test/parallel/test-stream-readable-event.js
@@ -92,7 +92,7 @@ const Readable = require('stream').Readable;
   const result = [];
 
   const r = new Readable({
-    encoding: 'utf8',
+    encoding: 'utf8'
   });
   r._read = function() {
     process.nextTick(() => {
@@ -109,9 +109,12 @@ const Readable = require('stream').Readable;
     if (data !== null) result.push(data);
   });
 
-  r.on('end', common.mustCall(() => {
-    assert.deepStrictEqual(result, expected);
-  }));
+  r.on(
+    'end',
+    common.mustCall(() => {
+      assert.deepStrictEqual(result, expected);
+    })
+  );
 }
 
 {
diff --git a/test/parallel/test-stream-readable-flow-recursion.js b/test/parallel/test-stream-readable-flow-recursion.js
index 43b8103eb6b61e..d3664b06d7aea7 100644
--- a/test/parallel/test-stream-readable-flow-recursion.js
+++ b/test/parallel/test-stream-readable-flow-recursion.js
@@ -40,10 +40,8 @@ stream._read = function(size) {
   reads++;
   size = Math.min(size, total);
   total -= size;
-  if (size === 0)
-    stream.push(null);
-  else
-    stream.push(Buffer.allocUnsafe(size));
+  if (size === 0) stream.push(null);
+  else stream.push(Buffer.allocUnsafe(size));
 };
 
 let depth = 0;
@@ -52,18 +50,20 @@ function flow(stream, size, callback) {
   depth += 1;
   const chunk = stream.read(size);
 
-  if (!chunk)
-    stream.once('readable', flow.bind(null, stream, size, callback));
-  else
-    callback(chunk);
+  if (!chunk) stream.once('readable', flow.bind(null, stream, size, callback));
+  else callback(chunk);
 
   depth -= 1;
   console.log(`flow(${depth}): exit`);
 }
 
-flow(stream, 5000, function() {
-  console.log(`complete (${depth})`);
-});
+flow(
+  stream,
+  5000,
+  function() {
+    console.log(`complete (${depth})`);
+  }
+);
 
 process.on('exit', function(code) {
   assert.strictEqual(reads, 2);
diff --git a/test/parallel/test-stream-readable-hwm-0.js b/test/parallel/test-stream-readable-hwm-0.js
index ecbc197d48208f..548c493c400592 100644
--- a/test/parallel/test-stream-readable-hwm-0.js
+++ b/test/parallel/test-stream-readable-hwm-0.js
@@ -12,16 +12,19 @@ const { Readable } = require('stream');
 const r = new Readable({
   // must be called only once upon setting 'readable' listener
   read: common.mustCall(),
-  highWaterMark: 0,
+  highWaterMark: 0
 });
 
 let pushedNull = false;
 // this will trigger read(0) but must only be called after push(null)
 // because the we haven't pushed any data
-r.on('readable', common.mustCall(() => {
-  assert.strictEqual(r.read(), null);
-  assert.strictEqual(pushedNull, true);
-}));
+r.on(
+  'readable',
+  common.mustCall(() => {
+    assert.strictEqual(r.read(), null);
+    assert.strictEqual(pushedNull, true);
+  })
+);
 r.on('end', common.mustCall());
 process.nextTick(() => {
   assert.strictEqual(r.read(), null);
diff --git a/test/parallel/test-stream-readable-needReadable.js b/test/parallel/test-stream-readable-needReadable.js
index 7058e123f07823..2715a1dc7ef02b 100644
--- a/test/parallel/test-stream-readable-needReadable.js
+++ b/test/parallel/test-stream-readable-needReadable.js
@@ -10,11 +10,14 @@ const readable = new Readable({
 // Initialized to false.
 assert.strictEqual(readable._readableState.needReadable, false);
 
-readable.on('readable', common.mustCall(() => {
-  // When the readable event fires, needReadable is reset.
-  assert.strictEqual(readable._readableState.needReadable, false);
-  readable.read();
-}));
+readable.on(
+  'readable',
+  common.mustCall(() => {
+    // When the readable event fires, needReadable is reset.
+    assert.strictEqual(readable._readableState.needReadable, false);
+    readable.read();
+  })
+);
 
 // If a readable listener is attached, then a readable event is needed.
 assert.strictEqual(readable._readableState.needReadable, true);
@@ -22,34 +25,46 @@ assert.strictEqual(readable._readableState.needReadable, true);
 readable.push('foo');
 readable.push(null);
 
-readable.on('end', common.mustCall(() => {
-  // No need to emit readable anymore when the stream ends.
-  assert.strictEqual(readable._readableState.needReadable, false);
-}));
+readable.on(
+  'end',
+  common.mustCall(() => {
+    // No need to emit readable anymore when the stream ends.
+    assert.strictEqual(readable._readableState.needReadable, false);
+  })
+);
 
 const asyncReadable = new Readable({
   read: () => {}
 });
 
-asyncReadable.on('readable', common.mustCall(() => {
-  if (asyncReadable.read() !== null) {
-    // After each read(), the buffer is empty.
-    // If the stream doesn't end now,
-    // then we need to notify the reader on future changes.
-    assert.strictEqual(asyncReadable._readableState.needReadable, true);
-  }
-}, 2));
+asyncReadable.on(
+  'readable',
+  common.mustCall(() => {
+    if (asyncReadable.read() !== null) {
+      // After each read(), the buffer is empty.
+      // If the stream doesn't end now,
+      // then we need to notify the reader on future changes.
+      assert.strictEqual(asyncReadable._readableState.needReadable, true);
+    }
+  }, 2)
+);
 
-process.nextTick(common.mustCall(() => {
-  asyncReadable.push('foooo');
-}));
-process.nextTick(common.mustCall(() => {
-  asyncReadable.push('bar');
-}));
-setImmediate(common.mustCall(() => {
-  asyncReadable.push(null);
-  assert.strictEqual(asyncReadable._readableState.needReadable, false);
-}));
+process.nextTick(
+  common.mustCall(() => {
+    asyncReadable.push('foooo');
+  })
+);
+process.nextTick(
+  common.mustCall(() => {
+    asyncReadable.push('bar');
+  })
+);
+setImmediate(
+  common.mustCall(() => {
+    asyncReadable.push(null);
+    assert.strictEqual(asyncReadable._readableState.needReadable, false);
+  })
+);
 
 const flowing = new Readable({
   read: () => {}
@@ -59,39 +74,55 @@ const flowing = new Readable({
 flowing.push('foooo');
 flowing.push('bar');
 flowing.push('quo');
-process.nextTick(common.mustCall(() => {
-  flowing.push(null);
-}));
+process.nextTick(
+  common.mustCall(() => {
+    flowing.push(null);
+  })
+);
 
 // When the buffer already has enough data, and the stream is
 // in flowing mode, there is no need for the readable event.
-flowing.on('data', common.mustCall(function(data) {
-  assert.strictEqual(flowing._readableState.needReadable, false);
-}, 3));
+flowing.on(
+  'data',
+  common.mustCall(function(data) {
+    assert.strictEqual(flowing._readableState.needReadable, false);
+  }, 3)
+);
 
 const slowProducer = new Readable({
   read: () => {}
 });
 
-slowProducer.on('readable', common.mustCall(() => {
-  if (slowProducer.read(8) === null) {
-    // The buffer doesn't have enough data, and the stream is not need,
-    // we need to notify the reader when data arrives.
-    assert.strictEqual(slowProducer._readableState.needReadable, true);
-  } else {
-    assert.strictEqual(slowProducer._readableState.needReadable, false);
-  }
-}, 4));
+slowProducer.on(
+  'readable',
+  common.mustCall(() => {
+    if (slowProducer.read(8) === null) {
+      // The buffer doesn't have enough data, and the stream is not need,
+      // we need to notify the reader when data arrives.
+      assert.strictEqual(slowProducer._readableState.needReadable, true);
+    } else {
+      assert.strictEqual(slowProducer._readableState.needReadable, false);
+    }
+  }, 4)
+);
 
-process.nextTick(common.mustCall(() => {
-  slowProducer.push('foo');
-  process.nextTick(common.mustCall(() => {
+process.nextTick(
+  common.mustCall(() => {
     slowProducer.push('foo');
-    process.nextTick(common.mustCall(() => {
-      slowProducer.push('foo');
-      process.nextTick(common.mustCall(() => {
-        slowProducer.push(null);
-      }));
-    }));
-  }));
-}));
+    process.nextTick(
+      common.mustCall(() => {
+        slowProducer.push('foo');
+        process.nextTick(
+          common.mustCall(() => {
+            slowProducer.push('foo');
+            process.nextTick(
+              common.mustCall(() => {
+                slowProducer.push(null);
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-stream-readable-no-unneeded-readable.js b/test/parallel/test-stream-readable-no-unneeded-readable.js
index 13ee2b498c4b96..c10290771234a9 100644
--- a/test/parallel/test-stream-readable-no-unneeded-readable.js
+++ b/test/parallel/test-stream-readable-no-unneeded-readable.js
@@ -19,7 +19,7 @@ function test(r) {
         }
         // else the end event should fire
       });
-    },
+    }
   });
 
   r.once('end', function() {
@@ -55,7 +55,7 @@ function test(r) {
         // asynchronous call
         process.nextTick(() => r.push(null));
       }
-    },
+    }
   });
 
   test(r);
diff --git a/test/parallel/test-stream-readable-object-multi-push-async.js b/test/parallel/test-stream-readable-object-multi-push-async.js
index 17c84c7310e053..636693f2c8166b 100644
--- a/test/parallel/test-stream-readable-object-multi-push-async.js
+++ b/test/parallel/test-stream-readable-object-multi-push-async.js
@@ -47,14 +47,17 @@ const BATCH = 10;
   readable.on('readable', () => {
     let data;
     console.log('readable emitted');
-    while (data = readable.read()) {
+    while ((data = readable.read())) {
       console.log(data);
     }
   });
 
-  readable.on('end', common.mustCall(() => {
-    assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
-  }));
+  readable.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
+    })
+  );
 }
 
 {
@@ -98,9 +101,12 @@ const BATCH = 10;
     console.log('data emitted', data);
   });
 
-  readable.on('end', common.mustCall(() => {
-    assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
-  }));
+  readable.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
+    })
+  );
 }
 
 {
@@ -139,9 +145,12 @@ const BATCH = 10;
     console.log('data emitted', data);
   });
 
-  readable.on('end', common.mustCall(() => {
-    assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
-  }));
+  readable.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(i, (Math.floor(MAX / BATCH) + 1) * BATCH);
+    })
+  );
 }
 
 {
@@ -159,9 +168,12 @@ const BATCH = 10;
     nextTickPassed = true;
   });
 
-  readable.on('end', common.mustCall(() => {
-    assert.strictEqual(nextTickPassed, true);
-  }));
+  readable.on(
+    'end',
+    common.mustCall(() => {
+      assert.strictEqual(nextTickPassed, true);
+    })
+  );
 }
 
 {
diff --git a/test/parallel/test-stream-readable-pause-and-resume.js b/test/parallel/test-stream-readable-pause-and-resume.js
index 505327e247da38..8bc2ab5f6ffacc 100644
--- a/test/parallel/test-stream-readable-pause-and-resume.js
+++ b/test/parallel/test-stream-readable-pause-and-resume.js
@@ -9,8 +9,7 @@ let expectedData = 19;
 const rs = new Readable({
   objectMode: true,
   read: () => {
-    if (ticks-- > 0)
-      return process.nextTick(() => rs.push({}));
+    if (ticks-- > 0) return process.nextTick(() => rs.push({}));
     rs.push({});
     rs.push(null);
   }
@@ -26,8 +25,7 @@ function readAndPause() {
     rs.pause();
 
     expectedData--;
-    if (expectedData <= 0)
-      return;
+    if (expectedData <= 0) return;
 
     setImmediate(function() {
       rs.removeListener('data', ondata);
diff --git a/test/parallel/test-stream-readable-reading-readingMore.js b/test/parallel/test-stream-readable-reading-readingMore.js
index 71c07d7b062c18..dc28988ad5c120 100644
--- a/test/parallel/test-stream-readable-reading-readingMore.js
+++ b/test/parallel/test-stream-readable-reading-readingMore.js
@@ -14,15 +14,17 @@ const Readable = require('stream').Readable;
   assert.strictEqual(state.reading, false);
   assert.strictEqual(state.readingMore, false);
 
-  readable.on('data', common.mustCall((data) => {
-    // while in a flowing state with a 'readable' listener
-    // we should not be reading more
-    if (readable.readableFlowing)
-      assert.strictEqual(state.readingMore, true);
-
-    // reading as long as we've not ended
-    assert.strictEqual(state.reading, !state.ended);
-  }, 2));
+  readable.on(
+    'data',
+    common.mustCall((data) => {
+      // while in a flowing state with a 'readable' listener
+      // we should not be reading more
+      if (readable.readableFlowing) assert.strictEqual(state.readingMore, true);
+
+      // reading as long as we've not ended
+      assert.strictEqual(state.reading, !state.ended);
+    }, 2)
+  );
 
   function onStreamEnd() {
     // End of stream; state.reading is false
@@ -32,18 +34,22 @@ const Readable = require('stream').Readable;
   }
 
   const expectedReadingMore = [true, false];
-  readable.on('readable', common.mustCall(() => {
-    // there is only one readingMore scheduled from on('data'),
-    // after which everything is governed by the .read() call
-    assert.strictEqual(state.readingMore, expectedReadingMore.shift());
-
-    // if the stream has ended, we shouldn't be reading
-    assert.strictEqual(state.ended, !state.reading);
-
-    const data = readable.read();
-    if (data === null) // reached end of stream
-      process.nextTick(common.mustCall(onStreamEnd, 1));
-  }, 2));
+  readable.on(
+    'readable',
+    common.mustCall(() => {
+      // there is only one readingMore scheduled from on('data'),
+      // after which everything is governed by the .read() call
+      assert.strictEqual(state.readingMore, expectedReadingMore.shift());
+
+      // if the stream has ended, we shouldn't be reading
+      assert.strictEqual(state.ended, !state.reading);
+
+      const data = readable.read();
+      if (data === null)
+        // reached end of stream
+        process.nextTick(common.mustCall(onStreamEnd, 1));
+    }, 2)
+  );
 
   readable.on('end', common.mustCall(onStreamEnd));
   readable.push('pushed');
@@ -72,15 +78,17 @@ const Readable = require('stream').Readable;
   assert.strictEqual(state.reading, false);
   assert.strictEqual(state.readingMore, false);
 
-  readable.on('data', common.mustCall((data) => {
-    // while in a flowing state without a 'readable' listener
-    // we should be reading more
-    if (readable.readableFlowing)
-      assert.strictEqual(state.readingMore, true);
+  readable.on(
+    'data',
+    common.mustCall((data) => {
+      // while in a flowing state without a 'readable' listener
+      // we should be reading more
+      if (readable.readableFlowing) assert.strictEqual(state.readingMore, true);
 
-    // reading as long as we've not ended
-    assert.strictEqual(state.reading, !state.ended);
-  }, 2));
+      // reading as long as we've not ended
+      assert.strictEqual(state.reading, !state.ended);
+    }, 2)
+  );
 
   function onStreamEnd() {
     // End of stream; state.reading is false
@@ -126,10 +134,13 @@ const Readable = require('stream').Readable;
 
   readable.on('readable', onReadable);
 
-  readable.on('data', common.mustCall((data) => {
-    // reading as long as we've not ended
-    assert.strictEqual(state.reading, !state.ended);
-  }, 2));
+  readable.on(
+    'data',
+    common.mustCall((data) => {
+      // reading as long as we've not ended
+      assert.strictEqual(state.reading, !state.ended);
+    }, 2)
+  );
 
   readable.removeListener('readable', onReadable);
 
diff --git a/test/parallel/test-stream-readable-resumeScheduled.js b/test/parallel/test-stream-readable-resumeScheduled.js
index 6d1bc913388f46..fe9cdee95a716f 100644
--- a/test/parallel/test-stream-readable-resumeScheduled.js
+++ b/test/parallel/test-stream-readable-resumeScheduled.js
@@ -18,9 +18,11 @@ const { Readable, Writable } = require('stream');
   r.pipe(w);
   assert.strictEqual(r._readableState.resumeScheduled, true);
 
-  process.nextTick(common.mustCall(() => {
-    assert.strictEqual(r._readableState.resumeScheduled, false);
-  }));
+  process.nextTick(
+    common.mustCall(() => {
+      assert.strictEqual(r._readableState.resumeScheduled, false);
+    })
+  );
 }
 
 {
@@ -33,14 +35,19 @@ const { Readable, Writable } = require('stream');
   r.push(Buffer.from([1, 2, 3]));
 
   // adding 'data' listener should change the state value
-  r.on('data', common.mustCall(() => {
-    assert.strictEqual(r._readableState.resumeScheduled, false);
-  }));
+  r.on(
+    'data',
+    common.mustCall(() => {
+      assert.strictEqual(r._readableState.resumeScheduled, false);
+    })
+  );
   assert.strictEqual(r._readableState.resumeScheduled, true);
 
-  process.nextTick(common.mustCall(() => {
-    assert.strictEqual(r._readableState.resumeScheduled, false);
-  }));
+  process.nextTick(
+    common.mustCall(() => {
+      assert.strictEqual(r._readableState.resumeScheduled, false);
+    })
+  );
 }
 
 {
@@ -54,12 +61,17 @@ const { Readable, Writable } = require('stream');
   r.resume();
   assert.strictEqual(r._readableState.resumeScheduled, true);
 
-  r.on('resume', common.mustCall(() => {
-    // The state value should be `false` again
-    assert.strictEqual(r._readableState.resumeScheduled, false);
-  }));
-
-  process.nextTick(common.mustCall(() => {
-    assert.strictEqual(r._readableState.resumeScheduled, false);
-  }));
+  r.on(
+    'resume',
+    common.mustCall(() => {
+      // The state value should be `false` again
+      assert.strictEqual(r._readableState.resumeScheduled, false);
+    })
+  );
+
+  process.nextTick(
+    common.mustCall(() => {
+      assert.strictEqual(r._readableState.resumeScheduled, false);
+    })
+  );
 }
diff --git a/test/parallel/test-stream-readable-setEncoding-null.js b/test/parallel/test-stream-readable-setEncoding-null.js
index b95b26bb795728..25885f4ecc1dc4 100644
--- a/test/parallel/test-stream-readable-setEncoding-null.js
+++ b/test/parallel/test-stream-readable-setEncoding-null.js
@@ -4,7 +4,6 @@ require('../common');
 const assert = require('assert');
 const { Readable } = require('stream');
 
-
 {
   const readable = new Readable({ encoding: 'hex' });
   assert.strictEqual(readable._readableState.encoding, 'hex');
diff --git a/test/parallel/test-stream-readable-with-unimplemented-_read.js b/test/parallel/test-stream-readable-with-unimplemented-_read.js
index 973899b7a7844e..4d9fc2a19182a8 100644
--- a/test/parallel/test-stream-readable-with-unimplemented-_read.js
+++ b/test/parallel/test-stream-readable-with-unimplemented-_read.js
@@ -5,10 +5,13 @@ const { Readable } = require('stream');
 
 const readable = new Readable();
 
-readable.on('error', common.expectsError({
-  code: 'ERR_METHOD_NOT_IMPLEMENTED',
-  type: Error,
-  message: 'The _read() method is not implemented'
-}));
+readable.on(
+  'error',
+  common.expectsError({
+    code: 'ERR_METHOD_NOT_IMPLEMENTED',
+    type: Error,
+    message: 'The _read() method is not implemented'
+  })
+);
 
 readable.read();
diff --git a/test/parallel/test-stream-readableListening-state.js b/test/parallel/test-stream-readableListening-state.js
index 5e3071faf370e5..beb0b8f0f61413 100644
--- a/test/parallel/test-stream-readableListening-state.js
+++ b/test/parallel/test-stream-readableListening-state.js
@@ -11,10 +11,13 @@ const r = new stream.Readable({
 // readableListening state should start in `false`.
 assert.strictEqual(r._readableState.readableListening, false);
 
-r.on('readable', common.mustCall(() => {
-  // Inside the readable event this state should be true.
-  assert.strictEqual(r._readableState.readableListening, true);
-}));
+r.on(
+  'readable',
+  common.mustCall(() => {
+    // Inside the readable event this state should be true.
+    assert.strictEqual(r._readableState.readableListening, true);
+  })
+);
 
 r.push(Buffer.from('Testing readableListening state'));
 
@@ -25,10 +28,13 @@ const r2 = new stream.Readable({
 // readableListening state should start in `false`.
 assert.strictEqual(r2._readableState.readableListening, false);
 
-r2.on('data', common.mustCall((chunk) => {
-  // readableListening should be false because we don't have
-  // a `readable` listener
-  assert.strictEqual(r2._readableState.readableListening, false);
-}));
+r2.on(
+  'data',
+  common.mustCall((chunk) => {
+    // readableListening should be false because we don't have
+    // a `readable` listener
+    assert.strictEqual(r2._readableState.readableListening, false);
+  })
+);
 
 r2.push(Buffer.from('Testing readableListening state'));
diff --git a/test/parallel/test-stream-transform-callback-twice.js b/test/parallel/test-stream-transform-callback-twice.js
index 83c799b92fba25..1c1c26921b9834 100644
--- a/test/parallel/test-stream-transform-callback-twice.js
+++ b/test/parallel/test-stream-transform-callback-twice.js
@@ -2,13 +2,19 @@
 const common = require('../common');
 const { Transform } = require('stream');
 const stream = new Transform({
-  transform(chunk, enc, cb) { cb(); cb(); }
+  transform(chunk, enc, cb) {
+    cb();
+    cb();
+  }
 });
 
-stream.on('error', common.expectsError({
-  type: Error,
-  message: 'Callback called multiple times',
-  code: 'ERR_MULTIPLE_CALLBACK'
-}));
+stream.on(
+  'error',
+  common.expectsError({
+    type: Error,
+    message: 'Callback called multiple times',
+    code: 'ERR_MULTIPLE_CALLBACK'
+  })
+);
 
 stream.write('foo');
diff --git a/test/parallel/test-stream-transform-constructor-set-methods.js b/test/parallel/test-stream-transform-constructor-set-methods.js
index d599e768386515..731e2761255cfc 100644
--- a/test/parallel/test-stream-transform-constructor-set-methods.js
+++ b/test/parallel/test-stream-transform-constructor-set-methods.js
@@ -6,11 +6,14 @@ const { Transform } = require('stream');
 
 const t = new Transform();
 
-t.on('error', common.expectsError({
-  type: Error,
-  code: 'ERR_METHOD_NOT_IMPLEMENTED',
-  message: 'The _transform() method is not implemented'
-}));
+t.on(
+  'error',
+  common.expectsError({
+    type: Error,
+    code: 'ERR_METHOD_NOT_IMPLEMENTED',
+    message: 'The _transform() method is not implemented'
+  })
+);
 
 t.end(Buffer.from('blerg'));
 
diff --git a/test/parallel/test-stream-transform-destroy.js b/test/parallel/test-stream-transform-destroy.js
index 47cce87264b5c1..e97ad8c86d9792 100644
--- a/test/parallel/test-stream-transform-destroy.js
+++ b/test/parallel/test-stream-transform-destroy.js
@@ -29,9 +29,12 @@ const assert = require('assert');
   transform.on('end', common.mustNotCall());
   transform.on('finish', common.mustNotCall());
   transform.on('close', common.mustCall());
-  transform.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  transform.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   transform.destroy(expected);
 }
@@ -50,9 +53,12 @@ const assert = require('assert');
 
   transform.on('finish', common.mustNotCall('no finish event'));
   transform.on('close', common.mustCall());
-  transform.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  transform.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   transform.destroy(expected);
 }
@@ -135,9 +141,12 @@ const assert = require('assert');
   transform.on('close', common.mustCall());
   transform.on('finish', common.mustNotCall('no finish event'));
   transform.on('end', common.mustNotCall('no end event'));
-  transform.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  transform.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   transform.destroy();
 }
diff --git a/test/parallel/test-stream-transform-final-sync.js b/test/parallel/test-stream-transform-final-sync.js
index 666c1dce9996d1..1c7f4fcfa8efcb 100644
--- a/test/parallel/test-stream-transform-final-sync.js
+++ b/test/parallel/test-stream-transform-final-sync.js
@@ -87,24 +87,36 @@ const t = new stream.Transform({
     });
   }, 1)
 });
-t.on('finish', common.mustCall(function() {
-  state++;
-  // finishListener
-  assert.strictEqual(state, 13);
-}, 1));
-t.on('end', common.mustCall(function() {
-  state++;
-  // endEvent
-  assert.strictEqual(state, 16);
-}, 1));
-t.on('data', common.mustCall(function(d) {
-  // dataListener
-  assert.strictEqual(++state, d + 1);
-}, 3));
+t.on(
+  'finish',
+  common.mustCall(function() {
+    state++;
+    // finishListener
+    assert.strictEqual(state, 13);
+  }, 1)
+);
+t.on(
+  'end',
+  common.mustCall(function() {
+    state++;
+    // endEvent
+    assert.strictEqual(state, 16);
+  }, 1)
+);
+t.on(
+  'data',
+  common.mustCall(function(d) {
+    // dataListener
+    assert.strictEqual(++state, d + 1);
+  }, 3)
+);
 t.write(1);
 t.write(4);
-t.end(7, common.mustCall(function() {
-  state++;
-  // endMethodCallback
-  assert.strictEqual(state, 14);
-}, 1));
+t.end(
+  7,
+  common.mustCall(function() {
+    state++;
+    // endMethodCallback
+    assert.strictEqual(state, 14);
+  }, 1)
+);
diff --git a/test/parallel/test-stream-transform-final.js b/test/parallel/test-stream-transform-final.js
index 3d6c4563c6e194..595675141e590a 100644
--- a/test/parallel/test-stream-transform-final.js
+++ b/test/parallel/test-stream-transform-final.js
@@ -89,24 +89,36 @@ const t = new stream.Transform({
     });
   }, 1)
 });
-t.on('finish', common.mustCall(function() {
-  state++;
-  // finishListener
-  assert.strictEqual(state, 13);
-}, 1));
-t.on('end', common.mustCall(function() {
-  state++;
-  // end event
-  assert.strictEqual(state, 16);
-}, 1));
-t.on('data', common.mustCall(function(d) {
-  // dataListener
-  assert.strictEqual(++state, d + 1);
-}, 3));
+t.on(
+  'finish',
+  common.mustCall(function() {
+    state++;
+    // finishListener
+    assert.strictEqual(state, 13);
+  }, 1)
+);
+t.on(
+  'end',
+  common.mustCall(function() {
+    state++;
+    // end event
+    assert.strictEqual(state, 16);
+  }, 1)
+);
+t.on(
+  'data',
+  common.mustCall(function(d) {
+    // dataListener
+    assert.strictEqual(++state, d + 1);
+  }, 3)
+);
 t.write(1);
 t.write(4);
-t.end(7, common.mustCall(function() {
-  state++;
-  // endMethodCallback
-  assert.strictEqual(state, 14);
-}, 1));
+t.end(
+  7,
+  common.mustCall(function() {
+    state++;
+    // endMethodCallback
+    assert.strictEqual(state, 14);
+  }, 1)
+);
diff --git a/test/parallel/test-stream-transform-flush-data.js b/test/parallel/test-stream-transform-flush-data.js
index 6d6aedd3a72bf8..e4a2aced71084f 100644
--- a/test/parallel/test-stream-transform-flush-data.js
+++ b/test/parallel/test-stream-transform-flush-data.js
@@ -5,10 +5,8 @@ require('../common');
 const assert = require('assert');
 const Transform = require('stream').Transform;
 
-
 const expected = 'asdf';
 
-
 function _transform(d, e, n) {
   n();
 }
diff --git a/test/parallel/test-stream-transform-objectmode-falsey-value.js b/test/parallel/test-stream-transform-objectmode-falsey-value.js
index 78ede5d1006515..b7f1fab1affb3e 100644
--- a/test/parallel/test-stream-transform-objectmode-falsey-value.js
+++ b/test/parallel/test-stream-transform-objectmode-falsey-value.js
@@ -30,22 +30,28 @@ const src = new PassThrough({ objectMode: true });
 const tx = new PassThrough({ objectMode: true });
 const dest = new PassThrough({ objectMode: true });
 
-const expect = [ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+const expect = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 const results = [];
 
-dest.on('data', common.mustCall(function(x) {
-  results.push(x);
-}, expect.length));
+dest.on(
+  'data',
+  common.mustCall(function(x) {
+    results.push(x);
+  }, expect.length)
+);
 
 src.pipe(tx).pipe(dest);
 
 let i = -1;
-const int = setInterval(common.mustCall(function() {
-  if (results.length === expect.length) {
-    src.end();
-    clearInterval(int);
-    assert.deepStrictEqual(results, expect);
-  } else {
-    src.write(i++);
-  }
-}, expect.length + 1), 1);
+const int = setInterval(
+  common.mustCall(function() {
+    if (results.length === expect.length) {
+      src.end();
+      clearInterval(int);
+      assert.deepStrictEqual(results, expect);
+    } else {
+      src.write(i++);
+    }
+  }, expect.length + 1),
+  1
+);
diff --git a/test/parallel/test-stream-transform-split-highwatermark.js b/test/parallel/test-stream-transform-split-highwatermark.js
index f931d4f6ceb928..70c85da9e35929 100644
--- a/test/parallel/test-stream-transform-split-highwatermark.js
+++ b/test/parallel/test-stream-transform-split-highwatermark.js
@@ -17,7 +17,7 @@ testTransform(666, DEFAULT, { readableHighWaterMark: 666 });
 testTransform(DEFAULT, 777, { writableHighWaterMark: 777 });
 testTransform(666, 777, {
   readableHighWaterMark: 666,
-  writableHighWaterMark: 777,
+  writableHighWaterMark: 777
 });
 
 // test 0 overriding defaultHwm
@@ -27,31 +27,31 @@ testTransform(DEFAULT, 0, { writableHighWaterMark: 0 });
 // test highWaterMark overriding
 testTransform(555, 555, {
   highWaterMark: 555,
-  readableHighWaterMark: 666,
+  readableHighWaterMark: 666
 });
 testTransform(555, 555, {
   highWaterMark: 555,
-  writableHighWaterMark: 777,
+  writableHighWaterMark: 777
 });
 testTransform(555, 555, {
   highWaterMark: 555,
   readableHighWaterMark: 666,
-  writableHighWaterMark: 777,
+  writableHighWaterMark: 777
 });
 
 // test highWaterMark = 0 overriding
 testTransform(0, 0, {
   highWaterMark: 0,
-  readableHighWaterMark: 666,
+  readableHighWaterMark: 666
 });
 testTransform(0, 0, {
   highWaterMark: 0,
-  writableHighWaterMark: 777,
+  writableHighWaterMark: 777
 });
 testTransform(0, 0, {
   highWaterMark: 0,
   readableHighWaterMark: 666,
-  writableHighWaterMark: 777,
+  writableHighWaterMark: 777
 });
 
 // test undefined, null
@@ -64,21 +64,27 @@ testTransform(0, 0, {
 
 // test NaN
 {
-  common.expectsError(() => {
-    new Transform({ readableHighWaterMark: NaN });
-  }, {
-    type: TypeError,
-    code: 'ERR_INVALID_OPT_VALUE',
-    message: 'The value "NaN" is invalid for option "readableHighWaterMark"'
-  });
+  common.expectsError(
+    () => {
+      new Transform({ readableHighWaterMark: NaN });
+    },
+    {
+      type: TypeError,
+      code: 'ERR_INVALID_OPT_VALUE',
+      message: 'The value "NaN" is invalid for option "readableHighWaterMark"'
+    }
+  );
 
-  common.expectsError(() => {
-    new Transform({ writableHighWaterMark: NaN });
-  }, {
-    type: TypeError,
-    code: 'ERR_INVALID_OPT_VALUE',
-    message: 'The value "NaN" is invalid for option "writableHighWaterMark"'
-  });
+  common.expectsError(
+    () => {
+      new Transform({ writableHighWaterMark: NaN });
+    },
+    {
+      type: TypeError,
+      code: 'ERR_INVALID_OPT_VALUE',
+      message: 'The value "NaN" is invalid for option "writableHighWaterMark"'
+    }
+  );
 }
 
 // test non Duplex streams ignore the options
diff --git a/test/parallel/test-stream-transform-split-objectmode.js b/test/parallel/test-stream-transform-split-objectmode.js
index 55d613573493b9..b077289537da0d 100644
--- a/test/parallel/test-stream-transform-split-objectmode.js
+++ b/test/parallel/test-stream-transform-split-objectmode.js
@@ -31,10 +31,14 @@ assert(parser._readableState.objectMode);
 assert(!parser._writableState.objectMode);
 assert.strictEqual(parser.readableHighWaterMark, 16);
 assert.strictEqual(parser.writableHighWaterMark, 16 * 1024);
-assert.strictEqual(parser.readableHighWaterMark,
-                   parser._readableState.highWaterMark);
-assert.strictEqual(parser.writableHighWaterMark,
-                   parser._writableState.highWaterMark);
+assert.strictEqual(
+  parser.readableHighWaterMark,
+  parser._readableState.highWaterMark
+);
+assert.strictEqual(
+  parser.writableHighWaterMark,
+  parser._writableState.highWaterMark
+);
 
 parser._transform = function(chunk, enc, callback) {
   callback(null, { val: chunk[0] });
@@ -52,17 +56,20 @@ process.on('exit', function() {
   assert.strictEqual(parsed.val, 42);
 });
 
-
 const serializer = new Transform({ writableObjectMode: true });
 
 assert(!serializer._readableState.objectMode);
 assert(serializer._writableState.objectMode);
 assert.strictEqual(serializer.readableHighWaterMark, 16 * 1024);
 assert.strictEqual(serializer.writableHighWaterMark, 16);
-assert.strictEqual(parser.readableHighWaterMark,
-                   parser._readableState.highWaterMark);
-assert.strictEqual(parser.writableHighWaterMark,
-                   parser._writableState.highWaterMark);
+assert.strictEqual(
+  parser.readableHighWaterMark,
+  parser._readableState.highWaterMark
+);
+assert.strictEqual(
+  parser.writableHighWaterMark,
+  parser._writableState.highWaterMark
+);
 
 serializer._transform = function(obj, _, callback) {
   callback(null, Buffer.from([obj.val]));
diff --git a/test/parallel/test-stream-unpipe-event.js b/test/parallel/test-stream-unpipe-event.js
index 340502d1a98b7c..9a6e2148352afe 100644
--- a/test/parallel/test-stream-unpipe-event.js
+++ b/test/parallel/test-stream-unpipe-event.js
@@ -55,7 +55,10 @@ class NeverEndReadable extends Readable {
   const src = new QuickEndReadable();
   dest.on('pipe', common.mustCall());
   dest.on('unpipe', common.mustCall());
-  src.pipe(dest, { end: false });
+  src.pipe(
+    dest,
+    { end: false }
+  );
   setImmediate(() => {
     assert.strictEqual(src._readableState.pipesCount, 0);
   });
@@ -66,7 +69,10 @@ class NeverEndReadable extends Readable {
   const src = new NeverEndReadable();
   dest.on('pipe', common.mustCall());
   dest.on('unpipe', common.mustNotCall('unpipe should not have been emitted'));
-  src.pipe(dest, { end: false });
+  src.pipe(
+    dest,
+    { end: false }
+  );
   setImmediate(() => {
     assert.strictEqual(src._readableState.pipesCount, 1);
   });
@@ -77,7 +83,10 @@ class NeverEndReadable extends Readable {
   const src = new NeverEndReadable();
   dest.on('pipe', common.mustCall());
   dest.on('unpipe', common.mustCall());
-  src.pipe(dest, { end: false });
+  src.pipe(
+    dest,
+    { end: false }
+  );
   src.unpipe(dest);
   setImmediate(() => {
     assert.strictEqual(src._readableState.pipesCount, 0);
diff --git a/test/parallel/test-stream-unshift-empty-chunk.js b/test/parallel/test-stream-unshift-empty-chunk.js
index 9c2c12a41a3958..ea6e6e15410b43 100644
--- a/test/parallel/test-stream-unshift-empty-chunk.js
+++ b/test/parallel/test-stream-unshift-empty-chunk.js
@@ -41,7 +41,7 @@ let readAll = false;
 const seen = [];
 r.on('readable', function() {
   let chunk;
-  while (chunk = r.read()) {
+  while ((chunk = r.read())) {
     seen.push(chunk.toString());
     // simulate only reading a certain amount of the data,
     // and then putting the rest of the chunk back into the
@@ -54,25 +54,26 @@ r.on('readable', function() {
   }
 });
 
-const expect =
-  [ 'xxxxxxxxxx',
-    'yyyyy',
-    'xxxxxxxxxx',
-    'yyyyy',
-    'xxxxxxxxxx',
-    'yyyyy',
-    'xxxxxxxxxx',
-    'yyyyy',
-    'xxxxxxxxxx',
-    'yyyyy',
-    'xxxxxxxxxx',
-    'yyyyy',
-    'xxxxxxxxxx',
-    'yyyyy',
-    'xxxxxxxxxx',
-    'yyyyy',
-    'xxxxxxxxxx',
-    'yyyyy' ];
+const expect = [
+  'xxxxxxxxxx',
+  'yyyyy',
+  'xxxxxxxxxx',
+  'yyyyy',
+  'xxxxxxxxxx',
+  'yyyyy',
+  'xxxxxxxxxx',
+  'yyyyy',
+  'xxxxxxxxxx',
+  'yyyyy',
+  'xxxxxxxxxx',
+  'yyyyy',
+  'xxxxxxxxxx',
+  'yyyyy',
+  'xxxxxxxxxx',
+  'yyyyy',
+  'xxxxxxxxxx',
+  'yyyyy'
+];
 
 r.on('end', function() {
   assert.deepStrictEqual(seen, expect);
diff --git a/test/parallel/test-stream-unshift-read-race.js b/test/parallel/test-stream-unshift-read-race.js
index f2977b285f4db3..ce791fab33fbf8 100644
--- a/test/parallel/test-stream-unshift-read-race.js
+++ b/test/parallel/test-stream-unshift-read-race.js
@@ -68,16 +68,18 @@ r._read = function(n) {
 };
 
 function pushError() {
-  common.expectsError(function() {
-    r.push(Buffer.allocUnsafe(1));
-  }, {
-    code: 'ERR_STREAM_PUSH_AFTER_EOF',
-    type: Error,
-    message: 'stream.push() after EOF'
-  });
+  common.expectsError(
+    function() {
+      r.push(Buffer.allocUnsafe(1));
+    },
+    {
+      code: 'ERR_STREAM_PUSH_AFTER_EOF',
+      type: Error,
+      message: 'stream.push() after EOF'
+    }
+  );
 }
 
-
 const w = stream.Writable();
 const written = [];
 w._write = function(chunk, encoding, cb) {
@@ -85,48 +87,64 @@ w._write = function(chunk, encoding, cb) {
   cb();
 };
 
-r.on('end', common.mustCall(function() {
-  common.expectsError(function() {
-    r.unshift(Buffer.allocUnsafe(1));
-  }, {
-    code: 'ERR_STREAM_UNSHIFT_AFTER_END_EVENT',
-    type: Error,
-    message: 'stream.unshift() after end event'
-  });
-  w.end();
-}));
+r.on(
+  'end',
+  common.mustCall(function() {
+    common.expectsError(
+      function() {
+        r.unshift(Buffer.allocUnsafe(1));
+      },
+      {
+        code: 'ERR_STREAM_UNSHIFT_AFTER_END_EVENT',
+        type: Error,
+        message: 'stream.unshift() after end event'
+      }
+    );
+    w.end();
+  })
+);
 
 r.on('readable', function() {
   let chunk;
   while (null !== (chunk = r.read(10))) {
     w.write(chunk);
-    if (chunk.length > 4)
-      r.unshift(Buffer.from('1234'));
+    if (chunk.length > 4) r.unshift(Buffer.from('1234'));
   }
 });
 
-w.on('finish', common.mustCall(function() {
-  // each chunk should start with 1234, and then be asfdasdfasdf...
-  // The first got pulled out before the first unshift('1234'), so it's
-  // lacking that piece.
-  assert.strictEqual(written[0], 'asdfasdfas');
-  let asdf = 'd';
-  console.error(`0: ${written[0]}`);
-  for (let i = 1; i < written.length; i++) {
-    console.error(`${i.toString(32)}: ${written[i]}`);
-    assert.strictEqual(written[i].slice(0, 4), '1234');
-    for (let j = 4; j < written[i].length; j++) {
-      const c = written[i].charAt(j);
-      assert.strictEqual(c, asdf);
-      switch (asdf) {
-        case 'a': asdf = 's'; break;
-        case 's': asdf = 'd'; break;
-        case 'd': asdf = 'f'; break;
-        case 'f': asdf = 'a'; break;
+w.on(
+  'finish',
+  common.mustCall(function() {
+    // each chunk should start with 1234, and then be asfdasdfasdf...
+    // The first got pulled out before the first unshift('1234'), so it's
+    // lacking that piece.
+    assert.strictEqual(written[0], 'asdfasdfas');
+    let asdf = 'd';
+    console.error(`0: ${written[0]}`);
+    for (let i = 1; i < written.length; i++) {
+      console.error(`${i.toString(32)}: ${written[i]}`);
+      assert.strictEqual(written[i].slice(0, 4), '1234');
+      for (let j = 4; j < written[i].length; j++) {
+        const c = written[i].charAt(j);
+        assert.strictEqual(c, asdf);
+        switch (asdf) {
+          case 'a':
+            asdf = 's';
+            break;
+          case 's':
+            asdf = 'd';
+            break;
+          case 'd':
+            asdf = 'f';
+            break;
+          case 'f':
+            asdf = 'a';
+            break;
+        }
       }
     }
-  }
-}));
+  })
+);
 
 process.on('exit', function() {
   assert.strictEqual(written.length, 18);
diff --git a/test/parallel/test-stream-wrap-drain.js b/test/parallel/test-stream-wrap-drain.js
index 068e2d7fd45979..1de49cf52f367d 100644
--- a/test/parallel/test-stream-wrap-drain.js
+++ b/test/parallel/test-stream-wrap-drain.js
@@ -34,9 +34,12 @@ const { ShutdownWrap } = internalBinding('stream_wrap');
   );
 
   // Make sure that the 'drain' events will be emitted.
-  testDuplex.on('drain', common.mustCall(() => {
-    console.log('testDuplex drain');
-  }));
+  testDuplex.on(
+    'drain',
+    common.mustCall(() => {
+      console.log('testDuplex drain');
+    })
+  );
 
   assert.strictEqual(typeof resolve, 'function');
 
diff --git a/test/parallel/test-stream-wrap-encoding.js b/test/parallel/test-stream-wrap-encoding.js
index ce6f95fa27d68f..8b2c17bf3f48fc 100644
--- a/test/parallel/test-stream-wrap-encoding.js
+++ b/test/parallel/test-stream-wrap-encoding.js
@@ -14,11 +14,14 @@ const Duplex = require('stream').Duplex;
 
   const wrap = new StreamWrap(stream);
 
-  wrap.on('error', common.expectsError({
-    type: Error,
-    code: 'ERR_STREAM_WRAP',
-    message: 'Stream has StringDecoder set or is in objectMode'
-  }));
+  wrap.on(
+    'error',
+    common.expectsError({
+      type: Error,
+      code: 'ERR_STREAM_WRAP',
+      message: 'Stream has StringDecoder set or is in objectMode'
+    })
+  );
 
   stream.push('ohai');
 }
@@ -32,11 +35,14 @@ const Duplex = require('stream').Duplex;
 
   const wrap = new StreamWrap(stream);
 
-  wrap.on('error', common.expectsError({
-    type: Error,
-    code: 'ERR_STREAM_WRAP',
-    message: 'Stream has StringDecoder set or is in objectMode'
-  }));
+  wrap.on(
+    'error',
+    common.expectsError({
+      type: Error,
+      code: 'ERR_STREAM_WRAP',
+      message: 'Stream has StringDecoder set or is in objectMode'
+    })
+  );
 
   stream.push(new Error('foo'));
 }
diff --git a/test/parallel/test-stream-wrap.js b/test/parallel/test-stream-wrap.js
index 9a279790d8aceb..acb08633f61afc 100644
--- a/test/parallel/test-stream-wrap.js
+++ b/test/parallel/test-stream-wrap.js
@@ -10,10 +10,8 @@ const { ShutdownWrap } = internalBinding('stream_wrap');
 
 function testShutdown(callback) {
   const stream = new Duplex({
-    read: function() {
-    },
-    write: function() {
-    }
+    read: function() {},
+    write: function() {}
   });
 
   const wrap = new StreamWrap(stream);
diff --git a/test/parallel/test-stream-writable-change-default-encoding.js b/test/parallel/test-stream-writable-change-default-encoding.js
index 4fc1970a9d05db..fce48432b30ef5 100644
--- a/test/parallel/test-stream-writable-change-default-encoding.js
+++ b/test/parallel/test-stream-writable-change-default-encoding.js
@@ -38,39 +38,52 @@ class MyWritable extends stream.Writable {
 }
 
 (function defaultCondingIsUtf8() {
-  const m = new MyWritable(function(isBuffer, type, enc) {
-    assert.strictEqual(enc, 'utf8');
-  }, { decodeStrings: false });
+  const m = new MyWritable(
+    function(isBuffer, type, enc) {
+      assert.strictEqual(enc, 'utf8');
+    },
+    { decodeStrings: false }
+  );
   m.write('foo');
   m.end();
-}());
+})();
 
 (function changeDefaultEncodingToAscii() {
-  const m = new MyWritable(function(isBuffer, type, enc) {
-    assert.strictEqual(enc, 'ascii');
-  }, { decodeStrings: false });
+  const m = new MyWritable(
+    function(isBuffer, type, enc) {
+      assert.strictEqual(enc, 'ascii');
+    },
+    { decodeStrings: false }
+  );
   m.setDefaultEncoding('ascii');
   m.write('bar');
   m.end();
-}());
+})();
 
-common.expectsError(function changeDefaultEncodingToInvalidValue() {
-  const m = new MyWritable(function(isBuffer, type, enc) {
-  }, { decodeStrings: false });
-  m.setDefaultEncoding({});
-  m.write('bar');
-  m.end();
-}, {
-  type: TypeError,
-  code: 'ERR_UNKNOWN_ENCODING',
-  message: 'Unknown encoding: [object Object]'
-});
+common.expectsError(
+  function changeDefaultEncodingToInvalidValue() {
+    const m = new MyWritable(function(isBuffer, type, enc) {}, {
+      decodeStrings: false
+    });
+    m.setDefaultEncoding({});
+    m.write('bar');
+    m.end();
+  },
+  {
+    type: TypeError,
+    code: 'ERR_UNKNOWN_ENCODING',
+    message: 'Unknown encoding: [object Object]'
+  }
+);
 
 (function checkVairableCaseEncoding() {
-  const m = new MyWritable(function(isBuffer, type, enc) {
-    assert.strictEqual(enc, 'ascii');
-  }, { decodeStrings: false });
+  const m = new MyWritable(
+    function(isBuffer, type, enc) {
+      assert.strictEqual(enc, 'ascii');
+    },
+    { decodeStrings: false }
+  );
   m.setDefaultEncoding('AsCii');
   m.write('bar');
   m.end();
-}());
+})();
diff --git a/test/parallel/test-stream-writable-constructor-set-methods.js b/test/parallel/test-stream-writable-constructor-set-methods.js
index 13a8dc286021f2..5062be7ee2a662 100644
--- a/test/parallel/test-stream-writable-constructor-set-methods.js
+++ b/test/parallel/test-stream-writable-constructor-set-methods.js
@@ -6,11 +6,14 @@ const { Writable } = require('stream');
 
 const w = new Writable();
 
-w.on('error', common.expectsError({
-  type: Error,
-  code: 'ERR_METHOD_NOT_IMPLEMENTED',
-  message: 'The _write() method is not implemented'
-}));
+w.on(
+  'error',
+  common.expectsError({
+    type: Error,
+    code: 'ERR_METHOD_NOT_IMPLEMENTED',
+    message: 'The _write() method is not implemented'
+  })
+);
 
 w.end(Buffer.from('blerg'));
 
diff --git a/test/parallel/test-stream-writable-decoded-encoding.js b/test/parallel/test-stream-writable-decoded-encoding.js
index 578208a84bdec0..12cef2387f2869 100644
--- a/test/parallel/test-stream-writable-decoded-encoding.js
+++ b/test/parallel/test-stream-writable-decoded-encoding.js
@@ -38,21 +38,27 @@ class MyWritable extends stream.Writable {
 }
 
 {
-  const m = new MyWritable(function(isBuffer, type, enc) {
-    assert(isBuffer);
-    assert.strictEqual(type, 'object');
-    assert.strictEqual(enc, 'buffer');
-  }, { decodeStrings: true });
+  const m = new MyWritable(
+    function(isBuffer, type, enc) {
+      assert(isBuffer);
+      assert.strictEqual(type, 'object');
+      assert.strictEqual(enc, 'buffer');
+    },
+    { decodeStrings: true }
+  );
   m.write('some-text', 'utf8');
   m.end();
 }
 
 {
-  const m = new MyWritable(function(isBuffer, type, enc) {
-    assert(!isBuffer);
-    assert.strictEqual(type, 'string');
-    assert.strictEqual(enc, 'utf8');
-  }, { decodeStrings: false });
+  const m = new MyWritable(
+    function(isBuffer, type, enc) {
+      assert(!isBuffer);
+      assert.strictEqual(type, 'string');
+      assert.strictEqual(enc, 'utf8');
+    },
+    { decodeStrings: false }
+  );
   m.write('some-text', 'utf8');
   m.end();
 }
diff --git a/test/parallel/test-stream-writable-destroy.js b/test/parallel/test-stream-writable-destroy.js
index 565a5564e2bc29..6650d423215bda 100644
--- a/test/parallel/test-stream-writable-destroy.js
+++ b/test/parallel/test-stream-writable-destroy.js
@@ -7,7 +7,9 @@ const { inherits } = require('util');
 
 {
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   write.on('finish', common.mustNotCall());
@@ -19,16 +21,21 @@ const { inherits } = require('util');
 
 {
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   const expected = new Error('kaboom');
 
   write.on('finish', common.mustNotCall());
   write.on('close', common.mustCall());
-  write.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  write.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   write.destroy(expected);
   assert.strictEqual(write.destroyed, true);
@@ -36,7 +43,9 @@ const { inherits } = require('util');
 
 {
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   write._destroy = function(err, cb) {
@@ -48,9 +57,12 @@ const { inherits } = require('util');
 
   write.on('finish', common.mustNotCall('no finish event'));
   write.on('close', common.mustCall());
-  write.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  write.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   write.destroy(expected);
   assert.strictEqual(write.destroyed, true);
@@ -58,7 +70,9 @@ const { inherits } = require('util');
 
 {
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); },
+    write(chunk, enc, cb) {
+      cb();
+    },
     destroy: common.mustCall(function(err, cb) {
       assert.strictEqual(err, expected);
       cb();
@@ -79,7 +93,9 @@ const { inherits } = require('util');
 
 {
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   write._destroy = common.mustCall(function(err, cb) {
@@ -93,7 +109,9 @@ const { inherits } = require('util');
 
 {
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   write._destroy = common.mustCall(function(err, cb) {
@@ -118,7 +136,9 @@ const { inherits } = require('util');
 
 {
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   const expected = new Error('kaboom');
@@ -130,9 +150,12 @@ const { inherits } = require('util');
 
   write.on('close', common.mustCall());
   write.on('finish', common.mustNotCall('no finish event'));
-  write.on('error', common.mustCall((err) => {
-    assert.strictEqual(err, expected);
-  }));
+  write.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err, expected);
+    })
+  );
 
   write.destroy();
   assert.strictEqual(write.destroyed, true);
@@ -141,7 +164,9 @@ const { inherits } = require('util');
 {
   // double error case
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   write.on('close', common.mustCall());
@@ -155,7 +180,9 @@ const { inherits } = require('util');
 
 {
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   write.destroyed = true;
@@ -181,16 +208,21 @@ const { inherits } = require('util');
 {
   // destroy and destroy callback
   const write = new Writable({
-    write(chunk, enc, cb) { cb(); }
+    write(chunk, enc, cb) {
+      cb();
+    }
   });
 
   write.destroy();
 
   const expected = new Error('kaboom');
 
-  write.destroy(expected, common.mustCall(function(err) {
-    assert.strictEqual(expected, err);
-  }));
+  write.destroy(
+    expected,
+    common.mustCall(function(err) {
+      assert.strictEqual(expected, err);
+    })
+  );
 }
 
 {
diff --git a/test/parallel/test-stream-writable-ended-state.js b/test/parallel/test-stream-writable-ended-state.js
index 69ba3c88ede253..59647f37542f97 100644
--- a/test/parallel/test-stream-writable-ended-state.js
+++ b/test/parallel/test-stream-writable-ended-state.js
@@ -14,8 +14,11 @@ writable._write = (chunk, encoding, cb) => {
 
 assert.strictEqual(writable._writableState.ended, false);
 
-writable.end('testing ended state', common.mustCall(() => {
-  assert.strictEqual(writable._writableState.ended, true);
-}));
+writable.end(
+  'testing ended state',
+  common.mustCall(() => {
+    assert.strictEqual(writable._writableState.ended, true);
+  })
+);
 
 assert.strictEqual(writable._writableState.ended, true);
diff --git a/test/parallel/test-stream-writable-finished-state.js b/test/parallel/test-stream-writable-finished-state.js
index b42137ed0b5d6b..bc74a65c168e5f 100644
--- a/test/parallel/test-stream-writable-finished-state.js
+++ b/test/parallel/test-stream-writable-finished-state.js
@@ -13,10 +13,16 @@ writable._write = (chunk, encoding, cb) => {
   cb();
 };
 
-writable.on('finish', common.mustCall(() => {
-  assert.strictEqual(writable._writableState.finished, true);
-}));
+writable.on(
+  'finish',
+  common.mustCall(() => {
+    assert.strictEqual(writable._writableState.finished, true);
+  })
+);
 
-writable.end('testing finished state', common.mustCall(() => {
-  assert.strictEqual(writable._writableState.finished, true);
-}));
+writable.end(
+  'testing finished state',
+  common.mustCall(() => {
+    assert.strictEqual(writable._writableState.finished, true);
+  })
+);
diff --git a/test/parallel/test-stream-writable-needdrain-state.js b/test/parallel/test-stream-writable-needdrain-state.js
index ea5617d997d5ed..595a6a93e8d3be 100644
--- a/test/parallel/test-stream-writable-needdrain-state.js
+++ b/test/parallel/test-stream-writable-needdrain-state.js
@@ -16,8 +16,11 @@ function _transform(chunk, encoding, cb) {
 
 assert.strictEqual(transform._writableState.needDrain, false);
 
-transform.write('asdasd', common.mustCall(() => {
-  assert.strictEqual(transform._writableState.needDrain, false);
-}));
+transform.write(
+  'asdasd',
+  common.mustCall(() => {
+    assert.strictEqual(transform._writableState.needDrain, false);
+  })
+);
 
 assert.strictEqual(transform._writableState.needDrain, true);
diff --git a/test/parallel/test-stream-writable-null.js b/test/parallel/test-stream-writable-null.js
index 63e122a3b496e1..d78ea69d740870 100644
--- a/test/parallel/test-stream-writable-null.js
+++ b/test/parallel/test-stream-writable-null.js
@@ -27,7 +27,8 @@ common.expectsError(
   }
 );
 
-{ // Should not throw.
+{
+  // Should not throw.
   const m = new MyWritable({ objectMode: true }).on('error', assert);
   m.write(null, assert);
 }
@@ -43,17 +44,20 @@ common.expectsError(
   }
 );
 
-{ // Should not throw.
+{
+  // Should not throw.
   const m = new MyWritable().on('error', assert);
   m.write(false, assert);
 }
 
-{ // Should not throw.
+{
+  // Should not throw.
   const m = new MyWritable({ objectMode: true });
   m.write(false, assert.ifError);
 }
 
-{ // Should not throw.
+{
+  // Should not throw.
   const m = new MyWritable({ objectMode: true }).on('error', (e) => {
     assert.ifError(e || new Error('should not get here'));
   });
diff --git a/test/parallel/test-stream-writable-write-writev-finish.js b/test/parallel/test-stream-writable-write-writev-finish.js
index 98660b76ac8ea6..2fda2a54766efd 100644
--- a/test/parallel/test-stream-writable-write-writev-finish.js
+++ b/test/parallel/test-stream-writable-write-writev-finish.js
@@ -15,16 +15,22 @@ const stream = require('stream');
   };
 
   let firstError = false;
-  writable.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
+  writable.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(firstError, true);
+    })
+  );
 
   writable.on('prefinish', common.mustCall());
 
-  writable.on('error', common.mustCall((er) => {
-    assert.strictEqual(er.message, 'write test error');
-    firstError = true;
-  }));
+  writable.on(
+    'error',
+    common.mustCall((er) => {
+      assert.strictEqual(er.message, 'write test error');
+      firstError = true;
+    })
+  );
 
   writable.end('test');
 }
@@ -37,16 +43,22 @@ const stream = require('stream');
   };
 
   let firstError = false;
-  writable.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
+  writable.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(firstError, true);
+    })
+  );
 
   writable.on('prefinish', common.mustCall());
 
-  writable.on('error', common.mustCall((er) => {
-    assert.strictEqual(er.message, 'write test error');
-    firstError = true;
-  }));
+  writable.on(
+    'error',
+    common.mustCall((er) => {
+      assert.strictEqual(er.message, 'write test error');
+      firstError = true;
+    })
+  );
 
   writable.end('test');
 }
@@ -63,16 +75,22 @@ const stream = require('stream');
   };
 
   let firstError = false;
-  writable.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
+  writable.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(firstError, true);
+    })
+  );
 
   writable.on('prefinish', common.mustCall());
 
-  writable.on('error', common.mustCall((er) => {
-    assert.strictEqual(er.message, 'writev test error');
-    firstError = true;
-  }));
+  writable.on(
+    'error',
+    common.mustCall((er) => {
+      assert.strictEqual(er.message, 'writev test error');
+      firstError = true;
+    })
+  );
 
   writable.cork();
   writable.write('test');
@@ -94,16 +112,22 @@ const stream = require('stream');
   };
 
   let firstError = false;
-  writable.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
+  writable.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(firstError, true);
+    })
+  );
 
   writable.on('prefinish', common.mustCall());
 
-  writable.on('error', common.mustCall((er) => {
-    assert.strictEqual(er.message, 'writev test error');
-    firstError = true;
-  }));
+  writable.on(
+    'error',
+    common.mustCall((er) => {
+      assert.strictEqual(er.message, 'writev test error');
+      firstError = true;
+    })
+  );
 
   writable.cork();
   writable.write('test');
@@ -125,12 +149,18 @@ const stream = require('stream');
   const ws = new stream.Writable();
   let firstError = false;
 
-  ws.on('finish', common.mustCall(function() {
-    assert.strictEqual(firstError, true);
-  }));
-  ws.on('error', common.mustCall(function() {
-    firstError = true;
-  }));
+  ws.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(firstError, true);
+    })
+  );
+  ws.on(
+    'error',
+    common.mustCall(function() {
+      firstError = true;
+    })
+  );
 
   ws._write = (chunk, encoding, done) => {
     setImmediate(done, new Error());
diff --git a/test/parallel/test-stream-write-destroy.js b/test/parallel/test-stream-write-destroy.js
index 83b329a6a8a7b3..574bea0ff014d8 100644
--- a/test/parallel/test-stream-write-destroy.js
+++ b/test/parallel/test-stream-write-destroy.js
@@ -6,8 +6,8 @@ const { Writable } = require('stream');
 // Test interaction between calling .destroy() on a writable and pending
 // writes.
 
-for (const withPendingData of [ false, true ]) {
-  for (const useEnd of [ false, true ]) {
+for (const withPendingData of [false, true]) {
+  for (const useEnd of [false, true]) {
     const callbacks = [];
 
     const w = new Writable({
@@ -22,7 +22,7 @@ for (const withPendingData of [ false, true ]) {
     let drains = 0;
     let finished = false;
     w.on('drain', () => drains++);
-    w.on('finish', () => finished = true);
+    w.on('finish', () => (finished = true));
 
     w.write('abc', () => chunksWritten++);
     assert.strictEqual(chunksWritten, 0);
diff --git a/test/parallel/test-stream-write-final.js b/test/parallel/test-stream-write-final.js
index 56537bd7fae94d..51d7001c04567f 100644
--- a/test/parallel/test-stream-write-final.js
+++ b/test/parallel/test-stream-write-final.js
@@ -17,8 +17,11 @@ const w = new stream.Writable({
     process.nextTick(cb);
   }
 });
-w.on('finish', common.mustCall(function() {
-  assert(shutdown);
-}));
+w.on(
+  'finish',
+  common.mustCall(function() {
+    assert(shutdown);
+  })
+);
 w.write(Buffer.allocUnsafe(1));
 w.end(Buffer.allocUnsafe(0));
diff --git a/test/parallel/test-stream-writev.js b/test/parallel/test-stream-writev.js
index a0d344440ee7bb..f26c47ee434caf 100644
--- a/test/parallel/test-stream-writev.js
+++ b/test/parallel/test-stream-writev.js
@@ -38,10 +38,8 @@ run();
 
 function run() {
   const t = queue.pop();
-  if (t)
-    test(t[0], t[1], t[2], run);
-  else
-    console.log('ok');
+  if (t) test(t[0], t[1], t[2], run);
+  else console.log('ok');
 }
 
 function test(decode, uncork, multi, next) {
@@ -61,32 +59,36 @@ function test(decode, uncork, multi, next) {
   const w = new stream.Writable({ decodeStrings: decode });
   w._write = common.mustNotCall('Should not call _write');
 
-  const expectChunks = decode ? [
-    { encoding: 'buffer',
-      chunk: [104, 101, 108, 108, 111, 44, 32] },
-    { encoding: 'buffer',
-      chunk: [119, 111, 114, 108, 100] },
-    { encoding: 'buffer',
-      chunk: [33] },
-    { encoding: 'buffer',
-      chunk: [10, 97, 110, 100, 32, 116, 104, 101, 110, 46, 46, 46] },
-    { encoding: 'buffer',
-      chunk: [250, 206, 190, 167, 222, 173, 190, 239, 222, 202, 251, 173] }
-  ] : [
-    { encoding: 'ascii', chunk: 'hello, ' },
-    { encoding: 'utf8', chunk: 'world' },
-    { encoding: 'buffer', chunk: [33] },
-    { encoding: 'latin1', chunk: '\nand then...' },
-    { encoding: 'hex', chunk: 'facebea7deadbeefdecafbad' }
-  ];
+  const expectChunks = decode
+    ? [
+        { encoding: 'buffer', chunk: [104, 101, 108, 108, 111, 44, 32] },
+        { encoding: 'buffer', chunk: [119, 111, 114, 108, 100] },
+        { encoding: 'buffer', chunk: [33] },
+        {
+          encoding: 'buffer',
+          chunk: [10, 97, 110, 100, 32, 116, 104, 101, 110, 46, 46, 46]
+        },
+        {
+          encoding: 'buffer',
+          chunk: [250, 206, 190, 167, 222, 173, 190, 239, 222, 202, 251, 173]
+        }
+      ]
+    : [
+        { encoding: 'ascii', chunk: 'hello, ' },
+        { encoding: 'utf8', chunk: 'world' },
+        { encoding: 'buffer', chunk: [33] },
+        { encoding: 'latin1', chunk: '\nand then...' },
+        { encoding: 'hex', chunk: 'facebea7deadbeefdecafbad' }
+      ];
 
   let actualChunks;
   w._writev = function(chunks, cb) {
     actualChunks = chunks.map(function(chunk) {
       return {
         encoding: chunk.encoding,
-        chunk: Buffer.isBuffer(chunk.chunk) ?
-          Array.prototype.slice.call(chunk.chunk) : chunk.chunk
+        chunk: Buffer.isBuffer(chunk.chunk)
+          ? Array.prototype.slice.call(chunk.chunk)
+          : chunk.chunk
       };
     });
     cb();
@@ -96,19 +98,16 @@ function test(decode, uncork, multi, next) {
   w.write('hello, ', 'ascii', cnt('hello'));
   w.write('world', 'utf8', cnt('world'));
 
-  if (multi)
-    w.cork();
+  if (multi) w.cork();
 
   w.write(Buffer.from('!'), 'buffer', cnt('!'));
   w.write('\nand then...', 'latin1', cnt('and then'));
 
-  if (multi)
-    w.uncork();
+  if (multi) w.uncork();
 
   w.write('facebea7deadbeefdecafbad', 'hex', cnt('hex'));
 
-  if (uncork)
-    w.uncork();
+  if (uncork) w.uncork();
 
   w.end(cnt('end'));
 
diff --git a/test/parallel/test-stream2-basic.js b/test/parallel/test-stream2-basic.js
index 0083077fc2d649..4689715dab0d71 100644
--- a/test/parallel/test-stream2-basic.js
+++ b/test/parallel/test-stream2-basic.js
@@ -47,8 +47,7 @@ class TestReader extends R {
         this._bufs -= 1;
         if (this._bufs <= 0) {
           // read them all!
-          if (!this.ended)
-            this.push(null);
+          if (!this.ended) this.push(null);
         } else {
           // now we have more.
           // kinda cheating by calling _read, but whatever,
@@ -89,26 +88,31 @@ class TestWriter extends EE {
   const r = new TestReader(20);
 
   const reads = [];
-  const expect = [ 'x',
-                   'xx',
-                   'xxx',
-                   'xxxx',
-                   'xxxxx',
-                   'xxxxxxxxx',
-                   'xxxxxxxxxx',
-                   'xxxxxxxxxxxx',
-                   'xxxxxxxxxxxxx',
-                   'xxxxxxxxxxxxxxx',
-                   'xxxxxxxxxxxxxxxxx',
-                   'xxxxxxxxxxxxxxxxxxx',
-                   'xxxxxxxxxxxxxxxxxxxxx',
-                   'xxxxxxxxxxxxxxxxxxxxxxx',
-                   'xxxxxxxxxxxxxxxxxxxxxxxxx',
-                   'xxxxxxxxxxxxxxxxxxxxx' ];
-
-  r.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(reads, expect);
-  }));
+  const expect = [
+    'x',
+    'xx',
+    'xxx',
+    'xxxx',
+    'xxxxx',
+    'xxxxxxxxx',
+    'xxxxxxxxxx',
+    'xxxxxxxxxxxx',
+    'xxxxxxxxxxxxx',
+    'xxxxxxxxxxxxxxx',
+    'xxxxxxxxxxxxxxxxx',
+    'xxxxxxxxxxxxxxxxxxx',
+    'xxxxxxxxxxxxxxxxxxxxx',
+    'xxxxxxxxxxxxxxxxxxxxxxx',
+    'xxxxxxxxxxxxxxxxxxxxxxxxx',
+    'xxxxxxxxxxxxxxxxxxxxx'
+  ];
+
+  r.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(reads, expect);
+    })
+  );
 
   let readSize = 1;
   function flow() {
@@ -126,45 +130,51 @@ class TestWriter extends EE {
   // Verify pipe
   const r = new TestReader(5);
 
-  const expect = [ 'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx' ];
+  const expect = [
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx'
+  ];
 
   const w = new TestWriter();
 
-  w.on('end', common.mustCall(function(received) {
-    assert.deepStrictEqual(received, expect);
-  }));
+  w.on(
+    'end',
+    common.mustCall(function(received) {
+      assert.deepStrictEqual(received, expect);
+    })
+  );
 
   r.pipe(w);
 }
 
-
 [1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(function(SPLIT) {
   // Verify unpipe
   const r = new TestReader(5);
 
   // unpipe after 3 writes, then write to another stream instead.
-  let expect = [ 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx' ];
-  expect = [ expect.slice(0, SPLIT), expect.slice(SPLIT) ];
-
-  const w = [ new TestWriter(), new TestWriter() ];
+  let expect = [
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx'
+  ];
+  expect = [expect.slice(0, SPLIT), expect.slice(SPLIT)];
+
+  const w = [new TestWriter(), new TestWriter()];
 
   let writes = SPLIT;
   w[0].on('write', function() {
@@ -179,68 +189,82 @@ class TestWriter extends EE {
 
   let ended = 0;
 
-  w[0].on('end', common.mustCall(function(results) {
-    ended++;
-    assert.strictEqual(ended, 1);
-    assert.deepStrictEqual(results, expect[0]);
-  }));
-
-  w[1].on('end', common.mustCall(function(results) {
-    ended++;
-    assert.strictEqual(ended, 2);
-    assert.deepStrictEqual(results, expect[1]);
-  }));
+  w[0].on(
+    'end',
+    common.mustCall(function(results) {
+      ended++;
+      assert.strictEqual(ended, 1);
+      assert.deepStrictEqual(results, expect[0]);
+    })
+  );
+
+  w[1].on(
+    'end',
+    common.mustCall(function(results) {
+      ended++;
+      assert.strictEqual(ended, 2);
+      assert.deepStrictEqual(results, expect[1]);
+    })
+  );
 
   r.pipe(w[0]);
 });
 
-
 {
   // Verify both writers get the same data when piping to destinations
   const r = new TestReader(5);
-  const w = [ new TestWriter(), new TestWriter() ];
-
-  const expect = [ 'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx',
-                   'xxxxx' ];
-
-  w[0].on('end', common.mustCall(function(received) {
-    assert.deepStrictEqual(received, expect);
-  }));
-  w[1].on('end', common.mustCall(function(received) {
-    assert.deepStrictEqual(received, expect);
-  }));
+  const w = [new TestWriter(), new TestWriter()];
+
+  const expect = [
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx'
+  ];
+
+  w[0].on(
+    'end',
+    common.mustCall(function(received) {
+      assert.deepStrictEqual(received, expect);
+    })
+  );
+  w[1].on(
+    'end',
+    common.mustCall(function(received) {
+      assert.deepStrictEqual(received, expect);
+    })
+  );
 
   r.pipe(w[0]);
   r.pipe(w[1]);
 }
 
-
 [1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(function(SPLIT) {
   // Verify multi-unpipe
   const r = new TestReader(5);
 
   // unpipe after 3 writes, then write to another stream instead.
-  let expect = [ 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx',
-                 'xxxxx' ];
-  expect = [ expect.slice(0, SPLIT), expect.slice(SPLIT) ];
-
-  const w = [ new TestWriter(), new TestWriter(), new TestWriter() ];
+  let expect = [
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx',
+    'xxxxx'
+  ];
+  expect = [expect.slice(0, SPLIT), expect.slice(SPLIT)];
+
+  const w = [new TestWriter(), new TestWriter(), new TestWriter()];
 
   let writes = SPLIT;
   w[0].on('write', function() {
@@ -253,17 +277,23 @@ class TestWriter extends EE {
 
   let ended = 0;
 
-  w[0].on('end', common.mustCall(function(results) {
-    ended++;
-    assert.strictEqual(ended, 1);
-    assert.deepStrictEqual(results, expect[0]);
-  }));
-
-  w[1].on('end', common.mustCall(function(results) {
-    ended++;
-    assert.strictEqual(ended, 2);
-    assert.deepStrictEqual(results, expect[1]);
-  }));
+  w[0].on(
+    'end',
+    common.mustCall(function(results) {
+      ended++;
+      assert.strictEqual(ended, 1);
+      assert.deepStrictEqual(results, expect[0]);
+    })
+  );
+
+  w[1].on(
+    'end',
+    common.mustCall(function(results) {
+      ended++;
+      assert.strictEqual(ended, 2);
+      assert.deepStrictEqual(results, expect[1]);
+    })
+  );
 
   r.pipe(w[0]);
   r.pipe(w[2]);
@@ -396,10 +426,8 @@ class TestWriter extends EE {
   let readCalled = 0;
 
   r._read = function(n) {
-    if (readCalled++ === 2)
-      r.push(null);
-    else
-      r.push(Buffer.from('asdf'));
+    if (readCalled++ === 2) r.push(null);
+    else r.push(Buffer.from('asdf'));
   };
 
   r.on('readable', function() {
@@ -407,16 +435,23 @@ class TestWriter extends EE {
     r.read();
   });
 
-  r.on('end', common.mustCall(function() {
-    assert.strictEqual(readCalled, 3);
-    assert.ok(onReadable);
-  }));
+  r.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(readCalled, 3);
+      assert.ok(onReadable);
+    })
+  );
 }
 
 {
   // Verify that streams are chainable
   const r = new R();
   r._read = common.mustCall();
-  const r2 = r.setEncoding('utf8').pause().resume().pause();
+  const r2 = r
+    .setEncoding('utf8')
+    .pause()
+    .resume()
+    .pause();
   assert.strictEqual(r, r2);
 }
diff --git a/test/parallel/test-stream2-decode-partial.js b/test/parallel/test-stream2-decode-partial.js
index 9b1baf7fd677f4..a43bf26e129bfe 100644
--- a/test/parallel/test-stream2-decode-partial.js
+++ b/test/parallel/test-stream2-decode-partial.js
@@ -4,8 +4,8 @@ const Readable = require('_stream_readable');
 const assert = require('assert');
 
 let buf = '';
-const euro = Buffer.from([0xE2, 0x82, 0xAC]);
-const cent = Buffer.from([0xC2, 0xA2]);
+const euro = Buffer.from([0xe2, 0x82, 0xac]);
+const cent = Buffer.from([0xc2, 0xa2]);
 const source = Buffer.concat([euro, cent]);
 
 const readable = Readable({ encoding: 'utf8' });
diff --git a/test/parallel/test-stream2-httpclient-response-end.js b/test/parallel/test-stream2-httpclient-response-end.js
index 27d31e50a96a7e..eab7cda28b881f 100644
--- a/test/parallel/test-stream2-httpclient-response-end.js
+++ b/test/parallel/test-stream2-httpclient-response-end.js
@@ -3,20 +3,28 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 const msg = 'Hello';
-const server = http.createServer(function(req, res) {
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.end(msg);
-}).listen(0, function() {
-  http.get({ port: this.address().port }, function(res) {
-    let data = '';
-    res.on('readable', common.mustCall(function() {
-      console.log('readable event');
-      data += res.read();
-    }));
-    res.on('end', common.mustCall(function() {
-      console.log('end event');
-      assert.strictEqual(msg, data);
-      server.close();
-    }));
+const server = http
+  .createServer(function(req, res) {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end(msg);
+  })
+  .listen(0, function() {
+    http.get({ port: this.address().port }, function(res) {
+      let data = '';
+      res.on(
+        'readable',
+        common.mustCall(function() {
+          console.log('readable event');
+          data += res.read();
+        })
+      );
+      res.on(
+        'end',
+        common.mustCall(function() {
+          console.log('end event');
+          assert.strictEqual(msg, data);
+          server.close();
+        })
+      );
+    });
   });
-});
diff --git a/test/parallel/test-stream2-large-read-stall.js b/test/parallel/test-stream2-large-read-stall.js
index 2d44bb7f783b9d..1cfa62e2592d9f 100644
--- a/test/parallel/test-stream2-large-read-stall.js
+++ b/test/parallel/test-stream2-large-read-stall.js
@@ -48,20 +48,24 @@ r.on('readable', function() {
     console.error(`  < ${ret && ret.length} (${rs.length} remain)`);
   } while (ret && ret.length === READSIZE);
 
-  console.error('<< after read()',
-                ret && ret.length,
-                rs.needReadable,
-                rs.length);
+  console.error(
+    '<< after read()',
+    ret && ret.length,
+    rs.needReadable,
+    rs.length
+  );
 });
 
-r.on('end', common.mustCall(function() {
-  assert.strictEqual(pushes, PUSHCOUNT + 1);
-}));
+r.on(
+  'end',
+  common.mustCall(function() {
+    assert.strictEqual(pushes, PUSHCOUNT + 1);
+  })
+);
 
 let pushes = 0;
 function push() {
-  if (pushes > PUSHCOUNT)
-    return;
+  if (pushes > PUSHCOUNT) return;
 
   if (pushes++ === PUSHCOUNT) {
     console.error('   push(EOF)');
@@ -69,6 +73,5 @@ function push() {
   }
 
   console.error(`   push #${pushes}`);
-  if (r.push(Buffer.allocUnsafe(PUSHSIZE)))
-    setTimeout(push, 1);
+  if (r.push(Buffer.allocUnsafe(PUSHSIZE))) setTimeout(push, 1);
 }
diff --git a/test/parallel/test-stream2-objects.js b/test/parallel/test-stream2-objects.js
index f58ea4a32a1e7d..d41529545cc1a8 100644
--- a/test/parallel/test-stream2-objects.js
+++ b/test/parallel/test-stream2-objects.js
@@ -68,12 +68,13 @@ function fromArray(list) {
   // Verify that objects can be piped into the stream
   const r = fromArray([{ one: '1' }, { two: '2' }]);
 
-  r.pipe(toArray(common.mustCall(function(list) {
-    assert.deepStrictEqual(list, [
-      { one: '1' },
-      { two: '2' }
-    ]);
-  })));
+  r.pipe(
+    toArray(
+      common.mustCall(function(list) {
+        assert.deepStrictEqual(list, [{ one: '1' }, { two: '2' }]);
+      })
+    )
+  );
 }
 
 {
@@ -93,12 +94,13 @@ function fromArray(list) {
     r.push(item || null);
   };
 
-  r.pipe(toArray(common.mustCall(function(list) {
-    assert.deepStrictEqual(list, [
-      { one: '1' },
-      { two: '2' }
-    ]);
-  })));
+  r.pipe(
+    toArray(
+      common.mustCall(function(list) {
+        assert.deepStrictEqual(list, [{ one: '1' }, { two: '2' }]);
+      })
+    )
+  );
 }
 
 {
@@ -112,12 +114,13 @@ function fromArray(list) {
     });
   };
 
-  r.pipe(toArray(common.mustCall(function(list) {
-    assert.deepStrictEqual(list, [
-      { one: '1' },
-      { two: '2' }
-    ]);
-  })));
+  r.pipe(
+    toArray(
+      common.mustCall(function(list) {
+        assert.deepStrictEqual(list, [{ one: '1' }, { two: '2' }]);
+      })
+    )
+  );
 }
 
 {
@@ -132,9 +135,13 @@ function fromArray(list) {
   });
   r.push(null);
 
-  r.pipe(toArray(common.mustCall(function(array) {
-    assert.deepStrictEqual(array, list);
-  })));
+  r.pipe(
+    toArray(
+      common.mustCall(function(array) {
+        assert.deepStrictEqual(array, list);
+      })
+    )
+  );
 }
 
 {
@@ -147,9 +154,13 @@ function fromArray(list) {
   r.push('foobar');
   r.push(null);
 
-  r.pipe(toArray(common.mustCall(function(array) {
-    assert.deepStrictEqual(array, ['foobar']);
-  })));
+  r.pipe(
+    toArray(
+      common.mustCall(function(array) {
+        assert.deepStrictEqual(array, ['foobar']);
+      })
+    )
+  );
 }
 
 {
@@ -164,9 +175,13 @@ function fromArray(list) {
   r.push('');
   r.push(null);
 
-  r.pipe(toArray(common.mustCall(function(array) {
-    assert.deepStrictEqual(array, [false, 0, '']);
-  })));
+  r.pipe(
+    toArray(
+      common.mustCall(function(array) {
+        assert.deepStrictEqual(array, [false, 0, '']);
+      })
+    )
+  );
 }
 
 {
@@ -237,9 +252,12 @@ function fromArray(list) {
     cb();
   };
 
-  w.on('finish', common.mustCall(function() {
-    assert.deepStrictEqual(list, [0, 1, 2, 3, 4]);
-  }));
+  w.on(
+    'finish',
+    common.mustCall(function() {
+      assert.deepStrictEqual(list, [0, 1, 2, 3, 4]);
+    })
+  );
 
   w.write(0);
   w.write(1);
@@ -261,9 +279,12 @@ function fromArray(list) {
     process.nextTick(cb);
   };
 
-  w.on('finish', common.mustCall(function() {
-    assert.deepStrictEqual(list, ['0', '1', '2', '3', '4']);
-  }));
+  w.on(
+    'finish',
+    common.mustCall(function() {
+      assert.deepStrictEqual(list, ['0', '1', '2', '3', '4']);
+    })
+  );
 
   w.write('0');
   w.write('1');
@@ -289,9 +310,12 @@ function fromArray(list) {
     });
   };
 
-  w.on('finish', common.mustCall(function() {
-    assert.strictEqual(called, true);
-  }));
+  w.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(called, true);
+    })
+  );
 
   w.write('foo');
   w.end();
diff --git a/test/parallel/test-stream2-push.js b/test/parallel/test-stream2-push.js
index 33645df8a5541c..2a9893751d372a 100644
--- a/test/parallel/test-stream2-push.js
+++ b/test/parallel/test-stream2-push.js
@@ -26,7 +26,6 @@ const { Readable, Writable } = require('stream');
 
 const EE = require('events').EventEmitter;
 
-
 // a mock thing a bit like the net.Socket/tcp_wrap.handle interaction
 
 const stream = new Readable({
@@ -49,8 +48,7 @@ stream.on('end', function() {
 source.on('data', function(chunk) {
   const ret = stream.push(chunk);
   console.error('data', stream.readableLength);
-  if (!ret)
-    readStop();
+  if (!ret) readStop();
 });
 
 source.on('end', function() {
@@ -69,8 +67,7 @@ function readStop() {
   reading = false;
   process.nextTick(function() {
     const r = stream.read();
-    if (r !== null)
-      writer.write(r);
+    if (r !== null) writer.write(r);
   });
 }
 
@@ -80,13 +77,14 @@ const writer = new Writable({
 
 const written = [];
 
-const expectWritten =
-  [ 'asdfgasdfgasdfgasdfg',
-    'asdfgasdfgasdfgasdfg',
-    'asdfgasdfgasdfgasdfg',
-    'asdfgasdfgasdfgasdfg',
-    'asdfgasdfgasdfgasdfg',
-    'asdfgasdfgasdfgasdfg' ];
+const expectWritten = [
+  'asdfgasdfgasdfgasdfg',
+  'asdfgasdfgasdfgasdfg',
+  'asdfgasdfgasdfgasdfg',
+  'asdfgasdfgasdfgasdfg',
+  'asdfgasdfgasdfgasdfg',
+  'asdfgasdfgasdfgasdfg'
+];
 
 writer._write = function(chunk, encoding, cb) {
   console.error(`WRITE ${chunk}`);
@@ -96,7 +94,6 @@ writer._write = function(chunk, encoding, cb) {
 
 writer.on('finish', finish);
 
-
 // now emit some chunks.
 
 const chunk = 'asdfg';
@@ -114,10 +111,8 @@ function data() {
   assert(reading);
   source.emit('data', chunk);
   assert(!reading);
-  if (set++ < 5)
-    setTimeout(data, 10);
-  else
-    end();
+  if (set++ < 5) setTimeout(data, 10);
+  else end();
 }
 
 function finish() {
diff --git a/test/parallel/test-stream2-read-sync-stack.js b/test/parallel/test-stream2-read-sync-stack.js
index e6a5ea7e52162f..34c89170f4cebf 100644
--- a/test/parallel/test-stream2-read-sync-stack.js
+++ b/test/parallel/test-stream2-read-sync-stack.js
@@ -36,8 +36,7 @@ r._read = function(n) {
 };
 
 r.on('readable', function onReadable() {
-  if (!(r.readableLength % 256))
-    console.error('readable', r.readableLength);
+  if (!(r.readableLength % 256)) console.error('readable', r.readableLength);
   r.read(N * 2);
 });
 
diff --git a/test/parallel/test-stream2-readable-empty-buffer-no-eof.js b/test/parallel/test-stream2-readable-empty-buffer-no-eof.js
index d2ef827b12ee89..1fa4c430d2450c 100644
--- a/test/parallel/test-stream2-readable-empty-buffer-no-eof.js
+++ b/test/parallel/test-stream2-readable-empty-buffer-no-eof.js
@@ -74,8 +74,7 @@ function test1() {
   const results = [];
   function flow() {
     let chunk;
-    while (null !== (chunk = r.read()))
-      results.push(String(chunk));
+    while (null !== (chunk = r.read())) results.push(String(chunk));
   }
   r.on('readable', flow);
   r.on('end', function() {
@@ -84,7 +83,7 @@ function test1() {
   flow();
 
   process.on('exit', function() {
-    assert.deepStrictEqual(results, [ 'xxxxx', 'xxxxx', 'EOF' ]);
+    assert.deepStrictEqual(results, ['xxxxx', 'xxxxx', 'EOF']);
     console.log('ok');
   });
 }
@@ -93,17 +92,15 @@ function test2() {
   const r = new Readable({ encoding: 'base64' });
   let reads = 5;
   r._read = function(n) {
-    if (!reads--)
-      return r.push(null); // EOF
-    else
-      return r.push(Buffer.from('x'));
+    if (!reads--) return r.push(null);
+    // EOF
+    else return r.push(Buffer.from('x'));
   };
 
   const results = [];
   function flow() {
     let chunk;
-    while (null !== (chunk = r.read()))
-      results.push(String(chunk));
+    while (null !== (chunk = r.read())) results.push(String(chunk));
   }
   r.on('readable', flow);
   r.on('end', function() {
@@ -112,7 +109,7 @@ function test2() {
   flow();
 
   process.on('exit', function() {
-    assert.deepStrictEqual(results, [ 'eHh4', 'eHg=', 'EOF' ]);
+    assert.deepStrictEqual(results, ['eHh4', 'eHg=', 'EOF']);
     console.log('ok');
   });
 }
diff --git a/test/parallel/test-stream2-readable-from-list.js b/test/parallel/test-stream2-readable-from-list.js
index 00024b91200fff..cd1993fa59f133 100644
--- a/test/parallel/test-stream2-readable-from-list.js
+++ b/test/parallel/test-stream2-readable-from-list.js
@@ -29,28 +29,30 @@ const util = require('util');
 
 function bufferListFromArray(arr) {
   const bl = new BufferList();
-  for (let i = 0; i < arr.length; ++i)
-    bl.push(arr[i]);
+  for (let i = 0; i < arr.length; ++i) bl.push(arr[i]);
   return bl;
 }
 
 {
   // Verify behavior with buffers
-  let list = [ Buffer.from('foog'),
-               Buffer.from('bark'),
-               Buffer.from('bazy'),
-               Buffer.from('kuel') ];
+  let list = [
+    Buffer.from('foog'),
+    Buffer.from('bark'),
+    Buffer.from('bazy'),
+    Buffer.from('kuel')
+  ];
   list = bufferListFromArray(list);
 
   assert.strictEqual(
-    util.inspect([ list ], { compact: false }),
+    util.inspect([list], { compact: false }),
     `[
   BufferList {
     head: [Object],
     tail: [Object],
     length: 4
   }
-]`);
+]`
+  );
 
   // read more than the first element.
   let ret = fromList(6, { buffer: list, length: 16 });
@@ -74,10 +76,7 @@ function bufferListFromArray(arr) {
 
 {
   // Verify behavior with strings
-  let list = [ 'foog',
-               'bark',
-               'bazy',
-               'kuel' ];
+  let list = ['foog', 'bark', 'bazy', 'kuel'];
   list = bufferListFromArray(list);
 
   // read more than the first element.
diff --git a/test/parallel/test-stream2-readable-wrap-empty.js b/test/parallel/test-stream2-readable-wrap-empty.js
index 1489717f3e49c3..0ae87e5f5cc61d 100644
--- a/test/parallel/test-stream2-readable-wrap-empty.js
+++ b/test/parallel/test-stream2-readable-wrap-empty.js
@@ -31,8 +31,6 @@ oldStream.resume = () => {};
 
 const newStream = new Readable().wrap(oldStream);
 
-newStream
-  .on('readable', () => {})
-  .on('end', common.mustCall());
+newStream.on('readable', () => {}).on('end', common.mustCall());
 
 oldStream.emit('end');
diff --git a/test/parallel/test-stream2-readable-wrap.js b/test/parallel/test-stream2-readable-wrap.js
index 0c9cb5861d936e..7dc9d7d42262e4 100644
--- a/test/parallel/test-stream2-readable-wrap.js
+++ b/test/parallel/test-stream2-readable-wrap.js
@@ -27,7 +27,6 @@ const Writable = require('_stream_writable');
 const EE = require('events').EventEmitter;
 
 function runTest(highWaterMark, objectMode, produce) {
-
   const old = new EE();
   const r = new Readable({ highWaterMark, objectMode });
   assert.strictEqual(r, r.wrap(old));
@@ -61,17 +60,19 @@ function runTest(highWaterMark, objectMode, produce) {
     }
   }
 
-  const w = new Writable({ highWaterMark: highWaterMark * 2,
-                           objectMode });
+  const w = new Writable({ highWaterMark: highWaterMark * 2, objectMode });
   const written = [];
   w._write = function(chunk, encoding, cb) {
     written.push(chunk);
     setTimeout(cb, 1);
   };
 
-  w.on('finish', common.mustCall(function() {
-    performAsserts();
-  }));
+  w.on(
+    'finish',
+    common.mustCall(function() {
+      performAsserts();
+    })
+  );
 
   r.pipe(w);
 
@@ -83,9 +84,17 @@ function runTest(highWaterMark, objectMode, produce) {
   }
 }
 
-runTest(100, false, function() { return Buffer.allocUnsafe(100); });
-runTest(10, false, function() { return Buffer.from('xxxxxxxxxx'); });
-runTest(1, true, function() { return { foo: 'bar' }; });
+runTest(100, false, function() {
+  return Buffer.allocUnsafe(100);
+});
+runTest(10, false, function() {
+  return Buffer.from('xxxxxxxxxx');
+});
+runTest(1, true, function() {
+  return { foo: 'bar' };
+});
 
-const objectChunks = [ 5, 'a', false, 0, '', 'xyz', { x: 4 }, 7, [], 555 ];
-runTest(1, true, function() { return objectChunks.shift(); });
+const objectChunks = [5, 'a', false, 0, '', 'xyz', { x: 4 }, 7, [], 555];
+runTest(1, true, function() {
+  return objectChunks.shift();
+});
diff --git a/test/parallel/test-stream2-set-encoding.js b/test/parallel/test-stream2-set-encoding.js
index f60e8df9e15a85..b75c44187c9e42 100644
--- a/test/parallel/test-stream2-set-encoding.js
+++ b/test/parallel/test-stream2-set-encoding.js
@@ -59,66 +59,71 @@ class TestReader extends R {
   const tr = new TestReader(100);
   tr.setEncoding('utf8');
   const out = [];
-  const expect =
-    [ 'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa' ];
+  const expect = [
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa'
+  ];
 
   tr.on('readable', function flow() {
     let chunk;
-    while (null !== (chunk = tr.read(10)))
-      out.push(chunk);
+    while (null !== (chunk = tr.read(10))) out.push(chunk);
   });
 
-  tr.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(out, expect);
-  }));
+  tr.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(out, expect);
+    })
+  );
 }
 
-
 {
   // Verify hex encoding
   const tr = new TestReader(100);
   tr.setEncoding('hex');
   const out = [];
-  const expect =
-    [ '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161' ];
+  const expect = [
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161'
+  ];
 
   tr.on('readable', function flow() {
     let chunk;
-    while (null !== (chunk = tr.read(10)))
-      out.push(chunk);
+    while (null !== (chunk = tr.read(10))) out.push(chunk);
   });
 
-  tr.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(out, expect);
-  }));
+  tr.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(out, expect);
+    })
+  );
 }
 
 {
@@ -126,33 +131,36 @@ class TestReader extends R {
   const tr = new TestReader(100);
   tr.setEncoding('hex');
   const out = [];
-  const expect =
-    [ '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '16161' ];
+  const expect = [
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '16161'
+  ];
 
   tr.on('readable', function flow() {
     let chunk;
-    while (null !== (chunk = tr.read(13)))
-      out.push(chunk);
+    while (null !== (chunk = tr.read(13))) out.push(chunk);
   });
 
-  tr.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(out, expect);
-  }));
+  tr.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(out, expect);
+    })
+  );
 }
 
 {
@@ -160,160 +168,174 @@ class TestReader extends R {
   const tr = new TestReader(100);
   tr.setEncoding('base64');
   const out = [];
-  const expect =
-    [ 'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYQ==' ];
+  const expect = [
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYQ=='
+  ];
 
   tr.on('readable', function flow() {
     let chunk;
-    while (null !== (chunk = tr.read(10)))
-      out.push(chunk);
+    while (null !== (chunk = tr.read(10))) out.push(chunk);
   });
 
-  tr.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(out, expect);
-  }));
+  tr.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(out, expect);
+    })
+  );
 }
 
 {
   // Verify utf8 encoding
   const tr = new TestReader(100, { encoding: 'utf8' });
   const out = [];
-  const expect =
-    [ 'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa',
-      'aaaaaaaaaa' ];
+  const expect = [
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa',
+    'aaaaaaaaaa'
+  ];
 
   tr.on('readable', function flow() {
     let chunk;
-    while (null !== (chunk = tr.read(10)))
-      out.push(chunk);
+    while (null !== (chunk = tr.read(10))) out.push(chunk);
   });
 
-  tr.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(out, expect);
-  }));
+  tr.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(out, expect);
+    })
+  );
 }
 
-
 {
   // Verify hex encoding
   const tr = new TestReader(100, { encoding: 'hex' });
   const out = [];
-  const expect =
-    [ '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161',
-      '6161616161' ];
+  const expect = [
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161',
+    '6161616161'
+  ];
 
   tr.on('readable', function flow() {
     let chunk;
-    while (null !== (chunk = tr.read(10)))
-      out.push(chunk);
+    while (null !== (chunk = tr.read(10))) out.push(chunk);
   });
 
-  tr.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(out, expect);
-  }));
+  tr.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(out, expect);
+    })
+  );
 }
 
 {
   // Verify hex encoding with read(13)
   const tr = new TestReader(100, { encoding: 'hex' });
   const out = [];
-  const expect =
-    [ '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '1616161616161',
-      '6161616161616',
-      '16161' ];
+  const expect = [
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '1616161616161',
+    '6161616161616',
+    '16161'
+  ];
 
   tr.on('readable', function flow() {
     let chunk;
-    while (null !== (chunk = tr.read(13)))
-      out.push(chunk);
+    while (null !== (chunk = tr.read(13))) out.push(chunk);
   });
 
-  tr.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(out, expect);
-  }));
+  tr.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(out, expect);
+    })
+  );
 }
 
 {
   // Verify base64 encoding
   const tr = new TestReader(100, { encoding: 'base64' });
   const out = [];
-  const expect =
-    [ 'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYWFhYWFh',
-      'YWFhYWFhYW',
-      'FhYQ==' ];
+  const expect = [
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYWFhYWFh',
+    'YWFhYWFhYW',
+    'FhYQ=='
+  ];
 
   tr.on('readable', function flow() {
     let chunk;
-    while (null !== (chunk = tr.read(10)))
-      out.push(chunk);
+    while (null !== (chunk = tr.read(10))) out.push(chunk);
   });
 
-  tr.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(out, expect);
-  }));
+  tr.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(out, expect);
+    })
+  );
 }
 
 {
diff --git a/test/parallel/test-stream2-transform.js b/test/parallel/test-stream2-transform.js
index 8484e8ddb74603..8b74d632f57039 100644
--- a/test/parallel/test-stream2-transform.js
+++ b/test/parallel/test-stream2-transform.js
@@ -46,9 +46,12 @@ const Transform = require('_stream_transform');
   assert.strictEqual(tx.readableLength, 10);
   assert.strictEqual(transformed, 10);
   assert.strictEqual(tx._transformState.writechunk.length, 5);
-  assert.deepStrictEqual(tx.writableBuffer.map(function(c) {
-    return c.chunk.length;
-  }), [6, 7, 8, 9, 10]);
+  assert.deepStrictEqual(
+    tx.writableBuffer.map(function(c) {
+      return c.chunk.length;
+    }),
+    [6, 7, 8, 9, 10]
+  );
 }
 
 {
@@ -166,12 +169,15 @@ const Transform = require('_stream_transform');
   pt.write(Buffer.from('kuel'));
   pt.end();
 
-  pt.on('finish', common.mustCall(function() {
-    assert.strictEqual(pt.read(5).toString(), 'foogb');
-    assert.strictEqual(pt.read(5).toString(), 'arkba');
-    assert.strictEqual(pt.read(5).toString(), 'zykue');
-    assert.strictEqual(pt.read(5).toString(), 'l');
-  }));
+  pt.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(pt.read(5).toString(), 'foogb');
+      assert.strictEqual(pt.read(5).toString(), 'arkba');
+      assert.strictEqual(pt.read(5).toString(), 'zykue');
+      assert.strictEqual(pt.read(5).toString(), 'l');
+    })
+  );
 }
 
 {
@@ -195,15 +201,18 @@ const Transform = require('_stream_transform');
   pt.write(Buffer.from('kuel'));
   pt.end();
 
-  pt.on('finish', common.mustCall(function() {
-    assert.strictEqual(pt.read(5).toString(), 'foogf');
-    assert.strictEqual(pt.read(5).toString(), 'oogba');
-    assert.strictEqual(pt.read(5).toString(), 'rkbar');
-    assert.strictEqual(pt.read(5).toString(), 'kbazy');
-    assert.strictEqual(pt.read(5).toString(), 'bazyk');
-    assert.strictEqual(pt.read(5).toString(), 'uelku');
-    assert.strictEqual(pt.read(5).toString(), 'el');
-  }));
+  pt.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(pt.read(5).toString(), 'foogf');
+      assert.strictEqual(pt.read(5).toString(), 'oogba');
+      assert.strictEqual(pt.read(5).toString(), 'rkbar');
+      assert.strictEqual(pt.read(5).toString(), 'kbazy');
+      assert.strictEqual(pt.read(5).toString(), 'bazyk');
+      assert.strictEqual(pt.read(5).toString(), 'uelku');
+      assert.strictEqual(pt.read(5).toString(), 'el');
+    })
+  );
 }
 
 {
@@ -215,8 +224,7 @@ const Transform = require('_stream_transform');
   pt.state = '';
 
   pt._transform = function(chunk, encoding, cb) {
-    if (!chunk)
-      chunk = '';
+    if (!chunk) chunk = '';
     const s = chunk.toString();
     setTimeout(() => {
       this.state += s.charAt(0);
@@ -252,11 +260,14 @@ const Transform = require('_stream_transform');
   pt.end();
 
   // 'abcdeabcdeabcd'
-  pt.on('finish', common.mustCall(function() {
-    assert.strictEqual(pt.read(5).toString(), 'abcde');
-    assert.strictEqual(pt.read(5).toString(), 'abcde');
-    assert.strictEqual(pt.read(5).toString(), 'abcd');
-  }));
+  pt.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(pt.read(5).toString(), 'abcde');
+      assert.strictEqual(pt.read(5).toString(), 'abcde');
+      assert.strictEqual(pt.read(5).toString(), 'abcd');
+    })
+  );
 }
 
 // this tests for a stall when data is written to a full stream
@@ -267,8 +278,7 @@ const Transform = require('_stream_transform');
   let saved = null;
   const pt = new Transform({ highWaterMark: 3 });
   pt._transform = function(c, e, cb) {
-    if (count++ === 1)
-      saved = c;
+    if (count++ === 1) saved = c;
     else {
       if (saved) {
         pt.push(saved);
@@ -283,9 +293,12 @@ const Transform = require('_stream_transform');
   pt.once('readable', function() {
     process.nextTick(function() {
       pt.write(Buffer.from('d'));
-      pt.write(Buffer.from('ef'), common.mustCall(function() {
-        pt.end();
-      }));
+      pt.write(
+        Buffer.from('ef'),
+        common.mustCall(function() {
+          pt.end();
+        })
+      );
       assert.strictEqual(pt.read().toString(), 'abcdef');
       assert.strictEqual(pt.read(), null);
     });
@@ -294,7 +307,6 @@ const Transform = require('_stream_transform');
   pt.write(Buffer.from('abc'));
 }
 
-
 {
   // Verify passthrough event emission
   const pt = new PassThrough();
@@ -343,22 +355,31 @@ const Transform = require('_stream_transform');
   assert.strictEqual(pt.read(5).toString(), 'foogb');
   assert.strictEqual(pt.read(5), null);
 
-  pt.once('readable', common.mustCall(function() {
-    assert.strictEqual(pt.read(5).toString(), 'arkba');
-    assert.strictEqual(pt.read(5), null);
-
-    pt.once('readable', common.mustCall(function() {
-      assert.strictEqual(pt.read(5).toString(), 'zykue');
+  pt.once(
+    'readable',
+    common.mustCall(function() {
+      assert.strictEqual(pt.read(5).toString(), 'arkba');
       assert.strictEqual(pt.read(5), null);
-      pt.once('readable', common.mustCall(function() {
-        assert.strictEqual(pt.read(5).toString(), 'l');
-        assert.strictEqual(pt.read(5), null);
-        assert.strictEqual(emits, 3);
-      }));
-      pt.end();
-    }));
-    pt.write(Buffer.from('kuel'));
-  }));
+
+      pt.once(
+        'readable',
+        common.mustCall(function() {
+          assert.strictEqual(pt.read(5).toString(), 'zykue');
+          assert.strictEqual(pt.read(5), null);
+          pt.once(
+            'readable',
+            common.mustCall(function() {
+              assert.strictEqual(pt.read(5).toString(), 'l');
+              assert.strictEqual(pt.read(5), null);
+              assert.strictEqual(emits, 3);
+            })
+          );
+          pt.end();
+        })
+      );
+      pt.write(Buffer.from('kuel'));
+    })
+  );
 
   pt.write(Buffer.from('bazy'));
 }
@@ -371,9 +392,12 @@ const Transform = require('_stream_transform');
     datas.push(chunk.toString());
   });
 
-  pt.on('end', common.mustCall(function() {
-    assert.deepStrictEqual(datas, ['foog', 'bark', 'bazy', 'kuel']);
-  }));
+  pt.on(
+    'end',
+    common.mustCall(function() {
+      assert.deepStrictEqual(datas, ['foog', 'bark', 'bazy', 'kuel']);
+    })
+  );
 
   pt.write(Buffer.from('foog'));
   setTimeout(function() {
@@ -408,7 +432,7 @@ const Transform = require('_stream_transform');
     { foo: 'bar' },
     100,
     'string',
-    { nested: { things: [ { foo: 'bar' }, 100, 'string' ] } }
+    { nested: { things: [{ foo: 'bar' }, 100, 'string'] } }
   ];
 
   let ended = false;
@@ -426,9 +450,11 @@ const Transform = require('_stream_transform');
   // read one more time to get the 'end' event
   jp.read();
 
-  process.nextTick(common.mustCall(function() {
-    assert.strictEqual(ended, true);
-  }));
+  process.nextTick(
+    common.mustCall(function() {
+      assert.strictEqual(ended, true);
+    })
+  );
 }
 
 {
@@ -449,7 +475,7 @@ const Transform = require('_stream_transform');
     { foo: 'bar' },
     100,
     'string',
-    { nested: { things: [ { foo: 'bar' }, 100, 'string' ] } }
+    { nested: { things: [{ foo: 'bar' }, 100, 'string'] } }
   ];
 
   let ended = false;
@@ -467,7 +493,9 @@ const Transform = require('_stream_transform');
   // read one more time to get the 'end' event
   js.read();
 
-  process.nextTick(common.mustCall(function() {
-    assert.strictEqual(ended, true);
-  }));
+  process.nextTick(
+    common.mustCall(function() {
+      assert.strictEqual(ended, true);
+    })
+  );
 }
diff --git a/test/parallel/test-stream2-unpipe-drain.js b/test/parallel/test-stream2-unpipe-drain.js
index 582ab61b06fb96..e28574181cf433 100644
--- a/test/parallel/test-stream2-unpipe-drain.js
+++ b/test/parallel/test-stream2-unpipe-drain.js
@@ -53,19 +53,16 @@ src1.pipe(dest);
 
 src1.once('readable', function() {
   process.nextTick(function() {
-
     src2.pipe(dest);
 
     src2.once('readable', function() {
       process.nextTick(function() {
-
         src1.unpipe(dest);
       });
     });
   });
 });
 
-
 process.on('exit', function() {
   assert.strictEqual(src1.reads, 2);
   assert.strictEqual(src2.reads, 2);
diff --git a/test/parallel/test-stream2-writable.js b/test/parallel/test-stream2-writable.js
index ec8e088221277f..c0d453e3f56c8f 100644
--- a/test/parallel/test-stream2-writable.js
+++ b/test/parallel/test-stream2-writable.js
@@ -54,10 +54,13 @@ for (let i = 0; i < chunks.length; i++) {
     highWaterMark: 100
   });
 
-  tw.on('finish', common.mustCall(function() {
-    // got chunks in the right order
-    assert.deepStrictEqual(tw.buffer, chunks);
-  }));
+  tw.on(
+    'finish',
+    common.mustCall(function() {
+      // got chunks in the right order
+      assert.deepStrictEqual(tw.buffer, chunks);
+    })
+  );
 
   chunks.forEach(function(chunk) {
     // Ignore backpressure. Just buffer it all up.
@@ -72,18 +75,19 @@ for (let i = 0; i < chunks.length; i++) {
     highWaterMark: 100
   });
 
-  tw.on('finish', common.mustCall(function() {
-    //  got chunks in the right order
-    assert.deepStrictEqual(tw.buffer, chunks);
-  }));
+  tw.on(
+    'finish',
+    common.mustCall(function() {
+      //  got chunks in the right order
+      assert.deepStrictEqual(tw.buffer, chunks);
+    })
+  );
 
   let i = 0;
   (function W() {
     tw.write(chunks[i++]);
-    if (i < chunks.length)
-      setTimeout(W, 10);
-    else
-      tw.end();
+    if (i < chunks.length) setTimeout(W, 10);
+    else tw.end();
   })();
 }
 
@@ -95,11 +99,14 @@ for (let i = 0; i < chunks.length; i++) {
 
   let drains = 0;
 
-  tw.on('finish', common.mustCall(function() {
-    // got chunks in the right order
-    assert.deepStrictEqual(tw.buffer, chunks);
-    assert.strictEqual(drains, 17);
-  }));
+  tw.on(
+    'finish',
+    common.mustCall(function() {
+      // got chunks in the right order
+      assert.deepStrictEqual(tw.buffer, chunks);
+      assert.strictEqual(drains, 17);
+    })
+  );
 
   tw.on('drain', function() {
     drains++;
@@ -127,19 +134,20 @@ for (let i = 0; i < chunks.length; i++) {
     highWaterMark: 100
   });
 
-  const encodings =
-    [ 'hex',
-      'utf8',
-      'utf-8',
-      'ascii',
-      'latin1',
-      'binary',
-      'base64',
-      'ucs2',
-      'ucs-2',
-      'utf16le',
-      'utf-16le',
-      undefined ];
+  const encodings = [
+    'hex',
+    'utf8',
+    'utf-8',
+    'ascii',
+    'latin1',
+    'binary',
+    'base64',
+    'ucs2',
+    'ucs-2',
+    'utf16le',
+    'utf-16le',
+    undefined
+  ];
 
   tw.on('finish', function() {
     // got the expected chunks
@@ -166,19 +174,20 @@ for (let i = 0; i < chunks.length; i++) {
     return TestWriter.prototype._write.call(this, chunk, encoding, cb);
   };
 
-  const encodings =
-    [ 'hex',
-      'utf8',
-      'utf-8',
-      'ascii',
-      'latin1',
-      'binary',
-      'base64',
-      'ucs2',
-      'ucs-2',
-      'utf16le',
-      'utf-16le',
-      undefined ];
+  const encodings = [
+    'hex',
+    'utf8',
+    'utf-8',
+    'ascii',
+    'latin1',
+    'binary',
+    'base64',
+    'ucs2',
+    'ucs-2',
+    'utf16le',
+    'utf-16le',
+    undefined
+  ];
 
   tw.on('finish', function() {
     // got the expected chunks
@@ -194,28 +203,38 @@ for (let i = 0; i < chunks.length; i++) {
 
 {
   // Verify write callbacks
-  const callbacks = chunks.map(function(chunk, i) {
-    return [i, function() {
-      callbacks._called[i] = chunk;
-    }];
-  }).reduce(function(set, x) {
-    set[`callback-${x[0]}`] = x[1];
-    return set;
-  }, {});
+  const callbacks = chunks
+    .map(function(chunk, i) {
+      return [
+        i,
+        function() {
+          callbacks._called[i] = chunk;
+        }
+      ];
+    })
+    .reduce(function(set, x) {
+      set[`callback-${x[0]}`] = x[1];
+      return set;
+    }, {});
   callbacks._called = [];
 
   const tw = new TestWriter({
     highWaterMark: 100
   });
 
-  tw.on('finish', common.mustCall(function() {
-    process.nextTick(common.mustCall(function() {
-      // got chunks in the right order
-      assert.deepStrictEqual(tw.buffer, chunks);
-      // called all callbacks
-      assert.deepStrictEqual(callbacks._called, chunks);
-    }));
-  }));
+  tw.on(
+    'finish',
+    common.mustCall(function() {
+      process.nextTick(
+        common.mustCall(function() {
+          // got chunks in the right order
+          assert.deepStrictEqual(tw.buffer, chunks);
+          // called all callbacks
+          assert.deepStrictEqual(callbacks._called, chunks);
+        })
+      );
+    })
+  );
 
   chunks.forEach(function(chunk, i) {
     tw.write(chunk, callbacks[`callback-${i}`]);
@@ -255,9 +274,11 @@ for (let i = 0; i < chunks.length; i++) {
   tw.write(Buffer.from('hello world'), function() {
     writeCalledback = true;
   });
-  tw.end(common.mustCall(function() {
-    assert.strictEqual(writeCalledback, true);
-  }));
+  tw.end(
+    common.mustCall(function() {
+      assert.strictEqual(writeCalledback, true);
+    })
+  );
 }
 
 {
@@ -309,9 +330,11 @@ for (let i = 0; i < chunks.length; i++) {
   });
   w.end('this is the end');
   w.end('and so is this');
-  process.nextTick(common.mustCall(function() {
-    assert.strictEqual(gotError, true);
-  }));
+  process.nextTick(
+    common.mustCall(function() {
+      assert.strictEqual(gotError, true);
+    })
+  );
 }
 
 {
@@ -327,9 +350,12 @@ for (let i = 0; i < chunks.length; i++) {
       cb();
     }, 1);
   };
-  w.on('finish', common.mustCall(function() {
-    assert.strictEqual(wrote, true);
-  }));
+  w.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(wrote, true);
+    })
+  );
   w.write(Buffer.alloc(0));
   w.end();
 }
@@ -344,9 +370,12 @@ for (let i = 0; i < chunks.length; i++) {
       cb();
     }, 10);
   };
-  w.on('finish', common.mustCall(function() {
-    assert.strictEqual(writeCb, true);
-  }));
+  w.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(writeCb, true);
+    })
+  );
   w.write(Buffer.alloc(0));
   w.end();
 }
@@ -358,9 +387,12 @@ for (let i = 0; i < chunks.length; i++) {
   w._write = function(chunk, e, cb) {
     cb();
   };
-  w.on('finish', common.mustCall(function() {
-    assert.strictEqual(writeCb, true);
-  }));
+  w.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(writeCb, true);
+    })
+  );
   w.write(Buffer.alloc(0), function() {
     writeCb = true;
   });
@@ -393,9 +425,12 @@ for (let i = 0; i < chunks.length; i++) {
   w._write = function(chunk, e, cb) {
     process.nextTick(cb);
   };
-  w.on('finish', common.mustCall(function() {
-    assert.strictEqual(shutdown, true);
-  }));
+  w.on(
+    'finish',
+    common.mustCall(function() {
+      assert.strictEqual(shutdown, true);
+    })
+  );
   w.write(Buffer.allocUnsafe(1));
   w.end(Buffer.allocUnsafe(0));
 }
diff --git a/test/parallel/test-stream3-pause-then-read.js b/test/parallel/test-stream3-pause-then-read.js
index 5de8d8ec512c2b..cbffefdac8a0ba 100644
--- a/test/parallel/test-stream3-pause-then-read.js
+++ b/test/parallel/test-stream3-pause-then-read.js
@@ -36,12 +36,9 @@ const r = new Readable({ highWaterMark: 1000 });
 let chunks = totalChunks;
 r._read = function(n) {
   console.log('_read called', chunks);
-  if (!(chunks % 2))
-    setImmediate(push);
-  else if (!(chunks % 3))
-    process.nextTick(push);
-  else
-    push();
+  if (!(chunks % 2)) setImmediate(push);
+  else if (!(chunks % 3)) process.nextTick(push);
+  else push();
 };
 
 let totalPushed = 0;
@@ -67,8 +64,7 @@ function readn(n, then) {
   (function read() {
     const c = r.read(n);
     console.error('c', c);
-    if (!c)
-      r.once('readable', read);
+    if (!c) r.once('readable', read);
     else {
       assert.strictEqual(c.length, n);
       assert(!r.readableFlowing);
@@ -151,7 +147,6 @@ function resumePause() {
   setImmediate(pipe);
 }
 
-
 function pipe() {
   console.error('pipe the rest');
   const w = new Writable();
diff --git a/test/parallel/test-streams-highwatermark.js b/test/parallel/test-streams-highwatermark.js
index 4dd9694a464272..8b3c5d0bd34e85 100644
--- a/test/parallel/test-streams-highwatermark.js
+++ b/test/parallel/test-streams-highwatermark.js
@@ -21,14 +21,16 @@ const stream = require('stream');
 
   for (const invalidHwm of [true, false, '5', {}, -5, NaN]) {
     for (const type of [stream.Readable, stream.Writable]) {
-      common.expectsError(() => {
-        type({ highWaterMark: invalidHwm });
-      }, {
-        type: TypeError,
-        code: 'ERR_INVALID_OPT_VALUE',
-        message:
-          `The value "${invalidHwm}" is invalid for option "highWaterMark"`
-      });
+      common.expectsError(
+        () => {
+          type({ highWaterMark: invalidHwm });
+        },
+        {
+          type: TypeError,
+          code: 'ERR_INVALID_OPT_VALUE',
+          message: `The value "${invalidHwm}" is invalid for option "highWaterMark"`
+        }
+      );
     }
   }
 }
diff --git a/test/parallel/test-string-decoder-end.js b/test/parallel/test-string-decoder-end.js
index c686b19b713d73..b9141d590be1f0 100644
--- a/test/parallel/test-string-decoder-end.js
+++ b/test/parallel/test-string-decoder-end.js
@@ -29,45 +29,48 @@ const assert = require('assert');
 const SD = require('string_decoder').StringDecoder;
 const encodings = ['base64', 'hex', 'utf8', 'utf16le', 'ucs2'];
 
-const bufs = [ '☃💩', 'asdf' ].map((b) => Buffer.from(b));
+const bufs = ['☃💩', 'asdf'].map((b) => Buffer.from(b));
 
 // also test just arbitrary bytes from 0-15.
 for (let i = 1; i <= 16; i++) {
-  const bytes = '.'.repeat(i - 1).split('.').map((_, j) => j + 0x78);
+  const bytes = '.'
+    .repeat(i - 1)
+    .split('.')
+    .map((_, j) => j + 0x78);
   bufs.push(Buffer.from(bytes));
 }
 
 encodings.forEach(testEncoding);
 
-testEnd('utf8', Buffer.of(0xE2), Buffer.of(0x61), '\uFFFDa');
-testEnd('utf8', Buffer.of(0xE2), Buffer.of(0x82), '\uFFFD\uFFFD');
-testEnd('utf8', Buffer.of(0xE2), Buffer.of(0xE2), '\uFFFD\uFFFD');
-testEnd('utf8', Buffer.of(0xE2, 0x82), Buffer.of(0x61), '\uFFFDa');
-testEnd('utf8', Buffer.of(0xE2, 0x82), Buffer.of(0xAC), '\uFFFD\uFFFD');
-testEnd('utf8', Buffer.of(0xE2, 0x82), Buffer.of(0xE2), '\uFFFD\uFFFD');
-testEnd('utf8', Buffer.of(0xE2, 0x82, 0xAC), Buffer.of(0x61), '€a');
+testEnd('utf8', Buffer.of(0xe2), Buffer.of(0x61), '\uFFFDa');
+testEnd('utf8', Buffer.of(0xe2), Buffer.of(0x82), '\uFFFD\uFFFD');
+testEnd('utf8', Buffer.of(0xe2), Buffer.of(0xe2), '\uFFFD\uFFFD');
+testEnd('utf8', Buffer.of(0xe2, 0x82), Buffer.of(0x61), '\uFFFDa');
+testEnd('utf8', Buffer.of(0xe2, 0x82), Buffer.of(0xac), '\uFFFD\uFFFD');
+testEnd('utf8', Buffer.of(0xe2, 0x82), Buffer.of(0xe2), '\uFFFD\uFFFD');
+testEnd('utf8', Buffer.of(0xe2, 0x82, 0xac), Buffer.of(0x61), '€a');
 
-testEnd('utf16le', Buffer.of(0x3D), Buffer.of(0x61, 0x00), 'a');
-testEnd('utf16le', Buffer.of(0x3D), Buffer.of(0xD8, 0x4D, 0xDC), '\u4DD8');
-testEnd('utf16le', Buffer.of(0x3D, 0xD8), Buffer.of(), '\uD83D');
-testEnd('utf16le', Buffer.of(0x3D, 0xD8), Buffer.of(0x61, 0x00), '\uD83Da');
+testEnd('utf16le', Buffer.of(0x3d), Buffer.of(0x61, 0x00), 'a');
+testEnd('utf16le', Buffer.of(0x3d), Buffer.of(0xd8, 0x4d, 0xdc), '\u4DD8');
+testEnd('utf16le', Buffer.of(0x3d, 0xd8), Buffer.of(), '\uD83D');
+testEnd('utf16le', Buffer.of(0x3d, 0xd8), Buffer.of(0x61, 0x00), '\uD83Da');
 testEnd(
   'utf16le',
-  Buffer.of(0x3D, 0xD8),
-  Buffer.of(0x4D, 0xDC),
+  Buffer.of(0x3d, 0xd8),
+  Buffer.of(0x4d, 0xdc),
   '\uD83D\uDC4D'
 );
-testEnd('utf16le', Buffer.of(0x3D, 0xD8, 0x4D), Buffer.of(), '\uD83D');
+testEnd('utf16le', Buffer.of(0x3d, 0xd8, 0x4d), Buffer.of(), '\uD83D');
 testEnd(
   'utf16le',
-  Buffer.of(0x3D, 0xD8, 0x4D),
+  Buffer.of(0x3d, 0xd8, 0x4d),
   Buffer.of(0x61, 0x00),
   '\uD83Da'
 );
-testEnd('utf16le', Buffer.of(0x3D, 0xD8, 0x4D), Buffer.of(0xDC), '\uD83D');
+testEnd('utf16le', Buffer.of(0x3d, 0xd8, 0x4d), Buffer.of(0xdc), '\uD83D');
 testEnd(
   'utf16le',
-  Buffer.of(0x3D, 0xD8, 0x4D, 0xDC),
+  Buffer.of(0x3d, 0xd8, 0x4d, 0xdc),
   Buffer.of(0x61, 0x00),
   '👍a'
 );
diff --git a/test/parallel/test-string-decoder-fuzz.js b/test/parallel/test-string-decoder-fuzz.js
index d8d01881591161..8a99006bef8596 100644
--- a/test/parallel/test-string-decoder-fuzz.js
+++ b/test/parallel/test-string-decoder-fuzz.js
@@ -14,14 +14,11 @@ function rand(max) {
 
 function randBuf(maxLen) {
   const buf = Buffer.allocUnsafe(rand(maxLen));
-  for (let i = 0; i < buf.length; i++)
-    buf[i] = rand(256);
+  for (let i = 0; i < buf.length; i++) buf[i] = rand(256);
   return buf;
 }
 
-const encodings = [
-  'utf16le', 'utf8', 'ascii', 'hex', 'base64', 'latin1'
-];
+const encodings = ['utf16le', 'utf8', 'ascii', 'hex', 'base64', 'latin1'];
 
 function runSingleFuzzTest() {
   const enc = encodings[rand(encodings.length)];
@@ -37,12 +34,14 @@ function runSingleFuzzTest() {
   }
   strings.push(sd.end());
 
-  assert.strictEqual(strings.join(''), Buffer.concat(bufs).toString(enc),
-                     `Mismatch:\n${util.inspect(strings)}\n` +
-                     util.inspect(bufs.map((buf) => buf.toString('hex'))) +
-                     `\nfor encoding ${enc}`);
+  assert.strictEqual(
+    strings.join(''),
+    Buffer.concat(bufs).toString(enc),
+    `Mismatch:\n${util.inspect(strings)}\n` +
+      util.inspect(bufs.map((buf) => buf.toString('hex'))) +
+      `\nfor encoding ${enc}`
+  );
 }
 
 const start = Date.now();
-while (Date.now() - start < 100)
-  runSingleFuzzTest();
+while (Date.now() - start < 100) runSingleFuzzTest();
diff --git a/test/parallel/test-string-decoder.js b/test/parallel/test-string-decoder.js
index c043795fc6ee5e..6668900d26d8d5 100644
--- a/test/parallel/test-string-decoder.js
+++ b/test/parallel/test-string-decoder.js
@@ -48,7 +48,7 @@ test('utf-8', Buffer.from('𤭢', 'utf-8'), '𤭢');
 // U+3045 -> E3 81 85
 test(
   'utf-8',
-  Buffer.from([0xCB, 0xA4, 0x64, 0xE1, 0x8B, 0xA4, 0x30, 0xE3, 0x81, 0x85]),
+  Buffer.from([0xcb, 0xa4, 0x64, 0xe1, 0x8b, 0xa4, 0x30, 0xe3, 0x81, 0x85]),
   '\u02e4\u0064\u12e4\u0030\u3045'
 );
 
@@ -77,8 +77,11 @@ test('utf-8', Buffer.from('CCB8CDB9', 'hex'), '\u0338\u0379');
 
 // V8 has changed their invalid UTF-8 handling, see
 // https://chromium-review.googlesource.com/c/v8/v8/+/671020 for more info.
-test('utf-8', Buffer.from('EDA0B5EDB08D', 'hex'),
-     '\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd');
+test(
+  'utf-8',
+  Buffer.from('EDA0B5EDB08D', 'hex'),
+  '\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd'
+);
 
 // UCS-2
 test('ucs2', Buffer.from('ababc', 'ucs2'), 'ababc');
@@ -101,10 +104,7 @@ assert.strictEqual(decoder.end(), '\ufffd');
 const arrayBufferViewStr = 'String for ArrayBufferView tests\n';
 const inputBuffer = Buffer.from(arrayBufferViewStr.repeat(8), 'utf8');
 for (const expectView of common.getArrayBufferViews(inputBuffer)) {
-  assert.strictEqual(
-    decoder.write(expectView),
-    inputBuffer.toString('utf8')
-  );
+  assert.strictEqual(decoder.write(expectView), inputBuffer.toString('utf8'));
   assert.strictEqual(decoder.end(), '');
 }
 
@@ -117,8 +117,10 @@ assert.strictEqual(decoder.write(Buffer.from('\ufffd')), '\ufffd');
 assert.strictEqual(decoder.end(), '');
 
 decoder = new StringDecoder('utf8');
-assert.strictEqual(decoder.write(Buffer.from('\ufffd\ufffd\ufffd')),
-                   '\ufffd\ufffd\ufffd');
+assert.strictEqual(
+  decoder.write(Buffer.from('\ufffd\ufffd\ufffd')),
+  '\ufffd\ufffd\ufffd'
+);
 assert.strictEqual(decoder.end(), '');
 
 decoder = new StringDecoder('utf8');
@@ -173,33 +175,25 @@ assert.strictEqual(decoder.write(Buffer.from('f4', 'hex')), '');
 assert.strictEqual(decoder.write(Buffer.from('bde5', 'hex')), '\ufffd\ufffd');
 assert.strictEqual(decoder.end(), '\ufffd');
 
-common.expectsError(
-  () => new StringDecoder(1),
-  {
-    code: 'ERR_UNKNOWN_ENCODING',
-    type: TypeError,
-    message: 'Unknown encoding: 1'
-  }
-);
+common.expectsError(() => new StringDecoder(1), {
+  code: 'ERR_UNKNOWN_ENCODING',
+  type: TypeError,
+  message: 'Unknown encoding: 1'
+});
 
-common.expectsError(
-  () => new StringDecoder('test'),
-  {
-    code: 'ERR_UNKNOWN_ENCODING',
-    type: TypeError,
-    message: 'Unknown encoding: test'
-  }
-);
+common.expectsError(() => new StringDecoder('test'), {
+  code: 'ERR_UNKNOWN_ENCODING',
+  type: TypeError,
+  message: 'Unknown encoding: test'
+});
 
-common.expectsError(
-  () => new StringDecoder('utf8').write(null),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "buf" argument must be one of type Buffer, TypedArray,' +
-      ' or DataView. Received type object'
-  }
-);
+common.expectsError(() => new StringDecoder('utf8').write(null), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "buf" argument must be one of type Buffer, TypedArray,' +
+    ' or DataView. Received type object'
+});
 
 // test verifies that StringDecoder will correctly decode the given input
 // buffer with the given encoding to the expected output. It will attempt all
diff --git a/test/parallel/test-stringbytes-external.js b/test/parallel/test-stringbytes-external.js
index 2a04159ce9db3c..5fb6eac6f708eb 100644
--- a/test/parallel/test-stringbytes-external.js
+++ b/test/parallel/test-stringbytes-external.js
@@ -23,13 +23,12 @@
 require('../common');
 const assert = require('assert');
 // minimum string size to overflow into external string space
-const EXTERN_APEX = 0xFBEE9;
+const EXTERN_APEX = 0xfbee9;
 
 // manually controlled string for checking binary output
 let ucs2_control = 'a\u0000';
 let write_str = 'a';
 
-
 // first do basic checks
 let b = Buffer.from(write_str, 'ucs2');
 // first check latin1
@@ -81,7 +80,6 @@ assert.strictEqual(c_bin.toString('ucs2'), c_ucs.toString('ucs2'));
 assert.strictEqual(c_bin.toString('latin1'), ucs2_control);
 assert.strictEqual(c_ucs.toString('latin1'), ucs2_control);
 
-
 // now let's test BASE64 and HEX encoding/decoding
 const RADIOS = 2;
 const PRE_HALF_APEX = Math.ceil(EXTERN_APEX / 2) - RADIOS;
@@ -131,7 +129,7 @@ const PRE_3OF4_APEX = Math.ceil((EXTERN_APEX / 4) * 3) - RADIOS;
 
 // https://github.com/nodejs/node/issues/1024
 {
-  const a = 'x'.repeat(1 << 20 - 1);
+  const a = 'x'.repeat(1 << (20 - 1));
   const b = Buffer.from(a, 'ucs2').toString('ucs2');
   const c = Buffer.from(b, 'utf8').toString('utf8');
 
diff --git a/test/parallel/test-sync-io-option.js b/test/parallel/test-sync-io-option.js
index 3dfe622963a0e2..d3ea32b9e0148b 100644
--- a/test/parallel/test-sync-io-option.js
+++ b/test/parallel/test-sync-io-option.js
@@ -9,7 +9,6 @@ if (process.argv[2] === 'child') {
     require('fs').readFileSync(__filename);
     process.exit();
   });
-
 } else {
   (function runTest(flags) {
     const execArgv = [flags.pop()];
@@ -20,8 +19,7 @@ if (process.argv[2] === 'child') {
     execFile(process.execPath, args, function(err, stdout, stderr) {
       assert.strictEqual(err, null);
       assert.strictEqual(stdout, '');
-      if (/WARNING[\s\S]*readFileSync/.test(stderr))
-        cntr++;
+      if (/WARNING[\s\S]*readFileSync/.test(stderr)) cntr++;
       if (args[0] === '--trace-sync-io') {
         assert.strictEqual(cntr, 1);
       } else if (args[0] === __filename) {
@@ -29,8 +27,7 @@ if (process.argv[2] === 'child') {
       } else {
         throw new Error('UNREACHABLE');
       }
-      if (flags.length > 0)
-        setImmediate(runTest, flags);
+      if (flags.length > 0) setImmediate(runTest, flags);
     });
-  }(['--trace-sync-io', '']));
+  })(['--trace-sync-io', '']);
 }
diff --git a/test/parallel/test-tcp-wrap-connect.js b/test/parallel/test-tcp-wrap-connect.js
index 5e3e81f6e11712..97bbca8f73cdba 100644
--- a/test/parallel/test-tcp-wrap-connect.js
+++ b/test/parallel/test-tcp-wrap-connect.js
@@ -3,18 +3,20 @@
 require('../common');
 const assert = require('assert');
 const { internalBinding } = require('internal/test/binding');
-const {
-  TCP,
-  constants: TCPConstants,
-  TCPConnectWrap
-} = internalBinding('tcp_wrap');
+const { TCP, constants: TCPConstants, TCPConnectWrap } = internalBinding(
+  'tcp_wrap'
+);
 const { ShutdownWrap } = internalBinding('stream_wrap');
 
 function makeConnection() {
   const client = new TCP(TCPConstants.SOCKET);
 
   const req = new TCPConnectWrap();
-  const err = client.connect(req, '127.0.0.1', this.address().port);
+  const err = client.connect(
+    req,
+    '127.0.0.1',
+    this.address().port
+  );
   assert.strictEqual(err, 0);
 
   req.oncomplete = function(status, client_, req_, readable, writable) {
diff --git a/test/parallel/test-tcp-wrap-listen.js b/test/parallel/test-tcp-wrap-listen.js
index 72981b683ccea3..2e27a0bde3f24e 100644
--- a/test/parallel/test-tcp-wrap-listen.js
+++ b/test/parallel/test-tcp-wrap-listen.js
@@ -54,10 +54,8 @@ server.onconnection = (err, client) => {
       // 11 bytes should flush
       assert.strictEqual(client.writeQueueSize, 0);
 
-      if (req.async)
-        req.oncomplete = common.mustCall(done);
-      else
-        process.nextTick(done.bind(null, 0, client, req));
+      if (req.async) req.oncomplete = common.mustCall(done);
+      else process.nextTick(done.bind(null, 0, client, req));
 
       function done(status, client_, req_) {
         assert.strictEqual(client.pendingWrites.shift(), req);
@@ -72,7 +70,6 @@ server.onconnection = (err, client) => {
 
         maybeCloseClient();
       }
-
     } else {
       console.log('eof');
       client.gotEOF = true;
@@ -86,12 +83,20 @@ const net = require('net');
 
 const c = net.createConnection(port);
 
-c.on('connect', common.mustCall(() => { c.end('hello world'); }));
+c.on(
+  'connect',
+  common.mustCall(() => {
+    c.end('hello world');
+  })
+);
 
 c.setEncoding('utf8');
-c.on('data', common.mustCall((d) => {
-  assert.strictEqual(d, 'hello world');
-}));
+c.on(
+  'data',
+  common.mustCall((d) => {
+    assert.strictEqual(d, 'hello world');
+  })
+);
 
 c.on('close', () => {
   console.error('client closed');
diff --git a/test/parallel/test-tick-processor-arguments.js b/test/parallel/test-tick-processor-arguments.js
index 606dbd03c8f6c4..a63d930c98c02c 100644
--- a/test/parallel/test-tick-processor-arguments.js
+++ b/test/parallel/test-tick-processor-arguments.js
@@ -5,18 +5,15 @@ const fs = require('fs');
 const assert = require('assert');
 const { spawnSync } = require('child_process');
 
-if (!common.isMainThread)
-  common.skip('chdir not available in workers');
-if (!common.enoughTestMem)
-  common.skip('skipped due to memory requirements');
-if (common.isAIX)
-  common.skip('does not work on AIX');
+if (!common.isMainThread) common.skip('chdir not available in workers');
+if (!common.enoughTestMem) common.skip('skipped due to memory requirements');
+if (common.isAIX) common.skip('does not work on AIX');
 
 tmpdir.refresh();
 process.chdir(tmpdir.path);
 
 // Generate log file.
-spawnSync(process.execPath, [ '--prof', '-p', '42' ]);
+spawnSync(process.execPath, ['--prof', '-p', '42']);
 
 const logfile = fs.readdirSync('.').filter((name) => name.endsWith('.log'))[0];
 assert(logfile);
@@ -27,8 +24,9 @@ assert(logfile);
 // is ever removed.
 const { stdout } = spawnSync(
   process.execPath,
-  [ '--prof-process', '--preprocess', logfile ],
-  { encoding: 'utf8' });
+  ['--prof-process', '--preprocess', logfile],
+  { encoding: 'utf8' }
+);
 
 // Make sure that the result is valid JSON.
 JSON.parse(stdout);
diff --git a/test/parallel/test-tick-processor-version-check.js b/test/parallel/test-tick-processor-version-check.js
index b253adfb59b6f3..33bc8b97fc9d05 100644
--- a/test/parallel/test-tick-processor-version-check.js
+++ b/test/parallel/test-tick-processor-version-check.js
@@ -8,17 +8,26 @@ assert.strictEqual(versionCheck('v8-version,1,2,3,4,0', '1.2.3'), undefined);
 assert.strictEqual(versionCheck('v8-version,1,2,3,4,0', '1.2.3.3'), undefined);
 assert.strictEqual(versionCheck('v8-version,1,2,3,4,0', '1.2.3.4'), undefined);
 assert.strictEqual(versionCheck('v8-version,1,2,3,4,0', '1.2.3.5'), undefined);
-assert.strictEqual(versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3'),
-                   undefined);
-assert.strictEqual(versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3.4'),
-                   undefined);
-assert.strictEqual(versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3-node.1'),
-                   undefined);
-assert.strictEqual(versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3-node.2'),
-                   undefined);
+assert.strictEqual(
+  versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3'),
+  undefined
+);
+assert.strictEqual(
+  versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3.4'),
+  undefined
+);
+assert.strictEqual(
+  versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3-node.1'),
+  undefined
+);
+assert.strictEqual(
+  versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3-node.2'),
+  undefined
+);
 assert.strictEqual(
   versionCheck('v8-version,1,2,3,4,-node.1,0', '1.2.3.4-node.2'),
-  undefined);
+  undefined
+);
 
 {
   const expected = 'Unable to read v8-version from log file.';
@@ -28,8 +37,10 @@ assert.strictEqual(
   assert.strictEqual(versionCheck('v8-version,1,2', '1.2.3'), expected);
   assert.strictEqual(versionCheck('v8-version,1,2,3', '1.2.3'), expected);
   assert.strictEqual(versionCheck('v8-version,1,2,3,4', '1.2.3'), expected);
-  assert.strictEqual(versionCheck('v8-version,1,2,3,4,5,6,7', '1.2.3'),
-                     expected);
+  assert.strictEqual(
+    versionCheck('v8-version,1,2,3,4,5,6,7', '1.2.3'),
+    expected
+  );
 }
 
 {
diff --git a/test/parallel/test-timer-immediate.js b/test/parallel/test-timer-immediate.js
index b0f52db1b713d3..4b975fd3150f89 100644
--- a/test/parallel/test-timer-immediate.js
+++ b/test/parallel/test-timer-immediate.js
@@ -1,5 +1,5 @@
 'use strict';
 const common = require('../common');
-global.process = {};  // Boom!
+global.process = {}; // Boom!
 common.allowGlobals(global.process);
 setImmediate(common.mustCall());
diff --git a/test/parallel/test-timers-active.js b/test/parallel/test-timers-active.js
index a98d32c0b042d1..f4abd09eb72060 100644
--- a/test/parallel/test-timers-active.js
+++ b/test/parallel/test-timers-active.js
@@ -4,10 +4,7 @@ const assert = require('assert');
 const active = require('timers').active;
 
 // active() should create timers for these
-const legitTimers = [
-  { _idleTimeout: 0 },
-  { _idleTimeout: 1 }
-];
+const legitTimers = [{ _idleTimeout: 0 }, { _idleTimeout: 1 }];
 
 legitTimers.forEach(function(legit) {
   const savedTimeout = legit._idleTimeout;
@@ -19,12 +16,8 @@ legitTimers.forEach(function(legit) {
   assert(legit._idlePrev);
 });
 
-
 // active() should not create a timer for these
-const bogusTimers = [
-  { _idleTimeout: -1 },
-  { _idleTimeout: undefined },
-];
+const bogusTimers = [{ _idleTimeout: -1 }, { _idleTimeout: undefined }];
 
 bogusTimers.forEach(function(bogus) {
   const savedTimeout = bogus._idleTimeout;
diff --git a/test/parallel/test-timers-api-refs.js b/test/parallel/test-timers-api-refs.js
index c062369444b1e0..6ec79aaa5d48a3 100644
--- a/test/parallel/test-timers-api-refs.js
+++ b/test/parallel/test-timers-api-refs.js
@@ -11,11 +11,17 @@ delete global.clearInterval;
 delete global.setImmediate;
 delete global.clearImmediate;
 
-const timeoutCallback = () => { timers.clearTimeout(timeout); };
+const timeoutCallback = () => {
+  timers.clearTimeout(timeout);
+};
 const timeout = timers.setTimeout(common.mustCall(timeoutCallback), 1);
 
-const intervalCallback = () => { timers.clearInterval(interval); };
+const intervalCallback = () => {
+  timers.clearInterval(interval);
+};
 const interval = timers.setInterval(common.mustCall(intervalCallback), 1);
 
-const immediateCallback = () => { timers.clearImmediate(immediate); };
+const immediateCallback = () => {
+  timers.clearImmediate(immediate);
+};
 const immediate = timers.setImmediate(immediateCallback);
diff --git a/test/parallel/test-timers-args.js b/test/parallel/test-timers-args.js
index 1ba44d8bcf3664..f6d3d30237085f 100644
--- a/test/parallel/test-timers-args.js
+++ b/test/parallel/test-timers-args.js
@@ -3,7 +3,12 @@ require('../common');
 const assert = require('assert');
 
 function range(n) {
-  return 'x'.repeat(n + 1).split('').map(function(_, i) { return i; });
+  return 'x'
+    .repeat(n + 1)
+    .split('')
+    .map(function(_, i) {
+      return i;
+    });
 }
 
 function timeout(nargs) {
diff --git a/test/parallel/test-timers-enroll-invalid-msecs.js b/test/parallel/test-timers-enroll-invalid-msecs.js
index 384ab0ab257908..51c0c80df3a271 100644
--- a/test/parallel/test-timers-enroll-invalid-msecs.js
+++ b/test/parallel/test-timers-enroll-invalid-msecs.js
@@ -3,35 +3,20 @@
 const common = require('../common');
 const timers = require('timers');
 
-[
-  {},
-  [],
-  'foo',
-  () => { },
-  Symbol('foo')
-].forEach((val) => {
-  common.expectsError(
-    () => timers.enroll({}, val),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    }
-  );
+[{}, [], 'foo', () => {}, Symbol('foo')].forEach((val) => {
+  common.expectsError(() => timers.enroll({}, val), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 });
 
-[
-  -1,
-  Infinity,
-  NaN
-].forEach((val) => {
-  common.expectsError(
-    () => timers.enroll({}, val),
-    {
-      code: 'ERR_OUT_OF_RANGE',
-      type: RangeError,
-      message: 'The value of "msecs" is out of range. ' +
-               'It must be a non-negative finite number. ' +
-               `Received ${val}`
-    }
-  );
+[-1, Infinity, NaN].forEach((val) => {
+  common.expectsError(() => timers.enroll({}, val), {
+    code: 'ERR_OUT_OF_RANGE',
+    type: RangeError,
+    message:
+      'The value of "msecs" is out of range. ' +
+      'It must be a non-negative finite number. ' +
+      `Received ${val}`
+  });
 });
diff --git a/test/parallel/test-timers-enroll-second-time.js b/test/parallel/test-timers-enroll-second-time.js
index a914e6c4a18a98..3ff8c44d74c7ae 100644
--- a/test/parallel/test-timers-enroll-second-time.js
+++ b/test/parallel/test-timers-enroll-second-time.js
@@ -6,7 +6,7 @@ const assert = require('assert');
 const timers = require('timers');
 
 const enrollObj = {
-  _onTimeout: common.mustCall(),
+  _onTimeout: common.mustCall()
 };
 
 timers.enroll(enrollObj, 1);
diff --git a/test/parallel/test-timers-immediate-queue-throw.js b/test/parallel/test-timers-immediate-queue-throw.js
index 9929b27ab2fea3..878ad0d26a757f 100644
--- a/test/parallel/test-timers-immediate-queue-throw.js
+++ b/test/parallel/test-timers-immediate-queue-throw.js
@@ -33,21 +33,20 @@ d1.once('error', () => assert.strictEqual(stage, 0));
 const run = common.mustCall((callStage) => {
   assert(callStage >= stage);
   stage = callStage;
-  if (threw)
-    return;
+  if (threw) return;
 
   setImmediate(run, 2);
 }, QUEUE * 3);
 
-for (let i = 0; i < QUEUE; i++)
-  setImmediate(run, 0);
+for (let i = 0; i < QUEUE; i++) setImmediate(run, 0);
 setImmediate(() => {
   threw = true;
   process.nextTick(() => assert.strictEqual(stage, 1));
   throw new Error('setImmediate Err');
 });
-d1.run(() => setImmediate(() => {
-  throw new Error('setImmediate Err');
-}));
-for (let i = 0; i < QUEUE; i++)
-  setImmediate(run, 1);
+d1.run(() =>
+  setImmediate(() => {
+    throw new Error('setImmediate Err');
+  })
+);
+for (let i = 0; i < QUEUE; i++) setImmediate(run, 1);
diff --git a/test/parallel/test-timers-immediate-queue.js b/test/parallel/test-timers-immediate-queue.js
index dd793eead03438..f477f42baeedbb 100644
--- a/test/parallel/test-timers-immediate-queue.js
+++ b/test/parallel/test-timers-immediate-queue.js
@@ -37,7 +37,9 @@ const QUEUE = 10;
 
 function run() {
   if (hit === 0) {
-    setTimeout(() => { ticked = true; }, 1);
+    setTimeout(() => {
+      ticked = true;
+    }, 1);
     const now = Date.now();
     while (Date.now() - now < 2);
   }
@@ -48,8 +50,7 @@ function run() {
   setImmediate(run);
 }
 
-for (let i = 0; i < QUEUE; i++)
-  setImmediate(run);
+for (let i = 0; i < QUEUE; i++) setImmediate(run);
 
 process.on('exit', function() {
   console.log('hit', hit);
diff --git a/test/parallel/test-timers-immediate-unref.js b/test/parallel/test-timers-immediate-unref.js
index ecb26682c1e1bb..04474c25338636 100644
--- a/test/parallel/test-timers-immediate-unref.js
+++ b/test/parallel/test-timers-immediate-unref.js
@@ -13,11 +13,17 @@ clearImmediate(immediate);
 
 // This immediate should execute as it was unrefed and refed again.
 // It also confirms that unref/ref are chainable.
-setImmediate(common.mustCall(firstStep)).ref().unref().unref().ref();
+setImmediate(common.mustCall(firstStep))
+  .ref()
+  .unref()
+  .unref()
+  .ref();
 
 function firstStep() {
-  const countdown =
-    new Countdown(2, common.mustCall(() => setImmediate(secondStep)));
+  const countdown = new Countdown(
+    2,
+    common.mustCall(() => setImmediate(secondStep))
+  );
   // Unrefed setImmediate executes if it was unrefed but something else keeps
   // the loop open
   setImmediate(() => countdown.dec()).unref();
diff --git a/test/parallel/test-timers-immediate.js b/test/parallel/test-timers-immediate.js
index 0227e38efa9b20..42784af842cf42 100644
--- a/test/parallel/test-timers-immediate.js
+++ b/test/parallel/test-timers-immediate.js
@@ -25,19 +25,33 @@ const assert = require('assert');
 
 let mainFinished = false;
 
-setImmediate(common.mustCall(function() {
-  assert.strictEqual(mainFinished, true);
-  clearImmediate(immediateB);
-}));
+setImmediate(
+  common.mustCall(function() {
+    assert.strictEqual(mainFinished, true);
+    clearImmediate(immediateB);
+  })
+);
 
 const immediateB = setImmediate(common.mustNotCall());
 
-setImmediate(common.mustCall((...args) => {
-  assert.deepStrictEqual(args, [1, 2, 3]);
-}), 1, 2, 3);
+setImmediate(
+  common.mustCall((...args) => {
+    assert.deepStrictEqual(args, [1, 2, 3]);
+  }),
+  1,
+  2,
+  3
+);
 
-setImmediate(common.mustCall((...args) => {
-  assert.deepStrictEqual(args, [1, 2, 3, 4, 5]);
-}), 1, 2, 3, 4, 5);
+setImmediate(
+  common.mustCall((...args) => {
+    assert.deepStrictEqual(args, [1, 2, 3, 4, 5]);
+  }),
+  1,
+  2,
+  3,
+  4,
+  5
+);
 
 mainFinished = true;
diff --git a/test/parallel/test-timers-interval-throw.js b/test/parallel/test-timers-interval-throw.js
index 876f0de55aa27e..dbb037a2534a81 100644
--- a/test/parallel/test-timers-interval-throw.js
+++ b/test/parallel/test-timers-interval-throw.js
@@ -7,11 +7,16 @@ const assert = require('assert');
 // being rescheduled even if it throws.
 
 let count = 2;
-const interval = setInterval(() => { throw new Error('IntervalError'); }, 1);
+const interval = setInterval(() => {
+  throw new Error('IntervalError');
+}, 1);
 
-process.on('uncaughtException', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'IntervalError');
-  if (--count === 0) {
-    clearInterval(interval);
-  }
-}, 2));
+process.on(
+  'uncaughtException',
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'IntervalError');
+    if (--count === 0) {
+      clearInterval(interval);
+    }
+  }, 2)
+);
diff --git a/test/parallel/test-timers-linked-list.js b/test/parallel/test-timers-linked-list.js
index c7601462f65e31..2363ba3244c201 100644
--- a/test/parallel/test-timers-linked-list.js
+++ b/test/parallel/test-timers-linked-list.js
@@ -33,7 +33,6 @@ const B = { name: 'B' };
 const C = { name: 'C' };
 const D = { name: 'D' };
 
-
 L.init(list);
 L.init(A);
 L.init(B);
@@ -83,10 +82,8 @@ L.remove(D);
 // list
 assert.strictEqual(L.peek(list), null);
 
-
 assert.ok(L.isEmpty(list));
 
-
 L.append(list, D);
 // list -> D
 assert.strictEqual(L.peek(list), D);
diff --git a/test/parallel/test-timers-max-duration-warning.js b/test/parallel/test-timers-max-duration-warning.js
index c978cf29c3fe4d..18147952426b41 100644
--- a/test/parallel/test-timers-max-duration-warning.js
+++ b/test/parallel/test-timers-max-duration-warning.js
@@ -10,17 +10,21 @@ function timerNotCanceled() {
   assert.fail('Timer should be canceled');
 }
 
-process.on('warning', common.mustCall((warning) => {
-  if (warning.name === 'DeprecationWarning') return;
-
-  const lines = warning.message.split('\n');
-
-  assert.strictEqual(warning.name, 'TimeoutOverflowWarning');
-  assert.strictEqual(lines[0], `${OVERFLOW} does not fit into a 32-bit signed` +
-                               ' integer.');
-  assert.strictEqual(lines.length, 2);
-}, 5));
-
+process.on(
+  'warning',
+  common.mustCall((warning) => {
+    if (warning.name === 'DeprecationWarning') return;
+
+    const lines = warning.message.split('\n');
+
+    assert.strictEqual(warning.name, 'TimeoutOverflowWarning');
+    assert.strictEqual(
+      lines[0],
+      `${OVERFLOW} does not fit into a 32-bit signed` + ' integer.'
+    );
+    assert.strictEqual(lines.length, 2);
+  }, 5)
+);
 
 {
   const timeout = setTimeout(timerNotCanceled, OVERFLOW);
diff --git a/test/parallel/test-timers-next-tick.js b/test/parallel/test-timers-next-tick.js
index 89ebf6c8c1a9d7..cc66a84c6dfcd4 100644
--- a/test/parallel/test-timers-next-tick.js
+++ b/test/parallel/test-timers-next-tick.js
@@ -5,26 +5,31 @@ const common = require('../common');
 // This test verifies that the next tick queue runs after each
 // individual Timeout, as well as each individual Immediate.
 
-setTimeout(common.mustCall(() => {
-  process.nextTick(() => {
-    // Confirm that clearing Timeouts from a next tick doesn't explode.
-    clearTimeout(t2);
-    clearTimeout(t3);
-  });
-}), 1);
+setTimeout(
+  common.mustCall(() => {
+    process.nextTick(() => {
+      // Confirm that clearing Timeouts from a next tick doesn't explode.
+      clearTimeout(t2);
+      clearTimeout(t3);
+    });
+  }),
+  1
+);
 const t2 = setTimeout(common.mustNotCall(), 1);
 const t3 = setTimeout(common.mustNotCall(), 1);
 setTimeout(common.mustCall(), 1);
 
 common.busyLoop(5);
 
-setImmediate(common.mustCall(() => {
-  process.nextTick(() => {
-    // Confirm that clearing Immediates from a next tick doesn't explode.
-    clearImmediate(i2);
-    clearImmediate(i3);
-  });
-}));
+setImmediate(
+  common.mustCall(() => {
+    process.nextTick(() => {
+      // Confirm that clearing Immediates from a next tick doesn't explode.
+      clearImmediate(i2);
+      clearImmediate(i3);
+    });
+  })
+);
 const i2 = setImmediate(common.mustNotCall());
 const i3 = setImmediate(common.mustNotCall());
 setImmediate(common.mustCall());
diff --git a/test/parallel/test-timers-non-integer-delay.js b/test/parallel/test-timers-non-integer-delay.js
index 017ef28d0f86ef..c7b1c1158c1baf 100644
--- a/test/parallel/test-timers-non-integer-delay.js
+++ b/test/parallel/test-timers-non-integer-delay.js
@@ -41,9 +41,12 @@ const common = require('../common');
 const TIMEOUT_DELAY = 1.1;
 let N = 50;
 
-const interval = setInterval(common.mustCall(() => {
-  if (--N === 0) {
-    clearInterval(interval);
-    process.exit(0);
-  }
-}, N), TIMEOUT_DELAY);
+const interval = setInterval(
+  common.mustCall(() => {
+    if (--N === 0) {
+      clearInterval(interval);
+      process.exit(0);
+    }
+  }, N),
+  TIMEOUT_DELAY
+);
diff --git a/test/parallel/test-timers-ordering.js b/test/parallel/test-timers-ordering.js
index e163ea55bf2dd8..a0d77ec737fa0c 100644
--- a/test/parallel/test-timers-ordering.js
+++ b/test/parallel/test-timers-ordering.js
@@ -40,8 +40,7 @@ function f(i) {
 
     // check that this iteration is fired at least 1ms later than the previous
     const now = getLibuvNow();
-    assert(now >= last_ts + 1,
-           `current ts ${now} < prev ts ${last_ts} + 1`);
+    assert(now >= last_ts + 1, `current ts ${now} < prev ts ${last_ts} + 1`);
     last_ts = now;
 
     // schedule next iteration
diff --git a/test/parallel/test-timers-promisified.js b/test/parallel/test-timers-promisified.js
index 85e7093cfa185f..c1d6b0075b6d1c 100644
--- a/test/parallel/test-timers-promisified.js
+++ b/test/parallel/test-timers-promisified.js
@@ -11,28 +11,36 @@ const setImmediate = promisify(timers.setImmediate);
 
 {
   const promise = setTimeout(1);
-  promise.then(common.mustCall((value) => {
-    assert.strictEqual(value, undefined);
-  }));
+  promise.then(
+    common.mustCall((value) => {
+      assert.strictEqual(value, undefined);
+    })
+  );
 }
 
 {
   const promise = setTimeout(1, 'foobar');
-  promise.then(common.mustCall((value) => {
-    assert.strictEqual(value, 'foobar');
-  }));
+  promise.then(
+    common.mustCall((value) => {
+      assert.strictEqual(value, 'foobar');
+    })
+  );
 }
 
 {
   const promise = setImmediate();
-  promise.then(common.mustCall((value) => {
-    assert.strictEqual(value, undefined);
-  }));
+  promise.then(
+    common.mustCall((value) => {
+      assert.strictEqual(value, undefined);
+    })
+  );
 }
 
 {
   const promise = setImmediate('foobar');
-  promise.then(common.mustCall((value) => {
-    assert.strictEqual(value, 'foobar');
-  }));
+  promise.then(
+    common.mustCall((value) => {
+      assert.strictEqual(value, 'foobar');
+    })
+  );
 }
diff --git a/test/parallel/test-timers-refresh.js b/test/parallel/test-timers-refresh.js
index 2c47be8d8d15ae..d9a84cf2e160c7 100644
--- a/test/parallel/test-timers-refresh.js
+++ b/test/parallel/test-timers-refresh.js
@@ -16,16 +16,22 @@ const { setUnrefTimeout } = require('internal/timers');
 // unref()'d timer
 {
   let called = false;
-  const timer = setTimeout(common.mustCall(() => {
-    called = true;
-  }), 1);
+  const timer = setTimeout(
+    common.mustCall(() => {
+      called = true;
+    }),
+    1
+  );
   timer.unref();
 
   // This relies on implicit timers handle sorting withing libuv.
 
-  setTimeout(common.mustCall(() => {
-    strictEqual(called, false, 'unref()\'d timer returned before check');
-  }), 1);
+  setTimeout(
+    common.mustCall(() => {
+      strictEqual(called, false, "unref()'d timer returned before check");
+    }),
+    1
+  );
 
   strictEqual(timer.refresh(), timer);
 }
@@ -33,13 +39,19 @@ const { setUnrefTimeout } = require('internal/timers');
 // unref pooled timer
 {
   let called = false;
-  const timer = setUnrefTimeout(common.mustCall(() => {
-    called = true;
-  }), 1);
-
-  setUnrefTimeout(common.mustCall(() => {
-    strictEqual(called, false, 'unref pooled timer returned before check');
-  }), 1);
+  const timer = setUnrefTimeout(
+    common.mustCall(() => {
+      called = true;
+    }),
+    1
+  );
+
+  setUnrefTimeout(
+    common.mustCall(() => {
+      strictEqual(called, false, 'unref pooled timer returned before check');
+    }),
+    1
+  );
 
   strictEqual(timer.refresh(), timer);
 }
@@ -47,13 +59,19 @@ const { setUnrefTimeout } = require('internal/timers');
 // regular timer
 {
   let called = false;
-  const timer = setTimeout(common.mustCall(() => {
-    called = true;
-  }), 1);
-
-  setTimeout(common.mustCall(() => {
-    strictEqual(called, false, 'pooled timer returned before check');
-  }), 1);
+  const timer = setTimeout(
+    common.mustCall(() => {
+      called = true;
+    }),
+    1
+  );
+
+  setTimeout(
+    common.mustCall(() => {
+      strictEqual(called, false, 'pooled timer returned before check');
+    }),
+    1
+  );
 
   strictEqual(timer.refresh(), timer);
 }
@@ -61,16 +79,22 @@ const { setUnrefTimeout } = require('internal/timers');
 // interval
 {
   let called = 0;
-  const timer = setInterval(common.mustCall(() => {
-    called += 1;
-    if (called === 2) {
-      clearInterval(timer);
-    }
-  }, 2), 1);
-
-  setTimeout(common.mustCall(() => {
-    strictEqual(called, 0, 'pooled timer returned before check');
-  }), 1);
+  const timer = setInterval(
+    common.mustCall(() => {
+      called += 1;
+      if (called === 2) {
+        clearInterval(timer);
+      }
+    }, 2),
+    1
+  );
+
+  setTimeout(
+    common.mustCall(() => {
+      strictEqual(called, 0, 'pooled timer returned before check');
+    }),
+    1
+  );
 
   strictEqual(timer.refresh(), timer);
 }
diff --git a/test/parallel/test-timers-reset-process-domain-on-throw.js b/test/parallel/test-timers-reset-process-domain-on-throw.js
index 946ae715b0e193..5add6be67b3d98 100644
--- a/test/parallel/test-timers-reset-process-domain-on-throw.js
+++ b/test/parallel/test-timers-reset-process-domain-on-throw.js
@@ -36,8 +36,10 @@ function secondTimer() {
   // secondTimer was scheduled before any domain had been created, so its
   // callback should not have any active domain set when it runs.
   if (process.domain !== null) {
-    console.log('process.domain should be null in this timer callback, but is:',
-                process.domain);
+    console.log(
+      'process.domain should be null in this timer callback, but is:',
+      process.domain
+    );
     // Do not use assert here, as it throws errors and if a domain with an error
     // handler is active, then asserting wouldn't make the test fail.
     process.exit(1);
diff --git a/test/parallel/test-timers-same-timeout-wrong-list-deleted.js b/test/parallel/test-timers-same-timeout-wrong-list-deleted.js
index 3e04cb6c4cbc42..c96f2637f49d8d 100644
--- a/test/parallel/test-timers-same-timeout-wrong-list-deleted.js
+++ b/test/parallel/test-timers-same-timeout-wrong-list-deleted.js
@@ -15,22 +15,28 @@ const common = require('../common');
 
 const TIMEOUT = common.platformTimeout(100);
 
-const handle1 = setTimeout(common.mustCall(function() {
-  // Cause the old TIMEOUT list to be deleted
-  clearTimeout(handle1);
+const handle1 = setTimeout(
+  common.mustCall(function() {
+    // Cause the old TIMEOUT list to be deleted
+    clearTimeout(handle1);
 
-  // Cause a new list with the same key (TIMEOUT) to be created for this timer
-  const handle2 = setTimeout(common.mustNotCall(), TIMEOUT);
+    // Cause a new list with the same key (TIMEOUT) to be created for this timer
+    const handle2 = setTimeout(common.mustNotCall(), TIMEOUT);
 
-  setTimeout(common.mustCall(function() {
-    // Attempt to cancel the second timer. Fix for this bug will keep the
-    // newer timer from being dereferenced by keeping its list from being
-    // erroneously deleted. If we are able to cancel the timer successfully,
-    // the bug is fixed.
-    clearTimeout(handle2);
-  }), 1);
+    setTimeout(
+      common.mustCall(function() {
+        // Attempt to cancel the second timer. Fix for this bug will keep the
+        // newer timer from being dereferenced by keeping its list from being
+        // erroneously deleted. If we are able to cancel the timer successfully,
+        // the bug is fixed.
+        clearTimeout(handle2);
+      }),
+      1
+    );
 
-  // When this callback completes, `listOnTimeout` should now look at the
-  // correct list and refrain from removing the new TIMEOUT list which
-  // contains the reference to the newer timer.
-}), TIMEOUT);
+    // When this callback completes, `listOnTimeout` should now look at the
+    // correct list and refrain from removing the new TIMEOUT list which
+    // contains the reference to the newer timer.
+  }),
+  TIMEOUT
+);
diff --git a/test/parallel/test-timers-setimmediate-infinite-loop.js b/test/parallel/test-timers-setimmediate-infinite-loop.js
index 49adc390fa7bb5..42023cae4b87ee 100644
--- a/test/parallel/test-timers-setimmediate-infinite-loop.js
+++ b/test/parallel/test-timers-setimmediate-infinite-loop.js
@@ -9,10 +9,12 @@ const common = require('../common');
 //
 // Ref: https://github.com/nodejs/node/issues/9756
 
-setImmediate(common.mustCall(function() {
-  clearImmediate(i2);
-  clearImmediate(i3);
-}));
+setImmediate(
+  common.mustCall(function() {
+    clearImmediate(i2);
+    clearImmediate(i3);
+  })
+);
 
 const i2 = setImmediate(common.mustNotCall());
 
diff --git a/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js b/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
index 5dceb386fdbdf4..68ae333c929a55 100644
--- a/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
+++ b/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
@@ -32,16 +32,20 @@ const server = net.createServer(function onClient(client) {
   }
 });
 
-server.listen(0, common.localhostIPv4, common.mustCall(() => {
-  const countdown = new Countdown(2, () => server.close());
-
-  {
-    const client = net.connect({ port: server.address().port });
-    client.on('end', () => countdown.dec());
-  }
-
-  {
-    const client = net.connect({ port: server.address().port });
-    client.on('end', () => countdown.dec());
-  }
-}));
+server.listen(
+  0,
+  common.localhostIPv4,
+  common.mustCall(() => {
+    const countdown = new Countdown(2, () => server.close());
+
+    {
+      const client = net.connect({ port: server.address().port });
+      client.on('end', () => countdown.dec());
+    }
+
+    {
+      const client = net.connect({ port: server.address().port });
+      client.on('end', () => countdown.dec());
+    }
+  })
+);
diff --git a/test/parallel/test-timers-this.js b/test/parallel/test-timers-this.js
index a2a028fb0620f9..e1835be4b4e1a5 100644
--- a/test/parallel/test-timers-this.js
+++ b/test/parallel/test-timers-this.js
@@ -23,28 +23,47 @@
 const common = require('../common');
 const assert = require('assert');
 
-const immediateHandler = setImmediate(common.mustCall(function() {
-  assert.strictEqual(this, immediateHandler);
-}));
+const immediateHandler = setImmediate(
+  common.mustCall(function() {
+    assert.strictEqual(this, immediateHandler);
+  })
+);
 
-const immediateArgsHandler = setImmediate(common.mustCall(function() {
-  assert.strictEqual(this, immediateArgsHandler);
-}), 'args ...');
+const immediateArgsHandler = setImmediate(
+  common.mustCall(function() {
+    assert.strictEqual(this, immediateArgsHandler);
+  }),
+  'args ...'
+);
 
-const intervalHandler = setInterval(common.mustCall(function() {
-  clearInterval(intervalHandler);
-  assert.strictEqual(this, intervalHandler);
-}), 1);
+const intervalHandler = setInterval(
+  common.mustCall(function() {
+    clearInterval(intervalHandler);
+    assert.strictEqual(this, intervalHandler);
+  }),
+  1
+);
 
-const intervalArgsHandler = setInterval(common.mustCall(function() {
-  clearInterval(intervalArgsHandler);
-  assert.strictEqual(this, intervalArgsHandler);
-}), 1, 'args ...');
+const intervalArgsHandler = setInterval(
+  common.mustCall(function() {
+    clearInterval(intervalArgsHandler);
+    assert.strictEqual(this, intervalArgsHandler);
+  }),
+  1,
+  'args ...'
+);
 
-const timeoutHandler = setTimeout(common.mustCall(function() {
-  assert.strictEqual(this, timeoutHandler);
-}), 1);
+const timeoutHandler = setTimeout(
+  common.mustCall(function() {
+    assert.strictEqual(this, timeoutHandler);
+  }),
+  1
+);
 
-const timeoutArgsHandler = setTimeout(common.mustCall(function() {
-  assert.strictEqual(this, timeoutArgsHandler);
-}), 1, 'args ...');
+const timeoutArgsHandler = setTimeout(
+  common.mustCall(function() {
+    assert.strictEqual(this, timeoutArgsHandler);
+  }),
+  1,
+  'args ...'
+);
diff --git a/test/parallel/test-timers-throw-when-cb-not-function.js b/test/parallel/test-timers-throw-when-cb-not-function.js
index 9f7f653d3d3afc..5317007121cf38 100644
--- a/test/parallel/test-timers-throw-when-cb-not-function.js
+++ b/test/parallel/test-timers-throw-when-cb-not-function.js
@@ -8,10 +8,13 @@ function doSetTimeout(callback, after) {
   };
 }
 
-const errMessage = common.expectsError({
-  code: 'ERR_INVALID_CALLBACK',
-  type: TypeError
-}, 18);
+const errMessage = common.expectsError(
+  {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError
+  },
+  18
+);
 
 assert.throws(doSetTimeout('foo'), errMessage);
 assert.throws(doSetTimeout({ foo: 'bar' }), errMessage);
@@ -20,7 +23,6 @@ assert.throws(doSetTimeout(undefined, 0), errMessage);
 assert.throws(doSetTimeout(null, 0), errMessage);
 assert.throws(doSetTimeout(false, 0), errMessage);
 
-
 function doSetInterval(callback, after) {
   return function() {
     setInterval(callback, after);
@@ -34,7 +36,6 @@ assert.throws(doSetInterval(undefined, 0), errMessage);
 assert.throws(doSetInterval(null, 0), errMessage);
 assert.throws(doSetInterval(false, 0), errMessage);
 
-
 function doSetImmediate(callback, after) {
   return function() {
     setImmediate(callback, after);
diff --git a/test/parallel/test-timers-timeout-to-interval.js b/test/parallel/test-timers-timeout-to-interval.js
index 6b83e2e09e34a5..57a1e2d17c2aa8 100644
--- a/test/parallel/test-timers-timeout-to-interval.js
+++ b/test/parallel/test-timers-timeout-to-interval.js
@@ -4,9 +4,12 @@ const common = require('../common');
 // This isn't officially supported but nonetheless is something that is
 // currently possible and as such it shouldn't cause the process to crash
 
-const t = setTimeout(common.mustCall(() => {
-  if (t._repeat) {
-    clearInterval(t);
-  }
-  t._repeat = 1;
-}, 2), 1);
+const t = setTimeout(
+  common.mustCall(() => {
+    if (t._repeat) {
+      clearInterval(t);
+    }
+    t._repeat = 1;
+  }, 2),
+  1
+);
diff --git a/test/parallel/test-timers-uncaught-exception.js b/test/parallel/test-timers-uncaught-exception.js
index 0a0eabf4c14e5b..f8d368ddf7a7cc 100644
--- a/test/parallel/test-timers-uncaught-exception.js
+++ b/test/parallel/test-timers-uncaught-exception.js
@@ -25,9 +25,12 @@ const assert = require('assert');
 const errorMsg = 'BAM!';
 
 // the first timer throws...
-setTimeout(common.mustCall(function() {
-  throw new Error(errorMsg);
-}), 1);
+setTimeout(
+  common.mustCall(function() {
+    throw new Error(errorMsg);
+  }),
+  1
+);
 
 // ...but the second one should still run
 setTimeout(common.mustCall(), 1);
diff --git a/test/parallel/test-timers-unenroll-unref-interval.js b/test/parallel/test-timers-unenroll-unref-interval.js
index 8d9203a04ac96d..2906338d368520 100644
--- a/test/parallel/test-timers-unenroll-unref-interval.js
+++ b/test/parallel/test-timers-unenroll-unref-interval.js
@@ -4,33 +4,48 @@ const common = require('../common');
 const timers = require('timers');
 
 {
-  const interval = setInterval(common.mustCall(() => {
-    clearTimeout(interval);
-  }), 1).unref();
+  const interval = setInterval(
+    common.mustCall(() => {
+      clearTimeout(interval);
+    }),
+    1
+  ).unref();
 }
 
 {
-  const interval = setInterval(common.mustCall(() => {
-    interval.close();
-  }), 1).unref();
+  const interval = setInterval(
+    common.mustCall(() => {
+      interval.close();
+    }),
+    1
+  ).unref();
 }
 
 {
-  const interval = setInterval(common.mustCall(() => {
-    timers.unenroll(interval);
-  }), 1).unref();
+  const interval = setInterval(
+    common.mustCall(() => {
+      timers.unenroll(interval);
+    }),
+    1
+  ).unref();
 }
 
 {
-  const interval = setInterval(common.mustCall(() => {
-    interval._idleTimeout = -1;
-  }), 1).unref();
+  const interval = setInterval(
+    common.mustCall(() => {
+      interval._idleTimeout = -1;
+    }),
+    1
+  ).unref();
 }
 
 {
-  const interval = setInterval(common.mustCall(() => {
-    interval._onTimeout = null;
-  }), 1).unref();
+  const interval = setInterval(
+    common.mustCall(() => {
+      interval._onTimeout = null;
+    }),
+    1
+  ).unref();
 }
 
 // Use timers' intrinsic behavior to keep this open
@@ -44,6 +59,9 @@ const timers = require('timers');
 // Keep the event loop alive for one timeout and then
 // another. Any problems will occur when the second
 // should be called but before it is able to be.
-setTimeout(common.mustCall(() => {
-  setTimeout(common.mustCall(), 1);
-}), 1);
+setTimeout(
+  common.mustCall(() => {
+    setTimeout(common.mustCall(), 1);
+  }),
+  1
+);
diff --git a/test/parallel/test-timers-unref-throw-then-ref.js b/test/parallel/test-timers-unref-throw-then-ref.js
index d3ae27e83551c7..2c3cdc341f59a3 100644
--- a/test/parallel/test-timers-unref-throw-then-ref.js
+++ b/test/parallel/test-timers-unref-throw-then-ref.js
@@ -2,9 +2,12 @@
 const common = require('../common');
 const assert = require('assert');
 
-process.once('uncaughtException', common.expectsError({
-  message: 'Timeout Error'
-}));
+process.once(
+  'uncaughtException',
+  common.expectsError({
+    message: 'Timeout Error'
+  })
+);
 
 let called = false;
 const t = setTimeout(() => {
diff --git a/test/parallel/test-timers-unref.js b/test/parallel/test-timers-unref.js
index 35615d111ada54..90df49ac991268 100644
--- a/test/parallel/test-timers-unref.js
+++ b/test/parallel/test-timers-unref.js
@@ -35,41 +35,53 @@ const SHORT_TIME = 100;
 const timer = setTimeout(() => {}, 10);
 assert.strictEqual(timer.hasRef(), true);
 // Should not throw.
-timer.unref().ref().unref();
+timer
+  .unref()
+  .ref()
+  .unref();
 assert.strictEqual(timer.hasRef(), false);
 
-setInterval(() => {}, 10).unref().ref().unref();
+setInterval(() => {}, 10)
+  .unref()
+  .ref()
+  .unref();
 
 setInterval(common.mustNotCall('Interval should not fire'), LONG_TIME).unref();
 setTimeout(common.mustNotCall('Timer should not fire'), LONG_TIME).unref();
 
-const interval = setInterval(common.mustCall(() => {
-  unref_interval = true;
-  clearInterval(interval);
-}), SHORT_TIME);
+const interval = setInterval(
+  common.mustCall(() => {
+    unref_interval = true;
+    clearInterval(interval);
+  }),
+  SHORT_TIME
+);
 interval.unref();
 
-setTimeout(common.mustCall(() => {
-  unref_timer = true;
-}), SHORT_TIME).unref();
+setTimeout(
+  common.mustCall(() => {
+    unref_timer = true;
+  }),
+  SHORT_TIME
+).unref();
 
 const check_unref = setInterval(() => {
-  if (checks > 5 || (unref_interval && unref_timer))
-    clearInterval(check_unref);
+  if (checks > 5 || (unref_interval && unref_timer)) clearInterval(check_unref);
   checks += 1;
 }, 100);
 
 {
-  const timeout =
-    setTimeout(common.mustCall(() => {
+  const timeout = setTimeout(
+    common.mustCall(() => {
       timeout.unref();
-    }), SHORT_TIME);
+    }),
+    SHORT_TIME
+  );
 }
 
 {
   // Should not timeout the test
-  const timeout =
-    setInterval(() => timeout.unref(), SHORT_TIME);
+  const timeout = setInterval(() => timeout.unref(), SHORT_TIME);
 }
 
 // Should not assert on args.Holder()->InternalFieldCount() > 0.
diff --git a/test/parallel/test-timers-unrefd-interval-still-fires.js b/test/parallel/test-timers-unrefd-interval-still-fires.js
index 45c59c01082777..e06c30331f9a40 100644
--- a/test/parallel/test-timers-unrefd-interval-still-fires.js
+++ b/test/parallel/test-timers-unrefd-interval-still-fires.js
@@ -7,18 +7,22 @@ const common = require('../common');
 const TEST_DURATION = common.platformTimeout(1000);
 let N = 3;
 
-const keepOpen =
-  setTimeout(
-    common.mustNotCall('Test timed out. keepOpen was not canceled.'),
-    TEST_DURATION);
+const keepOpen = setTimeout(
+  common.mustNotCall('Test timed out. keepOpen was not canceled.'),
+  TEST_DURATION
+);
 
-const timer = setInterval(common.mustCall(() => {
-  if (--N === 0) {
-    clearInterval(timer);
-    timer._onTimeout =
-      common.mustNotCall('Unrefd interval fired after being cleared');
-    clearTimeout(keepOpen);
-  }
-}, N), 1);
+const timer = setInterval(
+  common.mustCall(() => {
+    if (--N === 0) {
+      clearInterval(timer);
+      timer._onTimeout = common.mustNotCall(
+        'Unrefd interval fired after being cleared'
+      );
+      clearTimeout(keepOpen);
+    }
+  }, N),
+  1
+);
 
 timer.unref();
diff --git a/test/parallel/test-timers-unrefed-in-beforeexit.js b/test/parallel/test-timers-unrefed-in-beforeexit.js
index a38b55bf45d599..5e334d5ea01b8e 100644
--- a/test/parallel/test-timers-unrefed-in-beforeexit.js
+++ b/test/parallel/test-timers-unrefed-in-beforeexit.js
@@ -2,6 +2,9 @@
 
 const common = require('../common');
 
-process.on('beforeExit', common.mustCall(() => {
-  setTimeout(common.mustNotCall(), 1).unref();
-}));
+process.on(
+  'beforeExit',
+  common.mustCall(() => {
+    setTimeout(common.mustNotCall(), 1).unref();
+  })
+);
diff --git a/test/parallel/test-timers-unrefed-in-callback.js b/test/parallel/test-timers-unrefed-in-callback.js
index 50e6881bd3f60b..ad76ade90b23bb 100644
--- a/test/parallel/test-timers-unrefed-in-callback.js
+++ b/test/parallel/test-timers-unrefed-in-callback.js
@@ -27,18 +27,20 @@ function Test1() {
   // server only for maintaining event loop
   const server = net.createServer().listen(0);
 
-  const timer1 = setInterval(common.mustCall(() => {
-    timer1.unref();
-    if (counter1++ === 3) {
-      clearInterval(timer1);
-      server.close(() => {
-        Test2();
-      });
-    }
-  }, 4), 1);
+  const timer1 = setInterval(
+    common.mustCall(() => {
+      timer1.unref();
+      if (counter1++ === 3) {
+        clearInterval(timer1);
+        server.close(() => {
+          Test2();
+        });
+      }
+    }, 4),
+    1
+  );
 }
 
-
 // Test2 checks setInterval continues even if it is unrefed within
 // timer callback. counter2 continues to be incremented more than 11
 // until server close completed.
@@ -48,8 +50,7 @@ function Test2() {
 
   const timer2 = setInterval(() => {
     timer2.unref();
-    if (counter2++ === 3)
-      server.close();
+    if (counter2++ === 3) server.close();
   }, 1);
 }
 
diff --git a/test/parallel/test-timers-user-call.js b/test/parallel/test-timers-user-call.js
index 4ff24e688b5aa3..d49d26f876be98 100644
--- a/test/parallel/test-timers-user-call.js
+++ b/test/parallel/test-timers-user-call.js
@@ -26,7 +26,9 @@ const common = require('../common');
 
 {
   const testInterval = (...args) => {
-    const fn = common.mustCall(() => { clearInterval(interval); });
+    const fn = common.mustCall(() => {
+      clearInterval(interval);
+    });
     fn.call = 'not a function';
     fn.apply = 'also not a function';
     const interval = setInterval(fn, 1, ...args);
diff --git a/test/parallel/test-timers.js b/test/parallel/test-timers.js
index 1aa5d351a4d4bd..e012a230f0de5f 100644
--- a/test/parallel/test-timers.js
+++ b/test/parallel/test-timers.js
@@ -34,8 +34,8 @@ const inputs = [
   NaN,
   +Infinity,
   -Infinity,
-  (1.0 / 0.0),      // sanity check
-  parseFloat('x'),  // NaN
+  1.0 / 0.0, // sanity check
+  parseFloat('x'), // NaN
   -10,
   -1,
   -0.5,
@@ -47,8 +47,8 @@ const inputs = [
   0.5,
   1,
   1.0,
-  2147483648,     // browser behavior: timeouts > 2^31-1 run on next tick
-  12345678901234  // ditto
+  2147483648, // browser behavior: timeouts > 2^31-1 run on next tick
+  12345678901234 // ditto
 ];
 
 const timeouts = [];
@@ -68,14 +68,22 @@ inputs.forEach((value, index) => {
 // All values in inputs array coerce to 1 ms. Therefore, they should all run
 // before a timer set here for 2 ms.
 
-setTimeout(common.mustCall(() => {
-  // assert that all other timers have run
-  inputs.forEach((value, index) => {
-    assert(timeouts[index]);
-    assert(intervals[index]);
-  });
-}), 2);
+setTimeout(
+  common.mustCall(() => {
+    // assert that all other timers have run
+    inputs.forEach((value, index) => {
+      assert(timeouts[index]);
+      assert(intervals[index]);
+    });
+  }),
+  2
+);
 
 // Test 10 ms timeout separately.
 setTimeout(common.mustCall(), 10);
-setInterval(common.mustCall(function() { clearInterval(this); }), 10);
+setInterval(
+  common.mustCall(function() {
+    clearInterval(this);
+  }),
+  10
+);
diff --git a/test/parallel/test-tls-0-dns-altname.js b/test/parallel/test-tls-0-dns-altname.js
index 4bc87e44cb60c1..653882226e9d11 100644
--- a/test/parallel/test-tls-0-dns-altname.js
+++ b/test/parallel/test-tls-0-dns-altname.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // Check getPeerCertificate can properly handle '\0' for fix CVE-2009-2408.
 
@@ -30,25 +29,42 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
-const server = tls.createServer({
-  key: fixtures.readSync(['0-dns', '0-dns-key.pem']),
-  cert: fixtures.readSync(['0-dns', '0-dns-cert.pem'])
-}, common.mustCall((c) => {
-  c.once('data', common.mustCall(() => {
-    c.destroy();
-    server.close();
-  }));
-})).listen(0, common.mustCall(() => {
-  const c = tls.connect(server.address().port, {
-    rejectUnauthorized: false
-  }, common.mustCall(() => {
-    const cert = c.getPeerCertificate();
-    assert.strictEqual(cert.subjectaltname,
-                       'DNS:good.example.org\0.evil.example.com, ' +
-                           'DNS:just-another.example.com, ' +
-                           'IP Address:8.8.8.8, ' +
-                           'IP Address:8.8.4.4, ' +
-                           'DNS:last.example.com');
-    c.write('ok');
-  }));
-}));
+const server = tls
+  .createServer(
+    {
+      key: fixtures.readSync(['0-dns', '0-dns-key.pem']),
+      cert: fixtures.readSync(['0-dns', '0-dns-cert.pem'])
+    },
+    common.mustCall((c) => {
+      c.once(
+        'data',
+        common.mustCall(() => {
+          c.destroy();
+          server.close();
+        })
+      );
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const c = tls.connect(
+        server.address().port,
+        {
+          rejectUnauthorized: false
+        },
+        common.mustCall(() => {
+          const cert = c.getPeerCertificate();
+          assert.strictEqual(
+            cert.subjectaltname,
+            'DNS:good.example.org\0.evil.example.com, ' +
+              'DNS:just-another.example.com, ' +
+              'IP Address:8.8.8.8, ' +
+              'IP Address:8.8.4.4, ' +
+              'DNS:last.example.com'
+          );
+          c.write('ok');
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-addca.js b/test/parallel/test-tls-addca.js
index 8eb88db6291457..17f60ca67c51d3 100644
--- a/test/parallel/test-tls-addca.js
+++ b/test/parallel/test-tls-addca.js
@@ -6,9 +6,7 @@ const fixtures = require('../common/fixtures');
 // contextWithoutCert. This is tested by trying to connect to a server that
 // depends on that CA using contextWithoutCert.
 
-const {
-  assert, connect, keys, tls
-} = require(fixtures.path('tls-connect'));
+const { assert, connect, keys, tls } = require(fixtures.path('tls-connect'));
 
 const contextWithoutCert = tls.createSecureContext({});
 const contextWithCert = tls.createSecureContext({});
@@ -16,35 +14,41 @@ contextWithCert.context.addCACert(keys.agent1.ca);
 
 const serverOptions = {
   key: keys.agent1.key,
-  cert: keys.agent1.cert,
+  cert: keys.agent1.cert
 };
 
 const clientOptions = {
   ca: [keys.agent1.ca],
   servername: 'agent1',
-  rejectUnauthorized: true,
+  rejectUnauthorized: true
 };
 
 // This client should fail to connect because it doesn't trust the CA
 // certificate.
 clientOptions.secureContext = contextWithoutCert;
 
-connect({
-  client: clientOptions,
-  server: serverOptions,
-}, common.mustCall((err, pair, cleanup) => {
-  assert(err);
-  assert.strictEqual(err.message, 'unable to verify the first certificate');
-  cleanup();
-
-  // This time it should connect because contextWithCert includes the needed CA
-  // certificate.
-  clientOptions.secureContext = contextWithCert;
-  connect({
+connect(
+  {
     client: clientOptions,
-    server: serverOptions,
-  }, common.mustCall((err, pair, cleanup) => {
-    assert.ifError(err);
+    server: serverOptions
+  },
+  common.mustCall((err, pair, cleanup) => {
+    assert(err);
+    assert.strictEqual(err.message, 'unable to verify the first certificate');
     cleanup();
-  }));
-}));
+
+    // This time it should connect because contextWithCert includes the needed CA
+    // certificate.
+    clientOptions.secureContext = contextWithCert;
+    connect(
+      {
+        client: clientOptions,
+        server: serverOptions
+      },
+      common.mustCall((err, pair, cleanup) => {
+        assert.ifError(err);
+        cleanup();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-tls-alert-handling.js b/test/parallel/test-tls-alert-handling.js
index c686d68a182e3d..dfc254b523149d 100644
--- a/test/parallel/test-tls-alert-handling.js
+++ b/test/parallel/test-tls-alert-handling.js
@@ -1,11 +1,9 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI');
 
 const net = require('net');
 const tls = require('tls');
@@ -31,50 +29,64 @@ let iter = 0;
 
 const errorHandler = common.mustCall(() => {
   errorReceived = true;
-  if (canCloseServer())
-    server.close();
+  if (canCloseServer()) server.close();
 });
-const server = tls.createServer(opts, common.mustCall(function(s) {
-  s.pipe(s);
-  s.on('error', errorHandler);
-}, 2));
-
-server.listen(0, common.mustCall(function() {
-  sendClient();
-}));
+const server = tls.createServer(
+  opts,
+  common.mustCall(function(s) {
+    s.pipe(s);
+    s.on('error', errorHandler);
+  }, 2)
+);
 
+server.listen(
+  0,
+  common.mustCall(function() {
+    sendClient();
+  })
+);
 
 function sendClient() {
-  const client = tls.connect(server.address().port, {
-    rejectUnauthorized: false
-  });
-  client.on('data', common.mustCall(function() {
-    if (iter++ === 2) sendBADTLSRecord();
-    if (iter < max_iter) {
-      client.write('a');
-      return;
+  const client = tls.connect(
+    server.address().port,
+    {
+      rejectUnauthorized: false
     }
-    client.end();
-  }, max_iter));
+  );
+  client.on(
+    'data',
+    common.mustCall(function() {
+      if (iter++ === 2) sendBADTLSRecord();
+      if (iter < max_iter) {
+        client.write('a');
+        return;
+      }
+      client.end();
+    }, max_iter)
+  );
   client.write('a');
   client.on('error', common.mustNotCall());
-  client.on('close', common.mustCall(function() {
-    clientClosed = true;
-    if (canCloseServer())
-      server.close();
-  }));
+  client.on(
+    'close',
+    common.mustCall(function() {
+      clientClosed = true;
+      if (canCloseServer()) server.close();
+    })
+  );
 }
 
-
 function sendBADTLSRecord() {
   const BAD_RECORD = Buffer.from([0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
   const socket = net.connect(server.address().port);
-  const client = tls.connect({
-    socket: socket,
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    socket.write(BAD_RECORD);
-    socket.end();
-  }));
+  const client = tls.connect(
+    {
+      socket: socket,
+      rejectUnauthorized: false
+    },
+    common.mustCall(function() {
+      socket.write(BAD_RECORD);
+      socket.end();
+    })
+  );
   client.on('error', common.mustCall());
 }
diff --git a/test/parallel/test-tls-alert.js b/test/parallel/test-tls-alert.js
index 5847f9ce9ad684..70ac38bdcebc21 100644
--- a/test/parallel/test-tls-alert.js
+++ b/test/parallel/test-tls-alert.js
@@ -21,11 +21,9 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
 const assert = require('assert');
 const { spawn } = require('child_process');
@@ -38,25 +36,35 @@ function loadPEM(n) {
   return fixtures.readKey(`${n}.pem`);
 }
 
-const server = tls.Server({
-  secureProtocol: 'TLSv1_2_server_method',
-  key: loadPEM('agent2-key'),
-  cert: loadPEM('agent2-cert')
-}, null).listen(0, function() {
-  const args = ['s_client', '-quiet', '-tls1_1',
-                '-connect', `127.0.0.1:${this.address().port}`];
+const server = tls
+  .Server(
+    {
+      secureProtocol: 'TLSv1_2_server_method',
+      key: loadPEM('agent2-key'),
+      cert: loadPEM('agent2-cert')
+    },
+    null
+  )
+  .listen(0, function() {
+    const args = [
+      's_client',
+      '-quiet',
+      '-tls1_1',
+      '-connect',
+      `127.0.0.1:${this.address().port}`
+    ];
 
-  const client = spawn(common.opensslCli, args);
-  let out = '';
-  client.stderr.setEncoding('utf8');
-  client.stderr.on('data', function(d) {
-    out += d;
-    if (/SSL alert number 70/.test(out)) {
-      success = true;
-      server.close();
-    }
+    const client = spawn(common.opensslCli, args);
+    let out = '';
+    client.stderr.setEncoding('utf8');
+    client.stderr.on('data', function(d) {
+      out += d;
+      if (/SSL alert number 70/.test(out)) {
+        success = true;
+        server.close();
+      }
+    });
   });
-});
 process.on('exit', function() {
   assert(success);
 });
diff --git a/test/parallel/test-tls-alpn-server-client.js b/test/parallel/test-tls-alpn-server-client.js
index 2540831a38f25c..5387025a6c5da4 100644
--- a/test/parallel/test-tls-alpn-server-client.js
+++ b/test/parallel/test-tls-alpn-server-client.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -39,48 +38,51 @@ function runTest(clientsOptions, serverOptions, cb) {
     opt.rejectUnauthorized = false;
 
     results[index] = {};
-    const client = tls.connect(opt, function() {
-      results[index].client = { ALPN: client.alpnProtocol };
-      client.destroy();
-      if (options.length) {
-        index++;
-        connectClient(options);
-      } else {
-        server.close();
-        cb(results);
+    const client = tls.connect(
+      opt,
+      function() {
+        results[index].client = { ALPN: client.alpnProtocol };
+        client.destroy();
+        if (options.length) {
+          index++;
+          connectClient(options);
+        } else {
+          server.close();
+          cb(results);
+        }
       }
-    });
+    );
   }
-
 }
 
 // Server: ALPN, Client: ALPN
 function Test1() {
   const serverOptions = {
-    ALPNProtocols: ['a', 'b', 'c'],
+    ALPNProtocols: ['a', 'b', 'c']
   };
 
-  const clientsOptions = [{
-    ALPNProtocols: ['a', 'b', 'c'],
-  }, {
-    ALPNProtocols: ['c', 'b', 'e'],
-  }, {
-    ALPNProtocols: ['first-priority-unsupported', 'x', 'y'],
-  }];
+  const clientsOptions = [
+    {
+      ALPNProtocols: ['a', 'b', 'c']
+    },
+    {
+      ALPNProtocols: ['c', 'b', 'e']
+    },
+    {
+      ALPNProtocols: ['first-priority-unsupported', 'x', 'y']
+    }
+  ];
 
   runTest(clientsOptions, serverOptions, function(results) {
     // 'a' is selected by ALPN
-    checkResults(results[0],
-                 { server: { ALPN: 'a' },
-                   client: { ALPN: 'a' } });
+    checkResults(results[0], { server: { ALPN: 'a' }, client: { ALPN: 'a' } });
     // 'b' is selected by ALPN
-    checkResults(results[1],
-                 { server: { ALPN: 'b' },
-                   client: { ALPN: 'b' } });
+    checkResults(results[1], { server: { ALPN: 'b' }, client: { ALPN: 'b' } });
     // nothing is selected by ALPN
-    checkResults(results[2],
-                 { server: { ALPN: false },
-                   client: { ALPN: false } });
+    checkResults(results[2], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // execute next test
     Test2();
   });
@@ -89,24 +91,27 @@ function Test1() {
 // Server: ALPN, Client: Nothing
 function Test2() {
   const serverOptions = {
-    ALPNProtocols: ['a', 'b', 'c'],
+    ALPNProtocols: ['a', 'b', 'c']
   };
 
   const clientsOptions = [{}, {}, {}];
 
   runTest(clientsOptions, serverOptions, function(results) {
     // nothing is selected by ALPN
-    checkResults(results[0],
-                 { server: { ALPN: false },
-                   client: { ALPN: false } });
+    checkResults(results[0], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // nothing is selected by ALPN
-    checkResults(results[1],
-                 { server: { ALPN: false },
-                   client: { ALPN: false } });
+    checkResults(results[1], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // nothing is selected by ALPN
-    checkResults(results[2],
-                 { server: { ALPN: false },
-                   client: { ALPN: false } });
+    checkResults(results[2], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // execute next test
     Test3();
   });
@@ -116,25 +121,34 @@ function Test2() {
 function Test3() {
   const serverOptions = {};
 
-  const clientsOptions = [{
-    ALPNrotocols: ['a', 'b', 'c'],
-  }, {
-    ALPNProtocols: ['c', 'b', 'e'],
-  }, {
-    ALPNProtocols: ['first-priority-unsupported', 'x', 'y'],
-  }];
+  const clientsOptions = [
+    {
+      ALPNrotocols: ['a', 'b', 'c']
+    },
+    {
+      ALPNProtocols: ['c', 'b', 'e']
+    },
+    {
+      ALPNProtocols: ['first-priority-unsupported', 'x', 'y']
+    }
+  ];
 
   runTest(clientsOptions, serverOptions, function(results) {
     // nothing is selected
-    checkResults(results[0], { server: { ALPN: false },
-                               client: { ALPN: false } });
+    checkResults(results[0], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // nothing is selected
-    checkResults(results[1], { server: { ALPN: false },
-                               client: { ALPN: false } });
+    checkResults(results[1], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // nothing is selected
-    checkResults(results[2],
-                 { server: { ALPN: false },
-                   client: { ALPN: false } });
+    checkResults(results[2], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // execute next test
     Test4();
   });
@@ -148,15 +162,20 @@ function Test4() {
 
   runTest(clientsOptions, serverOptions, function(results) {
     // nothing is selected
-    checkResults(results[0], { server: { ALPN: false },
-                               client: { ALPN: false } });
+    checkResults(results[0], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // nothing is selected
-    checkResults(results[1], { server: { ALPN: false },
-                               client: { ALPN: false } });
+    checkResults(results[1], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
     // nothing is selected
-    checkResults(results[2],
-                 { server: { ALPN: false },
-                   client: { ALPN: false } });
+    checkResults(results[2], {
+      server: { ALPN: false },
+      client: { ALPN: false }
+    });
   });
 }
 
diff --git a/test/parallel/test-tls-async-cb-after-socket-end.js b/test/parallel/test-tls-async-cb-after-socket-end.js
index 6ca38461fdec6a..f85c0347b3bbd5 100644
--- a/test/parallel/test-tls-async-cb-after-socket-end.js
+++ b/test/parallel/test-tls-async-cb-after-socket-end.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const SSL_OP_NO_TICKET = require('crypto').constants.SSL_OP_NO_TICKET;
 const tls = require('tls');
@@ -19,47 +18,69 @@ const server = tls.createServer(options, common.mustCall());
 let sessionCb = null;
 let client = null;
 
-server.on('newSession', common.mustCall((key, session, done) => {
-  done();
-}));
+server.on(
+  'newSession',
+  common.mustCall((key, session, done) => {
+    done();
+  })
+);
 
-server.on('resumeSession', common.mustCall((id, cb) => {
-  sessionCb = cb;
-  next();
-}));
+server.on(
+  'resumeSession',
+  common.mustCall((id, cb) => {
+    sessionCb = cb;
+    next();
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const clientOpts = {
-    port: server.address().port,
-    rejectUnauthorized: false,
-    session: false
-  };
+server.listen(
+  0,
+  common.mustCall(() => {
+    const clientOpts = {
+      port: server.address().port,
+      rejectUnauthorized: false,
+      session: false
+    };
 
-  const s1 = tls.connect(clientOpts, common.mustCall(() => {
-    clientOpts.session = s1.getSession();
-    console.log('1st secure');
+    const s1 = tls.connect(
+      clientOpts,
+      common.mustCall(() => {
+        clientOpts.session = s1.getSession();
+        console.log('1st secure');
 
-    s1.destroy();
-    const s2 = tls.connect(clientOpts, (s) => {
-      console.log('2nd secure');
+        s1.destroy();
+        const s2 = tls
+          .connect(
+            clientOpts,
+            (s) => {
+              console.log('2nd secure');
 
-      s2.destroy();
-    }).on('connect', common.mustCall(() => {
-      console.log('2nd connected');
-      client = s2;
+              s2.destroy();
+            }
+          )
+          .on(
+            'connect',
+            common.mustCall(() => {
+              console.log('2nd connected');
+              client = s2;
 
-      next();
-    }));
-  }));
-}));
+              next();
+            })
+          );
+      })
+    );
+  })
+);
 
 function next() {
-  if (!client || !sessionCb)
-    return;
+  if (!client || !sessionCb) return;
 
   client.destroy();
-  setTimeout(common.mustCall(() => {
-    sessionCb();
-    server.close();
-  }), 100);
+  setTimeout(
+    common.mustCall(() => {
+      sessionCb();
+      server.close();
+    }),
+    100
+  );
 }
diff --git a/test/parallel/test-tls-basic-validations.js b/test/parallel/test-tls-basic-validations.js
index 8d39b8d45c9c65..0009c78cbee8b5 100644
--- a/test/parallel/test-tls-basic-validations.js
+++ b/test/parallel/test-tls-basic-validations.js
@@ -1,27 +1,22 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
 
-common.expectsError(
-  () => tls.createSecureContext({ ciphers: 1 }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'Ciphers must be a string'
-  });
+common.expectsError(() => tls.createSecureContext({ ciphers: 1 }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'Ciphers must be a string'
+});
 
-common.expectsError(
-  () => tls.createServer({ ciphers: 1 }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'Ciphers must be a string'
-  });
+common.expectsError(() => tls.createServer({ ciphers: 1 }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'Ciphers must be a string'
+});
 
 common.expectsError(
   () => tls.createSecureContext({ key: 'dummykey', passphrase: 1 }),
@@ -29,7 +24,8 @@ common.expectsError(
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
     message: 'Pass phrase must be a string'
-  });
+  }
+);
 
 common.expectsError(
   () => tls.createServer({ key: 'dummykey', passphrase: 1 }),
@@ -37,53 +33,45 @@ common.expectsError(
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
     message: 'Pass phrase must be a string'
-  });
-
-common.expectsError(
-  () => tls.createServer({ ecdhCurve: 1 }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'ECDH curve name must be a string'
-  });
-
-common.expectsError(
-  () => tls.createServer({ handshakeTimeout: 'abcd' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.handshakeTimeout" property must ' +
-              'be of type number. Received type string'
   }
 );
 
-common.expectsError(
-  () => tls.createServer({ sessionTimeout: 'abcd' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'Session timeout must be a 32-bit integer'
-  });
+common.expectsError(() => tls.createServer({ ecdhCurve: 1 }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'ECDH curve name must be a string'
+});
 
-common.expectsError(
-  () => tls.createServer({ ticketKeys: 'abcd' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'Ticket keys must be a buffer'
-  });
+common.expectsError(() => tls.createServer({ handshakeTimeout: 'abcd' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.handshakeTimeout" property must ' +
+    'be of type number. Received type string'
+});
 
-assert.throws(() => tls.createServer({ ticketKeys: Buffer.alloc(0) }),
-              /TypeError: Ticket keys length must be 48 bytes/);
+common.expectsError(() => tls.createServer({ sessionTimeout: 'abcd' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'Session timeout must be a 32-bit integer'
+});
 
-common.expectsError(
-  () => tls.createSecurePair({}),
-  {
-    code: 'ERR_ASSERTION',
-    message: 'context.context must be a NativeSecureContext'
-  }
+common.expectsError(() => tls.createServer({ ticketKeys: 'abcd' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message: 'Ticket keys must be a buffer'
+});
+
+assert.throws(
+  () => tls.createServer({ ticketKeys: Buffer.alloc(0) }),
+  /TypeError: Ticket keys length must be 48 bytes/
 );
 
+common.expectsError(() => tls.createSecurePair({}), {
+  code: 'ERR_ASSERTION',
+  message: 'context.context must be a NativeSecureContext'
+});
+
 {
   const buffer = Buffer.from('abcd');
   const out = {};
@@ -104,14 +92,12 @@ common.expectsError(
 }
 
 {
-  const protocols = [(new String('a')).repeat(500)];
+  const protocols = [new String('a').repeat(500)];
   const out = {};
-  common.expectsError(
-    () => tls.convertALPNProtocols(protocols, out),
-    {
-      code: 'ERR_OUT_OF_RANGE',
-      message: 'The byte length of the protocol at index 0 exceeds the ' +
-        'maximum length. It must be <= 255. Received 500'
-    }
-  );
+  common.expectsError(() => tls.convertALPNProtocols(protocols, out), {
+    code: 'ERR_OUT_OF_RANGE',
+    message:
+      'The byte length of the protocol at index 0 exceeds the ' +
+      'maximum length. It must be <= 255. Received 500'
+  });
 }
diff --git a/test/parallel/test-tls-buffersize.js b/test/parallel/test-tls-buffersize.js
index c94b95d7b32d31..ece6aea4fa38fa 100644
--- a/test/parallel/test-tls-buffersize.js
+++ b/test/parallel/test-tls-buffersize.js
@@ -1,43 +1,59 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const tls = require('tls');
 
 const iter = 10;
 
-const server = tls.createServer({
-  key: fixtures.readKey('agent2-key.pem'),
-  cert: fixtures.readKey('agent2-cert.pem')
-}, common.mustCall((socket) => {
-  let str = '';
-  socket.setEncoding('utf-8');
-  socket.on('data', (chunk) => { str += chunk; });
+const server = tls.createServer(
+  {
+    key: fixtures.readKey('agent2-key.pem'),
+    cert: fixtures.readKey('agent2-cert.pem')
+  },
+  common.mustCall((socket) => {
+    let str = '';
+    socket.setEncoding('utf-8');
+    socket.on('data', (chunk) => {
+      str += chunk;
+    });
 
-  socket.on('end', common.mustCall(() => {
-    assert.strictEqual(str, 'a'.repeat(iter - 1));
-    server.close();
-  }));
-}));
+    socket.on(
+      'end',
+      common.mustCall(() => {
+        assert.strictEqual(str, 'a'.repeat(iter - 1));
+        server.close();
+      })
+    );
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  const client = tls.connect({
-    port: server.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(() => {
-    assert.strictEqual(client.bufferSize, 0);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = tls.connect(
+      {
+        port: server.address().port,
+        rejectUnauthorized: false
+      },
+      common.mustCall(() => {
+        assert.strictEqual(client.bufferSize, 0);
 
-    for (let i = 1; i < iter; i++) {
-      client.write('a');
-      assert.strictEqual(client.bufferSize, i + 1);
-    }
+        for (let i = 1; i < iter; i++) {
+          client.write('a');
+          assert.strictEqual(client.bufferSize, i + 1);
+        }
 
-    client.on('finish', common.mustCall(() => {
-      assert.strictEqual(client.bufferSize, 0);
-    }));
+        client.on(
+          'finish',
+          common.mustCall(() => {
+            assert.strictEqual(client.bufferSize, 0);
+          })
+        );
 
-    client.end();
-  }));
-}));
+        client.end();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-tls-ca-concat.js b/test/parallel/test-tls-ca-concat.js
index efec4e649c9506..396ade2856e922 100644
--- a/test/parallel/test-tls-ca-concat.js
+++ b/test/parallel/test-tls-ca-concat.js
@@ -5,20 +5,21 @@ const fixtures = require('../common/fixtures');
 // Check ca option can contain concatenated certs by prepending an unrelated
 // non-CA cert and showing that agent6's CA root is still found.
 
-const {
-  assert, connect, keys
-} = require(fixtures.path('tls-connect'));
+const { assert, connect, keys } = require(fixtures.path('tls-connect'));
 
-connect({
-  client: {
-    checkServerIdentity: (servername, cert) => { },
-    ca: `${keys.agent1.cert}\n${keys.agent6.ca}`,
+connect(
+  {
+    client: {
+      checkServerIdentity: (servername, cert) => {},
+      ca: `${keys.agent1.cert}\n${keys.agent6.ca}`
+    },
+    server: {
+      cert: keys.agent6.cert,
+      key: keys.agent6.key
+    }
   },
-  server: {
-    cert: keys.agent6.cert,
-    key: keys.agent6.key,
-  },
-}, common.mustCall((err, pair, cleanup) => {
-  assert.ifError(err);
-  return cleanup();
-}));
+  common.mustCall((err, pair, cleanup) => {
+    assert.ifError(err);
+    return cleanup();
+  })
+);
diff --git a/test/parallel/test-tls-canonical-ip.js b/test/parallel/test-tls-canonical-ip.js
index f5a4aab17a203e..796cb0b8dbf4e5 100644
--- a/test/parallel/test-tls-canonical-ip.js
+++ b/test/parallel/test-tls-canonical-ip.js
@@ -16,18 +16,25 @@ assert.strictEqual(canonicalizeIP('::1'), '::1');
 assert.strictEqual(canonicalizeIP('fe80:0:0:0:0:0:0:1'), 'fe80::1');
 assert.strictEqual(canonicalizeIP('fe80:0:0:0:0:0:0:0'), 'fe80::');
 assert.strictEqual(canonicalizeIP('fe80::0000:0010:0001'), 'fe80::10:1');
-assert.strictEqual(canonicalizeIP('0001:2222:3333:4444:5555:6666:7777:0088'),
-                   '1:2222:3333:4444:5555:6666:7777:88');
+assert.strictEqual(
+  canonicalizeIP('0001:2222:3333:4444:5555:6666:7777:0088'),
+  '1:2222:3333:4444:5555:6666:7777:88'
+);
 
-assert.strictEqual(canonicalizeIP('0001:2222:3333:4444:5555:6666::'),
-                   '1:2222:3333:4444:5555:6666::');
+assert.strictEqual(
+  canonicalizeIP('0001:2222:3333:4444:5555:6666::'),
+  '1:2222:3333:4444:5555:6666::'
+);
 
-assert.strictEqual(canonicalizeIP('a002:B12:00Ba:4444:5555:6666:0:0'),
-                   'a002:b12:ba:4444:5555:6666::');
+assert.strictEqual(
+  canonicalizeIP('a002:B12:00Ba:4444:5555:6666:0:0'),
+  'a002:b12:ba:4444:5555:6666::'
+);
 
 // IPv4 address represented in IPv6
-assert.strictEqual(canonicalizeIP('0:0:0:0:0:ffff:c0a8:101'),
-                   '::ffff:192.168.1.1');
+assert.strictEqual(
+  canonicalizeIP('0:0:0:0:0:ffff:c0a8:101'),
+  '::ffff:192.168.1.1'
+);
 
-assert.strictEqual(canonicalizeIP('::ffff:192.168.1.1'),
-                   '::ffff:192.168.1.1');
+assert.strictEqual(canonicalizeIP('::ffff:192.168.1.1'), '::ffff:192.168.1.1');
diff --git a/test/parallel/test-tls-cert-chains-concat.js b/test/parallel/test-tls-cert-chains-concat.js
index 1fc25fd7e7cc69..5546dc44fdf521 100644
--- a/test/parallel/test-tls-cert-chains-concat.js
+++ b/test/parallel/test-tls-cert-chains-concat.js
@@ -5,46 +5,47 @@ const fixtures = require('../common/fixtures');
 // Check cert chain is received by client, and is completed with the ca cert
 // known to the client.
 
-const {
-  assert, connect, debug, keys
-} = require(fixtures.path('tls-connect'));
+const { assert, connect, debug, keys } = require(fixtures.path('tls-connect'));
 
 // agent6-cert.pem includes cert for agent6 and ca3
-connect({
-  client: {
-    checkServerIdentity: (servername, cert) => { },
-    ca: keys.agent6.ca,
+connect(
+  {
+    client: {
+      checkServerIdentity: (servername, cert) => {},
+      ca: keys.agent6.ca
+    },
+    server: {
+      cert: keys.agent6.cert,
+      key: keys.agent6.key
+    }
   },
-  server: {
-    cert: keys.agent6.cert,
-    key: keys.agent6.key,
-  },
-}, common.mustCall((err, pair, cleanup) => {
-  assert.ifError(err);
-
-  const peer = pair.client.conn.getPeerCertificate();
-  debug('peer:\n', peer);
-  assert.strictEqual(peer.subject.emailAddress, 'adam.lippai@tresorit.com');
-  assert.strictEqual(peer.subject.CN, 'Ádám Lippai'),
-  assert.strictEqual(peer.issuer.CN, 'ca3');
-  assert.strictEqual(peer.serialNumber, 'D0082F458B6EFBE8');
-
-  const next = pair.client.conn.getPeerCertificate(true).issuerCertificate;
-  const root = next.issuerCertificate;
-  delete next.issuerCertificate;
-  debug('next:\n', next);
-  assert.strictEqual(next.subject.CN, 'ca3');
-  assert.strictEqual(next.issuer.CN, 'ca1');
-  assert.strictEqual(next.serialNumber, 'ECC9B856270DA9A7');
-
-  debug('root:\n', root);
-  assert.strictEqual(root.subject.CN, 'ca1');
-  assert.strictEqual(root.issuer.CN, 'ca1');
-  assert.strictEqual(root.serialNumber, 'CB153AE212609FC6');
-
-  // No client cert, so empty object returned.
-  assert.deepStrictEqual(pair.server.conn.getPeerCertificate(), {});
-  assert.deepStrictEqual(pair.server.conn.getPeerCertificate(true), {});
-
-  return cleanup();
-}));
+  common.mustCall((err, pair, cleanup) => {
+    assert.ifError(err);
+
+    const peer = pair.client.conn.getPeerCertificate();
+    debug('peer:\n', peer);
+    assert.strictEqual(peer.subject.emailAddress, 'adam.lippai@tresorit.com');
+    assert.strictEqual(peer.subject.CN, 'Ádám Lippai'),
+      assert.strictEqual(peer.issuer.CN, 'ca3');
+    assert.strictEqual(peer.serialNumber, 'D0082F458B6EFBE8');
+
+    const next = pair.client.conn.getPeerCertificate(true).issuerCertificate;
+    const root = next.issuerCertificate;
+    delete next.issuerCertificate;
+    debug('next:\n', next);
+    assert.strictEqual(next.subject.CN, 'ca3');
+    assert.strictEqual(next.issuer.CN, 'ca1');
+    assert.strictEqual(next.serialNumber, 'ECC9B856270DA9A7');
+
+    debug('root:\n', root);
+    assert.strictEqual(root.subject.CN, 'ca1');
+    assert.strictEqual(root.issuer.CN, 'ca1');
+    assert.strictEqual(root.serialNumber, 'CB153AE212609FC6');
+
+    // No client cert, so empty object returned.
+    assert.deepStrictEqual(pair.server.conn.getPeerCertificate(), {});
+    assert.deepStrictEqual(pair.server.conn.getPeerCertificate(true), {});
+
+    return cleanup();
+  })
+);
diff --git a/test/parallel/test-tls-cert-chains-in-ca.js b/test/parallel/test-tls-cert-chains-in-ca.js
index 0e834cc9bd11a2..7427ceb3d585ec 100644
--- a/test/parallel/test-tls-cert-chains-in-ca.js
+++ b/test/parallel/test-tls-cert-chains-in-ca.js
@@ -5,41 +5,41 @@ const fixtures = require('../common/fixtures');
 // Check cert chain is received by client, and is completed with the ca cert
 // known to the client.
 
-const {
-  assert, connect, debug, keys
-} = require(fixtures.path('tls-connect'));
-
+const { assert, connect, debug, keys } = require(fixtures.path('tls-connect'));
 
 // agent6-cert.pem includes cert for agent6 and ca3, split it apart and
 // provide ca3 in the .ca property.
 const agent6Chain = keys.agent6.cert.split(/(?=-----BEGIN CERTIFICATE-----)/);
 const agent6End = agent6Chain[0];
 const agent6Middle = agent6Chain[1];
-connect({
-  client: {
-    checkServerIdentity: (servername, cert) => { },
-    ca: keys.agent6.ca,
-  },
-  server: {
-    cert: agent6End,
-    key: keys.agent6.key,
-    ca: agent6Middle,
+connect(
+  {
+    client: {
+      checkServerIdentity: (servername, cert) => {},
+      ca: keys.agent6.ca
+    },
+    server: {
+      cert: agent6End,
+      key: keys.agent6.key,
+      ca: agent6Middle
+    }
   },
-}, function(err, pair, cleanup) {
-  assert.ifError(err);
+  function(err, pair, cleanup) {
+    assert.ifError(err);
 
-  const peer = pair.client.conn.getPeerCertificate();
-  debug('peer:\n', peer);
-  assert.strictEqual(peer.serialNumber, 'D0082F458B6EFBE8');
+    const peer = pair.client.conn.getPeerCertificate();
+    debug('peer:\n', peer);
+    assert.strictEqual(peer.serialNumber, 'D0082F458B6EFBE8');
 
-  const next = pair.client.conn.getPeerCertificate(true).issuerCertificate;
-  const root = next.issuerCertificate;
-  delete next.issuerCertificate;
-  debug('next:\n', next);
-  assert.strictEqual(next.serialNumber, 'ECC9B856270DA9A7');
+    const next = pair.client.conn.getPeerCertificate(true).issuerCertificate;
+    const root = next.issuerCertificate;
+    delete next.issuerCertificate;
+    debug('next:\n', next);
+    assert.strictEqual(next.serialNumber, 'ECC9B856270DA9A7');
 
-  debug('root:\n', root);
-  assert.strictEqual(root.serialNumber, 'CB153AE212609FC6');
+    debug('root:\n', root);
+    assert.strictEqual(root.serialNumber, 'CB153AE212609FC6');
 
-  return cleanup();
-});
+    return cleanup();
+  }
+);
diff --git a/test/parallel/test-tls-cert-regression.js b/test/parallel/test-tls-cert-regression.js
index 478402772eb0df..4c2b5f9636258e 100644
--- a/test/parallel/test-tls-cert-regression.js
+++ b/test/parallel/test-tls-cert-regression.js
@@ -22,13 +22,11 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
-const cert =
-`-----BEGIN CERTIFICATE-----
+const cert = `-----BEGIN CERTIFICATE-----
 MIIDNDCCAp2gAwIBAgIJAJvXLQpGPpm7MA0GCSqGSIb3DQEBBQUAMHAxCzAJBgNV
 BAYTAkdCMRAwDgYDVQQIEwdHd3luZWRkMREwDwYDVQQHEwhXYXVuZmF3cjEUMBIG
 A1UEChMLQWNrbmFjayBMdGQxEjAQBgNVBAsTCVRlc3QgQ2VydDESMBAGA1UEAxMJ
@@ -49,8 +47,7 @@ SBuhNrHes4U8QxS8+x/KWjd/81gzsf9J1C2VzTlFaydAgigz3SkQYgs+TMnFkT2o
 US7eCSHZsVo=
 -----END CERTIFICATE-----`;
 
-const key =
-`-----BEGIN RSA PRIVATE KEY-----
+const key = `-----BEGIN RSA PRIVATE KEY-----
 MIICXgIBAAKBgQDXcpu5xntssOi5SXya0LQuU5ijhq0l4sqJWAmxjsuMWSOCg99X
 d9Pe44ZUBSchftdIMJBOtg7iXny7wWQ1LLy3tUfG85VYWZwVZ/t0CclCFkAC/g7E
 Y/D9yqA+5N+t0DeXSGgNRjgINr2XD8tRwlLLzoLw1xkVAmajSwMrfof3KQIDAQAB
@@ -67,14 +64,20 @@ sPWhSOb9VQjMXekI4Y2l8fqAVTS2Fn6+8jkVKxXBywSVCw==
 -----END RSA PRIVATE KEY-----`;
 
 function test(cert, key, cb) {
-  const server = tls.createServer({
-    cert,
-    key
-  }).listen(0, function() {
-    server.close(cb);
-  });
+  const server = tls
+    .createServer({
+      cert,
+      key
+    })
+    .listen(0, function() {
+      server.close(cb);
+    });
 }
 
-test(cert, key, common.mustCall(function() {
-  test(Buffer.from(cert), Buffer.from(key), common.mustCall());
-}));
+test(
+  cert,
+  key,
+  common.mustCall(function() {
+    test(Buffer.from(cert), Buffer.from(key), common.mustCall());
+  })
+);
diff --git a/test/parallel/test-tls-check-server-identity.js b/test/parallel/test-tls-check-server-identity.js
index fe27770c1ebc84..5fa3c2d405bfce 100644
--- a/test/parallel/test-tls-check-server-identity.js
+++ b/test/parallel/test-tls-check-server-identity.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const util = require('util');
@@ -31,10 +30,12 @@ const util = require('util');
 const tls = require('tls');
 
 common.expectWarning('DeprecationWarning', [
-  ['The URI http://[a.b.a.com]/ found in cert.subjectaltname ' +
-  'is not a valid URI, and is supported in the tls module ' +
-  'solely for compatibility.',
-   'DEP0109'],
+  [
+    'The URI http://[a.b.a.com]/ found in cert.subjectaltname ' +
+      'is not a valid URI, and is supported in the tls module ' +
+      'solely for compatibility.',
+    'DEP0109'
+  ]
 ]);
 
 const tests = [
@@ -42,17 +43,17 @@ const tests = [
   {
     host: false,
     cert: { subject: { CN: 'a.com' } },
-    error: 'Host: false. is not cert\'s CN: a.com'
+    error: "Host: false. is not cert's CN: a.com"
   },
   {
     host: null,
     cert: { subject: { CN: 'a.com' } },
-    error: 'Host: null. is not cert\'s CN: a.com'
+    error: "Host: null. is not cert's CN: a.com"
   },
   {
     host: undefined,
     cert: { subject: { CN: 'a.com' } },
-    error: 'Host: undefined. is not cert\'s CN: a.com'
+    error: "Host: undefined. is not cert's CN: a.com"
   },
 
   // Basic CN handling
@@ -61,13 +62,13 @@ const tests = [
   {
     host: 'a.com',
     cert: { subject: { CN: 'b.com' } },
-    error: 'Host: a.com. is not cert\'s CN: b.com'
+    error: "Host: a.com. is not cert's CN: b.com"
   },
   { host: 'a.com', cert: { subject: { CN: 'a.com.' } } },
   {
     host: 'a.com',
     cert: { subject: { CN: '.a.com' } },
-    error: 'Host: a.com. is not cert\'s CN: .a.com'
+    error: "Host: a.com. is not cert's CN: .a.com"
   },
 
   // Wildcards in CN
@@ -75,86 +76,92 @@ const tests = [
   {
     host: 'ba.com',
     cert: { subject: { CN: '*.a.com' } },
-    error: 'Host: ba.com. is not cert\'s CN: *.a.com'
+    error: "Host: ba.com. is not cert's CN: *.a.com"
   },
   {
     host: '\n.b.com',
     cert: { subject: { CN: '*n.b.com' } },
-    error: 'Host: \n.b.com. is not cert\'s CN: *n.b.com'
+    error: "Host: \n.b.com. is not cert's CN: *n.b.com"
   },
-  { host: 'b.a.com', cert: {
-    subjectaltname: 'DNS:omg.com',
-    subject: { CN: '*.a.com' } },
-    error: 'Host: b.a.com. is not in the cert\'s altnames: ' +
-           'DNS:omg.com'
+  {
+    host: 'b.a.com',
+    cert: {
+      subjectaltname: 'DNS:omg.com',
+      subject: { CN: '*.a.com' }
+    },
+    error: "Host: b.a.com. is not in the cert's altnames: " + 'DNS:omg.com'
   },
   {
     host: 'b.a.com',
     cert: { subject: { CN: 'b*b.a.com' } },
-    error: 'Host: b.a.com. is not cert\'s CN: b*b.a.com'
+    error: "Host: b.a.com. is not cert's CN: b*b.a.com"
   },
 
   // Empty Cert
   {
     host: 'a.com',
-    cert: { },
+    cert: {},
     error: 'Cert is empty'
   },
 
   // Multiple CN fields
   {
-    host: 'foo.com', cert: {
+    host: 'foo.com',
+    cert: {
       subject: { CN: ['foo.com', 'bar.com'] } // CN=foo.com; CN=bar.com;
     }
   },
 
   // DNS names and CN
   {
-    host: 'a.com', cert: {
+    host: 'a.com',
+    cert: {
       subjectaltname: 'DNS:*',
       subject: { CN: 'b.com' }
     },
-    error: 'Host: a.com. is not in the cert\'s altnames: ' +
-           'DNS:*'
+    error: "Host: a.com. is not in the cert's altnames: " + 'DNS:*'
   },
   {
-    host: 'a.com', cert: {
+    host: 'a.com',
+    cert: {
       subjectaltname: 'DNS:*.com',
       subject: { CN: 'b.com' }
     },
-    error: 'Host: a.com. is not in the cert\'s altnames: ' +
-           'DNS:*.com'
+    error: "Host: a.com. is not in the cert's altnames: " + 'DNS:*.com'
   },
   {
-    host: 'a.co.uk', cert: {
+    host: 'a.co.uk',
+    cert: {
       subjectaltname: 'DNS:*.co.uk',
       subject: { CN: 'b.com' }
     }
   },
   {
-    host: 'a.com', cert: {
+    host: 'a.com',
+    cert: {
       subjectaltname: 'DNS:*.a.com',
       subject: { CN: 'a.com' }
     },
-    error: 'Host: a.com. is not in the cert\'s altnames: ' +
-           'DNS:*.a.com'
+    error: "Host: a.com. is not in the cert's altnames: " + 'DNS:*.a.com'
   },
   {
-    host: 'a.com', cert: {
+    host: 'a.com',
+    cert: {
       subjectaltname: 'DNS:*.a.com',
       subject: { CN: 'b.com' }
     },
-    error: 'Host: a.com. is not in the cert\'s altnames: ' +
-           'DNS:*.a.com'
+    error: "Host: a.com. is not in the cert's altnames: " + 'DNS:*.a.com'
   },
   {
-    host: 'a.com', cert: {
+    host: 'a.com',
+    cert: {
       subjectaltname: 'DNS:a.com',
       subject: { CN: 'b.com' }
     }
   },
   {
-    host: 'a.com', cert: {
+    host: 'a.com',
+    cert: {
       subjectaltname: 'DNS:A.COM',
       subject: { CN: 'b.com' }
     }
@@ -162,118 +169,130 @@ const tests = [
 
   // DNS names
   {
-    host: 'a.com', cert: {
+    host: 'a.com',
+    cert: {
       subjectaltname: 'DNS:*.a.com',
       subject: {}
     },
-    error: 'Host: a.com. is not in the cert\'s altnames: ' +
-           'DNS:*.a.com'
+    error: "Host: a.com. is not in the cert's altnames: " + 'DNS:*.a.com'
   },
   {
-    host: 'b.a.com', cert: {
+    host: 'b.a.com',
+    cert: {
       subjectaltname: 'DNS:*.a.com',
       subject: {}
     }
   },
   {
-    host: 'c.b.a.com', cert: {
+    host: 'c.b.a.com',
+    cert: {
       subjectaltname: 'DNS:*.a.com',
       subject: {}
     },
-    error: 'Host: c.b.a.com. is not in the cert\'s altnames: ' +
-           'DNS:*.a.com'
+    error: "Host: c.b.a.com. is not in the cert's altnames: " + 'DNS:*.a.com'
   },
   {
-    host: 'b.a.com', cert: {
+    host: 'b.a.com',
+    cert: {
       subjectaltname: 'DNS:*b.a.com',
       subject: {}
     }
   },
   {
-    host: 'a-cb.a.com', cert: {
+    host: 'a-cb.a.com',
+    cert: {
       subjectaltname: 'DNS:*b.a.com',
       subject: {}
     }
   },
   {
-    host: 'a.b.a.com', cert: {
+    host: 'a.b.a.com',
+    cert: {
       subjectaltname: 'DNS:*b.a.com',
       subject: {}
     },
-    error: 'Host: a.b.a.com. is not in the cert\'s altnames: ' +
-           'DNS:*b.a.com'
+    error: "Host: a.b.a.com. is not in the cert's altnames: " + 'DNS:*b.a.com'
   },
   // Multiple DNS names
   {
-    host: 'a.b.a.com', cert: {
+    host: 'a.b.a.com',
+    cert: {
       subjectaltname: 'DNS:*b.a.com, DNS:a.b.a.com',
       subject: {}
     }
   },
   // URI names
   {
-    host: 'a.b.a.com', cert: {
+    host: 'a.b.a.com',
+    cert: {
       subjectaltname: 'URI:http://a.b.a.com/',
       subject: {}
     }
   },
   {
-    host: 'a.b.a.com', cert: {
+    host: 'a.b.a.com',
+    cert: {
       subjectaltname: 'URI:http://*.b.a.com/',
       subject: {}
     },
-    error: 'Host: a.b.a.com. is not in the cert\'s altnames: ' +
-           'URI:http://*.b.a.com/'
+    error:
+      "Host: a.b.a.com. is not in the cert's altnames: " +
+      'URI:http://*.b.a.com/'
   },
   // Invalid URI
   {
-    host: 'a.b.a.com', cert: {
+    host: 'a.b.a.com',
+    cert: {
       subjectaltname: 'URI:http://[a.b.a.com]/',
       subject: {}
     }
   },
   // IP addresses
   {
-    host: 'a.b.a.com', cert: {
+    host: 'a.b.a.com',
+    cert: {
       subjectaltname: 'IP Address:127.0.0.1',
       subject: {}
     },
-    error: 'Host: a.b.a.com. is not in the cert\'s altnames: ' +
-           'IP Address:127.0.0.1'
+    error:
+      "Host: a.b.a.com. is not in the cert's altnames: " +
+      'IP Address:127.0.0.1'
   },
   {
-    host: '127.0.0.1', cert: {
+    host: '127.0.0.1',
+    cert: {
       subjectaltname: 'IP Address:127.0.0.1',
       subject: {}
     }
   },
   {
-    host: '127.0.0.2', cert: {
+    host: '127.0.0.2',
+    cert: {
       subjectaltname: 'IP Address:127.0.0.1',
       subject: {}
     },
-    error: 'IP: 127.0.0.2 is not in the cert\'s list: ' +
-           '127.0.0.1'
+    error: "IP: 127.0.0.2 is not in the cert's list: " + '127.0.0.1'
   },
   {
-    host: '127.0.0.1', cert: {
+    host: '127.0.0.1',
+    cert: {
       subjectaltname: 'DNS:a.com',
       subject: {}
     },
-    error: 'IP: 127.0.0.1 is not in the cert\'s list: '
+    error: "IP: 127.0.0.1 is not in the cert's list: "
   },
   {
-    host: 'localhost', cert: {
+    host: 'localhost',
+    cert: {
       subjectaltname: 'DNS:a.com',
       subject: { CN: 'localhost' }
     },
-    error: 'Host: localhost. is not in the cert\'s altnames: ' +
-           'DNS:a.com'
+    error: "Host: localhost. is not in the cert's altnames: " + 'DNS:a.com'
   },
   // IDNA
   {
     host: 'xn--bcher-kva.example.com',
-    cert: { subject: { CN: '*.example.com' } },
+    cert: { subject: { CN: '*.example.com' } }
   },
   // RFC 6125, section 6.4.3: "[...] the client SHOULD NOT attempt to match
   // a presented identifier where the wildcard character is embedded within
@@ -281,15 +300,18 @@ const tests = [
   {
     host: 'xn--bcher-kva.example.com',
     cert: { subject: { CN: 'xn--*.example.com' } },
-    error: 'Host: xn--bcher-kva.example.com. is not cert\'s CN: ' +
-            'xn--*.example.com',
-  },
+    error:
+      "Host: xn--bcher-kva.example.com. is not cert's CN: " +
+      'xn--*.example.com'
+  }
 ];
 
 tests.forEach(function(test, i) {
   const err = tls.checkServerIdentity(test.host, test.cert);
-  assert.strictEqual(err && err.reason,
-                     test.error,
-                     `Test# ${i} failed: ${util.inspect(test)} \n` +
-                     `${test.error} != ${(err && err.reason)}`);
+  assert.strictEqual(
+    err && err.reason,
+    test.error,
+    `Test# ${i} failed: ${util.inspect(test)} \n` +
+      `${test.error} != ${err && err.reason}`
+  );
 });
diff --git a/test/parallel/test-tls-cipher-list.js b/test/parallel/test-tls-cipher-list.js
index 4a39ee9391a7c1..d33a89ecc0df43 100644
--- a/test/parallel/test-tls-cipher-list.js
+++ b/test/parallel/test-tls-cipher-list.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
@@ -10,17 +9,16 @@ const defaultCoreList = require('crypto').constants.defaultCoreCipherList;
 
 function doCheck(arg, check) {
   let out = '';
-  arg = arg.concat([
-    '-pe',
-    'require("crypto").constants.defaultCipherList'
-  ]);
+  arg = arg.concat(['-pe', 'require("crypto").constants.defaultCipherList']);
   spawn(process.execPath, arg, {})
     .on('error', common.mustNotCall())
     .stdout.on('data', function(chunk) {
       out += chunk;
-    }).on('end', function() {
+    })
+    .on('end', function() {
       assert.strictEqual(out.trim(), check);
-    }).on('error', common.mustNotCall());
+    })
+    .on('error', common.mustNotCall());
 }
 
 // test the default unmodified version
diff --git a/test/parallel/test-tls-client-abort.js b/test/parallel/test-tls-client-abort.js
index 09f252db308881..6f532049adf6ae 100644
--- a/test/parallel/test-tls-client-abort.js
+++ b/test/parallel/test-tls-client-abort.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
@@ -30,6 +29,9 @@ const fixtures = require('../common/fixtures');
 const cert = fixtures.readSync('test_cert.pem');
 const key = fixtures.readSync('test_key.pem');
 
-const conn = tls.connect({ cert, key, port: 0 }, common.mustNotCall());
+const conn = tls.connect(
+  { cert, key, port: 0 },
+  common.mustNotCall()
+);
 conn.on('error', function() {});
 conn.destroy();
diff --git a/test/parallel/test-tls-client-abort2.js b/test/parallel/test-tls-client-abort2.js
index b253e6696c6b5c..326f170a65f429 100644
--- a/test/parallel/test-tls-client-abort2.js
+++ b/test/parallel/test-tls-client-abort2.js
@@ -21,12 +21,17 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
-const conn = tls.connect(0, common.mustNotCall());
-conn.on('error', common.mustCall(function() {
-  conn.destroy();
-}));
+const conn = tls.connect(
+  0,
+  common.mustNotCall()
+);
+conn.on(
+  'error',
+  common.mustCall(function() {
+    conn.destroy();
+  })
+);
diff --git a/test/parallel/test-tls-client-default-ciphers.js b/test/parallel/test-tls-client-default-ciphers.js
index 1596c8e981fbff..fdb12df3be5676 100644
--- a/test/parallel/test-tls-client-default-ciphers.js
+++ b/test/parallel/test-tls-client-default-ciphers.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
diff --git a/test/parallel/test-tls-client-destroy-soon.js b/test/parallel/test-tls-client-destroy-soon.js
index 1d49a6094bd7e6..8e373ae673459f 100644
--- a/test/parallel/test-tls-client-destroy-soon.js
+++ b/test/parallel/test-tls-client-destroy-soon.js
@@ -25,8 +25,7 @@
 // ASSERT resumption.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -40,28 +39,39 @@ const options = {
 const big = Buffer.alloc(2 * 1024 * 1024, 'Y');
 
 // create server
-const server = tls.createServer(options, common.mustCall(function(socket) {
-  socket.end(big);
-  socket.destroySoon();
-}));
+const server = tls.createServer(
+  options,
+  common.mustCall(function(socket) {
+    socket.end(big);
+    socket.destroySoon();
+  })
+);
 
 // start listening
-server.listen(0, common.mustCall(function() {
-  const client = tls.connect({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    let bytesRead = 0;
+server.listen(
+  0,
+  common.mustCall(function() {
+    const client = tls.connect(
+      {
+        port: this.address().port,
+        rejectUnauthorized: false
+      },
+      common.mustCall(function() {
+        let bytesRead = 0;
 
-    client.on('readable', function() {
-      const d = client.read();
-      if (d)
-        bytesRead += d.length;
-    });
+        client.on('readable', function() {
+          const d = client.read();
+          if (d) bytesRead += d.length;
+        });
 
-    client.on('end', common.mustCall(function() {
-      server.close();
-      assert.strictEqual(big.length, bytesRead);
-    }));
-  }));
-}));
+        client.on(
+          'end',
+          common.mustCall(function() {
+            server.close();
+            assert.strictEqual(big.length, bytesRead);
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-tls-client-getephemeralkeyinfo.js b/test/parallel/test-tls-client-getephemeralkeyinfo.js
index 9432a277ac0fd0..e5598499685968 100644
--- a/test/parallel/test-tls-client-getephemeralkeyinfo.js
+++ b/test/parallel/test-tls-client-getephemeralkeyinfo.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 
 const assert = require('assert');
@@ -18,9 +17,9 @@ function loadDHParam(n) {
 }
 
 const cipherlist = {
-  'NOT_PFS': 'AES128-SHA256',
-  'DH': 'DHE-RSA-AES128-GCM-SHA256',
-  'ECDH': 'ECDHE-RSA-AES128-GCM-SHA256'
+  NOT_PFS: 'AES128-SHA256',
+  DH: 'DHE-RSA-AES128-GCM-SHA256',
+  ECDH: 'ECDHE-RSA-AES128-GCM-SHA256'
 };
 
 function test(size, type, name, next) {
@@ -41,24 +40,34 @@ function test(size, type, name, next) {
     conn.end();
   });
 
-  server.on('close', common.mustCall(function(err) {
-    assert.ifError(err);
-    if (next) next();
-  }));
-
-  server.listen(0, '127.0.0.1', common.mustCall(function() {
-    const client = tls.connect({
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, function() {
-      const ekeyinfo = client.getEphemeralKeyInfo();
-      assert.strictEqual(ekeyinfo.type, type);
-      assert.strictEqual(ekeyinfo.size, size);
-      assert.strictEqual(ekeyinfo.name, name);
-      nsuccess++;
-      server.close();
-    });
-  }));
+  server.on(
+    'close',
+    common.mustCall(function(err) {
+      assert.ifError(err);
+      if (next) next();
+    })
+  );
+
+  server.listen(
+    0,
+    '127.0.0.1',
+    common.mustCall(function() {
+      const client = tls.connect(
+        {
+          port: this.address().port,
+          rejectUnauthorized: false
+        },
+        function() {
+          const ekeyinfo = client.getEphemeralKeyInfo();
+          assert.strictEqual(ekeyinfo.type, type);
+          assert.strictEqual(ekeyinfo.size, size);
+          assert.strictEqual(ekeyinfo.name, name);
+          nsuccess++;
+          server.close();
+        }
+      );
+    })
+  );
 }
 
 function testNOT_PFS() {
diff --git a/test/parallel/test-tls-client-mindhsize.js b/test/parallel/test-tls-client-mindhsize.js
index 3017d30e6c5e9e..268cab36d76494 100644
--- a/test/parallel/test-tls-client-mindhsize.js
+++ b/test/parallel/test-tls-client-mindhsize.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -38,14 +37,17 @@ function test(size, err, next) {
     // client set minimum DH parameter size to 2048 bits so that
     // it fails when it make a connection to the tls server where
     // dhparams is 1024 bits
-    const client = tls.connect({
-      minDHSize: 2048,
-      port: this.address().port,
-      rejectUnauthorized: false
-    }, function() {
-      nsuccess++;
-      server.close();
-    });
+    const client = tls.connect(
+      {
+        minDHSize: 2048,
+        port: this.address().port,
+        rejectUnauthorized: false
+      },
+      function() {
+        nsuccess++;
+        server.close();
+      }
+    );
     if (err) {
       client.on('error', function(e) {
         nerror++;
@@ -70,13 +72,14 @@ function testDHE2048() {
 
 testDHE1024();
 
-assert.throws(() => test(512, true, common.mustNotCall()),
-              /DH parameter is less than 1024 bits/);
+assert.throws(
+  () => test(512, true, common.mustNotCall()),
+  /DH parameter is less than 1024 bits/
+);
 
 let errMessage = /minDHSize is not a positive number/;
 [0, -1, -Infinity, NaN].forEach((minDHSize) => {
-  assert.throws(() => tls.connect({ minDHSize }),
-                errMessage);
+  assert.throws(() => tls.connect({ minDHSize }), errMessage);
 });
 
 errMessage = /minDHSize is not a number/;
diff --git a/test/parallel/test-tls-client-reject.js b/test/parallel/test-tls-client-reject.js
index 955d97da6fb6fc..748648539ab2df 100644
--- a/test/parallel/test-tls-client-reject.js
+++ b/test/parallel/test-tls-client-reject.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -33,49 +32,68 @@ const options = {
   cert: fixtures.readSync('test_cert.pem')
 };
 
-const server = tls.createServer(options, common.mustCall(function(socket) {
-  socket.on('data', function(data) {
-    console.error(data.toString());
-    assert.strictEqual(data.toString(), 'ok');
+const server = tls
+  .createServer(
+    options,
+    common.mustCall(function(socket) {
+      socket.on('data', function(data) {
+        console.error(data.toString());
+        assert.strictEqual(data.toString(), 'ok');
+      });
+    }, 3)
+  )
+  .listen(0, function() {
+    unauthorized();
   });
-}, 3)).listen(0, function() {
-  unauthorized();
-});
 
 function unauthorized() {
-  const socket = tls.connect({
-    port: server.address().port,
-    servername: 'localhost',
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    assert(!socket.authorized);
-    socket.end();
-    rejectUnauthorized();
-  }));
+  const socket = tls.connect(
+    {
+      port: server.address().port,
+      servername: 'localhost',
+      rejectUnauthorized: false
+    },
+    common.mustCall(function() {
+      assert(!socket.authorized);
+      socket.end();
+      rejectUnauthorized();
+    })
+  );
   socket.on('error', common.mustNotCall());
   socket.write('ok');
 }
 
 function rejectUnauthorized() {
-  const socket = tls.connect(server.address().port, {
-    servername: 'localhost'
-  }, common.mustNotCall());
-  socket.on('error', common.mustCall(function(err) {
-    console.error(err);
-    authorized();
-  }));
+  const socket = tls.connect(
+    server.address().port,
+    {
+      servername: 'localhost'
+    },
+    common.mustNotCall()
+  );
+  socket.on(
+    'error',
+    common.mustCall(function(err) {
+      console.error(err);
+      authorized();
+    })
+  );
   socket.write('ng');
 }
 
 function authorized() {
-  const socket = tls.connect(server.address().port, {
-    ca: [fixtures.readSync('test_cert.pem')],
-    servername: 'localhost'
-  }, common.mustCall(function() {
-    assert(socket.authorized);
-    socket.end();
-    server.close();
-  }));
+  const socket = tls.connect(
+    server.address().port,
+    {
+      ca: [fixtures.readSync('test_cert.pem')],
+      servername: 'localhost'
+    },
+    common.mustCall(function() {
+      assert(socket.authorized);
+      socket.end();
+      server.close();
+    })
+  );
   socket.on('error', common.mustNotCall());
   socket.write('ok');
 }
diff --git a/test/parallel/test-tls-client-resume.js b/test/parallel/test-tls-client-resume.js
index 296df88e9f9152..441362d7cc13f7 100644
--- a/test/parallel/test-tls-client-resume.js
+++ b/test/parallel/test-tls-client-resume.js
@@ -25,8 +25,7 @@
 // ASSERT resumption.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -38,22 +37,27 @@ const options = {
 };
 
 // create server
-const server = tls.Server(options, common.mustCall(function(socket) {
-  socket.end('Goodbye');
-}, 2));
+const server = tls.Server(
+  options,
+  common.mustCall(function(socket) {
+    socket.end('Goodbye');
+  }, 2)
+);
 
 // start listening
 server.listen(0, function() {
-
   let session1 = null;
-  const client1 = tls.connect({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, function() {
-    console.log('connect1');
-    assert.ok(!client1.isSessionReused(), 'Session *should not* be reused.');
-    session1 = client1.getSession();
-  });
+  const client1 = tls.connect(
+    {
+      port: this.address().port,
+      rejectUnauthorized: false
+    },
+    function() {
+      console.log('connect1');
+      assert.ok(!client1.isSessionReused(), 'Session *should not* be reused.');
+      session1 = client1.getSession();
+    }
+  );
 
   client1.on('close', function() {
     console.log('close1');
@@ -64,10 +68,13 @@ server.listen(0, function() {
       session: session1
     };
 
-    const client2 = tls.connect(opts, function() {
-      console.log('connect2');
-      assert.ok(client2.isSessionReused(), 'Session *should* be reused.');
-    });
+    const client2 = tls.connect(
+      opts,
+      function() {
+        console.log('connect2');
+        assert.ok(client2.isSessionReused(), 'Session *should* be reused.');
+      }
+    );
 
     client2.on('close', function() {
       console.log('close2');
diff --git a/test/parallel/test-tls-client-verify.js b/test/parallel/test-tls-client-verify.js
index 12d2514eed3a89..6f7a763db69b7e 100644
--- a/test/parallel/test-tls-client-verify.js
+++ b/test/parallel/test-tls-client-verify.js
@@ -21,15 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
 const testCases = [
-  { ca: ['ca1-cert'],
+  {
+    ca: ['ca1-cert'],
     key: 'agent2-key',
     cert: 'agent2-cert',
     servers: [
@@ -39,7 +39,8 @@ const testCases = [
     ]
   },
 
-  { ca: [],
+  {
+    ca: [],
     key: 'agent2-key',
     cert: 'agent2-cert',
     servers: [
@@ -49,7 +50,8 @@ const testCases = [
     ]
   },
 
-  { ca: ['ca1-cert', 'ca2-cert'],
+  {
+    ca: ['ca1-cert', 'ca2-cert'],
     key: 'agent2-key',
     cert: 'agent2-cert',
     servers: [
@@ -60,7 +62,6 @@ const testCases = [
   }
 ];
 
-
 function loadPEM(n) {
   return fixtures.readKey(`${n}.pem`);
 }
@@ -84,40 +85,55 @@ function testServers(index, servers, clientOptions, cb) {
     serverOptions.cert = loadPEM(serverOptions.cert);
   }
 
-  const server = tls.createServer(serverOptions, common.mustCall(function(s) {
-    s.end('hello world\n');
-  }));
-
-  server.listen(0, common.mustCall(function() {
-    let b = '';
-
-    console.error('connecting...');
-    clientOptions.port = this.address().port;
-    const client = tls.connect(clientOptions, common.mustCall(function() {
-      const authorized = client.authorized ||
-          (client.authorizationError === 'ERR_TLS_CERT_ALTNAME_INVALID');
-
-      console.error(`expected: ${ok} authed: ${authorized}`);
-
-      assert.strictEqual(authorized, ok);
-      server.close();
-    }));
-
-    client.on('data', function(d) {
-      b += d.toString();
-    });
-
-    client.on('end', common.mustCall(function() {
-      assert.strictEqual(b, 'hello world\n');
-    }));
-
-    client.on('close', common.mustCall(function() {
-      testServers(index + 1, servers, clientOptions, cb);
-    }));
-  }));
+  const server = tls.createServer(
+    serverOptions,
+    common.mustCall(function(s) {
+      s.end('hello world\n');
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(function() {
+      let b = '';
+
+      console.error('connecting...');
+      clientOptions.port = this.address().port;
+      const client = tls.connect(
+        clientOptions,
+        common.mustCall(function() {
+          const authorized =
+            client.authorized ||
+            client.authorizationError === 'ERR_TLS_CERT_ALTNAME_INVALID';
+
+          console.error(`expected: ${ok} authed: ${authorized}`);
+
+          assert.strictEqual(authorized, ok);
+          server.close();
+        })
+      );
+
+      client.on('data', function(d) {
+        b += d.toString();
+      });
+
+      client.on(
+        'end',
+        common.mustCall(function() {
+          assert.strictEqual(b, 'hello world\n');
+        })
+      );
+
+      client.on(
+        'close',
+        common.mustCall(function() {
+          testServers(index + 1, servers, clientOptions, cb);
+        })
+      );
+    })
+  );
 }
 
-
 function runTest(testIndex) {
   const tcase = testCases[testIndex];
   if (!tcase) return;
@@ -130,17 +146,19 @@ function runTest(testIndex) {
     rejectUnauthorized: false
   };
 
-
-  testServers(0, tcase.servers, clientOptions, common.mustCall(function() {
-    successfulTests++;
-    runTest(testIndex + 1);
-  }));
+  testServers(
+    0,
+    tcase.servers,
+    clientOptions,
+    common.mustCall(function() {
+      successfulTests++;
+      runTest(testIndex + 1);
+    })
+  );
 }
 
-
 runTest(0);
 
-
 process.on('exit', function() {
   console.log(`successful tests: ${successfulTests}`);
   assert.strictEqual(successfulTests, testCases.length);
diff --git a/test/parallel/test-tls-clientcertengine-invalid-arg-type.js b/test/parallel/test-tls-clientcertengine-invalid-arg-type.js
index b91e0f35c4c384..8f86c17e9bd03b 100644
--- a/test/parallel/test-tls-clientcertengine-invalid-arg-type.js
+++ b/test/parallel/test-tls-clientcertengine-invalid-arg-type.js
@@ -1,14 +1,15 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
 {
   common.expectsError(
-    () => { tls.createSecureContext({ clientCertEngine: 0 }); },
-    { code: 'ERR_INVALID_ARG_TYPE',
-      message: / Received type number$/ });
+    () => {
+      tls.createSecureContext({ clientCertEngine: 0 });
+    },
+    { code: 'ERR_INVALID_ARG_TYPE', message: / Received type number$/ }
+  );
 }
diff --git a/test/parallel/test-tls-clientcertengine-unsupported.js b/test/parallel/test-tls-clientcertengine-unsupported.js
index 34b4ea49218194..ee8bc80b3d8fcd 100644
--- a/test/parallel/test-tls-clientcertengine-unsupported.js
+++ b/test/parallel/test-tls-clientcertengine-unsupported.js
@@ -2,8 +2,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // Monkey-patch SecureContext
 const { internalBinding } = require('internal/test/binding');
@@ -20,7 +19,9 @@ const tls = require('tls');
 
 {
   common.expectsError(
-    () => { tls.createSecureContext({ clientCertEngine: 'Cannonmouth' }); },
+    () => {
+      tls.createSecureContext({ clientCertEngine: 'Cannonmouth' });
+    },
     {
       code: 'ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED',
       message: 'Custom engines not supported by this OpenSSL'
diff --git a/test/parallel/test-tls-close-error.js b/test/parallel/test-tls-close-error.js
index de51b4686a93a4..c919f97b3bec9d 100644
--- a/test/parallel/test-tls-close-error.js
+++ b/test/parallel/test-tls-close-error.js
@@ -1,24 +1,36 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
-const server = tls.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem')
-}, function(c) {
-}).listen(0, common.mustCall(function() {
-  const c = tls.connect(this.address().port, common.mustNotCall());
+const server = tls
+  .createServer(
+    {
+      key: fixtures.readKey('agent1-key.pem'),
+      cert: fixtures.readKey('agent1-cert.pem')
+    },
+    function(c) {}
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const c = tls.connect(
+        this.address().port,
+        common.mustNotCall()
+      );
 
-  c.on('error', common.mustCall());
+      c.on('error', common.mustCall());
 
-  c.on('close', common.mustCall(function(err) {
-    assert.ok(err);
-    server.close();
-  }));
-}));
+      c.on(
+        'close',
+        common.mustCall(function(err) {
+          assert.ok(err);
+          server.close();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-close-notify.js b/test/parallel/test-tls-close-notify.js
index 808727b12739b2..c86dd7ef753891 100644
--- a/test/parallel/test-tls-close-notify.js
+++ b/test/parallel/test-tls-close-notify.js
@@ -23,31 +23,45 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const { internalBinding } = require('internal/test/binding');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 const { ShutdownWrap } = internalBinding('stream_wrap');
 
-const server = tls.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem')
-}, function(c) {
-  // Send close-notify without shutting down TCP socket
-  const req = new ShutdownWrap();
-  req.oncomplete = common.mustCall(() => {});
-  req.handle = c._handle;
-  c._handle.shutdown(req);
-}).listen(0, common.mustCall(function() {
-  const c = tls.connect(this.address().port, {
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    // Ensure that we receive 'end' event anyway
-    c.on('end', common.mustCall(function() {
-      c.destroy();
-      server.close();
-    }));
-  }));
-}));
+const server = tls
+  .createServer(
+    {
+      key: fixtures.readKey('agent1-key.pem'),
+      cert: fixtures.readKey('agent1-cert.pem')
+    },
+    function(c) {
+      // Send close-notify without shutting down TCP socket
+      const req = new ShutdownWrap();
+      req.oncomplete = common.mustCall(() => {});
+      req.handle = c._handle;
+      c._handle.shutdown(req);
+    }
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const c = tls.connect(
+        this.address().port,
+        {
+          rejectUnauthorized: false
+        },
+        common.mustCall(function() {
+          // Ensure that we receive 'end' event anyway
+          c.on(
+            'end',
+            common.mustCall(function() {
+              c.destroy();
+              server.close();
+            })
+          );
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-cnnic-whitelist.js b/test/parallel/test-tls-cnnic-whitelist.js
index e08e93013f6aca..391b7c1afd34b8 100644
--- a/test/parallel/test-tls-cnnic-whitelist.js
+++ b/test/parallel/test-tls-cnnic-whitelist.js
@@ -2,8 +2,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -39,18 +38,28 @@ function runTest(tindex) {
 
   if (!tcase) return;
 
-  const server = tls.createServer(tcase.serverOpts, (s) => {
-    s.resume();
-  }).listen(0, common.mustCall(function() {
-    tcase.clientOpts.port = this.address().port;
-    const client = tls.connect(tcase.clientOpts);
-    client.on('error', common.mustCall((e) => {
-      assert.strictEqual(e.code, tcase.errorCode);
-      server.close(common.mustCall(() => {
-        runTest(tindex + 1);
-      }));
-    }));
-  }));
+  const server = tls
+    .createServer(tcase.serverOpts, (s) => {
+      s.resume();
+    })
+    .listen(
+      0,
+      common.mustCall(function() {
+        tcase.clientOpts.port = this.address().port;
+        const client = tls.connect(tcase.clientOpts);
+        client.on(
+          'error',
+          common.mustCall((e) => {
+            assert.strictEqual(e.code, tcase.errorCode);
+            server.close(
+              common.mustCall(() => {
+                runTest(tindex + 1);
+              })
+            );
+          })
+        );
+      })
+    );
 }
 
 runTest(0);
diff --git a/test/parallel/test-tls-connect-address-family.js b/test/parallel/test-tls-connect-address-family.js
index 569688ca8abd18..9564e1c6002d5b 100644
--- a/test/parallel/test-tls-connect-address-family.js
+++ b/test/parallel/test-tls-connect-address-family.js
@@ -1,10 +1,8 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.hasIPv6)
-  common.skip('no IPv6 support');
+if (!common.hasIPv6) common.skip('no IPv6 support');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -12,24 +10,36 @@ const tls = require('tls');
 const dns = require('dns');
 
 function runTest() {
-  tls.createServer({
-    cert: fixtures.readKey('agent1-cert.pem'),
-    key: fixtures.readKey('agent1-key.pem'),
-  }, common.mustCall(function() {
-    this.close();
-  })).listen(0, '::1', common.mustCall(function() {
-    const options = {
-      host: 'localhost',
-      port: this.address().port,
-      family: 6,
-      rejectUnauthorized: false,
-    };
-    // Will fail with ECONNREFUSED if the address family is not honored.
-    tls.connect(options).once('secureConnect', common.mustCall(function() {
-      assert.strictEqual(this.remoteAddress, '::1');
-      this.destroy();
-    }));
-  }));
+  tls
+    .createServer(
+      {
+        cert: fixtures.readKey('agent1-cert.pem'),
+        key: fixtures.readKey('agent1-key.pem')
+      },
+      common.mustCall(function() {
+        this.close();
+      })
+    )
+    .listen(
+      0,
+      '::1',
+      common.mustCall(function() {
+        const options = {
+          host: 'localhost',
+          port: this.address().port,
+          family: 6,
+          rejectUnauthorized: false
+        };
+        // Will fail with ECONNREFUSED if the address family is not honored.
+        tls.connect(options).once(
+          'secureConnect',
+          common.mustCall(function() {
+            assert.strictEqual(this.remoteAddress, '::1');
+            this.destroy();
+          })
+        );
+      })
+    );
 }
 
 dns.lookup('localhost', { family: 6, all: true }, (err, addresses) => {
@@ -40,8 +50,6 @@ dns.lookup('localhost', { family: 6, all: true }, (err, addresses) => {
     throw err;
   }
 
-  if (addresses.some((val) => val.address === '::1'))
-    runTest();
-  else
-    common.skip('localhost does not resolve to ::1');
+  if (addresses.some((val) => val.address === '::1')) runTest();
+  else common.skip('localhost does not resolve to ::1');
 });
diff --git a/test/parallel/test-tls-connect-given-socket.js b/test/parallel/test-tls-connect-given-socket.js
index 5fc5603dd1653b..ed60acce3765b3 100644
--- a/test/parallel/test-tls-connect-given-socket.js
+++ b/test/parallel/test-tls-connect-given-socket.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 
 const assert = require('assert');
@@ -34,52 +33,74 @@ const options = {
   cert: fixtures.readSync('test_cert.pem')
 };
 
-const server = tls.createServer(options, common.mustCall((socket) => {
-  socket.end('Hello');
-}, 2)).listen(0, common.mustCall(() => {
-  let waiting = 2;
-  function establish(socket, calls) {
-    const client = tls.connect({
-      rejectUnauthorized: false,
-      socket: socket
-    }, common.mustCall(() => {
-      let data = '';
-      client.on('data', common.mustCall((chunk) => {
-        data += chunk.toString();
-      }));
-      client.on('end', common.mustCall(() => {
-        assert.strictEqual(data, 'Hello');
-        if (--waiting === 0)
-          server.close();
-      }));
-    }, calls));
-    assert(client.readable);
-    assert(client.writable);
+const server = tls
+  .createServer(
+    options,
+    common.mustCall((socket) => {
+      socket.end('Hello');
+    }, 2)
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      let waiting = 2;
+      function establish(socket, calls) {
+        const client = tls.connect(
+          {
+            rejectUnauthorized: false,
+            socket: socket
+          },
+          common.mustCall(() => {
+            let data = '';
+            client.on(
+              'data',
+              common.mustCall((chunk) => {
+                data += chunk.toString();
+              })
+            );
+            client.on(
+              'end',
+              common.mustCall(() => {
+                assert.strictEqual(data, 'Hello');
+                if (--waiting === 0) server.close();
+              })
+            );
+          }, calls)
+        );
+        assert(client.readable);
+        assert(client.writable);
 
-    return client;
-  }
+        return client;
+      }
 
-  const { port } = server.address();
+      const { port } = server.address();
 
-  // Immediate death socket
-  const immediateDeath = net.connect(port);
-  establish(immediateDeath, 0).destroy();
+      // Immediate death socket
+      const immediateDeath = net.connect(port);
+      establish(immediateDeath, 0).destroy();
 
-  // Outliving
-  const outlivingTCP = net.connect(port, common.mustCall(() => {
-    outlivingTLS.destroy();
-    next();
-  }));
-  const outlivingTLS = establish(outlivingTCP, 0);
+      // Outliving
+      const outlivingTCP = net.connect(
+        port,
+        common.mustCall(() => {
+          outlivingTLS.destroy();
+          next();
+        })
+      );
+      const outlivingTLS = establish(outlivingTCP, 0);
 
-  function next() {
-    // Already connected socket
-    const connected = net.connect(port, common.mustCall(() => {
-      establish(connected);
-    }));
+      function next() {
+        // Already connected socket
+        const connected = net.connect(
+          port,
+          common.mustCall(() => {
+            establish(connected);
+          })
+        );
 
-    // Connecting socket
-    const connecting = net.connect(port);
-    establish(connecting);
-  }
-}));
+        // Connecting socket
+        const connecting = net.connect(port);
+        establish(connecting);
+      }
+    })
+  );
diff --git a/test/parallel/test-tls-connect-memleak.js b/test/parallel/test-tls-connect-memleak.js
index 0278e6c7159a68..36cc2de22c4d93 100644
--- a/test/parallel/test-tls-connect-memleak.js
+++ b/test/parallel/test-tls-connect-memleak.js
@@ -23,8 +23,7 @@
 // Flags: --expose-gc
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const onGC = require('../common/ongc');
 const assert = require('assert');
@@ -34,13 +33,19 @@ const fixtures = require('../common/fixtures');
 // Test that the implicit listener for an 'connect' event on tls.Sockets is
 // added using `once()`, i.e. can be gc'ed once that event has occurred.
 
-const server = tls.createServer({
-  cert: fixtures.readSync('test_cert.pem'),
-  key: fixtures.readSync('test_key.pem')
-}).listen(0);
+const server = tls
+  .createServer({
+    cert: fixtures.readSync('test_cert.pem'),
+    key: fixtures.readSync('test_key.pem')
+  })
+  .listen(0);
 
 let collected = false;
-const gcListener = { ongc() { collected = true; } };
+const gcListener = {
+  ongc() {
+    collected = true;
+  }
+};
 
 {
   const gcObject = {};
@@ -53,7 +58,8 @@ const gcListener = { ongc() { collected = true; } };
       assert.strictEqual(gcObject, gcObject); // keep reference alive
       assert.strictEqual(collected, false);
       setImmediate(done, sock);
-    }));
+    })
+  );
 }
 
 function done(sock) {
diff --git a/test/parallel/test-tls-connect-no-host.js b/test/parallel/test-tls-connect-no-host.js
index f6384743ac7081..c0d0f2e09fdbb4 100644
--- a/test/parallel/test-tls-connect-no-host.js
+++ b/test/parallel/test-tls-connect-no-host.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const assert = require('assert');
@@ -14,20 +13,28 @@ const key = fixtures.readSync('test_key.pem');
 // https://github.com/nodejs/node/issues/1489
 // tls.connect(options) with no options.host should accept a cert with
 //   CN:'localhost'
-const server = tls.createServer({
-  key,
-  cert
-}).listen(0, common.mustCall(function() {
-  const socket = tls.connect({
-    port: this.address().port,
-    ca: cert,
-    // No host set here. 'localhost' is the default,
-    // but tls.checkServerIdentity() breaks before the fix with:
-    // Error: Hostname/IP doesn't match certificate's altnames:
-    //   "Host: undefined. is not cert's CN: localhost"
-  }, common.mustCall(function() {
-    assert(socket.authorized);
-    socket.destroy();
-    server.close();
-  }));
-}));
+const server = tls
+  .createServer({
+    key,
+    cert
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      const socket = tls.connect(
+        {
+          port: this.address().port,
+          ca: cert
+          // No host set here. 'localhost' is the default,
+          // but tls.checkServerIdentity() breaks before the fix with:
+          // Error: Hostname/IP doesn't match certificate's altnames:
+          //   "Host: undefined. is not cert's CN: localhost"
+        },
+        common.mustCall(function() {
+          assert(socket.authorized);
+          socket.destroy();
+          server.close();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-connect-pipe.js b/test/parallel/test-tls-connect-pipe.js
index 88e78b7a2b2e59..33ad4e3b866591 100644
--- a/test/parallel/test-tls-connect-pipe.js
+++ b/test/parallel/test-tls-connect-pipe.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
@@ -36,12 +35,22 @@ const options = {
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-const server = tls.Server(options, common.mustCall(function(socket) {
-  server.close();
-}));
-server.listen(common.PIPE, common.mustCall(function() {
-  const options = { rejectUnauthorized: false };
-  const client = tls.connect(common.PIPE, options, common.mustCall(function() {
-    client.end();
-  }));
-}));
+const server = tls.Server(
+  options,
+  common.mustCall(function(socket) {
+    server.close();
+  })
+);
+server.listen(
+  common.PIPE,
+  common.mustCall(function() {
+    const options = { rejectUnauthorized: false };
+    const client = tls.connect(
+      common.PIPE,
+      options,
+      common.mustCall(function() {
+        client.end();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-tls-connect-secure-context.js b/test/parallel/test-tls-connect-secure-context.js
index afa98cf3313b6f..f2547e1c51c2c8 100644
--- a/test/parallel/test-tls-connect-secure-context.js
+++ b/test/parallel/test-tls-connect-secure-context.js
@@ -4,22 +4,23 @@ require('../common');
 // Verify connection with explicitly created client SecureContext.
 
 const fixtures = require('../common/fixtures');
-const {
-  assert, connect, keys, tls
-} = require(fixtures.path('tls-connect'));
+const { assert, connect, keys, tls } = require(fixtures.path('tls-connect'));
 
-connect({
-  client: {
-    servername: 'agent1',
-    secureContext: tls.createSecureContext({
-      ca: keys.agent1.ca,
-    }),
+connect(
+  {
+    client: {
+      servername: 'agent1',
+      secureContext: tls.createSecureContext({
+        ca: keys.agent1.ca
+      })
+    },
+    server: {
+      cert: keys.agent1.cert,
+      key: keys.agent1.key
+    }
   },
-  server: {
-    cert: keys.agent1.cert,
-    key: keys.agent1.key,
-  },
-}, function(err, pair, cleanup) {
-  assert.ifError(err);
-  return cleanup();
-});
+  function(err, pair, cleanup) {
+    assert.ifError(err);
+    return cleanup();
+  }
+);
diff --git a/test/parallel/test-tls-connect-simple.js b/test/parallel/test-tls-connect-simple.js
index 633529d6d3ccb1..cc4ec90069bf25 100644
--- a/test/parallel/test-tls-connect-simple.js
+++ b/test/parallel/test-tls-connect-simple.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
@@ -35,28 +34,37 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = tls.Server(options, common.mustCall(function(socket) {
-  if (++serverConnected === 2) {
-    server.close(common.mustCall());
-    server.on('close', common.mustCall());
-  }
-}, 2));
+const server = tls.Server(
+  options,
+  common.mustCall(function(socket) {
+    if (++serverConnected === 2) {
+      server.close(common.mustCall());
+      server.on('close', common.mustCall());
+    }
+  }, 2)
+);
 
 server.listen(0, function() {
   const client1options = {
     port: this.address().port,
     rejectUnauthorized: false
   };
-  const client1 = tls.connect(client1options, common.mustCall(function() {
-    client1.end();
-  }));
+  const client1 = tls.connect(
+    client1options,
+    common.mustCall(function() {
+      client1.end();
+    })
+  );
 
   const client2options = {
     port: this.address().port,
     rejectUnauthorized: false
   };
   const client2 = tls.connect(client2options);
-  client2.on('secureConnect', common.mustCall(function() {
-    client2.end();
-  }));
+  client2.on(
+    'secureConnect',
+    common.mustCall(function() {
+      client2.end();
+    })
+  );
 });
diff --git a/test/parallel/test-tls-connect-stream-writes.js b/test/parallel/test-tls-connect-stream-writes.js
index 0c6ae2b660d502..845327e235ac3e 100644
--- a/test/parallel/test-tls-connect-stream-writes.js
+++ b/test/parallel/test-tls-connect-stream-writes.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -9,10 +8,12 @@ const stream = require('stream');
 const net = require('net');
 const fixtures = require('../common/fixtures');
 
-const options = { key: fixtures.readSync('test_key.pem'),
-                  cert: fixtures.readSync('test_cert.pem'),
-                  ca: [ fixtures.readSync('test_ca.pem') ],
-                  ciphers: 'AES256-GCM-SHA384' };
+const options = {
+  key: fixtures.readSync('test_key.pem'),
+  cert: fixtures.readSync('test_cert.pem'),
+  ca: [fixtures.readSync('test_ca.pem')],
+  ciphers: 'AES256-GCM-SHA384'
+};
 const content = 'hello world';
 const recv_bufs = [];
 let send_data = '';
@@ -26,8 +27,7 @@ server.listen(0, function() {
 
   let pending = false;
   raw.on('readable', function() {
-    if (pending)
-      p._read();
+    if (pending) p._read();
   });
 
   const p = new stream.Duplex({
@@ -46,20 +46,23 @@ server.listen(0, function() {
     }
   });
 
-  const socket = tls.connect({
-    socket: p,
-    rejectUnauthorized: false
-  }, function() {
-    for (let i = 0; i < 50; ++i) {
-      socket.write(content);
-      send_data += content;
+  const socket = tls.connect(
+    {
+      socket: p,
+      rejectUnauthorized: false
+    },
+    function() {
+      for (let i = 0; i < 50; ++i) {
+        socket.write(content);
+        send_data += content;
+      }
+      socket.end();
+      server.close();
     }
-    socket.end();
-    server.close();
-  });
+  );
 });
 
 process.on('exit', function() {
-  const recv_data = (Buffer.concat(recv_bufs)).toString();
+  const recv_data = Buffer.concat(recv_bufs).toString();
   assert.strictEqual(send_data, recv_data);
 });
diff --git a/test/parallel/test-tls-delayed-attach-error.js b/test/parallel/test-tls-delayed-attach-error.js
index 69a35f011ea774..a829e2d2780127 100644
--- a/test/parallel/test-tls-delayed-attach-error.js
+++ b/test/parallel/test-tls-delayed-attach-error.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const net = require('net');
@@ -15,22 +14,32 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = net.createServer(common.mustCall(function(c) {
-  setTimeout(common.mustCall(function() {
-    const s = new tls.TLSSocket(c, {
-      isServer: true,
-      secureContext: tls.createSecureContext(options)
-    });
+const server = net
+  .createServer(
+    common.mustCall(function(c) {
+      setTimeout(
+        common.mustCall(function() {
+          const s = new tls.TLSSocket(c, {
+            isServer: true,
+            secureContext: tls.createSecureContext(options)
+          });
 
-    s.on('_tlsError', common.mustCall());
+          s.on('_tlsError', common.mustCall());
 
-    s.on('close', function() {
-      server.close();
-      s.destroy();
-    });
-  }), 200);
-})).listen(0, function() {
-  const c = net.connect({ port: this.address().port }, function() {
-    c.write(bonkers);
+          s.on('close', function() {
+            server.close();
+            s.destroy();
+          });
+        }),
+        200
+      );
+    })
+  )
+  .listen(0, function() {
+    const c = net.connect(
+      { port: this.address().port },
+      function() {
+        c.write(bonkers);
+      }
+    );
   });
-});
diff --git a/test/parallel/test-tls-delayed-attach.js b/test/parallel/test-tls-delayed-attach.js
index b756db2d67ca5f..74928bb3f5c426 100644
--- a/test/parallel/test-tls-delayed-attach.js
+++ b/test/parallel/test-tls-delayed-attach.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // This test tries to confirm that a TLS Socket will work as expected even if it
 // is created after the original socket has received some data.
@@ -43,29 +42,43 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = net.createServer(common.mustCall((c) => {
-  setTimeout(function() {
-    const s = new tls.TLSSocket(c, {
-      isServer: true,
-      secureContext: tls.createSecureContext(options)
-    });
+const server = net
+  .createServer(
+    common.mustCall((c) => {
+      setTimeout(function() {
+        const s = new tls.TLSSocket(c, {
+          isServer: true,
+          secureContext: tls.createSecureContext(options)
+        });
 
-    s.on('data', (chunk) => {
-      received += chunk;
-    });
+        s.on('data', (chunk) => {
+          received += chunk;
+        });
 
-    s.on('end', common.mustCall(() => {
-      server.close();
-      s.destroy();
-    }));
-  }, 200);
-})).listen(0, common.mustCall(() => {
-  const c = tls.connect(server.address().port, {
-    rejectUnauthorized: false
-  }, () => {
-    c.end(sent);
-  });
-}));
+        s.on(
+          'end',
+          common.mustCall(() => {
+            server.close();
+            s.destroy();
+          })
+        );
+      }, 200);
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const c = tls.connect(
+        server.address().port,
+        {
+          rejectUnauthorized: false
+        },
+        () => {
+          c.end(sent);
+        }
+      );
+    })
+  );
 
 process.on('exit', () => {
   assert.strictEqual(received, sent);
diff --git a/test/parallel/test-tls-destroy-stream.js b/test/parallel/test-tls-destroy-stream.js
index eb7a2ca338bd40..bd98c22f8633ce 100644
--- a/test/parallel/test-tls-destroy-stream.js
+++ b/test/parallel/test-tls-destroy-stream.js
@@ -18,52 +18,67 @@ const tlsServer = tls.createServer(
   {
     key: fixtures.readSync('test_key.pem'),
     cert: fixtures.readSync('test_cert.pem'),
-    ca: [fixtures.readSync('test_ca.pem')],
+    ca: [fixtures.readSync('test_ca.pem')]
   },
   (socket) => {
     socket.on('error', common.mustNotCall());
     socket.on('close', common.mustCall());
     socket.write(CONTENT);
     socket.destroy();
-  },
+  }
 );
 
 const server = net.createServer((conn) => {
   conn.on('error', common.mustNotCall());
   // Assume that we want to use data to determine what to do with connections.
-  conn.once('data', common.mustCall((chunk) => {
-    const { clientSide, serverSide } = makeDuplexPair();
-    serverSide.on('close', common.mustCall(() => {
-      conn.destroy();
-    }));
-    clientSide.pipe(conn);
-    conn.pipe(clientSide);
+  conn.once(
+    'data',
+    common.mustCall((chunk) => {
+      const { clientSide, serverSide } = makeDuplexPair();
+      serverSide.on(
+        'close',
+        common.mustCall(() => {
+          conn.destroy();
+        })
+      );
+      clientSide.pipe(conn);
+      conn.pipe(clientSide);
 
-    conn.on('close', common.mustCall(() => {
-      clientSide.destroy();
-    }));
-    clientSide.on('close', common.mustCall(() => {
-      conn.destroy();
-    }));
+      conn.on(
+        'close',
+        common.mustCall(() => {
+          clientSide.destroy();
+        })
+      );
+      clientSide.on(
+        'close',
+        common.mustCall(() => {
+          conn.destroy();
+        })
+      );
 
-    process.nextTick(() => {
-      conn.unshift(chunk);
-    });
+      process.nextTick(() => {
+        conn.unshift(chunk);
+      });
 
-    tlsServer.emit('connection', serverSide);
-  }));
+      tlsServer.emit('connection', serverSide);
+    })
+  );
 });
 
 server.listen(0, () => {
   const port = server.address().port;
-  const conn = tls.connect({ port, rejectUnauthorized: false }, () => {
-    conn.on('data', common.mustCall((data) => {
-      assert.strictEqual(data.toString('utf8'), CONTENT);
-    }));
-    conn.on('error', common.mustNotCall());
-    conn.on(
-      'close',
-      common.mustCall(() => server.close()),
-    );
-  });
+  const conn = tls.connect(
+    { port, rejectUnauthorized: false },
+    () => {
+      conn.on(
+        'data',
+        common.mustCall((data) => {
+          assert.strictEqual(data.toString('utf8'), CONTENT);
+        })
+      );
+      conn.on('error', common.mustNotCall());
+      conn.on('close', common.mustCall(() => server.close()));
+    }
+  );
 });
diff --git a/test/parallel/test-tls-destroy-whilst-write.js b/test/parallel/test-tls-destroy-whilst-write.js
index d157c7bf3f82b5..4a267c07e6a74b 100644
--- a/test/parallel/test-tls-destroy-whilst-write.js
+++ b/test/parallel/test-tls-destroy-whilst-write.js
@@ -1,15 +1,13 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const stream = require('stream');
 
 const delay = new stream.Duplex({
-  read: function read() {
-  },
+  read: function read() {},
   write: function write(data, enc, cb) {
     console.log('pending');
     setImmediate(function() {
diff --git a/test/parallel/test-tls-dhe.js b/test/parallel/test-tls-dhe.js
index 86130aff262ab5..cf5f40cb52373b 100644
--- a/test/parallel/test-tls-dhe.js
+++ b/test/parallel/test-tls-dhe.js
@@ -22,11 +22,9 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('missing openssl-cli');
+if (!common.opensslCli) common.skip('missing openssl-cli');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -40,14 +38,15 @@ let ntests = 0;
 const ciphers = 'DHE-RSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256';
 
 // Test will emit a warning because the DH parameter size is < 2048 bits
-common.expectWarning('SecurityWarning',
-                     'DH parameter is less than 2048 bits',
-                     common.noWarnCode);
+common.expectWarning(
+  'SecurityWarning',
+  'DH parameter is less than 2048 bits',
+  common.noWarnCode
+);
 
 function loadDHParam(n) {
   const params = [`dh${n}.pem`];
-  if (n !== 'error')
-    params.unshift('keys');
+  if (n !== 'error') params.unshift('keys');
   return fixtures.readSync(params);
 }
 
@@ -69,8 +68,13 @@ function test(keylen, expectedCipher, cb) {
   });
 
   server.listen(0, '127.0.0.1', function() {
-    const args = ['s_client', '-connect', `127.0.0.1:${this.address().port}`,
-                  '-cipher', ciphers];
+    const args = [
+      's_client',
+      '-connect',
+      `127.0.0.1:${this.address().port}`,
+      '-cipher',
+      ciphers
+    ];
 
     const client = spawn(common.opensslCli, args);
     let out = '';
diff --git a/test/parallel/test-tls-disable-renegotiation.js b/test/parallel/test-tls-disable-renegotiation.js
index b688079a58af50..3f843c6609f789 100644
--- a/test/parallel/test-tls-disable-renegotiation.js
+++ b/test/parallel/test-tls-disable-renegotiation.js
@@ -5,8 +5,7 @@ const fixtures = require('../common/fixtures');
 
 // Tests that calling disableRenegotiation on a TLSSocket stops renegotiation.
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
@@ -15,58 +14,81 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = tls.Server(options, common.mustCall((socket) => {
-  socket.on('error', common.mustCall((err) => {
-    common.expectsError({
-      type: Error,
-      code: 'ERR_TLS_RENEGOTIATION_DISABLED',
-      message: 'TLS session renegotiation disabled for this socket'
-    })(err);
-    socket.destroy();
-    server.close();
-  }));
-  // Disable renegotiation after the first chunk of data received.
-  // Demonstrates that renegotiation works successfully up until
-  // disableRenegotiation is called.
-  socket.on('data', common.mustCall((chunk) => {
-    socket.write(chunk);
-    socket.disableRenegotiation();
-  }));
-  socket.on('secure', common.mustCall(() => {
-    assert(socket._handle.handshakes < 2,
-           `Too many handshakes [${socket._handle.handshakes}]`);
-  }));
-}));
+const server = tls.Server(
+  options,
+  common.mustCall((socket) => {
+    socket.on(
+      'error',
+      common.mustCall((err) => {
+        common.expectsError({
+          type: Error,
+          code: 'ERR_TLS_RENEGOTIATION_DISABLED',
+          message: 'TLS session renegotiation disabled for this socket'
+        })(err);
+        socket.destroy();
+        server.close();
+      })
+    );
+    // Disable renegotiation after the first chunk of data received.
+    // Demonstrates that renegotiation works successfully up until
+    // disableRenegotiation is called.
+    socket.on(
+      'data',
+      common.mustCall((chunk) => {
+        socket.write(chunk);
+        socket.disableRenegotiation();
+      })
+    );
+    socket.on(
+      'secure',
+      common.mustCall(() => {
+        assert(
+          socket._handle.handshakes < 2,
+          `Too many handshakes [${socket._handle.handshakes}]`
+        );
+      })
+    );
+  })
+);
 
-
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const options = {
-    rejectUnauthorized: false,
-    port
-  };
-  const client =
-    tls.connect(options, common.mustCall(() => {
-      client.write('');
-      // Negotiation is still permitted for this first
-      // attempt. This should succeed.
-      client.renegotiate(
-        { rejectUnauthorized: false },
-        common.mustCall(() => {
-          // Once renegotiation completes, we write some
-          // data to the socket, which triggers the on
-          // data event on the server. After that data
-          // is received, disableRenegotiation is called.
-          client.write('data', common.mustCall(() => {
-            client.write('');
-            // This second renegotiation attempt should fail
-            // and the callback should never be invoked. The
-            // server will simply drop the connection after
-            // emitting the error.
-            client.renegotiate(
-              { rejectUnauthorized: false },
-              common.mustNotCall());
-          }));
-        }));
-    }));
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const options = {
+      rejectUnauthorized: false,
+      port
+    };
+    const client = tls.connect(
+      options,
+      common.mustCall(() => {
+        client.write('');
+        // Negotiation is still permitted for this first
+        // attempt. This should succeed.
+        client.renegotiate(
+          { rejectUnauthorized: false },
+          common.mustCall(() => {
+            // Once renegotiation completes, we write some
+            // data to the socket, which triggers the on
+            // data event on the server. After that data
+            // is received, disableRenegotiation is called.
+            client.write(
+              'data',
+              common.mustCall(() => {
+                client.write('');
+                // This second renegotiation attempt should fail
+                // and the callback should never be invoked. The
+                // server will simply drop the connection after
+                // emitting the error.
+                client.renegotiate(
+                  { rejectUnauthorized: false },
+                  common.mustNotCall()
+                );
+              })
+            );
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-tls-ecdh-auto.js b/test/parallel/test-tls-ecdh-auto.js
index 840063229a60b7..5fa284ccce3faa 100644
--- a/test/parallel/test-tls-ecdh-auto.js
+++ b/test/parallel/test-tls-ecdh-auto.js
@@ -4,11 +4,9 @@ const common = require('../common');
 // This test ensures that the value "auto" on ecdhCurve option is
 // supported to enable automatic curve selection in TLS server.
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('missing openssl-cli');
+if (!common.opensslCli) common.skip('missing openssl-cli');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -35,16 +33,19 @@ const server = tls.createServer(options, function(conn) {
 let gotReply = false;
 
 server.listen(0, function() {
-  const args = ['s_client',
-                '-cipher', `${options.ciphers}`,
-                '-connect', `127.0.0.1:${this.address().port}`];
+  const args = [
+    's_client',
+    '-cipher',
+    `${options.ciphers}`,
+    '-connect',
+    `127.0.0.1:${this.address().port}`
+  ];
 
   const client = spawn(common.opensslCli, args);
 
   client.stdout.on('data', function(data) {
     const message = data.toString();
-    if (message.includes(reply))
-      gotReply = true;
+    if (message.includes(reply)) gotReply = true;
   });
 
   client.on('exit', function(code) {
diff --git a/test/parallel/test-tls-ecdh-multiple.js b/test/parallel/test-tls-ecdh-multiple.js
index d5f27a5e464437..c853cd6daef007 100644
--- a/test/parallel/test-tls-ecdh-multiple.js
+++ b/test/parallel/test-tls-ecdh-multiple.js
@@ -4,11 +4,9 @@ const common = require('../common');
 // This test ensures that ecdhCurve option of TLS server supports colon
 // separated ECDH curve names as value.
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('missing openssl-cli');
+if (!common.opensslCli) common.skip('missing openssl-cli');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -35,16 +33,19 @@ const server = tls.createServer(options, function(conn) {
 let gotReply = false;
 
 server.listen(0, function() {
-  const args = ['s_client',
-                '-cipher', `${options.ciphers}`,
-                '-connect', `127.0.0.1:${this.address().port}`];
+  const args = [
+    's_client',
+    '-cipher',
+    `${options.ciphers}`,
+    '-connect',
+    `127.0.0.1:${this.address().port}`
+  ];
 
   const client = spawn(common.opensslCli, args);
 
   client.stdout.on('data', function(data) {
     const message = data.toString();
-    if (message.includes(reply))
-      gotReply = true;
+    if (message.includes(reply)) gotReply = true;
   });
 
   client.on('exit', function(code) {
@@ -66,11 +67,12 @@ process.on('exit', function() {
   ];
 
   // Brainpool is not supported in FIPS mode
-  if (common.hasFipsCrypto)
-    unsupportedCurves.push('brainpoolP256r1');
+  if (common.hasFipsCrypto) unsupportedCurves.push('brainpoolP256r1');
 
   unsupportedCurves.forEach((ecdhCurve) => {
-    assert.throws(() => tls.createServer({ ecdhCurve }),
-                  /Error: Failed to set ECDH curve/);
+    assert.throws(
+      () => tls.createServer({ ecdhCurve }),
+      /Error: Failed to set ECDH curve/
+    );
   });
 });
diff --git a/test/parallel/test-tls-ecdh.js b/test/parallel/test-tls-ecdh.js
index e7d986cc9aec09..89ee273bdd6ee6 100644
--- a/test/parallel/test-tls-ecdh.js
+++ b/test/parallel/test-tls-ecdh.js
@@ -23,11 +23,9 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('missing openssl-cli');
+if (!common.opensslCli) common.skip('missing openssl-cli');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -43,17 +41,28 @@ const options = {
 
 const reply = 'I AM THE WALRUS'; // something recognizable
 
-const server = tls.createServer(options, common.mustCall(function(conn) {
-  conn.end(reply);
-}));
+const server = tls.createServer(
+  options,
+  common.mustCall(function(conn) {
+    conn.end(reply);
+  })
+);
 
-server.listen(0, '127.0.0.1', common.mustCall(function() {
-  const cmd = `"${common.opensslCli}" s_client -cipher ${
-    options.ciphers} -connect 127.0.0.1:${this.address().port}`;
+server.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    const cmd = `"${common.opensslCli}" s_client -cipher ${
+      options.ciphers
+    } -connect 127.0.0.1:${this.address().port}`;
 
-  exec(cmd, common.mustCall(function(err, stdout, stderr) {
-    assert.ifError(err);
-    assert(stdout.includes(reply));
-    server.close();
-  }));
-}));
+    exec(
+      cmd,
+      common.mustCall(function(err, stdout, stderr) {
+        assert.ifError(err);
+        assert(stdout.includes(reply));
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-tls-econnreset.js b/test/parallel/test-tls-econnreset.js
index 1ffd7b1e97522f..e483a0b7ebbd7a 100644
--- a/test/parallel/test-tls-econnreset.js
+++ b/test/parallel/test-tls-econnreset.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -31,19 +30,30 @@ const tls = require('tls');
 
 let clientError = null;
 
-const server = tls.createServer({
-  cert: fixtures.readKey('agent1-cert.pem'),
-  key: fixtures.readKey('agent1-key.pem'),
-}, common.mustNotCall()).on('tlsClientError', function(err, conn) {
-  assert(!clientError && conn);
-  clientError = err;
-  server.close();
-}).listen(0, function() {
-  net.connect(this.address().port, function() {
-    // Destroy the socket once it is connected, so the server sees ECONNRESET.
-    this.destroy();
-  }).on('error', common.mustNotCall());
-});
+const server = tls
+  .createServer(
+    {
+      cert: fixtures.readKey('agent1-cert.pem'),
+      key: fixtures.readKey('agent1-key.pem')
+    },
+    common.mustNotCall()
+  )
+  .on('tlsClientError', function(err, conn) {
+    assert(!clientError && conn);
+    clientError = err;
+    server.close();
+  })
+  .listen(0, function() {
+    net
+      .connect(
+        this.address().port,
+        function() {
+          // Destroy the socket once it is connected, so the server sees ECONNRESET.
+          this.destroy();
+        }
+      )
+      .on('error', common.mustNotCall());
+  });
 
 process.on('exit', function() {
   assert(clientError);
diff --git a/test/parallel/test-tls-empty-sni-context.js b/test/parallel/test-tls-empty-sni-context.js
index 9b963e66294c32..2b82aaa022aeae 100644
--- a/test/parallel/test-tls-empty-sni-context.js
+++ b/test/parallel/test-tls-empty-sni-context.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -13,19 +12,34 @@ const options = {
   }
 };
 
-const server = tls.createServer(options, (c) => {
-  assert.fail('Should not be called');
-}).on('tlsClientError', common.mustCall((err, c) => {
-  assert(/SSL_use_certificate:passed a null parameter/i.test(err.message));
-  server.close();
-})).listen(0, common.mustCall(() => {
-  const c = tls.connect({
-    port: server.address().port,
-    rejectUnauthorized: false,
-    servername: 'any.name'
-  }, common.mustNotCall());
+const server = tls
+  .createServer(options, (c) => {
+    assert.fail('Should not be called');
+  })
+  .on(
+    'tlsClientError',
+    common.mustCall((err, c) => {
+      assert(/SSL_use_certificate:passed a null parameter/i.test(err.message));
+      server.close();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const c = tls.connect(
+        {
+          port: server.address().port,
+          rejectUnauthorized: false,
+          servername: 'any.name'
+        },
+        common.mustNotCall()
+      );
 
-  c.on('error', common.mustCall((err) => {
-    assert(/Client network socket disconnected/.test(err.message));
-  }));
-}));
+      c.on(
+        'error',
+        common.mustCall((err) => {
+          assert(/Client network socket disconnected/.test(err.message));
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-env-bad-extra-ca.js b/test/parallel/test-tls-env-bad-extra-ca.js
index 5167f586079187..03f08eb02fddc0 100644
--- a/test/parallel/test-tls-env-bad-extra-ca.js
+++ b/test/parallel/test-tls-env-bad-extra-ca.js
@@ -3,8 +3,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -18,28 +17,35 @@ if (process.env.CHILD) {
 
 const env = Object.assign({}, process.env, {
   CHILD: 'yes',
-  NODE_EXTRA_CA_CERTS: `${fixtures.fixturesDir}/no-such-file-exists-🐢`,
+  NODE_EXTRA_CA_CERTS: `${fixtures.fixturesDir}/no-such-file-exists-🐢`
 });
 
 const opts = {
   env: env,
-  silent: true,
+  silent: true
 };
 let stderr = '';
 
 fork(__filename, opts)
-  .on('exit', common.mustCall(function(status) {
-    // Check that client succeeded in connecting.
-    assert.strictEqual(status, 0);
-  }))
-  .on('close', common.mustCall(function() {
-    // TODO(addaleax): Make `SafeGetenv` work like `process.env`
-    // encoding-wise
-    if (!common.isWindows) {
-      const re = /Warning: Ignoring extra certs from.*no-such-file-exists-🐢.* load failed:.*No such file or directory/;
-      assert(re.test(stderr), stderr);
-    }
-  }))
-  .stderr.setEncoding('utf8').on('data', function(str) {
+  .on(
+    'exit',
+    common.mustCall(function(status) {
+      // Check that client succeeded in connecting.
+      assert.strictEqual(status, 0);
+    })
+  )
+  .on(
+    'close',
+    common.mustCall(function() {
+      // TODO(addaleax): Make `SafeGetenv` work like `process.env`
+      // encoding-wise
+      if (!common.isWindows) {
+        const re = /Warning: Ignoring extra certs from.*no-such-file-exists-🐢.* load failed:.*No such file or directory/;
+        assert(re.test(stderr), stderr);
+      }
+    })
+  )
+  .stderr.setEncoding('utf8')
+  .on('data', function(str) {
     stderr += str;
   });
diff --git a/test/parallel/test-tls-env-extra-ca-file-load.js b/test/parallel/test-tls-env-extra-ca-file-load.js
index fa97d7c0c6103f..bf8e18af902267 100644
--- a/test/parallel/test-tls-env-extra-ca-file-load.js
+++ b/test/parallel/test-tls-env-extra-ca-file-load.js
@@ -3,8 +3,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -29,12 +28,14 @@ if (process.argv[2] !== 'child') {
 
   [
     extendsEnv({ CHILD_USE_EXTRA_CA_CERTS: 'yes', NODE_EXTRA_CA_CERTS }),
-    extendsEnv({ CHILD_USE_EXTRA_CA_CERTS: 'no' }),
+    extendsEnv({ CHILD_USE_EXTRA_CA_CERTS: 'no' })
   ].forEach((processEnv) => {
-    fork(__filename, ['child'], { env: processEnv })
-    .on('exit', common.mustCall((status) => {
-      // client did not succeed in connecting
-      assert.strictEqual(status, 0);
-    }));
+    fork(__filename, ['child'], { env: processEnv }).on(
+      'exit',
+      common.mustCall((status) => {
+        // client did not succeed in connecting
+        assert.strictEqual(status, 0);
+      })
+    );
   });
 }
diff --git a/test/parallel/test-tls-env-extra-ca-no-crypto.js b/test/parallel/test-tls-env-extra-ca-no-crypto.js
index 06399c5d239fc6..ac364afe6d21f1 100644
--- a/test/parallel/test-tls-env-extra-ca-no-crypto.js
+++ b/test/parallel/test-tls-env-extra-ca-no-crypto.js
@@ -11,12 +11,13 @@ if (process.argv[2] === 'child') {
 } else {
   const NODE_EXTRA_CA_CERTS = fixtures.path('keys', 'ca1-cert.pem');
 
-  fork(
-    __filename,
-    ['child'],
-    { env: Object.assign({}, process.env, { NODE_EXTRA_CA_CERTS }) },
-  ).on('exit', common.mustCall(function(status) {
-    // client did not succeed in connecting
-    assert.strictEqual(status, 0);
-  }));
+  fork(__filename, ['child'], {
+    env: Object.assign({}, process.env, { NODE_EXTRA_CA_CERTS })
+  }).on(
+    'exit',
+    common.mustCall(function(status) {
+      // client did not succeed in connecting
+      assert.strictEqual(status, 0);
+    })
+  );
 }
diff --git a/test/parallel/test-tls-env-extra-ca.js b/test/parallel/test-tls-env-extra-ca.js
index b8ff1d3be237eb..38b07d9b31e11c 100644
--- a/test/parallel/test-tls-env-extra-ca.js
+++ b/test/parallel/test-tls-env-extra-ca.js
@@ -3,8 +3,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -15,31 +14,45 @@ const { fork } = require('child_process');
 if (process.env.CHILD) {
   const copts = {
     port: process.env.PORT,
-    checkServerIdentity: common.mustCall(),
+    checkServerIdentity: common.mustCall()
   };
-  const client = tls.connect(copts, common.mustCall(function() {
-    client.end('hi');
-  }));
+  const client = tls.connect(
+    copts,
+    common.mustCall(function() {
+      client.end('hi');
+    })
+  );
   return;
 }
 
 const options = {
   key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = tls.createServer(options, common.mustCall(function(s) {
-  s.end('bye');
-  server.close();
-})).listen(0, common.mustCall(function() {
-  const env = Object.assign({}, process.env, {
-    CHILD: 'yes',
-    PORT: this.address().port,
-    NODE_EXTRA_CA_CERTS: fixtures.path('keys', 'ca1-cert.pem')
-  });
-
-  fork(__filename, { env }).on('exit', common.mustCall(function(status) {
-    // client did not succeed in connecting
-    assert.strictEqual(status, 0);
-  }));
-}));
+const server = tls
+  .createServer(
+    options,
+    common.mustCall(function(s) {
+      s.end('bye');
+      server.close();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const env = Object.assign({}, process.env, {
+        CHILD: 'yes',
+        PORT: this.address().port,
+        NODE_EXTRA_CA_CERTS: fixtures.path('keys', 'ca1-cert.pem')
+      });
+
+      fork(__filename, { env }).on(
+        'exit',
+        common.mustCall(function(status) {
+          // client did not succeed in connecting
+          assert.strictEqual(status, 0);
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-error-servername.js b/test/parallel/test-tls-error-servername.js
index c42ff2fe73f466..9f99a9355d145a 100644
--- a/test/parallel/test-tls-error-servername.js
+++ b/test/parallel/test-tls-error-servername.js
@@ -5,8 +5,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const { connect, TLSSocket } = require('tls');
 const makeDuplexPair = require('../common/duplexpair');
@@ -19,17 +18,21 @@ const ca = fixtures.readKey('ca1-cert.pem');
 const client = connect({
   socket: clientSide,
   ca,
-  host: 'agent1'  // Hostname from certificate
+  host: 'agent1' // Hostname from certificate
 });
 
 [undefined, null, 1, true, {}].forEach((value) => {
-  common.expectsError(() => {
-    client.setServername(value);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "name" argument must be of type string. ' +
-             `Received type ${typeof value}`
-  });
+  common.expectsError(
+    () => {
+      client.setServername(value);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message:
+        'The "name" argument must be of type string. ' +
+        `Received type ${typeof value}`
+    }
+  );
 });
 
 const server = new TLSSocket(serverSide, {
@@ -39,9 +42,12 @@ const server = new TLSSocket(serverSide, {
   ca
 });
 
-common.expectsError(() => {
-  server.setServername('localhost');
-}, {
-  code: 'ERR_TLS_SNI_FROM_SERVER',
-  message: 'Cannot issue SNI from a TLS server-side socket'
-});
+common.expectsError(
+  () => {
+    server.setServername('localhost');
+  },
+  {
+    code: 'ERR_TLS_SNI_FROM_SERVER',
+    message: 'Cannot issue SNI from a TLS server-side socket'
+  }
+);
diff --git a/test/parallel/test-tls-external-accessor.js b/test/parallel/test-tls-external-accessor.js
index 33d371923a600c..0845dd08c0a72b 100644
--- a/test/parallel/test-tls-external-accessor.js
+++ b/test/parallel/test-tls-external-accessor.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
diff --git a/test/parallel/test-tls-fast-writing.js b/test/parallel/test-tls-fast-writing.js
index 937694228a5951..866ba67532ecda 100644
--- a/test/parallel/test-tls-fast-writing.js
+++ b/test/parallel/test-tls-fast-writing.js
@@ -21,16 +21,17 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const tls = require('tls');
 
-const options = { key: fixtures.readSync('test_key.pem'),
-                  cert: fixtures.readSync('test_cert.pem'),
-                  ca: [ fixtures.readSync('test_ca.pem') ] };
+const options = {
+  key: fixtures.readSync('test_key.pem'),
+  cert: fixtures.readSync('test_cert.pem'),
+  ca: [fixtures.readSync('test_ca.pem')]
+};
 
 const server = tls.createServer(options, onconnection);
 let gotChunk = false;
@@ -47,25 +48,26 @@ function onconnection(conn) {
     assert(c.length);
     assert(Buffer.isBuffer(c));
 
-    if (gotDrain)
-      process.exit(0);
+    if (gotDrain) process.exit(0);
   });
 }
 
 server.listen(0, function() {
   const chunk = Buffer.alloc(1024, 'x');
   const opt = { port: this.address().port, rejectUnauthorized: false };
-  const conn = tls.connect(opt, function() {
-    conn.on('drain', ondrain);
-    write();
-  });
+  const conn = tls.connect(
+    opt,
+    function() {
+      conn.on('drain', ondrain);
+      write();
+    }
+  );
   function ondrain() {
     if (!gotDrain) {
       gotDrain = true;
       console.log('ok - got drain');
     }
-    if (gotChunk)
-      process.exit(0);
+    if (gotChunk) process.exit(0);
     write();
   }
   function write() {
diff --git a/test/parallel/test-tls-finished.js b/test/parallel/test-tls-finished.js
index 8b52934b049d95..502d1e97cf7ce9 100644
--- a/test/parallel/test-tls-finished.js
+++ b/test/parallel/test-tls-finished.js
@@ -3,8 +3,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // This test ensures that tlsSocket.getFinished() and
 // tlsSocket.getPeerFinished() return undefined before
@@ -18,34 +17,43 @@ const tls = require('tls');
 
 const msg = {};
 const pem = (n) => fixtures.readKey(`${n}.pem`);
-const server = tls.createServer({
-  key: pem('agent1-key'),
-  cert: pem('agent1-cert')
-}, common.mustCall((alice) => {
-  msg.server = {
-    alice: alice.getFinished(),
-    bob: alice.getPeerFinished()
-  };
-  server.close();
-}));
+const server = tls.createServer(
+  {
+    key: pem('agent1-key'),
+    cert: pem('agent1-cert')
+  },
+  common.mustCall((alice) => {
+    msg.server = {
+      alice: alice.getFinished(),
+      bob: alice.getPeerFinished()
+    };
+    server.close();
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const bob = tls.connect(
+      {
+        port: server.address().port,
+        rejectUnauthorized: false
+      },
+      common.mustCall(() => {
+        msg.client = {
+          alice: bob.getPeerFinished(),
+          bob: bob.getFinished()
+        };
+        bob.end();
+      })
+    );
 
-server.listen(0, common.mustCall(() => {
-  const bob = tls.connect({
-    port: server.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(() => {
-    msg.client = {
+    msg.before = {
       alice: bob.getPeerFinished(),
       bob: bob.getFinished()
     };
-    bob.end();
-  }));
-
-  msg.before = {
-    alice: bob.getPeerFinished(),
-    bob: bob.getFinished()
-  };
-}));
+  })
+);
 
 process.on('exit', () => {
   assert.strictEqual(undefined, msg.before.alice);
diff --git a/test/parallel/test-tls-friendly-error-message.js b/test/parallel/test-tls-friendly-error-message.js
index b52918be27ac9b..1330e1fdfc857b 100644
--- a/test/parallel/test-tls-friendly-error-message.js
+++ b/test/parallel/test-tls-friendly-error-message.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
@@ -31,14 +30,28 @@ const tls = require('tls');
 const key = fixtures.readKey('agent1-key.pem');
 const cert = fixtures.readKey('agent1-cert.pem');
 
-tls.createServer({ key, cert }, common.mustCall(function(conn) {
-  conn.end();
-  this.close();
-})).listen(0, common.mustCall(function() {
-  const options = { port: this.address().port, rejectUnauthorized: true };
-  tls.connect(options).on('error', common.mustCall(function(err) {
-    assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE');
-    assert.strictEqual(err.message, 'unable to verify the first certificate');
-    this.destroy();
-  }));
-}));
+tls
+  .createServer(
+    { key, cert },
+    common.mustCall(function(conn) {
+      conn.end();
+      this.close();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const options = { port: this.address().port, rejectUnauthorized: true };
+      tls.connect(options).on(
+        'error',
+        common.mustCall(function(err) {
+          assert.strictEqual(err.code, 'UNABLE_TO_VERIFY_LEAF_SIGNATURE');
+          assert.strictEqual(
+            err.message,
+            'unable to verify the first certificate'
+          );
+          this.destroy();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-generic-stream.js b/test/parallel/test-tls-generic-stream.js
index d4e5427acae110..3ca8280255b3de 100644
--- a/test/parallel/test-tls-generic-stream.js
+++ b/test/parallel/test-tls-generic-stream.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const makeDuplexPair = require('../common/duplexpair');
@@ -17,7 +16,7 @@ const { clientSide, serverSide } = makeDuplexPair();
 const clientTLS = connect({
   socket: clientSide,
   ca,
-  host: 'agent1'  // Hostname from certificate
+  host: 'agent1' // Hostname from certificate
 });
 const serverTLS = new TLSSocket(serverSide, {
   isServer: true,
@@ -29,10 +28,16 @@ const serverTLS = new TLSSocket(serverSide, {
 assert.strictEqual(clientTLS.connecting, false);
 assert.strictEqual(serverTLS.connecting, false);
 
-clientTLS.on('secureConnect', common.mustCall(() => {
-  clientTLS.write('foobar', common.mustCall(() => {
-    assert.strictEqual(serverTLS.read().toString(), 'foobar');
-    assert.strictEqual(clientTLS._handle.writeQueueSize, 0);
-  }));
-  assert.ok(clientTLS._handle.writeQueueSize > 0);
-}));
+clientTLS.on(
+  'secureConnect',
+  common.mustCall(() => {
+    clientTLS.write(
+      'foobar',
+      common.mustCall(() => {
+        assert.strictEqual(serverTLS.read().toString(), 'foobar');
+        assert.strictEqual(clientTLS._handle.writeQueueSize, 0);
+      })
+    );
+    assert.ok(clientTLS._handle.writeQueueSize > 0);
+  })
+);
diff --git a/test/parallel/test-tls-getcipher.js b/test/parallel/test-tls-getcipher.js
index 3ba33faf42369d..dcb44a1eede491 100644
--- a/test/parallel/test-tls-getcipher.js
+++ b/test/parallel/test-tls-getcipher.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -41,17 +40,24 @@ const options = {
 
 const server = tls.createServer(options, common.mustCall());
 
-server.listen(0, '127.0.0.1', common.mustCall(function() {
-  const client = tls.connect({
-    host: '127.0.0.1',
-    port: this.address().port,
-    ciphers: cipher_list.join(':'),
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    const cipher = client.getCipher();
-    assert.strictEqual(cipher.name, cipher_list[0]);
-    assert(cipher_version_pattern.test(cipher.version));
-    client.end();
-    server.close();
-  }));
-}));
+server.listen(
+  0,
+  '127.0.0.1',
+  common.mustCall(function() {
+    const client = tls.connect(
+      {
+        host: '127.0.0.1',
+        port: this.address().port,
+        ciphers: cipher_list.join(':'),
+        rejectUnauthorized: false
+      },
+      common.mustCall(function() {
+        const cipher = client.getCipher();
+        assert.strictEqual(cipher.name, cipher_list[0]);
+        assert(cipher_version_pattern.test(cipher.version));
+        client.end();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-tls-getprotocol.js b/test/parallel/test-tls-getprotocol.js
index 20018241e33572..c77736d61e72f8 100644
--- a/test/parallel/test-tls-getprotocol.js
+++ b/test/parallel/test-tls-getprotocol.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // This test ensures that `getProtocol` returns the right protocol
 // from a TLS connection
@@ -22,23 +21,31 @@ const serverConfig = {
   cert: fixtures.readSync('/keys/agent2-cert.pem')
 };
 
-const server = tls.createServer(serverConfig, common.mustCall(function() {
-
-}, clientConfigs.length)).listen(0, common.localhostIPv4, function() {
-  let connected = 0;
-  clientConfigs.forEach(function(v) {
-    tls.connect({
-      host: common.localhostIPv4,
-      port: server.address().port,
-      rejectUnauthorized: false,
-      secureProtocol: v.secureProtocol
-    }, common.mustCall(function() {
-      assert.strictEqual(this.getProtocol(), v.version);
-      this.on('end', common.mustCall(function() {
-        assert.strictEqual(this.getProtocol(), null);
-      })).end();
-      if (++connected === clientConfigs.length)
-        server.close();
-    }));
+const server = tls
+  .createServer(
+    serverConfig,
+    common.mustCall(function() {}, clientConfigs.length)
+  )
+  .listen(0, common.localhostIPv4, function() {
+    let connected = 0;
+    clientConfigs.forEach(function(v) {
+      tls.connect(
+        {
+          host: common.localhostIPv4,
+          port: server.address().port,
+          rejectUnauthorized: false,
+          secureProtocol: v.secureProtocol
+        },
+        common.mustCall(function() {
+          assert.strictEqual(this.getProtocol(), v.version);
+          this.on(
+            'end',
+            common.mustCall(function() {
+              assert.strictEqual(this.getProtocol(), null);
+            })
+          ).end();
+          if (++connected === clientConfigs.length) server.close();
+        })
+      );
+    });
   });
-});
diff --git a/test/parallel/test-tls-handshake-error.js b/test/parallel/test-tls-handshake-error.js
index 2aef1adcc38c1f..d47db981be885a 100644
--- a/test/parallel/test-tls-handshake-error.js
+++ b/test/parallel/test-tls-handshake-error.js
@@ -2,26 +2,35 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
 
 const fixtures = require('../common/fixtures');
 
-const server = tls.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem'),
-  rejectUnauthorized: true
-}, function(c) {
-}).listen(0, common.mustCall(function() {
-  assert.throws(() => {
-    tls.connect({
-      port: this.address().port,
-      ciphers: 'RC4'
-    }, common.mustNotCall());
-  }, /no cipher match/i);
+const server = tls
+  .createServer(
+    {
+      key: fixtures.readKey('agent1-key.pem'),
+      cert: fixtures.readKey('agent1-cert.pem'),
+      rejectUnauthorized: true
+    },
+    function(c) {}
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      assert.throws(() => {
+        tls.connect(
+          {
+            port: this.address().port,
+            ciphers: 'RC4'
+          },
+          common.mustNotCall()
+        );
+      }, /no cipher match/i);
 
-  server.close();
-}));
+      server.close();
+    })
+  );
diff --git a/test/parallel/test-tls-handshake-exception.js b/test/parallel/test-tls-handshake-exception.js
index 1ba4bc6438e2f9..ac01dbb64768d4 100644
--- a/test/parallel/test-tls-handshake-exception.js
+++ b/test/parallel/test-tls-handshake-exception.js
@@ -10,8 +10,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 if (process.argv[2] === 'child') {
   const fixtures = require('../common/fixtures');
@@ -44,7 +43,9 @@ if (process.argv[2] === 'child') {
     c.on('data', d.push.bind(d));
 
     const options = { key, cert };
-    const fail = () => { throw new Error('eyecatcher'); };
+    const fail = () => {
+      throw new Error('eyecatcher');
+    };
     tls.createServer(options, mustCall(fail)).emit('connection', d);
   }
 } else {
diff --git a/test/parallel/test-tls-handshake-nohang.js b/test/parallel/test-tls-handshake-nohang.js
index e724fcd3422b00..356ff43e398599 100644
--- a/test/parallel/test-tls-handshake-nohang.js
+++ b/test/parallel/test-tls-handshake-nohang.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
diff --git a/test/parallel/test-tls-hello-parser-failure.js b/test/parallel/test-tls-hello-parser-failure.js
index 4b92f6bde3151c..cfbdd2fc7c556d 100644
--- a/test/parallel/test-tls-hello-parser-failure.js
+++ b/test/parallel/test-tls-hello-parser-failure.js
@@ -27,8 +27,7 @@ const fixtures = require('../common/fixtures');
 // This test ensures that the tls parser causes a client error if the client
 // sends invalid data.
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -42,25 +41,37 @@ const options = {
 
 const bonkers = Buffer.alloc(1024 * 1024, 42);
 
-const server = tls.createServer(options, function(c) {
+const server = tls
+  .createServer(options, function(c) {})
+  .listen(
+    0,
+    common.mustCall(function() {
+      const client = net.connect(
+        this.address().port,
+        common.mustCall(function() {
+          client.write(bonkers);
+        })
+      );
 
-}).listen(0, common.mustCall(function() {
-  const client = net.connect(this.address().port, common.mustCall(function() {
-    client.write(bonkers);
-  }));
+      const writeAgain = setImmediate(function() {
+        client.write(bonkers);
+      });
 
-  const writeAgain = setImmediate(function() {
-    client.write(bonkers);
-  });
+      client.once(
+        'error',
+        common.mustCall(function(err) {
+          clearImmediate(writeAgain);
+          client.destroy();
+          server.close();
+        })
+      );
 
-  client.once('error', common.mustCall(function(err) {
-    clearImmediate(writeAgain);
-    client.destroy();
-    server.close();
-  }));
-
-  client.on('close', common.mustCall(function(hadError) {
-    // Confirm that client errored
-    assert.strictEqual(hadError, true);
-  }));
-}));
+      client.on(
+        'close',
+        common.mustCall(function(hadError) {
+          // Confirm that client errored
+          assert.strictEqual(hadError, true);
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-honorcipherorder.js b/test/parallel/test-tls-honorcipherorder.js
index 8e7c4badcb269d..2007e7945b8230 100644
--- a/test/parallel/test-tls-honorcipherorder.js
+++ b/test/parallel/test-tls-honorcipherorder.js
@@ -4,8 +4,7 @@ const fixtures = require('../common/fixtures');
 
 // Test the honorCipherOrder property
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const mustCall = common.mustCall;
@@ -22,57 +21,78 @@ function test(honorCipherOrder, clientCipher, expectedCipher, defaultCiphers) {
     secureProtocol: SSL_Method,
     key: fixtures.readKey('agent2-key.pem'),
     cert: fixtures.readKey('agent2-cert.pem'),
-    ciphers: 'AES256-SHA256:AES128-GCM-SHA256:AES128-SHA256:' +
-             'ECDHE-RSA-AES128-GCM-SHA256',
-    honorCipherOrder: honorCipherOrder,
+    ciphers:
+      'AES256-SHA256:AES128-GCM-SHA256:AES128-SHA256:' +
+      'ECDHE-RSA-AES128-GCM-SHA256',
+    honorCipherOrder: honorCipherOrder
   };
 
-  const server = tls.createServer(soptions, mustCall(function(clearTextStream) {
-    // End socket to send CLOSE_NOTIFY and TCP FIN packet, otherwise
-    // it may hang for ~30 seconds in FIN_WAIT_1 state (at least on OSX).
-    clearTextStream.end();
-  }));
-  server.listen(0, localhost, mustCall(function() {
-    const coptions = {
-      rejectUnauthorized: false,
-      secureProtocol: SSL_Method
-    };
-    if (clientCipher) {
-      coptions.ciphers = clientCipher;
-    }
-    const port = this.address().port;
-    const savedDefaults = tls.DEFAULT_CIPHERS;
-    tls.DEFAULT_CIPHERS = defaultCiphers || savedDefaults;
-    const client = tls.connect(port, localhost, coptions, mustCall(function() {
-      const cipher = client.getCipher();
-      client.end();
-      server.close();
-      const msg = util.format(
-        'honorCipherOrder=%j, clientCipher=%j, expect=%j, got=%j',
-        honorCipherOrder, clientCipher, expectedCipher, cipher.name);
-      assert.strictEqual(cipher.name, expectedCipher, msg);
-    }));
-    tls.DEFAULT_CIPHERS = savedDefaults;
-  }));
+  const server = tls.createServer(
+    soptions,
+    mustCall(function(clearTextStream) {
+      // End socket to send CLOSE_NOTIFY and TCP FIN packet, otherwise
+      // it may hang for ~30 seconds in FIN_WAIT_1 state (at least on OSX).
+      clearTextStream.end();
+    })
+  );
+  server.listen(
+    0,
+    localhost,
+    mustCall(function() {
+      const coptions = {
+        rejectUnauthorized: false,
+        secureProtocol: SSL_Method
+      };
+      if (clientCipher) {
+        coptions.ciphers = clientCipher;
+      }
+      const port = this.address().port;
+      const savedDefaults = tls.DEFAULT_CIPHERS;
+      tls.DEFAULT_CIPHERS = defaultCiphers || savedDefaults;
+      const client = tls.connect(
+        port,
+        localhost,
+        coptions,
+        mustCall(function() {
+          const cipher = client.getCipher();
+          client.end();
+          server.close();
+          const msg = util.format(
+            'honorCipherOrder=%j, clientCipher=%j, expect=%j, got=%j',
+            honorCipherOrder,
+            clientCipher,
+            expectedCipher,
+            cipher.name
+          );
+          assert.strictEqual(cipher.name, expectedCipher, msg);
+        })
+      );
+      tls.DEFAULT_CIPHERS = savedDefaults;
+    })
+  );
 }
 
 // Client explicitly has the preference of cipher suites, not the default.
-test(false, 'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256',
-     'AES128-GCM-SHA256');
+test(
+  false,
+  'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256',
+  'AES128-GCM-SHA256'
+);
 
 // Server has the preference of cipher suites, and AES256-SHA256 is
 // the server's top choice.
-test(true, 'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256',
-     'AES256-SHA256');
-test(undefined, 'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256',
-     'AES256-SHA256');
+test(true, 'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256', 'AES256-SHA256');
+test(
+  undefined,
+  'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256',
+  'AES256-SHA256'
+);
 
 // Server has the preference of cipher suites. AES128-GCM-SHA256 is given
 // higher priority over AES128-SHA256 among client cipher suites.
 test(true, 'AES128-SHA256:AES128-GCM-SHA256', 'AES128-GCM-SHA256');
 test(undefined, 'AES128-SHA256:AES128-GCM-SHA256', 'AES128-GCM-SHA256');
 
-
 // As client has only one cipher, server has no choice, irrespective
 // of honorCipherOrder.
 test(true, 'AES128-SHA256', 'AES128-SHA256');
diff --git a/test/parallel/test-tls-inception.js b/test/parallel/test-tls-inception.js
index f28f92373c5500..1a1b6cdf64feb7 100644
--- a/test/parallel/test-tls-inception.js
+++ b/test/parallel/test-tls-inception.js
@@ -23,8 +23,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -76,11 +75,14 @@ a.listen(0, function() {
     ssl.on('data', function(data) {
       buf += data;
     });
-    ssl.on('end', common.mustCall(function() {
-      assert.strictEqual(buf, body);
-      ssl.end();
-      a.close();
-      b.close();
-    }));
+    ssl.on(
+      'end',
+      common.mustCall(function() {
+        assert.strictEqual(buf, body);
+        ssl.end();
+        a.close();
+        b.close();
+      })
+    );
   });
 });
diff --git a/test/parallel/test-tls-interleave.js b/test/parallel/test-tls-interleave.js
index 70f98f33e4f2b2..ebfb6c3b4de6e1 100644
--- a/test/parallel/test-tls-interleave.js
+++ b/test/parallel/test-tls-interleave.js
@@ -22,53 +22,57 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
 
 const fixtures = require('../common/fixtures');
 
-const options = { key: fixtures.readSync('test_key.pem'),
-                  cert: fixtures.readSync('test_cert.pem'),
-                  ca: [ fixtures.readSync('test_ca.pem') ] };
+const options = {
+  key: fixtures.readSync('test_key.pem'),
+  cert: fixtures.readSync('test_cert.pem'),
+  ca: [fixtures.readSync('test_ca.pem')]
+};
 
-const writes = [
-  'some server data',
-  'and a separate packet',
-  'and one more',
-];
+const writes = ['some server data', 'and a separate packet', 'and one more'];
 let receivedWrites = 0;
 
-const server = tls.createServer(options, function(c) {
-  c.resume();
-  writes.forEach(function(str) {
-    c.write(str);
-  });
-}).listen(0, common.mustCall(function() {
-  const connectOpts = { rejectUnauthorized: false };
-  const c = tls.connect(this.address().port, connectOpts, function() {
-    c.write('some client data');
-    c.on('readable', function() {
-      let data = c.read();
-      if (data === null)
-        return;
+const server = tls
+  .createServer(options, function(c) {
+    c.resume();
+    writes.forEach(function(str) {
+      c.write(str);
+    });
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      const connectOpts = { rejectUnauthorized: false };
+      const c = tls.connect(
+        this.address().port,
+        connectOpts,
+        function() {
+          c.write('some client data');
+          c.on('readable', function() {
+            let data = c.read();
+            if (data === null) return;
 
-      data = data.toString();
-      while (data.length !== 0) {
-        assert(data.startsWith(writes[receivedWrites]));
-        data = data.slice(writes[receivedWrites].length);
+            data = data.toString();
+            while (data.length !== 0) {
+              assert(data.startsWith(writes[receivedWrites]));
+              data = data.slice(writes[receivedWrites].length);
 
-        if (++receivedWrites === writes.length) {
-          c.end();
-          server.close();
+              if (++receivedWrites === writes.length) {
+                c.end();
+                server.close();
+              }
+            }
+          });
         }
-      }
-    });
-  });
-}));
-
+      );
+    })
+  );
 
 process.on('exit', function() {
   assert.strictEqual(receivedWrites, writes.length);
diff --git a/test/parallel/test-tls-invoke-queued.js b/test/parallel/test-tls-invoke-queued.js
index 482ab847352793..e3be1e76c0dc84 100644
--- a/test/parallel/test-tls-invoke-queued.js
+++ b/test/parallel/test-tls-invoke-queued.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -32,28 +31,51 @@ const fixtures = require('../common/fixtures');
 
 let received = '';
 
-const server = tls.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem')
-}, common.mustCall(function(c) {
-  c.write('hello ', null, common.mustCall(function() {
-    c.write('world!', null, common.mustCall(function() {
-      c.destroy();
-    }));
-    // Data on next _write() will be written, and the cb will still be invoked
-    c.write(' gosh', null, common.mustCall());
-  }));
+const server = tls
+  .createServer(
+    {
+      key: fixtures.readKey('agent1-key.pem'),
+      cert: fixtures.readKey('agent1-cert.pem')
+    },
+    common.mustCall(function(c) {
+      c.write(
+        'hello ',
+        null,
+        common.mustCall(function() {
+          c.write(
+            'world!',
+            null,
+            common.mustCall(function() {
+              c.destroy();
+            })
+          );
+          // Data on next _write() will be written, and the cb will still be invoked
+          c.write(' gosh', null, common.mustCall());
+        })
+      );
 
-  server.close();
-})).listen(0, common.mustCall(function() {
-  const c = tls.connect(this.address().port, {
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    c.on('data', function(chunk) {
-      received += chunk;
-    });
-    c.on('end', common.mustCall(function() {
-      assert.strictEqual(received, 'hello world! gosh');
-    }));
-  }));
-}));
+      server.close();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const c = tls.connect(
+        this.address().port,
+        {
+          rejectUnauthorized: false
+        },
+        common.mustCall(function() {
+          c.on('data', function(chunk) {
+            received += chunk;
+          });
+          c.on(
+            'end',
+            common.mustCall(function() {
+              assert.strictEqual(received, 'hello world! gosh');
+            })
+          );
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-ip-servername-deprecation.js b/test/parallel/test-tls-ip-servername-deprecation.js
index b747caa03d57c4..b14fbfeb4f6494 100644
--- a/test/parallel/test-tls-ip-servername-deprecation.js
+++ b/test/parallel/test-tls-ip-servername-deprecation.js
@@ -3,8 +3,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
@@ -13,7 +12,7 @@ const tls = require('tls');
 common.expectWarning(
   'DeprecationWarning',
   'Setting the TLS ServerName to an IP address is not permitted by ' +
-  'RFC 6066. This will be ignored in a future version.',
+    'RFC 6066. This will be ignored in a future version.',
   'DEP0123'
 );
 
@@ -23,19 +22,27 @@ common.expectWarning(
     cert: fixtures.readKey('agent1-cert.pem')
   };
 
-  const server = tls.createServer(options, function(s) {
-    s.end('hello');
-  }).listen(0, function() {
-    const client = tls.connect({
-      port: this.address().port,
-      rejectUnauthorized: false,
-      servername: '127.0.0.1',
-    }, function() {
-      client.end();
+  const server = tls
+    .createServer(options, function(s) {
+      s.end('hello');
+    })
+    .listen(0, function() {
+      const client = tls.connect(
+        {
+          port: this.address().port,
+          rejectUnauthorized: false,
+          servername: '127.0.0.1'
+        },
+        function() {
+          client.end();
+        }
+      );
     });
-  });
 
-  server.on('connection', common.mustCall(function(socket) {
-    server.close();
-  }));
+  server.on(
+    'connection',
+    common.mustCall(function(socket) {
+      server.close();
+    })
+  );
 }
diff --git a/test/parallel/test-tls-js-stream.js b/test/parallel/test-tls-js-stream.js
index 908f4c48876a56..526c118fca8cc1 100644
--- a/test/parallel/test-tls-js-stream.js
+++ b/test/parallel/test-tls-js-stream.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
@@ -16,58 +15,65 @@ const connected = {
   server: 0
 };
 
-const server = tls.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem')
-}, function(c) {
-  console.log('new client');
-  connected.server++;
-  c.end('ohai');
-}).listen(0, function() {
-  const raw = net.connect(this.address().port);
+const server = tls
+  .createServer(
+    {
+      key: fixtures.readKey('agent1-key.pem'),
+      cert: fixtures.readKey('agent1-cert.pem')
+    },
+    function(c) {
+      console.log('new client');
+      connected.server++;
+      c.end('ohai');
+    }
+  )
+  .listen(0, function() {
+    const raw = net.connect(this.address().port);
 
-  let pending = false;
-  raw.on('readable', function() {
-    if (pending)
-      p._read();
-  });
+    let pending = false;
+    raw.on('readable', function() {
+      if (pending) p._read();
+    });
 
-  const p = new stream.Duplex({
-    read: function read() {
-      pending = false;
+    const p = new stream.Duplex({
+      read: function read() {
+        pending = false;
 
-      const chunk = raw.read();
-      if (chunk) {
-        console.log('read', chunk);
-        this.push(chunk);
-      } else {
-        pending = true;
+        const chunk = raw.read();
+        if (chunk) {
+          console.log('read', chunk);
+          this.push(chunk);
+        } else {
+          pending = true;
+        }
+      },
+      write: function write(data, enc, cb) {
+        console.log('write', data, enc);
+        raw.write(data, enc, cb);
       }
-    },
-    write: function write(data, enc, cb) {
-      console.log('write', data, enc);
-      raw.write(data, enc, cb);
-    }
-  });
+    });
 
-  const socket = tls.connect({
-    socket: p,
-    rejectUnauthorized: false
-  }, function() {
-    console.log('client secure');
+    const socket = tls.connect(
+      {
+        socket: p,
+        rejectUnauthorized: false
+      },
+      function() {
+        console.log('client secure');
 
-    connected.client++;
+        connected.client++;
 
-    socket.end('hello');
-    socket.resume();
-    socket.destroy();
-  });
+        socket.end('hello');
+        socket.resume();
+        socket.destroy();
+      }
+    );
 
-  socket.once('close', function() {
-    console.log('client close');
-    server.close();
+    socket.once('close', function() {
+      console.log('client close');
+      server.close();
+    });
   });
-});
 
 process.once('exit', function() {
   assert.strictEqual(connected.client, 1);
diff --git a/test/parallel/test-tls-junk-closes-server.js b/test/parallel/test-tls-junk-closes-server.js
index 06fa57267a9104..d593f3bcdb61bd 100644
--- a/test/parallel/test-tls-junk-closes-server.js
+++ b/test/parallel/test-tls-junk-closes-server.js
@@ -23,8 +23,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const net = require('net');
@@ -36,14 +35,23 @@ const options = {
 
 const server = tls.createServer(options, common.mustNotCall());
 
-server.listen(0, common.mustCall(function() {
-  const c = net.createConnection(this.address().port);
-
-  c.on('connect', common.mustCall(function() {
-    c.write('blah\nblah\nblah\n');
-  }));
-
-  c.on('end', common.mustCall(function() {
-    server.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    const c = net.createConnection(this.address().port);
+
+    c.on(
+      'connect',
+      common.mustCall(function() {
+        c.write('blah\nblah\nblah\n');
+      })
+    );
+
+    c.on(
+      'end',
+      common.mustCall(function() {
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-tls-junk-server.js b/test/parallel/test-tls-junk-server.js
index 27c273857b51ff..1e89a3f6097b17 100644
--- a/test/parallel/test-tls-junk-server.js
+++ b/test/parallel/test-tls-junk-server.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -20,10 +19,15 @@ server.listen(0, function() {
   const req = https.request({ port: this.address().port });
   req.end();
 
-  req.once('error', common.mustCall(function(err) {
-    // OpenSSL 1.0.x and 1.1.x use different error messages for junk inputs.
-    assert(/unknown protocol/.test(err.message) ||
-           /wrong version number/.test(err.message));
-    server.close();
-  }));
+  req.once(
+    'error',
+    common.mustCall(function(err) {
+      // OpenSSL 1.0.x and 1.1.x use different error messages for junk inputs.
+      assert(
+        /unknown protocol/.test(err.message) ||
+          /wrong version number/.test(err.message)
+      );
+      server.close();
+    })
+  );
 });
diff --git a/test/parallel/test-tls-key-mismatch.js b/test/parallel/test-tls-key-mismatch.js
index b0c8affadefe95..759b1075483ffe 100644
--- a/test/parallel/test-tls-key-mismatch.js
+++ b/test/parallel/test-tls-key-mismatch.js
@@ -22,15 +22,13 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
 const assert = require('assert');
 const tls = require('tls');
-const errorMessageRegex =
-  /^Error: error:0B080074:x509 certificate routines:X509_check_private_key:key values mismatch$/;
+const errorMessageRegex = /^Error: error:0B080074:x509 certificate routines:X509_check_private_key:key values mismatch$/;
 
 const options = {
   key: fixtures.readKey('agent1-key.pem'),
diff --git a/test/parallel/test-tls-legacy-deprecated.js b/test/parallel/test-tls-legacy-deprecated.js
index 8aa8fd31d2e255..853c0f2242e630 100644
--- a/test/parallel/test-tls-legacy-deprecated.js
+++ b/test/parallel/test-tls-legacy-deprecated.js
@@ -1,8 +1,7 @@
 // Flags: --no-warnings
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
diff --git a/test/parallel/test-tls-max-send-fragment.js b/test/parallel/test-tls-max-send-fragment.js
index eca995d66483b5..5abce509c6fe8e 100644
--- a/test/parallel/test-tls-max-send-fragment.js
+++ b/test/parallel/test-tls-max-send-fragment.js
@@ -23,8 +23,7 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -33,32 +32,47 @@ const buf = Buffer.allocUnsafe(10000);
 let received = 0;
 const maxChunk = 768;
 
-const server = tls.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem')
-}, function(c) {
-  // Lower and upper limits
-  assert(!c.setMaxSendFragment(511));
-  assert(!c.setMaxSendFragment(16385));
+const server = tls
+  .createServer(
+    {
+      key: fixtures.readKey('agent1-key.pem'),
+      cert: fixtures.readKey('agent1-cert.pem')
+    },
+    function(c) {
+      // Lower and upper limits
+      assert(!c.setMaxSendFragment(511));
+      assert(!c.setMaxSendFragment(16385));
 
-  // Correct fragment size
-  assert(c.setMaxSendFragment(maxChunk));
+      // Correct fragment size
+      assert(c.setMaxSendFragment(maxChunk));
 
-  c.end(buf);
-}).listen(0, common.mustCall(function() {
-  const c = tls.connect(this.address().port, {
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    c.on('data', function(chunk) {
-      assert(chunk.length <= maxChunk);
-      received += chunk.length;
-    });
+      c.end(buf);
+    }
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const c = tls.connect(
+        this.address().port,
+        {
+          rejectUnauthorized: false
+        },
+        common.mustCall(function() {
+          c.on('data', function(chunk) {
+            assert(chunk.length <= maxChunk);
+            received += chunk.length;
+          });
 
-    // Ensure that we receive 'end' event anyway
-    c.on('end', common.mustCall(function() {
-      c.destroy();
-      server.close();
-      assert.strictEqual(received, buf.length);
-    }));
-  }));
-}));
+          // Ensure that we receive 'end' event anyway
+          c.on(
+            'end',
+            common.mustCall(function() {
+              c.destroy();
+              server.close();
+              assert.strictEqual(received, buf.length);
+            })
+          );
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-multi-key.js b/test/parallel/test-tls-multi-key.js
index 8ccc0d32d93757..5d8a49d0c88186 100644
--- a/test/parallel/test-tls-multi-key.js
+++ b/test/parallel/test-tls-multi-key.js
@@ -24,8 +24,7 @@ const common = require('../common');
 
 // Test multi-identity ('key')/multi-algorithm scenarios.
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
@@ -33,108 +32,81 @@ const tls = require('tls');
 
 // Key is ordered as ec, rsa, cert is ordered as rsa, ec.
 test({
-  key: [
-    fixtures.readKey('ec10-key.pem'),
-    fixtures.readKey('agent1-key.pem'),
-  ],
+  key: [fixtures.readKey('ec10-key.pem'), fixtures.readKey('agent1-key.pem')],
   cert: [
     fixtures.readKey('agent1-cert.pem'),
-    fixtures.readKey('ec10-cert.pem'),
+    fixtures.readKey('ec10-cert.pem')
   ],
   eccCN: 'agent10.example.com',
-  client: { ca: [
-    fixtures.readKey('ca5-cert.pem'),
-    fixtures.readKey('ca1-cert.pem'),
-  ] },
+  client: {
+    ca: [fixtures.readKey('ca5-cert.pem'), fixtures.readKey('ca1-cert.pem')]
+  }
 });
 
 // Key and cert are ordered as ec, rsa.
 test({
-  key: [
-    fixtures.readKey('ec10-key.pem'),
-    fixtures.readKey('agent1-key.pem'),
-  ],
+  key: [fixtures.readKey('ec10-key.pem'), fixtures.readKey('agent1-key.pem')],
   cert: [
     fixtures.readKey('agent1-cert.pem'),
-    fixtures.readKey('ec10-cert.pem'),
+    fixtures.readKey('ec10-cert.pem')
   ],
   eccCN: 'agent10.example.com',
-  client: { ca: [
-    fixtures.readKey('ca5-cert.pem'),
-    fixtures.readKey('ca1-cert.pem'),
-  ] },
+  client: {
+    ca: [fixtures.readKey('ca5-cert.pem'), fixtures.readKey('ca1-cert.pem')]
+  }
 });
 
 // Key, cert, and pfx options can be used simultaneously.
 test({
-  key: [
-    fixtures.readKey('ec-key.pem'),
-  ],
-  cert: [
-    fixtures.readKey('ec-cert.pem'),
-  ],
+  key: [fixtures.readKey('ec-key.pem')],
+  cert: [fixtures.readKey('ec-cert.pem')],
   pfx: fixtures.readKey('agent1.pfx'),
   passphrase: 'sample',
-  client: { ca: [
-    fixtures.readKey('ec-cert.pem'),
-    fixtures.readKey('ca1-cert.pem'),
-  ] },
+  client: {
+    ca: [fixtures.readKey('ec-cert.pem'), fixtures.readKey('ca1-cert.pem')]
+  }
 });
 
 // Key and cert with mixed algorithms, and cert chains with intermediate CAs
 test({
-  key: [
-    fixtures.readKey('ec10-key.pem'),
-    fixtures.readKey('agent10-key.pem'),
-  ],
+  key: [fixtures.readKey('ec10-key.pem'), fixtures.readKey('agent10-key.pem')],
   cert: [
     fixtures.readKey('agent10-cert.pem'),
-    fixtures.readKey('ec10-cert.pem'),
+    fixtures.readKey('ec10-cert.pem')
   ],
   rsaCN: 'agent10.example.com',
   eccCN: 'agent10.example.com',
-  client: { ca: [
-    fixtures.readKey('ca2-cert.pem'),
-    fixtures.readKey('ca5-cert.pem'),
-  ] },
+  client: {
+    ca: [fixtures.readKey('ca2-cert.pem'), fixtures.readKey('ca5-cert.pem')]
+  }
 });
 
 // Key and cert with mixed algorithms, and cert chains with intermediate CAs,
 // using PFX for EC.
 test({
-  key: [
-    fixtures.readKey('agent10-key.pem'),
-  ],
-  cert: [
-    fixtures.readKey('agent10-cert.pem'),
-  ],
+  key: [fixtures.readKey('agent10-key.pem')],
+  cert: [fixtures.readKey('agent10-cert.pem')],
   pfx: fixtures.readKey('ec10.pfx'),
   passphrase: 'sample',
   rsaCN: 'agent10.example.com',
   eccCN: 'agent10.example.com',
-  client: { ca: [
-    fixtures.readKey('ca2-cert.pem'),
-    fixtures.readKey('ca5-cert.pem'),
-  ] },
+  client: {
+    ca: [fixtures.readKey('ca2-cert.pem'), fixtures.readKey('ca5-cert.pem')]
+  }
 });
 
 // Key and cert with mixed algorithms, and cert chains with intermediate CAs,
 // using PFX for RSA.
 test({
-  key: [
-    fixtures.readKey('ec10-key.pem'),
-  ],
-  cert: [
-    fixtures.readKey('ec10-cert.pem'),
-  ],
+  key: [fixtures.readKey('ec10-key.pem')],
+  cert: [fixtures.readKey('ec10-cert.pem')],
   pfx: fixtures.readKey('agent10.pfx'),
   passphrase: 'sample',
   rsaCN: 'agent10.example.com',
   eccCN: 'agent10.example.com',
-  client: { ca: [
-    fixtures.readKey('ca2-cert.pem'),
-    fixtures.readKey('ca5-cert.pem'),
-  ] },
+  client: {
+    ca: [fixtures.readKey('ca2-cert.pem'), fixtures.readKey('ca5-cert.pem')]
+  }
 });
 
 function test(options) {
@@ -144,45 +116,55 @@ function test(options) {
   delete options.rsaCN;
   delete options.eccCN;
   delete options.client;
-  const server = tls.createServer(options, function(conn) {
-    conn.end('ok');
-  }).listen(0, common.mustCall(connectWithEcdsa));
+  const server = tls
+    .createServer(options, function(conn) {
+      conn.end('ok');
+    })
+    .listen(0, common.mustCall(connectWithEcdsa));
 
   function connectWithEcdsa() {
-    const ecdsa = tls.connect(this.address().port, {
-      ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384',
-      rejectUnauthorized: true,
-      ca: clientTrustRoots,
-      checkServerIdentity: (_, c) => assert.strictEqual(c.subject.CN, eccCN),
-    }, common.mustCall(function() {
-      assert.deepStrictEqual(ecdsa.getCipher(), {
-        name: 'ECDHE-ECDSA-AES256-GCM-SHA384',
-        version: 'TLSv1/SSLv3'
-      });
-      assert.strictEqual(ecdsa.getPeerCertificate().subject.CN, eccCN);
-      // XXX(sam) certs don't currently include EC key info, so depend on
-      // absence of RSA key info to indicate key is EC.
-      assert(!ecdsa.getPeerCertificate().exponent, 'not cert for an RSA key');
-      ecdsa.end();
-      connectWithRsa();
-    }));
+    const ecdsa = tls.connect(
+      this.address().port,
+      {
+        ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384',
+        rejectUnauthorized: true,
+        ca: clientTrustRoots,
+        checkServerIdentity: (_, c) => assert.strictEqual(c.subject.CN, eccCN)
+      },
+      common.mustCall(function() {
+        assert.deepStrictEqual(ecdsa.getCipher(), {
+          name: 'ECDHE-ECDSA-AES256-GCM-SHA384',
+          version: 'TLSv1/SSLv3'
+        });
+        assert.strictEqual(ecdsa.getPeerCertificate().subject.CN, eccCN);
+        // XXX(sam) certs don't currently include EC key info, so depend on
+        // absence of RSA key info to indicate key is EC.
+        assert(!ecdsa.getPeerCertificate().exponent, 'not cert for an RSA key');
+        ecdsa.end();
+        connectWithRsa();
+      })
+    );
   }
 
   function connectWithRsa() {
-    const rsa = tls.connect(server.address().port, {
-      ciphers: 'ECDHE-RSA-AES256-GCM-SHA384',
-      rejectUnauthorized: true,
-      ca: clientTrustRoots,
-      checkServerIdentity: (_, c) => assert.strictEqual(c.subject.CN, rsaCN),
-    }, common.mustCall(function() {
-      assert.deepStrictEqual(rsa.getCipher(), {
-        name: 'ECDHE-RSA-AES256-GCM-SHA384',
-        version: 'TLSv1/SSLv3'
-      });
-      assert.strictEqual(rsa.getPeerCertificate().subject.CN, rsaCN);
-      assert(rsa.getPeerCertificate().exponent, 'cert for an RSA key');
-      rsa.end();
-      server.close();
-    }));
+    const rsa = tls.connect(
+      server.address().port,
+      {
+        ciphers: 'ECDHE-RSA-AES256-GCM-SHA384',
+        rejectUnauthorized: true,
+        ca: clientTrustRoots,
+        checkServerIdentity: (_, c) => assert.strictEqual(c.subject.CN, rsaCN)
+      },
+      common.mustCall(function() {
+        assert.deepStrictEqual(rsa.getCipher(), {
+          name: 'ECDHE-RSA-AES256-GCM-SHA384',
+          version: 'TLSv1/SSLv3'
+        });
+        assert.strictEqual(rsa.getPeerCertificate().subject.CN, rsaCN);
+        assert(rsa.getPeerCertificate().exponent, 'cert for an RSA key');
+        rsa.end();
+        server.close();
+      })
+    );
   }
 }
diff --git a/test/parallel/test-tls-multi-pfx.js b/test/parallel/test-tls-multi-pfx.js
index 28cd945e3cf3b9..92109b6921595f 100644
--- a/test/parallel/test-tls-multi-pfx.js
+++ b/test/parallel/test-tls-multi-pfx.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -19,32 +18,45 @@ const options = {
 
 const ciphers = [];
 
-const server = tls.createServer(options, function(conn) {
-  conn.end('ok');
-}).listen(0, function() {
-  const ecdsa = tls.connect(this.address().port, {
-    ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384',
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    ciphers.push(ecdsa.getCipher());
-    const rsa = tls.connect(server.address().port, {
-      ciphers: 'ECDHE-RSA-AES256-GCM-SHA384',
-      rejectUnauthorized: false
-    }, common.mustCall(function() {
-      ciphers.push(rsa.getCipher());
-      ecdsa.end();
-      rsa.end();
-      server.close();
-    }));
-  }));
-});
+const server = tls
+  .createServer(options, function(conn) {
+    conn.end('ok');
+  })
+  .listen(0, function() {
+    const ecdsa = tls.connect(
+      this.address().port,
+      {
+        ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384',
+        rejectUnauthorized: false
+      },
+      common.mustCall(function() {
+        ciphers.push(ecdsa.getCipher());
+        const rsa = tls.connect(
+          server.address().port,
+          {
+            ciphers: 'ECDHE-RSA-AES256-GCM-SHA384',
+            rejectUnauthorized: false
+          },
+          common.mustCall(function() {
+            ciphers.push(rsa.getCipher());
+            ecdsa.end();
+            rsa.end();
+            server.close();
+          })
+        );
+      })
+    );
+  });
 
 process.on('exit', function() {
-  assert.deepStrictEqual(ciphers, [{
-    name: 'ECDHE-ECDSA-AES256-GCM-SHA384',
-    version: 'TLSv1/SSLv3'
-  }, {
-    name: 'ECDHE-RSA-AES256-GCM-SHA384',
-    version: 'TLSv1/SSLv3'
-  }]);
+  assert.deepStrictEqual(ciphers, [
+    {
+      name: 'ECDHE-ECDSA-AES256-GCM-SHA384',
+      version: 'TLSv1/SSLv3'
+    },
+    {
+      name: 'ECDHE-RSA-AES256-GCM-SHA384',
+      version: 'TLSv1/SSLv3'
+    }
+  ]);
 });
diff --git a/test/parallel/test-tls-multiple-cas-as-string.js b/test/parallel/test-tls-multiple-cas-as-string.js
index 2612de55fe988f..df265122498b99 100644
--- a/test/parallel/test-tls-multiple-cas-as-string.js
+++ b/test/parallel/test-tls-multiple-cas-as-string.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // Verify that multiple CA certificates can be provided, and that for
 // convenience that can also be in newline-separated strings.
diff --git a/test/parallel/test-tls-net-connect-prefer-path.js b/test/parallel/test-tls-net-connect-prefer-path.js
index 263501ae0330ac..f40e0186dabc53 100644
--- a/test/parallel/test-tls-net-connect-prefer-path.js
+++ b/test/parallel/test-tls-net-connect-prefer-path.js
@@ -5,8 +5,7 @@ const fixtures = require('../common/fixtures');
 // This tests that both tls and net will ignore host and port if path is
 // provided.
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
@@ -21,9 +20,9 @@ function libName(lib) {
 
 function mkServer(lib, tcp, cb) {
   const handler = (socket) => {
-    socket.write(`${libName(lib)}:${
-      server.address().port || server.address()
-    }`);
+    socket.write(
+      `${libName(lib)}:${server.address().port || server.address()}`
+    );
     socket.end();
   };
   const args = [handler];
@@ -40,24 +39,36 @@ function mkServer(lib, tcp, cb) {
 function testLib(lib, cb) {
   mkServer(lib, true, (tcpServer) => {
     mkServer(lib, false, (unixServer) => {
-      const client = lib.connect({
-        path: unixServer.address(),
-        port: tcpServer.address().port,
-        host: 'localhost',
-        rejectUnauthorized: false
-      }, () => {
-        const bufs = [];
-        client.on('data', common.mustCall((d) => {
-          bufs.push(d);
-        }));
-        client.on('end', common.mustCall(() => {
-          const resp = Buffer.concat(bufs).toString();
-          assert.strictEqual(`${libName(lib)}:${unixServer.address()}`, resp);
-          tcpServer.close();
-          unixServer.close();
-          cb();
-        }));
-      });
+      const client = lib.connect(
+        {
+          path: unixServer.address(),
+          port: tcpServer.address().port,
+          host: 'localhost',
+          rejectUnauthorized: false
+        },
+        () => {
+          const bufs = [];
+          client.on(
+            'data',
+            common.mustCall((d) => {
+              bufs.push(d);
+            })
+          );
+          client.on(
+            'end',
+            common.mustCall(() => {
+              const resp = Buffer.concat(bufs).toString();
+              assert.strictEqual(
+                `${libName(lib)}:${unixServer.address()}`,
+                resp
+              );
+              tcpServer.close();
+              unixServer.close();
+              cb();
+            })
+          );
+        }
+      );
     });
   });
 }
diff --git a/test/parallel/test-tls-net-socket-keepalive.js b/test/parallel/test-tls-net-socket-keepalive.js
index c184e902b42685..0ae2689838df1a 100644
--- a/test/parallel/test-tls-net-socket-keepalive.js
+++ b/test/parallel/test-tls-net-socket-keepalive.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const tls = require('tls');
@@ -16,38 +15,49 @@ const ca = fixtures.readKey('ca1-cert.pem');
 const options = {
   key,
   cert,
-  ca: [ca],
+  ca: [ca]
 };
 
-const server = tls.createServer(options, common.mustCall((conn) => {
-  conn.write('hello');
-  conn.on('data', common.mustCall());
-  conn.end();
-})).listen(0, common.mustCall(() => {
-  const netSocket = new net.Socket({
-    allowHalfOpen: true,
-  });
-
-  const socket = tls.connect({
-    socket: netSocket,
-    rejectUnauthorized: false,
-  });
-
-  const { port, address } = server.address();
-
-  // Doing `net.Socket.connect()` after `tls.connect()` will make tls module
-  // wrap the socket in StreamWrap.
-  netSocket.connect({
-    port,
-    address,
-  });
-
-  socket.on('end', common.mustCall());
-  socket.on('data', common.mustCall());
-  socket.on('close', common.mustCall(() => {
-    server.close();
-  }));
-
-  socket.write('hello');
-  socket.end();
-}));
+const server = tls
+  .createServer(
+    options,
+    common.mustCall((conn) => {
+      conn.write('hello');
+      conn.on('data', common.mustCall());
+      conn.end();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const netSocket = new net.Socket({
+        allowHalfOpen: true
+      });
+
+      const socket = tls.connect({
+        socket: netSocket,
+        rejectUnauthorized: false
+      });
+
+      const { port, address } = server.address();
+
+      // Doing `net.Socket.connect()` after `tls.connect()` will make tls module
+      // wrap the socket in StreamWrap.
+      netSocket.connect({
+        port,
+        address
+      });
+
+      socket.on('end', common.mustCall());
+      socket.on('data', common.mustCall());
+      socket.on(
+        'close',
+        common.mustCall(() => {
+          server.close();
+        })
+      );
+
+      socket.write('hello');
+      socket.end();
+    })
+  );
diff --git a/test/parallel/test-tls-no-cert-required.js b/test/parallel/test-tls-no-cert-required.js
index ef1d366c919bb1..fdc9682270fb31 100644
--- a/test/parallel/test-tls-no-cert-required.js
+++ b/test/parallel/test-tls-no-cert-required.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -30,26 +29,22 @@ const tls = require('tls');
 // Omitting the cert or pfx option to tls.createServer() should not throw.
 // AECDH-NULL-SHA is a no-authentication/no-encryption cipher and hence
 // doesn't need a certificate.
-tls.createServer({ ciphers: 'AECDH-NULL-SHA' })
+tls
+  .createServer({ ciphers: 'AECDH-NULL-SHA' })
   .listen(0, common.mustCall(close));
 
-tls.createServer(assert.fail)
-  .listen(0, common.mustCall(close));
+tls.createServer(assert.fail).listen(0, common.mustCall(close));
 
-tls.createServer({})
-  .listen(0, common.mustCall(close));
+tls.createServer({}).listen(0, common.mustCall(close));
 
-common.expectsError(() => tls.createServer('this is not valid'),
-                    {
-                      code: 'ERR_INVALID_ARG_TYPE',
-                      type: TypeError,
-                      message: 'The "options" argument must be of type ' +
-                               'Object. Received type string'
-                    }
-);
+common.expectsError(() => tls.createServer('this is not valid'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options" argument must be of type ' + 'Object. Received type string'
+});
 
-tls.createServer()
-  .listen(0, common.mustCall(close));
+tls.createServer().listen(0, common.mustCall(close));
 
 function close() {
   this.close();
diff --git a/test/parallel/test-tls-no-rsa-key.js b/test/parallel/test-tls-no-rsa-key.js
index e3c1b5eda316b3..47c7bd4eba730d 100644
--- a/test/parallel/test-tls-no-rsa-key.js
+++ b/test/parallel/test-tls-no-rsa-key.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -33,22 +32,34 @@ const options = {
   cert: fixtures.readKey('ec-cert.pem')
 };
 
-const server = tls.createServer(options, function(conn) {
-  conn.end('ok');
-}).listen(0, common.mustCall(function() {
-  const c = tls.connect(this.address().port, {
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    c.on('end', common.mustCall(function() {
-      c.end();
-      server.close();
-    }));
+const server = tls
+  .createServer(options, function(conn) {
+    conn.end('ok');
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      const c = tls.connect(
+        this.address().port,
+        {
+          rejectUnauthorized: false
+        },
+        common.mustCall(function() {
+          c.on(
+            'end',
+            common.mustCall(function() {
+              c.end();
+              server.close();
+            })
+          );
 
-    c.on('data', function(data) {
-      assert.strictEqual(data.toString(), 'ok');
-    });
+          c.on('data', function(data) {
+            assert.strictEqual(data.toString(), 'ok');
+          });
 
-    const cert = c.getPeerCertificate();
-    assert.strictEqual(cert.subject.C, 'US');
-  }));
-}));
+          const cert = c.getPeerCertificate();
+          assert.strictEqual(cert.subject.C, 'US');
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-no-sslv23.js b/test/parallel/test-tls-no-sslv23.js
index 737f42b530d93a..a4f1625f6fc459 100644
--- a/test/parallel/test-tls-no-sslv23.js
+++ b/test/parallel/test-tls-no-sslv23.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
diff --git a/test/parallel/test-tls-no-sslv3.js b/test/parallel/test-tls-no-sslv3.js
index 4cbb62e3d595f1..18adbdf5e5e5cb 100644
--- a/test/parallel/test-tls-no-sslv3.js
+++ b/test/parallel/test-tls-no-sslv3.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 if (common.opensslCli === false)
   common.skip('node compiled without OpenSSL CLI.');
@@ -19,20 +18,21 @@ let stderr = '';
 
 server.listen(0, '127.0.0.1', function() {
   const address = `${this.address().address}:${this.address().port}`;
-  const args = ['s_client',
-                '-ssl3',
-                '-connect', address];
+  const args = ['s_client', '-ssl3', '-connect', address];
 
   const client = spawn(common.opensslCli, args, { stdio: 'pipe' });
   client.stdout.pipe(process.stdout);
   client.stderr.pipe(process.stderr);
   client.stderr.setEncoding('utf8');
-  client.stderr.on('data', (data) => stderr += data);
-
-  client.once('exit', common.mustCall(function(exitCode) {
-    assert.strictEqual(exitCode, 1);
-    server.close();
-  }));
+  client.stderr.on('data', (data) => (stderr += data));
+
+  client.once(
+    'exit',
+    common.mustCall(function(exitCode) {
+      assert.strictEqual(exitCode, 1);
+      server.close();
+    })
+  );
 });
 
 server.on('tlsClientError', (err) => errors.push(err));
@@ -43,7 +43,9 @@ process.on('exit', function() {
   } else {
     assert.strictEqual(errors.length, 1);
     // OpenSSL 1.0.x and 1.1.x report invalid client versions differently.
-    assert(/:wrong version number/.test(errors[0].message) ||
-           /:version too low/.test(errors[0].message));
+    assert(
+      /:wrong version number/.test(errors[0].message) ||
+        /:version too low/.test(errors[0].message)
+    );
   }
 });
diff --git a/test/parallel/test-tls-ocsp-callback.js b/test/parallel/test-tls-ocsp-callback.js
index 2670fefd3dcf72..bf2a3f289d083a 100644
--- a/test/parallel/test-tls-ocsp-callback.js
+++ b/test/parallel/test-tls-ocsp-callback.js
@@ -22,11 +22,9 @@
 'use strict';
 const common = require('../common');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
@@ -38,7 +36,6 @@ const SSL_OP_NO_TICKET = require('crypto').constants.SSL_OP_NO_TICKET;
 const pfx = fixtures.readKey('agent1.pfx');
 
 function test(testOptions, cb) {
-
   const key = fixtures.readKey('agent1-key.pem');
   const cert = fixtures.readKey('agent1-cert.pem');
   const ca = fixtures.readKey('ca1-cert.pem');
@@ -64,8 +61,7 @@ function test(testOptions, cb) {
       // We're ok with getting ECONNRESET in this test, but it's
       // timing-dependent, and thus unreliable. Any other errors
       // are just failures, though.
-      if (er.code !== 'ECONNRESET')
-        throw er;
+      if (er.code !== 'ECONNRESET') throw er;
     });
     ++requestCount;
     cleartext.end();
@@ -77,24 +73,27 @@ function test(testOptions, cb) {
 
     // Just to check that async really works there
     setTimeout(function() {
-      callback(null,
-               testOptions.response ? Buffer.from(testOptions.response) : null);
+      callback(
+        null,
+        testOptions.response ? Buffer.from(testOptions.response) : null
+      );
     }, 100);
   });
   server.listen(0, function() {
-    const client = tls.connect({
-      port: this.address().port,
-      requestOCSP: testOptions.ocsp !== false,
-      secureOptions: testOptions.ocsp === false ?
-        SSL_OP_NO_TICKET : 0,
-      rejectUnauthorized: false
-    }, function() {
-      clientSecure++;
-    });
+    const client = tls.connect(
+      {
+        port: this.address().port,
+        requestOCSP: testOptions.ocsp !== false,
+        secureOptions: testOptions.ocsp === false ? SSL_OP_NO_TICKET : 0,
+        rejectUnauthorized: false
+      },
+      function() {
+        clientSecure++;
+      }
+    );
     client.on('OCSPResponse', function(resp) {
       ocspResponse = resp;
-      if (resp)
-        client.destroy();
+      if (resp) client.destroy();
     });
     client.on('close', function() {
       server.close(cb);
@@ -132,9 +131,12 @@ if (!common.hasFipsCrypto) {
 function runTests(i) {
   if (i === tests.length) return;
 
-  test(tests[i], common.mustCall(function() {
-    runTests(i + 1);
-  }));
+  test(
+    tests[i],
+    common.mustCall(function() {
+      runTests(i + 1);
+    })
+  );
 }
 
 runTests(0);
diff --git a/test/parallel/test-tls-on-empty-socket.js b/test/parallel/test-tls-on-empty-socket.js
index 87d51a81bbe08e..4fd4cdf65c1b89 100644
--- a/test/parallel/test-tls-on-empty-socket.js
+++ b/test/parallel/test-tls-on-empty-socket.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -11,29 +10,37 @@ const fixtures = require('../common/fixtures');
 
 let out = '';
 
-const server = tls.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem')
-}, function(c) {
-  c.end('hello');
-}).listen(0, function() {
-  const socket = new net.Socket();
+const server = tls
+  .createServer(
+    {
+      key: fixtures.readKey('agent1-key.pem'),
+      cert: fixtures.readKey('agent1-cert.pem')
+    },
+    function(c) {
+      c.end('hello');
+    }
+  )
+  .listen(0, function() {
+    const socket = new net.Socket();
 
-  const s = tls.connect({
-    socket: socket,
-    rejectUnauthorized: false
-  }, function() {
-    s.on('data', function(chunk) {
-      out += chunk;
-    });
-    s.on('end', function() {
-      s.destroy();
-      server.close();
-    });
-  });
+    const s = tls.connect(
+      {
+        socket: socket,
+        rejectUnauthorized: false
+      },
+      function() {
+        s.on('data', function(chunk) {
+          out += chunk;
+        });
+        s.on('end', function() {
+          s.destroy();
+          server.close();
+        });
+      }
+    );
 
-  socket.connect(this.address().port);
-});
+    socket.connect(this.address().port);
+  });
 
 process.on('exit', function() {
   assert.strictEqual(out, 'hello');
diff --git a/test/parallel/test-tls-options-boolean-check.js b/test/parallel/test-tls-options-boolean-check.js
index 242df1140e41c2..c01ec3239a5c40 100644
--- a/test/parallel/test-tls-options-boolean-check.js
+++ b/test/parallel/test-tls-options-boolean-check.js
@@ -3,21 +3,20 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
 function toArrayBuffer(buf) {
   const ab = new ArrayBuffer(buf.length);
   const view = new Uint8Array(ab);
-  return buf.map((b, i) => view[i] = b);
+  return buf.map((b, i) => (view[i] = b));
 }
 
 function toDataView(buf) {
   const ab = new ArrayBuffer(buf.length);
   const view = new DataView(ab);
-  return buf.map((b, i) => view[i] = b);
+  return buf.map((b, i) => (view[i] = b));
 }
 
 const keyBuff = fixtures.readKey('agent1-key.pem');
@@ -81,14 +80,18 @@ const caArrDataView = toDataView(caCert);
   [true, [certBuff, certBuff2]]
 ].forEach(([key, cert, index]) => {
   const type = typeof (index === undefined ? key : key[index]);
-  common.expectsError(() => {
-    tls.createServer({ key, cert });
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.key" property must be one of type string, Buffer, ' +
-             `TypedArray, or DataView. Received type ${type}`
-  });
+  common.expectsError(
+    () => {
+      tls.createServer({ key, cert });
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "options.key" property must be one of type string, Buffer, ' +
+        `TypedArray, or DataView. Received type ${type}`
+    }
+  );
 });
 
 [
@@ -106,14 +109,18 @@ const caArrDataView = toDataView(caCert);
   [[keyStr, keyStr2], true]
 ].forEach(([key, cert, index]) => {
   const type = typeof (index === undefined ? cert : cert[index]);
-  common.expectsError(() => {
-    tls.createServer({ key, cert });
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.cert" property must be one of type string, Buffer,' +
-             ` TypedArray, or DataView. Received type ${type}`
-  });
+  common.expectsError(
+    () => {
+      tls.createServer({ key, cert });
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "options.cert" property must be one of type string, Buffer,' +
+        ` TypedArray, or DataView. Received type ${type}`
+    }
+  );
 });
 
 // Checks to ensure tls.createServer works with the CA parameter
@@ -125,7 +132,7 @@ const caArrDataView = toDataView(caCert);
   [keyBuff, certBuff, [caCertStr, caCertStr2]],
   [keyBuff, certBuff, caArrBuff],
   [keyBuff, certBuff, caArrDataView],
-  [keyBuff, certBuff, false],
+  [keyBuff, certBuff, false]
 ].forEach(([key, cert, ca]) => {
   tls.createServer({ key, cert, ca });
 });
@@ -140,14 +147,18 @@ const caArrDataView = toDataView(caCert);
   [keyBuff, certBuff, [caCert, true], 1]
 ].forEach(([key, cert, ca, index]) => {
   const type = typeof (index === undefined ? ca : ca[index]);
-  common.expectsError(() => {
-    tls.createServer({ key, cert, ca });
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.ca" property must be one of type string, Buffer, ' +
-             `TypedArray, or DataView. Received type ${type}`
-  });
+  common.expectsError(
+    () => {
+      tls.createServer({ key, cert, ca });
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "options.ca" property must be one of type string, Buffer, ' +
+        `TypedArray, or DataView. Received type ${type}`
+    }
+  );
 });
 
 // Checks to ensure tls.createSecureContext works with false-y input
diff --git a/test/parallel/test-tls-over-http-tunnel.js b/test/parallel/test-tls-over-http-tunnel.js
index b26cf7872f6582..fef298f841ddc9 100644
--- a/test/parallel/test-tls-over-http-tunnel.js
+++ b/test/parallel/test-tls-over-http-tunnel.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // This test ensures that the data received through tls over http tunnel
 // is same as what is sent.
@@ -40,14 +39,17 @@ const cert = fixtures.readKey('agent1-cert.pem');
 
 const options = { key, cert };
 
-const server = https.createServer(options, common.mustCall((req, res) => {
-  console.log('SERVER: got request');
-  res.writeHead(200, {
-    'content-type': 'text/plain'
-  });
-  console.log('SERVER: sending response');
-  res.end('hello world\n');
-}));
+const server = https.createServer(
+  options,
+  common.mustCall((req, res) => {
+    console.log('SERVER: got request');
+    res.writeHead(200, {
+      'content-type': 'text/plain'
+    });
+    console.log('SERVER: sending response');
+    res.end('hello world\n');
+  })
+);
 
 const proxy = net.createServer((clientSocket) => {
   console.log('PROXY: got a client connection');
@@ -57,33 +59,43 @@ const proxy = net.createServer((clientSocket) => {
   clientSocket.on('data', (chunk) => {
     if (!serverSocket) {
       // Verify the CONNECT request
-      assert.strictEqual(chunk.toString(),
-                         `CONNECT localhost:${server.address().port} ` +
-                         'HTTP/1.1\r\n' +
-                         'Proxy-Connections: keep-alive\r\n' +
-                         `Host: localhost:${proxy.address().port}\r\n` +
-                         'Connection: close\r\n\r\n');
+      assert.strictEqual(
+        chunk.toString(),
+        `CONNECT localhost:${server.address().port} ` +
+          'HTTP/1.1\r\n' +
+          'Proxy-Connections: keep-alive\r\n' +
+          `Host: localhost:${proxy.address().port}\r\n` +
+          'Connection: close\r\n\r\n'
+      );
 
       console.log('PROXY: got CONNECT request');
       console.log('PROXY: creating a tunnel');
 
       // create the tunnel
-      serverSocket = net.connect(server.address().port, common.mustCall(() => {
-        console.log('PROXY: replying to client CONNECT request');
-
-        // Send the response
-        clientSocket.write('HTTP/1.1 200 OK\r\nProxy-Connections: keep' +
-          '-alive\r\nConnections: keep-alive\r\nVia: ' +
-          `localhost:${proxy.address().port}\r\n\r\n`);
-      }));
+      serverSocket = net.connect(
+        server.address().port,
+        common.mustCall(() => {
+          console.log('PROXY: replying to client CONNECT request');
+
+          // Send the response
+          clientSocket.write(
+            'HTTP/1.1 200 OK\r\nProxy-Connections: keep' +
+              '-alive\r\nConnections: keep-alive\r\nVia: ' +
+              `localhost:${proxy.address().port}\r\n\r\n`
+          );
+        })
+      );
 
       serverSocket.on('data', (chunk) => {
         clientSocket.write(chunk);
       });
 
-      serverSocket.on('end', common.mustCall(() => {
-        clientSocket.destroy();
-      }));
+      serverSocket.on(
+        'end',
+        common.mustCall(() => {
+          clientSocket.destroy();
+        })
+      );
     } else {
       serverSocket.write(chunk);
     }
@@ -96,80 +108,94 @@ const proxy = net.createServer((clientSocket) => {
 
 server.listen(0);
 
-proxy.listen(0, common.mustCall(() => {
-  console.log('CLIENT: Making CONNECT request');
+proxy.listen(
+  0,
+  common.mustCall(() => {
+    console.log('CLIENT: Making CONNECT request');
+
+    const req = http.request({
+      port: proxy.address().port,
+      method: 'CONNECT',
+      path: `localhost:${server.address().port}`,
+      headers: {
+        'Proxy-Connections': 'keep-alive'
+      }
+    });
+    req.useChunkedEncodingByDefault = false; // for v0.6
+    req.on('response', onResponse); // for v0.6
+    req.on('upgrade', onUpgrade); // for v0.6
+    req.on('connect', onConnect); // for v0.7 or later
+    req.end();
+
+    function onResponse(res) {
+      // Very hacky. This is necessary to avoid http-parser leaks.
+      res.upgrade = true;
+    }
 
-  const req = http.request({
-    port: proxy.address().port,
-    method: 'CONNECT',
-    path: `localhost:${server.address().port}`,
-    headers: {
-      'Proxy-Connections': 'keep-alive'
+    function onUpgrade(res, socket, head) {
+      // Hacky.
+      process.nextTick(() => {
+        onConnect(res, socket, head);
+      });
     }
-  });
-  req.useChunkedEncodingByDefault = false; // for v0.6
-  req.on('response', onResponse); // for v0.6
-  req.on('upgrade', onUpgrade);   // for v0.6
-  req.on('connect', onConnect);   // for v0.7 or later
-  req.end();
-
-  function onResponse(res) {
-    // Very hacky. This is necessary to avoid http-parser leaks.
-    res.upgrade = true;
-  }
-
-  function onUpgrade(res, socket, head) {
-    // Hacky.
-    process.nextTick(() => {
-      onConnect(res, socket, head);
-    });
-  }
-
-  function onConnect(res, socket, header) {
-    assert.strictEqual(res.statusCode, 200);
-    console.log('CLIENT: got CONNECT response');
-
-    // detach the socket
-    socket.removeAllListeners('data');
-    socket.removeAllListeners('close');
-    socket.removeAllListeners('error');
-    socket.removeAllListeners('drain');
-    socket.removeAllListeners('end');
-    socket.ondata = null;
-    socket.onend = null;
-    socket.ondrain = null;
-
-    console.log('CLIENT: Making HTTPS request');
-
-    https.get({
-      path: '/foo',
-      key: key,
-      cert: cert,
-      socket: socket,  // reuse the socket
-      agent: false,
-      rejectUnauthorized: false
-    }, (res) => {
-      assert.strictEqual(res.statusCode, 200);
 
-      res.on('data', common.mustCall((chunk) => {
-        assert.strictEqual(chunk.toString(), 'hello world\n');
-        console.log('CLIENT: got HTTPS response');
-        gotRequest = true;
-      }));
-
-      res.on('end', common.mustCall(() => {
-        proxy.close();
-        server.close();
-      }));
-    }).on('error', (er) => {
-      // We're ok with getting ECONNRESET in this test, but it's
-      // timing-dependent, and thus unreliable. Any other errors
-      // are just failures, though.
-      if (er.code !== 'ECONNRESET')
-        throw er;
-    }).end();
-  }
-}));
+    function onConnect(res, socket, header) {
+      assert.strictEqual(res.statusCode, 200);
+      console.log('CLIENT: got CONNECT response');
+
+      // detach the socket
+      socket.removeAllListeners('data');
+      socket.removeAllListeners('close');
+      socket.removeAllListeners('error');
+      socket.removeAllListeners('drain');
+      socket.removeAllListeners('end');
+      socket.ondata = null;
+      socket.onend = null;
+      socket.ondrain = null;
+
+      console.log('CLIENT: Making HTTPS request');
+
+      https
+        .get(
+          {
+            path: '/foo',
+            key: key,
+            cert: cert,
+            socket: socket, // reuse the socket
+            agent: false,
+            rejectUnauthorized: false
+          },
+          (res) => {
+            assert.strictEqual(res.statusCode, 200);
+
+            res.on(
+              'data',
+              common.mustCall((chunk) => {
+                assert.strictEqual(chunk.toString(), 'hello world\n');
+                console.log('CLIENT: got HTTPS response');
+                gotRequest = true;
+              })
+            );
+
+            res.on(
+              'end',
+              common.mustCall(() => {
+                proxy.close();
+                server.close();
+              })
+            );
+          }
+        )
+        .on('error', (er) => {
+          // We're ok with getting ECONNRESET in this test, but it's
+          // timing-dependent, and thus unreliable. Any other errors
+          // are just failures, though.
+          if (er.code !== 'ECONNRESET') throw er;
+        })
+        .end();
+    }
+  })
+);
 
 process.on('exit', () => {
   assert.ok(gotRequest);
diff --git a/test/parallel/test-tls-parse-cert-string.js b/test/parallel/test-tls-parse-cert-string.js
index a3062c227e6fd1..f9bebd569164e2 100644
--- a/test/parallel/test-tls-parse-cert-string.js
+++ b/test/parallel/test-tls-parse-cert-string.js
@@ -2,13 +2,9 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-const {
-  hijackStderr,
-  restoreStderr
-} = require('../common/hijackstdio');
+const { hijackStderr, restoreStderr } = require('../common/hijackstdio');
 const assert = require('assert');
 // Flags: --expose_internals
 const internalTLS = require('internal/tls');
@@ -18,8 +14,9 @@ const noOutput = common.mustNotCall();
 hijackStderr(noOutput);
 
 {
-  const singles = 'C=US\nST=CA\nL=SF\nO=Node.js Foundation\nOU=Node.js\n' +
-                  'CN=ca1\nemailAddress=ry@clouds.org';
+  const singles =
+    'C=US\nST=CA\nL=SF\nO=Node.js Foundation\nOU=Node.js\n' +
+    'CN=ca1\nemailAddress=ry@clouds.org';
   const singlesOut = internalTLS.parseCertString(singles);
   assert.deepStrictEqual(singlesOut, {
     __proto__: null,
@@ -34,12 +31,13 @@ hijackStderr(noOutput);
 }
 
 {
-  const doubles = 'OU=Domain Control Validated\nOU=PositiveSSL Wildcard\n' +
-                  'CN=*.nodejs.org';
+  const doubles =
+    'OU=Domain Control Validated\nOU=PositiveSSL Wildcard\n' +
+    'CN=*.nodejs.org';
   const doublesOut = internalTLS.parseCertString(doubles);
   assert.deepStrictEqual(doublesOut, {
     __proto__: null,
-    OU: [ 'Domain Control Validated', 'PositiveSSL Wildcard' ],
+    OU: ['Domain Control Validated', 'PositiveSSL Wildcard'],
     CN: '*.nodejs.org'
   });
 }
@@ -61,10 +59,12 @@ hijackStderr(noOutput);
 restoreStderr();
 
 {
-  common.expectWarning('DeprecationWarning',
-                       'tls.parseCertString() is deprecated. ' +
-                       'Please use querystring.parse() instead.',
-                       'DEP0076');
+  common.expectWarning(
+    'DeprecationWarning',
+    'tls.parseCertString() is deprecated. ' +
+      'Please use querystring.parse() instead.',
+    'DEP0076'
+  );
 
   const ret = tls.parseCertString('foo=bar');
   assert.deepStrictEqual(ret, { __proto__: null, foo: 'bar' });
diff --git a/test/parallel/test-tls-passphrase.js b/test/parallel/test-tls-passphrase.js
index 6ed19c74d22f73..0dfa8580ff350a 100644
--- a/test/parallel/test-tls-passphrase.js
+++ b/test/parallel/test-tls-passphrase.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -37,189 +36,263 @@ assert(Buffer.isBuffer(cert));
 assert.strictEqual(typeof passKey.toString(), 'string');
 assert.strictEqual(typeof cert.toString(), 'string');
 
-const server = tls.Server({
-  key: passKey,
-  passphrase: 'passphrase',
-  cert: cert,
-  ca: [cert],
-  requestCert: true,
-  rejectUnauthorized: true
-}, function(s) {
-  s.end();
-});
-
-server.listen(0, common.mustCall(function() {
-  // Buffer
-  tls.connect({
-    port: this.address().port,
+const server = tls.Server(
+  {
     key: passKey,
     passphrase: 'passphrase',
     cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: rawKey,
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: rawKey,
-    passphrase: 'ignored',
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  // Buffer[]
-  tls.connect({
-    port: this.address().port,
-    key: [passKey],
-    passphrase: 'passphrase',
-    cert: [cert],
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [rawKey],
-    cert: [cert],
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [rawKey],
-    passphrase: 'ignored',
-    cert: [cert],
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  // string
-  tls.connect({
-    port: this.address().port,
-    key: passKey.toString(),
-    passphrase: 'passphrase',
-    cert: cert.toString(),
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: rawKey.toString(),
-    cert: cert.toString(),
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: rawKey.toString(),
-    passphrase: 'ignored',
-    cert: cert.toString(),
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  // String[]
-  tls.connect({
-    port: this.address().port,
-    key: [passKey.toString()],
-    passphrase: 'passphrase',
-    cert: [cert.toString()],
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [rawKey.toString()],
-    cert: [cert.toString()],
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [rawKey.toString()],
-    passphrase: 'ignored',
-    cert: [cert.toString()],
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  // Object[]
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: passKey, passphrase: 'passphrase' }],
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: passKey, passphrase: 'passphrase' }],
-    passphrase: 'ignored',
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: passKey }],
-    passphrase: 'passphrase',
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: passKey.toString(), passphrase: 'passphrase' }],
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: rawKey, passphrase: 'ignored' }],
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: rawKey.toString(), passphrase: 'ignored' }],
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: rawKey }],
-    passphrase: 'ignored',
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: rawKey.toString() }],
-    passphrase: 'ignored',
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: rawKey }],
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-
-  tls.connect({
-    port: this.address().port,
-    key: [{ pem: rawKey.toString() }],
-    cert: cert,
-    rejectUnauthorized: false
-  }, common.mustCall());
-})).unref();
+    ca: [cert],
+    requestCert: true,
+    rejectUnauthorized: true
+  },
+  function(s) {
+    s.end();
+  }
+);
+
+server
+  .listen(
+    0,
+    common.mustCall(function() {
+      // Buffer
+      tls.connect(
+        {
+          port: this.address().port,
+          key: passKey,
+          passphrase: 'passphrase',
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: rawKey,
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: rawKey,
+          passphrase: 'ignored',
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      // Buffer[]
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [passKey],
+          passphrase: 'passphrase',
+          cert: [cert],
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [rawKey],
+          cert: [cert],
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [rawKey],
+          passphrase: 'ignored',
+          cert: [cert],
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      // string
+      tls.connect(
+        {
+          port: this.address().port,
+          key: passKey.toString(),
+          passphrase: 'passphrase',
+          cert: cert.toString(),
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: rawKey.toString(),
+          cert: cert.toString(),
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: rawKey.toString(),
+          passphrase: 'ignored',
+          cert: cert.toString(),
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      // String[]
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [passKey.toString()],
+          passphrase: 'passphrase',
+          cert: [cert.toString()],
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [rawKey.toString()],
+          cert: [cert.toString()],
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [rawKey.toString()],
+          passphrase: 'ignored',
+          cert: [cert.toString()],
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      // Object[]
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: passKey, passphrase: 'passphrase' }],
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: passKey, passphrase: 'passphrase' }],
+          passphrase: 'ignored',
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: passKey }],
+          passphrase: 'passphrase',
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: passKey.toString(), passphrase: 'passphrase' }],
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: rawKey, passphrase: 'ignored' }],
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: rawKey.toString(), passphrase: 'ignored' }],
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: rawKey }],
+          passphrase: 'ignored',
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: rawKey.toString() }],
+          passphrase: 'ignored',
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: rawKey }],
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+
+      tls.connect(
+        {
+          port: this.address().port,
+          key: [{ pem: rawKey.toString() }],
+          cert: cert,
+          rejectUnauthorized: false
+        },
+        common.mustCall()
+      );
+    })
+  )
+  .unref();
 
 const errMessagePassword = /bad decrypt/;
 
diff --git a/test/parallel/test-tls-pause.js b/test/parallel/test-tls-pause.js
index e246acff807a91..3fb3c6959a2658 100644
--- a/test/parallel/test-tls-pause.js
+++ b/test/parallel/test-tls-pause.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // This test ensures that the data received over tls-server after pause
 // is same as what it was sent
@@ -40,52 +39,61 @@ const bufSize = 1024 * 1024;
 let sent = 0;
 let received = 0;
 
-const server = tls.Server(options, common.mustCall((socket) => {
-  socket.pipe(socket);
-  socket.on('data', (c) => {
-    console.error('data', c.length);
-  });
-}));
+const server = tls.Server(
+  options,
+  common.mustCall((socket) => {
+    socket.pipe(socket);
+    socket.on('data', (c) => {
+      console.error('data', c.length);
+    });
+  })
+);
 
-server.listen(0, common.mustCall(() => {
-  let resumed = false;
-  const client = tls.connect({
-    port: server.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(() => {
-    console.error('connected');
-    client.pause();
-    console.error('paused');
-    const send = (() => {
-      console.error('sending');
-      const ret = client.write(Buffer.allocUnsafe(bufSize));
-      console.error(`write => ${ret}`);
-      if (ret !== false) {
-        console.error('write again');
-        sent += bufSize;
-        assert.ok(sent < 100 * 1024 * 1024); // max 100MB
-        return process.nextTick(send);
+server.listen(
+  0,
+  common.mustCall(() => {
+    let resumed = false;
+    const client = tls.connect(
+      {
+        port: server.address().port,
+        rejectUnauthorized: false
+      },
+      common.mustCall(() => {
+        console.error('connected');
+        client.pause();
+        console.error('paused');
+        const send = (() => {
+          console.error('sending');
+          const ret = client.write(Buffer.allocUnsafe(bufSize));
+          console.error(`write => ${ret}`);
+          if (ret !== false) {
+            console.error('write again');
+            sent += bufSize;
+            assert.ok(sent < 100 * 1024 * 1024); // max 100MB
+            return process.nextTick(send);
+          }
+          sent += bufSize;
+          console.error(`sent: ${sent}`);
+          resumed = true;
+          client.resume();
+          console.error('resumed', client);
+        })();
+      })
+    );
+    client.on('data', (data) => {
+      console.error('data');
+      assert.ok(resumed);
+      received += data.length;
+      console.error('received', received);
+      console.error('sent', sent);
+      if (received >= sent) {
+        console.error(`received: ${received}`);
+        client.end();
+        server.close();
       }
-      sent += bufSize;
-      console.error(`sent: ${sent}`);
-      resumed = true;
-      client.resume();
-      console.error('resumed', client);
-    })();
-  }));
-  client.on('data', (data) => {
-    console.error('data');
-    assert.ok(resumed);
-    received += data.length;
-    console.error('received', received);
-    console.error('sent', sent);
-    if (received >= sent) {
-      console.error(`received: ${received}`);
-      client.end();
-      server.close();
-    }
-  });
-}));
+    });
+  })
+);
 
 process.on('exit', () => {
   assert.strictEqual(sent, received);
diff --git a/test/parallel/test-tls-peer-certificate-encoding.js b/test/parallel/test-tls-peer-certificate-encoding.js
index 19c7cde42cdc16..71cf9befa0962c 100644
--- a/test/parallel/test-tls-peer-certificate-encoding.js
+++ b/test/parallel/test-tls-peer-certificate-encoding.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -32,22 +31,28 @@ const fixtures = require('../common/fixtures');
 const options = {
   key: fixtures.readKey('agent5-key.pem'),
   cert: fixtures.readKey('agent5-cert.pem'),
-  ca: [ fixtures.readKey('ca2-cert.pem') ]
+  ca: [fixtures.readKey('ca2-cert.pem')]
 };
 
 const server = tls.createServer(options, function(cleartext) {
   cleartext.end('World');
 });
-server.listen(0, common.mustCall(function() {
-  const socket = tls.connect({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    const peerCert = socket.getPeerCertificate();
+server.listen(
+  0,
+  common.mustCall(function() {
+    const socket = tls.connect(
+      {
+        port: this.address().port,
+        rejectUnauthorized: false
+      },
+      common.mustCall(function() {
+        const peerCert = socket.getPeerCertificate();
 
-    console.error(util.inspect(peerCert));
-    assert.strictEqual(peerCert.subject.CN, 'Ádám Lippai');
-    server.close();
-  }));
-  socket.end('Hello');
-}));
+        console.error(util.inspect(peerCert));
+        assert.strictEqual(peerCert.subject.CN, 'Ádám Lippai');
+        server.close();
+      })
+    );
+    socket.end('Hello');
+  })
+);
diff --git a/test/parallel/test-tls-peer-certificate-multi-keys.js b/test/parallel/test-tls-peer-certificate-multi-keys.js
index a2548d6bcffb9e..5987766333a49d 100644
--- a/test/parallel/test-tls-peer-certificate-multi-keys.js
+++ b/test/parallel/test-tls-peer-certificate-multi-keys.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -37,26 +36,37 @@ const server = tls.createServer(options, function(cleartext) {
   cleartext.end('World');
 });
 
-server.once('secureConnection', common.mustCall(function(socket) {
-  const cert = socket.getCertificate();
-  // The server's local cert is the client's peer cert.
-  assert.deepStrictEqual(
-    cert.subject.OU,
-    ['Information Technology', 'Engineering', 'Marketing']
-  );
-}));
+server.once(
+  'secureConnection',
+  common.mustCall(function(socket) {
+    const cert = socket.getCertificate();
+    // The server's local cert is the client's peer cert.
+    assert.deepStrictEqual(cert.subject.OU, [
+      'Information Technology',
+      'Engineering',
+      'Marketing'
+    ]);
+  })
+);
 
-server.listen(0, common.mustCall(function() {
-  const socket = tls.connect({
-    port: this.address().port,
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    const peerCert = socket.getPeerCertificate();
-    assert.deepStrictEqual(
-      peerCert.subject.OU,
-      ['Information Technology', 'Engineering', 'Marketing']
+server.listen(
+  0,
+  common.mustCall(function() {
+    const socket = tls.connect(
+      {
+        port: this.address().port,
+        rejectUnauthorized: false
+      },
+      common.mustCall(function() {
+        const peerCert = socket.getPeerCertificate();
+        assert.deepStrictEqual(peerCert.subject.OU, [
+          'Information Technology',
+          'Engineering',
+          'Marketing'
+        ]);
+        server.close();
+      })
     );
-    server.close();
-  }));
-  socket.end('Hello');
-}));
+    socket.end('Hello');
+  })
+);
diff --git a/test/parallel/test-tls-peer-certificate.js b/test/parallel/test-tls-peer-certificate.js
index 0b820b93eb2ada..719d8675e48627 100644
--- a/test/parallel/test-tls-peer-certificate.js
+++ b/test/parallel/test-tls-peer-certificate.js
@@ -29,60 +29,62 @@ const crypto = require('crypto');
 
 // Verify that detailed getPeerCertificate() return value has all certs.
 
-const {
-  assert, connect, debug, keys
-} = require(fixtures.path('tls-connect'));
+const { assert, connect, debug, keys } = require(fixtures.path('tls-connect'));
 
 function sha256(s) {
   return crypto.createHash('sha256').update(s);
 }
 
-connect({
-  client: { rejectUnauthorized: false },
-  server: keys.agent1,
-}, function(err, pair, cleanup) {
-  assert.ifError(err);
-  const socket = pair.client.conn;
-  const localCert = socket.getCertificate();
-  assert.deepStrictEqual(localCert, {});
-  let peerCert = socket.getPeerCertificate();
-  assert.ok(!peerCert.issuerCertificate);
+connect(
+  {
+    client: { rejectUnauthorized: false },
+    server: keys.agent1
+  },
+  function(err, pair, cleanup) {
+    assert.ifError(err);
+    const socket = pair.client.conn;
+    const localCert = socket.getCertificate();
+    assert.deepStrictEqual(localCert, {});
+    let peerCert = socket.getPeerCertificate();
+    assert.ok(!peerCert.issuerCertificate);
 
-  peerCert = socket.getPeerCertificate(true);
-  debug('peerCert:\n', peerCert);
+    peerCert = socket.getPeerCertificate(true);
+    debug('peerCert:\n', peerCert);
 
-  assert.ok(peerCert.issuerCertificate);
-  assert.strictEqual(peerCert.subject.emailAddress, 'ry@tinyclouds.org');
-  assert.strictEqual(peerCert.serialNumber, 'ECC9B856270DA9A8');
-  assert.strictEqual(peerCert.exponent, '0x10001');
-  assert.strictEqual(
-    peerCert.fingerprint,
-    'D7:FD:F6:42:92:A8:83:51:8E:80:48:62:66:DA:85:C2:EE:A6:A1:CD'
-  );
-  assert.strictEqual(
-    peerCert.fingerprint256,
-    'B0:BE:46:49:B8:29:63:E0:6F:63:C8:8A:57:9C:3F:9B:72:C6:F5:89:E3:0D:84:AC:' +
-    '5B:08:9A:20:89:B6:8F:D6'
-  );
+    assert.ok(peerCert.issuerCertificate);
+    assert.strictEqual(peerCert.subject.emailAddress, 'ry@tinyclouds.org');
+    assert.strictEqual(peerCert.serialNumber, 'ECC9B856270DA9A8');
+    assert.strictEqual(peerCert.exponent, '0x10001');
+    assert.strictEqual(
+      peerCert.fingerprint,
+      'D7:FD:F6:42:92:A8:83:51:8E:80:48:62:66:DA:85:C2:EE:A6:A1:CD'
+    );
+    assert.strictEqual(
+      peerCert.fingerprint256,
+      'B0:BE:46:49:B8:29:63:E0:6F:63:C8:8A:57:9C:3F:9B:72:C6:F5:89:E3:0D:84:AC:' +
+        '5B:08:9A:20:89:B6:8F:D6'
+    );
 
-  // SHA256 fingerprint of the public key
-  assert.strictEqual(
-    sha256(peerCert.pubkey).digest('hex'),
-    '221fcc8593146e9eee65b2f7f9c1504993ece8de014657a4a1cde55c5e35d06e'
-  );
+    // SHA256 fingerprint of the public key
+    assert.strictEqual(
+      sha256(peerCert.pubkey).digest('hex'),
+      '221fcc8593146e9eee65b2f7f9c1504993ece8de014657a4a1cde55c5e35d06e'
+    );
 
-  // HPKP / RFC7469 "pin-sha256" of the public key
-  assert.strictEqual(
-    sha256(peerCert.pubkey).digest('base64'),
-    'Ih/MhZMUbp7uZbL3+cFQSZPs6N4BRlekoc3lXF410G4='
-  );
+    // HPKP / RFC7469 "pin-sha256" of the public key
+    assert.strictEqual(
+      sha256(peerCert.pubkey).digest('base64'),
+      'Ih/MhZMUbp7uZbL3+cFQSZPs6N4BRlekoc3lXF410G4='
+    );
 
-  assert.deepStrictEqual(peerCert.infoAccess['OCSP - URI'],
-                         [ 'http://ocsp.nodejs.org/' ]);
+    assert.deepStrictEqual(peerCert.infoAccess['OCSP - URI'], [
+      'http://ocsp.nodejs.org/'
+    ]);
 
-  const issuer = peerCert.issuerCertificate;
-  assert.strictEqual(issuer.issuerCertificate, issuer);
-  assert.strictEqual(issuer.serialNumber, 'CB153AE212609FC6');
+    const issuer = peerCert.issuerCertificate;
+    assert.strictEqual(issuer.issuerCertificate, issuer);
+    assert.strictEqual(issuer.serialNumber, 'CB153AE212609FC6');
 
-  return cleanup();
-});
+    return cleanup();
+  }
+);
diff --git a/test/parallel/test-tls-pfx-authorizationerror.js b/test/parallel/test-tls-pfx-authorizationerror.js
index 6daf89dff0d82f..b2f85c09e400cf 100644
--- a/test/parallel/test-tls-pfx-authorizationerror.js
+++ b/test/parallel/test-tls-pfx-authorizationerror.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('node compiled without crypto.');
+if (!common.hasCrypto) common.skip('node compiled without crypto.');
 const fixtures = require('../common/fixtures');
 
 // This test ensures that TLS does not fail to read a self-signed certificate
@@ -22,8 +21,10 @@ const server = tls
       rejectUnauthorized: false
     },
     common.mustCall(function(c) {
-      assert.strictEqual(c.getPeerCertificate().serialNumber,
-                         'ECC9B856270DA9A8');
+      assert.strictEqual(
+        c.getPeerCertificate().serialNumber,
+        'ECC9B856270DA9A8'
+      );
       assert.strictEqual(c.authorizationError, null);
       c.end();
     })
@@ -37,8 +38,10 @@ const server = tls
         rejectUnauthorized: false
       },
       function() {
-        assert.strictEqual(client.getCertificate().serialNumber,
-                           'ECC9B856270DA9A8');
+        assert.strictEqual(
+          client.getCertificate().serialNumber,
+          'ECC9B856270DA9A8'
+        );
         client.end();
         server.close();
       }
diff --git a/test/parallel/test-tls-request-timeout.js b/test/parallel/test-tls-request-timeout.js
index 6bbb8432f5ed0b..9f8f70670446f7 100644
--- a/test/parallel/test-tls-request-timeout.js
+++ b/test/parallel/test-tls-request-timeout.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -33,15 +32,21 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = tls.Server(options, common.mustCall(function(socket) {
-  const s = socket.setTimeout(100);
-  assert.ok(s instanceof tls.TLSSocket);
+const server = tls.Server(
+  options,
+  common.mustCall(function(socket) {
+    const s = socket.setTimeout(100);
+    assert.ok(s instanceof tls.TLSSocket);
 
-  socket.on('timeout', common.mustCall(function(err) {
-    socket.end();
-    server.close();
-  }));
-}));
+    socket.on(
+      'timeout',
+      common.mustCall(function(err) {
+        socket.end();
+        server.close();
+      })
+    );
+  })
+);
 
 server.listen(0, function() {
   tls.connect({
diff --git a/test/parallel/test-tls-retain-handle-no-abort.js b/test/parallel/test-tls-retain-handle-no-abort.js
index 6571aab3a95721..ca7a428ef7148e 100644
--- a/test/parallel/test-tls-retain-handle-no-abort.js
+++ b/test/parallel/test-tls-retain-handle-no-abort.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -25,16 +24,21 @@ process.on('exit', function() {
   util.inspect(ssl);
 });
 
-const server = tls.createServer(serverOptions, function(s) {
-  s.on('data', function() { });
-  s.on('end', function() {
-    server.close();
-    s.destroy();
+const server = tls
+  .createServer(serverOptions, function(s) {
+    s.on('data', function() {});
+    s.on('end', function() {
+      server.close();
+      s.destroy();
+    });
+  })
+  .listen(0, function() {
+    const c = new tls.TLSSocket();
+    ssl = c.ssl;
+    c.connect(
+      this.address().port,
+      function() {
+        c.end(sent);
+      }
+    );
   });
-}).listen(0, function() {
-  const c = new tls.TLSSocket();
-  ssl = c.ssl;
-  c.connect(this.address().port, function() {
-    c.end(sent);
-  });
-});
diff --git a/test/parallel/test-tls-securepair-fiftharg.js b/test/parallel/test-tls-securepair-fiftharg.js
index 185dc43d941ca6..6124b039009c0e 100644
--- a/test/parallel/test-tls-securepair-fiftharg.js
+++ b/test/parallel/test-tls-securepair-fiftharg.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
diff --git a/test/parallel/test-tls-securepair-leak.js b/test/parallel/test-tls-securepair-leak.js
index 4cd927d64ac088..3185bf4177a984 100644
--- a/test/parallel/test-tls-securepair-leak.js
+++ b/test/parallel/test-tls-securepair-leak.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const { createSecureContext } = require('tls');
diff --git a/test/parallel/test-tls-securepair-server.js b/test/parallel/test-tls-securepair-server.js
index 92234fb4108fc5..4173f67cb92230 100644
--- a/test/parallel/test-tls-securepair-server.js
+++ b/test/parallel/test-tls-securepair-server.js
@@ -21,11 +21,9 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('missing openssl-cli');
+if (!common.opensslCli) common.skip('missing openssl-cli');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -40,107 +38,117 @@ function log(a) {
   console.error(`***server*** ${a}`);
 }
 
-const server = net.createServer(common.mustCall(function(socket) {
-  log(`connection fd=${socket.fd}`);
-  const sslcontext = tls.createSecureContext({ key, cert });
-  sslcontext.context.setCiphers('RC4-SHA:AES128-SHA:AES256-SHA');
-
-  const pair = tls.createSecurePair(sslcontext, true);
-
-  assert.ok(pair.encrypted.writable);
-  assert.ok(pair.cleartext.writable);
-
-  pair.encrypted.pipe(socket);
-  socket.pipe(pair.encrypted);
-
-  log('i set it secure');
-
-  pair.on('secure', function() {
-    log('connected+secure!');
-    pair.cleartext.write('hello\r\n');
-    log(pair.cleartext.getPeerCertificate());
-    log(pair.cleartext.getCipher());
-  });
-
-  pair.cleartext.on('data', function(data) {
-    log(`read bytes ${data.length}`);
-    pair.cleartext.write(data);
-  });
-
-  socket.on('end', function() {
-    log('socket end');
-  });
-
-  pair.cleartext.on('error', function(err) {
-    log('got error: ');
-    log(err);
-    log(err.stack);
-    socket.destroy();
-  });
-
-  pair.encrypted.on('error', function(err) {
-    log('encrypted error: ');
-    log(err);
-    log(err.stack);
-    socket.destroy();
-  });
-
-  socket.on('error', function(err) {
-    log('socket error: ');
-    log(err);
-    log(err.stack);
-    socket.destroy();
-  });
-
-  socket.on('close', function(err) {
-    log('socket closed');
-  });
-
-  pair.on('error', function(err) {
-    log('secure error: ');
-    log(err);
-    log(err.stack);
-    socket.destroy();
-  });
-}));
+const server = net.createServer(
+  common.mustCall(function(socket) {
+    log(`connection fd=${socket.fd}`);
+    const sslcontext = tls.createSecureContext({ key, cert });
+    sslcontext.context.setCiphers('RC4-SHA:AES128-SHA:AES256-SHA');
+
+    const pair = tls.createSecurePair(sslcontext, true);
+
+    assert.ok(pair.encrypted.writable);
+    assert.ok(pair.cleartext.writable);
+
+    pair.encrypted.pipe(socket);
+    socket.pipe(pair.encrypted);
+
+    log('i set it secure');
+
+    pair.on('secure', function() {
+      log('connected+secure!');
+      pair.cleartext.write('hello\r\n');
+      log(pair.cleartext.getPeerCertificate());
+      log(pair.cleartext.getCipher());
+    });
+
+    pair.cleartext.on('data', function(data) {
+      log(`read bytes ${data.length}`);
+      pair.cleartext.write(data);
+    });
+
+    socket.on('end', function() {
+      log('socket end');
+    });
+
+    pair.cleartext.on('error', function(err) {
+      log('got error: ');
+      log(err);
+      log(err.stack);
+      socket.destroy();
+    });
+
+    pair.encrypted.on('error', function(err) {
+      log('encrypted error: ');
+      log(err);
+      log(err.stack);
+      socket.destroy();
+    });
+
+    socket.on('error', function(err) {
+      log('socket error: ');
+      log(err);
+      log(err.stack);
+      socket.destroy();
+    });
+
+    socket.on('close', function(err) {
+      log('socket closed');
+    });
+
+    pair.on('error', function(err) {
+      log('secure error: ');
+      log(err);
+      log(err.stack);
+      socket.destroy();
+    });
+  })
+);
 
 let gotHello = false;
 let sentWorld = false;
 let gotWorld = false;
 
-server.listen(0, common.mustCall(function() {
-  // To test use: openssl s_client -connect localhost:8000
-
-  const args = ['s_client', '-connect', `127.0.0.1:${this.address().port}`];
-
-  const client = spawn(common.opensslCli, args);
-
-
-  let out = '';
-
-  client.stdout.setEncoding('utf8');
-  client.stdout.on('data', function(d) {
-    out += d;
-
-    if (!gotHello && /hello/.test(out)) {
-      gotHello = true;
-      client.stdin.write('world\r\n');
-      sentWorld = true;
-    }
-
-    if (!gotWorld && /world/.test(out)) {
-      gotWorld = true;
-      client.stdin.end();
-    }
-  });
-
-  client.stdout.pipe(process.stdout, { end: false });
-
-  client.on('exit', common.mustCall(function(code) {
-    assert.strictEqual(code, 0);
-    server.close();
-  }));
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    // To test use: openssl s_client -connect localhost:8000
+
+    const args = ['s_client', '-connect', `127.0.0.1:${this.address().port}`];
+
+    const client = spawn(common.opensslCli, args);
+
+    let out = '';
+
+    client.stdout.setEncoding('utf8');
+    client.stdout.on('data', function(d) {
+      out += d;
+
+      if (!gotHello && /hello/.test(out)) {
+        gotHello = true;
+        client.stdin.write('world\r\n');
+        sentWorld = true;
+      }
+
+      if (!gotWorld && /world/.test(out)) {
+        gotWorld = true;
+        client.stdin.end();
+      }
+    });
+
+    client.stdout.pipe(
+      process.stdout,
+      { end: false }
+    );
+
+    client.on(
+      'exit',
+      common.mustCall(function(code) {
+        assert.strictEqual(code, 0);
+        server.close();
+      })
+    );
+  })
+);
 
 process.on('exit', function() {
   assert.ok(gotHello);
diff --git a/test/parallel/test-tls-server-connection-server.js b/test/parallel/test-tls-server-connection-server.js
index 7fb2c74996ab4b..58d23f258de053 100644
--- a/test/parallel/test-tls-server-connection-server.js
+++ b/test/parallel/test-tls-server-connection-server.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -13,20 +12,28 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = tls.createServer(options, function(s) {
-  s.end('hello');
-}).listen(0, function() {
-  const opts = {
-    port: this.address().port,
-    rejectUnauthorized: false
-  };
+const server = tls
+  .createServer(options, function(s) {
+    s.end('hello');
+  })
+  .listen(0, function() {
+    const opts = {
+      port: this.address().port,
+      rejectUnauthorized: false
+    };
 
-  server.on('connection', common.mustCall(function(socket) {
-    assert.strictEqual(socket.server, server);
-    server.close();
-  }));
+    server.on(
+      'connection',
+      common.mustCall(function(socket) {
+        assert.strictEqual(socket.server, server);
+        server.close();
+      })
+    );
 
-  const client = tls.connect(opts, function() {
-    client.end();
+    const client = tls.connect(
+      opts,
+      function() {
+        client.end();
+      }
+    );
   });
-});
diff --git a/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js b/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js
index c4351008c147c9..0ba37cbdae9963 100644
--- a/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js
+++ b/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const net = require('net');
@@ -10,21 +9,31 @@ const assert = require('assert');
 
 const bonkers = Buffer.alloc(1024, 42);
 
-
-const server = tls.createServer({})
+const server = tls
+  .createServer({})
   .listen(0, function() {
-    const c = net.connect({ port: this.address().port }, function() {
-      c.write(bonkers);
-    });
-
-  }).on('tlsClientError', common.mustCall(function(e) {
-    assert.ok(e instanceof Error,
-              'Instance of Error should be passed to error handler');
-    // OpenSSL 1.0.x and 1.1.x use different error codes for junk inputs.
-    assert.ok(
-      /SSL routines:[^:]*:(unknown protocol|wrong version number)/.test(
-        e.message),
-      'Expecting SSL unknown protocol');
+    const c = net.connect(
+      { port: this.address().port },
+      function() {
+        c.write(bonkers);
+      }
+    );
+  })
+  .on(
+    'tlsClientError',
+    common.mustCall(function(e) {
+      assert.ok(
+        e instanceof Error,
+        'Instance of Error should be passed to error handler'
+      );
+      // OpenSSL 1.0.x and 1.1.x use different error codes for junk inputs.
+      assert.ok(
+        /SSL routines:[^:]*:(unknown protocol|wrong version number)/.test(
+          e.message
+        ),
+        'Expecting SSL unknown protocol'
+      );
 
-    server.close();
-  }));
+      server.close();
+    })
+  );
diff --git a/test/parallel/test-tls-server-setoptions-clientcertengine.js b/test/parallel/test-tls-server-setoptions-clientcertengine.js
index 56026c9b23d4ed..5df73f976e38e9 100644
--- a/test/parallel/test-tls-server-setoptions-clientcertengine.js
+++ b/test/parallel/test-tls-server-setoptions-clientcertengine.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -10,9 +9,11 @@ const tls = require('tls');
 {
   const server = tls.createServer();
   assert.strictEqual(server.clientCertEngine, undefined);
-  common.expectWarning('DeprecationWarning',
-                       'Server.prototype.setOptions() is deprecated',
-                       'DEP0122');
+  common.expectWarning(
+    'DeprecationWarning',
+    'Server.prototype.setOptions() is deprecated',
+    'DEP0122'
+  );
   server.setOptions({ clientCertEngine: 'Cannonmouth' });
   assert.strictEqual(server.clientCertEngine, 'Cannonmouth');
 }
diff --git a/test/parallel/test-tls-server-verify.js b/test/parallel/test-tls-server-verify.js
index 2fd815d627fdf7..f590d25776836b 100644
--- a/test/parallel/test-tls-server-verify.js
+++ b/test/parallel/test-tls-server-verify.js
@@ -22,11 +22,9 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
 // This is a rather complex test which sets up various TLS servers with node
 // and connects to them using the 'openssl s_client' command line utility
@@ -38,94 +36,100 @@ if (!common.opensslCli)
 
 const assert = require('assert');
 const { spawn } = require('child_process');
-const { SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION } =
-  require('crypto').constants;
+const {
+  SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
+} = require('crypto').constants;
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
-const testCases =
-  [{ title: 'Do not request certs. Everyone is unauthorized.',
-     requestCert: false,
-     rejectUnauthorized: false,
-     renegotiate: false,
-     CAs: ['ca1-cert'],
-     clients:
-     [{ name: 'agent1', shouldReject: false, shouldAuth: false },
+const testCases = [
+  {
+    title: 'Do not request certs. Everyone is unauthorized.',
+    requestCert: false,
+    rejectUnauthorized: false,
+    renegotiate: false,
+    CAs: ['ca1-cert'],
+    clients: [
+      { name: 'agent1', shouldReject: false, shouldAuth: false },
       { name: 'agent2', shouldReject: false, shouldAuth: false },
       { name: 'agent3', shouldReject: false, shouldAuth: false },
       { name: 'nocert', shouldReject: false, shouldAuth: false }
-     ]
+    ]
   },
 
-   { title: 'Allow both authed and unauthed connections with CA1',
-     requestCert: true,
-     rejectUnauthorized: false,
-     renegotiate: false,
-     CAs: ['ca1-cert'],
-     clients:
-    [{ name: 'agent1', shouldReject: false, shouldAuth: true },
-     { name: 'agent2', shouldReject: false, shouldAuth: false },
-     { name: 'agent3', shouldReject: false, shouldAuth: false },
-     { name: 'nocert', shouldReject: false, shouldAuth: false }
+  {
+    title: 'Allow both authed and unauthed connections with CA1',
+    requestCert: true,
+    rejectUnauthorized: false,
+    renegotiate: false,
+    CAs: ['ca1-cert'],
+    clients: [
+      { name: 'agent1', shouldReject: false, shouldAuth: true },
+      { name: 'agent2', shouldReject: false, shouldAuth: false },
+      { name: 'agent3', shouldReject: false, shouldAuth: false },
+      { name: 'nocert', shouldReject: false, shouldAuth: false }
     ]
-   },
-
-   { title: 'Do not request certs at connection. Do that later',
-     requestCert: false,
-     rejectUnauthorized: false,
-     renegotiate: true,
-     CAs: ['ca1-cert'],
-     clients:
-    [{ name: 'agent1', shouldReject: false, shouldAuth: true },
-     { name: 'agent2', shouldReject: false, shouldAuth: false },
-     { name: 'agent3', shouldReject: false, shouldAuth: false },
-     { name: 'nocert', shouldReject: false, shouldAuth: false }
+  },
+
+  {
+    title: 'Do not request certs at connection. Do that later',
+    requestCert: false,
+    rejectUnauthorized: false,
+    renegotiate: true,
+    CAs: ['ca1-cert'],
+    clients: [
+      { name: 'agent1', shouldReject: false, shouldAuth: true },
+      { name: 'agent2', shouldReject: false, shouldAuth: false },
+      { name: 'agent3', shouldReject: false, shouldAuth: false },
+      { name: 'nocert', shouldReject: false, shouldAuth: false }
     ]
-   },
-
-   { title: 'Allow only authed connections with CA1',
-     requestCert: true,
-     rejectUnauthorized: true,
-     renegotiate: false,
-     CAs: ['ca1-cert'],
-     clients:
-    [{ name: 'agent1', shouldReject: false, shouldAuth: true },
-     { name: 'agent2', shouldReject: true },
-     { name: 'agent3', shouldReject: true },
-     { name: 'nocert', shouldReject: true }
+  },
+
+  {
+    title: 'Allow only authed connections with CA1',
+    requestCert: true,
+    rejectUnauthorized: true,
+    renegotiate: false,
+    CAs: ['ca1-cert'],
+    clients: [
+      { name: 'agent1', shouldReject: false, shouldAuth: true },
+      { name: 'agent2', shouldReject: true },
+      { name: 'agent3', shouldReject: true },
+      { name: 'nocert', shouldReject: true }
     ]
-   },
-
-   { title: 'Allow only authed connections with CA1 and CA2',
-     requestCert: true,
-     rejectUnauthorized: true,
-     renegotiate: false,
-     CAs: ['ca1-cert', 'ca2-cert'],
-     clients:
-    [{ name: 'agent1', shouldReject: false, shouldAuth: true },
-     { name: 'agent2', shouldReject: true },
-     { name: 'agent3', shouldReject: false, shouldAuth: true },
-     { name: 'nocert', shouldReject: true }
+  },
+
+  {
+    title: 'Allow only authed connections with CA1 and CA2',
+    requestCert: true,
+    rejectUnauthorized: true,
+    renegotiate: false,
+    CAs: ['ca1-cert', 'ca2-cert'],
+    clients: [
+      { name: 'agent1', shouldReject: false, shouldAuth: true },
+      { name: 'agent2', shouldReject: true },
+      { name: 'agent3', shouldReject: false, shouldAuth: true },
+      { name: 'nocert', shouldReject: true }
     ]
-   },
-
-
-   { title: 'Allow only certs signed by CA2 but not in the CRL',
-     requestCert: true,
-     rejectUnauthorized: true,
-     renegotiate: false,
-     CAs: ['ca2-cert'],
-     crl: 'ca2-crl',
-     clients: [
-       { name: 'agent1', shouldReject: true, shouldAuth: false },
-       { name: 'agent2', shouldReject: true, shouldAuth: false },
-       { name: 'agent3', shouldReject: false, shouldAuth: true },
-       // Agent4 has a cert in the CRL.
-       { name: 'agent4', shouldReject: true, shouldAuth: false },
-       { name: 'nocert', shouldReject: true }
-     ]
-   }
-  ];
+  },
+
+  {
+    title: 'Allow only certs signed by CA2 but not in the CRL',
+    requestCert: true,
+    rejectUnauthorized: true,
+    renegotiate: false,
+    CAs: ['ca2-cert'],
+    crl: 'ca2-crl',
+    clients: [
+      { name: 'agent1', shouldReject: true, shouldAuth: false },
+      { name: 'agent2', shouldReject: true, shouldAuth: false },
+      { name: 'agent3', shouldReject: false, shouldAuth: true },
+      // Agent4 has a cert in the CRL.
+      { name: 'agent4', shouldReject: true, shouldAuth: false },
+      { name: 'nocert', shouldReject: true }
+    ]
+  }
+];
 
 function filenamePEM(n) {
   return fixtures.path('keys', `${n}.pem`);
@@ -135,13 +139,10 @@ function loadPEM(n) {
   return fixtures.readKey(`${n}.pem`);
 }
 
-
 const serverKey = loadPEM('agent2-key');
 const serverCert = loadPEM('agent2-cert');
 
-
 function runClient(prefix, port, options, cb) {
-
   // Client can connect in three ways:
   // - Self-signed cert
   // - Certificate, but not signed by CA.
@@ -226,23 +227,29 @@ function runClient(prefix, port, options, cb) {
   client.on('exit', function(code) {
     if (options.shouldReject) {
       assert.strictEqual(
-        rejected, true,
-        `${prefix}${options.name} NOT rejected, but should have been`);
+        rejected,
+        true,
+        `${prefix}${options.name} NOT rejected, but should have been`
+      );
     } else {
       assert.strictEqual(
-        rejected, false,
-        `${prefix}${options.name} rejected, but should NOT have been`);
+        rejected,
+        false,
+        `${prefix}${options.name} rejected, but should NOT have been`
+      );
       assert.strictEqual(
-        authed, options.shouldAuth,
+        authed,
+        options.shouldAuth,
         `${prefix}${options.name} authed is ${authed} but should have been ${
-          options.shouldAuth}`);
+          options.shouldAuth
+        }`
+      );
     }
 
     cb();
   });
 }
 
-
 // Run the tests
 let successfulTests = 0;
 function runTest(port, testIndex) {
@@ -270,8 +277,7 @@ function runTest(port, testIndex) {
    * client's certificate (probably because of bug in the openssl)
    */
   if (tcase.renegotiate) {
-    serverOptions.secureOptions =
-        SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
+    serverOptions.secureOptions = SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
   }
 
   let renegotiated = false;
@@ -287,21 +293,25 @@ function runTest(port, testIndex) {
       setTimeout(function() {
         console.error(`${prefix}- connected, renegotiating`);
         c.write('\n_renegotiating\n');
-        return c.renegotiate({
-          requestCert: true,
-          rejectUnauthorized: false
-        }, function(err) {
-          assert.ifError(err);
-          c.write('\n_renegotiated\n');
-          handleConnection(c);
-        });
+        return c.renegotiate(
+          {
+            requestCert: true,
+            rejectUnauthorized: false
+          },
+          function(err) {
+            assert.ifError(err);
+            c.write('\n_renegotiated\n');
+            handleConnection(c);
+          }
+        );
       }, 200);
       return;
     }
 
     if (c.authorized) {
-      console.error(`${prefix}- authed connection: ${
-        c.getPeerCertificate().subject.CN}`);
+      console.error(
+        `${prefix}- authed connection: ${c.getPeerCertificate().subject.CN}`
+      );
       c.write('\n_authed\n');
     } else {
       console.error(`${prefix}- unauthed connection: %s`, c.authorizationError);
@@ -344,11 +354,9 @@ function runTest(port, testIndex) {
   });
 }
 
-
 let nextTest = 0;
 runTest(0, nextTest++);
 
-
 process.on('exit', function() {
   assert.strictEqual(successfulTests, testCases.length);
 });
diff --git a/test/parallel/test-tls-session-cache.js b/test/parallel/test-tls-session-cache.js
index 2a74be0521df21..9eccc52c6afdde 100644
--- a/test/parallel/test-tls-session-cache.js
+++ b/test/parallel/test-tls-session-cache.js
@@ -21,16 +21,13 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const tls = require('tls');
 const { spawn } = require('child_process');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
-
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
 doTest({ tickets: false }, function() {
   doTest({ tickets: true }, function() {
@@ -49,7 +46,7 @@ function doTest(testOptions, callback) {
     ca: [cert],
     requestCert: true,
     rejectUnauthorized: false,
-    secureProtocol: 'TLS_method',
+    secureProtocol: 'TLS_method'
   };
   let requestCount = 0;
   let resumeCount = 0;
@@ -61,8 +58,7 @@ function doTest(testOptions, callback) {
       // We're ok with getting ECONNRESET in this test, but it's
       // timing-dependent, and thus unreliable. Any other errors
       // are just failures, though.
-      if (er.code !== 'ECONNRESET')
-        throw er;
+      if (er.code !== 'ECONNRESET') throw er;
     });
     ++requestCount;
     cleartext.end();
@@ -99,16 +95,20 @@ function doTest(testOptions, callback) {
     const args = [
       's_client',
       '-tls1',
-      '-connect', `localhost:${this.address().port}`,
-      '-servername', 'ohgod',
-      '-key', fixtures.path('agent.key'),
-      '-cert', fixtures.path('agent.crt'),
+      '-connect',
+      `localhost:${this.address().port}`,
+      '-servername',
+      'ohgod',
+      '-key',
+      fixtures.path('agent.key'),
+      '-cert',
+      fixtures.path('agent.crt'),
       '-reconnect'
     ].concat(testOptions.tickets ? [] : '-no_ticket');
 
     function spawnClient() {
       const client = spawn(common.opensslCli, args, {
-        stdio: [ 0, 1, 'pipe' ]
+        stdio: [0, 1, 'pipe']
       });
       let err = '';
       client.stderr.setEncoding('utf8');
@@ -116,22 +116,27 @@ function doTest(testOptions, callback) {
         err += chunk;
       });
 
-      client.on('exit', common.mustCall(function(code, signal) {
-        if (code !== 0) {
-          // If SmartOS and connection refused, then retry. See
-          // https://github.com/nodejs/node/issues/2663.
-          if (common.isSunOS && err.includes('Connection refused')) {
-            requestCount = 0;
-            spawnClient();
-            return;
+      client.on(
+        'exit',
+        common.mustCall(function(code, signal) {
+          if (code !== 0) {
+            // If SmartOS and connection refused, then retry. See
+            // https://github.com/nodejs/node/issues/2663.
+            if (common.isSunOS && err.includes('Connection refused')) {
+              requestCount = 0;
+              spawnClient();
+              return;
+            }
+            assert.fail(`code: ${code}, signal: ${signal}, output: ${err}`);
           }
-          assert.fail(`code: ${code}, signal: ${signal}, output: ${err}`);
-        }
-        assert.strictEqual(code, 0);
-        server.close(common.mustCall(function() {
-          setImmediate(callback);
-        }));
-      }));
+          assert.strictEqual(code, 0);
+          server.close(
+            common.mustCall(function() {
+              setImmediate(callback);
+            })
+          );
+        })
+      );
     }
 
     spawnClient();
diff --git a/test/parallel/test-tls-set-ciphers-error.js b/test/parallel/test-tls-set-ciphers-error.js
index 5ef08dda041f01..674a47352aa4cb 100644
--- a/test/parallel/test-tls-set-ciphers-error.js
+++ b/test/parallel/test-tls-set-ciphers-error.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -14,9 +13,13 @@ const fixtures = require('../common/fixtures');
     cert: fixtures.readKey('agent2-cert.pem'),
     ciphers: 'aes256-sha'
   };
-  assert.throws(() => tls.createServer(options, common.mustNotCall()),
-                /no cipher match/i);
+  assert.throws(
+    () => tls.createServer(options, common.mustNotCall()),
+    /no cipher match/i
+  );
   options.ciphers = 'FOOBARBAZ';
-  assert.throws(() => tls.createServer(options, common.mustNotCall()),
-                /no cipher match/i);
+  assert.throws(
+    () => tls.createServer(options, common.mustNotCall()),
+    /no cipher match/i
+  );
 }
diff --git a/test/parallel/test-tls-set-ciphers.js b/test/parallel/test-tls-set-ciphers.js
index ef2c2543517e5f..c84323596cf7bb 100644
--- a/test/parallel/test-tls-set-ciphers.js
+++ b/test/parallel/test-tls-set-ciphers.js
@@ -22,11 +22,9 @@
 'use strict';
 const common = require('../common');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const exec = require('child_process').exec;
@@ -46,13 +44,17 @@ process.on('exit', function() {
   assert.ok(response.includes(reply));
 });
 
-const server = tls.createServer(options, common.mustCall(function(conn) {
-  conn.end(reply);
-}));
+const server = tls.createServer(
+  options,
+  common.mustCall(function(conn) {
+    conn.end(reply);
+  })
+);
 
 server.listen(0, '127.0.0.1', function() {
   const cmd = `"${common.opensslCli}" s_client -cipher ${
-    options.ciphers} -connect 127.0.0.1:${this.address().port}`;
+    options.ciphers
+  } -connect 127.0.0.1:${this.address().port}`;
 
   exec(cmd, function(err, stdout, stderr) {
     assert.ifError(err);
diff --git a/test/parallel/test-tls-set-encoding.js b/test/parallel/test-tls-set-encoding.js
index 77cb5763aeecca..af4fedbec91e54 100644
--- a/test/parallel/test-tls-set-encoding.js
+++ b/test/parallel/test-tls-set-encoding.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -39,10 +38,12 @@ const messageUtf8 = 'x√ab c';
 // The same string above represented with ASCII
 const messageAscii = 'xb\b\u001aab c';
 
-const server = tls.Server(options, common.mustCall(function(socket) {
-  socket.end(messageUtf8);
-}));
-
+const server = tls.Server(
+  options,
+  common.mustCall(function(socket) {
+    socket.end(messageUtf8);
+  })
+);
 
 server.listen(0, function() {
   const client = tls.connect({
@@ -59,7 +60,6 @@ server.listen(0, function() {
     buffer += d;
   });
 
-
   client.on('close', function() {
     // readyState is deprecated but we want to make
     // sure this isn't triggering an assert in lib/net.js
diff --git a/test/parallel/test-tls-set-secure-context.js b/test/parallel/test-tls-set-secure-context.js
index f8857701c68b3c..2e1ab95ef77319 100644
--- a/test/parallel/test-tls-set-secure-context.js
+++ b/test/parallel/test-tls-set-secure-context.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 // This test verifies the behavior of the tls setSecureContext() method.
 // It also verifies that existing connections are not disrupted when the
@@ -39,39 +38,42 @@ const server = https.createServer(credentialOptions[0], (req, res) => {
   res.end('success');
 });
 
-server.listen(0, common.mustCall(() => {
-  const { port } = server.address();
-  const firstRequest = makeRequest(port, 1);
-
-  async function makeRemainingRequests() {
-    // Wait until the first request is guaranteed to have been handled.
-    if (!firstResponse) {
-      return setImmediate(makeRemainingRequests);
+server.listen(
+  0,
+  common.mustCall(() => {
+    const { port } = server.address();
+    const firstRequest = makeRequest(port, 1);
+
+    async function makeRemainingRequests() {
+      // Wait until the first request is guaranteed to have been handled.
+      if (!firstResponse) {
+        return setImmediate(makeRemainingRequests);
+      }
+
+      assert.strictEqual(await makeRequest(port, 2), 'success');
+
+      server.setSecureContext(credentialOptions[1]);
+      firstResponse.write('request-');
+      await assert.rejects(async () => {
+        await makeRequest(port, 3);
+      }, /^Error: self signed certificate$/);
+
+      server.setSecureContext(credentialOptions[0]);
+      assert.strictEqual(await makeRequest(port, 4), 'success');
+
+      server.setSecureContext(credentialOptions[1]);
+      firstResponse.end('fun!');
+      await assert.rejects(async () => {
+        await makeRequest(port, 5);
+      }, /^Error: self signed certificate$/);
+
+      assert.strictEqual(await firstRequest, 'multi-request-success-fun!');
+      server.close();
     }
 
-    assert.strictEqual(await makeRequest(port, 2), 'success');
-
-    server.setSecureContext(credentialOptions[1]);
-    firstResponse.write('request-');
-    await assert.rejects(async () => {
-      await makeRequest(port, 3);
-    }, /^Error: self signed certificate$/);
-
-    server.setSecureContext(credentialOptions[0]);
-    assert.strictEqual(await makeRequest(port, 4), 'success');
-
-    server.setSecureContext(credentialOptions[1]);
-    firstResponse.end('fun!');
-    await assert.rejects(async () => {
-      await makeRequest(port, 5);
-    }, /^Error: self signed certificate$/);
-
-    assert.strictEqual(await firstRequest, 'multi-request-success-fun!');
-    server.close();
-  }
-
-  makeRemainingRequests();
-}));
+    makeRemainingRequests();
+  })
+);
 
 function makeRequest(port, id) {
   return new Promise((resolve, reject) => {
@@ -82,20 +84,25 @@ function makeRequest(port, id) {
       headers: { id }
     };
 
-    https.get(`https://localhost:${port}`, options, (res) => {
-      let response = '';
-
-      res.setEncoding('utf8');
-
-      res.on('data', (chunk) => {
-        response += chunk;
+    https
+      .get(`https://localhost:${port}`, options, (res) => {
+        let response = '';
+
+        res.setEncoding('utf8');
+
+        res.on('data', (chunk) => {
+          response += chunk;
+        });
+
+        res.on(
+          'end',
+          common.mustCall(() => {
+            resolve(response);
+          })
+        );
+      })
+      .on('error', (err) => {
+        reject(err);
       });
-
-      res.on('end', common.mustCall(() => {
-        resolve(response);
-      }));
-    }).on('error', (err) => {
-      reject(err);
-    });
   });
 }
diff --git a/test/parallel/test-tls-sni-option.js b/test/parallel/test-tls-sni-option.js
index 375575c78ab635..72d8fe762245db 100644
--- a/test/parallel/test-tls-sni-option.js
+++ b/test/parallel/test-tls-sni-option.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -43,10 +42,8 @@ const serverOptions = {
     // Just to test asynchronous callback
     setTimeout(function() {
       if (context) {
-        if (context.emptyRegression)
-          callback(null, {});
-        else
-          callback(null, tls.createSecureContext(context));
+        if (context.emptyRegression) callback(null, {});
+        else callback(null, tls.createSecureContext(context));
       } else {
         callback(null, null);
       }
@@ -58,7 +55,7 @@ const SNIContexts = {
   'a.example.com': {
     key: loadPEM('agent1-key'),
     cert: loadPEM('agent1-cert'),
-    ca: [ loadPEM('ca2-cert') ]
+    ca: [loadPEM('ca2-cert')]
   },
   'b.example.com': {
     key: loadPEM('agent3-key'),
@@ -69,42 +66,48 @@ const SNIContexts = {
   }
 };
 
-const clientsOptions = [{
-  port: undefined,
-  key: loadPEM('agent1-key'),
-  cert: loadPEM('agent1-cert'),
-  ca: [loadPEM('ca1-cert')],
-  servername: 'a.example.com',
-  rejectUnauthorized: false
-}, {
-  port: undefined,
-  key: loadPEM('agent4-key'),
-  cert: loadPEM('agent4-cert'),
-  ca: [loadPEM('ca1-cert')],
-  servername: 'a.example.com',
-  rejectUnauthorized: false
-}, {
-  port: undefined,
-  key: loadPEM('agent2-key'),
-  cert: loadPEM('agent2-cert'),
-  ca: [loadPEM('ca2-cert')],
-  servername: 'b.example.com',
-  rejectUnauthorized: false
-}, {
-  port: undefined,
-  key: loadPEM('agent3-key'),
-  cert: loadPEM('agent3-cert'),
-  ca: [loadPEM('ca1-cert')],
-  servername: 'c.wrong.com',
-  rejectUnauthorized: false
-}, {
-  port: undefined,
-  key: loadPEM('agent3-key'),
-  cert: loadPEM('agent3-cert'),
-  ca: [loadPEM('ca1-cert')],
-  servername: 'c.another.com',
-  rejectUnauthorized: false
-}];
+const clientsOptions = [
+  {
+    port: undefined,
+    key: loadPEM('agent1-key'),
+    cert: loadPEM('agent1-cert'),
+    ca: [loadPEM('ca1-cert')],
+    servername: 'a.example.com',
+    rejectUnauthorized: false
+  },
+  {
+    port: undefined,
+    key: loadPEM('agent4-key'),
+    cert: loadPEM('agent4-cert'),
+    ca: [loadPEM('ca1-cert')],
+    servername: 'a.example.com',
+    rejectUnauthorized: false
+  },
+  {
+    port: undefined,
+    key: loadPEM('agent2-key'),
+    cert: loadPEM('agent2-cert'),
+    ca: [loadPEM('ca2-cert')],
+    servername: 'b.example.com',
+    rejectUnauthorized: false
+  },
+  {
+    port: undefined,
+    key: loadPEM('agent3-key'),
+    cert: loadPEM('agent3-cert'),
+    ca: [loadPEM('ca1-cert')],
+    servername: 'c.wrong.com',
+    rejectUnauthorized: false
+  },
+  {
+    port: undefined,
+    key: loadPEM('agent3-key'),
+    cert: loadPEM('agent3-cert'),
+    ca: [loadPEM('ca1-cert')],
+    servername: 'c.another.com',
+    rejectUnauthorized: false
+  }
+];
 
 const serverResults = [];
 const clientResults = [];
@@ -131,14 +134,18 @@ function startTest() {
     serverError = null;
 
     options.port = server.address().port;
-    const client = tls.connect(options, function() {
-      clientResults.push(
-        client.authorizationError &&
-         (client.authorizationError === 'ERR_TLS_CERT_ALTNAME_INVALID'));
-      client.destroy();
-
-      next();
-    });
+    const client = tls.connect(
+      options,
+      function() {
+        clientResults.push(
+          client.authorizationError &&
+            client.authorizationError === 'ERR_TLS_CERT_ALTNAME_INVALID'
+        );
+        client.destroy();
+
+        next();
+      }
+    );
 
     client.on('error', function(err) {
       clientResults.push(false);
@@ -150,10 +157,8 @@ function startTest() {
       clientErrors.push(clientError);
       serverErrors.push(serverError);
 
-      if (i === clientsOptions.length - 1)
-        callback();
-      else
-        connectClient(i + 1, callback);
+      if (i === clientsOptions.length - 1) callback();
+      else connectClient(i + 1, callback);
     }
   }
 
@@ -172,11 +177,18 @@ process.on('exit', function() {
   ]);
   assert.deepStrictEqual(clientResults, [true, true, true, false, false]);
   assert.deepStrictEqual(clientErrors, [
-    null, null, null, null,
+    null,
+    null,
+    null,
+    null,
     'Client network socket disconnected before secure TLS ' +
-    'connection was established'
+      'connection was established'
   ]);
   assert.deepStrictEqual(serverErrors, [
-    null, null, null, null, 'Invalid SNI context'
+    null,
+    null,
+    null,
+    null,
+    'Invalid SNI context'
   ]);
 });
diff --git a/test/parallel/test-tls-sni-server-client.js b/test/parallel/test-tls-sni-server-client.js
index 073e95988a3a08..3d55fbc1be3519 100644
--- a/test/parallel/test-tls-sni-server-client.js
+++ b/test/parallel/test-tls-sni-server-client.js
@@ -21,14 +21,12 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
-
 function loadPEM(n) {
   return fixtures.readKey(`${n}.pem`);
 }
@@ -54,32 +52,38 @@ const SNIContexts = {
   }
 };
 
-const clientsOptions = [{
-  port: undefined,
-  ca: [loadPEM('ca1-cert')],
-  servername: 'a.example.com',
-  rejectUnauthorized: false
-}, {
-  port: undefined,
-  ca: [loadPEM('ca2-cert')],
-  servername: 'b.test.com',
-  rejectUnauthorized: false
-}, {
-  port: undefined,
-  ca: [loadPEM('ca2-cert')],
-  servername: 'a.b.test.com',
-  rejectUnauthorized: false
-}, {
-  port: undefined,
-  ca: [loadPEM('ca1-cert')],
-  servername: 'c.wrong.com',
-  rejectUnauthorized: false
-}, {
-  port: undefined,
-  ca: [loadPEM('ca1-cert')],
-  servername: 'chain.example.com',
-  rejectUnauthorized: false
-}];
+const clientsOptions = [
+  {
+    port: undefined,
+    ca: [loadPEM('ca1-cert')],
+    servername: 'a.example.com',
+    rejectUnauthorized: false
+  },
+  {
+    port: undefined,
+    ca: [loadPEM('ca2-cert')],
+    servername: 'b.test.com',
+    rejectUnauthorized: false
+  },
+  {
+    port: undefined,
+    ca: [loadPEM('ca2-cert')],
+    servername: 'a.b.test.com',
+    rejectUnauthorized: false
+  },
+  {
+    port: undefined,
+    ca: [loadPEM('ca1-cert')],
+    servername: 'c.wrong.com',
+    rejectUnauthorized: false
+  },
+  {
+    port: undefined,
+    ca: [loadPEM('ca1-cert')],
+    servername: 'chain.example.com',
+    rejectUnauthorized: false
+  }
+];
 
 const serverResults = [];
 const clientResults = [];
@@ -98,20 +102,23 @@ function startTest() {
   let i = 0;
   function start() {
     // No options left
-    if (i === clientsOptions.length)
-      return server.close();
+    if (i === clientsOptions.length) return server.close();
 
     const options = clientsOptions[i++];
     options.port = server.address().port;
-    const client = tls.connect(options, function() {
-      clientResults.push(
-        client.authorizationError &&
-        (client.authorizationError === 'ERR_TLS_CERT_ALTNAME_INVALID'));
-      client.destroy();
-
-      // Continue
-      start();
-    });
+    const client = tls.connect(
+      options,
+      function() {
+        clientResults.push(
+          client.authorizationError &&
+            client.authorizationError === 'ERR_TLS_CERT_ALTNAME_INVALID'
+        );
+        client.destroy();
+
+        // Continue
+        start();
+      }
+    );
   }
 
   start();
@@ -119,7 +126,10 @@ function startTest() {
 
 process.on('exit', function() {
   assert.deepStrictEqual(serverResults, [
-    'a.example.com', 'b.test.com', 'a.b.test.com', 'c.wrong.com',
+    'a.example.com',
+    'b.test.com',
+    'a.b.test.com',
+    'c.wrong.com',
     'chain.example.com'
   ]);
   assert.deepStrictEqual(clientResults, [true, true, false, false, true]);
diff --git a/test/parallel/test-tls-snicallback-error.js b/test/parallel/test-tls-snicallback-error.js
index 1e1c82225309b4..40b53c249868b2 100644
--- a/test/parallel/test-tls-snicallback-error.js
+++ b/test/parallel/test-tls-snicallback-error.js
@@ -1,14 +1,15 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
 
 ['fhqwhgads', 42, {}, []].forEach((testValue) => {
   assert.throws(
-    () => { tls.createServer({ SNICallback: testValue }); },
+    () => {
+      tls.createServer({ SNICallback: testValue });
+    },
     { code: 'ERR_INVALID_ARG_TYPE', message: /\boptions\.SNICallback\b/ }
   );
 });
diff --git a/test/parallel/test-tls-socket-close.js b/test/parallel/test-tls-socket-close.js
index debaca213bb0e2..e3b46f428cddb9 100644
--- a/test/parallel/test-tls-socket-close.js
+++ b/test/parallel/test-tls-socket-close.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -15,23 +14,31 @@ let tlsSocket;
 // tls server
 const tlsServer = tls.createServer({ cert, key }, (socket) => {
   tlsSocket = socket;
-  socket.on('error', common.mustCall((error) => {
-    assert.strictEqual(error.code, 'EINVAL');
-    tlsServer.close();
-    netServer.close();
-  }));
+  socket.on(
+    'error',
+    common.mustCall((error) => {
+      assert.strictEqual(error.code, 'EINVAL');
+      tlsServer.close();
+      netServer.close();
+    })
+  );
 });
 
 let netSocket;
 // plain tcp server
-const netServer = net.createServer((socket) => {
-  // if client wants to use tls
-  tlsServer.emit('connection', socket);
+const netServer = net
+  .createServer((socket) => {
+    // if client wants to use tls
+    tlsServer.emit('connection', socket);
 
-  netSocket = socket;
-}).listen(0, common.mustCall(function() {
-  connectClient(netServer);
-}));
+    netSocket = socket;
+  })
+  .listen(
+    0,
+    common.mustCall(function() {
+      connectClient(netServer);
+    })
+  );
 
 function connectClient(server) {
   const tlsConnection = tls.connect({
@@ -40,28 +47,34 @@ function connectClient(server) {
     rejectUnauthorized: false
   });
 
-  tlsConnection.write('foo', 'utf8', common.mustCall(() => {
-    assert(netSocket);
-    netSocket.setTimeout(1, common.mustCall(() => {
-      assert(tlsSocket);
-      // this breaks if TLSSocket is already managing the socket:
-      netSocket.destroy();
-      const interval = setInterval(() => {
-        // Checking this way allows us to do the write at a time that causes a
-        // segmentation fault (not always, but often) in Node.js 7.7.3 and
-        // earlier. If we instead, for example, wait on the `close` event, then
-        // it will not segmentation fault, which is what this test is all about.
-        if (tlsSocket._handle._parent.bytesRead === 0) {
-          tlsSocket.write('bar');
-          clearInterval(interval);
-        }
-      }, 1);
-    }));
-  }));
+  tlsConnection.write(
+    'foo',
+    'utf8',
+    common.mustCall(() => {
+      assert(netSocket);
+      netSocket.setTimeout(
+        1,
+        common.mustCall(() => {
+          assert(tlsSocket);
+          // this breaks if TLSSocket is already managing the socket:
+          netSocket.destroy();
+          const interval = setInterval(() => {
+            // Checking this way allows us to do the write at a time that causes a
+            // segmentation fault (not always, but often) in Node.js 7.7.3 and
+            // earlier. If we instead, for example, wait on the `close` event, then
+            // it will not segmentation fault, which is what this test is all about.
+            if (tlsSocket._handle._parent.bytesRead === 0) {
+              tlsSocket.write('bar');
+              clearInterval(interval);
+            }
+          }, 1);
+        })
+      );
+    })
+  );
   tlsConnection.on('error', (e) => {
     // Tolerate the occasional ECONNRESET.
     // Ref: https://github.com/nodejs/node/issues/13184
-    if (e.code !== 'ECONNRESET')
-      throw e;
+    if (e.code !== 'ECONNRESET') throw e;
   });
 }
diff --git a/test/parallel/test-tls-socket-constructor-alpn-options-parsing.js b/test/parallel/test-tls-socket-constructor-alpn-options-parsing.js
index 6b0a23f31b6eeb..2dda4007d05e82 100644
--- a/test/parallel/test-tls-socket-constructor-alpn-options-parsing.js
+++ b/test/parallel/test-tls-socket-constructor-alpn-options-parsing.js
@@ -4,13 +4,12 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
 new tls.TLSSocket(null, {
-  ALPNProtocols: ['http/1.1'],
+  ALPNProtocols: ['http/1.1']
 });
 
 const assert = require('assert');
@@ -22,37 +21,46 @@ const cert = fixtures.readKey('agent1-cert.pem');
 
 const protocols = [];
 
-const server = net.createServer(common.mustCall((s) => {
-  const tlsSocket = new tls.TLSSocket(s, {
-    isServer: true,
-    server,
-    key,
-    cert,
-    ALPNProtocols: ['http/1.1'],
-  });
-
-  tlsSocket.on('secure', common.mustCall(() => {
-    protocols.push({
-      alpnProtocol: tlsSocket.alpnProtocol,
+const server = net.createServer(
+  common.mustCall((s) => {
+    const tlsSocket = new tls.TLSSocket(s, {
+      isServer: true,
+      server,
+      key,
+      cert,
+      ALPNProtocols: ['http/1.1']
     });
-    tlsSocket.end();
-  }));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const alpnOpts = {
-    port: server.address().port,
-    rejectUnauthorized: false,
-    ALPNProtocols: ['h2', 'http/1.1']
-  };
-
-  tls.connect(alpnOpts, function() {
-    this.end();
-
-    server.close();
-
-    assert.deepStrictEqual(protocols, [
-      { alpnProtocol: 'http/1.1' },
-    ]);
-  });
-}));
+
+    tlsSocket.on(
+      'secure',
+      common.mustCall(() => {
+        protocols.push({
+          alpnProtocol: tlsSocket.alpnProtocol
+        });
+        tlsSocket.end();
+      })
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const alpnOpts = {
+      port: server.address().port,
+      rejectUnauthorized: false,
+      ALPNProtocols: ['h2', 'http/1.1']
+    };
+
+    tls.connect(
+      alpnOpts,
+      function() {
+        this.end();
+
+        server.close();
+
+        assert.deepStrictEqual(protocols, [{ alpnProtocol: 'http/1.1' }]);
+      }
+    );
+  })
+);
diff --git a/test/parallel/test-tls-socket-default-options.js b/test/parallel/test-tls-socket-default-options.js
index f086377b0faa20..2b1d3e8a11458e 100644
--- a/test/parallel/test-tls-socket-default-options.js
+++ b/test/parallel/test-tls-socket-default-options.js
@@ -5,9 +5,7 @@ const fixtures = require('../common/fixtures');
 // Test directly created TLS sockets and options.
 
 const assert = require('assert');
-const {
-  connect, keys, tls
-} = require(fixtures.path('tls-connect'));
+const { connect, keys, tls } = require(fixtures.path('tls-connect'));
 
 test(undefined, (err) => {
   assert.strictEqual(err.message, 'unable to verify the first certificate');
@@ -19,49 +17,68 @@ test({}, (err) => {
 
 test(
   { secureContext: tls.createSecureContext({ ca: keys.agent1.ca }) },
-  (err) => { assert.ifError(err); });
+  (err) => {
+    assert.ifError(err);
+  }
+);
 
-test(
-  { ca: keys.agent1.ca },
-  (err) => { assert.ifError(err); });
+test({ ca: keys.agent1.ca }, (err) => {
+  assert.ifError(err);
+});
 
 // Secure context options, like ca, are ignored if a sec ctx is explicitly
 // provided.
 test(
   { secureContext: tls.createSecureContext(), ca: keys.agent1.ca },
   (err) => {
-    assert.strictEqual(err.message,
-                       'unable to verify the first certificate');
-  });
+    assert.strictEqual(err.message, 'unable to verify the first certificate');
+  }
+);
 
 function test(client, callback) {
   callback = common.mustCall(callback);
-  connect({
-    server: {
-      key: keys.agent1.key,
-      cert: keys.agent1.cert,
+  connect(
+    {
+      server: {
+        key: keys.agent1.key,
+        cert: keys.agent1.cert
+      }
     },
-  }, function(err, pair, cleanup) {
-    assert.strictEqual(err.message, 'unable to verify the first certificate');
-    let recv = '';
-    pair.server.server.once('secureConnection', common.mustCall((conn) => {
-      conn.on('data', (data) => recv += data);
-      conn.on('end', common.mustCall(() => {
-        // Server sees nothing wrong with connection, even though the client's
-        // authentication of the server cert failed.
-        assert.strictEqual(recv, 'hello');
-        cleanup();
-      }));
-    }));
+    function(err, pair, cleanup) {
+      assert.strictEqual(err.message, 'unable to verify the first certificate');
+      let recv = '';
+      pair.server.server.once(
+        'secureConnection',
+        common.mustCall((conn) => {
+          conn.on('data', (data) => (recv += data));
+          conn.on(
+            'end',
+            common.mustCall(() => {
+              // Server sees nothing wrong with connection, even though the client's
+              // authentication of the server cert failed.
+              assert.strictEqual(recv, 'hello');
+              cleanup();
+            })
+          );
+        })
+      );
 
-    // Client doesn't support the 'secureConnect' event, and doesn't error if
-    // authentication failed. Caller must explicitly check for failure.
-    (new tls.TLSSocket(null, client)).connect(pair.server.server.address().port)
-      .on('connect', common.mustCall(function() {
-        this.end('hello');
-      }))
-      .on('secure', common.mustCall(function() {
-        callback(this.ssl.verifyError());
-      }));
-  });
+      // Client doesn't support the 'secureConnect' event, and doesn't error if
+      // authentication failed. Caller must explicitly check for failure.
+      new tls.TLSSocket(null, client)
+        .connect(pair.server.server.address().port)
+        .on(
+          'connect',
+          common.mustCall(function() {
+            this.end('hello');
+          })
+        )
+        .on(
+          'secure',
+          common.mustCall(function() {
+            callback(this.ssl.verifyError());
+          })
+        );
+    }
+  );
 }
diff --git a/test/parallel/test-tls-socket-destroy.js b/test/parallel/test-tls-socket-destroy.js
index 6f1d4b4186b74f..5168c16d75774c 100644
--- a/test/parallel/test-tls-socket-destroy.js
+++ b/test/parallel/test-tls-socket-destroy.js
@@ -2,8 +2,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const net = require('net');
 const tls = require('tls');
@@ -14,23 +13,31 @@ const cert = fixtures.readKey('agent1-cert.pem');
 
 const secureContext = tls.createSecureContext({ key, cert });
 
-const server = net.createServer(common.mustCall((conn) => {
-  const options = { isServer: true, secureContext, server };
-  const socket = new tls.TLSSocket(conn, options);
-  socket.once('data', common.mustCall(() => {
-    socket._destroySSL();  // Should not crash.
-    socket.destroy();
-    server.close();
-  }));
-}));
+const server = net.createServer(
+  common.mustCall((conn) => {
+    const options = { isServer: true, secureContext, server };
+    const socket = new tls.TLSSocket(conn, options);
+    socket.once(
+      'data',
+      common.mustCall(() => {
+        socket._destroySSL(); // Should not crash.
+        socket.destroy();
+        server.close();
+      })
+    );
+  })
+);
 
 server.listen(0, function() {
   const options = {
     port: this.address().port,
-    rejectUnauthorized: false,
+    rejectUnauthorized: false
   };
-  tls.connect(options, function() {
-    this.write('*'.repeat(1 << 20));  // Write more data than fits in a frame.
-    this.on('error', this.destroy);  // Server closes connection on us.
-  });
+  tls.connect(
+    options,
+    function() {
+      this.write('*'.repeat(1 << 20)); // Write more data than fits in a frame.
+      this.on('error', this.destroy); // Server closes connection on us.
+    }
+  );
 });
diff --git a/test/parallel/test-tls-socket-failed-handshake-emits-error.js b/test/parallel/test-tls-socket-failed-handshake-emits-error.js
index d67a5498d65195..6367f091d214ef 100644
--- a/test/parallel/test-tls-socket-failed-handshake-emits-error.js
+++ b/test/parallel/test-tls-socket-failed-handshake-emits-error.js
@@ -1,8 +1,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const net = require('net');
@@ -10,30 +9,42 @@ const assert = require('assert');
 
 const bonkers = Buffer.alloc(1024, 42);
 
-const server = net.createServer(function(c) {
-  setTimeout(function() {
-    const s = new tls.TLSSocket(c, {
-      isServer: true,
-      server: server
-    });
+const server = net
+  .createServer(function(c) {
+    setTimeout(function() {
+      const s = new tls.TLSSocket(c, {
+        isServer: true,
+        server: server
+      });
 
-    s.on('error', common.mustCall(function(e) {
-      assert.ok(e instanceof Error,
-                'Instance of Error should be passed to error handler');
-      // OpenSSL 1.0.x and 1.1.x use different error codes for junk inputs.
-      assert.ok(
-        /SSL routines:[^:]*:(unknown protocol|wrong version number)/.test(
-          e.message),
-        'Expecting SSL unknown protocol');
-    }));
+      s.on(
+        'error',
+        common.mustCall(function(e) {
+          assert.ok(
+            e instanceof Error,
+            'Instance of Error should be passed to error handler'
+          );
+          // OpenSSL 1.0.x and 1.1.x use different error codes for junk inputs.
+          assert.ok(
+            /SSL routines:[^:]*:(unknown protocol|wrong version number)/.test(
+              e.message
+            ),
+            'Expecting SSL unknown protocol'
+          );
+        })
+      );
 
-    s.on('close', function() {
-      server.close();
-      s.destroy();
-    });
-  }, common.platformTimeout(200));
-}).listen(0, function() {
-  const c = net.connect({ port: this.address().port }, function() {
-    c.write(bonkers);
+      s.on('close', function() {
+        server.close();
+        s.destroy();
+      });
+    }, common.platformTimeout(200));
+  })
+  .listen(0, function() {
+    const c = net.connect(
+      { port: this.address().port },
+      function() {
+        c.write(bonkers);
+      }
+    );
   });
-});
diff --git a/test/parallel/test-tls-socket-snicallback-without-server.js b/test/parallel/test-tls-socket-snicallback-without-server.js
index 9d30bc17b96b65..13c49a295e63b6 100644
--- a/test/parallel/test-tls-socket-snicallback-without-server.js
+++ b/test/parallel/test-tls-socket-snicallback-without-server.js
@@ -4,8 +4,7 @@
 // for the deprecated `tls.createSecurePair()` variant.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
diff --git a/test/parallel/test-tls-startcom-wosign-whitelist.js b/test/parallel/test-tls-startcom-wosign-whitelist.js
index 33da14884836bf..c3fac24576aca7 100644
--- a/test/parallel/test-tls-startcom-wosign-whitelist.js
+++ b/test/parallel/test-tls-startcom-wosign-whitelist.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -14,7 +13,8 @@ function loadPEM(n) {
 }
 
 const testCases = [
-  { // agent8 is signed by fake-startcom-root with notBefore of
+  {
+    // agent8 is signed by fake-startcom-root with notBefore of
     // Oct 20 23:59:59 2016 GMT. It passes StartCom/WoSign check.
     serverOpts: {
       key: loadPEM('agent8-key'),
@@ -27,7 +27,8 @@ const testCases = [
     },
     errorCode: 'CERT_REVOKED'
   },
-  { // agent9 is signed by fake-startcom-root with notBefore of
+  {
+    // agent9 is signed by fake-startcom-root with notBefore of
     // Oct 21 00:00:01 2016 GMT. It fails StartCom/WoSign check.
     serverOpts: {
       key: loadPEM('agent9-key'),
@@ -42,7 +43,6 @@ const testCases = [
   }
 ];
 
-
 function runNextTest(server, tindex) {
   server.close(function() {
     finished++;
@@ -50,33 +50,33 @@ function runNextTest(server, tindex) {
   });
 }
 
-
 function runTest(tindex) {
   const tcase = testCases[tindex];
 
   if (!tcase) return;
 
-  const server = tls.createServer(tcase.serverOpts, function(s) {
-    s.resume();
-  }).listen(0, function() {
-    tcase.clientOpts.port = this.address().port;
-    const client = tls.connect(tcase.clientOpts);
-    client.on('error', function(e) {
-      assert.strictEqual(e.code, tcase.errorCode);
-      runNextTest(server, tindex);
-    });
+  const server = tls
+    .createServer(tcase.serverOpts, function(s) {
+      s.resume();
+    })
+    .listen(0, function() {
+      tcase.clientOpts.port = this.address().port;
+      const client = tls.connect(tcase.clientOpts);
+      client.on('error', function(e) {
+        assert.strictEqual(e.code, tcase.errorCode);
+        runNextTest(server, tindex);
+      });
 
-    client.on('secureConnect', function() {
-      // agent8 can pass StartCom/WoSign check so that the secureConnect
-      // is established.
-      assert.strictEqual(tcase.errorCode, 'CERT_REVOKED');
-      client.end();
-      runNextTest(server, tindex);
+      client.on('secureConnect', function() {
+        // agent8 can pass StartCom/WoSign check so that the secureConnect
+        // is established.
+        assert.strictEqual(tcase.errorCode, 'CERT_REVOKED');
+        client.end();
+        runNextTest(server, tindex);
+      });
     });
-  });
 }
 
-
 runTest(0);
 
 process.on('exit', function() {
diff --git a/test/parallel/test-tls-starttls-server.js b/test/parallel/test-tls-starttls-server.js
index d9a1c02fc87c0f..37f2b78081cbbb 100644
--- a/test/parallel/test-tls-starttls-server.js
+++ b/test/parallel/test-tls-starttls-server.js
@@ -5,8 +5,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const net = require('net');
@@ -16,33 +15,43 @@ const fixtures = require('../common/fixtures');
 const key = fixtures.readKey('agent1-key.pem');
 const cert = fixtures.readKey('agent1-cert.pem');
 
-const server = net.createServer(common.mustCall((s) => {
-  const tlsSocket = new tls.TLSSocket(s, {
-    isServer: true,
-    server: server,
-
-    secureContext: tls.createSecureContext({ key, cert }),
-
-    SNICallback: common.mustCall((hostname, callback) => {
-      assert.strictEqual(hostname, 'test.test');
-
-      callback(null, null);
+const server = net
+  .createServer(
+    common.mustCall((s) => {
+      const tlsSocket = new tls.TLSSocket(s, {
+        isServer: true,
+        server: server,
+
+        secureContext: tls.createSecureContext({ key, cert }),
+
+        SNICallback: common.mustCall((hostname, callback) => {
+          assert.strictEqual(hostname, 'test.test');
+
+          callback(null, null);
+        })
+      });
+
+      tlsSocket.on(
+        'secure',
+        common.mustCall(() => {
+          tlsSocket.end();
+          server.close();
+        })
+      );
     })
+  )
+  .listen(0, () => {
+    const opts = {
+      servername: 'test.test',
+      port: server.address().port,
+      rejectUnauthorized: false,
+      requestOCSP: true
+    };
+
+    tls.connect(
+      opts,
+      function() {
+        this.end();
+      }
+    );
   });
-
-  tlsSocket.on('secure', common.mustCall(() => {
-    tlsSocket.end();
-    server.close();
-  }));
-})).listen(0, () => {
-  const opts = {
-    servername: 'test.test',
-    port: server.address().port,
-    rejectUnauthorized: false,
-    requestOCSP: true
-  };
-
-  tls.connect(opts, function() {
-    this.end();
-  });
-});
diff --git a/test/parallel/test-tls-streamwrap-buffersize.js b/test/parallel/test-tls-streamwrap-buffersize.js
index f65a3d6e76b9d8..28255ef7e6eb9b 100644
--- a/test/parallel/test-tls-streamwrap-buffersize.js
+++ b/test/parallel/test-tls-streamwrap-buffersize.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const makeDuplexPair = require('../common/duplexpair');
@@ -18,55 +17,75 @@ const net = require('net');
     const { clientSide, serverSide } = makeDuplexPair();
 
     return new Promise((resolve, reject) => {
-      const socket = net.connect({
-        port,
-      }, common.mustCall(() => {
-        clientSide.pipe(socket);
-        socket.pipe(clientSide);
-        clientSide.on('close', common.mustCall(() => socket.destroy()));
-        socket.on('close', common.mustCall(() => clientSide.destroy()));
+      const socket = net.connect(
+        {
+          port
+        },
+        common.mustCall(() => {
+          clientSide.pipe(socket);
+          socket.pipe(clientSide);
+          clientSide.on('close', common.mustCall(() => socket.destroy()));
+          socket.on('close', common.mustCall(() => clientSide.destroy()));
 
-        resolve(serverSide);
-      }));
+          resolve(serverSide);
+        })
+      );
     });
   }
 
-  const server = tls.createServer({
-    key: fixtures.readKey('agent2-key.pem'),
-    cert: fixtures.readKey('agent2-cert.pem')
-  }, common.mustCall((socket) => {
-    let str = '';
-    socket.setEncoding('utf-8');
-    socket.on('data', (chunk) => { str += chunk; });
+  const server = tls.createServer(
+    {
+      key: fixtures.readKey('agent2-key.pem'),
+      cert: fixtures.readKey('agent2-cert.pem')
+    },
+    common.mustCall((socket) => {
+      let str = '';
+      socket.setEncoding('utf-8');
+      socket.on('data', (chunk) => {
+        str += chunk;
+      });
 
-    socket.on('end', common.mustCall(() => {
-      assert.strictEqual(str, 'a'.repeat(iter - 1));
-      server.close();
-    }));
-  }));
+      socket.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(str, 'a'.repeat(iter - 1));
+          server.close();
+        })
+      );
+    })
+  );
 
-  server.listen(0, common.mustCall(() => {
-    const { port } = server.address();
-    createDuplex(port).then((socket) => {
-      const client = tls.connect({
-        socket,
-        rejectUnauthorized: false,
-      }, common.mustCall(() => {
-        assert.strictEqual(client.bufferSize, 0);
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const { port } = server.address();
+      createDuplex(port).then((socket) => {
+        const client = tls.connect(
+          {
+            socket,
+            rejectUnauthorized: false
+          },
+          common.mustCall(() => {
+            assert.strictEqual(client.bufferSize, 0);
 
-        for (let i = 1; i < iter; i++) {
-          client.write('a');
-          assert.strictEqual(client.bufferSize, i + 1);
-        }
+            for (let i = 1; i < iter; i++) {
+              client.write('a');
+              assert.strictEqual(client.bufferSize, i + 1);
+            }
 
-        // It seems that tlsSockets created from sockets of `Duplex` emit no
-        // "finish" events. We use "end" event instead.
-        client.on('end', common.mustCall(() => {
-          assert.strictEqual(client.bufferSize, undefined);
-        }));
+            // It seems that tlsSockets created from sockets of `Duplex` emit no
+            // "finish" events. We use "end" event instead.
+            client.on(
+              'end',
+              common.mustCall(() => {
+                assert.strictEqual(client.bufferSize, undefined);
+              })
+            );
 
-        client.end();
-      }));
-    });
-  }));
+            client.end();
+          })
+        );
+      });
+    })
+  );
 }
diff --git a/test/parallel/test-tls-ticket-cluster.js b/test/parallel/test-tls-ticket-cluster.js
index a139cccad34075..9761c02321f359 100644
--- a/test/parallel/test-tls-ticket-cluster.js
+++ b/test/parallel/test-tls-ticket-cluster.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -41,21 +40,25 @@ if (cluster.isMaster) {
 
   function shoot() {
     console.error('[master] connecting', workerPort);
-    const c = tls.connect(workerPort, {
-      session: lastSession,
-      rejectUnauthorized: false
-    }, function() {
-      lastSession = c.getSession();
-      c.end();
-
-      if (++reqCount === expectedReqCount) {
-        Object.keys(cluster.workers).forEach(function(id) {
-          cluster.workers[id].send('die');
-        });
-      } else {
-        shoot();
+    const c = tls.connect(
+      workerPort,
+      {
+        session: lastSession,
+        rejectUnauthorized: false
+      },
+      function() {
+        lastSession = c.getSession();
+        c.end();
+
+        if (++reqCount === expectedReqCount) {
+          Object.keys(cluster.workers).forEach(function(id) {
+            cluster.workers[id].send('die');
+          });
+        } else {
+          shoot();
+        }
       }
-    });
+    );
   }
 
   function fork() {
@@ -104,7 +107,7 @@ server.listen(0, function() {
   const { port } = server.address();
   process.send({
     msg: 'listening',
-    port,
+    port
   });
 });
 
diff --git a/test/parallel/test-tls-ticket.js b/test/parallel/test-tls-ticket.js
index 187dd22cee6b76..aca7b9b047e406 100644
--- a/test/parallel/test-tls-ticket.js
+++ b/test/parallel/test-tls-ticket.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -41,63 +40,70 @@ function createServer() {
   let counter = 0;
   let previousKey = null;
 
-  const server = tls.createServer({
-    key: fixtures.readKey('agent1-key.pem'),
-    cert: fixtures.readKey('agent1-cert.pem'),
-    ticketKeys: keys
-  }, function(c) {
-    serverLog.push(id);
-    c.end();
-
-    counter++;
-
-    // Rotate ticket keys
-    if (counter === 1) {
-      previousKey = server.getTicketKeys();
-      server.setTicketKeys(crypto.randomBytes(48));
-    } else if (counter === 2) {
-      server.setTicketKeys(previousKey);
-    } else if (counter === 3) {
-      // Use keys from counter=2
-    } else {
-      throw new Error('UNREACHABLE');
+  const server = tls.createServer(
+    {
+      key: fixtures.readKey('agent1-key.pem'),
+      cert: fixtures.readKey('agent1-cert.pem'),
+      ticketKeys: keys
+    },
+    function(c) {
+      serverLog.push(id);
+      c.end();
+
+      counter++;
+
+      // Rotate ticket keys
+      if (counter === 1) {
+        previousKey = server.getTicketKeys();
+        server.setTicketKeys(crypto.randomBytes(48));
+      } else if (counter === 2) {
+        server.setTicketKeys(previousKey);
+      } else if (counter === 3) {
+        // Use keys from counter=2
+      } else {
+        throw new Error('UNREACHABLE');
+      }
     }
-  });
+  );
 
   return server;
 }
 
-const naturalServers = [ createServer(), createServer(), createServer() ];
+const naturalServers = [createServer(), createServer(), createServer()];
 
 // 3x servers
 const servers = naturalServers.concat(naturalServers).concat(naturalServers);
 
 // Create one TCP server and balance sockets to multiple TLS server instances
-const shared = net.createServer(function(c) {
-  servers.shift().emit('connection', c);
-}).listen(0, function() {
-  start(function() {
-    shared.close();
+const shared = net
+  .createServer(function(c) {
+    servers.shift().emit('connection', c);
+  })
+  .listen(0, function() {
+    start(function() {
+      shared.close();
+    });
   });
-});
 
 function start(callback) {
   let sess = null;
   let left = servers.length;
 
   function connect() {
-    const s = tls.connect(shared.address().port, {
-      session: sess,
-      rejectUnauthorized: false
-    }, function() {
-      sess = sess || s.getSession();
-      ticketLog.push(s.getTLSTicket().toString('hex'));
-    });
+    const s = tls.connect(
+      shared.address().port,
+      {
+        session: sess,
+        rejectUnauthorized: false
+      },
+      function() {
+        sess = sess || s.getSession();
+        ticketLog.push(s.getTLSTicket().toString('hex'));
+      }
+    );
     s.on('close', function() {
-      if (--left === 0)
-        callback();
-      else
-        connect();
+      if (--left === 0) callback();
+      else connect();
     });
   }
 
diff --git a/test/parallel/test-tls-timeout-server-2.js b/test/parallel/test-tls-timeout-server-2.js
index d2ffaf799008ff..9d7fcba85dc59a 100644
--- a/test/parallel/test-tls-timeout-server-2.js
+++ b/test/parallel/test-tls-timeout-server-2.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -33,18 +32,24 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = tls.createServer(options, common.mustCall(function(cleartext) {
-  const s = cleartext.setTimeout(50, function() {
-    cleartext.destroy();
-    server.close();
-  });
-  assert.ok(s instanceof tls.TLSSocket);
-}));
+const server = tls.createServer(
+  options,
+  common.mustCall(function(cleartext) {
+    const s = cleartext.setTimeout(50, function() {
+      cleartext.destroy();
+      server.close();
+    });
+    assert.ok(s instanceof tls.TLSSocket);
+  })
+);
 
-server.listen(0, common.mustCall(function() {
-  tls.connect({
-    host: '127.0.0.1',
-    port: this.address().port,
-    rejectUnauthorized: false
-  });
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    tls.connect({
+      host: '127.0.0.1',
+      port: this.address().port,
+      rejectUnauthorized: false
+    });
+  })
+);
diff --git a/test/parallel/test-tls-timeout-server.js b/test/parallel/test-tls-timeout-server.js
index 7ca85f14d7ae33..ff766adb8a77a3 100644
--- a/test/parallel/test-tls-timeout-server.js
+++ b/test/parallel/test-tls-timeout-server.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const net = require('net');
@@ -37,11 +36,17 @@ const options = {
 
 const server = tls.createServer(options, common.mustNotCall());
 
-server.on('tlsClientError', common.mustCall(function(err, conn) {
-  conn.destroy();
-  server.close();
-}));
+server.on(
+  'tlsClientError',
+  common.mustCall(function(err, conn) {
+    conn.destroy();
+    server.close();
+  })
+);
 
-server.listen(0, common.mustCall(function() {
-  net.connect({ host: '127.0.0.1', port: this.address().port });
-}));
+server.listen(
+  0,
+  common.mustCall(function() {
+    net.connect({ host: '127.0.0.1', port: this.address().port });
+  })
+);
diff --git a/test/parallel/test-tls-tlswrap-segfault.js b/test/parallel/test-tls-tlswrap-segfault.js
index a36016efa48a02..cbafd093a3020a 100644
--- a/test/parallel/test-tls-tlswrap-segfault.js
+++ b/test/parallel/test-tls-tlswrap-segfault.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 
 // This test ensures that Node.js doesn't incur a segfault while accessing
@@ -16,18 +15,23 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = tls.createServer(options, function(s) {
-  s.end('hello');
-}).listen(0, function() {
-  const opts = {
-    port: this.address().port,
-    rejectUnauthorized: false
-  };
-  const client = tls.connect(opts, function() {
-    putImmediate(client);
+const server = tls
+  .createServer(options, function(s) {
+    s.end('hello');
+  })
+  .listen(0, function() {
+    const opts = {
+      port: this.address().port,
+      rejectUnauthorized: false
+    };
+    const client = tls.connect(
+      opts,
+      function() {
+        putImmediate(client);
+      }
+    );
+    client.resume();
   });
-  client.resume();
-});
 
 function putImmediate(client) {
   setImmediate(function() {
diff --git a/test/parallel/test-tls-translate-peer-certificate.js b/test/parallel/test-tls-translate-peer-certificate.js
index f8499e0c7e84ff..66823dd0fc56eb 100644
--- a/test/parallel/test-tls-translate-peer-certificate.js
+++ b/test/parallel/test-tls-translate-peer-certificate.js
@@ -2,8 +2,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const { strictEqual, deepStrictEqual } = require('assert');
 const { translatePeerCertificate } = require('_tls_common');
@@ -23,27 +22,32 @@ strictEqual(translatePeerCertificate(1), 1);
 
 deepStrictEqual(translatePeerCertificate({}), {});
 
-deepStrictEqual(translatePeerCertificate({ issuer: '' }),
-                { issuer: Object.create(null) });
-deepStrictEqual(translatePeerCertificate({ issuer: null }),
-                { issuer: null });
-deepStrictEqual(translatePeerCertificate({ issuer: certString }),
-                { issuer: certObject });
+deepStrictEqual(translatePeerCertificate({ issuer: '' }), {
+  issuer: Object.create(null)
+});
+deepStrictEqual(translatePeerCertificate({ issuer: null }), { issuer: null });
+deepStrictEqual(translatePeerCertificate({ issuer: certString }), {
+  issuer: certObject
+});
 
-deepStrictEqual(translatePeerCertificate({ subject: '' }),
-                { subject: Object.create(null) });
-deepStrictEqual(translatePeerCertificate({ subject: null }),
-                { subject: null });
-deepStrictEqual(translatePeerCertificate({ subject: certString }),
-                { subject: certObject });
+deepStrictEqual(translatePeerCertificate({ subject: '' }), {
+  subject: Object.create(null)
+});
+deepStrictEqual(translatePeerCertificate({ subject: null }), { subject: null });
+deepStrictEqual(translatePeerCertificate({ subject: certString }), {
+  subject: certObject
+});
 
-deepStrictEqual(translatePeerCertificate({ issuerCertificate: '' }),
-                { issuerCertificate: null });
-deepStrictEqual(translatePeerCertificate({ issuerCertificate: null }),
-                { issuerCertificate: null });
+deepStrictEqual(translatePeerCertificate({ issuerCertificate: '' }), {
+  issuerCertificate: null
+});
+deepStrictEqual(translatePeerCertificate({ issuerCertificate: null }), {
+  issuerCertificate: null
+});
 deepStrictEqual(
   translatePeerCertificate({ issuerCertificate: { subject: certString } }),
-  { issuerCertificate: { subject: certObject } });
+  { issuerCertificate: { subject: certObject } }
+);
 
 {
   const cert = {};
@@ -51,19 +55,22 @@ deepStrictEqual(
   deepStrictEqual(translatePeerCertificate(cert), { issuerCertificate: cert });
 }
 
-deepStrictEqual(translatePeerCertificate({ infoAccess: '' }),
-                { infoAccess: Object.create(null) });
-deepStrictEqual(translatePeerCertificate({ infoAccess: null }),
-                { infoAccess: null });
+deepStrictEqual(translatePeerCertificate({ infoAccess: '' }), {
+  infoAccess: Object.create(null)
+});
+deepStrictEqual(translatePeerCertificate({ infoAccess: null }), {
+  infoAccess: null
+});
 {
   const input =
-      '__proto__:mostly harmless\n' +
-      'hasOwnProperty:not a function\n' +
-      'OCSP - URI:file:///etc/passwd\n';
+    '__proto__:mostly harmless\n' +
+    'hasOwnProperty:not a function\n' +
+    'OCSP - URI:file:///etc/passwd\n';
   const expected = Object.create(null);
   expected.__proto__ = ['mostly harmless'];
   expected.hasOwnProperty = ['not a function'];
   expected['OCSP - URI'] = ['file:///etc/passwd'];
-  deepStrictEqual(translatePeerCertificate({ infoAccess: input }),
-                  { infoAccess: expected });
+  deepStrictEqual(translatePeerCertificate({ infoAccess: input }), {
+    infoAccess: expected
+  });
 }
diff --git a/test/parallel/test-tls-transport-destroy-after-own-gc.js b/test/parallel/test-tls-transport-destroy-after-own-gc.js
index 46f630982af643..c1fc01fab1fd3f 100644
--- a/test/parallel/test-tls-transport-destroy-after-own-gc.js
+++ b/test/parallel/test-tls-transport-destroy-after-own-gc.js
@@ -6,8 +6,7 @@
 // a similar tool.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const { TLSSocket } = require('tls');
 const makeDuplexPair = require('../common/duplexpair');
diff --git a/test/parallel/test-tls-wrap-econnreset-localaddress.js b/test/parallel/test-tls-wrap-econnreset-localaddress.js
index 9df145ac374ab7..160cb204f2b153 100644
--- a/test/parallel/test-tls-wrap-econnreset-localaddress.js
+++ b/test/parallel/test-tls-wrap-econnreset-localaddress.js
@@ -1,28 +1,38 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const net = require('net');
 const tls = require('tls');
 
-const server = net.createServer((c) => {
-  c.end();
-}).listen(common.mustCall(() => {
-  const port = server.address().port;
+const server = net
+  .createServer((c) => {
+    c.end();
+  })
+  .listen(
+    common.mustCall(() => {
+      const port = server.address().port;
 
-  tls.connect({
-    port: port,
-    localAddress: common.localhostIPv4
-  }, common.localhostIPv4)
-    .once('error', common.mustCall((e) => {
-      assert.strictEqual(e.code, 'ECONNRESET');
-      assert.strictEqual(e.path, undefined);
-      assert.strictEqual(e.host, undefined);
-      assert.strictEqual(e.port, port);
-      assert.strictEqual(e.localAddress, common.localhostIPv4);
-      server.close();
-    }));
-}));
+      tls
+        .connect(
+          {
+            port: port,
+            localAddress: common.localhostIPv4
+          },
+          common.localhostIPv4
+        )
+        .once(
+          'error',
+          common.mustCall((e) => {
+            assert.strictEqual(e.code, 'ECONNRESET');
+            assert.strictEqual(e.path, undefined);
+            assert.strictEqual(e.host, undefined);
+            assert.strictEqual(e.port, port);
+            assert.strictEqual(e.localAddress, common.localhostIPv4);
+            server.close();
+          })
+        );
+    })
+  );
diff --git a/test/parallel/test-tls-wrap-econnreset-pipe.js b/test/parallel/test-tls-wrap-econnreset-pipe.js
index b400e35d412392..d0ec0aa9a2b993 100644
--- a/test/parallel/test-tls-wrap-econnreset-pipe.js
+++ b/test/parallel/test-tls-wrap-econnreset-pipe.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -11,16 +10,23 @@ const net = require('net');
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-const server = net.createServer((c) => {
-  c.end();
-}).listen(common.PIPE, common.mustCall(() => {
-  tls.connect({ path: common.PIPE })
-    .once('error', common.mustCall((e) => {
-      assert.strictEqual(e.code, 'ECONNRESET');
-      assert.strictEqual(e.path, common.PIPE);
-      assert.strictEqual(e.port, undefined);
-      assert.strictEqual(e.host, undefined);
-      assert.strictEqual(e.localAddress, undefined);
-      server.close();
-    }));
-}));
+const server = net
+  .createServer((c) => {
+    c.end();
+  })
+  .listen(
+    common.PIPE,
+    common.mustCall(() => {
+      tls.connect({ path: common.PIPE }).once(
+        'error',
+        common.mustCall((e) => {
+          assert.strictEqual(e.code, 'ECONNRESET');
+          assert.strictEqual(e.path, common.PIPE);
+          assert.strictEqual(e.port, undefined);
+          assert.strictEqual(e.host, undefined);
+          assert.strictEqual(e.localAddress, undefined);
+          server.close();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-wrap-econnreset-socket.js b/test/parallel/test-tls-wrap-econnreset-socket.js
index 672da9876fd005..8457fd94b0eeaf 100644
--- a/test/parallel/test-tls-wrap-econnreset-socket.js
+++ b/test/parallel/test-tls-wrap-econnreset-socket.js
@@ -1,29 +1,34 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const net = require('net');
 const tls = require('tls');
 
-const server = net.createServer((c) => {
-  c.end();
-}).listen(common.mustCall(() => {
-  const port = server.address().port;
+const server = net
+  .createServer((c) => {
+    c.end();
+  })
+  .listen(
+    common.mustCall(() => {
+      const port = server.address().port;
 
-  const socket = new net.Socket();
+      const socket = new net.Socket();
 
-  tls.connect({ socket })
-    .once('error', common.mustCall((e) => {
-      assert.strictEqual(e.code, 'ECONNRESET');
-      assert.strictEqual(e.path, undefined);
-      assert.strictEqual(e.host, undefined);
-      assert.strictEqual(e.port, undefined);
-      assert.strictEqual(e.localAddress, undefined);
-      server.close();
-    }));
+      tls.connect({ socket }).once(
+        'error',
+        common.mustCall((e) => {
+          assert.strictEqual(e.code, 'ECONNRESET');
+          assert.strictEqual(e.path, undefined);
+          assert.strictEqual(e.host, undefined);
+          assert.strictEqual(e.port, undefined);
+          assert.strictEqual(e.localAddress, undefined);
+          server.close();
+        })
+      );
 
-  socket.connect(port);
-}));
+      socket.connect(port);
+    })
+  );
diff --git a/test/parallel/test-tls-wrap-econnreset.js b/test/parallel/test-tls-wrap-econnreset.js
index 5c6db86b75e06a..ae3e45a8867f69 100644
--- a/test/parallel/test-tls-wrap-econnreset.js
+++ b/test/parallel/test-tls-wrap-econnreset.js
@@ -1,25 +1,35 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const net = require('net');
 const tls = require('tls');
 
-const server = net.createServer((c) => {
-  c.end();
-}).listen(common.mustCall(() => {
-  const port = server.address().port;
+const server = net
+  .createServer((c) => {
+    c.end();
+  })
+  .listen(
+    common.mustCall(() => {
+      const port = server.address().port;
 
-  tls.connect(port, common.localhostIPv4)
-    .once('error', common.mustCall((e) => {
-      assert.strictEqual(e.code, 'ECONNRESET');
-      assert.strictEqual(e.path, undefined);
-      assert.strictEqual(e.host, common.localhostIPv4);
-      assert.strictEqual(e.port, port);
-      assert.strictEqual(e.localAddress, undefined);
-      server.close();
-    }));
-}));
+      tls
+        .connect(
+          port,
+          common.localhostIPv4
+        )
+        .once(
+          'error',
+          common.mustCall((e) => {
+            assert.strictEqual(e.code, 'ECONNRESET');
+            assert.strictEqual(e.path, undefined);
+            assert.strictEqual(e.host, common.localhostIPv4);
+            assert.strictEqual(e.port, port);
+            assert.strictEqual(e.localAddress, undefined);
+            server.close();
+          })
+        );
+    })
+  );
diff --git a/test/parallel/test-tls-wrap-event-emmiter.js b/test/parallel/test-tls-wrap-event-emmiter.js
index 871e6c9ae6834c..5b74f4d48a5815 100644
--- a/test/parallel/test-tls-wrap-event-emmiter.js
+++ b/test/parallel/test-tls-wrap-event-emmiter.js
@@ -6,14 +6,12 @@
  */
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 
 const TlsSocket = require('tls').TLSSocket;
 const EventEmitter = require('events').EventEmitter;
-assert.throws(
-  () => { new TlsSocket(new EventEmitter()); },
-  TypeError
-);
+assert.throws(() => {
+  new TlsSocket(new EventEmitter());
+}, TypeError);
diff --git a/test/parallel/test-tls-wrap-no-abort.js b/test/parallel/test-tls-wrap-no-abort.js
index 9e75da501513fb..f208d5577aa082 100644
--- a/test/parallel/test-tls-wrap-no-abort.js
+++ b/test/parallel/test-tls-wrap-no-abort.js
@@ -2,8 +2,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const util = require('util');
 const { internalBinding } = require('internal/test/binding');
diff --git a/test/parallel/test-tls-wrap-timeout.js b/test/parallel/test-tls-wrap-timeout.js
index 6ae2c39c59b8d9..7b9f3ac284ae36 100644
--- a/test/parallel/test-tls-wrap-timeout.js
+++ b/test/parallel/test-tls-wrap-timeout.js
@@ -4,8 +4,7 @@
 const common = require('../common');
 const { kTimeout, TIMEOUT_MAX } = require('internal/timers');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -17,36 +16,42 @@ const options = {
   cert: fixtures.readKey('agent1-cert.pem')
 };
 
-const server = tls.createServer(options, common.mustCall((c) => {
-  setImmediate(() => {
-    c.write('hello', () => {
-      setImmediate(() => {
-        c.destroy();
-        server.close();
+const server = tls.createServer(
+  options,
+  common.mustCall((c) => {
+    setImmediate(() => {
+      c.write('hello', () => {
+        setImmediate(() => {
+          c.destroy();
+          server.close();
+        });
       });
     });
-  });
-}));
+  })
+);
 
 let socket;
 let lastIdleStart;
 
 server.listen(0, () => {
-  socket = net.connect(server.address().port, function() {
-    const s = socket.setTimeout(TIMEOUT_MAX, function() {
-      throw new Error('timeout');
-    });
-    assert.ok(s instanceof net.Socket);
+  socket = net.connect(
+    server.address().port,
+    function() {
+      const s = socket.setTimeout(TIMEOUT_MAX, function() {
+        throw new Error('timeout');
+      });
+      assert.ok(s instanceof net.Socket);
 
-    assert.notStrictEqual(socket[kTimeout]._idleTimeout, -1);
-    lastIdleStart = socket[kTimeout]._idleStart;
+      assert.notStrictEqual(socket[kTimeout]._idleTimeout, -1);
+      lastIdleStart = socket[kTimeout]._idleStart;
 
-    const tsocket = tls.connect({
-      socket: socket,
-      rejectUnauthorized: false
-    });
-    tsocket.resume();
-  });
+      const tsocket = tls.connect({
+        socket: socket,
+        rejectUnauthorized: false
+      });
+      tsocket.resume();
+    }
+  );
 });
 
 process.on('exit', () => {
diff --git a/test/parallel/test-tls-write-error.js b/test/parallel/test-tls-write-error.js
index 2783e62d063a28..2ede147f5f646a 100644
--- a/test/parallel/test-tls-write-error.js
+++ b/test/parallel/test-tls-write-error.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const { TestTLSSocket, ccs } = require('../common/tls');
 const fixtures = require('../common/fixtures');
@@ -19,37 +18,51 @@ const opts = {
   cert: server_cert
 };
 
-const server = https.createServer(opts, (req, res) => {
-  res.write('hello');
-}).listen(0, common.mustCall(() => {
-  const client = new TestTLSSocket(server_cert);
-
-  client.connect({
-    host: 'localhost',
-    port: server.address().port
-  }, common.mustCall(() => {
-    const ch = client.createClientHello();
-    client.write(ch);
-  }));
-
-  client.once('data', common.mustCall((buf) => {
-    let remaining = buf;
-    do {
-      remaining = client.parseTLSFrame(remaining);
-    } while (remaining.length > 0);
-
-    const cke = client.createClientKeyExchange();
-    const finished = client.createFinished();
-    const ill = client.createIllegalHandshake();
-    const frames = Buffer.concat([
-      cke,
-      ccs,
-      client.encrypt(finished),
-      client.encrypt(ill)
-    ]);
-    client.write(frames, common.mustCall(() => {
-      client.end();
-      server.close();
-    }));
-  }));
-}));
+const server = https
+  .createServer(opts, (req, res) => {
+    res.write('hello');
+  })
+  .listen(
+    0,
+    common.mustCall(() => {
+      const client = new TestTLSSocket(server_cert);
+
+      client.connect(
+        {
+          host: 'localhost',
+          port: server.address().port
+        },
+        common.mustCall(() => {
+          const ch = client.createClientHello();
+          client.write(ch);
+        })
+      );
+
+      client.once(
+        'data',
+        common.mustCall((buf) => {
+          let remaining = buf;
+          do {
+            remaining = client.parseTLSFrame(remaining);
+          } while (remaining.length > 0);
+
+          const cke = client.createClientKeyExchange();
+          const finished = client.createFinished();
+          const ill = client.createIllegalHandshake();
+          const frames = Buffer.concat([
+            cke,
+            ccs,
+            client.encrypt(finished),
+            client.encrypt(ill)
+          ]);
+          client.write(
+            frames,
+            common.mustCall(() => {
+              client.end();
+              server.close();
+            })
+          );
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-writewrap-leak.js b/test/parallel/test-tls-writewrap-leak.js
index 7035764cba5394..7eca1eb740766b 100644
--- a/test/parallel/test-tls-writewrap-leak.js
+++ b/test/parallel/test-tls-writewrap-leak.js
@@ -1,24 +1,33 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const net = require('net');
 const tls = require('tls');
 
-const server = net.createServer(common.mustCall((c) => {
-  c.destroy();
-})).listen(0, common.mustCall(() => {
-  const c = tls.connect({ port: server.address().port });
-  c.on('error', () => {
-    // Otherwise `.write()` callback won't be invoked.
-    c._undestroy();
-  });
+const server = net
+  .createServer(
+    common.mustCall((c) => {
+      c.destroy();
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      const c = tls.connect({ port: server.address().port });
+      c.on('error', () => {
+        // Otherwise `.write()` callback won't be invoked.
+        c._undestroy();
+      });
 
-  c.write('hello', common.mustCall((err) => {
-    assert.strictEqual(err.code, 'ECANCELED');
-    server.close();
-  }));
-}));
+      c.write(
+        'hello',
+        common.mustCall((err) => {
+          assert.strictEqual(err.code, 'ECANCELED');
+          server.close();
+        })
+      );
+    })
+  );
diff --git a/test/parallel/test-tls-zero-clear-in.js b/test/parallel/test-tls-zero-clear-in.js
index b2a07960d4138c..cc5abd98f1bd17 100644
--- a/test/parallel/test-tls-zero-clear-in.js
+++ b/test/parallel/test-tls-zero-clear-in.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
@@ -31,30 +30,41 @@ const fixtures = require('../common/fixtures');
 const cert = fixtures.readSync('test_cert.pem');
 const key = fixtures.readSync('test_key.pem');
 
-const server = tls.createServer({
-  cert,
-  key
-}, function(c) {
-  // Nop
-  setTimeout(function() {
-    c.end();
-    server.close();
-  }, 20);
-}).listen(0, common.mustCall(function() {
-  const conn = tls.connect({
-    cert: cert,
-    key: key,
-    rejectUnauthorized: false,
-    port: this.address().port
-  }, function() {
-    setTimeout(function() {
-      conn.destroy();
-    }, 20);
-  });
+const server = tls
+  .createServer(
+    {
+      cert,
+      key
+    },
+    function(c) {
+      // Nop
+      setTimeout(function() {
+        c.end();
+        server.close();
+      }, 20);
+    }
+  )
+  .listen(
+    0,
+    common.mustCall(function() {
+      const conn = tls.connect(
+        {
+          cert: cert,
+          key: key,
+          rejectUnauthorized: false,
+          port: this.address().port
+        },
+        function() {
+          setTimeout(function() {
+            conn.destroy();
+          }, 20);
+        }
+      );
 
-  // SSL_write() call's return value, when called 0 bytes, should not be
-  // treated as error.
-  conn.end('');
+      // SSL_write() call's return value, when called 0 bytes, should not be
+      // treated as error.
+      conn.end('');
 
-  conn.on('error', common.mustNotCall());
-}));
+      conn.on('error', common.mustNotCall());
+    })
+  );
diff --git a/test/parallel/test-trace-events-all.js b/test/parallel/test-trace-events-all.js
index d0cdd4a8749213..1041e61d4085e6 100644
--- a/test/parallel/test-trace-events-all.js
+++ b/test/parallel/test-trace-events-all.js
@@ -12,45 +12,50 @@ const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 const FILE_NAME = path.join(tmpdir.path, 'node_trace.1.log');
 
-const proc = cp.spawn(process.execPath,
-                      [ '--trace-events-enabled', '-e', CODE ],
-                      { cwd: tmpdir.path });
+const proc = cp.spawn(
+  process.execPath,
+  ['--trace-events-enabled', '-e', CODE],
+  { cwd: tmpdir.path }
+);
 
-proc.once('exit', common.mustCall(() => {
-  assert(fs.existsSync(FILE_NAME));
-  fs.readFile(FILE_NAME, common.mustCall((err, data) => {
-    const traces = JSON.parse(data.toString()).traceEvents;
-    assert(traces.length > 0);
-    // V8 trace events should be generated.
-    assert(traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'v8')
-        return false;
-      if (trace.name !== 'V8.ScriptCompiler')
-        return false;
-      return true;
-    }));
+proc.once(
+  'exit',
+  common.mustCall(() => {
+    assert(fs.existsSync(FILE_NAME));
+    fs.readFile(
+      FILE_NAME,
+      common.mustCall((err, data) => {
+        const traces = JSON.parse(data.toString()).traceEvents;
+        assert(traces.length > 0);
+        // V8 trace events should be generated.
+        assert(
+          traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'v8') return false;
+            if (trace.name !== 'V8.ScriptCompiler') return false;
+            return true;
+          })
+        );
 
-    // C++ async_hooks trace events should be generated.
-    assert(traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'node,node.async_hooks')
-        return false;
-      return true;
-    }));
+        // C++ async_hooks trace events should be generated.
+        assert(
+          traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'node,node.async_hooks') return false;
+            return true;
+          })
+        );
 
-
-    // JavaScript async_hooks trace events should be generated.
-    assert(traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'node,node.async_hooks')
-        return false;
-      if (trace.name !== 'Timeout')
-        return false;
-      return true;
-    }));
-  }));
-}));
+        // JavaScript async_hooks trace events should be generated.
+        assert(
+          traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'node,node.async_hooks') return false;
+            if (trace.name !== 'Timeout') return false;
+            return true;
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-trace-events-api-worker-disabled.js b/test/parallel/test-trace-events-api-worker-disabled.js
index 6140d3a83c5339..109f67e336746a 100644
--- a/test/parallel/test-trace-events-api-worker-disabled.js
+++ b/test/parallel/test-trace-events-api-worker-disabled.js
@@ -4,8 +4,10 @@
 const common = require('../common');
 const { Worker } = require('worker_threads');
 
-new Worker("require('trace_events')", { eval: true })
-  .on('error', common.expectsError({
+new Worker("require('trace_events')", { eval: true }).on(
+  'error',
+  common.expectsError({
     code: 'ERR_TRACE_EVENTS_UNAVAILABLE',
     type: Error
-  }));
+  })
+);
diff --git a/test/parallel/test-trace-events-api.js b/test/parallel/test-trace-events-api.js
index 2810ac0dd0f6d7..8e2af917786cae 100644
--- a/test/parallel/test-trace-events-api.js
+++ b/test/parallel/test-trace-events-api.js
@@ -3,8 +3,7 @@
 
 const common = require('../common');
 
-if (!process.binding('config').hasTracing)
-  common.skip('missing trace events');
+if (!process.binding('config').hasTracing) common.skip('missing trace events');
 common.skipIfWorker(); // https://github.com/nodejs/node/issues/22767
 
 const assert = require('assert');
@@ -12,10 +11,7 @@ const cp = require('child_process');
 const path = require('path');
 const fs = require('fs');
 const tmpdir = require('../common/tmpdir');
-const {
-  createTracing,
-  getEnabledCategories
-} = require('trace_events');
+const { createTracing, getEnabledCategories } = require('trace_events');
 
 const isChild = process.argv[2] === 'child';
 const enabledCategories = isChild ? 'foo' : undefined;
@@ -32,36 +28,35 @@ assert.strictEqual(getEnabledCategories(), enabledCategories);
   });
 });
 
-common.expectsError(
-  () => createTracing({ categories: [] }),
-  {
-    code: 'ERR_TRACE_EVENTS_CATEGORY_REQUIRED',
-    type: TypeError
-  }
-);
+common.expectsError(() => createTracing({ categories: [] }), {
+  code: 'ERR_TRACE_EVENTS_CATEGORY_REQUIRED',
+  type: TypeError
+});
 
-const tracing = createTracing({ categories: [ 'node.perf' ] });
+const tracing = createTracing({ categories: ['node.perf'] });
 
 assert.strictEqual(tracing.categories, 'node.perf');
 assert.strictEqual(tracing.enabled, false);
 
 assert.strictEqual(getEnabledCategories(), enabledCategories);
 tracing.enable();
-tracing.enable();  // purposefully enable twice to test calling twice
+tracing.enable(); // purposefully enable twice to test calling twice
 assert.strictEqual(tracing.enabled, true);
 
-assert.strictEqual(getEnabledCategories(),
-                   isChild ? 'foo,node.perf' : 'node.perf');
+assert.strictEqual(
+  getEnabledCategories(),
+  isChild ? 'foo,node.perf' : 'node.perf'
+);
 
 tracing.disable();
 assert.strictEqual(tracing.enabled, false);
 
-const tracing2 = createTracing({ categories: [ 'foo' ] });
+const tracing2 = createTracing({ categories: ['foo'] });
 tracing2.enable();
 assert.strictEqual(getEnabledCategories(), 'foo');
 
 tracing2.disable();
-tracing2.disable();  // purposefully disable twice to test calling twice
+tracing2.disable(); // purposefully disable twice to test calling twice
 assert.strictEqual(getEnabledCategories(), enabledCategories);
 
 if (isChild) {
@@ -78,14 +73,13 @@ if (isChild) {
   // Intentional non-op, part of the test
   function f() {}
   const ff = performance.timerify(f);
-  ff();  // Will emit a timerify trace event
+  ff(); // Will emit a timerify trace event
 } else {
-
   // Test that enabled tracing references do not get garbage collected
   // until after they are disabled.
   {
     {
-      let tracing3 = createTracing({ categories: [ 'abc' ] });
+      let tracing3 = createTracing({ categories: ['abc'] });
       tracing3.enable();
       assert.strictEqual(getEnabledCategories(), 'abc');
       tracing3 = undefined;
@@ -99,10 +93,11 @@ if (isChild) {
     common.expectWarning(
       'Warning',
       'Possible trace_events memory leak detected. There are more than ' +
-      '10 enabled Tracing objects.',
-      common.noWarnCode);
+        '10 enabled Tracing objects.',
+      common.noWarnCode
+    );
     for (let n = 0; n < 10; n++) {
-      const tracing = createTracing({ categories: [ `a${n}` ] });
+      const tracing = createTracing({ categories: [`a${n}`] });
       tracing.enable();
     }
   }
@@ -120,47 +115,53 @@ if (isChild) {
     { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' }
   ];
 
-  const proc = cp.fork(__filename,
-                       ['child'],
-                       { execArgv: [ '--expose-gc',
-                                     '--trace-event-categories',
-                                     'foo' ] });
-
-  proc.once('exit', common.mustCall(() => {
-    const file = path.join(tmpdir.path, 'node_trace.1.log');
-
-    assert(fs.existsSync(file));
-    fs.readFile(file, common.mustCall((err, data) => {
-      const traces = JSON.parse(data.toString()).traceEvents
-        .filter((trace) => trace.cat !== '__metadata');
-      assert.strictEqual(traces.length,
-                         expectedMarks.length +
-                         expectedBegins.length +
-                         expectedEnds.length);
-
-      traces.forEach((trace) => {
-        assert.strictEqual(trace.pid, proc.pid);
-        switch (trace.ph) {
-          case 'R':
-            assert.strictEqual(trace.cat,
-                               'node,node.perf,node.perf.usertiming');
-            assert.strictEqual(trace.name,
-                               expectedMarks.shift());
-            break;
-          case 'b':
-            const expectedBegin = expectedBegins.shift();
-            assert.strictEqual(trace.cat, expectedBegin.cat);
-            assert.strictEqual(trace.name, expectedBegin.name);
-            break;
-          case 'e':
-            const expectedEnd = expectedEnds.shift();
-            assert.strictEqual(trace.cat, expectedEnd.cat);
-            assert.strictEqual(trace.name, expectedEnd.name);
-            break;
-          default:
-            assert.fail('Unexpected trace event phase');
-        }
-      });
-    }));
-  }));
+  const proc = cp.fork(__filename, ['child'], {
+    execArgv: ['--expose-gc', '--trace-event-categories', 'foo']
+  });
+
+  proc.once(
+    'exit',
+    common.mustCall(() => {
+      const file = path.join(tmpdir.path, 'node_trace.1.log');
+
+      assert(fs.existsSync(file));
+      fs.readFile(
+        file,
+        common.mustCall((err, data) => {
+          const traces = JSON.parse(data.toString()).traceEvents.filter(
+            (trace) => trace.cat !== '__metadata'
+          );
+          assert.strictEqual(
+            traces.length,
+            expectedMarks.length + expectedBegins.length + expectedEnds.length
+          );
+
+          traces.forEach((trace) => {
+            assert.strictEqual(trace.pid, proc.pid);
+            switch (trace.ph) {
+              case 'R':
+                assert.strictEqual(
+                  trace.cat,
+                  'node,node.perf,node.perf.usertiming'
+                );
+                assert.strictEqual(trace.name, expectedMarks.shift());
+                break;
+              case 'b':
+                const expectedBegin = expectedBegins.shift();
+                assert.strictEqual(trace.cat, expectedBegin.cat);
+                assert.strictEqual(trace.name, expectedBegin.name);
+                break;
+              case 'e':
+                const expectedEnd = expectedEnds.shift();
+                assert.strictEqual(trace.cat, expectedEnd.cat);
+                assert.strictEqual(trace.name, expectedEnd.name);
+                break;
+              default:
+                assert.fail('Unexpected trace event phase');
+            }
+          });
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-trace-events-async-hooks.js b/test/parallel/test-trace-events-async-hooks.js
index 09017e47745c49..0bced839139137 100644
--- a/test/parallel/test-trace-events-async-hooks.js
+++ b/test/parallel/test-trace-events-async-hooks.js
@@ -13,54 +13,64 @@ const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 const FILE_NAME = path.join(tmpdir.path, 'node_trace.1.log');
 
-const proc = cp.spawn(process.execPath,
-                      [ '--trace-event-categories', 'node.async_hooks',
-                        '-e', CODE ],
-                      { cwd: tmpdir.path });
+const proc = cp.spawn(
+  process.execPath,
+  ['--trace-event-categories', 'node.async_hooks', '-e', CODE],
+  { cwd: tmpdir.path }
+);
 
-proc.once('exit', common.mustCall(() => {
-  assert(fs.existsSync(FILE_NAME));
-  fs.readFile(FILE_NAME, common.mustCall((err, data) => {
-    const traces = JSON.parse(data.toString()).traceEvents;
-    assert(traces.length > 0);
-    // V8 trace events should be generated.
-    assert(!traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'v8')
-        return false;
-      if (trace.name !== 'V8.ScriptCompiler')
-        return false;
-      return true;
-    }));
+proc.once(
+  'exit',
+  common.mustCall(() => {
+    assert(fs.existsSync(FILE_NAME));
+    fs.readFile(
+      FILE_NAME,
+      common.mustCall((err, data) => {
+        const traces = JSON.parse(data.toString()).traceEvents;
+        assert(traces.length > 0);
+        // V8 trace events should be generated.
+        assert(
+          !traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'v8') return false;
+            if (trace.name !== 'V8.ScriptCompiler') return false;
+            return true;
+          })
+        );
 
-    // C++ async_hooks trace events should be generated.
-    assert(traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'node,node.async_hooks')
-        return false;
-      return true;
-    }));
+        // C++ async_hooks trace events should be generated.
+        assert(
+          traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'node,node.async_hooks') return false;
+            return true;
+          })
+        );
 
-    // JavaScript async_hooks trace events should be generated.
-    assert(traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'node,node.async_hooks')
-        return false;
-      if (trace.name !== 'Timeout')
-        return false;
-      return true;
-    }));
+        // JavaScript async_hooks trace events should be generated.
+        assert(
+          traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'node,node.async_hooks') return false;
+            if (trace.name !== 'Timeout') return false;
+            return true;
+          })
+        );
 
-    // Check args in init events
-    const initEvents = traces.filter((trace) => {
-      return (trace.ph === 'b' && !trace.name.includes('_CALLBACK'));
-    });
-    assert.ok(initEvents.every((trace) => {
-      return (trace.args.data.executionAsyncId > 0 &&
-              trace.args.data.triggerAsyncId > 0);
-    }), `Unexpected initEvents format: ${util.inspect(initEvents)}`);
-  }));
-}));
+        // Check args in init events
+        const initEvents = traces.filter((trace) => {
+          return trace.ph === 'b' && !trace.name.includes('_CALLBACK');
+        });
+        assert.ok(
+          initEvents.every((trace) => {
+            return (
+              trace.args.data.executionAsyncId > 0 &&
+              trace.args.data.triggerAsyncId > 0
+            );
+          }),
+          `Unexpected initEvents format: ${util.inspect(initEvents)}`
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-trace-events-binding.js b/test/parallel/test-trace-events-binding.js
index a6994d47b3e695..ac5d567c365b91 100644
--- a/test/parallel/test-trace-events-binding.js
+++ b/test/parallel/test-trace-events-binding.js
@@ -21,42 +21,55 @@ const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 const FILE_NAME = path.join(tmpdir.path, 'node_trace.1.log');
 
-const proc = cp.spawn(process.execPath,
-                      [ '--trace-event-categories', 'custom',
-                        '--no-warnings',
-                        '--expose-internals',
-                        '-e', CODE ],
-                      { cwd: tmpdir.path });
+const proc = cp.spawn(
+  process.execPath,
+  [
+    '--trace-event-categories',
+    'custom',
+    '--no-warnings',
+    '--expose-internals',
+    '-e',
+    CODE
+  ],
+  { cwd: tmpdir.path }
+);
 
-proc.once('exit', common.mustCall(() => {
-  assert(fs.existsSync(FILE_NAME));
-  fs.readFile(FILE_NAME, common.mustCall((err, data) => {
-    const traces = JSON.parse(data.toString()).traceEvents
-      .filter((trace) => trace.cat !== '__metadata');
-    assert.strictEqual(traces.length, 3);
+proc.once(
+  'exit',
+  common.mustCall(() => {
+    assert(fs.existsSync(FILE_NAME));
+    fs.readFile(
+      FILE_NAME,
+      common.mustCall((err, data) => {
+        const traces = JSON.parse(data.toString()).traceEvents.filter(
+          (trace) => trace.cat !== '__metadata'
+        );
+        assert.strictEqual(traces.length, 3);
 
-    assert.strictEqual(traces[0].pid, proc.pid);
-    assert.strictEqual(traces[0].ph, 'b');
-    assert.strictEqual(traces[0].cat, 'custom');
-    assert.strictEqual(traces[0].name, 'type-value');
-    assert.strictEqual(traces[0].id, '0xa');
-    assert.deepStrictEqual(traces[0].args.data, { 'extra-value': 20 });
+        assert.strictEqual(traces[0].pid, proc.pid);
+        assert.strictEqual(traces[0].ph, 'b');
+        assert.strictEqual(traces[0].cat, 'custom');
+        assert.strictEqual(traces[0].name, 'type-value');
+        assert.strictEqual(traces[0].id, '0xa');
+        assert.deepStrictEqual(traces[0].args.data, { 'extra-value': 20 });
 
-    assert.strictEqual(traces[1].pid, proc.pid);
-    assert.strictEqual(traces[1].ph, 'b');
-    assert.strictEqual(traces[1].cat, 'custom');
-    assert.strictEqual(traces[1].name, 'type-value');
-    assert.strictEqual(traces[1].id, '0x14');
-    assert.deepStrictEqual(traces[1].args.data, {
-      'first-value': 20,
-      'second-value': 30
-    });
+        assert.strictEqual(traces[1].pid, proc.pid);
+        assert.strictEqual(traces[1].ph, 'b');
+        assert.strictEqual(traces[1].cat, 'custom');
+        assert.strictEqual(traces[1].name, 'type-value');
+        assert.strictEqual(traces[1].id, '0x14');
+        assert.deepStrictEqual(traces[1].args.data, {
+          'first-value': 20,
+          'second-value': 30
+        });
 
-    assert.strictEqual(traces[2].pid, proc.pid);
-    assert.strictEqual(traces[2].ph, 'b');
-    assert.strictEqual(traces[2].cat, 'custom');
-    assert.strictEqual(traces[2].name, 'type-value');
-    assert.strictEqual(traces[2].id, '0x1e');
-    assert.deepStrictEqual(traces[2].args, { });
-  }));
-}));
+        assert.strictEqual(traces[2].pid, proc.pid);
+        assert.strictEqual(traces[2].ph, 'b');
+        assert.strictEqual(traces[2].cat, 'custom');
+        assert.strictEqual(traces[2].name, 'type-value');
+        assert.strictEqual(traces[2].id, '0x1e');
+        assert.deepStrictEqual(traces[2].args, {});
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-trace-events-bootstrap.js b/test/parallel/test-trace-events-bootstrap.js
index 087fbd2f182a61..59aa25e0bdd089 100644
--- a/test/parallel/test-trace-events-bootstrap.js
+++ b/test/parallel/test-trace-events-bootstrap.js
@@ -28,26 +28,29 @@ if (process.argv[2] === 'child') {
 } else {
   tmpdir.refresh();
 
-  const proc = cp.fork(__filename,
-                       [ 'child' ], {
-                         cwd: tmpdir.path,
-                         execArgv: [
-                           '--trace-event-categories',
-                           'node.bootstrap'
-                         ]
-                       });
+  const proc = cp.fork(__filename, ['child'], {
+    cwd: tmpdir.path,
+    execArgv: ['--trace-event-categories', 'node.bootstrap']
+  });
 
-  proc.once('exit', common.mustCall(() => {
-    const file = path.join(tmpdir.path, 'node_trace.1.log');
+  proc.once(
+    'exit',
+    common.mustCall(() => {
+      const file = path.join(tmpdir.path, 'node_trace.1.log');
 
-    assert(fs.existsSync(file));
-    fs.readFile(file, common.mustCall((err, data) => {
-      const traces = JSON.parse(data.toString()).traceEvents
-        .filter((trace) => trace.cat !== '__metadata');
-      traces.forEach((trace) => {
-        assert.strictEqual(trace.pid, proc.pid);
-        assert(names.includes(trace.name));
-      });
-    }));
-  }));
+      assert(fs.existsSync(file));
+      fs.readFile(
+        file,
+        common.mustCall((err, data) => {
+          const traces = JSON.parse(data.toString()).traceEvents.filter(
+            (trace) => trace.cat !== '__metadata'
+          );
+          traces.forEach((trace) => {
+            assert.strictEqual(trace.pid, proc.pid);
+            assert(names.includes(trace.name));
+          });
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-trace-events-category-used.js b/test/parallel/test-trace-events-category-used.js
index bedc27bac4d45b..f07a06f6199d2d 100644
--- a/test/parallel/test-trace-events-category-used.js
+++ b/test/parallel/test-trace-events-category-used.js
@@ -16,36 +16,50 @@ tmpdir.refresh();
 
 const procEnabled = cp.spawn(
   process.execPath,
-  [ '--trace-event-categories', 'custom',
+  [
+    '--trace-event-categories',
+    'custom',
     // make test less noisy since internal/test/binding
     // emits a warning.
     '--no-warnings',
     '--expose-internals',
-    '-e', CODE ],
+    '-e',
+    CODE
+  ],
   { cwd: tmpdir.path }
 );
 let procEnabledOutput = '';
 
-procEnabled.stdout.on('data', (data) => procEnabledOutput += data);
+procEnabled.stdout.on('data', (data) => (procEnabledOutput += data));
 procEnabled.stderr.pipe(process.stderr);
-procEnabled.once('exit', common.mustCall(() => {
-  assert.strictEqual(procEnabledOutput, 'true\n');
-}));
+procEnabled.once(
+  'exit',
+  common.mustCall(() => {
+    assert.strictEqual(procEnabledOutput, 'true\n');
+  })
+);
 
 const procDisabled = cp.spawn(
   process.execPath,
-  [ '--trace-event-categories', 'other',
+  [
+    '--trace-event-categories',
+    'other',
     // make test less noisy since internal/test/binding
     // emits a warning.
     '--no-warnings',
     '--expose-internals',
-    '-e', CODE ],
+    '-e',
+    CODE
+  ],
   { cwd: tmpdir.path }
 );
 let procDisabledOutput = '';
 
-procDisabled.stdout.on('data', (data) => procDisabledOutput += data);
+procDisabled.stdout.on('data', (data) => (procDisabledOutput += data));
 procDisabled.stderr.pipe(process.stderr);
-procDisabled.once('exit', common.mustCall(() => {
-  assert.strictEqual(procDisabledOutput, 'false\n');
-}));
+procDisabled.once(
+  'exit',
+  common.mustCall(() => {
+    assert.strictEqual(procDisabledOutput, 'false\n');
+  })
+);
diff --git a/test/parallel/test-trace-events-console.js b/test/parallel/test-trace-events-console.js
index a4860b5da008b4..79b052a4bfa7ea 100644
--- a/test/parallel/test-trace-events-console.js
+++ b/test/parallel/test-trace-events-console.js
@@ -9,12 +9,9 @@ const tmpdir = require('../common/tmpdir');
 // Tests that node.console trace events for counters and time methods are
 // emitted as expected.
 
-const names = [
-  'time::foo',
-  'count::bar'
-];
-const expectedCounts = [ 1, 2, 0 ];
-const expectedTimeTypes = [ 'b', 'n', 'e' ];
+const names = ['time::foo', 'count::bar'];
+const expectedCounts = [1, 2, 0];
+const expectedTimeTypes = ['b', 'n', 'e'];
 
 if (process.argv[2] === 'child') {
   // The following console outputs exercise the test, causing node.console
@@ -32,31 +29,30 @@ if (process.argv[2] === 'child') {
 } else {
   tmpdir.refresh();
 
-  const proc = cp.fork(__filename,
-                       [ 'child' ], {
-                         cwd: tmpdir.path,
-                         execArgv: [
-                           '--trace-event-categories',
-                           'node.console'
-                         ]
-                       });
+  const proc = cp.fork(__filename, ['child'], {
+    cwd: tmpdir.path,
+    execArgv: ['--trace-event-categories', 'node.console']
+  });
 
-  proc.once('exit', common.mustCall(async () => {
-    const file = path.join(tmpdir.path, 'node_trace.1.log');
+  proc.once(
+    'exit',
+    common.mustCall(async () => {
+      const file = path.join(tmpdir.path, 'node_trace.1.log');
 
-    assert(fs.existsSync(file));
-    const data = await fs.promises.readFile(file, { encoding: 'utf8' });
-    JSON.parse(data).traceEvents
-      .filter((trace) => trace.cat !== '__metadata')
-      .forEach((trace) => {
-        assert.strictEqual(trace.pid, proc.pid);
-        assert(names.includes(trace.name));
-        if (trace.name === 'count::bar')
-          assert.strictEqual(trace.args.data, expectedCounts.shift());
-        else if (trace.name === 'time::foo')
-          assert.strictEqual(trace.ph, expectedTimeTypes.shift());
-      });
-    assert.strictEqual(expectedCounts.length, 0);
-    assert.strictEqual(expectedTimeTypes.length, 0);
-  }));
+      assert(fs.existsSync(file));
+      const data = await fs.promises.readFile(file, { encoding: 'utf8' });
+      JSON.parse(data)
+        .traceEvents.filter((trace) => trace.cat !== '__metadata')
+        .forEach((trace) => {
+          assert.strictEqual(trace.pid, proc.pid);
+          assert(names.includes(trace.name));
+          if (trace.name === 'count::bar')
+            assert.strictEqual(trace.args.data, expectedCounts.shift());
+          else if (trace.name === 'time::foo')
+            assert.strictEqual(trace.ph, expectedTimeTypes.shift());
+        });
+      assert.strictEqual(expectedCounts.length, 0);
+      assert.strictEqual(expectedTimeTypes.length, 0);
+    })
+  );
 }
diff --git a/test/parallel/test-trace-events-dynamic-enable-workers-disabled.js b/test/parallel/test-trace-events-dynamic-enable-workers-disabled.js
index adae50057e8a4e..292700d18e19d2 100644
--- a/test/parallel/test-trace-events-dynamic-enable-workers-disabled.js
+++ b/test/parallel/test-trace-events-dynamic-enable-workers-disabled.js
@@ -17,12 +17,16 @@ const { Session } = require('inspector');
 
 const session = new Session();
 session.connect();
-session.post('NodeTracing.start', {
-  traceConfig: { includedCategories: ['node.perf'] }
-}, common.mustCall((err) => {
-  assert.deepStrictEqual(err, {
-    code: -32000,
-    message:
-      'Tracing properties can only be changed through main thread sessions'
-  });
-}));
+session.post(
+  'NodeTracing.start',
+  {
+    traceConfig: { includedCategories: ['node.perf'] }
+  },
+  common.mustCall((err) => {
+    assert.deepStrictEqual(err, {
+      code: -32000,
+      message:
+        'Tracing properties can only be changed through main thread sessions'
+    });
+  })
+);
diff --git a/test/parallel/test-trace-events-dynamic-enable.js b/test/parallel/test-trace-events-dynamic-enable.js
index 645dcb2764a1be..0b9ad25882663b 100644
--- a/test/parallel/test-trace-events-dynamic-enable.js
+++ b/test/parallel/test-trace-events-dynamic-enable.js
@@ -14,10 +14,8 @@ const session = new Session();
 function post(message, data) {
   return new Promise((resolve, reject) => {
     session.post(message, data, (err, result) => {
-      if (err)
-        reject(new Error(JSON.stringify(err)));
-      else
-        resolve(result);
+      if (err) reject(new Error(JSON.stringify(err)));
+      else resolve(result);
     });
   });
 }
@@ -29,9 +27,9 @@ async function test() {
   let tracingComplete = false;
   session.on('NodeTracing.dataCollected', (n) => {
     assert.ok(n && n.data && n.data.value);
-    events.push(...n.data.value);  // append the events.
+    events.push(...n.data.value); // append the events.
   });
-  session.on('NodeTracing.tracingComplete', () => tracingComplete = true);
+  session.on('NodeTracing.tracingComplete', () => (tracingComplete = true));
 
   // Generate a node.perf event before tracing is enabled.
   performance.mark('mark1');
@@ -51,7 +49,9 @@ async function test() {
 
   assert.ok(tracingComplete);
 
-  const marks = events.filter((t) => null !== /node\.perf\.usertim/.exec(t.cat));
+  const marks = events.filter(
+    (t) => null !== /node\.perf\.usertim/.exec(t.cat)
+  );
   assert.strictEqual(marks.length, 1);
   assert.strictEqual(marks[0].name, 'mark2');
 }
diff --git a/test/parallel/test-trace-events-environment.js b/test/parallel/test-trace-events-environment.js
index 39218d0aac225e..95802184bf532c 100644
--- a/test/parallel/test-trace-events-environment.js
+++ b/test/parallel/test-trace-events-environment.js
@@ -28,34 +28,37 @@ if (process.argv[2] === 'child') {
   1 + 1;
   // These ensure that the RunTimers, CheckImmediate, and
   // RunAndClearNativeImmediates appear in the list.
-  setImmediate(() => { 1 + 1; });
-  setTimeout(() => { 1 + 1; }, 1);
+  setImmediate(() => {
+    1 + 1;
+  });
+  setTimeout(() => {
+    1 + 1;
+  }, 1);
 } else {
   tmpdir.refresh();
   process.chdir(tmpdir.path);
 
-  const proc = cp.fork(__filename,
-                       [ 'child' ], {
-                         execArgv: [
-                           '--trace-event-categories',
-                           'node.environment'
-                         ]
-                       });
-
-  proc.once('exit', common.mustCall(async () => {
-    const file = path.join(tmpdir.path, 'node_trace.1.log');
-    const checkSet = new Set();
-
-    assert(fs.existsSync(file));
-    const data = await fs.promises.readFile(file);
-    JSON.parse(data.toString()).traceEvents
-      .filter((trace) => trace.cat !== '__metadata')
-      .forEach((trace) => {
-        assert.strictEqual(trace.pid, proc.pid);
-        assert(names.has(trace.name));
-        checkSet.add(trace.name);
-      });
-
-    assert.deepStrictEqual(names, checkSet);
-  }));
+  const proc = cp.fork(__filename, ['child'], {
+    execArgv: ['--trace-event-categories', 'node.environment']
+  });
+
+  proc.once(
+    'exit',
+    common.mustCall(async () => {
+      const file = path.join(tmpdir.path, 'node_trace.1.log');
+      const checkSet = new Set();
+
+      assert(fs.existsSync(file));
+      const data = await fs.promises.readFile(file);
+      JSON.parse(data.toString())
+        .traceEvents.filter((trace) => trace.cat !== '__metadata')
+        .forEach((trace) => {
+          assert.strictEqual(trace.pid, proc.pid);
+          assert(names.has(trace.name));
+          checkSet.add(trace.name);
+        });
+
+      assert.deepStrictEqual(names, checkSet);
+    })
+  );
 }
diff --git a/test/parallel/test-trace-events-file-pattern.js b/test/parallel/test-trace-events-file-pattern.js
index a60559b7f91b2b..1a1353e251f765 100644
--- a/test/parallel/test-trace-events-file-pattern.js
+++ b/test/parallel/test-trace-events-file-pattern.js
@@ -11,21 +11,34 @@ tmpdir.refresh();
 const CODE =
   'setTimeout(() => { for (var i = 0; i < 100000; i++) { "test" + i } }, 1)';
 
-const proc = cp.spawn(process.execPath, [
-  '--trace-events-enabled',
-  '--trace-event-file-pattern',
-  // eslint-disable-next-line no-template-curly-in-string
-  '${pid}-${rotation}-${pid}-${rotation}.tracing.log',
-  '-e', CODE
-], { cwd: tmpdir.path });
+const proc = cp.spawn(
+  process.execPath,
+  [
+    '--trace-events-enabled',
+    '--trace-event-file-pattern',
+    // eslint-disable-next-line no-template-curly-in-string
+    '${pid}-${rotation}-${pid}-${rotation}.tracing.log',
+    '-e',
+    CODE
+  ],
+  { cwd: tmpdir.path }
+);
 
-proc.once('exit', common.mustCall(() => {
-  const expectedFilename = path.join(tmpdir.path,
-                                     `${proc.pid}-1-${proc.pid}-1.tracing.log`);
+proc.once(
+  'exit',
+  common.mustCall(() => {
+    const expectedFilename = path.join(
+      tmpdir.path,
+      `${proc.pid}-1-${proc.pid}-1.tracing.log`
+    );
 
-  assert(fs.existsSync(expectedFilename));
-  fs.readFile(expectedFilename, common.mustCall((err, data) => {
-    const traces = JSON.parse(data.toString()).traceEvents;
-    assert(traces.length > 0);
-  }));
-}));
+    assert(fs.existsSync(expectedFilename));
+    fs.readFile(
+      expectedFilename,
+      common.mustCall((err, data) => {
+        const traces = JSON.parse(data.toString()).traceEvents;
+        assert(traces.length > 0);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-trace-events-fs-sync.js b/test/parallel/test-trace-events-fs-sync.js
index d8e9ca30a8ebd3..3696eae8fce7d5 100644
--- a/test/parallel/test-trace-events-fs-sync.js
+++ b/test/parallel/test-trace-events-fs-sync.js
@@ -16,102 +16,134 @@ if (!common.isWindows) {
   uid = process.getuid();
 }
 
-tests['fs.sync.access'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                          'fs.accessSync("fs.txt");' +
-                          'fs.unlinkSync("fs.txt")';
-tests['fs.sync.chmod'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                         'fs.chmodSync("fs.txt",100);' +
-                         'fs.unlinkSync("fs.txt")';
-tests['fs.sync.chown'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                         'fs.chownSync("fs.txt",' + uid + ',' + gid + ');' +
-                         'fs.unlinkSync("fs.txt")';
-tests['fs.sync.close'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                         'fs.unlinkSync("fs.txt")';
-tests['fs.sync.copyfile'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                            'fs.copyFileSync("fs.txt","a.txt");' +
-                            'fs.unlinkSync("fs.txt")';
-tests['fs.sync.fchmod'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                          'const fd = fs.openSync("fs.txt", "r+");' +
-                          'fs.fchmodSync(fd,100);' +
-                          'fs.unlinkSync("fs.txt")';
-tests['fs.sync.fchown'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                          'const fd = fs.openSync("fs.txt", "r+");' +
-                          'fs.fchownSync(fd,' + uid + ',' + gid + ');' +
-                          'fs.unlinkSync("fs.txt")';
-tests['fs.sync.fdatasync'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                             'const fd = fs.openSync("fs.txt", "r+");' +
-                             'fs.fdatasyncSync(fd);' +
-                             'fs.unlinkSync("fs.txt")';
-tests['fs.sync.fstat'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                         'fs.readFileSync("fs.txt");' +
-                         'fs.unlinkSync("fs.txt")';
-tests['fs.sync.fsync'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                         'const fd = fs.openSync("fs.txt", "r+");' +
-                         'fs.fsyncSync(fd);' +
-                         'fs.unlinkSync("fs.txt")';
-tests['fs.sync.ftruncate'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                             'const fd = fs.openSync("fs.txt", "r+");' +
-                             'fs.ftruncateSync(fd, 1);' +
-                             'fs.unlinkSync("fs.txt")';
-tests['fs.sync.futimes'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                           'const fd = fs.openSync("fs.txt", "r+");' +
-                           'fs.futimesSync(fd,1,1);' +
-                           'fs.unlinkSync("fs.txt")';
-tests['fs.sync.lchown'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                          'fs.lchownSync("fs.txt",' + uid + ',' + gid + ');' +
-                          'fs.unlinkSync("fs.txt")';
-tests['fs.sync.link'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                        'fs.linkSync("fs.txt", "linkx");' +
-                        'fs.unlinkSync("linkx");' +
-                        'fs.unlinkSync("fs.txt")';
-tests['fs.sync.lstat'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                         'fs.lstatSync("fs.txt");' +
-                         'fs.unlinkSync("fs.txt")';
-tests['fs.sync.mkdir'] = 'fs.mkdirSync("fstemp");' +
-                         'fs.rmdirSync("fstemp")';
-tests['fs.sync.mkdtemp'] = 'const fp = fs.mkdtempSync("fstest");' +
-                           'fs.rmdirSync(fp)';
-tests['fs.sync.open'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                        'fs.unlinkSync("fs.txt")';
-tests['fs.sync.read'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                        'fs.readFileSync("fs.txt");' +
-                        'fs.unlinkSync("fs.txt")';
+tests['fs.sync.access'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.accessSync("fs.txt");' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.chmod'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.chmodSync("fs.txt",100);' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.chown'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.chownSync("fs.txt",' +
+  uid +
+  ',' +
+  gid +
+  ');' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.close'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' + 'fs.unlinkSync("fs.txt")';
+tests['fs.sync.copyfile'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.copyFileSync("fs.txt","a.txt");' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.fchmod'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'const fd = fs.openSync("fs.txt", "r+");' +
+  'fs.fchmodSync(fd,100);' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.fchown'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'const fd = fs.openSync("fs.txt", "r+");' +
+  'fs.fchownSync(fd,' +
+  uid +
+  ',' +
+  gid +
+  ');' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.fdatasync'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'const fd = fs.openSync("fs.txt", "r+");' +
+  'fs.fdatasyncSync(fd);' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.fstat'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.readFileSync("fs.txt");' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.fsync'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'const fd = fs.openSync("fs.txt", "r+");' +
+  'fs.fsyncSync(fd);' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.ftruncate'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'const fd = fs.openSync("fs.txt", "r+");' +
+  'fs.ftruncateSync(fd, 1);' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.futimes'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'const fd = fs.openSync("fs.txt", "r+");' +
+  'fs.futimesSync(fd,1,1);' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.lchown'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.lchownSync("fs.txt",' +
+  uid +
+  ',' +
+  gid +
+  ');' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.link'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.linkSync("fs.txt", "linkx");' +
+  'fs.unlinkSync("linkx");' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.lstat'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.lstatSync("fs.txt");' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.mkdir'] = 'fs.mkdirSync("fstemp");' + 'fs.rmdirSync("fstemp")';
+tests['fs.sync.mkdtemp'] =
+  'const fp = fs.mkdtempSync("fstest");' + 'fs.rmdirSync(fp)';
+tests['fs.sync.open'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' + 'fs.unlinkSync("fs.txt")';
+tests['fs.sync.read'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.readFileSync("fs.txt");' +
+  'fs.unlinkSync("fs.txt")';
 tests['fs.sync.readdir'] = 'fs.readdirSync("./")';
-tests['fs.sync.realpath'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                            'fs.linkSync("fs.txt", "linkx");' +
-                            'fs.realpathSync.native("linkx");' +
-                            'fs.unlinkSync("linkx");' +
-                            'fs.unlinkSync("fs.txt")';
-tests['fs.sync.rename'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                          'fs.renameSync("fs.txt","xyz.txt"); ' +
-                          'fs.unlinkSync("xyz.txt")';
-tests['fs.sync.rmdir'] = 'fs.mkdirSync("fstemp");' +
-                         'fs.rmdirSync("fstemp")';
-tests['fs.sync.stat'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                        'fs.statSync("fs.txt");' +
-                        'fs.unlinkSync("fs.txt")';
-tests['fs.sync.unlink'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                          'fs.linkSync("fs.txt", "linkx");' +
-                          'fs.unlinkSync("linkx");' +
-                          'fs.unlinkSync("fs.txt")';
-tests['fs.sync.utimes'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                          'fs.utimesSync("fs.txt",1,1);' +
-                          'fs.unlinkSync("fs.txt")';
-tests['fs.sync.write'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                         'fs.unlinkSync("fs.txt")';
+tests['fs.sync.realpath'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.linkSync("fs.txt", "linkx");' +
+  'fs.realpathSync.native("linkx");' +
+  'fs.unlinkSync("linkx");' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.rename'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.renameSync("fs.txt","xyz.txt"); ' +
+  'fs.unlinkSync("xyz.txt")';
+tests['fs.sync.rmdir'] = 'fs.mkdirSync("fstemp");' + 'fs.rmdirSync("fstemp")';
+tests['fs.sync.stat'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.statSync("fs.txt");' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.unlink'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.linkSync("fs.txt", "linkx");' +
+  'fs.unlinkSync("linkx");' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.utimes'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' +
+  'fs.utimesSync("fs.txt",1,1);' +
+  'fs.unlinkSync("fs.txt")';
+tests['fs.sync.write'] =
+  'fs.writeFileSync("fs.txt", "123", "utf8");' + 'fs.unlinkSync("fs.txt")';
 
 // On windows, we need permissions to test symlink and readlink.
 // We'll only try to run these tests if we have enough privileges.
 if (common.canCreateSymLink()) {
-  tests['fs.sync.symlink'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                             'fs.symlinkSync("fs.txt", "linkx");' +
-                             'fs.unlinkSync("linkx");' +
-                             'fs.unlinkSync("fs.txt")';
-  tests['fs.sync.readlink'] = 'fs.writeFileSync("fs.txt", "123", "utf8");' +
-                              'fs.symlinkSync("fs.txt", "linkx");' +
-                              'fs.readlinkSync("linkx");' +
-                              'fs.unlinkSync("linkx");' +
-                              'fs.unlinkSync("fs.txt")';
+  tests['fs.sync.symlink'] =
+    'fs.writeFileSync("fs.txt", "123", "utf8");' +
+    'fs.symlinkSync("fs.txt", "linkx");' +
+    'fs.unlinkSync("linkx");' +
+    'fs.unlinkSync("fs.txt")';
+  tests['fs.sync.readlink'] =
+    'fs.writeFileSync("fs.txt", "123", "utf8");' +
+    'fs.symlinkSync("fs.txt", "linkx");' +
+    'fs.readlinkSync("linkx");' +
+    'fs.unlinkSync("linkx");' +
+    'fs.unlinkSync("fs.txt")';
 }
 
 const tmpdir = require('../common/tmpdir');
@@ -119,11 +151,17 @@ tmpdir.refresh();
 const traceFile = path.join(tmpdir.path, 'node_trace.1.log');
 
 for (const tr in tests) {
-  const proc = cp.spawnSync(process.execPath,
-                            [ '--trace-events-enabled',
-                              '--trace-event-categories', 'node.fs.sync',
-                              '-e', tests[tr] ],
-                            { cwd: tmpdir.path, encoding: 'utf8' });
+  const proc = cp.spawnSync(
+    process.execPath,
+    [
+      '--trace-events-enabled',
+      '--trace-event-categories',
+      'node.fs.sync',
+      '-e',
+      tests[tr]
+    ],
+    { cwd: tmpdir.path, encoding: 'utf8' }
+  );
   // Some AIX versions don't support futimes or utimes, so skip.
   if (common.isAIX && proc.status !== 0 && tr === 'fs.sync.futimes') {
     continue;
@@ -147,13 +185,12 @@ for (const tr in tests) {
   assert(traces.length > 0);
 
   // C++ fs sync trace events should be generated.
-  assert(traces.some((trace) => {
-    if (trace.pid !== proc.pid)
-      return false;
-    if (trace.cat !== 'node,node.fs,node.fs.sync')
-      return false;
-    if (trace.name !== tr)
-      return false;
-    return true;
-  }));
+  assert(
+    traces.some((trace) => {
+      if (trace.pid !== proc.pid) return false;
+      if (trace.cat !== 'node,node.fs,node.fs.sync') return false;
+      if (trace.name !== tr) return false;
+      return true;
+    })
+  );
 }
diff --git a/test/parallel/test-trace-events-metadata.js b/test/parallel/test-trace-events-metadata.js
index 0db8555838cd42..6e70ba7e630785 100644
--- a/test/parallel/test-trace-events-metadata.js
+++ b/test/parallel/test-trace-events-metadata.js
@@ -13,62 +13,94 @@ const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 const FILE_NAME = path.join(tmpdir.path, 'node_trace.1.log');
 
-const proc = cp.spawn(process.execPath,
-                      [ '--trace-event-categories', 'node.perf.usertiming',
-                        '--title=bar',
-                        '-e', CODE ],
-                      { cwd: tmpdir.path });
-proc.once('exit', common.mustCall(() => {
-  assert(fs.existsSync(FILE_NAME));
-  fs.readFile(FILE_NAME, common.mustCall((err, data) => {
-    const traces = JSON.parse(data.toString()).traceEvents
-      .filter((trace) => trace.cat === '__metadata');
-    assert(traces.length > 0);
-    assert(traces.some((trace) =>
-      trace.name === 'thread_name' &&
-        trace.args.name === 'JavaScriptMainThread'));
-    assert(traces.some((trace) =>
-      trace.name === 'thread_name' &&
-        trace.args.name === 'PlatformWorkerThread'));
-    assert(traces.some((trace) =>
-      trace.name === 'version' &&
-        trace.args.node === process.versions.node));
+const proc = cp.spawn(
+  process.execPath,
+  [
+    '--trace-event-categories',
+    'node.perf.usertiming',
+    '--title=bar',
+    '-e',
+    CODE
+  ],
+  { cwd: tmpdir.path }
+);
+proc.once(
+  'exit',
+  common.mustCall(() => {
+    assert(fs.existsSync(FILE_NAME));
+    fs.readFile(
+      FILE_NAME,
+      common.mustCall((err, data) => {
+        const traces = JSON.parse(data.toString()).traceEvents.filter(
+          (trace) => trace.cat === '__metadata'
+        );
+        assert(traces.length > 0);
+        assert(
+          traces.some(
+            (trace) =>
+              trace.name === 'thread_name' &&
+              trace.args.name === 'JavaScriptMainThread'
+          )
+        );
+        assert(
+          traces.some(
+            (trace) =>
+              trace.name === 'thread_name' &&
+              trace.args.name === 'PlatformWorkerThread'
+          )
+        );
+        assert(
+          traces.some(
+            (trace) =>
+              trace.name === 'version' &&
+              trace.args.node === process.versions.node
+          )
+        );
 
-    assert(traces.some((trace) =>
-      trace.name === 'node' &&
-        (trace.args.process.versions.http_parser ===
-           process.versions.http_parser ||
-         trace.args.process.versions.llhttp === process.versions.llhttp) &&
-        trace.args.process.versions.node ===
-          process.versions.node &&
-        trace.args.process.versions.v8 ===
-          process.versions.v8 &&
-        trace.args.process.versions.uv ===
-          process.versions.uv &&
-        trace.args.process.versions.zlib ===
-          process.versions.zlib &&
-        trace.args.process.versions.ares ===
-          process.versions.ares &&
-        trace.args.process.versions.modules ===
-          process.versions.modules &&
-        trace.args.process.versions.nghttp2 ===
-          process.versions.nghttp2 &&
-        trace.args.process.versions.napi ===
-          process.versions.napi &&
-        trace.args.process.versions.openssl ===
-          process.versions.openssl &&
-        trace.args.process.arch === process.arch &&
-        trace.args.process.platform === process.platform &&
-        trace.args.process.release.name === process.release.name &&
-        (!process.release.lts ||
-          trace.args.process.release.lts === process.release.lts)));
+        assert(
+          traces.some(
+            (trace) =>
+              trace.name === 'node' &&
+              (trace.args.process.versions.http_parser ===
+                process.versions.http_parser ||
+                trace.args.process.versions.llhttp ===
+                  process.versions.llhttp) &&
+              trace.args.process.versions.node === process.versions.node &&
+              trace.args.process.versions.v8 === process.versions.v8 &&
+              trace.args.process.versions.uv === process.versions.uv &&
+              trace.args.process.versions.zlib === process.versions.zlib &&
+              trace.args.process.versions.ares === process.versions.ares &&
+              trace.args.process.versions.modules ===
+                process.versions.modules &&
+              trace.args.process.versions.nghttp2 ===
+                process.versions.nghttp2 &&
+              trace.args.process.versions.napi === process.versions.napi &&
+              trace.args.process.versions.openssl ===
+                process.versions.openssl &&
+              trace.args.process.arch === process.arch &&
+              trace.args.process.platform === process.platform &&
+              trace.args.process.release.name === process.release.name &&
+              (!process.release.lts ||
+                trace.args.process.release.lts === process.release.lts)
+          )
+        );
 
-    if (!common.isSunOS) {
-      // Changing process.title is currently unsupported on SunOS/SmartOS
-      assert(traces.some((trace) =>
-        trace.name === 'process_name' && trace.args.name === 'foo'));
-      assert(traces.some((trace) =>
-        trace.name === 'process_name' && trace.args.name === 'bar'));
-    }
-  }));
-}));
+        if (!common.isSunOS) {
+          // Changing process.title is currently unsupported on SunOS/SmartOS
+          assert(
+            traces.some(
+              (trace) =>
+                trace.name === 'process_name' && trace.args.name === 'foo'
+            )
+          );
+          assert(
+            traces.some(
+              (trace) =>
+                trace.name === 'process_name' && trace.args.name === 'bar'
+            )
+          );
+        }
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-trace-events-none.js b/test/parallel/test-trace-events-none.js
index dfe77e4b39369f..8c3733f9326e62 100644
--- a/test/parallel/test-trace-events-none.js
+++ b/test/parallel/test-trace-events-none.js
@@ -14,15 +14,24 @@ const FILE_NAME = path.join(tmpdir.path, 'node_trace.1.log');
 
 const proc_no_categories = cp.spawn(
   process.execPath,
-  [ '--trace-event-categories', '""', '-e', CODE ],
+  ['--trace-event-categories', '""', '-e', CODE],
   { cwd: tmpdir.path }
 );
 
-proc_no_categories.once('exit', common.mustCall(() => {
-  assert(fs.existsSync(FILE_NAME));
-  // Only __metadata categories should have been emitted.
-  fs.readFile(FILE_NAME, common.mustCall((err, data) => {
-    assert.ok(JSON.parse(data.toString()).traceEvents.every(
-      (trace) => trace.cat === '__metadata'));
-  }));
-}));
+proc_no_categories.once(
+  'exit',
+  common.mustCall(() => {
+    assert(fs.existsSync(FILE_NAME));
+    // Only __metadata categories should have been emitted.
+    fs.readFile(
+      FILE_NAME,
+      common.mustCall((err, data) => {
+        assert.ok(
+          JSON.parse(data.toString()).traceEvents.every(
+            (trace) => trace.cat === '__metadata'
+          )
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-trace-events-perf.js b/test/parallel/test-trace-events-perf.js
index 2403a8078a47fd..f1b8cfdaf824b0 100644
--- a/test/parallel/test-trace-events-perf.js
+++ b/test/parallel/test-trace-events-perf.js
@@ -19,7 +19,7 @@ if (process.argv[2] === 'child') {
   // Intentional non-op, part of the test
   function f() {}
   const ff = performance.timerify(f);
-  ff();  // Will emit a timerify trace event
+  ff(); // Will emit a timerify trace event
 } else {
   tmpdir.refresh();
 
@@ -33,52 +33,54 @@ if (process.argv[2] === 'child') {
     { cat: 'node,node.perf,node.perf.usertiming', name: 'A to B' }
   ];
 
-  const proc = cp.fork(__filename,
-                       [
-                         'child'
-                       ], {
-                         cwd: tmpdir.path,
-                         execArgv: [
-                           '--trace-event-categories',
-                           'node.perf'
-                         ]
-                       });
+  const proc = cp.fork(__filename, ['child'], {
+    cwd: tmpdir.path,
+    execArgv: ['--trace-event-categories', 'node.perf']
+  });
 
-  proc.once('exit', common.mustCall(() => {
-    const file = path.join(tmpdir.path, 'node_trace.1.log');
+  proc.once(
+    'exit',
+    common.mustCall(() => {
+      const file = path.join(tmpdir.path, 'node_trace.1.log');
 
-    assert(fs.existsSync(file));
-    fs.readFile(file, common.mustCall((err, data) => {
-      const traces = JSON.parse(data.toString()).traceEvents
-        .filter((trace) => trace.cat !== '__metadata');
-      assert.strictEqual(traces.length,
-                         expectedMarks.length +
-                         expectedBegins.length +
-                         expectedEnds.length);
+      assert(fs.existsSync(file));
+      fs.readFile(
+        file,
+        common.mustCall((err, data) => {
+          const traces = JSON.parse(data.toString()).traceEvents.filter(
+            (trace) => trace.cat !== '__metadata'
+          );
+          assert.strictEqual(
+            traces.length,
+            expectedMarks.length + expectedBegins.length + expectedEnds.length
+          );
 
-      traces.forEach((trace) => {
-        assert.strictEqual(trace.pid, proc.pid);
-        switch (trace.ph) {
-          case 'R':
-            assert.strictEqual(trace.cat,
-                               'node,node.perf,node.perf.usertiming');
-            assert.strictEqual(trace.name,
-                               expectedMarks.shift());
-            break;
-          case 'b':
-            const expectedBegin = expectedBegins.shift();
-            assert.strictEqual(trace.cat, expectedBegin.cat);
-            assert.strictEqual(trace.name, expectedBegin.name);
-            break;
-          case 'e':
-            const expectedEnd = expectedEnds.shift();
-            assert.strictEqual(trace.cat, expectedEnd.cat);
-            assert.strictEqual(trace.name, expectedEnd.name);
-            break;
-          default:
-            assert.fail('Unexpected trace event phase');
-        }
-      });
-    }));
-  }));
+          traces.forEach((trace) => {
+            assert.strictEqual(trace.pid, proc.pid);
+            switch (trace.ph) {
+              case 'R':
+                assert.strictEqual(
+                  trace.cat,
+                  'node,node.perf,node.perf.usertiming'
+                );
+                assert.strictEqual(trace.name, expectedMarks.shift());
+                break;
+              case 'b':
+                const expectedBegin = expectedBegins.shift();
+                assert.strictEqual(trace.cat, expectedBegin.cat);
+                assert.strictEqual(trace.name, expectedBegin.name);
+                break;
+              case 'e':
+                const expectedEnd = expectedEnds.shift();
+                assert.strictEqual(trace.cat, expectedEnd.cat);
+                assert.strictEqual(trace.name, expectedEnd.name);
+                break;
+              default:
+                assert.fail('Unexpected trace event phase');
+            }
+          });
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-trace-events-process-exit.js b/test/parallel/test-trace-events-process-exit.js
index 1a39b889a3c809..494499f9821d33 100644
--- a/test/parallel/test-trace-events-process-exit.js
+++ b/test/parallel/test-trace-events-process-exit.js
@@ -9,15 +9,22 @@ const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 const FILE_NAME = path.join(tmpdir.path, 'node_trace.1.log');
 
-const proc = cp.spawn(process.execPath,
-                      [ '--trace-events-enabled',
-                        '-e', 'process.exit()' ],
-                      { cwd: tmpdir.path });
+const proc = cp.spawn(
+  process.execPath,
+  ['--trace-events-enabled', '-e', 'process.exit()'],
+  { cwd: tmpdir.path }
+);
 
-proc.once('exit', common.mustCall(() => {
-  assert(fs.existsSync(FILE_NAME));
-  fs.readFile(FILE_NAME, common.mustCall((err, data) => {
-    const traces = JSON.parse(data.toString()).traceEvents;
-    assert(traces.length > 0);
-  }));
-}));
+proc.once(
+  'exit',
+  common.mustCall(() => {
+    assert(fs.existsSync(FILE_NAME));
+    fs.readFile(
+      FILE_NAME,
+      common.mustCall((err, data) => {
+        const traces = JSON.parse(data.toString()).traceEvents;
+        assert(traces.length > 0);
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-trace-events-promises.js b/test/parallel/test-trace-events-promises.js
index 0dd4fddc6d75ba..ca6e61acdc2b50 100644
--- a/test/parallel/test-trace-events-promises.js
+++ b/test/parallel/test-trace-events-promises.js
@@ -9,37 +9,45 @@ const tmpdir = require('../common/tmpdir');
 common.disableCrashOnUnhandledRejection();
 
 if (process.argv[2] === 'child') {
-  const p = Promise.reject(1);  // Handled later
-  Promise.reject(2);  // Unhandled
+  const p = Promise.reject(1); // Handled later
+  Promise.reject(2); // Unhandled
   setImmediate(() => {
-    p.catch(() => { /* intentional noop */ });
+    p.catch(() => {
+      /* intentional noop */
+    });
   });
 } else {
   tmpdir.refresh();
 
-  const proc = cp.fork(__filename,
-                       [ 'child' ], {
-                         cwd: tmpdir.path,
-                         execArgv: [
-                           '--no-warnings',
-                           '--trace-event-categories',
-                           'node.promises.rejections'
-                         ]
-                       });
+  const proc = cp.fork(__filename, ['child'], {
+    cwd: tmpdir.path,
+    execArgv: [
+      '--no-warnings',
+      '--trace-event-categories',
+      'node.promises.rejections'
+    ]
+  });
 
-  proc.once('exit', common.mustCall(() => {
-    const file = path.join(tmpdir.path, 'node_trace.1.log');
+  proc.once(
+    'exit',
+    common.mustCall(() => {
+      const file = path.join(tmpdir.path, 'node_trace.1.log');
 
-    assert(fs.existsSync(file));
-    fs.readFile(file, common.mustCall((err, data) => {
-      const traces = JSON.parse(data.toString()).traceEvents
-        .filter((trace) => trace.cat !== '__metadata');
-      traces.forEach((trace) => {
-        assert.strictEqual(trace.pid, proc.pid);
-        assert.strictEqual(trace.name, 'rejections');
-        assert(trace.args.unhandled <= 2);
-        assert(trace.args.handledAfter <= 1);
-      });
-    }));
-  }));
+      assert(fs.existsSync(file));
+      fs.readFile(
+        file,
+        common.mustCall((err, data) => {
+          const traces = JSON.parse(data.toString()).traceEvents.filter(
+            (trace) => trace.cat !== '__metadata'
+          );
+          traces.forEach((trace) => {
+            assert.strictEqual(trace.pid, proc.pid);
+            assert.strictEqual(trace.name, 'rejections');
+            assert(trace.args.unhandled <= 2);
+            assert(trace.args.handledAfter <= 1);
+          });
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-trace-events-v8.js b/test/parallel/test-trace-events-v8.js
index d79838892baa0d..f467ff6de4ce7d 100644
--- a/test/parallel/test-trace-events-v8.js
+++ b/test/parallel/test-trace-events-v8.js
@@ -12,47 +12,50 @@ const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 const FILE_NAME = path.join(tmpdir.path, 'node_trace.1.log');
 
-const proc = cp.spawn(process.execPath,
-                      [ '--trace-events-enabled',
-                        '--trace-event-categories', 'v8',
-                        '-e', CODE ],
-                      { cwd: tmpdir.path });
+const proc = cp.spawn(
+  process.execPath,
+  ['--trace-events-enabled', '--trace-event-categories', 'v8', '-e', CODE],
+  { cwd: tmpdir.path }
+);
 
-proc.once('exit', common.mustCall(() => {
-  assert(fs.existsSync(FILE_NAME));
-  fs.readFile(FILE_NAME, common.mustCall((err, data) => {
-    const traces = JSON.parse(data.toString()).traceEvents;
-    assert(traces.length > 0);
-    // V8 trace events should be generated.
-    assert(traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'v8')
-        return false;
-      if (trace.name !== 'V8.ScriptCompiler')
-        return false;
-      return true;
-    }));
+proc.once(
+  'exit',
+  common.mustCall(() => {
+    assert(fs.existsSync(FILE_NAME));
+    fs.readFile(
+      FILE_NAME,
+      common.mustCall((err, data) => {
+        const traces = JSON.parse(data.toString()).traceEvents;
+        assert(traces.length > 0);
+        // V8 trace events should be generated.
+        assert(
+          traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'v8') return false;
+            if (trace.name !== 'V8.ScriptCompiler') return false;
+            return true;
+          })
+        );
 
-    // C++ async_hooks trace events should be generated.
-    assert(!traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'node.async_hooks')
-        return false;
-      return true;
-    }));
+        // C++ async_hooks trace events should be generated.
+        assert(
+          !traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'node.async_hooks') return false;
+            return true;
+          })
+        );
 
-
-    // JavaScript async_hooks trace events should be generated.
-    assert(!traces.some((trace) => {
-      if (trace.pid !== proc.pid)
-        return false;
-      if (trace.cat !== 'node.async_hooks')
-        return false;
-      if (trace.name !== 'Timeout')
-        return false;
-      return true;
-    }));
-  }));
-}));
+        // JavaScript async_hooks trace events should be generated.
+        assert(
+          !traces.some((trace) => {
+            if (trace.pid !== proc.pid) return false;
+            if (trace.cat !== 'node.async_hooks') return false;
+            if (trace.name !== 'Timeout') return false;
+            return true;
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/parallel/test-trace-events-vm.js b/test/parallel/test-trace-events-vm.js
index 3e5d32b6c3f82c..3fd7b028b90c5e 100644
--- a/test/parallel/test-trace-events-vm.js
+++ b/test/parallel/test-trace-events-vm.js
@@ -6,11 +6,7 @@ const fs = require('fs');
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 
-const names = [
-  'ContextifyScript::New',
-  'RunInThisContext',
-  'RunInContext'
-];
+const names = ['ContextifyScript::New', 'RunInThisContext', 'RunInContext'];
 
 if (process.argv[2] === 'child') {
   const vm = require('vm');
@@ -18,26 +14,29 @@ if (process.argv[2] === 'child') {
 } else {
   tmpdir.refresh();
 
-  const proc = cp.fork(__filename,
-                       [ 'child' ], {
-                         cwd: tmpdir.path,
-                         execArgv: [
-                           '--trace-event-categories',
-                           'node.vm.script'
-                         ]
-                       });
+  const proc = cp.fork(__filename, ['child'], {
+    cwd: tmpdir.path,
+    execArgv: ['--trace-event-categories', 'node.vm.script']
+  });
 
-  proc.once('exit', common.mustCall(() => {
-    const file = path.join(tmpdir.path, 'node_trace.1.log');
+  proc.once(
+    'exit',
+    common.mustCall(() => {
+      const file = path.join(tmpdir.path, 'node_trace.1.log');
 
-    assert(fs.existsSync(file));
-    fs.readFile(file, common.mustCall((err, data) => {
-      const traces = JSON.parse(data.toString()).traceEvents
-        .filter((trace) => trace.cat !== '__metadata');
-      traces.forEach((trace) => {
-        assert.strictEqual(trace.pid, proc.pid);
-        assert(names.includes(trace.name));
-      });
-    }));
-  }));
+      assert(fs.existsSync(file));
+      fs.readFile(
+        file,
+        common.mustCall((err, data) => {
+          const traces = JSON.parse(data.toString()).traceEvents.filter(
+            (trace) => trace.cat !== '__metadata'
+          );
+          traces.forEach((trace) => {
+            assert.strictEqual(trace.pid, proc.pid);
+            assert(names.includes(trace.name));
+          });
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-trace-events-worker-metadata.js b/test/parallel/test-trace-events-worker-metadata.js
index e672aeefd721cc..fac3019dc37b5a 100644
--- a/test/parallel/test-trace-events-worker-metadata.js
+++ b/test/parallel/test-trace-events-worker-metadata.js
@@ -7,27 +7,42 @@ const fs = require('fs');
 const { isMainThread } = require('worker_threads');
 
 if (isMainThread) {
-  const CODE = 'const { Worker } = require(\'worker_threads\'); ' +
-               `new Worker('${__filename.replace(/\\/g, '/')}')`;
+  const CODE =
+    "const { Worker } = require('worker_threads'); " +
+    `new Worker('${__filename.replace(/\\/g, '/')}')`;
   const FILE_NAME = 'node_trace.1.log';
   const tmpdir = require('../common/tmpdir');
   tmpdir.refresh();
   process.chdir(tmpdir.path);
 
-  const proc = cp.spawn(process.execPath,
-                        [ '--experimental-worker',
-                          '--trace-event-categories', 'node',
-                          '-e', CODE ]);
-  proc.once('exit', common.mustCall(() => {
-    assert(fs.existsSync(FILE_NAME));
-    fs.readFile(FILE_NAME, common.mustCall((err, data) => {
-      const traces = JSON.parse(data.toString()).traceEvents;
-      assert(traces.length > 0);
-      assert(traces.some((trace) =>
-        trace.cat === '__metadata' && trace.name === 'thread_name' &&
-          trace.args.name === 'WorkerThread 1'));
-    }));
-  }));
+  const proc = cp.spawn(process.execPath, [
+    '--experimental-worker',
+    '--trace-event-categories',
+    'node',
+    '-e',
+    CODE
+  ]);
+  proc.once(
+    'exit',
+    common.mustCall(() => {
+      assert(fs.existsSync(FILE_NAME));
+      fs.readFile(
+        FILE_NAME,
+        common.mustCall((err, data) => {
+          const traces = JSON.parse(data.toString()).traceEvents;
+          assert(traces.length > 0);
+          assert(
+            traces.some(
+              (trace) =>
+                trace.cat === '__metadata' &&
+                trace.name === 'thread_name' &&
+                trace.args.name === 'WorkerThread 1'
+            )
+          );
+        })
+      );
+    })
+  );
 } else {
   // Do nothing here.
 }
diff --git a/test/parallel/test-tracing-no-crash.js b/test/parallel/test-tracing-no-crash.js
index 0ae402f5288cca..f1885b76267536 100644
--- a/test/parallel/test-tracing-no-crash.js
+++ b/test/parallel/test-tracing-no-crash.js
@@ -8,15 +8,20 @@ function CheckNoSignalAndErrorCodeOne(code, signal) {
   assert.strictEqual(code, 1);
 }
 
-const child = spawn(process.execPath, [
-  '--trace-event-categories', 'madeup', '-e', 'throw new Error()'
-], { stdio: [ 'inherit', 'inherit', 'pipe' ] });
+const child = spawn(
+  process.execPath,
+  ['--trace-event-categories', 'madeup', '-e', 'throw new Error()'],
+  { stdio: ['inherit', 'inherit', 'pipe'] }
+);
 child.on('exit', common.mustCall(CheckNoSignalAndErrorCodeOne));
 
 let stderr;
 child.stderr.setEncoding('utf8');
-child.stderr.on('data', (chunk) => stderr += chunk);
-child.stderr.on('end', common.mustCall(() => {
-  assert(stderr.includes('throw new Error()'), stderr);
-  assert(!stderr.includes('Could not open trace file'), stderr);
-}));
+child.stderr.on('data', (chunk) => (stderr += chunk));
+child.stderr.on(
+  'end',
+  common.mustCall(() => {
+    assert(stderr.includes('throw new Error()'), stderr);
+    assert(!stderr.includes('Could not open trace file'), stderr);
+  })
+);
diff --git a/test/parallel/test-tty-backwards-api.js b/test/parallel/test-tty-backwards-api.js
index 7b6dc3c09257bf..d34ef3e539e1c7 100644
--- a/test/parallel/test-tty-backwards-api.js
+++ b/test/parallel/test-tty-backwards-api.js
@@ -4,7 +4,7 @@ const common = require('../common');
 
 const noop = () => {};
 const { internalBinding } = require('internal/test/binding');
-const TTY = internalBinding('tty_wrap').TTY = function() {};
+const TTY = (internalBinding('tty_wrap').TTY = function() {});
 
 TTY.prototype = {
   setBlocking: noop,
@@ -13,12 +13,7 @@ TTY.prototype = {
 
 const { WriteStream } = require('tty');
 
-const methods = [
-  'cursorTo',
-  'moveCursor',
-  'clearLine',
-  'clearScreenDown'
-];
+const methods = ['cursorTo', 'moveCursor', 'clearLine', 'clearScreenDown'];
 
 methods.forEach((method) => {
   require('readline')[method] = common.mustCall();
diff --git a/test/parallel/test-ttywrap-invalid-fd.js b/test/parallel/test-ttywrap-invalid-fd.js
index 30c3cd2bc48a4a..f9964e68010332 100644
--- a/test/parallel/test-ttywrap-invalid-fd.js
+++ b/test/parallel/test-ttywrap-invalid-fd.js
@@ -4,20 +4,14 @@
 const common = require('../common');
 const tty = require('tty');
 const { internalBinding } = require('internal/test/binding');
-const {
-  UV_EBADF,
-  UV_EINVAL
-} = internalBinding('uv');
+const { UV_EBADF, UV_EINVAL } = internalBinding('uv');
 const assert = require('assert');
 
-assert.throws(
-  () => new tty.WriteStream(-1),
-  {
-    code: 'ERR_INVALID_FD',
-    name: 'RangeError [ERR_INVALID_FD]',
-    message: '"fd" must be a positive integer: -1'
-  }
-);
+assert.throws(() => new tty.WriteStream(-1), {
+  code: 'ERR_INVALID_FD',
+  name: 'RangeError [ERR_INVALID_FD]',
+  message: '"fd" must be a positive integer: -1'
+});
 
 {
   const info = {
@@ -27,8 +21,9 @@ assert.throws(
     syscall: 'uv_tty_init'
   };
 
-  const suffix = common.isWindows ?
-    'EBADF (bad file descriptor)' : 'EINVAL (invalid argument)';
+  const suffix = common.isWindows
+    ? 'EBADF (bad file descriptor)'
+    : 'EINVAL (invalid argument)';
   const message = `TTY initialization failed: uv_tty_init returned ${suffix}`;
 
   assert.throws(
@@ -36,7 +31,8 @@ assert.throws(
       common.runWithInvalidFD((fd) => {
         new tty.WriteStream(fd);
       });
-    }, {
+    },
+    {
       code: 'ERR_TTY_INIT_FAILED',
       name: 'SystemError [ERR_TTY_INIT_FAILED]',
       message,
@@ -49,19 +45,18 @@ assert.throws(
       common.runWithInvalidFD((fd) => {
         new tty.ReadStream(fd);
       });
-    }, {
+    },
+    {
       code: 'ERR_TTY_INIT_FAILED',
       name: 'SystemError [ERR_TTY_INIT_FAILED]',
       message,
       info
-    });
+    }
+  );
 }
 
-assert.throws(
-  () => new tty.ReadStream(-1),
-  {
-    code: 'ERR_INVALID_FD',
-    name: 'RangeError [ERR_INVALID_FD]',
-    message: '"fd" must be a positive integer: -1'
-  }
-);
+assert.throws(() => new tty.ReadStream(-1), {
+  code: 'ERR_INVALID_FD',
+  name: 'RangeError [ERR_INVALID_FD]',
+  message: '"fd" must be a positive integer: -1'
+});
diff --git a/test/parallel/test-url-domain-ascii-unicode.js b/test/parallel/test-url-domain-ascii-unicode.js
index 49259a7ab0f4c4..b3bfa9162aab5b 100644
--- a/test/parallel/test-url-domain-ascii-unicode.js
+++ b/test/parallel/test-url-domain-ascii-unicode.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const strictEqual = require('assert').strictEqual;
 const url = require('url');
diff --git a/test/parallel/test-url-format-invalid-input.js b/test/parallel/test-url-format-invalid-input.js
index 1a0df32657ece8..def4438a9a4401 100644
--- a/test/parallel/test-url-format-invalid-input.js
+++ b/test/parallel/test-url-format-invalid-input.js
@@ -14,14 +14,18 @@ const throwsObjsAndReportTypes = new Map([
 ]);
 
 for (const [urlObject, type] of throwsObjsAndReportTypes) {
-  common.expectsError(function() {
-    url.format(urlObject);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "urlObject" argument must be one of type Object or string. ' +
-             `Received type ${type}`
-  });
+  common.expectsError(
+    function() {
+      url.format(urlObject);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "urlObject" argument must be one of type Object or string. ' +
+        `Received type ${type}`
+    }
+  );
 }
 assert.strictEqual(url.format(''), '');
 assert.strictEqual(url.format({}), '');
diff --git a/test/parallel/test-url-format-whatwg.js b/test/parallel/test-url-format-whatwg.js
index e5c3e369e80390..69032dfed0520f 100644
--- a/test/parallel/test-url-format-whatwg.js
+++ b/test/parallel/test-url-format-whatwg.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const assert = require('assert');
 const url = require('url');
@@ -22,15 +21,13 @@ assert.strictEqual(
 
 {
   [true, 1, 'test', Infinity].forEach((value) => {
-    assert.throws(
-      () => url.format(myURL, value),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        name: 'TypeError [ERR_INVALID_ARG_TYPE]',
-        message: 'The "options" argument must be of type Object. ' +
-                 `Received type ${typeof value}`
-      }
-    );
+    assert.throws(() => url.format(myURL, value), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError [ERR_INVALID_ARG_TYPE]',
+      message:
+        'The "options" argument must be of type Object. ' +
+        `Received type ${typeof value}`
+    });
   });
 }
 
diff --git a/test/parallel/test-url-format.js b/test/parallel/test-url-format.js
index 571895832a3ffb..6a3fbaf9977e49 100644
--- a/test/parallel/test-url-format.js
+++ b/test/parallel/test-url-format.js
@@ -190,7 +190,7 @@ const formatTests = {
     hostname: 'ex.com',
     hash: '#frag',
     search: '?abc=the#1?&foo=bar',
-    pathname: '/foo?100%m#r',
+    pathname: '/foo?100%m#r'
   },
 
   // `?` and `#` in search only
@@ -200,7 +200,7 @@ const formatTests = {
     hostname: 'ex.com',
     hash: '#frag',
     search: '?abc=the#1?&foo=bar',
-    pathname: '/fooA100%mBr',
+    pathname: '/fooA100%mBr'
   },
 
   // multiple `#` in search
@@ -260,9 +260,16 @@ for (const u in formatTests) {
   delete formatTests[u].href;
   const actual = url.format(u);
   const actualObj = url.format(formatTests[u]);
-  assert.strictEqual(actual, expect,
-                     `wonky format(${u}) == ${expect}\nactual:${actual}`);
-  assert.strictEqual(actualObj, expect,
-                     `wonky format(${JSON.stringify(formatTests[u])}) == ${
-                       expect}\nactual: ${actualObj}`);
+  assert.strictEqual(
+    actual,
+    expect,
+    `wonky format(${u}) == ${expect}\nactual:${actual}`
+  );
+  assert.strictEqual(
+    actualObj,
+    expect,
+    `wonky format(${JSON.stringify(
+      formatTests[u]
+    )}) == ${expect}\nactual: ${actualObj}`
+  );
 }
diff --git a/test/parallel/test-url-parse-format.js b/test/parallel/test-url-parse-format.js
index f4e72ee5ef4896..1cfbfce56844d8 100644
--- a/test/parallel/test-url-parse-format.js
+++ b/test/parallel/test-url-parse-format.js
@@ -35,7 +35,8 @@ const parseTests = {
     query: 'json=%22%5C%22foo%5C%22%22',
     path: '/foo.html?json=%22%5C%22foo%5C%22%22',
     hash: '#h%5Ca%5Cs%5Ch',
-    href: 'http://evil-phisher/foo.html?json=%22%5C%22foo%5C%22%22#h%5Ca%5Cs%5Ch'
+    href:
+      'http://evil-phisher/foo.html?json=%22%5C%22foo%5C%22%22#h%5Ca%5Cs%5Ch'
   },
 
   'http:\\\\evil-phisher\\foo.html#h\\a\\s\\h?blarg': {
@@ -49,7 +50,6 @@ const parseTests = {
     href: 'http://evil-phisher/foo.html#h%5Ca%5Cs%5Ch?blarg'
   },
 
-
   'http:\\\\evil-phisher\\foo.html': {
     protocol: 'http:',
     slashes: true,
@@ -134,7 +134,7 @@ const parseTests = {
     path: '/'
   },
 
-  'http://x.com/path?that\'s#all, folks': {
+  "http://x.com/path?that's#all, folks": {
     href: 'http://x.com/path?that%27s#all,%20folks',
     protocol: 'http:',
     slashes: true,
@@ -258,8 +258,9 @@ const parseTests = {
   },
 
   'http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=': {
-    href: 'http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api' +
-          '&x=2&y=2&z=3&s=',
+    href:
+      'http://mt0.google.com/vt/lyrs=m@114???&hl=en&src=api' +
+      '&x=2&y=2&z=3&s=',
     protocol: 'http:',
     slashes: true,
     host: 'mt0.google.com',
@@ -271,7 +272,8 @@ const parseTests = {
   },
 
   'http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=': {
-    href: 'http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=',
+    href:
+      'http://user:pass@mt0.google.com/vt/lyrs=m@114???&hl=en&src=api&x=2&y=2&z=3&s=',
     protocol: 'http:',
     slashes: true,
     host: 'mt0.google.com',
@@ -409,11 +411,11 @@ const parseTests = {
     path: '?subject=hello'
   },
 
-  'javascript:alert(\'hello\');': {
-    href: 'javascript:alert(\'hello\');',
+  "javascript:alert('hello');": {
+    href: "javascript:alert('hello');",
     protocol: 'javascript:',
-    pathname: 'alert(\'hello\');',
-    path: 'alert(\'hello\');'
+    pathname: "alert('hello');",
+    path: "alert('hello');"
   },
 
   'xmpp:isaacschlueter@jabber.org': {
@@ -716,7 +718,7 @@ const parseTests = {
     hostname: '-lovemonsterz.tumblr.com',
     href: 'http://-lovemonsterz.tumblr.com/rss',
     pathname: '/rss',
-    path: '/rss',
+    path: '/rss'
   },
 
   'http://-lovemonsterz.tumblr.com:80/rss': {
@@ -727,7 +729,7 @@ const parseTests = {
     hostname: '-lovemonsterz.tumblr.com',
     href: 'http://-lovemonsterz.tumblr.com:80/rss',
     pathname: '/rss',
-    path: '/rss',
+    path: '/rss'
   },
 
   'http://user:pass@-lovemonsterz.tumblr.com/rss': {
@@ -738,7 +740,7 @@ const parseTests = {
     hostname: '-lovemonsterz.tumblr.com',
     href: 'http://user:pass@-lovemonsterz.tumblr.com/rss',
     pathname: '/rss',
-    path: '/rss',
+    path: '/rss'
   },
 
   'http://user:pass@-lovemonsterz.tumblr.com:80/rss': {
@@ -750,7 +752,7 @@ const parseTests = {
     hostname: '-lovemonsterz.tumblr.com',
     href: 'http://user:pass@-lovemonsterz.tumblr.com:80/rss',
     pathname: '/rss',
-    path: '/rss',
+    path: '/rss'
   },
 
   'http://_jabber._tcp.google.com/test': {
@@ -760,7 +762,7 @@ const parseTests = {
     hostname: '_jabber._tcp.google.com',
     href: 'http://_jabber._tcp.google.com/test',
     pathname: '/test',
-    path: '/test',
+    path: '/test'
   },
 
   'http://user:pass@_jabber._tcp.google.com/test': {
@@ -771,7 +773,7 @@ const parseTests = {
     hostname: '_jabber._tcp.google.com',
     href: 'http://user:pass@_jabber._tcp.google.com/test',
     pathname: '/test',
-    path: '/test',
+    path: '/test'
   },
 
   'http://_jabber._tcp.google.com:80/test': {
@@ -782,7 +784,7 @@ const parseTests = {
     hostname: '_jabber._tcp.google.com',
     href: 'http://_jabber._tcp.google.com:80/test',
     pathname: '/test',
-    path: '/test',
+    path: '/test'
   },
 
   'http://user:pass@_jabber._tcp.google.com:80/test': {
@@ -794,7 +796,7 @@ const parseTests = {
     hostname: '_jabber._tcp.google.com',
     href: 'http://user:pass@_jabber._tcp.google.com:80/test',
     pathname: '/test',
-    path: '/test',
+    path: '/test'
   },
 
   'http://x:1/\' <>"`/{}|\\^~`/': {
@@ -840,10 +842,12 @@ const parseTests = {
     hostname: 'a.b',
     hash: null,
     pathname: '/%09bc%0Adr%0Def%20g%22hq%27j%3Ckl%3E',
-    path: '/%09bc%0Adr%0Def%20g%22hq%27j%3Ckl%3E?mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz', // eslint-disable-line max-len
+    path:
+      '/%09bc%0Adr%0Def%20g%22hq%27j%3Ckl%3E?mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz', // eslint-disable-line max-len
     search: '?mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz',
     query: 'mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz',
-    href: 'http://a.b/%09bc%0Adr%0Def%20g%22hq%27j%3Ckl%3E?mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz'
+    href:
+      'http://a.b/%09bc%0Adr%0Def%20g%22hq%27j%3Ckl%3E?mn%5Cop%5Eq=r%6099%7Bst%7Cuv%7Dwz'
   },
 
   'http://a\r" \t\n<\'b:b@c\r\nd/e?f': {
@@ -858,7 +862,7 @@ const parseTests = {
     query: 'f',
     pathname: '%0D%0Ad/e',
     path: '%0D%0Ad/e?f',
-    href: 'http://a%0D%22%20%09%0A%3C\'b:b@c/%0D%0Ad/e?f'
+    href: "http://a%0D%22%20%09%0A%3C'b:b@c/%0D%0Ad/e?f"
   },
 
   // git urls used by npm
@@ -918,6 +922,9 @@ for (const u in parseTests) {
   expected = parseTests[u].href;
   actual = url.format(parseTests[u]);
 
-  assert.strictEqual(actual, expected,
-                     `format(${u}) == ${u}\nactual:${actual}`);
+  assert.strictEqual(
+    actual,
+    expected,
+    `format(${u}) == ${u}\nactual:${actual}`
+  );
 }
diff --git a/test/parallel/test-url-parse-invalid-input.js b/test/parallel/test-url-parse-invalid-input.js
index aad8462bfc2633..8d6c255916f238 100644
--- a/test/parallel/test-url-parse-invalid-input.js
+++ b/test/parallel/test-url-parse-invalid-input.js
@@ -16,22 +16,28 @@ const url = require('url');
   [() => {}, 'function'],
   [Symbol('foo'), 'symbol']
 ].forEach(([val, type]) => {
-  common.expectsError(() => {
-    url.parse(val);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: `The "url" argument must be of type string. Received type ${type}`
-  });
+  common.expectsError(
+    () => {
+      url.parse(val);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: `The "url" argument must be of type string. Received type ${type}`
+    }
+  );
 });
 
-assert.throws(() => { url.parse('http://%E0%A4%A@fail'); },
-              (e) => {
-                // The error should be a URIError.
-                if (!(e instanceof URIError))
-                  return false;
+assert.throws(
+  () => {
+    url.parse('http://%E0%A4%A@fail');
+  },
+  (e) => {
+    // The error should be a URIError.
+    if (!(e instanceof URIError)) return false;
 
-                // The error should be from the JS engine and not from Node.js.
-                // JS engine errors do not have the `code` property.
-                return e.code === undefined;
-              });
+    // The error should be from the JS engine and not from Node.js.
+    // JS engine errors do not have the `code` property.
+    return e.code === undefined;
+  }
+);
diff --git a/test/parallel/test-url-parse-query.js b/test/parallel/test-url-parse-query.js
index f9174d599ad01b..0b85f685ea3305 100644
--- a/test/parallel/test-url-parse-query.js
+++ b/test/parallel/test-url-parse-query.js
@@ -13,8 +13,10 @@ function createWithNoPrototype(properties = []) {
 
 function check(actual, expected) {
   assert.notStrictEqual(Object.getPrototypeOf(actual), Object.prototype);
-  assert.deepStrictEqual(Object.keys(actual).sort(),
-                         Object.keys(expected).sort());
+  assert.deepStrictEqual(
+    Object.keys(actual).sort(),
+    Object.keys(expected).sort()
+  );
   Object.keys(expected).forEach(function(key) {
     assert.deepStrictEqual(actual[key], expected[key]);
   });
diff --git a/test/parallel/test-url-pathtofileurl.js b/test/parallel/test-url-pathtofileurl.js
index ad8203cd7b1a87..b3b9eee8eab54c 100644
--- a/test/parallel/test-url-pathtofileurl.js
+++ b/test/parallel/test-url-pathtofileurl.js
@@ -12,10 +12,8 @@ const url = require('url');
 {
   const fileURL = url.pathToFileURL('test\\').href;
   assert.ok(fileURL.startsWith('file:///'));
-  if (isWindows)
-    assert.ok(fileURL.endsWith('/'));
-  else
-    assert.ok(fileURL.endsWith('%5C'));
+  if (isWindows) assert.ok(fileURL.endsWith('/'));
+  else assert.ok(fileURL.endsWith('%5C'));
 }
 
 {
diff --git a/test/parallel/test-url-relative.js b/test/parallel/test-url-relative.js
index d8532fcfee0ed6..ac05d6d0f8bc43 100644
--- a/test/parallel/test-url-relative.js
+++ b/test/parallel/test-url-relative.js
@@ -31,27 +31,37 @@ const relativeTests = [
   ['foo/bar', '../../../baz', '../../baz'],
   ['foo/bar/', '../../../baz', '../baz'],
   ['http://example.com/b//c//d;p?q#blarg', 'https:#hash2', 'https:///#hash2'],
-  ['http://example.com/b//c//d;p?q#blarg',
-   'https:/p/a/t/h?s#hash2',
-   'https://p/a/t/h?s#hash2'],
-  ['http://example.com/b//c//d;p?q#blarg',
-   'https://u:p@h.com/p/a/t/h?s#hash2',
-   'https://u:p@h.com/p/a/t/h?s#hash2'],
-  ['http://example.com/b//c//d;p?q#blarg',
-   'https:/a/b/c/d',
-   'https://a/b/c/d'],
-  ['http://example.com/b//c//d;p?q#blarg',
-   'http:#hash2',
-   'http://example.com/b//c//d;p?q#hash2'],
-  ['http://example.com/b//c//d;p?q#blarg',
-   'http:/p/a/t/h?s#hash2',
-   'http://example.com/p/a/t/h?s#hash2'],
-  ['http://example.com/b//c//d;p?q#blarg',
-   'http://u:p@h.com/p/a/t/h?s#hash2',
-   'http://u:p@h.com/p/a/t/h?s#hash2'],
-  ['http://example.com/b//c//d;p?q#blarg',
-   'http:/a/b/c/d',
-   'http://example.com/a/b/c/d'],
+  [
+    'http://example.com/b//c//d;p?q#blarg',
+    'https:/p/a/t/h?s#hash2',
+    'https://p/a/t/h?s#hash2'
+  ],
+  [
+    'http://example.com/b//c//d;p?q#blarg',
+    'https://u:p@h.com/p/a/t/h?s#hash2',
+    'https://u:p@h.com/p/a/t/h?s#hash2'
+  ],
+  ['http://example.com/b//c//d;p?q#blarg', 'https:/a/b/c/d', 'https://a/b/c/d'],
+  [
+    'http://example.com/b//c//d;p?q#blarg',
+    'http:#hash2',
+    'http://example.com/b//c//d;p?q#hash2'
+  ],
+  [
+    'http://example.com/b//c//d;p?q#blarg',
+    'http:/p/a/t/h?s#hash2',
+    'http://example.com/p/a/t/h?s#hash2'
+  ],
+  [
+    'http://example.com/b//c//d;p?q#blarg',
+    'http://u:p@h.com/p/a/t/h?s#hash2',
+    'http://u:p@h.com/p/a/t/h?s#hash2'
+  ],
+  [
+    'http://example.com/b//c//d;p?q#blarg',
+    'http:/a/b/c/d',
+    'http://example.com/a/b/c/d'
+  ],
   ['/foo/bar/baz', '/../etc/passwd', '/etc/passwd'],
   ['http://localhost', 'file:///Users/foo', 'file:///Users/foo'],
   ['http://localhost', 'file://foo/Users', 'file://foo/Users']
@@ -59,9 +69,12 @@ const relativeTests = [
 relativeTests.forEach(function(relativeTest) {
   const a = url.resolve(relativeTest[0], relativeTest[1]);
   const e = relativeTest[2];
-  assert.strictEqual(a, e,
-                     `resolve(${relativeTest[0]}, ${relativeTest[1]})` +
-                     ` == ${e}\n  actual=${a}`);
+  assert.strictEqual(
+    a,
+    e,
+    `resolve(${relativeTest[0]}, ${relativeTest[1]})` +
+      ` == ${e}\n  actual=${a}`
+  );
 });
 
 //
@@ -200,8 +213,8 @@ const relativeTests2 = [
   ['g', bases[3], 'fred:///s//a/b/g'],
   ['./g', bases[3], 'fred:///s//a/b/g'],
   ['g/', bases[3], 'fred:///s//a/b/g/'],
-  ['/g', bases[3], 'fred:///g'],  // may change to fred:///s//a/g
-  ['//g', bases[3], 'fred://g'],   // may change to fred:///s//g
+  ['/g', bases[3], 'fred:///g'], // may change to fred:///s//a/g
+  ['//g', bases[3], 'fred://g'], // may change to fred:///s//g
   ['//g/x', bases[3], 'fred://g/x'], // may change to fred:///s//g/x
   ['///g', bases[3], 'fred:///g'],
   ['./', bases[3], 'fred:///s//a/b/'],
@@ -220,8 +233,8 @@ const relativeTests2 = [
   ['g', bases[4], 'http:///s//a/b/g'],
   ['./g', bases[4], 'http:///s//a/b/g'],
   ['g/', bases[4], 'http:///s//a/b/g/'],
-  ['/g', bases[4], 'http:///g'],  // may change to http:///s//a/g
-  ['//g', bases[4], 'http://g/'],   // may change to http:///s//g
+  ['/g', bases[4], 'http:///g'], // may change to http:///s//a/g
+  ['//g', bases[4], 'http://g/'], // may change to http:///s//g
   ['//g/x', bases[4], 'http://g/x'], // may change to http:///s//g/x
   ['///g', bases[4], 'http:///g'],
   ['./', bases[4], 'http:///s//a/b/'],
@@ -247,9 +260,11 @@ const relativeTests2 = [
   ['', 'http://ex/x/y/', 'http://ex/x/y/'],
   ['', 'http://ex/x/y/pdq', 'http://ex/x/y/pdq'],
   ['z/', 'http://ex/x/y/', 'http://ex/x/y/z/'],
-  ['#Animal',
-   'file:/swap/test/animal.rdf',
-   'file:/swap/test/animal.rdf#Animal'],
+  [
+    '#Animal',
+    'file:/swap/test/animal.rdf',
+    'file:/swap/test/animal.rdf#Animal'
+  ],
   ['../abc', 'file:/e/x/y/z', 'file:/e/x/abc'],
   ['/example/x/abc', 'file:/example2/x/y/z', 'file:/example/x/abc'],
   ['../r', 'file:/ex/x/y/z', 'file:/ex/x/r'],
@@ -263,18 +278,21 @@ const relativeTests2 = [
   ['', 'file:/ex/x/y/', 'file:/ex/x/y/'],
   ['', 'file:/ex/x/y/pdq', 'file:/ex/x/y/pdq'],
   ['z/', 'file:/ex/x/y/', 'file:/ex/x/y/z/'],
-  ['file://meetings.example.com/cal#m1',
-   'file:/devel/WWW/2000/10/swap/test/reluri-1.n3',
-   'file://meetings.example.com/cal#m1'],
-  ['file://meetings.example.com/cal#m1',
-   'file:/home/connolly/w3ccvs/WWW/2000/10/swap/test/reluri-1.n3',
-   'file://meetings.example.com/cal#m1'],
+  [
+    'file://meetings.example.com/cal#m1',
+    'file:/devel/WWW/2000/10/swap/test/reluri-1.n3',
+    'file://meetings.example.com/cal#m1'
+  ],
+  [
+    'file://meetings.example.com/cal#m1',
+    'file:/home/connolly/w3ccvs/WWW/2000/10/swap/test/reluri-1.n3',
+    'file://meetings.example.com/cal#m1'
+  ],
   ['./#blort', 'file:/some/dir/foo', 'file:/some/dir/#blort'],
   ['./#', 'file:/some/dir/foo', 'file:/some/dir/#'],
   // Ryan Lee
   ['./', 'http://example/x/abc.efg', 'http://example/x/'],
 
-
   // Graham Klyne's tests
   // http://www.ninebynine.org/Software/HaskellUtils/Network/UriTest.xls
   // 01-31 are from Connelly's cases
@@ -284,12 +302,16 @@ const relativeTests2 = [
   ['./p=q:r', 'http://ex/x/y', 'http://ex/x/p=q:r'],
   ['?pp/rr', 'http://ex/x/y?pp/qq', 'http://ex/x/y?pp/rr'],
   ['y/z', 'http://ex/x/y?pp/qq', 'http://ex/x/y/z'],
-  ['local/qual@domain.org#frag',
-   'mailto:local',
-   'mailto:local/qual@domain.org#frag'],
-  ['more/qual2@domain2.org#frag',
-   'mailto:local/qual1@domain1.org',
-   'mailto:local/more/qual2@domain2.org#frag'],
+  [
+    'local/qual@domain.org#frag',
+    'mailto:local',
+    'mailto:local/qual@domain.org#frag'
+  ],
+  [
+    'more/qual2@domain2.org#frag',
+    'mailto:local/qual1@domain1.org',
+    'mailto:local/more/qual2@domain2.org#frag'
+  ],
   ['y?q', 'http://ex/x/y?q', 'http://ex/x/y?q'],
   ['/x/y?q', 'http://ex?p', 'http://ex/x/y?q'],
   ['c/d', 'foo:a/b', 'foo:a/c/d'],
@@ -317,12 +339,16 @@ const relativeTests2 = [
 
   // 70-77
   ['local2@domain2', 'mailto:local1@domain1?query1', 'mailto:local2@domain2'],
-  ['local2@domain2?query2',
-   'mailto:local1@domain1',
-   'mailto:local2@domain2?query2'],
-  ['local2@domain2?query2',
-   'mailto:local1@domain1?query1',
-   'mailto:local2@domain2?query2'],
+  [
+    'local2@domain2?query2',
+    'mailto:local1@domain1',
+    'mailto:local2@domain2?query2'
+  ],
+  [
+    'local2@domain2?query2',
+    'mailto:local1@domain1?query1',
+    'mailto:local2@domain2?query2'
+  ],
   ['?query2', 'mailto:local@domain?query1', 'mailto:local@domain?query2'],
   ['local@domain?query2', 'mailto:?query1', 'mailto:local@domain?query2'],
   ['?query2', 'mailto:local@domain?query1', 'mailto:local@domain?query2'],
@@ -337,40 +363,58 @@ const relativeTests2 = [
   ['http:this', 'http:base', 'http:this'],
   ['.//g', 'f:/a', 'f://g'],
   ['b/c//d/e', 'f://example.org/base/a', 'f://example.org/base/b/c//d/e'],
-  ['m2@example.ord/c2@example.org',
-   'mid:m@example.ord/c@example.org',
-   'mid:m@example.ord/m2@example.ord/c2@example.org'],
-  ['mini1.xml',
-   'file:///C:/DEV/Haskell/lib/HXmlToolbox-3.01/examples/',
-   'file:///C:/DEV/Haskell/lib/HXmlToolbox-3.01/examples/mini1.xml'],
+  [
+    'm2@example.ord/c2@example.org',
+    'mid:m@example.ord/c@example.org',
+    'mid:m@example.ord/m2@example.ord/c2@example.org'
+  ],
+  [
+    'mini1.xml',
+    'file:///C:/DEV/Haskell/lib/HXmlToolbox-3.01/examples/',
+    'file:///C:/DEV/Haskell/lib/HXmlToolbox-3.01/examples/mini1.xml'
+  ],
   ['../b/c', 'foo:a/y/z', 'foo:a/b/c'],
 
   // changeing auth
-  ['http://diff:auth@www.example.com',
-   'http://asdf:qwer@www.example.com',
-   'http://diff:auth@www.example.com/'],
+  [
+    'http://diff:auth@www.example.com',
+    'http://asdf:qwer@www.example.com',
+    'http://diff:auth@www.example.com/'
+  ],
 
   // changing port
-  ['https://example.com:81/',
-   'https://example.com:82/',
-   'https://example.com:81/'],
+  [
+    'https://example.com:81/',
+    'https://example.com:82/',
+    'https://example.com:81/'
+  ],
 
   // https://github.com/nodejs/node/issues/1435
-  ['https://another.host.com/',
-   'https://user:password@example.org/',
-   'https://another.host.com/'],
-  ['//another.host.com/',
-   'https://user:password@example.org/',
-   'https://another.host.com/'],
-  ['http://another.host.com/',
-   'https://user:password@example.org/',
-   'http://another.host.com/'],
-  ['mailto:another.host.com',
-   'mailto:user@example.org',
-   'mailto:another.host.com'],
-  ['https://example.com/foo',
-   'https://user:password@example.com',
-   'https://user:password@example.com/foo'],
+  [
+    'https://another.host.com/',
+    'https://user:password@example.org/',
+    'https://another.host.com/'
+  ],
+  [
+    '//another.host.com/',
+    'https://user:password@example.org/',
+    'https://another.host.com/'
+  ],
+  [
+    'http://another.host.com/',
+    'https://user:password@example.org/',
+    'http://another.host.com/'
+  ],
+  [
+    'mailto:another.host.com',
+    'mailto:user@example.org',
+    'mailto:another.host.com'
+  ],
+  [
+    'https://example.com/foo',
+    'https://user:password@example.com',
+    'https://user:password@example.com/foo'
+  ],
 
   // No path at all
   ['#hash1', '#hash2', '#hash1']
@@ -378,9 +422,12 @@ const relativeTests2 = [
 relativeTests2.forEach(function(relativeTest) {
   const a = url.resolve(relativeTest[1], relativeTest[0]);
   const e = url.format(relativeTest[2]);
-  assert.strictEqual(a, e,
-                     `resolve(${relativeTest[0]}, ${relativeTest[1]})` +
-                     ` == ${e}\n  actual=${a}`);
+  assert.strictEqual(
+    a,
+    e,
+    `resolve(${relativeTest[0]}, ${relativeTest[1]})` +
+      ` == ${e}\n  actual=${a}`
+  );
 });
 
 // If format and parse are inverse operations then
@@ -391,15 +438,16 @@ relativeTests.forEach(function(relativeTest) {
   let actual = url.resolveObject(url.parse(relativeTest[0]), relativeTest[1]);
   let expected = url.parse(relativeTest[2]);
 
-
   assert.deepStrictEqual(actual, expected);
 
   expected = relativeTest[2];
   actual = url.format(actual);
 
-  assert.strictEqual(actual, expected,
-                     `format(${actual}) == ${expected}\n` +
-                     `actual: ${actual}`);
+  assert.strictEqual(
+    actual,
+    expected,
+    `format(${actual}) == ${expected}\n` + `actual: ${actual}`
+  );
 });
 
 // format: [to, from, result]
@@ -411,9 +459,11 @@ relativeTests.forEach(function(relativeTest) {
 // it is unclear to me how to keep this information from being lost
 // it may be that a pathname of ////g should collapse to /g but this seems
 // to be a lot of work for an edge case.  Right now I remove the test
-if (relativeTests2[181][0] === './/g' &&
-    relativeTests2[181][1] === 'f:/a' &&
-    relativeTests2[181][2] === 'f://g') {
+if (
+  relativeTests2[181][0] === './/g' &&
+  relativeTests2[181][1] === 'f:/a' &&
+  relativeTests2[181][2] === 'f://g'
+) {
   relativeTests2.splice(181, 1);
 }
 relativeTests2.forEach(function(relativeTest) {
@@ -429,7 +479,9 @@ relativeTests2.forEach(function(relativeTest) {
   expected = url.format(relativeTest[2]);
   actual = url.format(actual);
 
-  assert.strictEqual(actual, expected,
-                     `format(${relativeTest[1]}) == ${expected}\n` +
-                     `actual: ${actual}`);
+  assert.strictEqual(
+    actual,
+    expected,
+    `format(${relativeTest[1]}) == ${expected}\n` + `actual: ${actual}`
+  );
 });
diff --git a/test/parallel/test-util-callbackify.js b/test/parallel/test-util-callbackify.js
index 9be3b132f95172..4b57a12839439b 100644
--- a/test/parallel/test-util-callbackify.js
+++ b/test/parallel/test-util-callbackify.js
@@ -32,10 +32,12 @@ const values = [
     }
 
     const cbAsyncFn = callbackify(asyncFn);
-    cbAsyncFn(common.mustCall((err, ret) => {
-      assert.ifError(err);
-      assert.strictEqual(ret, value);
-    }));
+    cbAsyncFn(
+      common.mustCall((err, ret) => {
+        assert.ifError(err);
+        assert.strictEqual(ret, value);
+      })
+    );
 
     // Test Promise factory
     function promiseFn() {
@@ -43,10 +45,12 @@ const values = [
     }
 
     const cbPromiseFn = callbackify(promiseFn);
-    cbPromiseFn(common.mustCall((err, ret) => {
-      assert.ifError(err);
-      assert.strictEqual(ret, value);
-    }));
+    cbPromiseFn(
+      common.mustCall((err, ret) => {
+        assert.ifError(err);
+        assert.strictEqual(ret, value);
+      })
+    );
 
     // Test Thenable
     function thenableFn() {
@@ -58,10 +62,12 @@ const values = [
     }
 
     const cbThenableFn = callbackify(thenableFn);
-    cbThenableFn(common.mustCall((err, ret) => {
-      assert.ifError(err);
-      assert.strictEqual(ret, value);
-    }));
+    cbThenableFn(
+      common.mustCall((err, ret) => {
+        assert.ifError(err);
+        assert.strictEqual(ret, value);
+      })
+    );
   }
 }
 
@@ -74,20 +80,22 @@ const values = [
     }
 
     const cbAsyncFn = callbackify(asyncFn);
-    cbAsyncFn(common.mustCall((err, ret) => {
-      assert.strictEqual(ret, undefined);
-      if (err instanceof Error) {
-        if ('reason' in err) {
-          assert(!value);
-          assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
-          assert.strictEqual(err.reason, value);
+    cbAsyncFn(
+      common.mustCall((err, ret) => {
+        assert.strictEqual(ret, undefined);
+        if (err instanceof Error) {
+          if ('reason' in err) {
+            assert(!value);
+            assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
+            assert.strictEqual(err.reason, value);
+          } else {
+            assert.strictEqual(String(value).endsWith(err.message), true);
+          }
         } else {
-          assert.strictEqual(String(value).endsWith(err.message), true);
+          assert.strictEqual(err, value);
         }
-      } else {
-        assert.strictEqual(err, value);
-      }
-    }));
+      })
+    );
 
     // test a Promise factory
     function promiseFn() {
@@ -95,20 +103,22 @@ const values = [
     }
 
     const cbPromiseFn = callbackify(promiseFn);
-    cbPromiseFn(common.mustCall((err, ret) => {
-      assert.strictEqual(ret, undefined);
-      if (err instanceof Error) {
-        if ('reason' in err) {
-          assert(!value);
-          assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
-          assert.strictEqual(err.reason, value);
+    cbPromiseFn(
+      common.mustCall((err, ret) => {
+        assert.strictEqual(ret, undefined);
+        if (err instanceof Error) {
+          if ('reason' in err) {
+            assert(!value);
+            assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
+            assert.strictEqual(err.reason, value);
+          } else {
+            assert.strictEqual(String(value).endsWith(err.message), true);
+          }
         } else {
-          assert.strictEqual(String(value).endsWith(err.message), true);
+          assert.strictEqual(err, value);
         }
-      } else {
-        assert.strictEqual(err, value);
-      }
-    }));
+      })
+    );
 
     // Test Thenable
     function thenableFn() {
@@ -120,20 +130,22 @@ const values = [
     }
 
     const cbThenableFn = callbackify(thenableFn);
-    cbThenableFn(common.mustCall((err, ret) => {
-      assert.strictEqual(ret, undefined);
-      if (err instanceof Error) {
-        if ('reason' in err) {
-          assert(!value);
-          assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
-          assert.strictEqual(err.reason, value);
+    cbThenableFn(
+      common.mustCall((err, ret) => {
+        assert.strictEqual(ret, undefined);
+        if (err instanceof Error) {
+          if ('reason' in err) {
+            assert(!value);
+            assert.strictEqual(err.code, 'ERR_FALSY_VALUE_REJECTION');
+            assert.strictEqual(err.reason, value);
+          } else {
+            assert.strictEqual(String(value).endsWith(err.message), true);
+          }
         } else {
-          assert.strictEqual(String(value).endsWith(err.message), true);
+          assert.strictEqual(err, value);
         }
-      } else {
-        assert.strictEqual(err, value);
-      }
-    }));
+      })
+    );
   }
 }
 
@@ -146,10 +158,13 @@ const values = [
     }
 
     const cbAsyncFn = callbackify(asyncFn);
-    cbAsyncFn(value, common.mustCall((err, ret) => {
-      assert.ifError(err);
-      assert.strictEqual(ret, value);
-    }));
+    cbAsyncFn(
+      value,
+      common.mustCall((err, ret) => {
+        assert.ifError(err);
+        assert.strictEqual(ret, value);
+      })
+    );
 
     function promiseFn(arg) {
       assert.strictEqual(arg, value);
@@ -157,10 +172,13 @@ const values = [
     }
 
     const cbPromiseFn = callbackify(promiseFn);
-    cbPromiseFn(value, common.mustCall((err, ret) => {
-      assert.ifError(err);
-      assert.strictEqual(ret, value);
-    }));
+    cbPromiseFn(
+      value,
+      common.mustCall((err, ret) => {
+        assert.ifError(err);
+        assert.strictEqual(ret, value);
+      })
+    );
   }
 }
 
@@ -171,27 +189,33 @@ const values = [
       fn(arg) {
         assert.strictEqual(this, iAmThis);
         return Promise.resolve(arg);
-      },
+      }
     };
     iAmThis.cbFn = callbackify(iAmThis.fn);
-    iAmThis.cbFn(value, common.mustCall(function(err, ret) {
-      assert.ifError(err);
-      assert.strictEqual(ret, value);
-      assert.strictEqual(this, iAmThis);
-    }));
+    iAmThis.cbFn(
+      value,
+      common.mustCall(function(err, ret) {
+        assert.ifError(err);
+        assert.strictEqual(ret, value);
+        assert.strictEqual(this, iAmThis);
+      })
+    );
 
     const iAmThat = {
       async fn(arg) {
         assert.strictEqual(this, iAmThat);
         return arg;
-      },
+      }
     };
     iAmThat.cbFn = callbackify(iAmThat.fn);
-    iAmThat.cbFn(value, common.mustCall(function(err, ret) {
-      assert.ifError(err);
-      assert.strictEqual(ret, value);
-      assert.strictEqual(this, iAmThat);
-    }));
+    iAmThat.cbFn(
+      value,
+      common.mustCall(function(err, ret) {
+        assert.ifError(err);
+        assert.strictEqual(ret, value);
+        assert.strictEqual(this, iAmThat);
+      })
+    );
   }
 }
 
@@ -222,7 +246,8 @@ const values = [
       assert.ifError(err);
       assert.strictEqual(
         stdout.trim(),
-        `ifError got unwanted exception: ${fixture}`);
+        `ifError got unwanted exception: ${fixture}`
+      );
       assert.strictEqual(stderr, '');
     })
   );
@@ -231,14 +256,18 @@ const values = [
 {
   // Verify that non-function inputs throw.
   ['foo', null, undefined, false, 0, {}, Symbol(), []].forEach((value) => {
-    common.expectsError(() => {
-      callbackify(value);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "original" argument must be of type Function. ' +
-               `Received type ${typeof value}`
-    });
+    common.expectsError(
+      () => {
+        callbackify(value);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The "original" argument must be of type Function. ' +
+          `Received type ${typeof value}`
+      }
+    );
   });
 }
 
@@ -253,13 +282,17 @@ const values = [
   // Verify that the last argument to the callbackified function is a function.
   ['foo', null, undefined, false, 0, {}, Symbol(), []].forEach((value) => {
     args.push(value);
-    common.expectsError(() => {
-      cb(...args);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The last argument must be of type Function. ' +
-               `Received type ${typeof value}`
-    });
+    common.expectsError(
+      () => {
+        cb(...args);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message:
+          'The last argument must be of type Function. ' +
+          `Received type ${typeof value}`
+      }
+    );
   });
 }
diff --git a/test/parallel/test-util-deprecate-invalid-code.js b/test/parallel/test-util-deprecate-invalid-code.js
index 635bab4252fb5b..f1e88f2f62307b 100644
--- a/test/parallel/test-util-deprecate-invalid-code.js
+++ b/test/parallel/test-util-deprecate-invalid-code.js
@@ -7,7 +7,8 @@ const util = require('util');
   common.expectsError(() => util.deprecate(() => {}, 'message', notString), {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
-    message: 'The "code" argument must be of type string. ' +
-             `Received type ${typeof notString}`
+    message:
+      'The "code" argument must be of type string. ' +
+      `Received type ${typeof notString}`
   });
 });
diff --git a/test/parallel/test-util-deprecate.js b/test/parallel/test-util-deprecate.js
index 1b4a5e76623743..96ce2045e36f58 100644
--- a/test/parallel/test-util-deprecate.js
+++ b/test/parallel/test-util-deprecate.js
@@ -48,8 +48,7 @@ process.on('warning', (warning) => {
   const expected = expectedWarnings.get(warning.message);
   assert.strictEqual(warning.code, expected.code);
   expected.count = expected.count - 1;
-  if (expected.count === 0)
-    expectedWarnings.delete(warning.message);
+  if (expected.count === 0) expectedWarnings.delete(warning.message);
 });
 
 process.on('exit', () => {
diff --git a/test/parallel/test-util-emit-experimental-warning.js b/test/parallel/test-util-emit-experimental-warning.js
index 1c1759a428307e..52b281350b545a 100644
--- a/test/parallel/test-util-emit-experimental-warning.js
+++ b/test/parallel/test-util-emit-experimental-warning.js
@@ -8,9 +8,12 @@ const { emitExperimentalWarning } = require('internal/util');
 // warning when passed an unsupported feature and that it simply returns
 // when passed the same feature multiple times.
 
-process.on('warning', common.mustCall((warning) => {
-  assert(/is an experimental feature/.test(warning.message));
-}, 2));
+process.on(
+  'warning',
+  common.mustCall((warning) => {
+    assert(/is an experimental feature/.test(warning.message));
+  }, 2)
+);
 
 emitExperimentalWarning('feature1');
 emitExperimentalWarning('feature1'); // should not warn
diff --git a/test/parallel/test-util-format.js b/test/parallel/test-util-format.js
index 2ca8e0857f3aad..eed806faaca5b6 100644
--- a/test/parallel/test-util-format.js
+++ b/test/parallel/test-util-format.js
@@ -45,11 +45,12 @@ assert.strictEqual(util.format('foo', symbol), 'foo Symbol(foo)');
 assert.strictEqual(util.format('%s', symbol), 'Symbol(foo)');
 assert.strictEqual(util.format('%j', symbol), 'undefined');
 assert.throws(
-  () => { util.format('%d', symbol); },
+  () => {
+    util.format('%d', symbol);
+  },
   (e) => {
     // The error should be a TypeError.
-    if (!(e instanceof TypeError))
-      return false;
+    if (!(e instanceof TypeError)) return false;
 
     // The error should be from the JS engine and not from Node.js.
     // JS engine errors do not have the `code` property.
@@ -92,10 +93,7 @@ assert.strictEqual(util.format('%i', -0.5), '0');
 assert.strictEqual(util.format('%i', ''), 'NaN');
 assert.strictEqual(util.format('%i %i', 42, 43), '42 43');
 assert.strictEqual(util.format('%i %i', 42), '42 %i');
-assert.strictEqual(
-  util.format('%i', 1180591620717411303424),
-  '1'
-);
+assert.strictEqual(util.format('%i', 1180591620717411303424), '1');
 assert.strictEqual(
   util.format('%i', 1180591620717411303424n),
   '1180591620717411303424n'
@@ -164,79 +162,88 @@ const nestedObj2 = {
 };
 assert.strictEqual(util.format('%o'), '%o');
 assert.strictEqual(util.format('%o', 42), '42');
-assert.strictEqual(util.format('%o', 'foo'), '\'foo\'');
+assert.strictEqual(util.format('%o', 'foo'), "'foo'");
 assert.strictEqual(
   util.format('%o', obj),
-  '{ foo: \'bar\',\n' +
-  '  foobar: 1,\n' +
-  '  func:\n' +
-  '   { [Function: func]\n' +
-  '     [length]: 0,\n' +
-  '     [name]: \'func\',\n' +
-  '     [prototype]: func { [constructor]: [Circular] } } }');
+  "{ foo: 'bar',\n" +
+    '  foobar: 1,\n' +
+    '  func:\n' +
+    '   { [Function: func]\n' +
+    '     [length]: 0,\n' +
+    "     [name]: 'func',\n" +
+    '     [prototype]: func { [constructor]: [Circular] } } }'
+);
 assert.strictEqual(
   util.format('%o', nestedObj2),
-  '{ foo: \'bar\',\n' +
-  '  foobar: 1,\n' +
-  '  func:\n' +
-  '   [ { a:\n' +
-  '        { [Function: a]\n' +
-  '          [length]: 0,\n' +
-  '          [name]: \'a\',\n' +
-  '          [prototype]: a { [constructor]: [Circular] } } },\n' +
-  '     [length]: 1 ] }');
+  "{ foo: 'bar',\n" +
+    '  foobar: 1,\n' +
+    '  func:\n' +
+    '   [ { a:\n' +
+    '        { [Function: a]\n' +
+    '          [length]: 0,\n' +
+    "          [name]: 'a',\n" +
+    '          [prototype]: a { [constructor]: [Circular] } } },\n' +
+    '     [length]: 1 ] }'
+);
 assert.strictEqual(
   util.format('%o', nestedObj),
-  '{ foo: \'bar\',\n' +
-  '  foobar:\n' +
-  '   { foo: \'bar\',\n' +
-  '     func:\n' +
-  '      { [Function: func]\n' +
-  '        [length]: 0,\n' +
-  '        [name]: \'func\',\n' +
-  '        [prototype]: func { [constructor]: [Circular] } } } }');
+  "{ foo: 'bar',\n" +
+    '  foobar:\n' +
+    "   { foo: 'bar',\n" +
+    '     func:\n' +
+    '      { [Function: func]\n' +
+    '        [length]: 0,\n' +
+    "        [name]: 'func',\n" +
+    '        [prototype]: func { [constructor]: [Circular] } } } }'
+);
 assert.strictEqual(
   util.format('%o %o', obj, obj),
-  '{ foo: \'bar\',\n' +
-  '  foobar: 1,\n' +
-  '  func:\n' +
-  '   { [Function: func]\n' +
-  '     [length]: 0,\n' +
-  '     [name]: \'func\',\n' +
-  '     [prototype]: func { [constructor]: [Circular] } } }' +
-  ' { foo: \'bar\',\n' +
-  '  foobar: 1,\n' +
-  '  func:\n' +
-  '   { [Function: func]\n' +
-  '     [length]: 0,\n' +
-  '     [name]: \'func\',\n' +
-  '     [prototype]: func { [constructor]: [Circular] } } }');
+  "{ foo: 'bar',\n" +
+    '  foobar: 1,\n' +
+    '  func:\n' +
+    '   { [Function: func]\n' +
+    '     [length]: 0,\n' +
+    "     [name]: 'func',\n" +
+    '     [prototype]: func { [constructor]: [Circular] } } }' +
+    " { foo: 'bar',\n" +
+    '  foobar: 1,\n' +
+    '  func:\n' +
+    '   { [Function: func]\n' +
+    '     [length]: 0,\n' +
+    "     [name]: 'func',\n" +
+    '     [prototype]: func { [constructor]: [Circular] } } }'
+);
 assert.strictEqual(
   util.format('%o %o', obj),
-  '{ foo: \'bar\',\n' +
-  '  foobar: 1,\n' +
-  '  func:\n' +
-  '   { [Function: func]\n' +
-  '     [length]: 0,\n' +
-  '     [name]: \'func\',\n' +
-  '     [prototype]: func { [constructor]: [Circular] } } } %o');
+  "{ foo: 'bar',\n" +
+    '  foobar: 1,\n' +
+    '  func:\n' +
+    '   { [Function: func]\n' +
+    '     [length]: 0,\n' +
+    "     [name]: 'func',\n" +
+    '     [prototype]: func { [constructor]: [Circular] } } } %o'
+);
 
 assert.strictEqual(util.format('%O'), '%O');
 assert.strictEqual(util.format('%O', 42), '42');
-assert.strictEqual(util.format('%O', 'foo'), '\'foo\'');
+assert.strictEqual(util.format('%O', 'foo'), "'foo'");
 assert.strictEqual(
   util.format('%O', obj),
-  '{ foo: \'bar\', foobar: 1, func: [Function: func] }');
+  "{ foo: 'bar', foobar: 1, func: [Function: func] }"
+);
 assert.strictEqual(
   util.format('%O', nestedObj),
-  '{ foo: \'bar\', foobar: { foo: \'bar\', func: [Function: func] } }');
+  "{ foo: 'bar', foobar: { foo: 'bar', func: [Function: func] } }"
+);
 assert.strictEqual(
   util.format('%O %O', obj, obj),
-  '{ foo: \'bar\', foobar: 1, func: [Function: func] } ' +
-  '{ foo: \'bar\', foobar: 1, func: [Function: func] }');
+  "{ foo: 'bar', foobar: 1, func: [Function: func] } " +
+    "{ foo: 'bar', foobar: 1, func: [Function: func] }"
+);
 assert.strictEqual(
   util.format('%O %O', obj),
-  '{ foo: \'bar\', foobar: 1, func: [Function: func] } %O');
+  "{ foo: 'bar', foobar: 1, func: [Function: func] } %O"
+);
 
 // Various format specifiers
 assert.strictEqual(util.format('%%s%s', 'foo'), '%sfoo');
@@ -266,11 +273,12 @@ assert.strictEqual(util.format('o: %o, a: %O', {}, []), 'o: {}, a: []');
 assert.strictEqual(util.format('o: %o, a: %o', {}), 'o: {}, a: %o');
 assert.strictEqual(util.format('o: %O, a: %O'), 'o: %O, a: %O');
 
-
 // Invalid format specifiers
 assert.strictEqual(util.format('a% b', 'x'), 'a% b x');
-assert.strictEqual(util.format('percent: %d%, fraction: %d', 10, 0.1),
-                   'percent: 10%, fraction: 0.1');
+assert.strictEqual(
+  util.format('percent: %d%, fraction: %d', 10, 0.1),
+  'percent: 10%, fraction: 0.1'
+);
 assert.strictEqual(util.format('abc%', 1), 'abc% 1');
 
 // Additional arguments after format specifiers
@@ -289,8 +297,10 @@ assert.strictEqual(util.format('%i', 1, () => {}), '1 [Function]');
       throw new Error('Not a circular object but still not serializable');
     }
   };
-  assert.throws(() => util.format('%j', o),
-                /^Error: Not a circular object but still not serializable$/);
+  assert.throws(
+    () => util.format('%j', o),
+    /^Error: Not a circular object but still not serializable$/
+  );
 }
 
 // Errors
@@ -299,10 +309,11 @@ assert.strictEqual(util.format(err), err.stack);
 class CustomError extends Error {
   constructor(msg) {
     super();
-    Object.defineProperty(this, 'message',
-                          { value: msg, enumerable: false });
-    Object.defineProperty(this, 'name',
-                          { value: 'CustomError', enumerable: false });
+    Object.defineProperty(this, 'message', { value: msg, enumerable: false });
+    Object.defineProperty(this, 'name', {
+      value: 'CustomError',
+      enumerable: false
+    });
     Error.captureStackTrace(this, CustomError);
   }
 }
@@ -311,14 +322,17 @@ assert.strictEqual(util.format(customError), customError.stack);
 // Doesn't capture stack trace
 function BadCustomError(msg) {
   Error.call(this);
-  Object.defineProperty(this, 'message',
-                        { value: msg, enumerable: false });
-  Object.defineProperty(this, 'name',
-                        { value: 'BadCustomError', enumerable: false });
+  Object.defineProperty(this, 'message', { value: msg, enumerable: false });
+  Object.defineProperty(this, 'name', {
+    value: 'BadCustomError',
+    enumerable: false
+  });
 }
 util.inherits(BadCustomError, Error);
-assert.strictEqual(util.format(new BadCustomError('foo')),
-                   '[BadCustomError: foo]');
+assert.strictEqual(
+  util.format(new BadCustomError('foo')),
+  '[BadCustomError: foo]'
+);
 
 // The format of arguments should not depend on type of the first argument
 assert.strictEqual(util.format('1', '1'), '1 1');
diff --git a/test/parallel/test-util-inherits.js b/test/parallel/test-util-inherits.js
index 9bbb4352dc3853..6e688eb52b8844 100644
--- a/test/parallel/test-util-inherits.js
+++ b/test/parallel/test-util-inherits.js
@@ -8,7 +8,9 @@ const { inherits } = require('util');
 function A() {
   this._a = 'a';
 }
-A.prototype.a = function() { return this._a; };
+A.prototype.a = function() {
+  return this._a;
+};
 
 // One level of inheritance
 function B(value) {
@@ -16,17 +18,16 @@ function B(value) {
   this._b = value;
 }
 inherits(B, A);
-B.prototype.b = function() { return this._b; };
-
-assert.deepStrictEqual(
-  Object.getOwnPropertyDescriptor(B, 'super_'),
-  {
-    value: A,
-    enumerable: false,
-    configurable: true,
-    writable: true
-  }
-);
+B.prototype.b = function() {
+  return this._b;
+};
+
+assert.deepStrictEqual(Object.getOwnPropertyDescriptor(B, 'super_'), {
+  value: A,
+  enumerable: false,
+  configurable: true,
+  writable: true
+});
 
 const b = new B('b');
 assert.strictEqual(b.a(), 'a');
@@ -39,8 +40,12 @@ function C() {
   this._c = 'c';
 }
 inherits(C, B);
-C.prototype.c = function() { return this._c; };
-C.prototype.getValue = function() { return this.a() + this.b() + this.c(); };
+C.prototype.c = function() {
+  return this._c;
+};
+C.prototype.getValue = function() {
+  return this.a() + this.b() + this.c();
+};
 
 assert.strictEqual(C.super_, B);
 
@@ -54,7 +59,9 @@ function D() {
   this._d = 'd';
 }
 
-D.prototype.d = function() { return this._d; };
+D.prototype.d = function() {
+  return this._d;
+};
 inherits(D, C);
 
 assert.strictEqual(D.super_, C);
@@ -70,7 +77,9 @@ class E {
     D.call(this);
     this._e = 'e';
   }
-  e() { return this._e; }
+  e() {
+    return this._e;
+  }
 }
 inherits(E, D);
 
@@ -83,28 +92,40 @@ assert.strictEqual(e.e(), 'e');
 assert.strictEqual(e.constructor, E);
 
 // Should throw with invalid arguments
-common.expectsError(function() {
-  inherits(A, {});
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "superCtor.prototype" property must be of type Function. ' +
-           'Received type undefined'
-});
+common.expectsError(
+  function() {
+    inherits(A, {});
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "superCtor.prototype" property must be of type Function. ' +
+      'Received type undefined'
+  }
+);
 
-common.expectsError(function() {
-  inherits(A, null);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "superCtor" argument must be of type Function. ' +
-           'Received type object'
-});
+common.expectsError(
+  function() {
+    inherits(A, null);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "superCtor" argument must be of type Function. ' +
+      'Received type object'
+  }
+);
 
-common.expectsError(function() {
-  inherits(null, A);
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "ctor" argument must be of type Function. Received type object'
-});
+common.expectsError(
+  function() {
+    inherits(null, A);
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "ctor" argument must be of type Function. Received type object'
+  }
+);
diff --git a/test/parallel/test-util-inspect-namespace.js b/test/parallel/test-util-inspect-namespace.js
index f2b6e57178b041..86ff435f37bd7e 100644
--- a/test/parallel/test-util-inspect-namespace.js
+++ b/test/parallel/test-util-inspect-namespace.js
@@ -14,7 +14,8 @@ const { inspect } = require('util');
   m.instantiate();
   assert.strictEqual(
     inspect(m.namespace),
-    '[Module] { a: <uninitialized>, b: undefined }');
+    '[Module] { a: <uninitialized>, b: undefined }'
+  );
   await m.evaluate();
   assert.strictEqual(inspect(m.namespace), '[Module] { a: 1, b: 2 }');
 })();
diff --git a/test/parallel/test-util-inspect-proxy.js b/test/parallel/test-util-inspect-proxy.js
index b3438a625240a2..33066271334269 100644
--- a/test/parallel/test-util-inspect-proxy.js
+++ b/test/parallel/test-util-inspect-proxy.js
@@ -10,7 +10,9 @@ const opts = { showProxy: true };
 
 const target = {};
 const handler = {
-  get: function() { throw new Error('Getter should not be called'); }
+  get: function() {
+    throw new Error('Getter should not be called');
+  }
 };
 const proxyObj = new Proxy(target, handler);
 
@@ -23,8 +25,10 @@ const details = processUtil.getProxyDetails(proxyObj);
 assert.strictEqual(target, details[0]);
 assert.strictEqual(handler, details[1]);
 
-assert.strictEqual(util.inspect(proxyObj, opts),
-                   'Proxy [ {}, { get: [Function: get] } ]');
+assert.strictEqual(
+  util.inspect(proxyObj, opts),
+  'Proxy [ {}, { get: [Function: get] } ]'
+);
 
 // Using getProxyDetails with non-proxy returns undefined
 assert.strictEqual(processUtil.getProxyDetails({}), undefined);
@@ -50,16 +54,19 @@ const expected1 = 'Proxy [ {}, {} ]';
 const expected2 = 'Proxy [ Proxy [ {}, {} ], {} ]';
 const expected3 = 'Proxy [ Proxy [ Proxy [ {}, {} ], {} ], Proxy [ {}, {} ] ]';
 const expected4 = 'Proxy [ Proxy [ {}, {} ], Proxy [ Proxy [ {}, {} ], {} ] ]';
-const expected5 = 'Proxy [ Proxy [ Proxy [ Proxy [Array], {} ],' +
-                  ' Proxy [ {}, {} ] ],\n  Proxy [ Proxy [ {}, {} ]' +
-                  ', Proxy [ Proxy [Array], {} ] ] ]';
-const expected6 = 'Proxy [ Proxy [ Proxy [ Proxy [Array], Proxy [Array]' +
-                  ' ],\n    Proxy [ Proxy [Array], Proxy [Array] ] ],\n' +
-                  '  Proxy [ Proxy [ Proxy [Array], Proxy [Array] ],\n' +
-                  '    Proxy [ Proxy [Array], Proxy [Array] ] ] ]';
+const expected5 =
+  'Proxy [ Proxy [ Proxy [ Proxy [Array], {} ],' +
+  ' Proxy [ {}, {} ] ],\n  Proxy [ Proxy [ {}, {} ]' +
+  ', Proxy [ Proxy [Array], {} ] ] ]';
+const expected6 =
+  'Proxy [ Proxy [ Proxy [ Proxy [Array], Proxy [Array]' +
+  ' ],\n    Proxy [ Proxy [Array], Proxy [Array] ] ],\n' +
+  '  Proxy [ Proxy [ Proxy [Array], Proxy [Array] ],\n' +
+  '    Proxy [ Proxy [Array], Proxy [Array] ] ] ]';
 assert.strictEqual(
   util.inspect(proxy1, { showProxy: true, depth: null }),
-  expected1);
+  expected1
+);
 assert.strictEqual(util.inspect(proxy2, opts), expected2);
 assert.strictEqual(util.inspect(proxy3, opts), expected3);
 assert.strictEqual(util.inspect(proxy4, opts), expected4);
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index c0fc3219ce736f..21d57245ab4d61 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -47,7 +47,7 @@ assert.strictEqual(
   util.inspect(new Date('Sun, 14 Feb 2010 11:48:40 GMT')),
   new Date('2010-02-14T12:48:40+01:00').toISOString()
 );
-assert.strictEqual(util.inspect(new Date('')), (new Date('')).toString());
+assert.strictEqual(util.inspect(new Date('')), new Date('').toString());
 assert.strictEqual(util.inspect('\n\u0001'), "'\\n\\u0001'");
 assert.strictEqual(
   util.inspect(`${Array(75).fill(1)}'\n\u001d\n\u0003`),
@@ -61,27 +61,42 @@ assert.strictEqual(util.inspect({}), '{}');
 assert.strictEqual(util.inspect({ a: 1 }), '{ a: 1 }');
 assert.strictEqual(util.inspect({ a: function() {} }), '{ a: [Function: a] }');
 assert.strictEqual(util.inspect({ a: () => {} }), '{ a: [Function: a] }');
-assert.strictEqual(util.inspect({ a: async function() {} }),
-                   '{ a: [AsyncFunction: a] }');
-assert.strictEqual(util.inspect({ a: async () => {} }),
-                   '{ a: [AsyncFunction: a] }');
-assert.strictEqual(util.inspect({ a: function*() {} }),
-                   '{ a: [GeneratorFunction: a] }');
+assert.strictEqual(
+  util.inspect({ a: async function() {} }),
+  '{ a: [AsyncFunction: a] }'
+);
+assert.strictEqual(
+  util.inspect({ a: async () => {} }),
+  '{ a: [AsyncFunction: a] }'
+);
+assert.strictEqual(
+  util.inspect({ a: function*() {} }),
+  '{ a: [GeneratorFunction: a] }'
+);
 assert.strictEqual(util.inspect({ a: 1, b: 2 }), '{ a: 1, b: 2 }');
-assert.strictEqual(util.inspect({ 'a': {} }), '{ a: {} }');
-assert.strictEqual(util.inspect({ 'a': { 'b': 2 } }), '{ a: { b: 2 } }');
-assert.strictEqual(util.inspect({ 'a': { 'b': { 'c': { 'd': 2 } } } }),
-                   '{ a: { b: { c: [Object] } } }');
+assert.strictEqual(util.inspect({ a: {} }), '{ a: {} }');
+assert.strictEqual(util.inspect({ a: { b: 2 } }), '{ a: { b: 2 } }');
 assert.strictEqual(
-  util.inspect({ 'a': { 'b': { 'c': { 'd': 2 } } } }, false, null),
-  '{ a: { b: { c: { d: 2 } } } }');
+  util.inspect({ a: { b: { c: { d: 2 } } } }),
+  '{ a: { b: { c: [Object] } } }'
+);
+assert.strictEqual(
+  util.inspect({ a: { b: { c: { d: 2 } } } }, false, null),
+  '{ a: { b: { c: { d: 2 } } } }'
+);
 assert.strictEqual(util.inspect([1, 2, 3], true), '[ 1, 2, 3, [length]: 3 ]');
-assert.strictEqual(util.inspect({ 'a': { 'b': { 'c': 2 } } }, false, 0),
-                   '{ a: [Object] }');
-assert.strictEqual(util.inspect({ 'a': { 'b': { 'c': 2 } } }, false, 1),
-                   '{ a: { b: [Object] } }');
-assert.strictEqual(util.inspect({ 'a': { 'b': ['c'] } }, false, 1),
-                   '{ a: { b: [Array] } }');
+assert.strictEqual(
+  util.inspect({ a: { b: { c: 2 } } }, false, 0),
+  '{ a: [Object] }'
+);
+assert.strictEqual(
+  util.inspect({ a: { b: { c: 2 } } }, false, 1),
+  '{ a: { b: [Object] } }'
+);
+assert.strictEqual(
+  util.inspect({ a: { b: ['c'] } }, false, 1),
+  '{ a: { b: [Array] } }'
+);
 assert.strictEqual(util.inspect(new Uint8Array(0)), 'Uint8Array []');
 assert(inspect(new Uint8Array(0), { showHidden: true }).includes('[buffer]'));
 assert.strictEqual(
@@ -94,15 +109,13 @@ assert.strictEqual(
   '{ visible: 1 }'
 );
 assert.strictEqual(
-  util.inspect(
-    Object.assign(new String('hello'), { [Symbol('foo')]: 123 }),
-    { showHidden: true }
-  ),
+  util.inspect(Object.assign(new String('hello'), { [Symbol('foo')]: 123 }), {
+    showHidden: true
+  }),
   "{ [String: 'hello'] [length]: 5, [Symbol(foo)]: 123 }"
 );
 
-assert.strictEqual(util.inspect((new JSStream())._externalStream),
-                   '[External]');
+assert.strictEqual(util.inspect(new JSStream()._externalStream), '[External]');
 
 {
   const regexp = /regexp/;
@@ -110,12 +123,16 @@ assert.strictEqual(util.inspect((new JSStream())._externalStream),
   assert.strictEqual(util.inspect({ a: regexp }, false, 0), '{ a: /regexp/ }');
 }
 
-assert(/Object/.test(
-  util.inspect({ a: { a: { a: { a: {} } } } }, undefined, undefined, true)
-));
-assert(!/Object/.test(
-  util.inspect({ a: { a: { a: { a: {} } } } }, undefined, null, true)
-));
+assert(
+  /Object/.test(
+    util.inspect({ a: { a: { a: { a: {} } } } }, undefined, undefined, true)
+  )
+);
+assert(
+  !/Object/.test(
+    util.inspect({ a: { a: { a: { a: {} } } } }, undefined, null, true)
+  )
+);
 
 for (const showHidden of [true, false]) {
   const ab = new ArrayBuffer(4);
@@ -124,30 +141,38 @@ for (const showHidden of [true, false]) {
     util.inspect(ab, showHidden),
     'ArrayBuffer { byteLength: 4 }'
   );
-  assert.strictEqual(util.inspect(new DataView(ab, 1, 2), showHidden),
-                     'DataView {\n' +
-                     '  byteLength: 2,\n' +
-                     '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4 } }');
+  assert.strictEqual(
+    util.inspect(new DataView(ab, 1, 2), showHidden),
+    'DataView {\n' +
+      '  byteLength: 2,\n' +
+      '  byteOffset: 1,\n' +
+      '  buffer: ArrayBuffer { byteLength: 4 } }'
+  );
   assert.strictEqual(
     util.inspect(ab, showHidden),
     'ArrayBuffer { byteLength: 4 }'
   );
-  assert.strictEqual(util.inspect(dv, showHidden),
-                     'DataView {\n' +
-                     '  byteLength: 2,\n' +
-                     '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4 } }');
+  assert.strictEqual(
+    util.inspect(dv, showHidden),
+    'DataView {\n' +
+      '  byteLength: 2,\n' +
+      '  byteOffset: 1,\n' +
+      '  buffer: ArrayBuffer { byteLength: 4 } }'
+  );
   ab.x = 42;
   dv.y = 1337;
-  assert.strictEqual(util.inspect(ab, showHidden),
-                     'ArrayBuffer { byteLength: 4, x: 42 }');
-  assert.strictEqual(util.inspect(dv, showHidden),
-                     'DataView {\n' +
-                     '  byteLength: 2,\n' +
-                     '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\n' +
-                     '  y: 1337 }');
+  assert.strictEqual(
+    util.inspect(ab, showHidden),
+    'ArrayBuffer { byteLength: 4, x: 42 }'
+  );
+  assert.strictEqual(
+    util.inspect(dv, showHidden),
+    'DataView {\n' +
+      '  byteLength: 2,\n' +
+      '  byteOffset: 1,\n' +
+      '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\n' +
+      '  y: 1337 }'
+  );
 }
 
 // Now do the same checks but from a different context.
@@ -158,33 +183,42 @@ for (const showHidden of [true, false]) {
     util.inspect(ab, showHidden),
     'ArrayBuffer { byteLength: 4 }'
   );
-  assert.strictEqual(util.inspect(new DataView(ab, 1, 2), showHidden),
-                     'DataView {\n' +
-                     '  byteLength: 2,\n' +
-                     '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4 } }');
+  assert.strictEqual(
+    util.inspect(new DataView(ab, 1, 2), showHidden),
+    'DataView {\n' +
+      '  byteLength: 2,\n' +
+      '  byteOffset: 1,\n' +
+      '  buffer: ArrayBuffer { byteLength: 4 } }'
+  );
   assert.strictEqual(
     util.inspect(ab, showHidden),
     'ArrayBuffer { byteLength: 4 }'
   );
-  assert.strictEqual(util.inspect(dv, showHidden),
-                     'DataView {\n' +
-                     '  byteLength: 2,\n' +
-                     '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4 } }');
+  assert.strictEqual(
+    util.inspect(dv, showHidden),
+    'DataView {\n' +
+      '  byteLength: 2,\n' +
+      '  byteOffset: 1,\n' +
+      '  buffer: ArrayBuffer { byteLength: 4 } }'
+  );
   ab.x = 42;
   dv.y = 1337;
-  assert.strictEqual(util.inspect(ab, showHidden),
-                     'ArrayBuffer { byteLength: 4, x: 42 }');
-  assert.strictEqual(util.inspect(dv, showHidden),
-                     'DataView {\n' +
-                     '  byteLength: 2,\n' +
-                     '  byteOffset: 1,\n' +
-                     '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\n' +
-                     '  y: 1337 }');
+  assert.strictEqual(
+    util.inspect(ab, showHidden),
+    'ArrayBuffer { byteLength: 4, x: 42 }'
+  );
+  assert.strictEqual(
+    util.inspect(dv, showHidden),
+    'DataView {\n' +
+      '  byteLength: 2,\n' +
+      '  byteOffset: 1,\n' +
+      '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\n' +
+      '  y: 1337 }'
+  );
 }
 
-[ Float32Array,
+[
+  Float32Array,
   Float64Array,
   Int16Array,
   Int32Array,
@@ -192,7 +226,8 @@ for (const showHidden of [true, false]) {
   Uint16Array,
   Uint32Array,
   Uint8Array,
-  Uint8ClampedArray ].forEach((constructor) => {
+  Uint8ClampedArray
+].forEach((constructor) => {
   const length = 2;
   const byteLength = length * constructor.BYTES_PER_ELEMENT;
   const array = new constructor(new ArrayBuffer(byteLength), 0, length);
@@ -207,7 +242,8 @@ for (const showHidden of [true, false]) {
       `  [length]: ${length},\n` +
       `  [byteLength]: ${byteLength},\n` +
       '  [byteOffset]: 0,\n' +
-      `  [buffer]: ArrayBuffer { byteLength: ${byteLength} } ]`);
+      `  [buffer]: ArrayBuffer { byteLength: ${byteLength} } ]`
+  );
   assert.strictEqual(
     util.inspect(array, false),
     `${constructor.name} [ 65, 97 ]`
@@ -215,7 +251,8 @@ for (const showHidden of [true, false]) {
 });
 
 // Now check that declaring a TypedArray in a different context works the same.
-[ Float32Array,
+[
+  Float32Array,
   Float64Array,
   Int16Array,
   Int32Array,
@@ -223,7 +260,8 @@ for (const showHidden of [true, false]) {
   Uint16Array,
   Uint32Array,
   Uint8Array,
-  Uint8ClampedArray ].forEach((constructor) => {
+  Uint8ClampedArray
+].forEach((constructor) => {
   const length = 2;
   const byteLength = length * constructor.BYTES_PER_ELEMENT;
   const array = vm.runInNewContext(
@@ -241,7 +279,8 @@ for (const showHidden of [true, false]) {
       `  [length]: ${length},\n` +
       `  [byteLength]: ${byteLength},\n` +
       '  [byteOffset]: 0,\n' +
-      `  [buffer]: ArrayBuffer { byteLength: ${byteLength} } ]`);
+      `  [buffer]: ArrayBuffer { byteLength: ${byteLength} } ]`
+  );
   assert.strictEqual(
     util.inspect(array, false),
     `${constructor.name} [ 65, 97 ]`
@@ -249,26 +288,37 @@ for (const showHidden of [true, false]) {
 });
 
 assert.strictEqual(
-  util.inspect(Object.create({}, {
-    visible: { value: 1, enumerable: true },
-    hidden: { value: 2 }
-  }), { showHidden: true }),
+  util.inspect(
+    Object.create(
+      {},
+      {
+        visible: { value: 1, enumerable: true },
+        hidden: { value: 2 }
+      }
+    ),
+    { showHidden: true }
+  ),
   '{ visible: 1, [hidden]: 2 }'
 );
 // Objects without prototype.
 assert.strictEqual(
-  util.inspect(Object.create(null, {
-    name: { value: 'Tim', enumerable: true },
-    hidden: { value: 'secret' }
-  }), { showHidden: true }),
+  util.inspect(
+    Object.create(null, {
+      name: { value: 'Tim', enumerable: true },
+      hidden: { value: 'secret' }
+    }),
+    { showHidden: true }
+  ),
   "[Object: null prototype] { name: 'Tim', [hidden]: 'secret' }"
 );
 
 assert.strictEqual(
-  util.inspect(Object.create(null, {
-    name: { value: 'Tim', enumerable: true },
-    hidden: { value: 'secret' }
-  })),
+  util.inspect(
+    Object.create(null, {
+      name: { value: 'Tim', enumerable: true },
+      hidden: { value: 'secret' }
+    })
+  ),
   "[Object: null prototype] { name: 'Tim' }"
 );
 
@@ -276,16 +326,19 @@ assert.strictEqual(
 {
   assert.strictEqual(
     util.inspect({ get readonly() {} }),
-    '{ readonly: [Getter] }');
+    '{ readonly: [Getter] }'
+  );
 
   assert.strictEqual(
     util.inspect({ get readwrite() {}, set readwrite(val) {} }),
-    '{ readwrite: [Getter/Setter] }');
+    '{ readwrite: [Getter/Setter] }'
+  );
 
   assert.strictEqual(
     // eslint-disable-next-line accessor-pairs
     util.inspect({ set writeonly(val) {} }),
-    '{ writeonly: [Setter] }');
+    '{ writeonly: [Setter] }'
+  );
 
   const value = {};
   value.a = value;
@@ -295,24 +348,21 @@ assert.strictEqual(
 // Array with dynamic properties.
 {
   const value = [1, 2, 3];
-  Object.defineProperty(
-    value,
-    'growingLength',
-    {
-      enumerable: true,
-      get: function() { this.push(true); return this.length; }
-    }
-  );
-  Object.defineProperty(
-    value,
-    '-1',
-    {
-      enumerable: true,
-      value: -1
+  Object.defineProperty(value, 'growingLength', {
+    enumerable: true,
+    get: function() {
+      this.push(true);
+      return this.length;
     }
+  });
+  Object.defineProperty(value, '-1', {
+    enumerable: true,
+    value: -1
+  });
+  assert.strictEqual(
+    util.inspect(value),
+    "[ 1, 2, 3, growingLength: [Getter], '-1': -1 ]"
   );
-  assert.strictEqual(util.inspect(value),
-                     "[ 1, 2, 3, growingLength: [Getter], '-1': -1 ]");
 }
 
 // Array with inherited number properties.
@@ -325,36 +375,49 @@ assert.strictEqual(
 
 // Array with extra properties.
 {
-  const arr = [1, 2, 3, , ];
+  const arr = [1, 2, 3, ,];
   arr.foo = 'bar';
-  assert.strictEqual(util.inspect(arr),
-                     "[ 1, 2, 3, <1 empty item>, foo: 'bar' ]");
+  assert.strictEqual(
+    util.inspect(arr),
+    "[ 1, 2, 3, <1 empty item>, foo: 'bar' ]"
+  );
 
   const arr2 = [];
   assert.strictEqual(util.inspect([], { showHidden: true }), '[ [length]: 0 ]');
   arr2['00'] = 1;
   assert.strictEqual(util.inspect(arr2), "[ '00': 1 ]");
-  assert.strictEqual(util.inspect(arr2, { showHidden: true }),
-                     "[ [length]: 0, '00': 1 ]");
+  assert.strictEqual(
+    util.inspect(arr2, { showHidden: true }),
+    "[ [length]: 0, '00': 1 ]"
+  );
   arr2[1] = 0;
   assert.strictEqual(util.inspect(arr2), "[ <1 empty item>, 0, '00': 1 ]");
-  assert.strictEqual(util.inspect(arr2, { showHidden: true }),
-                     "[ <1 empty item>, 0, [length]: 2, '00': 1 ]");
+  assert.strictEqual(
+    util.inspect(arr2, { showHidden: true }),
+    "[ <1 empty item>, 0, [length]: 2, '00': 1 ]"
+  );
   delete arr2[1];
   assert.strictEqual(util.inspect(arr2), "[ <2 empty items>, '00': 1 ]");
-  assert.strictEqual(util.inspect(arr2, { showHidden: true }),
-                     "[ <2 empty items>, [length]: 2, '00': 1 ]");
+  assert.strictEqual(
+    util.inspect(arr2, { showHidden: true }),
+    "[ <2 empty items>, [length]: 2, '00': 1 ]"
+  );
   arr2['01'] = 2;
-  assert.strictEqual(util.inspect(arr2),
-                     "[ <2 empty items>, '00': 1, '01': 2 ]");
-  assert.strictEqual(util.inspect(arr2, { showHidden: true }),
-                     "[ <2 empty items>, [length]: 2, '00': 1, '01': 2 ]");
+  assert.strictEqual(
+    util.inspect(arr2),
+    "[ <2 empty items>, '00': 1, '01': 2 ]"
+  );
+  assert.strictEqual(
+    util.inspect(arr2, { showHidden: true }),
+    "[ <2 empty items>, [length]: 2, '00': 1, '01': 2 ]"
+  );
   delete arr2['00'];
   arr2[0] = 0;
-  assert.strictEqual(util.inspect(arr2),
-                     "[ 0, <1 empty item>, '01': 2 ]");
-  assert.strictEqual(util.inspect(arr2, { showHidden: true }),
-                     "[ 0, <1 empty item>, [length]: 2, '01': 2 ]");
+  assert.strictEqual(util.inspect(arr2), "[ 0, <1 empty item>, '01': 2 ]");
+  assert.strictEqual(
+    util.inspect(arr2, { showHidden: true }),
+    "[ 0, <1 empty item>, [length]: 2, '01': 2 ]"
+  );
   delete arr2['01'];
   arr2[2 ** 32 - 2] = 'max';
   arr2[2 ** 32 - 1] = 'too far';
@@ -375,20 +438,25 @@ assert.strictEqual(
   assert.strictEqual(util.inspect(arr), "[ '4294967296': true ]");
   arr[0] = true;
   arr[10] = true;
-  assert.strictEqual(util.inspect(arr),
-                     "[ true, <9 empty items>, true, '4294967296': true ]");
+  assert.strictEqual(
+    util.inspect(arr),
+    "[ true, <9 empty items>, true, '4294967296': true ]"
+  );
   arr[2 ** 32 - 2] = true;
   arr[2 ** 32 - 1] = true;
   arr[2 ** 32 + 1] = true;
   delete arr[0];
   delete arr[10];
-  assert.strictEqual(util.inspect(arr),
-                     ['[ <4294967294 empty items>,',
-                      'true,',
-                      "'4294967296': true,",
-                      "'4294967295': true,",
-                      "'4294967297': true ]"
-                     ].join('\n  '));
+  assert.strictEqual(
+    util.inspect(arr),
+    [
+      '[ <4294967294 empty items>,',
+      'true,',
+      "'4294967296': true,",
+      "'4294967295': true,",
+      "'4294967297': true ]"
+    ].join('\n  ')
+  );
 }
 
 // Function with properties.
@@ -407,7 +475,7 @@ assert.strictEqual(
 
 // Regular expressions with properties.
 {
-  const value = /123/ig;
+  const value = /123/gi;
   value.aprop = 42;
   assert.strictEqual(util.inspect(value), '{ /123/gi aprop: 42 }');
 }
@@ -416,8 +484,10 @@ assert.strictEqual(
 {
   const value = new Date('Sun, 14 Feb 2010 11:48:40 GMT');
   value.aprop = 42;
-  assert.strictEqual(util.inspect(value),
-                     '{ 2010-02-14T11:48:40.000Z aprop: 42 }');
+  assert.strictEqual(
+    util.inspect(value),
+    '{ 2010-02-14T11:48:40.000Z aprop: 42 }'
+  );
 }
 
 // Test the internal isDate implementation.
@@ -491,17 +561,22 @@ assert.strictEqual(util.inspect(-5e-324), '-5e-324');
 {
   const getter = Object.create(null, {
     a: {
-      get: function() { return 'aaa'; }
+      get: function() {
+        return 'aaa';
+      }
     }
   });
   const setter = Object.create(null, {
-    b: { // eslint-disable-line accessor-pairs
+    b: {
+      // eslint-disable-line accessor-pairs
       set: function() {}
     }
   });
   const getterAndSetter = Object.create(null, {
     c: {
-      get: function() { return 'ccc'; },
+      get: function() {
+        return 'ccc';
+      },
       set: function() {}
     }
   });
@@ -594,10 +669,11 @@ assert.strictEqual(util.inspect(-5e-324), '-5e-324');
 {
   function BadCustomError(msg) {
     Error.call(this);
-    Object.defineProperty(this, 'message',
-                          { value: msg, enumerable: false });
-    Object.defineProperty(this, 'name',
-                          { value: 'BadCustomError', enumerable: false });
+    Object.defineProperty(this, 'message', { value: msg, enumerable: false });
+    Object.defineProperty(this, 'name', {
+      value: 'BadCustomError',
+      enumerable: false
+    });
   }
   util.inherits(BadCustomError, Error);
   assert.strictEqual(
@@ -633,8 +709,13 @@ assert.strictEqual(util.inspect(Object.create(Date.prototype)), 'Date {}');
 // See https://github.com/nodejs/node-v0.x-archive/issues/2225
 {
   const x = { [util.inspect.custom]: util.inspect };
-  assert(util.inspect(x).includes(
-    '[Symbol(nodejs.util.inspect.custom)]:\n   { [Function: inspect]'));
+  assert(
+    util
+      .inspect(x)
+      .includes(
+        '[Symbol(nodejs.util.inspect.custom)]:\n   { [Function: inspect]'
+      )
+  );
 }
 
 // `util.inspect` should display the escaped value of a key.
@@ -656,12 +737,11 @@ assert.strictEqual(util.inspect(Object.create(Date.prototype)), 'Date {}');
   assert.strictEqual(
     util.inspect(w),
     "{ '\\\\': 1, '\\\\\\\\': 2, '\\\\\\\\\\\\': 3, " +
-    "'\\\\\\\\\\\\\\\\': 4, '\\n': 5, '\\r': 6 }"
+      "'\\\\\\\\\\\\\\\\': 4, '\\n': 5, '\\r': 6 }"
   );
   assert.strictEqual(
     util.inspect(y),
-    "[ 'a', 'b', 'c', '\\\\\\\\': 'd', " +
-    "'\\n': 'e', '\\r': 'f' ]"
+    "[ 'a', 'b', 'c', '\\\\\\\\': 'd', " + "'\\n': 'e', '\\r': 'f' ]"
   );
 }
 
@@ -670,8 +750,7 @@ assert.strictEqual(util.inspect(Object.create(Date.prototype)), 'Date {}');
   function testColorStyle(style, input, implicit) {
     const colorName = util.inspect.styles[style];
     let color = ['', ''];
-    if (util.inspect.colors[colorName])
-      color = util.inspect.colors[colorName];
+    if (util.inspect.colors[colorName]) color = util.inspect.colors[colorName];
 
     const withoutColor = util.inspect(input, false, 0, false);
     const withColor = util.inspect(input, false, 0, true);
@@ -679,7 +758,8 @@ assert.strictEqual(util.inspect(Object.create(Date.prototype)), 'Date {}');
     assert.strictEqual(
       withColor,
       expect,
-      `util.inspect color for style ${style}`);
+      `util.inspect color for style ${style}`
+    );
   }
 
   testColorStyle('special', function() {});
@@ -772,7 +852,7 @@ util.inspect({ hasOwnProperty: null });
 
   subject[inspect] = () => ({ baz: 'quux' });
 
-  assert.strictEqual(util.inspect(subject), '{ baz: \'quux\' }');
+  assert.strictEqual(util.inspect(subject), "{ baz: 'quux' }");
 
   subject[inspect] = (depth, opts) => {
     assert.strictEqual(opts.customInspectOptions, true);
@@ -783,10 +863,17 @@ util.inspect({ hasOwnProperty: null });
 
 {
   // Returning `this` from a custom inspection function works.
-  const subject = { a: 123, [util.inspect.custom]() { return this; } };
+  const subject = {
+    a: 123,
+    [util.inspect.custom]() {
+      return this;
+    }
+  };
   const UIC = 'nodejs.util.inspect.custom';
-  assert.strictEqual(util.inspect(subject),
-                     `{ a: 123,\n  [Symbol(${UIC})]: [Function: [${UIC}]] }`);
+  assert.strictEqual(
+    util.inspect(subject),
+    `{ a: 123,\n  [Symbol(${UIC})]: [Function: [${UIC}]] }`
+  );
 }
 
 // Using `util.inspect` with "colors" option should produce as many lines as
@@ -869,10 +956,10 @@ if (typeof Symbol !== 'undefined') {
     '{ [Symbol(sym\\nbol)]: 42 }'
   );
 
-  Object.defineProperty(
-    subject,
-    Symbol(),
-    { enumerable: false, value: 'non-enum' });
+  Object.defineProperty(subject, Symbol(), {
+    enumerable: false,
+    value: 'non-enum'
+  });
   assert.strictEqual(util.inspect(subject), '{ [Symbol(sym\\nbol)]: 42 }');
   assert.strictEqual(
     util.inspect(subject, options),
@@ -882,8 +969,10 @@ if (typeof Symbol !== 'undefined') {
   subject = [1, 2, 3];
   subject[Symbol('symbol')] = 42;
 
-  assert.strictEqual(util.inspect(subject),
-                     '[ 1, 2, 3, [Symbol(symbol)]: 42 ]');
+  assert.strictEqual(
+    util.inspect(subject),
+    '[ 1, 2, 3, [Symbol(symbol)]: 42 ]'
+  );
 }
 
 // Test Set.
@@ -908,12 +997,16 @@ if (typeof Symbol !== 'undefined') {
 // Test Map.
 {
   assert.strictEqual(util.inspect(new Map()), 'Map {}');
-  assert.strictEqual(util.inspect(new Map([[1, 'a'], [2, 'b'], [3, 'c']])),
-                     "Map { 1 => 'a', 2 => 'b', 3 => 'c' }");
+  assert.strictEqual(
+    util.inspect(new Map([[1, 'a'], [2, 'b'], [3, 'c']])),
+    "Map { 1 => 'a', 2 => 'b', 3 => 'c' }"
+  );
   const map = new Map([['foo', null]]);
   map.bar = 42;
-  assert.strictEqual(util.inspect(map, true),
-                     "Map { 'foo' => null, [size]: 1, bar: 42 }");
+  assert.strictEqual(
+    util.inspect(map, true),
+    "Map { 'foo' => null, [size]: 1, bar: 42 }"
+  );
 }
 
 // Test circular Map.
@@ -943,8 +1036,10 @@ if (typeof Symbol !== 'undefined') {
 
   const promiseWithProperty = Promise.resolve('foo');
   promiseWithProperty.bar = 42;
-  assert.strictEqual(util.inspect(promiseWithProperty),
-                     "Promise { 'foo', bar: 42 }");
+  assert.strictEqual(
+    util.inspect(promiseWithProperty),
+    "Promise { 'foo', bar: 42 }"
+  );
 }
 
 // Make sure it doesn't choke on polyfills. Unlike Set/Map, there is no standard
@@ -952,7 +1047,9 @@ if (typeof Symbol !== 'undefined') {
 // a bonafide native Promise.
 {
   const oldPromise = Promise;
-  global.Promise = function() { this.bar = 42; };
+  global.Promise = function() {
+    this.bar = 42;
+  };
   assert.strictEqual(util.inspect(new Promise()), '{ bar: 42 }');
   global.Promise = oldPromise;
 }
@@ -960,11 +1057,13 @@ if (typeof Symbol !== 'undefined') {
 // Test Map iterators.
 {
   const map = new Map([['foo', 'bar']]);
-  assert.strictEqual(util.inspect(map.keys()), '[Map Iterator] { \'foo\' }');
-  assert.strictEqual(util.inspect(map.values()), '[Map Iterator] { \'bar\' }');
+  assert.strictEqual(util.inspect(map.keys()), "[Map Iterator] { 'foo' }");
+  assert.strictEqual(util.inspect(map.values()), "[Map Iterator] { 'bar' }");
   map.set('A', 'B!');
-  assert.strictEqual(util.inspect(map.entries(), { maxArrayLength: 1 }),
-                     "[Map Iterator] { [ 'foo', 'bar' ], ... 1 more item }");
+  assert.strictEqual(
+    util.inspect(map.entries(), { maxArrayLength: 1 }),
+    "[Map Iterator] { [ 'foo', 'bar' ], ... 1 more item }"
+  );
   // Make sure the iterator doesn't get consumed.
   const keys = map.keys();
   assert.strictEqual(util.inspect(keys), "[Map Iterator] { 'foo', 'A' }");
@@ -972,7 +1071,8 @@ if (typeof Symbol !== 'undefined') {
   keys.extra = true;
   assert.strictEqual(
     util.inspect(keys, { maxArrayLength: 0 }),
-    '[Map Iterator] { ... 2 more items, extra: true }');
+    '[Map Iterator] { ... 2 more items, extra: true }'
+  );
 }
 
 // Test Set iterators.
@@ -988,7 +1088,8 @@ if (typeof Symbol !== 'undefined') {
   keys.extra = true;
   assert.strictEqual(
     util.inspect(keys, { maxArrayLength: 1 }),
-    '[Set Iterator] { 1, ... 1 more item, extra: true }');
+    '[Set Iterator] { 1, ... 1 more item, extra: true }'
+  );
 }
 
 // Test alignment of items in container.
@@ -1025,7 +1126,6 @@ if (typeof Symbol !== 'undefined') {
   checkAlignment(new Map(bigArray.map((number) => [number, null])));
 }
 
-
 // Test display of constructors.
 {
   class ObjectSubclass {}
@@ -1036,16 +1136,23 @@ if (typeof Symbol !== 'undefined') {
 
   const x = new ObjectSubclass();
   x.foo = 42;
-  assert.strictEqual(util.inspect(x),
-                     'ObjectSubclass { foo: 42 }');
-  assert.strictEqual(util.inspect(new ArraySubclass(1, 2, 3)),
-                     'ArraySubclass [ 1, 2, 3 ]');
-  assert.strictEqual(util.inspect(new SetSubclass([1, 2, 3])),
-                     'SetSubclass [Set] { 1, 2, 3 }');
-  assert.strictEqual(util.inspect(new MapSubclass([['foo', 42]])),
-                     "MapSubclass [Map] { 'foo' => 42 }");
-  assert.strictEqual(util.inspect(new PromiseSubclass(() => {})),
-                     'PromiseSubclass [Promise] { <pending> }');
+  assert.strictEqual(util.inspect(x), 'ObjectSubclass { foo: 42 }');
+  assert.strictEqual(
+    util.inspect(new ArraySubclass(1, 2, 3)),
+    'ArraySubclass [ 1, 2, 3 ]'
+  );
+  assert.strictEqual(
+    util.inspect(new SetSubclass([1, 2, 3])),
+    'SetSubclass [Set] { 1, 2, 3 }'
+  );
+  assert.strictEqual(
+    util.inspect(new MapSubclass([['foo', 42]])),
+    "MapSubclass [Map] { 'foo' => 42 }"
+  );
+  assert.strictEqual(
+    util.inspect(new PromiseSubclass(() => {})),
+    'PromiseSubclass [Promise] { <pending> }'
+  );
   assert.strictEqual(
     util.inspect({ a: { b: new ArraySubclass([1, [2], 3]) } }, { depth: 1 }),
     '{ a: { b: [ArraySubclass] } }'
@@ -1084,7 +1191,7 @@ if (typeof Symbol !== 'undefined') {
 }
 
 {
-  const x = new function() {}; // eslint-disable-line new-parens
+  const x = new function() {}(); // eslint-disable-line new-parens
   assert.strictEqual(util.inspect(x), '{}');
 }
 
@@ -1110,26 +1217,32 @@ if (typeof Symbol !== 'undefined') {
     util.inspect(x, { maxArrayLength: -1 }),
     '[ ... 101 more items ]'
   );
-  assert.strictEqual(util.inspect(x, { maxArrayLength: 0 }),
-                     '[ ... 101 more items ]');
+  assert.strictEqual(
+    util.inspect(x, { maxArrayLength: 0 }),
+    '[ ... 101 more items ]'
+  );
 }
 
 {
   const x = Array(101);
-  assert.strictEqual(util.inspect(x, { maxArrayLength: 0 }),
-                     '[ ... 101 more items ]');
+  assert.strictEqual(
+    util.inspect(x, { maxArrayLength: 0 }),
+    '[ ... 101 more items ]'
+  );
   assert(!util.inspect(x, { maxArrayLength: null }).endsWith('1 more item ]'));
-  assert(!util.inspect(
-    x, { maxArrayLength: Infinity }
-  ).endsWith('1 more item ]'));
+  assert(
+    !util.inspect(x, { maxArrayLength: Infinity }).endsWith('1 more item ]')
+  );
 }
 
 {
   const x = new Uint8Array(101);
   assert(util.inspect(x).endsWith('1 more item ]'));
   assert(!util.inspect(x, { maxArrayLength: 101 }).endsWith('1 more item ]'));
-  assert.strictEqual(util.inspect(x, { maxArrayLength: 0 }),
-                     'Uint8Array [ ... 101 more items ]');
+  assert.strictEqual(
+    util.inspect(x, { maxArrayLength: 0 }),
+    'Uint8Array [ ... 101 more items ]'
+  );
   assert(!util.inspect(x, { maxArrayLength: null }).endsWith('1 more item ]'));
   assert(util.inspect(x, { maxArrayLength: Infinity }).endsWith('  0 ]'));
 }
@@ -1143,8 +1256,10 @@ if (typeof Symbol !== 'undefined') {
   const twoLines = util.inspect(obj, { breakLength: breakpoint });
 
   assert.strictEqual(oneLine, "{ foo: 'abc', bar: 'xyz' }");
-  assert.strictEqual(oneLine,
-                     util.inspect(obj, { breakLength: breakpoint + 1 }));
+  assert.strictEqual(
+    oneLine,
+    util.inspect(obj, { breakLength: breakpoint + 1 })
+  );
   assert.strictEqual(twoLines, "{ foo: 'abc',\n  bar: 'xyz' }");
 }
 
@@ -1181,24 +1296,30 @@ if (typeof Symbol !== 'undefined') {
     JSON.stringify(oldOptions)
   );
 
-  common.expectsError(() => {
-    util.inspect.defaultOptions = null;
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options" argument must be of type Object. ' +
-             'Received type object'
-  }
+  common.expectsError(
+    () => {
+      util.inspect.defaultOptions = null;
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "options" argument must be of type Object. ' +
+        'Received type object'
+    }
   );
 
-  common.expectsError(() => {
-    util.inspect.defaultOptions = 'bad';
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options" argument must be of type Object. ' +
-             'Received type string'
-  }
+  common.expectsError(
+    () => {
+      util.inspect.defaultOptions = 'bad';
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "options" argument must be of type Object. ' +
+        'Received type string'
+    }
   );
 }
 
@@ -1215,8 +1336,10 @@ util.inspect(process);
 
 {
   // @@toStringTag
-  assert.strictEqual(util.inspect({ [Symbol.toStringTag]: 'a' }),
-                     "Object [a] { [Symbol(Symbol.toStringTag)]: 'a' }");
+  assert.strictEqual(
+    util.inspect({ [Symbol.toStringTag]: 'a' }),
+    "Object [a] { [Symbol(Symbol.toStringTag)]: 'a' }"
+  );
 
   class Foo {
     constructor() {
@@ -1228,21 +1351,28 @@ util.inspect(process);
     }
   }
 
-  assert.strictEqual(util.inspect(
-    Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } })),
-                     '[Object: null prototype] [foo] {}');
+  assert.strictEqual(
+    util.inspect(
+      Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } })
+    ),
+    '[Object: null prototype] [foo] {}'
+  );
 
   assert.strictEqual(util.inspect(new Foo()), "Foo [bar] { foo: 'bar' }");
 
   assert.strictEqual(
-    util.inspect(new (class extends Foo {})()),
-    "Foo [bar] { foo: 'bar' }");
+    util.inspect(new class extends Foo {}()),
+    "Foo [bar] { foo: 'bar' }"
+  );
 
   assert.strictEqual(
-    util.inspect(Object.create(Object.create(Foo.prototype), {
-      foo: { value: 'bar', enumerable: true }
-    })),
-    "Foo [bar] { foo: 'bar' }");
+    util.inspect(
+      Object.create(Object.create(Foo.prototype), {
+        foo: { value: 'bar', enumerable: true }
+      })
+    ),
+    "Foo [bar] { foo: 'bar' }"
+  );
 
   class ThrowingClass {
     get [Symbol.toStringTag]() {
@@ -1258,17 +1388,24 @@ util.inspect(process);
     }
   }
 
-  assert.strictEqual(util.inspect(new NotStringClass()),
-                     'NotStringClass {}');
+  assert.strictEqual(util.inspect(new NotStringClass()), 'NotStringClass {}');
 }
 
 {
   const o = {
-    a: [1, 2, [[
-      'Lorem ipsum dolor\nsit amet,\tconsectetur adipiscing elit, sed do ' +
-        'eiusmod tempor incididunt ut labore et dolore magna aliqua.',
-      'test',
-      'foo']], 4],
+    a: [
+      1,
+      2,
+      [
+        [
+          'Lorem ipsum dolor\nsit amet,\tconsectetur adipiscing elit, sed do ' +
+            'eiusmod tempor incididunt ut labore et dolore magna aliqua.',
+          'test',
+          'foo'
+        ]
+      ],
+      4
+    ],
     b: new Map([['za', 1], ['zb', 'test']])
   };
 
@@ -1282,7 +1419,7 @@ util.inspect(process);
     "         'test',",
     "         'foo' ] ],",
     '     4 ],',
-    "  b: Map { 'za' => 1, 'zb' => 'test' } }",
+    "  b: Map { 'za' => 1, 'zb' => 'test' } }"
   ].join('\n');
   assert.strictEqual(out, expect);
 
@@ -1323,15 +1460,17 @@ util.inspect(process);
   ].join('\n');
   assert.strictEqual(out, expect);
 
-  out = util.inspect(
-    '12345678901234567890123456789012345678901234567890',
-    { compact: false, breakLength: 3 });
+  out = util.inspect('12345678901234567890123456789012345678901234567890', {
+    compact: false,
+    breakLength: 3
+  });
   expect = "'12345678901234567890123456789012345678901234567890'";
   assert.strictEqual(out, expect);
 
   out = util.inspect(
     '12 45 78 01 34 67 90 23 56 89 123456789012345678901234567890',
-    { compact: false, breakLength: 3 });
+    { compact: false, breakLength: 3 }
+  );
   expect = [
     "'12 45 78 01 34 ' +",
     "  '67 90 23 56 89 ' +",
@@ -1339,9 +1478,10 @@ util.inspect(process);
   ].join('\n');
   assert.strictEqual(out, expect);
 
-  out = util.inspect(
-    '12 45 78 01 34 67 90 23 56 89 1234567890123 0',
-    { compact: false, breakLength: 3 });
+  out = util.inspect('12 45 78 01 34 67 90 23 56 89 1234567890123 0', {
+    compact: false,
+    breakLength: 3
+  });
   expect = [
     "'12 45 78 01 34 ' +",
     "  '67 90 23 56 89 ' +",
@@ -1349,9 +1489,10 @@ util.inspect(process);
   ].join('\n');
   assert.strictEqual(out, expect);
 
-  out = util.inspect(
-    '12 45 78 01 34 67 90 23 56 89 12345678901234567 0',
-    { compact: false, breakLength: 3 });
+  out = util.inspect('12 45 78 01 34 67 90 23 56 89 12345678901234567 0', {
+    compact: false,
+    breakLength: 3
+  });
   expect = [
     "'12 45 78 01 34 ' +",
     "  '67 90 23 56 89 ' +",
@@ -1363,12 +1504,7 @@ util.inspect(process);
   o.a = () => {};
   o.b = new Number(3);
   out = util.inspect(o, { compact: false, breakLength: 3 });
-  expect = [
-    '{',
-    '  a: [Function],',
-    '  b: [Number: 3]',
-    '}'
-  ].join('\n');
+  expect = ['{', '  a: [Function],', '  b: [Number: 3]', '}'].join('\n');
   assert.strictEqual(out, expect);
 
   out = util.inspect(o, { compact: false, breakLength: 3, showHidden: true });
@@ -1500,7 +1636,8 @@ util.inspect(process);
   assert.strict.equal(out, expected);
 }
 
-{ // Test WeakMap
+{
+  // Test WeakMap
   const obj = {};
   const arr = [];
   const weakMap = new WeakMap([[obj, arr], [arr, obj]]);
@@ -1520,13 +1657,16 @@ util.inspect(process);
   out = util.inspect(weakMap, { maxArrayLength: 1, showHidden: true });
   // It is not possible to determine the output reliable.
   expect = 'WeakMap { [ [length]: 0 ] => {}, ... 1 more item, extra: true }';
-  const expectAlt = 'WeakMap { {} => [ [length]: 0 ], ... 1 more item, ' +
-                    'extra: true }';
-  assert(out === expect || out === expectAlt,
-         `Found: "${out}"\nrather than: "${expect}"\nor: "${expectAlt}"`);
+  const expectAlt =
+    'WeakMap { {} => [ [length]: 0 ], ... 1 more item, ' + 'extra: true }';
+  assert(
+    out === expect || out === expectAlt,
+    `Found: "${out}"\nrather than: "${expect}"\nor: "${expectAlt}"`
+  );
 }
 
-{ // Test WeakSet
+{
+  // Test WeakSet
   const weakSet = new WeakSet([{}, [1]]);
   let out = util.inspect(weakSet, { showHidden: true });
   let expect = 'WeakSet { [ 1, [length]: 1 ], {} }';
@@ -1544,14 +1684,19 @@ util.inspect(process);
   out = util.inspect(weakSet, { maxArrayLength: 1, showHidden: true });
   // It is not possible to determine the output reliable.
   expect = 'WeakSet { {}, ... 1 more item, extra: true }';
-  const expectAlt = 'WeakSet { [ 1, [length]: 1 ], ... 1 more item, ' +
-                    'extra: true }';
-  assert(out === expect || out === expectAlt,
-         `Found: "${out}"\nrather than: "${expect}"\nor: "${expectAlt}"`);
+  const expectAlt =
+    'WeakSet { [ 1, [length]: 1 ], ... 1 more item, ' + 'extra: true }';
+  assert(
+    out === expect || out === expectAlt,
+    `Found: "${out}"\nrather than: "${expect}"\nor: "${expectAlt}"`
+  );
 }
 
-{ // Test argument objects.
-  const args = (function() { return arguments; })('a');
+{
+  // Test argument objects.
+  const args = (function() {
+    return arguments;
+  })('a');
   assert.strictEqual(util.inspect(args), "[Arguments] { '0': 'a' }");
 }
 
@@ -1561,8 +1706,7 @@ util.inspect(process);
   let head = list;
   // A linked list of length 100k should be inspectable in some way, even though
   // the real cutoff value is much lower than 100k.
-  for (let i = 0; i < 100000; i++)
-    head = head.next = {};
+  for (let i = 0; i < 100000; i++) head = head.next = {};
   assert.strictEqual(
     util.inspect(list),
     '{ next: { next: { next: [Object] } } }'
@@ -1570,8 +1714,12 @@ util.inspect(process);
   const longList = util.inspect(list, { depth: Infinity });
   const match = longList.match(/next/g);
   assert(match.length > 1000 && match.length < 10000);
-  assert(longList.includes('[Object: Inspection interrupted ' +
-    'prematurely. Maximum call stack size exceeded.]'));
+  assert(
+    longList.includes(
+      '[Object: Inspection interrupted ' +
+        'prematurely. Maximum call stack size exceeded.]'
+    )
+  );
 }
 
 // Do not escape single quotes if no double quote or backtick is present.
@@ -1598,7 +1746,7 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
   [function() {}, '[Function]'],
   [() => {}, '[Function]'],
   [[1, 2], '[ 1, 2 ]'],
-  [[, , 5, , , , ], '[ <2 empty items>, 5, <3 empty items> ]'],
+  [[, , 5, , , ,], '[ <2 empty items>, 5, <3 empty items> ]'],
   [{ a: 5 }, '{ a: 5 }'],
   [new Set([1, 2]), 'Set { 1, 2 }'],
   [new Map([[1, 2]]), 'Map { 1 => 2 }'],
@@ -1608,7 +1756,7 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
   [new Uint8Array(2), 'Uint8Array [ 0, 0 ]'],
   [new Promise((resolve) => setTimeout(resolve, 10)), 'Promise { <pending> }'],
   [new WeakSet(), 'WeakSet { <items unknown> }'],
-  [new WeakMap(), 'WeakMap { <items unknown> }'],
+  [new WeakMap(), 'WeakMap { <items unknown> }']
 ].forEach(([value, expected]) => {
   Object.defineProperty(value, 'valueOf', {
     get() {
@@ -1632,8 +1780,10 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
   [[1, 3, 4], '[Array: null prototype] [ 1, 3, 4 ]'],
   [new Set([1, 2]), '[Set: null prototype] { 1, 2 }'],
   [new Map([[1, 2]]), '[Map: null prototype] { 1 => 2 }'],
-  [new Promise((resolve) => setTimeout(resolve, 10)),
-   '[Promise: null prototype] { <pending> }'],
+  [
+    new Promise((resolve) => setTimeout(resolve, 10)),
+    '[Promise: null prototype] { <pending> }'
+  ],
   [new WeakSet(), '[WeakSet: null prototype] { <items unknown> }'],
   [new WeakMap(), '[WeakMap: null prototype] { <items unknown> }'],
   [new Uint8Array(2), '[Uint8Array: null prototype] [ 0, 0 ]'],
@@ -1646,13 +1796,19 @@ assert.strictEqual(util.inspect('"\'${a}'), "'\"\\'${a}'");
   [new Float64Array(2), '[Float64Array: null prototype] [ 0, 0 ]'],
   [new BigInt64Array(2), '[BigInt64Array: null prototype] [ 0n, 0n ]'],
   [new BigUint64Array(2), '[BigUint64Array: null prototype] [ 0n, 0n ]'],
-  [new ArrayBuffer(16), '[ArrayBuffer: null prototype] ' +
-   '{ byteLength: undefined }'],
-  [new DataView(new ArrayBuffer(16)),
-   '[DataView: null prototype] {\n  byteLength: undefined,\n  ' +
-    'byteOffset: undefined,\n  buffer: undefined }'],
-  [new SharedArrayBuffer(2), '[SharedArrayBuffer: null prototype] ' +
-  '{ byteLength: undefined }']
+  [
+    new ArrayBuffer(16),
+    '[ArrayBuffer: null prototype] ' + '{ byteLength: undefined }'
+  ],
+  [
+    new DataView(new ArrayBuffer(16)),
+    '[DataView: null prototype] {\n  byteLength: undefined,\n  ' +
+      'byteOffset: undefined,\n  buffer: undefined }'
+  ],
+  [
+    new SharedArrayBuffer(2),
+    '[SharedArrayBuffer: null prototype] ' + '{ byteLength: undefined }'
+  ]
 ].forEach(([value, expected]) => {
   assert.strictEqual(
     util.inspect(Object.setPrototypeOf(value, null)),
@@ -1703,15 +1859,12 @@ assert.strictEqual(inspect(new BigUint64Array([0n])), 'BigUint64Array [ 0n ]');
   assert.strictEqual(
     inspect(rejection, { colors: true }),
     `Promise { \u001b[${special[0]}m<rejected>\u001b[${special[1]}m ` +
-    `\u001b[${string[0]}m'Oh no!'\u001b[${string[1]}m }`
+      `\u001b[${string[0]}m'Oh no!'\u001b[${string[1]}m }`
   );
   rejection.catch(() => {});
 }
 
-assert.strictEqual(
-  inspect([1, 3, 2], { sorted: true }),
-  inspect([1, 3, 2])
-);
+assert.strictEqual(inspect([1, 3, 2], { sorted: true }), inspect([1, 3, 2]));
 assert.strictEqual(
   inspect({ c: 3, a: 1, b: 2 }, { sorted: true }),
   '{ a: 1, b: 2, c: 3 }'
@@ -1719,7 +1872,11 @@ assert.strictEqual(
 assert.strictEqual(
   inspect(
     { a200: 4, a100: 1, a102: 3, a101: 2 },
-    { sorted(a, b) { return b.localeCompare(a); } }
+    {
+      sorted(a, b) {
+        return b.localeCompare(a);
+      }
+    }
   ),
   '{ a200: 4, a102: 3, a101: 2, a100: 1 }'
 );
@@ -1741,7 +1898,9 @@ assert.strictEqual(
 // Manipulate the prototype to one that we can not handle.
 {
   let obj = { a: true };
-  let value = (function() { return function() {}; })();
+  let value = (function() {
+    return function() {};
+  })();
   Object.setPrototypeOf(value, null);
   Object.setPrototypeOf(obj, value);
   assert.strictEqual(util.inspect(obj), '{ a: true }');
diff --git a/test/parallel/test-util-internal.js b/test/parallel/test-util-internal.js
index 4b78cefc6efe60..9b70995604009f 100644
--- a/test/parallel/test-util-internal.js
+++ b/test/parallel/test-util-internal.js
@@ -14,31 +14,27 @@ const {
 } = internalBinding('util');
 
 for (const oneEnv in process.env) {
-  assert.strictEqual(
-    safeGetenv(oneEnv),
-    process.env[oneEnv]
-  );
+  assert.strictEqual(safeGetenv(oneEnv), process.env[oneEnv]);
 }
 
 assert.strictEqual(
   getHiddenValue({}, kArrowMessagePrivateSymbolIndex),
-  undefined);
+  undefined
+);
 
 const obj = {};
 assert.strictEqual(
   setHiddenValue(obj, kArrowMessagePrivateSymbolIndex, 'bar'),
-  true);
-assert.strictEqual(
-  getHiddenValue(obj, kArrowMessagePrivateSymbolIndex),
-  'bar');
+  true
+);
+assert.strictEqual(getHiddenValue(obj, kArrowMessagePrivateSymbolIndex), 'bar');
 
 let arrowMessage;
 
 try {
   require(fixtures.path('syntax', 'bad_syntax'));
 } catch (err) {
-  arrowMessage =
-      getHiddenValue(err, kArrowMessagePrivateSymbolIndex);
+  arrowMessage = getHiddenValue(err, kArrowMessagePrivateSymbolIndex);
 }
 
 assert(/bad_syntax\.js:1/.test(arrowMessage));
diff --git a/test/parallel/test-util-isDeepStrictEqual.js b/test/parallel/test-util-isDeepStrictEqual.js
index fd585f7ccf0f1e..73baf6584b7cb8 100644
--- a/test/parallel/test-util-isDeepStrictEqual.js
+++ b/test/parallel/test-util-isDeepStrictEqual.js
@@ -58,20 +58,20 @@ class MyRegExp extends RegExp {
 {
   // For these cases, deepStrictEqual should throw.
   const similar = new Set([
-    { 0: '1' },  // Object
-    { 0: 1 },  // Object
-    new String('1'),  // Object
-    ['1'],  // Array
-    [1],  // Array
+    { 0: '1' }, // Object
+    { 0: 1 }, // Object
+    new String('1'), // Object
+    ['1'], // Array
+    [1], // Array
     new MyDate('2016'), // Date with this[0] = '1'
-    new MyRegExp('test'),  // RegExp with this[0] = '1'
+    new MyRegExp('test'), // RegExp with this[0] = '1'
     new Int8Array([1]), // Int8Array
     new Uint8Array([1]), // Uint8Array
     new Int16Array([1]), // Int16Array
     new Uint16Array([1]), // Uint16Array
     new Int32Array([1]), // Int32Array
     new Uint32Array([1]), // Uint32Array
-    Buffer.from([1]), // Buffer
+    Buffer.from([1]) // Buffer
   ]);
 
   for (const a of similar) {
@@ -104,10 +104,10 @@ utilIsDeepStrict(new Set(['1', '2', '3']), new Set(['1', '2', '3']));
 utilIsDeepStrict(new Set([[1, 2], [3, 4]]), new Set([[3, 4], [1, 2]]));
 
 {
-  const a = [ 1, 2 ];
-  const b = [ 3, 4 ];
-  const c = [ 1, 2 ];
-  const d = [ 3, 4 ];
+  const a = [1, 2];
+  const b = [3, 4];
+  const c = [1, 2];
+  const d = [3, 4];
 
   utilIsDeepStrict(
     { a: a, b: b, s: new Set([a, b]) },
@@ -118,10 +118,7 @@ utilIsDeepStrict(new Set([[1, 2], [3, 4]]), new Set([[3, 4], [1, 2]]));
 utilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[1, 1], [2, 2]]));
 utilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[2, 2], [1, 1]]));
 notUtilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[1, 2], [2, 1]]));
-notUtilIsDeepStrict(
-  new Map([[[1], 1], [{}, 2]]),
-  new Map([[[1], 2], [{}, 1]])
-);
+notUtilIsDeepStrict(new Map([[[1], 1], [{}, 2]]), new Map([[[1], 2], [{}, 1]]));
 
 notUtilIsDeepStrict(new Set([1]), [1]);
 notUtilIsDeepStrict(new Set(), []);
@@ -166,20 +163,14 @@ utilIsDeepStrict(
   new Map([[1, 'a'], [{}, 'a']]),
   new Map([[1, 'a'], [{}, 'a']])
 );
-utilIsDeepStrict(
-  new Set([1, 'a', [{}, 'a']]),
-  new Set([1, 'a', [{}, 'a']])
-);
+utilIsDeepStrict(new Set([1, 'a', [{}, 'a']]), new Set([1, 'a', [{}, 'a']]));
 
 // This is an awful case, where a map contains multiple equivalent keys:
 notUtilIsDeepStrict(
   new Map([[1, 'a'], ['1', 'b']]),
   new Map([['1', 'a'], [true, 'b']])
 );
-notUtilIsDeepStrict(
-  new Set(['a']),
-  new Set(['b'])
-);
+notUtilIsDeepStrict(new Set(['a']), new Set(['b']));
 utilIsDeepStrict(
   new Map([[{}, 'a'], [{}, 'b']]),
   new Map([[{}, 'b'], [{}, 'a']])
@@ -194,60 +185,27 @@ notUtilIsDeepStrict(
 );
 
 // Similar object keys
-notUtilIsDeepStrict(
-  new Set([{}, {}]),
-  new Set([{}, 1])
-);
-notUtilIsDeepStrict(
-  new Set([[{}, 1], [{}, 1]]),
-  new Set([[{}, 1], [1, 1]])
-);
-notUtilIsDeepStrict(
-  new Map([[{}, 1], [{}, 1]]),
-  new Map([[{}, 1], [1, 1]])
-);
-notUtilIsDeepStrict(
-  new Map([[{}, 1], [true, 1]]),
-  new Map([[{}, 1], [1, 1]])
-);
+notUtilIsDeepStrict(new Set([{}, {}]), new Set([{}, 1]));
+notUtilIsDeepStrict(new Set([[{}, 1], [{}, 1]]), new Set([[{}, 1], [1, 1]]));
+notUtilIsDeepStrict(new Map([[{}, 1], [{}, 1]]), new Map([[{}, 1], [1, 1]]));
+notUtilIsDeepStrict(new Map([[{}, 1], [true, 1]]), new Map([[{}, 1], [1, 1]]));
 
 // Similar primitive key / values
-notUtilIsDeepStrict(
-  new Set([1, true, false]),
-  new Set(['1', 0, '0'])
-);
+notUtilIsDeepStrict(new Set([1, true, false]), new Set(['1', 0, '0']));
 notUtilIsDeepStrict(
   new Map([[1, 5], [true, 5], [false, 5]]),
   new Map([['1', 5], [0, 5], ['0', 5]])
 );
 
 // undefined value in Map
-utilIsDeepStrict(
-  new Map([[1, undefined]]),
-  new Map([[1, undefined]])
-);
-notUtilIsDeepStrict(
-  new Map([[1, null]]),
-  new Map([['1', undefined]])
-);
-notUtilIsDeepStrict(
-  new Map([[1, undefined]]),
-  new Map([[2, undefined]])
-);
+utilIsDeepStrict(new Map([[1, undefined]]), new Map([[1, undefined]]));
+notUtilIsDeepStrict(new Map([[1, null]]), new Map([['1', undefined]]));
+notUtilIsDeepStrict(new Map([[1, undefined]]), new Map([[2, undefined]]));
 
 // null as key
-utilIsDeepStrict(
-  new Map([[null, 3]]),
-  new Map([[null, 3]])
-);
-notUtilIsDeepStrict(
-  new Map([[null, undefined]]),
-  new Map([[undefined, null]])
-);
-notUtilIsDeepStrict(
-  new Set([null]),
-  new Set([undefined])
-);
+utilIsDeepStrict(new Map([[null, 3]]), new Map([[null, 3]]));
+notUtilIsDeepStrict(new Map([[null, undefined]]), new Map([[undefined, null]]));
+notUtilIsDeepStrict(new Set([null]), new Set([undefined]));
 
 // GH-6416. Make sure circular refs don't throw.
 {
@@ -290,14 +248,18 @@ notUtilIsDeepStrict(
 
 // GH-7178. Ensure reflexivity of deepEqual with `arguments` objects.
 {
-  const args = (function() { return arguments; })();
+  const args = (function() {
+    return arguments;
+  })();
   notUtilIsDeepStrict([], args);
 }
 
 // More checking that arguments objects are handled correctly
 {
   // eslint-disable-next-line func-style
-  const returnArguments = function() { return arguments; };
+  const returnArguments = function() {
+    return arguments;
+  };
 
   const someArgs = returnArguments('a');
   const sameArgs = returnArguments('a');
@@ -320,7 +282,7 @@ notUtilIsDeepStrict(
     true,
     {},
     [],
-    () => {},
+    () => {}
   ];
   utilIsDeepStrict(new Set(values), new Set(values));
   utilIsDeepStrict(new Set(values), new Set(values.reverse()));
@@ -410,7 +372,7 @@ notUtilIsDeepStrict(
 
 // Handle sparse arrays
 utilIsDeepStrict([1, , , 3], [1, , , 3]);
-notUtilIsDeepStrict([1, , , 3], [1, , , 3, , , ]);
+notUtilIsDeepStrict([1, , , 3], [1, , , 3, , ,]);
 
 // Handle different error messages
 {
@@ -426,7 +388,7 @@ notUtilIsDeepStrict([1, , , 3], [1, , , 3, , , ]);
 assert.strictEqual(util.isDeepStrictEqual(NaN, NaN), true);
 assert.strictEqual(util.isDeepStrictEqual({ a: NaN }, { a: NaN }), true);
 assert.strictEqual(
-  util.isDeepStrictEqual([ 1, 2, NaN, 4 ], [ 1, 2, NaN, 4 ]),
+  util.isDeepStrictEqual([1, 2, NaN, 4], [1, 2, NaN, 4]),
   true
 );
 
@@ -459,7 +421,7 @@ utilIsDeepStrict(-0, -0);
   const obj1 = { [symbol1]: 1 };
   const obj2 = { [symbol1]: 1 };
   const obj3 = { [Symbol()]: 1 };
-  const obj4 = { };
+  const obj4 = {};
   // Add a non enumerable symbol as well. It is going to be ignored!
   Object.defineProperty(obj2, Symbol(), { value: 1 });
   Object.defineProperty(obj4, symbol1, { value: 1 });
diff --git a/test/parallel/test-util-log.js b/test/parallel/test-util-log.js
index 3de79b835d85a3..ee4afbdd3f01f6 100644
--- a/test/parallel/test-util-log.js
+++ b/test/parallel/test-util-log.js
@@ -25,7 +25,7 @@ const {
   hijackStdout,
   hijackStderr,
   restoreStdout,
-  restoreStderr,
+  restoreStderr
 } = require('../common/hijackstdio');
 const assert = require('assert');
 const util = require('util');
diff --git a/test/parallel/test-util-promisify.js b/test/parallel/test-util-promisify.js
index 0bece0df426b7b..3c850c5bfa11ab 100644
--- a/test/parallel/test-util-promisify.js
+++ b/test/parallel/test-util-promisify.js
@@ -12,16 +12,20 @@ const stat = promisify(fs.stat);
 {
   const promise = stat(__filename);
   assert(promise instanceof Promise);
-  promise.then(common.mustCall((value) => {
-    assert.deepStrictEqual(value, fs.statSync(__filename));
-  }));
+  promise.then(
+    common.mustCall((value) => {
+      assert.deepStrictEqual(value, fs.statSync(__filename));
+    })
+  );
 }
 
 {
   const promise = stat('/dontexist');
-  promise.catch(common.mustCall((error) => {
-    assert(error.message.includes('ENOENT: no such file or directory, stat'));
-  }));
+  promise.catch(
+    common.mustCall((error) => {
+      assert(error.message.includes('ENOENT: no such file or directory, stat'));
+    })
+  );
 }
 
 {
@@ -35,10 +39,10 @@ const stat = promisify(fs.stat);
 {
   function fn() {}
   fn[promisify.custom] = 42;
-  common.expectsError(
-    () => promisify(fn),
-    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
-  );
+  common.expectsError(() => promisify(fn), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  });
 }
 
 {
@@ -51,60 +55,74 @@ const stat = promisify(fs.stat);
 
   fn[customPromisifyArgs] = ['first', 'second'];
 
-  promisify(fn)().then(common.mustCall((obj) => {
-    assert.deepStrictEqual(obj, { first: firstValue, second: secondValue });
-  }));
+  promisify(fn)().then(
+    common.mustCall((obj) => {
+      assert.deepStrictEqual(obj, { first: firstValue, second: secondValue });
+    })
+  );
 }
 
 {
   const fn = vm.runInNewContext('(function() {})');
-  assert.notStrictEqual(Object.getPrototypeOf(promisify(fn)),
-                        Function.prototype);
+  assert.notStrictEqual(
+    Object.getPrototypeOf(promisify(fn)),
+    Function.prototype
+  );
 }
 
 {
   function fn(callback) {
     callback(null, 'foo', 'bar');
   }
-  promisify(fn)().then(common.mustCall((value) => {
-    assert.deepStrictEqual(value, 'foo');
-  }));
+  promisify(fn)().then(
+    common.mustCall((value) => {
+      assert.deepStrictEqual(value, 'foo');
+    })
+  );
 }
 
 {
   function fn(callback) {
     callback(null);
   }
-  promisify(fn)().then(common.mustCall((value) => {
-    assert.strictEqual(value, undefined);
-  }));
+  promisify(fn)().then(
+    common.mustCall((value) => {
+      assert.strictEqual(value, undefined);
+    })
+  );
 }
 
 {
   function fn(callback) {
     callback();
   }
-  promisify(fn)().then(common.mustCall((value) => {
-    assert.strictEqual(value, undefined);
-  }));
+  promisify(fn)().then(
+    common.mustCall((value) => {
+      assert.strictEqual(value, undefined);
+    })
+  );
 }
 
 {
   function fn(err, val, callback) {
     callback(err, val);
   }
-  promisify(fn)(null, 42).then(common.mustCall((value) => {
-    assert.strictEqual(value, 42);
-  }));
+  promisify(fn)(null, 42).then(
+    common.mustCall((value) => {
+      assert.strictEqual(value, 42);
+    })
+  );
 }
 
 {
   function fn(err, val, callback) {
     callback(err, val);
   }
-  promisify(fn)(new Error('oops'), null).catch(common.mustCall((err) => {
-    assert.strictEqual(err.message, 'oops');
-  }));
+  promisify(fn)(new Error('oops'), null).catch(
+    common.mustCall((err) => {
+      assert.strictEqual(err.message, 'oops');
+    })
+  );
 }
 
 {
@@ -121,15 +139,16 @@ const stat = promisify(fs.stat);
 {
   const o = {};
   const fn = promisify(function(cb) {
-
     cb(null, this === o);
   });
 
   o.fn = fn;
 
-  o.fn().then(common.mustCall(function(val) {
-    assert(val);
-  }));
+  o.fn().then(
+    common.mustCall(function(val) {
+      assert(val);
+    })
+  );
 }
 
 {
@@ -149,8 +168,8 @@ const stat = promisify(fs.stat);
 }
 
 {
-  function c() { }
-  const a = promisify(function() { });
+  function c() {}
+  const a = promisify(function() {});
   const b = promisify(a);
   assert.notStrictEqual(c, a);
   assert.strictEqual(a, b);
@@ -171,7 +190,9 @@ const stat = promisify(fs.stat);
   const err = new Error();
 
   const a = promisify((cb) => cb(err))();
-  const b = promisify(() => { throw err; })();
+  const b = promisify(() => {
+    throw err;
+  })();
 
   Promise.all([
     a.then(assert.fail, function(e) {
@@ -184,12 +205,11 @@ const stat = promisify(fs.stat);
 }
 
 [undefined, null, true, 0, 'str', {}, [], Symbol()].forEach((input) => {
-  common.expectsError(
-    () => promisify(input),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "original" argument must be of type Function. ' +
-               `Received type ${typeof input}`
-    });
+  common.expectsError(() => promisify(input), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "original" argument must be of type Function. ' +
+      `Received type ${typeof input}`
+  });
 });
diff --git a/test/parallel/test-util-sigint-watchdog.js b/test/parallel/test-util-sigint-watchdog.js
index 7ac1261eabab40..5755c8b9dac136 100644
--- a/test/parallel/test-util-sigint-watchdog.js
+++ b/test/parallel/test-util-sigint-watchdog.js
@@ -10,52 +10,58 @@ const assert = require('assert');
 const { internalBinding } = require('internal/test/binding');
 const binding = internalBinding('util');
 
-[(next) => {
-  // Test with no signal observed.
-  binding.startSigintWatchdog();
-  const hadPendingSignals = binding.stopSigintWatchdog();
-  assert.strictEqual(hadPendingSignals, false);
-  next();
-},
- (next) => {
-   // Test with one call to the watchdog, one signal.
-   binding.startSigintWatchdog();
-   process.kill(process.pid, 'SIGINT');
-   waitForPendingSignal(common.mustCall(() => {
-     const hadPendingSignals = binding.stopSigintWatchdog();
-     assert.strictEqual(hadPendingSignals, true);
-     next();
-   }));
- },
- (next) => {
-   // Nested calls are okay.
-   binding.startSigintWatchdog();
-   binding.startSigintWatchdog();
-   process.kill(process.pid, 'SIGINT');
-   waitForPendingSignal(common.mustCall(() => {
-     const hadPendingSignals1 = binding.stopSigintWatchdog();
-     const hadPendingSignals2 = binding.stopSigintWatchdog();
-     assert.strictEqual(hadPendingSignals1, true);
-     assert.strictEqual(hadPendingSignals2, false);
-     next();
-   }));
- },
- () => {
-   // Signal comes in after first call to stop.
-   binding.startSigintWatchdog();
-   binding.startSigintWatchdog();
-   const hadPendingSignals1 = binding.stopSigintWatchdog();
-   process.kill(process.pid, 'SIGINT');
-   waitForPendingSignal(common.mustCall(() => {
-     const hadPendingSignals2 = binding.stopSigintWatchdog();
-     assert.strictEqual(hadPendingSignals1, false);
-     assert.strictEqual(hadPendingSignals2, true);
-   }));
- }].reduceRight((a, b) => common.mustCall(b).bind(null, a))();
+[
+  (next) => {
+    // Test with no signal observed.
+    binding.startSigintWatchdog();
+    const hadPendingSignals = binding.stopSigintWatchdog();
+    assert.strictEqual(hadPendingSignals, false);
+    next();
+  },
+  (next) => {
+    // Test with one call to the watchdog, one signal.
+    binding.startSigintWatchdog();
+    process.kill(process.pid, 'SIGINT');
+    waitForPendingSignal(
+      common.mustCall(() => {
+        const hadPendingSignals = binding.stopSigintWatchdog();
+        assert.strictEqual(hadPendingSignals, true);
+        next();
+      })
+    );
+  },
+  (next) => {
+    // Nested calls are okay.
+    binding.startSigintWatchdog();
+    binding.startSigintWatchdog();
+    process.kill(process.pid, 'SIGINT');
+    waitForPendingSignal(
+      common.mustCall(() => {
+        const hadPendingSignals1 = binding.stopSigintWatchdog();
+        const hadPendingSignals2 = binding.stopSigintWatchdog();
+        assert.strictEqual(hadPendingSignals1, true);
+        assert.strictEqual(hadPendingSignals2, false);
+        next();
+      })
+    );
+  },
+  () => {
+    // Signal comes in after first call to stop.
+    binding.startSigintWatchdog();
+    binding.startSigintWatchdog();
+    const hadPendingSignals1 = binding.stopSigintWatchdog();
+    process.kill(process.pid, 'SIGINT');
+    waitForPendingSignal(
+      common.mustCall(() => {
+        const hadPendingSignals2 = binding.stopSigintWatchdog();
+        assert.strictEqual(hadPendingSignals1, false);
+        assert.strictEqual(hadPendingSignals2, true);
+      })
+    );
+  }
+].reduceRight((a, b) => common.mustCall(b).bind(null, a))();
 
 function waitForPendingSignal(cb) {
-  if (binding.watchdogHasPendingSigint())
-    cb();
-  else
-    setTimeout(waitForPendingSignal, 10, cb);
+  if (binding.watchdogHasPendingSigint()) cb();
+  else setTimeout(waitForPendingSignal, 10, cb);
 }
diff --git a/test/parallel/test-util-types.js b/test/parallel/test-util-types.js
index 64434e574a2de3..a6a56337e90bbb 100644
--- a/test/parallel/test-util-types.js
+++ b/test/parallel/test-util-types.js
@@ -8,65 +8,75 @@ const vm = require('vm');
 const { internalBinding } = require('internal/test/binding');
 const { JSStream } = internalBinding('js_stream');
 
-const external = (new JSStream())._externalStream;
+const external = new JSStream()._externalStream;
 const wasmBuffer = fixtures.readSync('test.wasm');
 
-for (const [ value, _method ] of [
-  [ external, 'isExternal' ],
-  [ new Date() ],
-  [ (function() { return arguments; })(), 'isArgumentsObject' ],
-  [ new Boolean(), 'isBooleanObject' ],
-  [ new Number(), 'isNumberObject' ],
-  [ new String(), 'isStringObject' ],
-  [ Object(Symbol()), 'isSymbolObject' ],
-  [ Object(BigInt(0)), 'isBigIntObject' ],
-  [ new Error(), 'isNativeError' ],
-  [ new RegExp() ],
-  [ async function() {}, 'isAsyncFunction' ],
-  [ function*() {}, 'isGeneratorFunction' ],
-  [ (function*() {})(), 'isGeneratorObject' ],
-  [ Promise.resolve() ],
-  [ new Map() ],
-  [ new Set() ],
-  [ (new Map())[Symbol.iterator](), 'isMapIterator' ],
-  [ (new Set())[Symbol.iterator](), 'isSetIterator' ],
-  [ new WeakMap() ],
-  [ new WeakSet() ],
-  [ new ArrayBuffer() ],
-  [ new Uint8Array() ],
-  [ new Uint8ClampedArray() ],
-  [ new Uint16Array() ],
-  [ new Uint32Array() ],
-  [ new Int8Array() ],
-  [ new Int16Array() ],
-  [ new Int32Array() ],
-  [ new Float32Array() ],
-  [ new Float64Array() ],
-  [ new BigInt64Array() ],
-  [ new BigUint64Array() ],
-  [ Object.defineProperty(new Uint8Array(),
-                          Symbol.toStringTag,
-                          { value: 'foo' }) ],
-  [ new DataView(new ArrayBuffer()) ],
-  [ new SharedArrayBuffer() ],
-  [ new Proxy({}, {}), 'isProxy' ],
-  [ new WebAssembly.Module(wasmBuffer), 'isWebAssemblyCompiledModule' ],
+for (const [value, _method] of [
+  [external, 'isExternal'],
+  [new Date()],
+  [
+    (function() {
+      return arguments;
+    })(),
+    'isArgumentsObject'
+  ],
+  [new Boolean(), 'isBooleanObject'],
+  [new Number(), 'isNumberObject'],
+  [new String(), 'isStringObject'],
+  [Object(Symbol()), 'isSymbolObject'],
+  [Object(BigInt(0)), 'isBigIntObject'],
+  [new Error(), 'isNativeError'],
+  [new RegExp()],
+  [async function() {}, 'isAsyncFunction'],
+  [function*() {}, 'isGeneratorFunction'],
+  [(function*() {})(), 'isGeneratorObject'],
+  [Promise.resolve()],
+  [new Map()],
+  [new Set()],
+  [new Map()[Symbol.iterator](), 'isMapIterator'],
+  [new Set()[Symbol.iterator](), 'isSetIterator'],
+  [new WeakMap()],
+  [new WeakSet()],
+  [new ArrayBuffer()],
+  [new Uint8Array()],
+  [new Uint8ClampedArray()],
+  [new Uint16Array()],
+  [new Uint32Array()],
+  [new Int8Array()],
+  [new Int16Array()],
+  [new Int32Array()],
+  [new Float32Array()],
+  [new Float64Array()],
+  [new BigInt64Array()],
+  [new BigUint64Array()],
+  [
+    Object.defineProperty(new Uint8Array(), Symbol.toStringTag, {
+      value: 'foo'
+    })
+  ],
+  [new DataView(new ArrayBuffer())],
+  [new SharedArrayBuffer()],
+  [new Proxy({}, {}), 'isProxy'],
+  [new WebAssembly.Module(wasmBuffer), 'isWebAssemblyCompiledModule']
 ]) {
   const method = _method || `is${value.constructor.name}`;
   assert(method in types, `Missing ${method} for ${inspect(value)}`);
   assert(types[method](value), `Want ${inspect(value)} to match ${method}`);
 
   for (const key of Object.keys(types)) {
-    if ((types.isArrayBufferView(value) ||
-         types.isAnyArrayBuffer(value)) && key.includes('Array') ||
-         key === 'isBoxedPrimitive') {
+    if (
+      ((types.isArrayBufferView(value) || types.isAnyArrayBuffer(value)) &&
+        key.includes('Array')) ||
+      key === 'isBoxedPrimitive'
+    ) {
       continue;
     }
 
-    assert.strictEqual(types[key](value),
-                       key === method,
-                       `${inspect(value)}: ${key}, ` +
-                       `${method}, ${types[key](value)}`);
+    assert.strictEqual(
+      types[key](value),
+      key === method,
+      `${inspect(value)}: ${key}, ` + `${method}, ${types[key](value)}`
+    );
   }
 }
 
@@ -97,30 +107,53 @@ for (const [ value, _method ] of [
   const fakeUint8Array = Object.create(Uint8Array.prototype);
   const fakeBuffer = Object.create(Buffer.prototype);
 
-  const stealthyDataView =
-      Object.setPrototypeOf(new DataView(arrayBuffer), Uint8Array.prototype);
-  const stealthyInt32Array =
-      Object.setPrototypeOf(new Int32Array(arrayBuffer), uint8Array);
-  const stealthyUint8Array =
-      Object.setPrototypeOf(new Uint8Array(arrayBuffer), ArrayBuffer.prototype);
+  const stealthyDataView = Object.setPrototypeOf(
+    new DataView(arrayBuffer),
+    Uint8Array.prototype
+  );
+  const stealthyInt32Array = Object.setPrototypeOf(
+    new Int32Array(arrayBuffer),
+    uint8Array
+  );
+  const stealthyUint8Array = Object.setPrototypeOf(
+    new Uint8Array(arrayBuffer),
+    ArrayBuffer.prototype
+  );
 
   const all = [
-    primitive, arrayBuffer, dataView, int32Array, uint8Array, buffer,
-    fakeDataView, fakeInt32Array, fakeUint8Array, fakeBuffer,
-    stealthyDataView, stealthyInt32Array, stealthyUint8Array
+    primitive,
+    arrayBuffer,
+    dataView,
+    int32Array,
+    uint8Array,
+    buffer,
+    fakeDataView,
+    fakeInt32Array,
+    fakeUint8Array,
+    fakeBuffer,
+    stealthyDataView,
+    stealthyInt32Array,
+    stealthyUint8Array
   ];
 
   const expected = {
     isArrayBufferView: [
-      dataView, int32Array, uint8Array, buffer,
-      stealthyDataView, stealthyInt32Array, stealthyUint8Array
+      dataView,
+      int32Array,
+      uint8Array,
+      buffer,
+      stealthyDataView,
+      stealthyInt32Array,
+      stealthyUint8Array
     ],
     isTypedArray: [
-      int32Array, uint8Array, buffer, stealthyInt32Array, stealthyUint8Array
+      int32Array,
+      uint8Array,
+      buffer,
+      stealthyInt32Array,
+      stealthyUint8Array
     ],
-    isUint8Array: [
-      uint8Array, buffer, stealthyUint8Array
-    ]
+    isUint8Array: [uint8Array, buffer, stealthyUint8Array]
   };
 
   for (const testedFunc of Object.keys(expected)) {
diff --git a/test/parallel/test-uv-binding-constant.js b/test/parallel/test-uv-binding-constant.js
index 11d9f6aa09cfd1..34b255e05e0f5e 100644
--- a/test/parallel/test-uv-binding-constant.js
+++ b/test/parallel/test-uv-binding-constant.js
@@ -13,8 +13,10 @@ const keys = Object.keys(uv);
 keys.forEach((key) => {
   if (key.startsWith('UV_')) {
     const val = uv[key];
-    assert.throws(() => uv[key] = 1,
-                  /^TypeError: Cannot assign to read only property/);
+    assert.throws(
+      () => (uv[key] = 1),
+      /^TypeError: Cannot assign to read only property/
+    );
     assert.strictEqual(uv[key], val);
   }
 });
diff --git a/test/parallel/test-uv-errno.js b/test/parallel/test-uv-errno.js
index 078db29adce923..848fadd1a00f1b 100644
--- a/test/parallel/test-uv-errno.js
+++ b/test/parallel/test-uv-errno.js
@@ -3,18 +3,14 @@
 
 const common = require('../common');
 const assert = require('assert');
-const {
-  getSystemErrorName,
-  _errnoException
-} = require('util');
+const { getSystemErrorName, _errnoException } = require('util');
 
 const { internalBinding } = require('internal/test/binding');
 const uv = internalBinding('uv');
 const keys = Object.keys(uv);
 
 keys.forEach((key) => {
-  if (!key.startsWith('UV_'))
-    return;
+  if (!key.startsWith('UV_')) return;
 
   const err = _errnoException(uv[key], 'test');
   const name = uv.errname(uv[key]);
@@ -26,26 +22,24 @@ keys.forEach((key) => {
 
 function runTest(fn) {
   ['test', {}, []].forEach((err) => {
-    common.expectsError(
-      () => fn(err),
-      {
-        code: 'ERR_INVALID_ARG_TYPE',
-        type: TypeError,
-        message: 'The "err" argument must be of type number. ' +
-                 `Received type ${typeof err}`
-      });
+    common.expectsError(() => fn(err), {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "err" argument must be of type number. ' +
+        `Received type ${typeof err}`
+    });
   });
 
   [0, 1, Infinity, -Infinity, NaN].forEach((err) => {
-    common.expectsError(
-      () => fn(err),
-      {
-        code: 'ERR_OUT_OF_RANGE',
-        type: RangeError,
-        message: 'The value of "err" is out of range. ' +
-                 'It must be a negative integer. ' +
-                 `Received ${err}`
-      });
+    common.expectsError(() => fn(err), {
+      code: 'ERR_OUT_OF_RANGE',
+      type: RangeError,
+      message:
+        'The value of "err" is out of range. ' +
+        'It must be a negative integer. ' +
+        `Received ${err}`
+    });
   });
 }
 
diff --git a/test/parallel/test-v8-coverage.js b/test/parallel/test-v8-coverage.js
index 191835fe0f5af9..b812729c8216ae 100644
--- a/test/parallel/test-v8-coverage.js
+++ b/test/parallel/test-v8-coverage.js
@@ -19,9 +19,11 @@ function nextdir() {
 // outputs coverage when event loop is drained, with no async logic.
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
-  const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/basic')
-  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const output = spawnSync(
+    process.execPath,
+    [require.resolve('../fixtures/v8-coverage/basic')],
+    { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } }
+  );
   assert.strictEqual(output.status, 0);
   const fixtureCoverage = getFixtureCoverage('basic.js', coverageDirectory);
   assert.ok(fixtureCoverage);
@@ -34,9 +36,11 @@ function nextdir() {
 // outputs coverage when process.exit(1) exits process.
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
-  const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/exit-1')
-  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const output = spawnSync(
+    process.execPath,
+    [require.resolve('../fixtures/v8-coverage/exit-1')],
+    { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } }
+  );
   assert.strictEqual(output.status, 1);
   const fixtureCoverage = getFixtureCoverage('exit-1.js', coverageDirectory);
   assert.ok(fixtureCoverage, 'coverage not found for file');
@@ -49,9 +53,11 @@ function nextdir() {
 // outputs coverage when process.kill(process.pid, "SIGINT"); exits process.
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
-  const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/sigint')
-  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const output = spawnSync(
+    process.execPath,
+    [require.resolve('../fixtures/v8-coverage/sigint')],
+    { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } }
+  );
   if (!common.isWindows) {
     assert.strictEqual(output.signal, 'SIGINT');
   }
@@ -66,12 +72,16 @@ function nextdir() {
 // outputs coverage from subprocess.
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
-  const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/spawn-subprocess')
-  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const output = spawnSync(
+    process.execPath,
+    [require.resolve('../fixtures/v8-coverage/spawn-subprocess')],
+    { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } }
+  );
   assert.strictEqual(output.status, 0);
-  const fixtureCoverage = getFixtureCoverage('subprocess.js',
-                                             coverageDirectory);
+  const fixtureCoverage = getFixtureCoverage(
+    'subprocess.js',
+    coverageDirectory
+  );
   assert.ok(fixtureCoverage);
   // first branch executed.
   assert.strictEqual(fixtureCoverage.functions[2].ranges[0].count, 1);
@@ -82,13 +92,19 @@ function nextdir() {
 // outputs coverage from worker.
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
-  const output = spawnSync(process.execPath, [
-    '--experimental-worker',
-    require.resolve('../fixtures/v8-coverage/worker')
-  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const output = spawnSync(
+    process.execPath,
+    [
+      '--experimental-worker',
+      require.resolve('../fixtures/v8-coverage/worker')
+    ],
+    { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } }
+  );
   assert.strictEqual(output.status, 0);
-  const fixtureCoverage = getFixtureCoverage('subprocess.js',
-                                             coverageDirectory);
+  const fixtureCoverage = getFixtureCoverage(
+    'subprocess.js',
+    coverageDirectory
+  );
   assert.ok(fixtureCoverage);
   // first branch executed.
   assert.strictEqual(fixtureCoverage.functions[2].ranges[0].count, 1);
@@ -99,24 +115,32 @@ function nextdir() {
 // does not output coverage if NODE_V8_COVERAGE is empty.
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
-  const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/spawn-subprocess-no-cov')
-  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const output = spawnSync(
+    process.execPath,
+    [require.resolve('../fixtures/v8-coverage/spawn-subprocess-no-cov')],
+    { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } }
+  );
   assert.strictEqual(output.status, 0);
-  const fixtureCoverage = getFixtureCoverage('subprocess.js',
-                                             coverageDirectory);
+  const fixtureCoverage = getFixtureCoverage(
+    'subprocess.js',
+    coverageDirectory
+  );
   assert.strictEqual(fixtureCoverage, undefined);
 }
 
 // disables async hooks before writing coverage.
 {
   const coverageDirectory = path.join(tmpdir.path, nextdir());
-  const output = spawnSync(process.execPath, [
-    require.resolve('../fixtures/v8-coverage/async-hooks')
-  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const output = spawnSync(
+    process.execPath,
+    [require.resolve('../fixtures/v8-coverage/async-hooks')],
+    { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } }
+  );
   assert.strictEqual(output.status, 0);
-  const fixtureCoverage = getFixtureCoverage('async-hooks.js',
-                                             coverageDirectory);
+  const fixtureCoverage = getFixtureCoverage(
+    'async-hooks.js',
+    coverageDirectory
+  );
   assert.ok(fixtureCoverage);
   // first branch executed.
   assert.strictEqual(fixtureCoverage.functions[1].ranges[0].count, 1);
diff --git a/test/parallel/test-v8-flag-type-check.js b/test/parallel/test-v8-flag-type-check.js
index 1dcdee928b1ec3..f34a650f7ea36a 100644
--- a/test/parallel/test-v8-flag-type-check.js
+++ b/test/parallel/test-v8-flag-type-check.js
@@ -3,13 +3,11 @@ const common = require('../common');
 const v8 = require('v8');
 
 [1, undefined].forEach((value) => {
-  common.expectsError(
-    () => v8.setFlagsFromString(value),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message: 'The "flags" argument must be of type string. ' +
-               `Received type ${typeof value}`
-    }
-  );
+  common.expectsError(() => v8.setFlagsFromString(value), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "flags" argument must be of type string. ' +
+      `Received type ${typeof value}`
+  });
 });
diff --git a/test/parallel/test-v8-flags.js b/test/parallel/test-v8-flags.js
index 50d7047a5ddfa9..7a566cb616007e 100644
--- a/test/parallel/test-v8-flags.js
+++ b/test/parallel/test-v8-flags.js
@@ -12,7 +12,9 @@ assert(eval('%_IsSmi(42)'));
 assert(vm.runInThisContext('%_IsSmi(43)'));
 
 v8.setFlagsFromString('--noallow_natives_syntax');
-assert.throws(function() { eval('%_IsSmi(44)'); },
-              /^SyntaxError: Unexpected token %$/);
-assert.throws(function() { vm.runInThisContext('%_IsSmi(45)'); },
-              /^SyntaxError: Unexpected token %$/);
+assert.throws(function() {
+  eval('%_IsSmi(44)');
+}, /^SyntaxError: Unexpected token %$/);
+assert.throws(function() {
+  vm.runInThisContext('%_IsSmi(45)');
+}, /^SyntaxError: Unexpected token %$/);
diff --git a/test/parallel/test-v8-serdes.js b/test/parallel/test-v8-serdes.js
index c019674f4592e4..b80e0d275f34a1 100644
--- a/test/parallel/test-v8-serdes.js
+++ b/test/parallel/test-v8-serdes.js
@@ -23,12 +23,10 @@ const objects = [
   circular
 ];
 
-const hostObject = new (internalBinding('js_stream').JSStream)();
+const hostObject = new (internalBinding('js_stream')).JSStream();
 
-const serializerTypeError =
-  /^TypeError: Class constructor Serializer cannot be invoked without 'new'$/;
-const deserializerTypeError =
-  /^TypeError: Class constructor Deserializer cannot be invoked without 'new'$/;
+const serializerTypeError = /^TypeError: Class constructor Serializer cannot be invoked without 'new'$/;
+const deserializerTypeError = /^TypeError: Class constructor Deserializer cannot be invoked without 'new'$/;
 
 {
   const ser = new v8.DefaultSerializer();
@@ -152,8 +150,10 @@ const deserializerTypeError =
 }
 
 {
-  assert.throws(() => v8.serialize(hostObject),
-                /^Error: Unknown host object type: \[object .*\]$/);
+  assert.throws(
+    () => v8.serialize(hostObject),
+    /^Error: Unknown host object type: \[object .*\]$/
+  );
 }
 
 {
@@ -177,8 +177,10 @@ const deserializerTypeError =
   buf.write('ff0d5c0404addeefbe', 32, 'hex');
   buf = buf.slice(32);
 
-  const expectedResult = os.endianness() === 'LE' ?
-    new Uint16Array([0xdead, 0xbeef]) : new Uint16Array([0xadde, 0xefbe]);
+  const expectedResult =
+    os.endianness() === 'LE'
+      ? new Uint16Array([0xdead, 0xbeef])
+      : new Uint16Array([0xadde, 0xefbe]);
 
   assert.deepStrictEqual(v8.deserialize(buf), expectedResult);
 }
@@ -188,7 +190,6 @@ const deserializerTypeError =
   assert.throws(v8.Deserializer, deserializerTypeError);
 }
 
-
 // `v8.deserialize()` and `new v8.Deserializer()` should support both
 // `TypedArray` and `DataView`.
 {
@@ -219,14 +220,14 @@ const deserializerTypeError =
   serializer.writeHeader();
   assert.throws(
     () => serializer.writeRawBytes(INVALID_SOURCE),
-    /^TypeError: source must be a TypedArray or a DataView$/,
+    /^TypeError: source must be a TypedArray or a DataView$/
   );
   assert.throws(
     () => v8.deserialize(INVALID_SOURCE),
-    /^TypeError: buffer must be a TypedArray or a DataView$/,
+    /^TypeError: buffer must be a TypedArray or a DataView$/
   );
   assert.throws(
     () => new v8.Deserializer(INVALID_SOURCE),
-    /^TypeError: buffer must be a TypedArray or a DataView$/,
+    /^TypeError: buffer must be a TypedArray or a DataView$/
   );
 }
diff --git a/test/parallel/test-v8-stats.js b/test/parallel/test-v8-stats.js
index 4bebf37c0553e3..46cf2a33a09a67 100644
--- a/test/parallel/test-v8-stats.js
+++ b/test/parallel/test-v8-stats.js
@@ -13,13 +13,13 @@ const keys = [
   'total_heap_size',
   'total_heap_size_executable',
   'total_physical_size',
-  'used_heap_size'];
+  'used_heap_size'
+];
 assert.deepStrictEqual(Object.keys(s).sort(), keys);
 keys.forEach(function(key) {
   assert.strictEqual(typeof s[key], 'number');
 });
 
-
 const expectedHeapSpaces = [
   'new_space',
   'old_space',
diff --git a/test/parallel/test-vm-api-handles-getter-errors.js b/test/parallel/test-vm-api-handles-getter-errors.js
index 6a74fb29c17c81..dc740af710c200 100644
--- a/test/parallel/test-vm-api-handles-getter-errors.js
+++ b/test/parallel/test-vm-api-handles-getter-errors.js
@@ -9,27 +9,35 @@ const execFile = require('child_process').execFile;
 
 const scripts = [];
 
-['filename', 'cachedData', 'produceCachedData', 'lineOffset', 'columnOffset']
-  .forEach((prop) => {
-    scripts.push(`vm.createScript('', {
+[
+  'filename',
+  'cachedData',
+  'produceCachedData',
+  'lineOffset',
+  'columnOffset'
+].forEach((prop) => {
+  scripts.push(`vm.createScript('', {
       get ${prop} () {
         throw new Error('xyz');
       }
     })`);
-  });
+});
 
-['breakOnSigint', 'timeout', 'displayErrors']
-  .forEach((prop) => {
-    scripts.push(`vm.createScript('').runInThisContext({
+['breakOnSigint', 'timeout', 'displayErrors'].forEach((prop) => {
+  scripts.push(`vm.createScript('').runInThisContext({
       get ${prop} () {
         throw new Error('xyz');
       }
     })`);
-  });
+});
 
 scripts.forEach((script) => {
   const node = process.execPath;
-  execFile(node, [ '-e', script ], common.mustCall((err, stdout, stderr) => {
-    assert(stderr.includes('Error: xyz'), 'createScript crashes');
-  }));
+  execFile(
+    node,
+    ['-e', script],
+    common.mustCall((err, stdout, stderr) => {
+      assert(stderr.includes('Error: xyz'), 'createScript crashes');
+    })
+  );
 });
diff --git a/test/parallel/test-vm-basic.js b/test/parallel/test-vm-basic.js
index 29e2a8b5251934..dd4df5c3ec65d9 100644
--- a/test/parallel/test-vm-basic.js
+++ b/test/parallel/test-vm-basic.js
@@ -33,7 +33,7 @@ const vm = require('vm');
   );
   assert.deepStrictEqual(sandbox, {
     foo: 'bar',
-    typeofProcess: 'undefined',
+    typeofProcess: 'undefined'
   });
   assert.strictEqual(result, 'function');
 }
@@ -66,9 +66,7 @@ const vm = require('vm');
 
 // vm.runInNewContext
 {
-  const result = vm.runInNewContext(
-    'vmResult = "foo"; typeof process;'
-  );
+  const result = vm.runInNewContext('vmResult = "foo"; typeof process;');
   assert.strictEqual(global.vmResult, undefined);
   assert.strictEqual(result, 'undefined');
 }
@@ -97,36 +95,48 @@ const vm = require('vm');
 
 // Invalid arguments
 [null, 'string'].forEach((input) => {
-  common.expectsError(() => {
-    vm.createContext({}, input);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options" argument must be of type Object. ' +
-             `Received type ${typeof input}`
-  });
+  common.expectsError(
+    () => {
+      vm.createContext({}, input);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        'The "options" argument must be of type Object. ' +
+        `Received type ${typeof input}`
+    }
+  );
 });
 
 ['name', 'origin'].forEach((propertyName) => {
-  common.expectsError(() => {
-    vm.createContext({}, { [propertyName]: null });
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: `The "options.${propertyName}" property must be of type string. ` +
-             'Received type object'
-  });
+  common.expectsError(
+    () => {
+      vm.createContext({}, { [propertyName]: null });
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        `The "options.${propertyName}" property must be of type string. ` +
+        'Received type object'
+    }
+  );
 });
 
 ['contextName', 'contextOrigin'].forEach((propertyName) => {
-  common.expectsError(() => {
-    vm.runInNewContext('', {}, { [propertyName]: null });
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: `The "options.${propertyName}" property must be of type string. ` +
-             'Received type object'
-  });
+  common.expectsError(
+    () => {
+      vm.runInNewContext('', {}, { [propertyName]: null });
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message:
+        `The "options.${propertyName}" property must be of type string. ` +
+        'Received type object'
+    }
+  );
 });
 
 // vm.compileFunction
@@ -137,30 +147,36 @@ const vm = require('vm');
   );
 
   assert.strictEqual(
-    vm.compileFunction(
-      'return p + q + r + s + t',
-      ['p', 'q', 'r', 's', 't']
-    )('ab', 'cd', 'ef', 'gh', 'ij'),
+    vm.compileFunction('return p + q + r + s + t', ['p', 'q', 'r', 's', 't'])(
+      'ab',
+      'cd',
+      'ef',
+      'gh',
+      'ij'
+    ),
     'abcdefghij'
   );
 
   vm.compileFunction('return'); // Should not throw on 'return'
 
-  common.expectsError(() => {
-    vm.compileFunction(
-      '});\n\n(function() {\nconsole.log(1);\n})();\n\n(function() {'
-    );
-  }, {
-    type: SyntaxError,
-    message: 'Unexpected token }'
-  });
+  common.expectsError(
+    () => {
+      vm.compileFunction(
+        '});\n\n(function() {\nconsole.log(1);\n})();\n\n(function() {'
+      );
+    },
+    {
+      type: SyntaxError,
+      message: 'Unexpected token }'
+    }
+  );
 
   // Tests for failed argument validation
   common.expectsError(() => vm.compileFunction(), {
     type: TypeError,
     code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "code" argument must be of type string. ' +
-      'Received type undefined'
+    message:
+      'The "code" argument must be of type string. ' + 'Received type undefined'
   });
 
   vm.compileFunction(''); // Should pass without params or options
@@ -168,160 +184,166 @@ const vm = require('vm');
   common.expectsError(() => vm.compileFunction('', null), {
     type: TypeError,
     code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "params" argument must be of type Array. ' +
-      'Received type object'
+    message:
+      'The "params" argument must be of type Array. ' + 'Received type object'
   });
 
   // vm.compileFunction('', undefined, null);
 
   const optionTypes = {
-    'filename': 'string',
-    'columnOffset': 'number',
-    'lineOffset': 'number',
-    'cachedData': 'Buffer, TypedArray, or DataView',
-    'produceCachedData': 'boolean',
+    filename: 'string',
+    columnOffset: 'number',
+    lineOffset: 'number',
+    cachedData: 'Buffer, TypedArray, or DataView',
+    produceCachedData: 'boolean'
   };
 
   for (const option in optionTypes) {
-    const typeErrorMessage = `The "options.${option}" property must be ` +
-       `${option === 'cachedData' ? 'one of' : 'of'} type`;
-    common.expectsError(() => {
-      vm.compileFunction('', undefined, { [option]: null });
-    }, {
-      type: TypeError,
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: typeErrorMessage +
-        ` ${optionTypes[option]}. Received type object`
-    });
+    const typeErrorMessage =
+      `The "options.${option}" property must be ` +
+      `${option === 'cachedData' ? 'one of' : 'of'} type`;
+    common.expectsError(
+      () => {
+        vm.compileFunction('', undefined, { [option]: null });
+      },
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_ARG_TYPE',
+        message:
+          typeErrorMessage + ` ${optionTypes[option]}. Received type object`
+      }
+    );
   }
 
   // Testing for context-based failures
-  [Boolean(), Number(), null, String(), Symbol(), {}].forEach(
-    (value) => {
-      common.expectsError(() => {
+  [Boolean(), Number(), null, String(), Symbol(), {}].forEach((value) => {
+    common.expectsError(
+      () => {
         vm.compileFunction('', undefined, { parsingContext: value });
-      }, {
+      },
+      {
         type: TypeError,
         code: 'ERR_INVALID_ARG_TYPE',
-        message: 'The "options.parsingContext" property must be of type ' +
+        message:
+          'The "options.parsingContext" property must be of type ' +
           `Context. Received type ${typeof value}`
-      });
-    }
-  );
+      }
+    );
+  });
 
   // Testing for non Array type-based failures
-  [Boolean(), Number(), null, Object(), Symbol(), {}].forEach(
-    (value) => {
-      common.expectsError(() => {
+  [Boolean(), Number(), null, Object(), Symbol(), {}].forEach((value) => {
+    common.expectsError(
+      () => {
         vm.compileFunction('', value);
-      }, {
+      },
+      {
         type: TypeError,
         code: 'ERR_INVALID_ARG_TYPE',
-        message: 'The "params" argument must be of type Array. ' +
+        message:
+          'The "params" argument must be of type Array. ' +
           `Received type ${typeof value}`
-      });
-    }
-  );
+      }
+    );
+  });
 
   assert.strictEqual(
-    vm.compileFunction(
-      'return a;',
-      undefined,
-      { contextExtensions: [{ a: 5 }] }
-    )(),
+    vm.compileFunction('return a;', undefined, {
+      contextExtensions: [{ a: 5 }]
+    })(),
     5
   );
 
-  common.expectsError(() => {
-    vm.compileFunction('', undefined, { contextExtensions: null });
-  }, {
-    type: TypeError,
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "options.contextExtensions" property must be of type Array' +
-       '. Received type object'
-  });
+  common.expectsError(
+    () => {
+      vm.compileFunction('', undefined, { contextExtensions: null });
+    },
+    {
+      type: TypeError,
+      code: 'ERR_INVALID_ARG_TYPE',
+      message:
+        'The "options.contextExtensions" property must be of type Array' +
+        '. Received type object'
+    }
+  );
 
-  common.expectsError(() => {
-    vm.compileFunction('', undefined, { contextExtensions: [0] });
-  }, {
-    type: TypeError,
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "options.contextExtensions[0]" property must be of type ' +
-       'object. Received type number'
-  });
+  common.expectsError(
+    () => {
+      vm.compileFunction('', undefined, { contextExtensions: [0] });
+    },
+    {
+      type: TypeError,
+      code: 'ERR_INVALID_ARG_TYPE',
+      message:
+        'The "options.contextExtensions[0]" property must be of type ' +
+        'object. Received type number'
+    }
+  );
 
   const oldLimit = Error.stackTraceLimit;
   // Setting value to run the last three tests
   Error.stackTraceLimit = 1;
 
-  common.expectsError(() => {
-    vm.compileFunction('throw new Error("Sample Error")')();
-  }, {
-    message: 'Sample Error',
-    stack: 'Error: Sample Error\n    at <anonymous>:1:7'
-  });
+  common.expectsError(
+    () => {
+      vm.compileFunction('throw new Error("Sample Error")')();
+    },
+    {
+      message: 'Sample Error',
+      stack: 'Error: Sample Error\n    at <anonymous>:1:7'
+    }
+  );
 
-  common.expectsError(() => {
-    vm.compileFunction(
-      'throw new Error("Sample Error")',
-      [],
-      { lineOffset: 3 }
-    )();
-  }, {
-    message: 'Sample Error',
-    stack: 'Error: Sample Error\n    at <anonymous>:4:7'
-  });
+  common.expectsError(
+    () => {
+      vm.compileFunction('throw new Error("Sample Error")', [], {
+        lineOffset: 3
+      })();
+    },
+    {
+      message: 'Sample Error',
+      stack: 'Error: Sample Error\n    at <anonymous>:4:7'
+    }
+  );
 
-  common.expectsError(() => {
-    vm.compileFunction(
-      'throw new Error("Sample Error")',
-      [],
-      { columnOffset: 3 }
-    )();
-  }, {
-    message: 'Sample Error',
-    stack: 'Error: Sample Error\n    at <anonymous>:1:10'
-  });
+  common.expectsError(
+    () => {
+      vm.compileFunction('throw new Error("Sample Error")', [], {
+        columnOffset: 3
+      })();
+    },
+    {
+      message: 'Sample Error',
+      stack: 'Error: Sample Error\n    at <anonymous>:1:10'
+    }
+  );
 
   assert.strictEqual(
-    vm.compileFunction(
-      'return varInContext',
-      [],
-      {
-        parsingContext: vm.createContext({ varInContext: 'abc' })
-      }
-    )(),
+    vm.compileFunction('return varInContext', [], {
+      parsingContext: vm.createContext({ varInContext: 'abc' })
+    })(),
     'abc'
   );
 
-  common.expectsError(() => {
-    vm.compileFunction(
-      'return varInContext',
-      []
-    )();
-  }, {
-    message: 'varInContext is not defined',
-    stack: 'ReferenceError: varInContext is not defined\n    at <anonymous>:1:1'
-  });
+  common.expectsError(
+    () => {
+      vm.compileFunction('return varInContext', [])();
+    },
+    {
+      message: 'varInContext is not defined',
+      stack:
+        'ReferenceError: varInContext is not defined\n    at <anonymous>:1:1'
+    }
+  );
 
   assert.notDeepStrictEqual(
-    vm.compileFunction(
-      'return global',
-      [],
-      {
-        parsingContext: vm.createContext({ global: {} })
-      }
-    )(),
+    vm.compileFunction('return global', [], {
+      parsingContext: vm.createContext({ global: {} })
+    })(),
     global
   );
 
-  assert.deepStrictEqual(
-    vm.compileFunction(
-      'return global',
-      []
-    )(),
-    global
-  );
+  assert.deepStrictEqual(vm.compileFunction('return global', [])(), global);
 
   // Resetting value
   Error.stackTraceLimit = oldLimit;
diff --git a/test/parallel/test-vm-cached-data.js b/test/parallel/test-vm-cached-data.js
index 1b14999cdbc2f7..b5db97eb70e5f8 100644
--- a/test/parallel/test-vm-cached-data.js
+++ b/test/parallel/test-vm-cached-data.js
@@ -9,10 +9,11 @@ function getSource(tag) {
 }
 
 function produce(source, count) {
-  if (!count)
-    count = 1;
+  if (!count) count = 1;
 
-  const out = spawnSync(process.execPath, [ '-e', `
+  const out = spawnSync(process.execPath, [
+    '-e',
+    `
     'use strict';
     const assert = require('assert');
     const vm = require('vm');
@@ -29,7 +30,9 @@ function produce(source, count) {
         data = script.cachedData.toString('base64');
     }
     console.log(data);
-  `, source]);
+  `,
+    source
+  ]);
 
   assert.strictEqual(out.status, 0, String(out.stderr));
 
@@ -86,12 +89,15 @@ function testRejectSlice() {
 testRejectSlice();
 
 // It should throw on non-Buffer cachedData
-common.expectsError(() => {
-  new vm.Script('function abc() {}', {
-    cachedData: 'ohai'
-  });
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: /must be one of type Buffer, TypedArray, or DataView/
-});
+common.expectsError(
+  () => {
+    new vm.Script('function abc() {}', {
+      cachedData: 'ohai'
+    });
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message: /must be one of type Buffer, TypedArray, or DataView/
+  }
+);
diff --git a/test/parallel/test-vm-codegen.js b/test/parallel/test-vm-codegen.js
index ebafe30c076e01..e96afe5b3732d4 100644
--- a/test/parallel/test-vm-codegen.js
+++ b/test/parallel/test-vm-codegen.js
@@ -5,19 +5,24 @@ const assert = require('assert');
 
 const { createContext, runInContext, runInNewContext } = require('vm');
 
-const WASM_BYTES = Buffer.from(
-  [0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]);
-
+const WASM_BYTES = Buffer.from([
+  0x00,
+  0x61,
+  0x73,
+  0x6d,
+  0x01,
+  0x00,
+  0x00,
+  0x00
+]);
 
 function expectsError(fn, type) {
   try {
     fn();
     assert.fail('expected fn to error');
   } catch (err) {
-    if (typeof type === 'string')
-      assert.strictEqual(err.name, type);
-    else
-      assert(err instanceof type);
+    if (typeof type === 'string') assert.strictEqual(err.name, type);
+    else assert(err instanceof type);
   }
 }
 
@@ -26,17 +31,24 @@ function expectsError(fn, type) {
   const test = 'eval(""); new WebAssembly.Module(WASM_BYTES);';
   runInContext(test, ctx);
 
-  runInNewContext(test, { WASM_BYTES }, {
-    contextCodeGeneration: undefined,
-  });
+  runInNewContext(
+    test,
+    { WASM_BYTES },
+    {
+      contextCodeGeneration: undefined
+    }
+  );
 }
 
 {
-  const ctx = createContext({}, {
-    codeGeneration: {
-      strings: false,
-    },
-  });
+  const ctx = createContext(
+    {},
+    {
+      codeGeneration: {
+        strings: false
+      }
+    }
+  );
 
   const EvalError = runInContext('EvalError', ctx);
   expectsError(() => {
@@ -45,11 +57,14 @@ function expectsError(fn, type) {
 }
 
 {
-  const ctx = createContext({ WASM_BYTES }, {
-    codeGeneration: {
-      wasm: false,
-    },
-  });
+  const ctx = createContext(
+    { WASM_BYTES },
+    {
+      codeGeneration: {
+        wasm: false
+      }
+    }
+  );
 
   const CompileError = runInContext('WebAssembly.CompileError', ctx);
   expectsError(() => {
@@ -58,53 +73,86 @@ function expectsError(fn, type) {
 }
 
 expectsError(() => {
-  runInNewContext('eval("x")', {}, {
-    contextCodeGeneration: {
-      strings: false,
-    },
-  });
+  runInNewContext(
+    'eval("x")',
+    {},
+    {
+      contextCodeGeneration: {
+        strings: false
+      }
+    }
+  );
 }, 'EvalError');
 
 expectsError(() => {
-  runInNewContext('new WebAssembly.Module(WASM_BYTES)', { WASM_BYTES }, {
-    contextCodeGeneration: {
-      wasm: false,
-    },
-  });
+  runInNewContext(
+    'new WebAssembly.Module(WASM_BYTES)',
+    { WASM_BYTES },
+    {
+      contextCodeGeneration: {
+        wasm: false
+      }
+    }
+  );
 }, 'CompileError');
 
-common.expectsError(() => {
-  createContext({}, {
-    codeGeneration: {
-      strings: 0,
-    },
-  });
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-});
-
-common.expectsError(() => {
-  runInNewContext('eval("x")', {}, {
-    contextCodeGeneration: {
-      wasm: 1,
-    },
-  });
-}, {
-  code: 'ERR_INVALID_ARG_TYPE'
-});
-
-common.expectsError(() => {
-  createContext({}, {
-    codeGeneration: 1,
-  });
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-});
-
-common.expectsError(() => {
-  createContext({}, {
-    codeGeneration: null,
-  });
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-});
+common.expectsError(
+  () => {
+    createContext(
+      {},
+      {
+        codeGeneration: {
+          strings: 0
+        }
+      }
+    );
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE'
+  }
+);
+
+common.expectsError(
+  () => {
+    runInNewContext(
+      'eval("x")',
+      {},
+      {
+        contextCodeGeneration: {
+          wasm: 1
+        }
+      }
+    );
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE'
+  }
+);
+
+common.expectsError(
+  () => {
+    createContext(
+      {},
+      {
+        codeGeneration: 1
+      }
+    );
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE'
+  }
+);
+
+common.expectsError(
+  () => {
+    createContext(
+      {},
+      {
+        codeGeneration: null
+      }
+    );
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE'
+  }
+);
diff --git a/test/parallel/test-vm-context-async-script.js b/test/parallel/test-vm-context-async-script.js
index 879315e37bb3e0..89c42ebc1c6326 100644
--- a/test/parallel/test-vm-context-async-script.js
+++ b/test/parallel/test-vm-context-async-script.js
@@ -29,7 +29,10 @@ const sandbox = { setTimeout };
 const ctx = vm.createContext(sandbox);
 
 vm.runInContext('setTimeout(function() { x = 3; }, 0);', ctx);
-setTimeout(common.mustCall(() => {
-  assert.strictEqual(sandbox.x, 3);
-  assert.strictEqual(ctx.x, 3);
-}), 1);
+setTimeout(
+  common.mustCall(() => {
+    assert.strictEqual(sandbox.x, 3);
+    assert.strictEqual(ctx.x, 3);
+  }),
+  1
+);
diff --git a/test/parallel/test-vm-context-property-forwarding.js b/test/parallel/test-vm-context-property-forwarding.js
index 800a9fa2438988..1f015d776ed87d 100644
--- a/test/parallel/test-vm-context-property-forwarding.js
+++ b/test/parallel/test-vm-context-property-forwarding.js
@@ -34,7 +34,11 @@ assert.strictEqual(sandbox.y, 4);
 assert.strictEqual(ctx.y, 4);
 
 // Test `IndexedPropertyGetterCallback` and `IndexedPropertyDeleterCallback`
-const x = { get 1() { return 5; } };
+const x = {
+  get 1() {
+    return 5;
+  }
+};
 const pd_expected = Object.getOwnPropertyDescriptor(x, 1);
 const ctx2 = vm.createContext(x);
 const pd_actual = Object.getOwnPropertyDescriptor(ctx2, 1);
diff --git a/test/parallel/test-vm-context.js b/test/parallel/test-vm-context.js
index e1cfd145f226ad..1b05e98d844dad 100644
--- a/test/parallel/test-vm-context.js
+++ b/test/parallel/test-vm-context.js
@@ -33,7 +33,7 @@ let result = script.runInContext(context);
 assert.strictEqual(result, 'passed');
 
 // Create a new pre-populated context
-context = vm.createContext({ 'foo': 'bar', 'thing': 'lala' });
+context = vm.createContext({ foo: 'bar', thing: 'lala' });
 assert.strictEqual(context.foo, 'bar');
 assert.strictEqual(context.thing, 'lala');
 
@@ -44,12 +44,15 @@ assert.strictEqual(context.foo, 3);
 assert.strictEqual(context.thing, 'lala');
 
 // Issue GH-227:
-common.expectsError(() => {
-  vm.runInNewContext('', null, 'some.js');
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    vm.runInNewContext('', null, 'some.js');
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }
+);
 
 // Issue GH-1140:
 // Test runInContext signature
@@ -58,8 +61,10 @@ try {
   vm.runInContext('throw new Error()', context, 'expected-filename.js');
 } catch (e) {
   gh1140Exception = e;
-  assert.ok(/expected-filename/.test(e.stack),
-            `expected appearance of filename in Error stack: ${e.stack}`);
+  assert.ok(
+    /expected-filename/.test(e.stack),
+    `expected appearance of filename in Error stack: ${e.stack}`
+  );
 }
 // This is outside of catch block to confirm catch block ran.
 assert.strictEqual(gh1140Exception.toString(), 'Error');
@@ -77,19 +82,28 @@ const contextifiedSandboxError = {
 
 [
   [undefined, nonContextualSandboxError],
-  [null, nonContextualSandboxError], [0, nonContextualSandboxError],
-  [0.0, nonContextualSandboxError], ['', nonContextualSandboxError],
-  [{}, contextifiedSandboxError], [[], contextifiedSandboxError]
+  [null, nonContextualSandboxError],
+  [0, nonContextualSandboxError],
+  [0.0, nonContextualSandboxError],
+  ['', nonContextualSandboxError],
+  [{}, contextifiedSandboxError],
+  [[], contextifiedSandboxError]
 ].forEach((e) => {
-  common.expectsError(() => { script.runInContext(e[0]); }, e[1]);
-  common.expectsError(() => { vm.runInContext('', e[0]); }, e[1]);
+  common.expectsError(() => {
+    script.runInContext(e[0]);
+  }, e[1]);
+  common.expectsError(() => {
+    vm.runInContext('', e[0]);
+  }, e[1]);
 });
 
 // Issue GH-693:
 // Test RegExp as argument to assert.throws
-script = vm.createScript('const assert = require(\'assert\'); assert.throws(' +
-                         'function() { throw "hello world"; }, /hello/);',
-                         'some.js');
+script = vm.createScript(
+  "const assert = require('assert'); assert.throws(" +
+    'function() { throw "hello world"; }, /hello/);',
+  'some.js'
+);
 script.runInNewContext({ require });
 
 // Issue GH-7529
@@ -103,17 +117,20 @@ assert.strictEqual(script.runInContext(ctx), false);
 // number.
 {
   let stack = null;
-  assert.throws(() => {
-    vm.runInContext(' throw new Error()', context, {
-      filename: 'expected-filename.js',
-      lineOffset: 32,
-      columnOffset: 123
-    });
-  }, (err) => {
-    stack = err.stack;
-    return /^ \^/m.test(stack) &&
-           /expected-filename\.js:33:131/.test(stack);
-  }, `stack not formatted as expected: ${stack}`);
+  assert.throws(
+    () => {
+      vm.runInContext(' throw new Error()', context, {
+        filename: 'expected-filename.js',
+        lineOffset: 32,
+        columnOffset: 123
+      });
+    },
+    (err) => {
+      stack = err.stack;
+      return /^ \^/m.test(stack) && /expected-filename\.js:33:131/.test(stack);
+    },
+    `stack not formatted as expected: ${stack}`
+  );
 }
 
 // https://github.com/nodejs/node/issues/6158
diff --git a/test/parallel/test-vm-create-and-run-in-context.js b/test/parallel/test-vm-create-and-run-in-context.js
index bd746cf2df7080..388902a839cd76 100644
--- a/test/parallel/test-vm-create-and-run-in-context.js
+++ b/test/parallel/test-vm-create-and-run-in-context.js
@@ -32,7 +32,7 @@ let result = vm.runInContext('"passed";', context);
 assert.strictEqual(result, 'passed');
 
 // Create a new pre-populated context
-context = vm.createContext({ 'foo': 'bar', 'thing': 'lala' });
+context = vm.createContext({ foo: 'bar', thing: 'lala' });
 assert.strictEqual(context.foo, 'bar');
 assert.strictEqual(context.thing, 'lala');
 
diff --git a/test/parallel/test-vm-create-context-arg.js b/test/parallel/test-vm-create-context-arg.js
index d9e017d0f9173a..2a264196ac10e9 100644
--- a/test/parallel/test-vm-create-context-arg.js
+++ b/test/parallel/test-vm-create-context-arg.js
@@ -23,12 +23,15 @@
 const common = require('../common');
 const vm = require('vm');
 
-common.expectsError(() => {
-  vm.createContext('string is not supported');
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError
-});
+common.expectsError(
+  () => {
+    vm.createContext('string is not supported');
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }
+);
 
 // Should not throw.
 vm.createContext({ a: 1 });
diff --git a/test/parallel/test-vm-deleting-property.js b/test/parallel/test-vm-deleting-property.js
index 994aa0aff94f2d..713f8a153cc132 100644
--- a/test/parallel/test-vm-deleting-property.js
+++ b/test/parallel/test-vm-deleting-property.js
@@ -6,10 +6,13 @@ const assert = require('assert');
 const vm = require('vm');
 
 const context = vm.createContext();
-const res = vm.runInContext(`
+const res = vm.runInContext(
+  `
   this.x = 'prop';
   delete this.x;
   Object.getOwnPropertyDescriptor(this, 'x');
-`, context);
+`,
+  context
+);
 
 assert.strictEqual(res, undefined);
diff --git a/test/parallel/test-vm-global-assignment.js b/test/parallel/test-vm-global-assignment.js
index 3fb3470b4c2a43..13a16012c82edb 100644
--- a/test/parallel/test-vm-global-assignment.js
+++ b/test/parallel/test-vm-global-assignment.js
@@ -4,7 +4,7 @@
 require('../common');
 const assert = require('assert');
 const vm = require('vm');
-const ctx = vm.createContext({ open() { } });
+const ctx = vm.createContext({ open() {} });
 const window = vm.runInContext('this', ctx);
 const other = 123;
 
diff --git a/test/parallel/test-vm-global-define-property.js b/test/parallel/test-vm-global-define-property.js
index 0b9a4dfb88cb02..8801ad59fd089f 100644
--- a/test/parallel/test-vm-global-define-property.js
+++ b/test/parallel/test-vm-global-define-property.js
@@ -26,14 +26,14 @@ const assert = require('assert');
 const vm = require('vm');
 
 const code =
-    'Object.defineProperty(this, "f", {\n' +
-    '  get: function() { return x; },\n' +
-    '  set: function(k) { x = k; },\n' +
-    '  configurable: true,\n' +
-    '  enumerable: true\n' +
-    '});\n' +
-    'g = f;\n' +
-    'f;\n';
+  'Object.defineProperty(this, "f", {\n' +
+  '  get: function() { return x; },\n' +
+  '  set: function(k) { x = k; },\n' +
+  '  configurable: true,\n' +
+  '  enumerable: true\n' +
+  '});\n' +
+  'g = f;\n' +
+  'f;\n';
 
 const x = {};
 const o = vm.createContext({ console, x });
diff --git a/test/parallel/test-vm-global-non-writable-properties.js b/test/parallel/test-vm-global-non-writable-properties.js
index 2a2f70ff7ed5aa..56aafe70245277 100644
--- a/test/parallel/test-vm-global-non-writable-properties.js
+++ b/test/parallel/test-vm-global-non-writable-properties.js
@@ -8,8 +8,10 @@ const vm = require('vm');
 const ctx = vm.createContext();
 vm.runInContext('Object.defineProperty(this, "x", { value: 42 })', ctx);
 assert.strictEqual(vm.runInContext('x', ctx), 42);
-vm.runInContext('x = 0', ctx);                      // Does not throw but x...
-assert.strictEqual(vm.runInContext('x', ctx), 42);  // ...should be unaltered.
-assert.throws(() => vm.runInContext('"use strict"; x = 0', ctx),
-              /Cannot assign to read only property 'x'/);
+vm.runInContext('x = 0', ctx); // Does not throw but x...
+assert.strictEqual(vm.runInContext('x', ctx), 42); // ...should be unaltered.
+assert.throws(
+  () => vm.runInContext('"use strict"; x = 0', ctx),
+  /Cannot assign to read only property 'x'/
+);
 assert.strictEqual(vm.runInContext('x', ctx), 42);
diff --git a/test/parallel/test-vm-global-property-interceptors.js b/test/parallel/test-vm-global-property-interceptors.js
index 8571fbe19fcb60..66bc4af8c45ab3 100644
--- a/test/parallel/test-vm-global-property-interceptors.js
+++ b/test/parallel/test-vm-global-property-interceptors.js
@@ -30,7 +30,8 @@ Object.defineProperties(sandbox, {
 
 const ctx = vm.createContext(sandbox);
 
-const result = vm.runInContext(`
+const result = vm.runInContext(
+  `
 const getDesc = (prop) => Object.getOwnPropertyDescriptor(this, prop);
 const result = {
   a: getDesc('a'),
@@ -42,7 +43,9 @@ const result = {
   g: getDesc('g')
 };
 result;
-`, ctx);
+`,
+  ctx
+);
 
 // eslint-disable-next-line no-restricted-properties
 assert.deepEqual(result, {
@@ -61,7 +64,8 @@ assert.deepEqual(result, {
 });
 
 // define new properties
-vm.runInContext(`
+vm.runInContext(
+  `
 Object.defineProperty(this, 'h', {value: 'h'});
 Object.defineProperty(this, 'i', {});
 Object.defineProperty(this, 'j', {
@@ -72,7 +76,9 @@ Object.defineProperty(this, 'k', {
   get() { return kValue; },
   set(value) { kValue = value }
 });
-`, ctx);
+`,
+  ctx
+);
 
 assert.deepStrictEqual(Object.getOwnPropertyDescriptor(ctx, 'h'), {
   value: 'h',
@@ -111,19 +117,32 @@ assert.strictEqual(vm.runInContext('k;', ctx), 2);
 // redefine properties on the global object
 assert.strictEqual(typeof vm.runInContext('encodeURI;', ctx), 'function');
 assert.strictEqual(ctx.encodeURI, undefined);
-vm.runInContext(`
+vm.runInContext(
+  `
 Object.defineProperty(this, 'encodeURI', { value: 42 });
-`, ctx);
+`,
+  ctx
+);
 assert.strictEqual(vm.runInContext('encodeURI;', ctx), 42);
 assert.strictEqual(ctx.encodeURI, 42);
 
 // redefine properties on the sandbox
-vm.runInContext(`
+vm.runInContext(
+  `
 Object.defineProperty(this, 'e', { value: 'newE' });
-`, ctx);
+`,
+  ctx
+);
 assert.strictEqual(ctx.e, 'newE');
 
-assert.throws(() => vm.runInContext(`
+assert.throws(
+  () =>
+    vm.runInContext(
+      `
 'use strict';
 Object.defineProperty(this, 'f', { value: 'newF' });
-`, ctx), /TypeError: Cannot redefine property: f/);
+`,
+      ctx
+    ),
+  /TypeError: Cannot redefine property: f/
+);
diff --git a/test/parallel/test-vm-indexed-properties.js b/test/parallel/test-vm-indexed-properties.js
index 34ef8d020b2181..222ef146b5ea6f 100644
--- a/test/parallel/test-vm-indexed-properties.js
+++ b/test/parallel/test-vm-indexed-properties.js
@@ -9,7 +9,6 @@ const code = `Object.defineProperty(this, 99, {
       enumerable: true
  });`;
 
-
 const sandbox = {};
 const ctx = vm.createContext(sandbox);
 vm.runInContext(code, ctx);
diff --git a/test/parallel/test-vm-inherited_properties.js b/test/parallel/test-vm-inherited_properties.js
index 53087e1596e5c8..33581794e2f98b 100644
--- a/test/parallel/test-vm-inherited_properties.js
+++ b/test/parallel/test-vm-inherited_properties.js
@@ -15,8 +15,10 @@ let sandbox = Object.create(base, {
 
 const context = vm.createContext(sandbox);
 
-let result = vm.runInContext('Object.hasOwnProperty(this, "propBase");',
-                             context);
+let result = vm.runInContext(
+  'Object.hasOwnProperty(this, "propBase");',
+  context
+);
 
 assert.strictEqual(result, false);
 
diff --git a/test/parallel/test-vm-is-context.js b/test/parallel/test-vm-is-context.js
index 2749a14834b295..485e771f280265 100644
--- a/test/parallel/test-vm-is-context.js
+++ b/test/parallel/test-vm-is-context.js
@@ -24,15 +24,16 @@ const common = require('../common');
 const assert = require('assert');
 const vm = require('vm');
 
-for (const valToTest of [
-  'string', null, undefined, 8.9, Symbol('sym'), true
-]) {
-  common.expectsError(() => {
-    vm.isContext(valToTest);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError
-  });
+for (const valToTest of ['string', null, undefined, 8.9, Symbol('sym'), true]) {
+  common.expectsError(
+    () => {
+      vm.isContext(valToTest);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError
+    }
+  );
 }
 
 assert.strictEqual(vm.isContext({}), false);
diff --git a/test/parallel/test-vm-module-basic.js b/test/parallel/test-vm-module-basic.js
index 8cf687c2bb23a8..0a353fa88f8839 100644
--- a/test/parallel/test-vm-module-basic.js
+++ b/test/parallel/test-vm-module-basic.js
@@ -10,7 +10,7 @@ const { SourceTextModule, createContext } = require('vm');
   const context = createContext({
     foo: 'bar',
     baz: undefined,
-    typeofProcess: undefined,
+    typeofProcess: undefined
   });
   const m = new SourceTextModule(
     'baz = foo; typeofProcess = typeof process; typeof Object;',
@@ -29,7 +29,7 @@ const { SourceTextModule, createContext } = require('vm');
     typeofProcess: 'undefined'
   });
   assert.strictEqual(result.result, 'function');
-}());
+})();
 
 (async () => {
   const m = new SourceTextModule(
@@ -47,14 +47,13 @@ const { SourceTextModule, createContext } = require('vm');
   const m = new SourceTextModule('while (true) {}');
   await m.link(common.mustNotCall());
   m.instantiate();
-  await m.evaluate({ timeout: 500 })
-    .then(() => assert(false), () => {});
+  await m.evaluate({ timeout: 500 }).then(() => assert(false), () => {});
 })();
 
 // Check the generated url for each module
 (async () => {
-  const context1 = createContext({ });
-  const context2 = createContext({ });
+  const context1 = createContext({});
+  const context2 = createContext({});
 
   const m1 = new SourceTextModule('1', { context: context1 });
   assert.strictEqual(m1.url, 'vm:module(0)');
diff --git a/test/parallel/test-vm-module-dynamic-import.js b/test/parallel/test-vm-module-dynamic-import.js
index 600f455e93306e..f997c0bbd28f28 100644
--- a/test/parallel/test-vm-module-dynamic-import.js
+++ b/test/parallel/test-vm-module-dynamic-import.js
@@ -34,7 +34,7 @@ async function test() {
         assert.strictEqual(specifier, 'foo');
         assert.strictEqual(wrap, s);
         return foo;
-      }),
+      })
     });
 
     const result = s.runInThisContext();
@@ -47,7 +47,7 @@ async function test() {
         assert.strictEqual(specifier, 'foo');
         assert.strictEqual(wrap, m);
         return foo;
-      }),
+      })
     });
     await m.link(common.mustNotCall());
     m.instantiate();
@@ -60,19 +60,21 @@ async function testInvalid() {
   const m = new SourceTextModule('import("foo")', {
     importModuleDynamically: common.mustCall((specifier, wrap) => {
       return 5;
-    }),
+    })
   });
   await m.link(common.mustNotCall());
   m.instantiate();
   const { result } = await m.evaluate();
-  await result.catch(common.mustCall((e) => {
-    assert.strictEqual(e.code, 'ERR_VM_MODULE_NOT_MODULE');
-  }));
+  await result.catch(
+    common.mustCall((e) => {
+      assert.strictEqual(e.code, 'ERR_VM_MODULE_NOT_MODULE');
+    })
+  );
 
   const s = new Script('import("foo")', {
     importModuleDynamically: common.mustCall((specifier, wrap) => {
       return undefined;
-    }),
+    })
   });
   let threw = false;
   try {
@@ -86,9 +88,7 @@ async function testInvalid() {
 
 async function testInvalidimportModuleDynamically() {
   assert.throws(
-    () => new Script(
-      'import("foo")',
-      { importModuleDynamically: false }),
+    () => new Script('import("foo")', { importModuleDynamically: false }),
     { code: 'ERR_INVALID_ARG_TYPE' }
   );
 }
@@ -98,4 +98,4 @@ async function testInvalidimportModuleDynamically() {
   await test();
   await testInvalid();
   await testInvalidimportModuleDynamically();
-}()).then(common.mustCall());
+})().then(common.mustCall());
diff --git a/test/parallel/test-vm-module-errors.js b/test/parallel/test-vm-module-errors.js
index a343a542a10abd..75420b7495314d 100644
--- a/test/parallel/test-vm-module-errors.js
+++ b/test/parallel/test-vm-module-errors.js
@@ -35,213 +35,292 @@ async function createEmptyLinkedModule() {
 }
 
 async function checkArgType() {
-  common.expectsError(() => {
-    new SourceTextModule();
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError
-  });
+  common.expectsError(
+    () => {
+      new SourceTextModule();
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError
+    }
+  );
 
   for (const invalidOptions of [
-    0, 1, null, true, 'str', () => {}, { url: 0 }, Symbol.iterator,
-    { context: null }, { context: 'hucairz' }, { context: {} }
+    0,
+    1,
+    null,
+    true,
+    'str',
+    () => {},
+    { url: 0 },
+    Symbol.iterator,
+    { context: null },
+    { context: 'hucairz' },
+    { context: {} }
   ]) {
-    common.expectsError(() => {
-      new SourceTextModule('', invalidOptions);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
+    common.expectsError(
+      () => {
+        new SourceTextModule('', invalidOptions);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError
+      }
+    );
   }
 
   for (const invalidLinker of [
-    0, 1, undefined, null, true, 'str', {}, Symbol.iterator
+    0,
+    1,
+    undefined,
+    null,
+    true,
+    'str',
+    {},
+    Symbol.iterator
   ]) {
-    await expectsRejection(async () => {
-      const m = new SourceTextModule('');
-      await m.link(invalidLinker);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
+    await expectsRejection(
+      async () => {
+        const m = new SourceTextModule('');
+        await m.link(invalidLinker);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError
+      }
+    );
   }
 }
 
 // Check methods/properties can only be used under a specific state.
 async function checkModuleState() {
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('');
-    await m.link(common.mustNotCall());
-    assert.strictEqual(m.linkingStatus, 'linked');
-    await m.link(common.mustNotCall());
-  }, {
-    code: 'ERR_VM_MODULE_ALREADY_LINKED'
-  });
-
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('');
-    m.link(common.mustNotCall());
-    assert.strictEqual(m.linkingStatus, 'linking');
-    await m.link(common.mustNotCall());
-  }, {
-    code: 'ERR_VM_MODULE_ALREADY_LINKED'
-  });
+  await expectsRejection(
+    async () => {
+      const m = new SourceTextModule('');
+      await m.link(common.mustNotCall());
+      assert.strictEqual(m.linkingStatus, 'linked');
+      await m.link(common.mustNotCall());
+    },
+    {
+      code: 'ERR_VM_MODULE_ALREADY_LINKED'
+    }
+  );
 
-  common.expectsError(() => {
-    const m = new SourceTextModule('');
-    m.instantiate();
-  }, {
-    code: 'ERR_VM_MODULE_NOT_LINKED'
-  });
+  await expectsRejection(
+    async () => {
+      const m = new SourceTextModule('');
+      m.link(common.mustNotCall());
+      assert.strictEqual(m.linkingStatus, 'linking');
+      await m.link(common.mustNotCall());
+    },
+    {
+      code: 'ERR_VM_MODULE_ALREADY_LINKED'
+    }
+  );
 
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('import "foo";');
-    try {
-      await m.link(common.mustCall(() => ({})));
-    } catch {
-      assert.strictEqual(m.linkingStatus, 'errored');
+  common.expectsError(
+    () => {
+      const m = new SourceTextModule('');
       m.instantiate();
+    },
+    {
+      code: 'ERR_VM_MODULE_NOT_LINKED'
+    }
+  );
+
+  await expectsRejection(
+    async () => {
+      const m = new SourceTextModule('import "foo";');
+      try {
+        await m.link(common.mustCall(() => ({})));
+      } catch {
+        assert.strictEqual(m.linkingStatus, 'errored');
+        m.instantiate();
+      }
+      assert.fail('Unreachable');
+    },
+    {
+      code: 'ERR_VM_MODULE_NOT_LINKED'
     }
-    assert.fail('Unreachable');
-  }, {
-    code: 'ERR_VM_MODULE_NOT_LINKED'
-  });
+  );
 
   {
     const m = new SourceTextModule('import "foo";');
-    await m.link(common.mustCall(async (specifier, module) => {
-      assert.strictEqual(module, m);
-      assert.strictEqual(specifier, 'foo');
-      assert.strictEqual(m.linkingStatus, 'linking');
-      common.expectsError(() => {
-        m.instantiate();
-      }, {
-        code: 'ERR_VM_MODULE_NOT_LINKED'
-      });
-      return new SourceTextModule('');
-    }));
+    await m.link(
+      common.mustCall(async (specifier, module) => {
+        assert.strictEqual(module, m);
+        assert.strictEqual(specifier, 'foo');
+        assert.strictEqual(m.linkingStatus, 'linking');
+        common.expectsError(
+          () => {
+            m.instantiate();
+          },
+          {
+            code: 'ERR_VM_MODULE_NOT_LINKED'
+          }
+        );
+        return new SourceTextModule('');
+      })
+    );
     m.instantiate();
     await m.evaluate();
   }
 
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('');
-    await m.evaluate();
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must be one of instantiated, evaluated, and errored'
-  });
+  await expectsRejection(
+    async () => {
+      const m = new SourceTextModule('');
+      await m.evaluate();
+    },
+    {
+      code: 'ERR_VM_MODULE_STATUS',
+      message:
+        'Module status must be one of instantiated, evaluated, and errored'
+    }
+  );
 
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('');
-    await m.evaluate(false);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    message: 'The "options" argument must be of type Object. ' +
-             'Received type boolean'
-  });
+  await expectsRejection(
+    async () => {
+      const m = new SourceTextModule('');
+      await m.evaluate(false);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message:
+        'The "options" argument must be of type Object. ' +
+        'Received type boolean'
+    }
+  );
 
-  await expectsRejection(async () => {
-    const m = await createEmptyLinkedModule();
-    await m.evaluate();
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must be one of instantiated, evaluated, and errored'
-  });
+  await expectsRejection(
+    async () => {
+      const m = await createEmptyLinkedModule();
+      await m.evaluate();
+    },
+    {
+      code: 'ERR_VM_MODULE_STATUS',
+      message:
+        'Module status must be one of instantiated, evaluated, and errored'
+    }
+  );
 
-  common.expectsError(() => {
-    const m = new SourceTextModule('');
-    m.error;
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must be errored'
-  });
+  common.expectsError(
+    () => {
+      const m = new SourceTextModule('');
+      m.error;
+    },
+    {
+      code: 'ERR_VM_MODULE_STATUS',
+      message: 'Module status must be errored'
+    }
+  );
 
-  await expectsRejection(async () => {
-    const m = await createEmptyLinkedModule();
-    m.instantiate();
-    await m.evaluate();
-    m.error;
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must be errored'
-  });
+  await expectsRejection(
+    async () => {
+      const m = await createEmptyLinkedModule();
+      m.instantiate();
+      await m.evaluate();
+      m.error;
+    },
+    {
+      code: 'ERR_VM_MODULE_STATUS',
+      message: 'Module status must be errored'
+    }
+  );
 
-  common.expectsError(() => {
-    const m = new SourceTextModule('');
-    m.namespace;
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must not be uninstantiated or instantiating'
-  });
+  common.expectsError(
+    () => {
+      const m = new SourceTextModule('');
+      m.namespace;
+    },
+    {
+      code: 'ERR_VM_MODULE_STATUS',
+      message: 'Module status must not be uninstantiated or instantiating'
+    }
+  );
 
-  await expectsRejection(async () => {
-    const m = await createEmptyLinkedModule();
-    m.namespace;
-  }, {
-    code: 'ERR_VM_MODULE_STATUS',
-    message: 'Module status must not be uninstantiated or instantiating'
-  });
+  await expectsRejection(
+    async () => {
+      const m = await createEmptyLinkedModule();
+      m.namespace;
+    },
+    {
+      code: 'ERR_VM_MODULE_STATUS',
+      message: 'Module status must not be uninstantiated or instantiating'
+    }
+  );
 }
 
 // Check link() fails when the returned module is not valid.
 async function checkLinking() {
-  await expectsRejection(async () => {
-    const m = new SourceTextModule('import "foo";');
-    try {
-      await m.link(common.mustCall(() => ({})));
-    } catch (err) {
-      assert.strictEqual(m.linkingStatus, 'errored');
-      throw err;
+  await expectsRejection(
+    async () => {
+      const m = new SourceTextModule('import "foo";');
+      try {
+        await m.link(common.mustCall(() => ({})));
+      } catch (err) {
+        assert.strictEqual(m.linkingStatus, 'errored');
+        throw err;
+      }
+      assert.fail('Unreachable');
+    },
+    {
+      code: 'ERR_VM_MODULE_NOT_MODULE'
     }
-    assert.fail('Unreachable');
-  }, {
-    code: 'ERR_VM_MODULE_NOT_MODULE'
-  });
+  );
 
-  await expectsRejection(async () => {
-    const c = createContext({ a: 1 });
-    const foo = new SourceTextModule('', { context: c });
-    await foo.link(common.mustNotCall());
-    const bar = new SourceTextModule('import "foo";');
-    try {
-      await bar.link(common.mustCall(() => foo));
-    } catch (err) {
-      assert.strictEqual(bar.linkingStatus, 'errored');
-      throw err;
+  await expectsRejection(
+    async () => {
+      const c = createContext({ a: 1 });
+      const foo = new SourceTextModule('', { context: c });
+      await foo.link(common.mustNotCall());
+      const bar = new SourceTextModule('import "foo";');
+      try {
+        await bar.link(common.mustCall(() => foo));
+      } catch (err) {
+        assert.strictEqual(bar.linkingStatus, 'errored');
+        throw err;
+      }
+      assert.fail('Unreachable');
+    },
+    {
+      code: 'ERR_VM_MODULE_DIFFERENT_CONTEXT'
     }
-    assert.fail('Unreachable');
-  }, {
-    code: 'ERR_VM_MODULE_DIFFERENT_CONTEXT'
-  });
+  );
 
-  await expectsRejection(async () => {
-    const erroredModule = new SourceTextModule('import "foo";');
-    try {
-      await erroredModule.link(common.mustCall(() => ({})));
-    } catch {
-      // ignored
-    } finally {
-      assert.strictEqual(erroredModule.linkingStatus, 'errored');
-    }
+  await expectsRejection(
+    async () => {
+      const erroredModule = new SourceTextModule('import "foo";');
+      try {
+        await erroredModule.link(common.mustCall(() => ({})));
+      } catch {
+        // ignored
+      } finally {
+        assert.strictEqual(erroredModule.linkingStatus, 'errored');
+      }
 
-    const rootModule = new SourceTextModule('import "errored";');
-    await rootModule.link(common.mustCall(() => erroredModule));
-  }, {
-    code: 'ERR_VM_MODULE_LINKING_ERRORED'
-  });
+      const rootModule = new SourceTextModule('import "errored";');
+      await rootModule.link(common.mustCall(() => erroredModule));
+    },
+    {
+      code: 'ERR_VM_MODULE_LINKING_ERRORED'
+    }
+  );
 }
 
-common.expectsError(() => {
-  new SourceTextModule('', {
-    importModuleDynamically: 'hucairz'
-  });
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: 'The "options.importModuleDynamically"' +
-    ' property must be of type function. Received type string'
-});
+common.expectsError(
+  () => {
+    new SourceTextModule('', {
+      importModuleDynamically: 'hucairz'
+    });
+  },
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "options.importModuleDynamically"' +
+      ' property must be of type function. Received type string'
+  }
+);
 
 // Check the JavaScript engine deals with exceptions correctly
 async function checkExecution() {
diff --git a/test/parallel/test-vm-module-import-meta.js b/test/parallel/test-vm-module-import-meta.js
index 4886464f34e1ae..5a4615edb9c1f1 100644
--- a/test/parallel/test-vm-module-import-meta.js
+++ b/test/parallel/test-vm-module-import-meta.js
@@ -24,16 +24,25 @@ async function testBasic() {
 
 async function testInvalid() {
   for (const invalidValue of [
-    null, {}, 0, Symbol.iterator, [], 'string', false
+    null,
+    {},
+    0,
+    Symbol.iterator,
+    [],
+    'string',
+    false
   ]) {
-    common.expectsError(() => {
-      new SourceTextModule('', {
-        initializeImportMeta: invalidValue
-      });
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
+    common.expectsError(
+      () => {
+        new SourceTextModule('', {
+          initializeImportMeta: invalidValue
+        });
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError
+      }
+    );
   }
 }
 
diff --git a/test/parallel/test-vm-module-link.js b/test/parallel/test-vm-module-link.js
index 20518c40540485..20a36a2984e897 100644
--- a/test/parallel/test-vm-module-link.js
+++ b/test/parallel/test-vm-module-link.js
@@ -17,11 +17,13 @@ async function simple() {
 
   assert.deepStrictEqual(bar.dependencySpecifiers, ['foo']);
 
-  await bar.link(common.mustCall((specifier, module) => {
-    assert.strictEqual(module, bar);
-    assert.strictEqual(specifier, 'foo');
-    return foo;
-  }));
+  await bar.link(
+    common.mustCall((specifier, module) => {
+      assert.strictEqual(module, bar);
+      assert.strictEqual(specifier, 'foo');
+      return foo;
+    })
+  );
 
   bar.instantiate();
 
@@ -37,11 +39,13 @@ async function depth() {
       import ${parentName} from '${parentName}';
       export default ${parentName};
     `);
-    await mod.link(common.mustCall((specifier, module) => {
-      assert.strictEqual(module, mod);
-      assert.strictEqual(specifier, parentName);
-      return parentModule;
-    }));
+    await mod.link(
+      common.mustCall((specifier, module) => {
+        assert.strictEqual(module, mod);
+        assert.strictEqual(specifier, parentName);
+        return parentModule;
+      })
+    );
     return mod;
   }
 
@@ -67,18 +71,22 @@ async function circular() {
       return foo;
     }
   `);
-  await foo.link(common.mustCall(async (fooSpecifier, fooModule) => {
-    assert.strictEqual(fooModule, foo);
-    assert.strictEqual(fooSpecifier, 'bar');
-    await bar.link(common.mustCall((barSpecifier, barModule) => {
-      assert.strictEqual(barModule, bar);
-      assert.strictEqual(barSpecifier, 'foo');
-      assert.strictEqual(foo.linkingStatus, 'linking');
-      return foo;
-    }));
-    assert.strictEqual(bar.linkingStatus, 'linked');
-    return bar;
-  }));
+  await foo.link(
+    common.mustCall(async (fooSpecifier, fooModule) => {
+      assert.strictEqual(fooModule, foo);
+      assert.strictEqual(fooSpecifier, 'bar');
+      await bar.link(
+        common.mustCall((barSpecifier, barModule) => {
+          assert.strictEqual(barModule, bar);
+          assert.strictEqual(barSpecifier, 'foo');
+          assert.strictEqual(foo.linkingStatus, 'linking');
+          return foo;
+        })
+      );
+      assert.strictEqual(bar.linkingStatus, 'linked');
+      return bar;
+    })
+  );
 
   foo.instantiate();
   await foo.evaluate();
@@ -87,7 +95,7 @@ async function circular() {
 
 async function circular2() {
   const sourceMap = {
-    'root': `
+    root: `
       import * as a from './a.mjs';
       import * as b from './b.mjs';
       if (!('fromA' in a))
@@ -115,7 +123,7 @@ async function circular2() {
       return moduleMap.get(specifier);
     }
     const mod = new SourceTextModule(sourceMap[specifier], {
-      url: new URL(specifier, 'file:///').href,
+      url: new URL(specifier, 'file:///').href
     });
     moduleMap.set(specifier, mod);
     return mod;
diff --git a/test/parallel/test-vm-new-script-new-context.js b/test/parallel/test-vm-new-script-new-context.js
index 482b4130d615d9..494c1487792539 100644
--- a/test/parallel/test-vm-new-script-new-context.js
+++ b/test/parallel/test-vm-new-script-new-context.js
@@ -27,7 +27,7 @@ const assert = require('assert');
 const Script = require('vm').Script;
 
 {
-  const script = new Script('\'passed\';');
+  const script = new Script("'passed';");
   const result1 = script.runInNewContext();
   const result2 = script.runInNewContext();
   assert.strictEqual(result1, 'passed');
@@ -35,7 +35,7 @@ const Script = require('vm').Script;
 }
 
 {
-  const script = new Script('throw new Error(\'test\');');
+  const script = new Script("throw new Error('test');");
   assert.throws(() => {
     script.runInNewContext();
   }, /^Error: test$/);
@@ -59,9 +59,8 @@ const Script = require('vm').Script;
 }
 
 {
-  global.code = 'foo = 1;' +
-                'bar = 2;' +
-                'if (baz !== 3) throw new Error(\'test fail\');';
+  global.code =
+    'foo = 1;' + 'bar = 2;' + "if (baz !== 3) throw new Error('test fail');";
   global.foo = 2;
   global.obj = { foo: 0, baz: 3 };
   const script = new Script(global.code);
@@ -80,7 +79,9 @@ const Script = require('vm').Script;
 
 {
   const script = new Script('f()');
-  function changeFoo() { global.foo = 100; }
+  function changeFoo() {
+    global.foo = 100;
+  }
   script.runInNewContext({ f: changeFoo });
   assert.strictEqual(global.foo, 100);
 
@@ -102,6 +103,6 @@ const Script = require('vm').Script;
 {
   const script = new Script('');
   assert.throws(() => {
-    script.runInNewContext.call('\'hello\';');
+    script.runInNewContext.call("'hello';");
   }, /^TypeError: this\.runInContext is not a function$/);
 }
diff --git a/test/parallel/test-vm-new-script-this-context.js b/test/parallel/test-vm-new-script-this-context.js
index 18f39f9086ae2a..273492e15b3379 100644
--- a/test/parallel/test-vm-new-script-this-context.js
+++ b/test/parallel/test-vm-new-script-this-context.js
@@ -25,12 +25,12 @@ const assert = require('assert');
 const Script = require('vm').Script;
 
 // Run a string
-let script = new Script('\'passed\';');
+let script = new Script("'passed';");
 const result = script.runInThisContext(script);
 assert.strictEqual(result, 'passed');
 
 // Thrown error
-script = new Script('throw new Error(\'test\');');
+script = new Script("throw new Error('test');");
 assert.throws(() => {
   script.runInThisContext(script);
 }, /^Error: test$/);
@@ -40,11 +40,11 @@ script = new Script('hello = 2');
 script.runInThisContext(script);
 assert.strictEqual(global.hello, 2);
 
-
 // Pass values
-global.code = 'foo = 1;' +
-              'bar = 2;' +
-              'if (typeof baz !== "undefined") throw new Error("test fail");';
+global.code =
+  'foo = 1;' +
+  'bar = 2;' +
+  'if (typeof baz !== "undefined") throw new Error("test fail");';
 global.foo = 2;
 global.obj = { foo: 0, baz: 3 };
 script = new Script(global.code);
@@ -54,7 +54,9 @@ assert.strictEqual(global.bar, 2);
 assert.strictEqual(global.foo, 1);
 
 // Call a function
-global.f = function() { global.foo = 100; };
+global.f = function() {
+  global.foo = 100;
+};
 script = new Script('f()');
 script.runInThisContext(script);
 assert.strictEqual(global.foo, 100);
diff --git a/test/parallel/test-vm-parse-abort-on-uncaught-exception.js b/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
index 4fcff30321f671..62b8e87a00c543 100644
--- a/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
+++ b/test/parallel/test-vm-parse-abort-on-uncaught-exception.js
@@ -6,7 +6,14 @@ const vm = require('vm');
 // Regression test for https://github.com/nodejs/node/issues/13258
 
 try {
-  new vm.Script({ toString() { throw new Error('foo'); } }, {});
+  new vm.Script(
+    {
+      toString() {
+        throw new Error('foo');
+      }
+    },
+    {}
+  );
 } catch {}
 
 try {
diff --git a/test/parallel/test-vm-run-in-new-context.js b/test/parallel/test-vm-run-in-new-context.js
index 51577668cfe7f8..fc1a7e41664639 100644
--- a/test/parallel/test-vm-run-in-new-context.js
+++ b/test/parallel/test-vm-run-in-new-context.js
@@ -30,23 +30,21 @@ if (typeof global.gc !== 'function')
   assert.fail('Run this test with --expose-gc');
 
 // Run a string
-const result = vm.runInNewContext('\'passed\';');
+const result = vm.runInNewContext("'passed';");
 assert.strictEqual(result, 'passed');
 
 // Thrown error
 assert.throws(() => {
-  vm.runInNewContext('throw new Error(\'test\');');
+  vm.runInNewContext("throw new Error('test');");
 }, /^Error: test$/);
 
 global.hello = 5;
 vm.runInNewContext('hello = 2');
 assert.strictEqual(global.hello, 5);
 
-
 // Pass values in and out
-global.code = 'foo = 1;' +
-              'bar = 2;' +
-              'if (baz !== 3) throw new Error(\'test fail\');';
+global.code =
+  'foo = 1;' + 'bar = 2;' + "if (baz !== 3) throw new Error('test fail');";
 global.foo = 2;
 global.obj = { foo: 0, baz: 3 };
 /* eslint-disable no-unused-vars */
@@ -57,7 +55,9 @@ assert.strictEqual(global.obj.bar, 2);
 assert.strictEqual(global.foo, 2);
 
 // Call a function by reference
-function changeFoo() { global.foo = 100; }
+function changeFoo() {
+  global.foo = 100;
+}
 vm.runInNewContext('f()', { f: changeFoo });
 assert.strictEqual(global.foo, 100);
 
@@ -77,24 +77,22 @@ fn();
   const code = 'throw new Error("foo");';
   const file = 'test_file.vm';
 
-  assert.throws(() => {
-    vm.runInNewContext(code, {}, file);
-  }, (err) => {
-    const lines = err.stack.split('\n');
+  assert.throws(
+    () => {
+      vm.runInNewContext(code, {}, file);
+    },
+    (err) => {
+      const lines = err.stack.split('\n');
 
-    assert.strictEqual(lines[0].trim(), `${file}:1`);
-    assert.strictEqual(lines[1].trim(), code);
-    // Skip lines[2] and lines[3]. They're just a ^ and blank line.
-    assert.strictEqual(lines[4].trim(), 'Error: foo');
-    assert.strictEqual(lines[5].trim(), `at ${file}:1:7`);
-    // The rest of the stack is uninteresting.
-    return true;
-  });
+      assert.strictEqual(lines[0].trim(), `${file}:1`);
+      assert.strictEqual(lines[1].trim(), code);
+      // Skip lines[2] and lines[3]. They're just a ^ and blank line.
+      assert.strictEqual(lines[4].trim(), 'Error: foo');
+      assert.strictEqual(lines[5].trim(), `at ${file}:1:7`);
+      // The rest of the stack is uninteresting.
+      return true;
+    }
+  );
 }
 
-common.allowGlobals(
-  global.hello,
-  global.code,
-  global.foo,
-  global.obj
-);
+common.allowGlobals(global.hello, global.code, global.foo, global.obj);
diff --git a/test/parallel/test-vm-sigint-existing-handler.js b/test/parallel/test-vm-sigint-existing-handler.js
index 13fccd9637c7fb..f9a04458a860d5 100644
--- a/test/parallel/test-vm-sigint-existing-handler.js
+++ b/test/parallel/test-vm-sigint-existing-handler.js
@@ -9,39 +9,43 @@ const assert = require('assert');
 const vm = require('vm');
 const spawn = require('child_process').spawn;
 
-const methods = [
-  'runInThisContext',
-  'runInContext'
-];
+const methods = ['runInThisContext', 'runInContext'];
 
 if (process.argv[2] === 'child') {
   const method = process.argv[3];
   assert.ok(method);
 
   let firstHandlerCalled = 0;
-  process.on('SIGINT', common.mustCall(() => {
-    firstHandlerCalled++;
-    // Handler attached _before_ execution.
-  }, 2));
+  process.on(
+    'SIGINT',
+    common.mustCall(() => {
+      firstHandlerCalled++;
+      // Handler attached _before_ execution.
+    }, 2)
+  );
 
   let onceHandlerCalled = 0;
-  process.once('SIGINT', common.mustCall(() => {
-    onceHandlerCalled++;
-    // Handler attached _before_ execution.
-  }));
+  process.once(
+    'SIGINT',
+    common.mustCall(() => {
+      onceHandlerCalled++;
+      // Handler attached _before_ execution.
+    })
+  );
 
   const script = `process.send('${method}'); while(true) {}`;
-  const args = method === 'runInContext' ?
-    [vm.createContext({ process })] :
-    [];
+  const args = method === 'runInContext' ? [vm.createContext({ process })] : [];
   const options = { breakOnSigint: true };
 
   common.expectsError(
-    () => { vm[method](script, ...args, options); },
+    () => {
+      vm[method](script, ...args, options);
+    },
     {
       code: 'ERR_SCRIPT_EXECUTION_INTERRUPTED',
       message: 'Script execution was interrupted by `SIGINT`'
-    });
+    }
+  );
   assert.strictEqual(firstHandlerCalled, 0);
   assert.strictEqual(onceHandlerCalled, 0);
 
@@ -50,21 +54,24 @@ if (process.argv[2] === 'child') {
 
   let afterHandlerCalled = 0;
 
-  process.on('SIGINT', common.mustCall(() => {
-    // Handler attached _after_ execution.
-    if (afterHandlerCalled++ === 0) {
-      // The first time it just bounces back to check that the `once()`
-      // handler is not called the second time.
-      assert.strictEqual(firstHandlerCalled, 1);
-      assert.strictEqual(onceHandlerCalled, 1);
-      process.send(method);
-      return;
-    }
+  process.on(
+    'SIGINT',
+    common.mustCall(() => {
+      // Handler attached _after_ execution.
+      if (afterHandlerCalled++ === 0) {
+        // The first time it just bounces back to check that the `once()`
+        // handler is not called the second time.
+        assert.strictEqual(firstHandlerCalled, 1);
+        assert.strictEqual(onceHandlerCalled, 1);
+        process.send(method);
+        return;
+      }
 
-    assert.strictEqual(onceHandlerCalled, 1);
-    assert.strictEqual(firstHandlerCalled, 2);
-    timeout.unref();
-  }, 2));
+      assert.strictEqual(onceHandlerCalled, 1);
+      assert.strictEqual(firstHandlerCalled, 2);
+      timeout.unref();
+    }, 2)
+  );
 
   process.send(method);
 
@@ -76,14 +83,20 @@ for (const method of methods) {
     stdio: [null, 'inherit', 'inherit', 'ipc']
   });
 
-  child.on('message', common.mustCall(() => {
-    // First kill() breaks the while(true) loop, second one invokes the real
-    // signal handlers.
-    process.kill(child.pid, 'SIGINT');
-  }, 3));
-
-  child.on('close', common.mustCall((code, signal) => {
-    assert.strictEqual(signal, null);
-    assert.strictEqual(code, 0);
-  }));
+  child.on(
+    'message',
+    common.mustCall(() => {
+      // First kill() breaks the while(true) loop, second one invokes the real
+      // signal handlers.
+      process.kill(child.pid, 'SIGINT');
+    }, 3)
+  );
+
+  child.on(
+    'close',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(signal, null);
+      assert.strictEqual(code, 0);
+    })
+  );
 }
diff --git a/test/parallel/test-vm-sigint.js b/test/parallel/test-vm-sigint.js
index 0fecfbace68049..888d059ca6822a 100644
--- a/test/parallel/test-vm-sigint.js
+++ b/test/parallel/test-vm-sigint.js
@@ -16,20 +16,21 @@ if (process.argv[2] === 'child') {
   assert.ok(Number.isInteger(listeners));
 
   const script = `process.send('${method}'); while(true) {}`;
-  const args = method === 'runInContext' ?
-    [vm.createContext({ process })] :
-    [];
+  const args = method === 'runInContext' ? [vm.createContext({ process })] : [];
   const options = { breakOnSigint: true };
 
   for (let i = 0; i < listeners; i++)
     process.on('SIGINT', common.mustNotCall());
 
   common.expectsError(
-    () => { vm[method](script, ...args, options); },
+    () => {
+      vm[method](script, ...args, options);
+    },
     {
       code: 'ERR_SCRIPT_EXECUTION_INTERRUPTED',
       message: 'Script execution was interrupted by `SIGINT`'
-    });
+    }
+  );
   return;
 }
 
@@ -40,13 +41,19 @@ for (const method of ['runInThisContext', 'runInContext']) {
       stdio: [null, 'pipe', 'inherit', 'ipc']
     });
 
-    child.on('message', common.mustCall(() => {
-      process.kill(child.pid, 'SIGINT');
-    }));
-
-    child.on('close', common.mustCall((code, signal) => {
-      assert.strictEqual(signal, null);
-      assert.strictEqual(code, 0);
-    }));
+    child.on(
+      'message',
+      common.mustCall(() => {
+        process.kill(child.pid, 'SIGINT');
+      })
+    );
+
+    child.on(
+      'close',
+      common.mustCall((code, signal) => {
+        assert.strictEqual(signal, null);
+        assert.strictEqual(code, 0);
+      })
+    );
   }
 }
diff --git a/test/parallel/test-vm-static-this.js b/test/parallel/test-vm-static-this.js
index e9382d6c3b4c1a..9570f1fee50ca5 100644
--- a/test/parallel/test-vm-static-this.js
+++ b/test/parallel/test-vm-static-this.js
@@ -25,24 +25,24 @@ const assert = require('assert');
 const vm = require('vm');
 
 // Run a string
-const result = vm.runInThisContext('\'passed\';');
+const result = vm.runInThisContext("'passed';");
 assert.strictEqual(result, 'passed');
 
 // thrown error
 assert.throws(function() {
-  vm.runInThisContext('throw new Error(\'test\');');
+  vm.runInThisContext("throw new Error('test');");
 }, /test/);
 
 global.hello = 5;
 vm.runInThisContext('hello = 2');
 assert.strictEqual(global.hello, 2);
 
-
 // pass values
-const code = 'foo = 1;' +
-             'bar = 2;' +
-             'if (typeof baz !== \'undefined\')' +
-             'throw new Error(\'test fail\');';
+const code =
+  'foo = 1;' +
+  'bar = 2;' +
+  "if (typeof baz !== 'undefined')" +
+  "throw new Error('test fail');";
 global.foo = 2;
 global.obj = { foo: 0, baz: 3 };
 /* eslint-disable no-unused-vars */
@@ -53,13 +53,10 @@ assert.strictEqual(global.bar, 2);
 assert.strictEqual(global.foo, 1);
 
 // call a function
-global.f = function() { global.foo = 100; };
+global.f = function() {
+  global.foo = 100;
+};
 vm.runInThisContext('f()');
 assert.strictEqual(global.foo, 100);
 
-common.allowGlobals(
-  global.hello,
-  global.foo,
-  global.obj,
-  global.f
-);
+common.allowGlobals(global.hello, global.foo, global.obj, global.f);
diff --git a/test/parallel/test-vm-strict-assign.js b/test/parallel/test-vm-strict-assign.js
index a61db82c639a23..3f375c603b2631 100644
--- a/test/parallel/test-vm-strict-assign.js
+++ b/test/parallel/test-vm-strict-assign.js
@@ -12,9 +12,11 @@ vm.runInContext('Object.defineProperty(this, "x", { value: 42 })', ctx);
 assert.strictEqual(ctx.x, 42);
 assert.strictEqual(vm.runInContext('x', ctx), 42);
 
-vm.runInContext('x = 0', ctx);                      // Does not throw but x...
-assert.strictEqual(vm.runInContext('x', ctx), 42);  // ...should be unaltered.
+vm.runInContext('x = 0', ctx); // Does not throw but x...
+assert.strictEqual(vm.runInContext('x', ctx), 42); // ...should be unaltered.
 
-assert.throws(() => vm.runInContext('"use strict"; x = 0', ctx),
-              /Cannot assign to read only property 'x'/);
+assert.throws(
+  () => vm.runInContext('"use strict"; x = 0', ctx),
+  /Cannot assign to read only property 'x'/
+);
 assert.strictEqual(vm.runInContext('x', ctx), 42);
diff --git a/test/parallel/test-vm-syntax-error-message.js b/test/parallel/test-vm-syntax-error-message.js
index 5a16239f5653e9..67a53d90045dce 100644
--- a/test/parallel/test-vm-syntax-error-message.js
+++ b/test/parallel/test-vm-syntax-error-message.js
@@ -6,17 +6,20 @@ const child_process = require('child_process');
 const p = child_process.spawn(process.execPath, [
   '-e',
   'vm = require("vm");' +
-      'context = vm.createContext({});' +
-      'try { vm.runInContext("throw new Error(\'boo\')", context); } ' +
-      'catch (e) { console.log(e.message); }'
+    'context = vm.createContext({});' +
+    'try { vm.runInContext("throw new Error(\'boo\')", context); } ' +
+    'catch (e) { console.log(e.message); }'
 ]);
 
 p.stderr.on('data', common.mustNotCall());
 
 let output = '';
 
-p.stdout.on('data', (data) => output += data);
+p.stdout.on('data', (data) => (output += data));
 
-p.stdout.on('end', common.mustCall(() => {
-  assert.strictEqual(output.replace(/[\r\n]+/g, ''), 'boo');
-}));
+p.stdout.on(
+  'end',
+  common.mustCall(() => {
+    assert.strictEqual(output.replace(/[\r\n]+/g, ''), 'boo');
+  })
+);
diff --git a/test/parallel/test-vm-syntax-error-stderr.js b/test/parallel/test-vm-syntax-error-stderr.js
index 137d5de432b398..37c643f842dcdf 100644
--- a/test/parallel/test-vm-syntax-error-stderr.js
+++ b/test/parallel/test-vm-syntax-error-stderr.js
@@ -16,10 +16,15 @@ p.stdout.on('data', common.mustNotCall());
 
 let output = '';
 
-p.stderr.on('data', (data) => output += data);
+p.stderr.on('data', (data) => (output += data));
 
-p.stderr.on('end', common.mustCall(() => {
-  assert(/BEGIN CERT/.test(output));
-  assert(/^\s+\^/m.test(output));
-  assert(/Invalid left-hand side expression in prefix operation/.test(output));
-}));
+p.stderr.on(
+  'end',
+  common.mustCall(() => {
+    assert(/BEGIN CERT/.test(output));
+    assert(/^\s+\^/m.test(output));
+    assert(
+      /Invalid left-hand side expression in prefix operation/.test(output)
+    );
+  })
+);
diff --git a/test/parallel/test-vm-timeout.js b/test/parallel/test-vm-timeout.js
index 426d1e06925514..99a7cca6ae54f8 100644
--- a/test/parallel/test-vm-timeout.js
+++ b/test/parallel/test-vm-timeout.js
@@ -32,7 +32,8 @@ assert.throws(
   {
     code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
     message: 'Script execution timed out after 100ms'
-  });
+  }
+);
 
 // Timeout of 1000ms, script finishes first
 vm.runInThisContext('', { timeout: 1000 });
@@ -52,7 +53,8 @@ assert.throws(
   {
     code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
     message: 'Script execution timed out after 10ms'
-  });
+  }
+);
 
 // Nested vm timeouts, outer timeout is shorter and fires first.
 assert.throws(
@@ -68,13 +70,14 @@ assert.throws(
   {
     code: 'ERR_SCRIPT_EXECUTION_TIMEOUT',
     message: 'Script execution timed out after 100ms'
-  });
+  }
+);
 
 // Nested vm timeouts, inner script throws an error.
 assert.throws(function() {
   const context = {
     runInVM: function(timeout) {
-      vm.runInNewContext('throw new Error(\'foobar\')', context, { timeout });
+      vm.runInNewContext("throw new Error('foobar')", context, { timeout });
     }
   };
   vm.runInNewContext('runInVM(10000)', context, { timeout: 100000 });
diff --git a/test/parallel/test-warn-sigprof.js b/test/parallel/test-warn-sigprof.js
index c3986a27be1703..32693e8fb58272 100644
--- a/test/parallel/test-warn-sigprof.js
+++ b/test/parallel/test-warn-sigprof.js
@@ -7,13 +7,14 @@ const common = require('../common');
 
 common.skipIfInspectorDisabled();
 
-if (common.isWindows)
-  common.skip('test does not apply to Windows');
+if (common.isWindows) common.skip('test does not apply to Windows');
 
 common.skipIfWorker(); // Worker inspector never has a server running
 
-common.expectWarning('Warning',
-                     'process.on(SIGPROF) is reserved while debugging',
-                     common.noWarnCode);
+common.expectWarning(
+  'Warning',
+  'process.on(SIGPROF) is reserved while debugging',
+  common.noWarnCode
+);
 
 process.on('SIGPROF', () => {});
diff --git a/test/parallel/test-wasm-simple.js b/test/parallel/test-wasm-simple.js
index ebcb366d551e22..11303e8aeb3720 100644
--- a/test/parallel/test-wasm-simple.js
+++ b/test/parallel/test-wasm-simple.js
@@ -10,8 +10,5 @@ assert.ok(WebAssembly.validate(buffer), 'Buffer should be valid WebAssembly');
 
 WebAssembly.instantiate(buffer, {}).then((results) => {
   // Exported function should add two numbers.
-  assert.strictEqual(
-    results.instance.exports.addTwo(10, 20),
-    30
-  );
+  assert.strictEqual(results.instance.exports.addTwo(10, 20), 30);
 });
diff --git a/test/parallel/test-whatwg-encoding-fatal-streaming.js b/test/parallel/test-whatwg-encoding-fatal-streaming.js
index ddedb483624331..befb7520ee25ac 100644
--- a/test/parallel/test-whatwg-encoding-fatal-streaming.js
+++ b/test/parallel/test-whatwg-encoding-fatal-streaming.js
@@ -4,14 +4,13 @@
 
 const common = require('../common');
 
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const assert = require('assert');
 
 {
   [
-    { encoding: 'utf-8', sequence: [0xC0] },
+    { encoding: 'utf-8', sequence: [0xc0] },
     { encoding: 'utf-16le', sequence: [0x00] },
     { encoding: 'utf-16be', sequence: [0x00] }
   ].forEach((testCase) => {
@@ -20,11 +19,13 @@ const assert = require('assert');
       () => {
         const decoder = new TextDecoder(testCase.encoding, { fatal: true });
         decoder.decode(data);
-      }, {
+      },
+      {
         code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
         type: TypeError,
-        message:
-          `The encoded data was not valid for encoding ${testCase.encoding}`
+        message: `The encoded data was not valid for encoding ${
+          testCase.encoding
+        }`
       }
     );
 
@@ -47,11 +48,11 @@ const assert = require('assert');
     () => {
       decoder.decode(even, { stream: true });
       decoder.decode(odd);
-    }, {
+    },
+    {
       code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
       type: TypeError,
-      message:
-        'The encoded data was not valid for encoding utf-16le'
+      message: 'The encoded data was not valid for encoding utf-16le'
     }
   );
 
@@ -59,11 +60,11 @@ const assert = require('assert');
     () => {
       decoder.decode(odd, { stream: true });
       decoder.decode(even);
-    }, {
+    },
+    {
       code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
       type: TypeError,
-      message:
-        'The encoded data was not valid for encoding utf-16le'
+      message: 'The encoded data was not valid for encoding utf-16le'
     }
   );
 
diff --git a/test/parallel/test-whatwg-encoding-internals.js b/test/parallel/test-whatwg-encoding-internals.js
index d025642365ff73..3594ebedba7712 100644
--- a/test/parallel/test-whatwg-encoding-internals.js
+++ b/test/parallel/test-whatwg-encoding-internals.js
@@ -9,19 +9,10 @@ const { getEncodingFromLabel } = require('internal/encoding');
 // Test Encoding Mappings
 {
   const mappings = {
-    'utf-8': [
-      'unicode-1-1-utf-8',
-      'utf8'
-    ],
+    'utf-8': ['unicode-1-1-utf-8', 'utf8'],
     'utf-16be': [],
-    'utf-16le': [
-      'utf-16'
-    ],
-    'ibm866': [
-      '866',
-      'cp866',
-      'csibm866'
-    ],
+    'utf-16le': ['utf-16'],
+    ibm866: ['866', 'cp866', 'csibm866'],
     'iso-8859-2': [
       'csisolatin2',
       'iso-ir-101',
@@ -101,10 +92,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso_8859-8:1988',
       'visual'
     ],
-    'iso-8859-8-i': [
-      'csiso88598i',
-      'logical'
-    ],
+    'iso-8859-8-i': ['csiso88598i', 'logical'],
     'iso-8859-10': [
       'csisolatin6',
       'iso-ir-157',
@@ -113,14 +101,8 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'l6',
       'latin6'
     ],
-    'iso-8859-13': [
-      'iso8859-13',
-      'iso885913'
-    ],
-    'iso-8859-14': [
-      'iso8859-14',
-      'iso885914'
-    ],
+    'iso-8859-13': ['iso8859-13', 'iso885913'],
+    'iso-8859-14': ['iso8859-14', 'iso885914'],
     'iso-8859-15': [
       'csisolatin9',
       'iso8859-15',
@@ -128,20 +110,9 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso_8859-15',
       'l9'
     ],
-    'koi8-r': [
-      'cskoi8r',
-      'koi',
-      'koi8',
-      'koi8_r'
-    ],
-    'koi8-u': [
-      'koi8-ru'
-    ],
-    'macintosh': [
-      'csmacintosh',
-      'mac',
-      'x-mac-roman'
-    ],
+    'koi8-r': ['cskoi8r', 'koi', 'koi8', 'koi8_r'],
+    'koi8-u': ['koi8-ru'],
+    macintosh: ['csmacintosh', 'mac', 'x-mac-roman'],
     'windows-874': [
       'dos-874',
       'iso-8859-11',
@@ -149,14 +120,8 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso885911',
       'tis-620'
     ],
-    'windows-1250': [
-      'cp1250',
-      'x-cp1250'
-    ],
-    'windows-1251': [
-      'cp1251',
-      'x-cp1251'
-    ],
+    'windows-1250': ['cp1250', 'x-cp1250'],
+    'windows-1251': ['cp1251', 'x-cp1251'],
     'windows-1252': [
       'ansi_x3.4-1968',
       'ascii',
@@ -175,10 +140,7 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'us-ascii',
       'x-cp1252'
     ],
-    'windows-1253': [
-      'cp1253',
-      'x-cp1253'
-    ],
+    'windows-1253': ['cp1253', 'x-cp1253'],
     'windows-1254': [
       'cp1254',
       'csisolatin5',
@@ -192,26 +154,12 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'latin5',
       'x-cp1254'
     ],
-    'windows-1255': [
-      'cp1255',
-      'x-cp1255'
-    ],
-    'windows-1256': [
-      'cp1256',
-      'x-cp1256'
-    ],
-    'windows-1257': [
-      'cp1257',
-      'x-cp1257'
-    ],
-    'windows-1258': [
-      'cp1258',
-      'x-cp1258'
-    ],
-    'x-mac-cyrillic': [
-      'x-mac-ukrainian'
-    ],
-    'gbk': [
+    'windows-1255': ['cp1255', 'x-cp1255'],
+    'windows-1256': ['cp1256', 'x-cp1256'],
+    'windows-1257': ['cp1257', 'x-cp1257'],
+    'windows-1258': ['cp1258', 'x-cp1258'],
+    'x-mac-cyrillic': ['x-mac-ukrainian'],
+    gbk: [
       'chinese',
       'csgb2312',
       'csiso58gb231280',
@@ -221,21 +169,11 @@ const { getEncodingFromLabel } = require('internal/encoding');
       'iso-ir-58',
       'x-gbk'
     ],
-    'gb18030': [ ],
-    'big5': [
-      'big5-hkscs',
-      'cn-big5',
-      'csbig5',
-      'x-x-big5'
-    ],
-    'euc-jp': [
-      'cseucpkdfmtjapanese',
-      'x-euc-jp'
-    ],
-    'iso-2022-jp': [
-      'csiso2022jp'
-    ],
-    'shift_jis': [
+    gb18030: [],
+    big5: ['big5-hkscs', 'cn-big5', 'csbig5', 'x-x-big5'],
+    'euc-jp': ['cseucpkdfmtjapanese', 'x-euc-jp'],
+    'iso-2022-jp': ['csiso2022jp'],
+    shift_jis: [
       'csshiftjis',
       'ms932',
       'ms_kanji',
diff --git a/test/parallel/test-whatwg-encoding-textdecoder-fatal.js b/test/parallel/test-whatwg-encoding-textdecoder-fatal.js
index aa945b61b10e72..65176b2ebdeb13 100644
--- a/test/parallel/test-whatwg-encoding-textdecoder-fatal.js
+++ b/test/parallel/test-whatwg-encoding-textdecoder-fatal.js
@@ -4,68 +4,127 @@
 
 const common = require('../common');
 
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const assert = require('assert');
 
 const bad = [
-  { encoding: 'utf-8', input: [0xFF], name: 'invalid code' },
-  { encoding: 'utf-8', input: [0xC0], name: 'ends early' },
-  { encoding: 'utf-8', input: [0xE0], name: 'ends early 2' },
-  { encoding: 'utf-8', input: [0xC0, 0x00], name: 'invalid trail' },
-  { encoding: 'utf-8', input: [0xC0, 0xC0], name: 'invalid trail 2' },
-  { encoding: 'utf-8', input: [0xE0, 0x00], name: 'invalid trail 3' },
-  { encoding: 'utf-8', input: [0xE0, 0xC0], name: 'invalid trail 4' },
-  { encoding: 'utf-8', input: [0xE0, 0x80, 0x00], name: 'invalid trail 5' },
-  { encoding: 'utf-8', input: [0xE0, 0x80, 0xC0], name: 'invalid trail 6' },
-  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x80, 0x80, 0x80],
-    name: '> 0x10FFFF' },
-  { encoding: 'utf-8', input: [0xFE, 0x80, 0x80, 0x80, 0x80, 0x80],
-    name: 'obsolete lead byte' },
+  { encoding: 'utf-8', input: [0xff], name: 'invalid code' },
+  { encoding: 'utf-8', input: [0xc0], name: 'ends early' },
+  { encoding: 'utf-8', input: [0xe0], name: 'ends early 2' },
+  { encoding: 'utf-8', input: [0xc0, 0x00], name: 'invalid trail' },
+  { encoding: 'utf-8', input: [0xc0, 0xc0], name: 'invalid trail 2' },
+  { encoding: 'utf-8', input: [0xe0, 0x00], name: 'invalid trail 3' },
+  { encoding: 'utf-8', input: [0xe0, 0xc0], name: 'invalid trail 4' },
+  { encoding: 'utf-8', input: [0xe0, 0x80, 0x00], name: 'invalid trail 5' },
+  { encoding: 'utf-8', input: [0xe0, 0x80, 0xc0], name: 'invalid trail 6' },
+  {
+    encoding: 'utf-8',
+    input: [0xfc, 0x80, 0x80, 0x80, 0x80, 0x80],
+    name: '> 0x10FFFF'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xfe, 0x80, 0x80, 0x80, 0x80, 0x80],
+    name: 'obsolete lead byte'
+  },
   // Overlong encodings
-  { encoding: 'utf-8', input: [0xC0, 0x80], name: 'overlong U+0000 - 2 bytes' },
-  { encoding: 'utf-8', input: [0xE0, 0x80, 0x80],
-    name: 'overlong U+0000 - 3 bytes' },
-  { encoding: 'utf-8', input: [0xF0, 0x80, 0x80, 0x80],
-    name: 'overlong U+0000 - 4 bytes' },
-  { encoding: 'utf-8', input: [0xF8, 0x80, 0x80, 0x80, 0x80],
-    name: 'overlong U+0000 - 5 bytes' },
-  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x80, 0x80, 0x80],
-    name: 'overlong U+0000 - 6 bytes' },
-  { encoding: 'utf-8', input: [0xC1, 0xBF], name: 'overlong U+007F - 2 bytes' },
-  { encoding: 'utf-8', input: [0xE0, 0x81, 0xBF],
-    name: 'overlong U+007F - 3 bytes' },
-  { encoding: 'utf-8', input: [0xF0, 0x80, 0x81, 0xBF],
-    name: 'overlong U+007F - 4 bytes' },
-  { encoding: 'utf-8', input: [0xF8, 0x80, 0x80, 0x81, 0xBF],
-    name: 'overlong U+007F - 5 bytes' },
-  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x80, 0x81, 0xBF],
-    name: 'overlong U+007F - 6 bytes' },
-  { encoding: 'utf-8', input: [0xE0, 0x9F, 0xBF],
-    name: 'overlong U+07FF - 3 bytes' },
-  { encoding: 'utf-8', input: [0xF0, 0x80, 0x9F, 0xBF],
-    name: 'overlong U+07FF - 4 bytes' },
-  { encoding: 'utf-8', input: [0xF8, 0x80, 0x80, 0x9F, 0xBF],
-    name: 'overlong U+07FF - 5 bytes' },
-  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x80, 0x9F, 0xBF],
-    name: 'overlong U+07FF - 6 bytes' },
-  { encoding: 'utf-8', input: [0xF0, 0x8F, 0xBF, 0xBF],
-    name: 'overlong U+FFFF - 4 bytes' },
-  { encoding: 'utf-8', input: [0xF8, 0x80, 0x8F, 0xBF, 0xBF],
-    name: 'overlong U+FFFF - 5 bytes' },
-  { encoding: 'utf-8', input: [0xFC, 0x80, 0x80, 0x8F, 0xBF, 0xBF],
-    name: 'overlong U+FFFF - 6 bytes' },
-  { encoding: 'utf-8', input: [0xF8, 0x84, 0x8F, 0xBF, 0xBF],
-    name: 'overlong U+10FFFF - 5 bytes' },
-  { encoding: 'utf-8', input: [0xFC, 0x80, 0x84, 0x8F, 0xBF, 0xBF],
-    name: 'overlong U+10FFFF - 6 bytes' },
+  { encoding: 'utf-8', input: [0xc0, 0x80], name: 'overlong U+0000 - 2 bytes' },
+  {
+    encoding: 'utf-8',
+    input: [0xe0, 0x80, 0x80],
+    name: 'overlong U+0000 - 3 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf0, 0x80, 0x80, 0x80],
+    name: 'overlong U+0000 - 4 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf8, 0x80, 0x80, 0x80, 0x80],
+    name: 'overlong U+0000 - 5 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xfc, 0x80, 0x80, 0x80, 0x80, 0x80],
+    name: 'overlong U+0000 - 6 bytes'
+  },
+  { encoding: 'utf-8', input: [0xc1, 0xbf], name: 'overlong U+007F - 2 bytes' },
+  {
+    encoding: 'utf-8',
+    input: [0xe0, 0x81, 0xbf],
+    name: 'overlong U+007F - 3 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf0, 0x80, 0x81, 0xbf],
+    name: 'overlong U+007F - 4 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf8, 0x80, 0x80, 0x81, 0xbf],
+    name: 'overlong U+007F - 5 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xfc, 0x80, 0x80, 0x80, 0x81, 0xbf],
+    name: 'overlong U+007F - 6 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xe0, 0x9f, 0xbf],
+    name: 'overlong U+07FF - 3 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf0, 0x80, 0x9f, 0xbf],
+    name: 'overlong U+07FF - 4 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf8, 0x80, 0x80, 0x9f, 0xbf],
+    name: 'overlong U+07FF - 5 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xfc, 0x80, 0x80, 0x80, 0x9f, 0xbf],
+    name: 'overlong U+07FF - 6 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf0, 0x8f, 0xbf, 0xbf],
+    name: 'overlong U+FFFF - 4 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf8, 0x80, 0x8f, 0xbf, 0xbf],
+    name: 'overlong U+FFFF - 5 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xfc, 0x80, 0x80, 0x8f, 0xbf, 0xbf],
+    name: 'overlong U+FFFF - 6 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xf8, 0x84, 0x8f, 0xbf, 0xbf],
+    name: 'overlong U+10FFFF - 5 bytes'
+  },
+  {
+    encoding: 'utf-8',
+    input: [0xfc, 0x80, 0x84, 0x8f, 0xbf, 0xbf],
+    name: 'overlong U+10FFFF - 6 bytes'
+  },
   // UTF-16 surrogates encoded as code points in UTF-8
-  { encoding: 'utf-8', input: [0xED, 0xA0, 0x80], name: 'lead surrogate' },
-  { encoding: 'utf-8', input: [0xED, 0xB0, 0x80], name: 'trail surrogate' },
-  { encoding: 'utf-8', input: [0xED, 0xA0, 0x80, 0xED, 0xB0, 0x80],
-    name: 'surrogate pair' },
-  { encoding: 'utf-16le', input: [0x00], name: 'truncated code unit' },
+  { encoding: 'utf-8', input: [0xed, 0xa0, 0x80], name: 'lead surrogate' },
+  { encoding: 'utf-8', input: [0xed, 0xb0, 0x80], name: 'trail surrogate' },
+  {
+    encoding: 'utf-8',
+    input: [0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80],
+    name: 'surrogate pair'
+  },
+  { encoding: 'utf-16le', input: [0x00], name: 'truncated code unit' }
   // Mismatched UTF-16 surrogates are exercised in utf16-surrogates.html
   // FIXME: Add legacy encoding cases
 ];
@@ -73,9 +132,11 @@ const bad = [
 bad.forEach((t) => {
   common.expectsError(
     () => {
-      new TextDecoder(t.encoding, { fatal: true })
-        .decode(new Uint8Array(t.input));
-    }, {
+      new TextDecoder(t.encoding, { fatal: true }).decode(
+        new Uint8Array(t.input)
+      );
+    },
+    {
       code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
       type: TypeError
     }
@@ -92,11 +153,14 @@ bad.forEach((t) => {
 {
   const notArrayBufferViewExamples = [false, {}, 1, '', new Error()];
   notArrayBufferViewExamples.forEach((invalidInputType) => {
-    common.expectsError(() => {
-      new TextDecoder(undefined, null).decode(invalidInputType);
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError
-    });
+    common.expectsError(
+      () => {
+        new TextDecoder(undefined, null).decode(invalidInputType);
+      },
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError
+      }
+    );
   });
 }
diff --git a/test/parallel/test-whatwg-encoding-textdecoder-ignorebom.js b/test/parallel/test-whatwg-encoding-textdecoder-ignorebom.js
index 72fe498cd056d9..4269da84a8bdd5 100644
--- a/test/parallel/test-whatwg-encoding-textdecoder-ignorebom.js
+++ b/test/parallel/test-whatwg-encoding-textdecoder-ignorebom.js
@@ -9,17 +9,17 @@ const assert = require('assert');
 const cases = [
   {
     encoding: 'utf-8',
-    bytes: [0xEF, 0xBB, 0xBF, 0x61, 0x62, 0x63],
+    bytes: [0xef, 0xbb, 0xbf, 0x61, 0x62, 0x63],
     skipNoIntl: false
   },
   {
     encoding: 'utf-16le',
-    bytes: [0xFF, 0xFE, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00],
+    bytes: [0xff, 0xfe, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00],
     skipNoIntl: false
   },
   {
     encoding: 'utf-16be',
-    bytes: [0xFE, 0xFF, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63],
+    bytes: [0xfe, 0xff, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63],
     skipNoIntl: true
   }
 ];
diff --git a/test/parallel/test-whatwg-encoding-textdecoder-streaming.js b/test/parallel/test-whatwg-encoding-textdecoder-streaming.js
index 69186accb5770d..b00854a0010199 100644
--- a/test/parallel/test-whatwg-encoding-textdecoder-streaming.js
+++ b/test/parallel/test-whatwg-encoding-textdecoder-streaming.js
@@ -10,19 +10,117 @@ const string =
   '\x00123ABCabc\x80\xFF\u0100\u1000\uFFFD\uD800\uDC00\uDBFF\uDFFF';
 const octets = {
   'utf-8': [
-    0x00, 0x31, 0x32, 0x33, 0x41, 0x42, 0x43, 0x61, 0x62, 0x63, 0xc2, 0x80,
-    0xc3, 0xbf, 0xc4, 0x80, 0xe1, 0x80, 0x80, 0xef, 0xbf, 0xbd, 0xf0, 0x90,
-    0x80, 0x80, 0xf4, 0x8f, 0xbf, 0xbf],
+    0x00,
+    0x31,
+    0x32,
+    0x33,
+    0x41,
+    0x42,
+    0x43,
+    0x61,
+    0x62,
+    0x63,
+    0xc2,
+    0x80,
+    0xc3,
+    0xbf,
+    0xc4,
+    0x80,
+    0xe1,
+    0x80,
+    0x80,
+    0xef,
+    0xbf,
+    0xbd,
+    0xf0,
+    0x90,
+    0x80,
+    0x80,
+    0xf4,
+    0x8f,
+    0xbf,
+    0xbf
+  ],
   'utf-16le': [
-    0x00, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x41, 0x00, 0x42, 0x00,
-    0x43, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x80, 0x00, 0xFF, 0x00,
-    0x00, 0x01, 0x00, 0x10, 0xFD, 0xFF, 0x00, 0xD8, 0x00, 0xDC, 0xFF, 0xDB,
-    0xFF, 0xDF],
+    0x00,
+    0x00,
+    0x31,
+    0x00,
+    0x32,
+    0x00,
+    0x33,
+    0x00,
+    0x41,
+    0x00,
+    0x42,
+    0x00,
+    0x43,
+    0x00,
+    0x61,
+    0x00,
+    0x62,
+    0x00,
+    0x63,
+    0x00,
+    0x80,
+    0x00,
+    0xff,
+    0x00,
+    0x00,
+    0x01,
+    0x00,
+    0x10,
+    0xfd,
+    0xff,
+    0x00,
+    0xd8,
+    0x00,
+    0xdc,
+    0xff,
+    0xdb,
+    0xff,
+    0xdf
+  ],
   'utf-16be': [
-    0x00, 0x00, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x41, 0x00, 0x42,
-    0x00, 0x43, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x80, 0x00, 0xFF,
-    0x01, 0x00, 0x10, 0x00, 0xFF, 0xFD, 0xD8, 0x00, 0xDC, 0x00, 0xDB, 0xFF,
-    0xDF, 0xFF]
+    0x00,
+    0x00,
+    0x00,
+    0x31,
+    0x00,
+    0x32,
+    0x00,
+    0x33,
+    0x00,
+    0x41,
+    0x00,
+    0x42,
+    0x00,
+    0x43,
+    0x00,
+    0x61,
+    0x00,
+    0x62,
+    0x00,
+    0x63,
+    0x00,
+    0x80,
+    0x00,
+    0xff,
+    0x01,
+    0x00,
+    0x10,
+    0x00,
+    0xff,
+    0xfd,
+    0xd8,
+    0x00,
+    0xdc,
+    0x00,
+    0xdb,
+    0xff,
+    0xdf,
+    0xff
+  ]
 };
 
 Object.keys(octets).forEach((encoding) => {
diff --git a/test/parallel/test-whatwg-encoding-textdecoder-utf16-surrogates.js b/test/parallel/test-whatwg-encoding-textdecoder-utf16-surrogates.js
index 163cccf9bb2b88..6cce67cf64f5eb 100644
--- a/test/parallel/test-whatwg-encoding-textdecoder-utf16-surrogates.js
+++ b/test/parallel/test-whatwg-encoding-textdecoder-utf16-surrogates.js
@@ -4,8 +4,7 @@
 
 const common = require('../common');
 
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const assert = require('assert');
 
@@ -43,16 +42,18 @@ const bad = [
 ];
 
 bad.forEach((t) => {
-
   assert.strictEqual(
     new TextDecoder(t.encoding).decode(new Uint8Array(t.input)),
-    t.expected);
+    t.expected
+  );
 
   common.expectsError(
     () => {
-      new TextDecoder(t.encoding, { fatal: true })
-        .decode(new Uint8Array(t.input));
-    }, {
+      new TextDecoder(t.encoding, { fatal: true }).decode(
+        new Uint8Array(t.input)
+      );
+    },
+    {
       code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
       type: TypeError
     }
diff --git a/test/parallel/test-whatwg-encoding-textdecoder.js b/test/parallel/test-whatwg-encoding-textdecoder.js
index 6d1db2ec33faad..28b4638850d797 100644
--- a/test/parallel/test-whatwg-encoding-textdecoder.js
+++ b/test/parallel/test-whatwg-encoding-textdecoder.js
@@ -6,8 +6,18 @@ const common = require('../common');
 const assert = require('assert');
 const { customInspectSymbol: inspect } = require('internal/util');
 
-const buf = Buffer.from([0xef, 0xbb, 0xbf, 0x74, 0x65,
-                         0x73, 0x74, 0xe2, 0x82, 0xac]);
+const buf = Buffer.from([
+  0xef,
+  0xbb,
+  0xbf,
+  0x74,
+  0x65,
+  0x73,
+  0x74,
+  0xe2,
+  0x82,
+  0xac
+]);
 
 // Make Sure TextDecoder exist
 assert(TextDecoder);
@@ -51,13 +61,11 @@ assert(TextDecoder);
 if (common.hasIntl) {
   ['unicode-1-1-utf-8', 'utf8', 'utf-8'].forEach((i) => {
     const dec = new TextDecoder(i, { fatal: true });
-    common.expectsError(() => dec.decode(buf.slice(0, 8)),
-                        {
-                          code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
-                          type: TypeError,
-                          message: 'The encoded data was not valid ' +
-                          'for encoding utf-8'
-                        });
+    common.expectsError(() => dec.decode(buf.slice(0, 8)), {
+      code: 'ERR_ENCODING_INVALID_ENCODED_DATA',
+      type: TypeError,
+      message: 'The encoded data was not valid ' + 'for encoding utf-8'
+    });
   });
 
   ['unicode-1-1-utf-8', 'utf8', 'utf-8'].forEach((i) => {
@@ -66,13 +74,11 @@ if (common.hasIntl) {
     dec.decode(buf.slice(8));
   });
 } else {
-  common.expectsError(
-    () => new TextDecoder('utf-8', { fatal: true }),
-    {
-      code: 'ERR_NO_ICU',
-      type: TypeError,
-      message: '"fatal" option is not supported on Node.js compiled without ICU'
-    });
+  common.expectsError(() => new TextDecoder('utf-8', { fatal: true }), {
+    code: 'ERR_NO_ICU',
+    type: TypeError,
+    message: '"fatal" option is not supported on Node.js compiled without ICU'
+  });
 }
 
 // Test TextDecoder, label undefined, options null
@@ -103,7 +109,7 @@ if (common.hasIntl) {
   const {
     encoding: { get: encodingGetter },
     fatal: { get: fatalGetter },
-    ignoreBOM: { get: ignoreBOMGetter },
+    ignoreBOM: { get: ignoreBOMGetter }
   } = Object.getOwnPropertyDescriptors(TextDecoder.prototype);
 
   const instance = new TextDecoder();
@@ -134,10 +140,12 @@ if (common.hasIntl) {
 function testDecodeSample(encoding, string, bytes) {
   assert.strictEqual(
     new TextDecoder(encoding).decode(new Uint8Array(bytes)),
-    string);
+    string
+  );
   assert.strictEqual(
     new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer),
-    string);
+    string
+  );
 }
 
 // z (ASCII U+007A), cent (Latin-1 U+00A2), CJK water (BMP U+6C34),
@@ -149,52 +157,103 @@ const sample = 'z\xA2\u6C34\uD834\uDD1E\uF8FF\uDBFF\uDFFD\uFFFE';
   const encoding = 'utf-8';
   const string = sample;
   const bytes = [
-    0x7A, 0xC2, 0xA2, 0xE6, 0xB0, 0xB4,
-    0xF0, 0x9D, 0x84, 0x9E, 0xEF, 0xA3,
-    0xBF, 0xF4, 0x8F, 0xBF, 0xBD, 0xEF,
-    0xBF, 0xBE
+    0x7a,
+    0xc2,
+    0xa2,
+    0xe6,
+    0xb0,
+    0xb4,
+    0xf0,
+    0x9d,
+    0x84,
+    0x9e,
+    0xef,
+    0xa3,
+    0xbf,
+    0xf4,
+    0x8f,
+    0xbf,
+    0xbd,
+    0xef,
+    0xbf,
+    0xbe
   ];
   const encoded = new TextEncoder().encode(string);
   assert.deepStrictEqual([].slice.call(encoded), bytes);
   assert.strictEqual(
     new TextDecoder(encoding).decode(new Uint8Array(bytes)),
-    string);
+    string
+  );
   assert.strictEqual(
     new TextDecoder(encoding).decode(new Uint8Array(bytes).buffer),
-    string);
+    string
+  );
 }
 
-testDecodeSample(
-  'utf-16le',
-  sample,
-  [
-    0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
-    0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
-    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF
-  ]
-);
+testDecodeSample('utf-16le', sample, [
+  0x7a,
+  0x00,
+  0xa2,
+  0x00,
+  0x34,
+  0x6c,
+  0x34,
+  0xd8,
+  0x1e,
+  0xdd,
+  0xff,
+  0xf8,
+  0xff,
+  0xdb,
+  0xfd,
+  0xdf,
+  0xfe,
+  0xff
+]);
 
 if (common.hasIntl) {
-  testDecodeSample(
-    'utf-16be',
-    sample,
-    [
-      0x00, 0x7A, 0x00, 0xA2, 0x6C, 0x34,
-      0xD8, 0x34, 0xDD, 0x1E, 0xF8, 0xFF,
-      0xDB, 0xFF, 0xDF, 0xFD, 0xFF, 0xFE
-    ]
-  );
+  testDecodeSample('utf-16be', sample, [
+    0x00,
+    0x7a,
+    0x00,
+    0xa2,
+    0x6c,
+    0x34,
+    0xd8,
+    0x34,
+    0xdd,
+    0x1e,
+    0xf8,
+    0xff,
+    0xdb,
+    0xff,
+    0xdf,
+    0xfd,
+    0xff,
+    0xfe
+  ]);
 }
 
-testDecodeSample(
-  'utf-16',
-  sample,
-  [
-    0x7A, 0x00, 0xA2, 0x00, 0x34, 0x6C,
-    0x34, 0xD8, 0x1E, 0xDD, 0xFF, 0xF8,
-    0xFF, 0xDB, 0xFD, 0xDF, 0xFE, 0xFF
-  ]
-);
+testDecodeSample('utf-16', sample, [
+  0x7a,
+  0x00,
+  0xa2,
+  0x00,
+  0x34,
+  0x6c,
+  0x34,
+  0xd8,
+  0x1e,
+  0xdd,
+  0xff,
+  0xf8,
+  0xff,
+  0xdb,
+  0xfd,
+  0xdf,
+  0xfe,
+  0xff
+]);
 
 // From: https://github.com/w3c/web-platform-tests/blob/master/encoding/api-invalid-label.html
 [
@@ -206,28 +265,19 @@ testDecodeSample(
   'utf-16'
 ].forEach((i) => {
   ['\u0000', '\u000b', '\u00a0', '\u2028', '\u2029'].forEach((ws) => {
-    common.expectsError(
-      () => new TextDecoder(`${ws}${i}`),
-      {
-        code: 'ERR_ENCODING_NOT_SUPPORTED',
-        type: RangeError
-      }
-    );
-
-    common.expectsError(
-      () => new TextDecoder(`${i}${ws}`),
-      {
-        code: 'ERR_ENCODING_NOT_SUPPORTED',
-        type: RangeError
-      }
-    );
-
-    common.expectsError(
-      () => new TextDecoder(`${ws}${i}${ws}`),
-      {
-        code: 'ERR_ENCODING_NOT_SUPPORTED',
-        type: RangeError
-      }
-    );
+    common.expectsError(() => new TextDecoder(`${ws}${i}`), {
+      code: 'ERR_ENCODING_NOT_SUPPORTED',
+      type: RangeError
+    });
+
+    common.expectsError(() => new TextDecoder(`${i}${ws}`), {
+      code: 'ERR_ENCODING_NOT_SUPPORTED',
+      type: RangeError
+    });
+
+    common.expectsError(() => new TextDecoder(`${ws}${i}${ws}`), {
+      code: 'ERR_ENCODING_NOT_SUPPORTED',
+      type: RangeError
+    });
   });
 });
diff --git a/test/parallel/test-whatwg-encoding-textencoder.js b/test/parallel/test-whatwg-encoding-textencoder.js
index 9022477229c0de..ca80ab7fd17284 100644
--- a/test/parallel/test-whatwg-encoding-textencoder.js
+++ b/test/parallel/test-whatwg-encoding-textencoder.js
@@ -6,8 +6,18 @@ const common = require('../common');
 const assert = require('assert');
 const { customInspectSymbol: inspect } = require('internal/util');
 
-const encoded = Buffer.from([0xef, 0xbb, 0xbf, 0x74, 0x65,
-                             0x73, 0x74, 0xe2, 0x82, 0xac]);
+const encoded = Buffer.from([
+  0xef,
+  0xbb,
+  0xbf,
+  0x74,
+  0x65,
+  0x73,
+  0x74,
+  0xe2,
+  0x82,
+  0xac
+]);
 
 // Make Sure TextEncoder exists
 assert(TextEncoder);
@@ -36,8 +46,10 @@ assert(TextEncoder);
 {
   const inspectFn = TextEncoder.prototype[inspect];
   const encodeFn = TextEncoder.prototype.encode;
-  const encodingGetter =
-    Object.getOwnPropertyDescriptor(TextEncoder.prototype, 'encoding').get;
+  const encodingGetter = Object.getOwnPropertyDescriptor(
+    TextEncoder.prototype,
+    'encoding'
+  ).get;
 
   const instance = new TextEncoder();
 
diff --git a/test/parallel/test-whatwg-url-constructor.js b/test/parallel/test-whatwg-url-constructor.js
index 282679d7797f2a..9234cfac7c4188 100644
--- a/test/parallel/test-whatwg-url-constructor.js
+++ b/test/parallel/test-whatwg-url-constructor.js
@@ -7,13 +7,20 @@ if (!common.hasIntl) {
 
 const fixtures = require('../common/fixtures');
 const { URL, URLSearchParams } = require('url');
-const { test, assert_equals, assert_true, assert_throws } =
-  require('../common/wpt').harness;
+const {
+  test,
+  assert_equals,
+  assert_true,
+  assert_throws
+} = require('../common/wpt').harness;
 
 const request = {
-  response: require(
-    fixtures.path('wpt', 'url', 'resources', 'urltestdata.json')
-  )
+  response: require(fixtures.path(
+    'wpt',
+    'url',
+    'resources',
+    'urltestdata.json'
+  ))
 };
 
 /* The following tests are copied from WPT. Modifications to them should be
@@ -30,116 +37,124 @@ function runURLConstructorTests() {
   //   request.send()
   //   request.responseType = "json"
   //   request.onload = setup.step_func(function() {
-         runURLTests(request.response)
+  runURLTests(request.response);
   //     setup.done()
   //   })
   // })
 }
 
 function bURL(url, base) {
-  return new URL(url, base || "about:blank")
+  return new URL(url, base || 'about:blank');
 }
 
-
 function runURLTests(urltests) {
-  for(var i = 0, l = urltests.length; i < l; i++) {
-    var expected = urltests[i]
-    if (typeof expected === "string") continue // skip comments
+  for (var i = 0, l = urltests.length; i < l; i++) {
+    var expected = urltests[i];
+    if (typeof expected === 'string') continue; // skip comments
 
     test(function() {
       if (expected.failure) {
         assert_throws(new TypeError(), function() {
-          bURL(expected.input, expected.base)
-        })
-        return
+          bURL(expected.input, expected.base);
+        });
+        return;
       }
 
-      var url = bURL(expected.input, expected.base)
-      assert_equals(url.href, expected.href, "href")
-      assert_equals(url.protocol, expected.protocol, "protocol")
-      assert_equals(url.username, expected.username, "username")
-      assert_equals(url.password, expected.password, "password")
-      assert_equals(url.host, expected.host, "host")
-      assert_equals(url.hostname, expected.hostname, "hostname")
-      assert_equals(url.port, expected.port, "port")
-      assert_equals(url.pathname, expected.pathname, "pathname")
-      assert_equals(url.search, expected.search, "search")
-      if ("searchParams" in expected) {
-        assert_true("searchParams" in url)
-        assert_equals(url.searchParams.toString(), expected.searchParams, "searchParams")
+      var url = bURL(expected.input, expected.base);
+      assert_equals(url.href, expected.href, 'href');
+      assert_equals(url.protocol, expected.protocol, 'protocol');
+      assert_equals(url.username, expected.username, 'username');
+      assert_equals(url.password, expected.password, 'password');
+      assert_equals(url.host, expected.host, 'host');
+      assert_equals(url.hostname, expected.hostname, 'hostname');
+      assert_equals(url.port, expected.port, 'port');
+      assert_equals(url.pathname, expected.pathname, 'pathname');
+      assert_equals(url.search, expected.search, 'search');
+      if ('searchParams' in expected) {
+        assert_true('searchParams' in url);
+        assert_equals(
+          url.searchParams.toString(),
+          expected.searchParams,
+          'searchParams'
+        );
       }
-      assert_equals(url.hash, expected.hash, "hash")
-    }, "Parsing: <" + expected.input + "> against <" + expected.base + ">")
+      assert_equals(url.hash, expected.hash, 'hash');
+    }, 'Parsing: <' + expected.input + '> against <' + expected.base + '>');
   }
 }
 
 function runURLSearchParamTests() {
   test(function() {
-    var url = bURL('http://example.org/?a=b')
-    assert_true("searchParams" in url)
-    var searchParams = url.searchParams
-    assert_true(url.searchParams === searchParams, 'Object identity should hold.')
-  }, 'URL.searchParams getter')
+    var url = bURL('http://example.org/?a=b');
+    assert_true('searchParams' in url);
+    var searchParams = url.searchParams;
+    assert_true(
+      url.searchParams === searchParams,
+      'Object identity should hold.'
+    );
+  }, 'URL.searchParams getter');
 
   test(function() {
-    var url = bURL('http://example.org/?a=b')
-    assert_true("searchParams" in url)
-    var searchParams = url.searchParams
-    assert_equals(searchParams.toString(), 'a=b')
-
-    searchParams.set('a', 'b')
-    assert_equals(url.searchParams.toString(), 'a=b')
-    assert_equals(url.search, '?a=b')
-    url.search = ''
-    assert_equals(url.searchParams.toString(), '')
-    assert_equals(url.search, '')
-    assert_equals(searchParams.toString(), '')
-  }, 'URL.searchParams updating, clearing')
+    var url = bURL('http://example.org/?a=b');
+    assert_true('searchParams' in url);
+    var searchParams = url.searchParams;
+    assert_equals(searchParams.toString(), 'a=b');
+
+    searchParams.set('a', 'b');
+    assert_equals(url.searchParams.toString(), 'a=b');
+    assert_equals(url.search, '?a=b');
+    url.search = '';
+    assert_equals(url.searchParams.toString(), '');
+    assert_equals(url.search, '');
+    assert_equals(searchParams.toString(), '');
+  }, 'URL.searchParams updating, clearing');
 
   test(function() {
-    'use strict'
-    var urlString = 'http://example.org'
-    var url = bURL(urlString)
-    assert_throws(TypeError(), function() { url.searchParams = new URLSearchParams(urlString) })
-  }, 'URL.searchParams setter, invalid values')
+    'use strict';
+    var urlString = 'http://example.org';
+    var url = bURL(urlString);
+    assert_throws(TypeError(), function() {
+      url.searchParams = new URLSearchParams(urlString);
+    });
+  }, 'URL.searchParams setter, invalid values');
 
   test(function() {
-    var url = bURL('http://example.org/file?a=b&c=d')
-    assert_true("searchParams" in url)
-    var searchParams = url.searchParams
-    assert_equals(url.search, '?a=b&c=d')
-    assert_equals(searchParams.toString(), 'a=b&c=d')
+    var url = bURL('http://example.org/file?a=b&c=d');
+    assert_true('searchParams' in url);
+    var searchParams = url.searchParams;
+    assert_equals(url.search, '?a=b&c=d');
+    assert_equals(searchParams.toString(), 'a=b&c=d');
 
     // Test that setting 'search' propagates to the URL object's query object.
-    url.search = 'e=f&g=h'
-    assert_equals(url.search, '?e=f&g=h')
-    assert_equals(searchParams.toString(), 'e=f&g=h')
+    url.search = 'e=f&g=h';
+    assert_equals(url.search, '?e=f&g=h');
+    assert_equals(searchParams.toString(), 'e=f&g=h');
 
     // ..and same but with a leading '?'.
-    url.search = '?e=f&g=h'
-    assert_equals(url.search, '?e=f&g=h')
-    assert_equals(searchParams.toString(), 'e=f&g=h')
+    url.search = '?e=f&g=h';
+    assert_equals(url.search, '?e=f&g=h');
+    assert_equals(searchParams.toString(), 'e=f&g=h');
 
     // And in the other direction, altering searchParams propagates
     // back to 'search'.
-    searchParams.append('i', ' j ')
-    assert_equals(url.search, '?e=f&g=h&i=+j+')
-    assert_equals(url.searchParams.toString(), 'e=f&g=h&i=+j+')
-    assert_equals(searchParams.get('i'), ' j ')
-
-    searchParams.set('e', 'updated')
-    assert_equals(url.search, '?e=updated&g=h&i=+j+')
-    assert_equals(searchParams.get('e'), 'updated')
-
-    var url2 = bURL('http://example.org/file??a=b&c=d')
-    assert_equals(url2.search, '??a=b&c=d')
-    assert_equals(url2.searchParams.toString(), '%3Fa=b&c=d')
-
-    url2.href = 'http://example.org/file??a=b'
-    assert_equals(url2.search, '??a=b')
-    assert_equals(url2.searchParams.toString(), '%3Fa=b')
-  }, 'URL.searchParams and URL.search setters, update propagation')
+    searchParams.append('i', ' j ');
+    assert_equals(url.search, '?e=f&g=h&i=+j+');
+    assert_equals(url.searchParams.toString(), 'e=f&g=h&i=+j+');
+    assert_equals(searchParams.get('i'), ' j ');
+
+    searchParams.set('e', 'updated');
+    assert_equals(url.search, '?e=updated&g=h&i=+j+');
+    assert_equals(searchParams.get('e'), 'updated');
+
+    var url2 = bURL('http://example.org/file??a=b&c=d');
+    assert_equals(url2.search, '??a=b&c=d');
+    assert_equals(url2.searchParams.toString(), '%3Fa=b&c=d');
+
+    url2.href = 'http://example.org/file??a=b';
+    assert_equals(url2.search, '??a=b');
+    assert_equals(url2.searchParams.toString(), '%3Fa=b');
+  }, 'URL.searchParams and URL.search setters, update propagation');
 }
-runURLSearchParamTests()
-runURLConstructorTests()
+runURLSearchParamTests();
+runURLConstructorTests();
 /* eslint-enable */
diff --git a/test/parallel/test-whatwg-url-custom-domainto.js b/test/parallel/test-whatwg-url-custom-domainto.js
index 9677d84286ebe4..e4c6f13a6bbc37 100644
--- a/test/parallel/test-whatwg-url-custom-domainto.js
+++ b/test/parallel/test-whatwg-url-custom-domainto.js
@@ -4,21 +4,25 @@
 
 const common = require('../common');
 
-if (!common.hasIntl)
-  common.skip('missing Intl');
+if (!common.hasIntl) common.skip('missing Intl');
 
 const assert = require('assert');
 const { domainToASCII, domainToUnicode } = require('url');
 
 const tests = require('../fixtures/url-idna');
 const fixtures = require('../common/fixtures');
-const wptToASCIITests = require(
-  fixtures.path('wpt', 'url', 'resources', 'toascii.json')
-);
+const wptToASCIITests = require(fixtures.path(
+  'wpt',
+  'url',
+  'resources',
+  'toascii.json'
+));
 
 {
   const expectedError = common.expectsError(
-    { code: 'ERR_MISSING_ARGS', type: TypeError }, 2);
+    { code: 'ERR_MISSING_ARGS', type: TypeError },
+    2
+  );
   assert.throws(() => domainToASCII(), expectedError);
   assert.throws(() => domainToUnicode(), expectedError);
   assert.strictEqual(domainToASCII(undefined), 'undefined');
@@ -27,25 +31,35 @@ const wptToASCIITests = require(
 
 {
   for (const [i, { ascii, unicode }] of tests.entries()) {
-    assert.strictEqual(ascii, domainToASCII(unicode),
-                       `domainToASCII(${i + 1})`);
-    assert.strictEqual(unicode, domainToUnicode(ascii),
-                       `domainToUnicode(${i + 1})`);
-    assert.strictEqual(ascii, domainToASCII(domainToUnicode(ascii)),
-                       `domainToASCII(domainToUnicode(${i + 1}))`);
-    assert.strictEqual(unicode, domainToUnicode(domainToASCII(unicode)),
-                       `domainToUnicode(domainToASCII(${i + 1}))`);
+    assert.strictEqual(
+      ascii,
+      domainToASCII(unicode),
+      `domainToASCII(${i + 1})`
+    );
+    assert.strictEqual(
+      unicode,
+      domainToUnicode(ascii),
+      `domainToUnicode(${i + 1})`
+    );
+    assert.strictEqual(
+      ascii,
+      domainToASCII(domainToUnicode(ascii)),
+      `domainToASCII(domainToUnicode(${i + 1}))`
+    );
+    assert.strictEqual(
+      unicode,
+      domainToUnicode(domainToASCII(unicode)),
+      `domainToUnicode(domainToASCII(${i + 1}))`
+    );
   }
 }
 
 {
   for (const [i, test] of wptToASCIITests.entries()) {
-    if (typeof test === 'string')
-      continue; // skip comments
+    if (typeof test === 'string') continue; // skip comments
     const { comment, input, output } = test;
     let caseComment = `Case ${i + 1}`;
-    if (comment)
-      caseComment += ` (${comment})`;
+    if (comment) caseComment += ` (${comment})`;
     if (output === null) {
       assert.strictEqual(domainToASCII(input), '', caseComment);
       assert.strictEqual(domainToUnicode(input), '', caseComment);
diff --git a/test/parallel/test-whatwg-url-custom-global.js b/test/parallel/test-whatwg-url-custom-global.js
index c79723f0490e07..2d8291c9cab9b7 100644
--- a/test/parallel/test-whatwg-url-custom-global.js
+++ b/test/parallel/test-whatwg-url-custom-global.js
@@ -6,15 +6,12 @@ require('../common');
 const assert = require('assert');
 const { URL, URLSearchParams } = require('url');
 
-assert.deepStrictEqual(
-  Object.getOwnPropertyDescriptor(global, 'URL'),
-  {
-    value: URL,
-    writable: true,
-    configurable: true,
-    enumerable: false
-  }
-);
+assert.deepStrictEqual(Object.getOwnPropertyDescriptor(global, 'URL'), {
+  value: URL,
+  writable: true,
+  configurable: true,
+  enumerable: false
+});
 
 assert.deepStrictEqual(
   Object.getOwnPropertyDescriptor(global, 'URLSearchParams'),
diff --git a/test/parallel/test-whatwg-url-custom-inspect.js b/test/parallel/test-whatwg-url-custom-inspect.js
index 1083866d86f505..473955532990ad 100644
--- a/test/parallel/test-whatwg-url-custom-inspect.js
+++ b/test/parallel/test-whatwg-url-custom-inspect.js
@@ -12,7 +12,9 @@ const util = require('util');
 const URL = require('url').URL;
 const assert = require('assert');
 
-const url = new URL('https://username:password@host.name:8080/path/name/?que=ry#hash');
+const url = new URL(
+  'https://username:password@host.name:8080/path/name/?que=ry#hash'
+);
 
 assert.strictEqual(
   util.inspect(url),
@@ -29,7 +31,8 @@ assert.strictEqual(
   pathname: '/path/name/',
   search: '?que=ry',
   searchParams: URLSearchParams { 'que' => 'ry' },
-  hash: '#hash' }`);
+  hash: '#hash' }`
+);
 
 assert.strictEqual(
   util.inspect(url, { showHidden: true }),
@@ -59,11 +62,10 @@ assert.strictEqual(
      port: 8080,
      path: [ 'path', 'name', '', [length]: 3 ],
      query: 'que=ry',
-     fragment: 'hash' } }`);
+     fragment: 'hash' } }`
+);
 
-assert.strictEqual(
-  util.inspect({ a: url }, { depth: 0 }),
-  '{ a: [Object] }');
+assert.strictEqual(util.inspect({ a: url }, { depth: 0 }), '{ a: [Object] }');
 
 class MyURL extends URL {}
 assert(util.inspect(new MyURL(url.href)).startsWith('MyURL {'));
diff --git a/test/parallel/test-whatwg-url-custom-parsing.js b/test/parallel/test-whatwg-url-custom-parsing.js
index 34d9062087eb10..f766aa875e8276 100644
--- a/test/parallel/test-whatwg-url-custom-parsing.js
+++ b/test/parallel/test-whatwg-url-custom-parsing.js
@@ -12,9 +12,12 @@ const URL = require('url').URL;
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 
-const tests = require(
-  fixtures.path('wpt', 'url', 'resources', 'urltestdata.json')
-);
+const tests = require(fixtures.path(
+  'wpt',
+  'url',
+  'resources',
+  'urltestdata.json'
+));
 
 const originalFailures = tests.filter((test) => test.failure);
 
@@ -38,38 +41,38 @@ const typeFailures = [
 // > must give failure. This tests that the logic for converting
 // > base URLs into strings properly fails the whole parsing
 // > algorithm if the base URL cannot be parsed.
-const aboutBlankFailures = originalFailures
-  .map((test) => ({
-    input: 'about:blank',
-    base: test.input,
-    failure: true
-  }));
+const aboutBlankFailures = originalFailures.map((test) => ({
+  input: 'about:blank',
+  base: test.input,
+  failure: true
+}));
 
 const failureTests = originalFailures
   .concat(typeFailures)
   .concat(aboutBlankFailures);
 
 const expectedError = common.expectsError(
-  { code: 'ERR_INVALID_URL', type: TypeError }, failureTests.length);
+  { code: 'ERR_INVALID_URL', type: TypeError },
+  failureTests.length
+);
 
 for (const test of failureTests) {
   assert.throws(
     () => new URL(test.input, test.base),
     (error) => {
-      if (!expectedError(error))
-        return false;
+      if (!expectedError(error)) return false;
 
       // The input could be processed, so we don't do strict matching here
-      const match = (`${error}`).match(/Invalid URL: (.*)$/);
+      const match = `${error}`.match(/Invalid URL: (.*)$/);
       if (!match) {
         return false;
       }
       return error.input === match[1];
-    });
+    }
+  );
 }
 
-const additional_tests =
-  require(fixtures.path('url-tests-additional.js'));
+const additional_tests = require(fixtures.path('url-tests-additional.js'));
 
 for (const test of additional_tests) {
   const url = new URL(test.url);
diff --git a/test/parallel/test-whatwg-url-custom-properties.js b/test/parallel/test-whatwg-url-custom-properties.js
index 4a35215bc4ac96..a5df2a5fe2afcf 100644
--- a/test/parallel/test-whatwg-url-custom-properties.js
+++ b/test/parallel/test-whatwg-url-custom-properties.js
@@ -9,7 +9,7 @@ const assert = require('assert');
 const urlToOptions = require('internal/url').urlToOptions;
 
 const url = new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test');
-const oldParams = url.searchParams;  // for test of [SameObject]
+const oldParams = url.searchParams; // for test of [SameObject]
 
 // To retrieve enumerable but not necessarily own properties,
 // we need to use the for-in loop.
@@ -21,120 +21,159 @@ for (const prop in url) {
 // See: https://url.spec.whatwg.org/#api
 // https://heycam.github.io/webidl/#es-attributes
 // https://heycam.github.io/webidl/#es-stringifier
-const expected = ['toString',
-                  'href', 'origin', 'protocol',
-                  'username', 'password', 'host', 'hostname', 'port',
-                  'pathname', 'search', 'searchParams', 'hash', 'toJSON'];
+const expected = [
+  'toString',
+  'href',
+  'origin',
+  'protocol',
+  'username',
+  'password',
+  'host',
+  'hostname',
+  'port',
+  'pathname',
+  'search',
+  'searchParams',
+  'hash',
+  'toJSON'
+];
 
 assert.deepStrictEqual(props, expected);
 
 // href is writable (not readonly) and is stringifier
 assert.strictEqual(url.toString(), url.href);
 url.href = 'http://user:pass@foo.bar.com:21/aaa/zzz?l=25#test';
-assert.strictEqual(url.href,
-                   'http://user:pass@foo.bar.com:21/aaa/zzz?l=25#test');
+assert.strictEqual(
+  url.href,
+  'http://user:pass@foo.bar.com:21/aaa/zzz?l=25#test'
+);
 assert.strictEqual(url.toString(), url.href);
 // Return true because it's configurable, but because the properties
 // are defined on the prototype per the spec, the deletion has no effect
-assert.strictEqual((delete url.href), true);
-assert.strictEqual(url.href,
-                   'http://user:pass@foo.bar.com:21/aaa/zzz?l=25#test');
-assert.strictEqual(url.searchParams, oldParams);  // [SameObject]
+assert.strictEqual(delete url.href, true);
+assert.strictEqual(
+  url.href,
+  'http://user:pass@foo.bar.com:21/aaa/zzz?l=25#test'
+);
+assert.strictEqual(url.searchParams, oldParams); // [SameObject]
 
 // searchParams is readonly. Under strict mode setting a
 // non-writable property should throw.
 // Note: this error message is subject to change in V8 updates
 assert.throws(
-  () => url.origin = 'http://foo.bar.com:22',
+  () => (url.origin = 'http://foo.bar.com:22'),
   /^TypeError: Cannot set property origin of \[object URL\] which has only a getter$/
 );
 assert.strictEqual(url.origin, 'http://foo.bar.com:21');
-assert.strictEqual(url.toString(),
-                   'http://user:pass@foo.bar.com:21/aaa/zzz?l=25#test');
-assert.strictEqual((delete url.origin), true);
+assert.strictEqual(
+  url.toString(),
+  'http://user:pass@foo.bar.com:21/aaa/zzz?l=25#test'
+);
+assert.strictEqual(delete url.origin, true);
 assert.strictEqual(url.origin, 'http://foo.bar.com:21');
 
 // The following properties should be writable (not readonly)
 url.protocol = 'https:';
 assert.strictEqual(url.protocol, 'https:');
-assert.strictEqual(url.toString(),
-                   'https://user:pass@foo.bar.com:21/aaa/zzz?l=25#test');
-assert.strictEqual((delete url.protocol), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user:pass@foo.bar.com:21/aaa/zzz?l=25#test'
+);
+assert.strictEqual(delete url.protocol, true);
 assert.strictEqual(url.protocol, 'https:');
 
 url.username = 'user2';
 assert.strictEqual(url.username, 'user2');
-assert.strictEqual(url.toString(),
-                   'https://user2:pass@foo.bar.com:21/aaa/zzz?l=25#test');
-assert.strictEqual((delete url.username), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass@foo.bar.com:21/aaa/zzz?l=25#test'
+);
+assert.strictEqual(delete url.username, true);
 assert.strictEqual(url.username, 'user2');
 
 url.password = 'pass2';
 assert.strictEqual(url.password, 'pass2');
-assert.strictEqual(url.toString(),
-                   'https://user2:pass2@foo.bar.com:21/aaa/zzz?l=25#test');
-assert.strictEqual((delete url.password), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass2@foo.bar.com:21/aaa/zzz?l=25#test'
+);
+assert.strictEqual(delete url.password, true);
 assert.strictEqual(url.password, 'pass2');
 
 url.host = 'foo.bar.net:22';
 assert.strictEqual(url.host, 'foo.bar.net:22');
-assert.strictEqual(url.toString(),
-                   'https://user2:pass2@foo.bar.net:22/aaa/zzz?l=25#test');
-assert.strictEqual((delete url.host), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass2@foo.bar.net:22/aaa/zzz?l=25#test'
+);
+assert.strictEqual(delete url.host, true);
 assert.strictEqual(url.host, 'foo.bar.net:22');
 
 url.hostname = 'foo.bar.org';
 assert.strictEqual(url.hostname, 'foo.bar.org');
-assert.strictEqual(url.toString(),
-                   'https://user2:pass2@foo.bar.org:22/aaa/zzz?l=25#test');
-assert.strictEqual((delete url.hostname), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass2@foo.bar.org:22/aaa/zzz?l=25#test'
+);
+assert.strictEqual(delete url.hostname, true);
 assert.strictEqual(url.hostname, 'foo.bar.org');
 
 url.port = '23';
 assert.strictEqual(url.port, '23');
-assert.strictEqual(url.toString(),
-                   'https://user2:pass2@foo.bar.org:23/aaa/zzz?l=25#test');
-assert.strictEqual((delete url.port), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass2@foo.bar.org:23/aaa/zzz?l=25#test'
+);
+assert.strictEqual(delete url.port, true);
 assert.strictEqual(url.port, '23');
 
 url.pathname = '/aaa/bbb';
 assert.strictEqual(url.pathname, '/aaa/bbb');
-assert.strictEqual(url.toString(),
-                   'https://user2:pass2@foo.bar.org:23/aaa/bbb?l=25#test');
-assert.strictEqual((delete url.pathname), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass2@foo.bar.org:23/aaa/bbb?l=25#test'
+);
+assert.strictEqual(delete url.pathname, true);
 assert.strictEqual(url.pathname, '/aaa/bbb');
 
 url.search = '?k=99';
 assert.strictEqual(url.search, '?k=99');
-assert.strictEqual(url.toString(),
-                   'https://user2:pass2@foo.bar.org:23/aaa/bbb?k=99#test');
-assert.strictEqual((delete url.search), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass2@foo.bar.org:23/aaa/bbb?k=99#test'
+);
+assert.strictEqual(delete url.search, true);
 assert.strictEqual(url.search, '?k=99');
 
 url.hash = '#abcd';
 assert.strictEqual(url.hash, '#abcd');
-assert.strictEqual(url.toString(),
-                   'https://user2:pass2@foo.bar.org:23/aaa/bbb?k=99#abcd');
-assert.strictEqual((delete url.hash), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass2@foo.bar.org:23/aaa/bbb?k=99#abcd'
+);
+assert.strictEqual(delete url.hash, true);
 assert.strictEqual(url.hash, '#abcd');
 
 // searchParams is readonly. Under strict mode setting a
 // non-writable property should throw.
 // Note: this error message is subject to change in V8 updates
 assert.throws(
-  () => url.searchParams = '?k=88',
+  () => (url.searchParams = '?k=88'),
   /^TypeError: Cannot set property searchParams of \[object URL\] which has only a getter$/
 );
 assert.strictEqual(url.searchParams, oldParams);
-assert.strictEqual(url.toString(),
-                   'https://user2:pass2@foo.bar.org:23/aaa/bbb?k=99#abcd');
-assert.strictEqual((delete url.searchParams), true);
+assert.strictEqual(
+  url.toString(),
+  'https://user2:pass2@foo.bar.org:23/aaa/bbb?k=99#abcd'
+);
+assert.strictEqual(delete url.searchParams, true);
 assert.strictEqual(url.searchParams, oldParams);
 
 // Test urlToOptions
 {
-  const opts =
-    urlToOptions(new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test'));
+  const opts = urlToOptions(
+    new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test')
+  );
   assert.strictEqual(opts instanceof URL, false);
   assert.strictEqual(opts.protocol, 'http:');
   assert.strictEqual(opts.auth, 'user:pass');
@@ -151,8 +190,10 @@ assert.strictEqual(url.searchParams, oldParams);
 
 // Test special origins
 [
-  { expected: 'https://whatwg.org',
-    url: 'blob:https://whatwg.org/d0360e2f-caee-469f-9a2f-87d5b0456f6f' },
+  {
+    expected: 'https://whatwg.org',
+    url: 'blob:https://whatwg.org/d0360e2f-caee-469f-9a2f-87d5b0456f6f'
+  },
   { expected: 'ftp://example.org', url: 'ftp://example.org/foo' },
   { expected: 'gopher://gopher.quux.org', url: 'gopher://gopher.quux.org/1/' },
   { expected: 'http://example.org', url: 'http://example.org/foo' },
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-append.js b/test/parallel/test-whatwg-url-custom-searchparams-append.js
index e5d3f203588c60..2befec63ad4c0b 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-append.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-append.js
@@ -8,30 +8,44 @@ const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
-  common.expectsError(() => {
-    params.append.call(undefined);
-  }, {
-    code: 'ERR_INVALID_THIS',
-    type: TypeError,
-    message: 'Value of "this" must be of type URLSearchParams'
-  });
-  common.expectsError(() => {
-    params.append('a');
-  }, {
-    code: 'ERR_MISSING_ARGS',
-    type: TypeError,
-    message: 'The "name" and "value" arguments must be specified'
-  });
+  common.expectsError(
+    () => {
+      params.append.call(undefined);
+    },
+    {
+      code: 'ERR_INVALID_THIS',
+      type: TypeError,
+      message: 'Value of "this" must be of type URLSearchParams'
+    }
+  );
+  common.expectsError(
+    () => {
+      params.append('a');
+    },
+    {
+      code: 'ERR_MISSING_ARGS',
+      type: TypeError,
+      message: 'The "name" and "value" arguments must be specified'
+    }
+  );
 
   const obj = {
-    toString() { throw new Error('toString'); },
-    valueOf() { throw new Error('valueOf'); }
+    toString() {
+      throw new Error('toString');
+    },
+    valueOf() {
+      throw new Error('valueOf');
+    }
   };
   const sym = Symbol();
   assert.throws(() => params.set(obj, 'b'), /^Error: toString$/);
   assert.throws(() => params.set('a', obj), /^Error: toString$/);
-  assert.throws(() => params.set(sym, 'b'),
-                /^TypeError: Cannot convert a Symbol value to a string$/);
-  assert.throws(() => params.set('a', sym),
-                /^TypeError: Cannot convert a Symbol value to a string$/);
+  assert.throws(
+    () => params.set(sym, 'b'),
+    /^TypeError: Cannot convert a Symbol value to a string$/
+  );
+  assert.throws(
+    () => params.set('a', sym),
+    /^TypeError: Cannot convert a Symbol value to a string$/
+  );
 }
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-constructor.js b/test/parallel/test-whatwg-url-custom-searchparams-constructor.js
index fd7cc511279033..d7cd4ab8616785 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-constructor.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-constructor.js
@@ -20,11 +20,14 @@ function makeIterableFunc(array) {
     type: TypeError,
     message: 'Query pairs must be iterable'
   });
-  const tupleError = common.expectsError({
-    code: 'ERR_INVALID_TUPLE',
-    type: TypeError,
-    message: 'Each query pair must be an iterable [name, value] tuple'
-  }, 6);
+  const tupleError = common.expectsError(
+    {
+      code: 'ERR_INVALID_TUPLE',
+      type: TypeError,
+      message: 'Each query pair must be an iterable [name, value] tuple'
+    },
+    6
+  );
 
   let params;
   params = new URLSearchParams(undefined);
@@ -41,19 +44,27 @@ function makeIterableFunc(array) {
   assert.strictEqual(params.toString(), 'key=val&key2=val2');
   assert.throws(() => new URLSearchParams([[1]]), tupleError);
   assert.throws(() => new URLSearchParams([[1, 2, 3]]), tupleError);
-  assert.throws(() => new URLSearchParams({ [Symbol.iterator]: 42 }),
-                iterableError);
+  assert.throws(
+    () => new URLSearchParams({ [Symbol.iterator]: 42 }),
+    iterableError
+  );
   assert.throws(() => new URLSearchParams([{}]), tupleError);
   assert.throws(() => new URLSearchParams(['a']), tupleError);
   assert.throws(() => new URLSearchParams([null]), tupleError);
-  assert.throws(() => new URLSearchParams([{ [Symbol.iterator]: 42 }]),
-                tupleError);
+  assert.throws(
+    () => new URLSearchParams([{ [Symbol.iterator]: 42 }]),
+    tupleError
+  );
 }
 
 {
   const obj = {
-    toString() { throw new Error('toString'); },
-    valueOf() { throw new Error('valueOf'); }
+    toString() {
+      throw new Error('toString');
+    },
+    valueOf() {
+      throw new Error('valueOf');
+    }
   };
   const sym = Symbol();
   const toStringError = /^Error: toString$/;
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-delete.js b/test/parallel/test-whatwg-url-custom-searchparams-delete.js
index a22345cc6eef82..9246f54f33a617 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-delete.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-delete.js
@@ -8,29 +8,41 @@ const { URL, URLSearchParams } = require('url');
 
 {
   const params = new URLSearchParams();
-  common.expectsError(() => {
-    params.delete.call(undefined);
-  }, {
-    code: 'ERR_INVALID_THIS',
-    type: TypeError,
-    message: 'Value of "this" must be of type URLSearchParams'
-  });
-  common.expectsError(() => {
-    params.delete();
-  }, {
-    code: 'ERR_MISSING_ARGS',
-    type: TypeError,
-    message: 'The "name" argument must be specified'
-  });
+  common.expectsError(
+    () => {
+      params.delete.call(undefined);
+    },
+    {
+      code: 'ERR_INVALID_THIS',
+      type: TypeError,
+      message: 'Value of "this" must be of type URLSearchParams'
+    }
+  );
+  common.expectsError(
+    () => {
+      params.delete();
+    },
+    {
+      code: 'ERR_MISSING_ARGS',
+      type: TypeError,
+      message: 'The "name" argument must be specified'
+    }
+  );
 
   const obj = {
-    toString() { throw new Error('toString'); },
-    valueOf() { throw new Error('valueOf'); }
+    toString() {
+      throw new Error('toString');
+    },
+    valueOf() {
+      throw new Error('valueOf');
+    }
   };
   const sym = Symbol();
   assert.throws(() => params.delete(obj), /^Error: toString$/);
-  assert.throws(() => params.delete(sym),
-                /^TypeError: Cannot convert a Symbol value to a string$/);
+  assert.throws(
+    () => params.delete(sym),
+    /^TypeError: Cannot convert a Symbol value to a string$/
+  );
 }
 
 // https://github.com/nodejs/node/issues/10480
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-entries.js b/test/parallel/test-whatwg-url-custom-searchparams-entries.js
index fc3086545870ee..6016a8ea70b2fb 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-entries.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-entries.js
@@ -26,17 +26,23 @@ assert.deepStrictEqual(entries.next(), {
   done: true
 });
 
-common.expectsError(() => {
-  entries.next.call(undefined);
-}, {
-  code: 'ERR_INVALID_THIS',
-  type: TypeError,
-  message: 'Value of "this" must be of type URLSearchParamsIterator'
-});
-common.expectsError(() => {
-  params.entries.call(undefined);
-}, {
-  code: 'ERR_INVALID_THIS',
-  type: TypeError,
-  message: 'Value of "this" must be of type URLSearchParams'
-});
+common.expectsError(
+  () => {
+    entries.next.call(undefined);
+  },
+  {
+    code: 'ERR_INVALID_THIS',
+    type: TypeError,
+    message: 'Value of "this" must be of type URLSearchParamsIterator'
+  }
+);
+common.expectsError(
+  () => {
+    params.entries.call(undefined);
+  },
+  {
+    code: 'ERR_INVALID_THIS',
+    type: TypeError,
+    message: 'Value of "this" must be of type URLSearchParams'
+  }
+);
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-foreach.js b/test/parallel/test-whatwg-url-custom-searchparams-foreach.js
index 3e729d2bcd4cdd..fab57059438b6b 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-foreach.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-foreach.js
@@ -7,11 +7,14 @@ const { URLSearchParams } = require('url');
 
 {
   const params = new URLSearchParams();
-  common.expectsError(() => {
-    params.forEach.call(undefined);
-  }, {
-    code: 'ERR_INVALID_THIS',
-    type: TypeError,
-    message: 'Value of "this" must be of type URLSearchParams'
-  });
+  common.expectsError(
+    () => {
+      params.forEach.call(undefined);
+    },
+    {
+      code: 'ERR_INVALID_THIS',
+      type: TypeError,
+      message: 'Value of "this" must be of type URLSearchParams'
+    }
+  );
 }
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-get.js b/test/parallel/test-whatwg-url-custom-searchparams-get.js
index b99a5fae97d927..fe2b5c2ca3b234 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-get.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-get.js
@@ -8,27 +8,39 @@ const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
-  common.expectsError(() => {
-    params.get.call(undefined);
-  }, {
-    code: 'ERR_INVALID_THIS',
-    type: TypeError,
-    message: 'Value of "this" must be of type URLSearchParams'
-  });
-  common.expectsError(() => {
-    params.get();
-  }, {
-    code: 'ERR_MISSING_ARGS',
-    type: TypeError,
-    message: 'The "name" argument must be specified'
-  });
+  common.expectsError(
+    () => {
+      params.get.call(undefined);
+    },
+    {
+      code: 'ERR_INVALID_THIS',
+      type: TypeError,
+      message: 'Value of "this" must be of type URLSearchParams'
+    }
+  );
+  common.expectsError(
+    () => {
+      params.get();
+    },
+    {
+      code: 'ERR_MISSING_ARGS',
+      type: TypeError,
+      message: 'The "name" argument must be specified'
+    }
+  );
 
   const obj = {
-    toString() { throw new Error('toString'); },
-    valueOf() { throw new Error('valueOf'); }
+    toString() {
+      throw new Error('toString');
+    },
+    valueOf() {
+      throw new Error('valueOf');
+    }
   };
   const sym = Symbol();
   assert.throws(() => params.get(obj), /^Error: toString$/);
-  assert.throws(() => params.get(sym),
-                /^TypeError: Cannot convert a Symbol value to a string$/);
+  assert.throws(
+    () => params.get(sym),
+    /^TypeError: Cannot convert a Symbol value to a string$/
+  );
 }
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-getall.js b/test/parallel/test-whatwg-url-custom-searchparams-getall.js
index 7f3c7b7610cfd7..f4e1436e5d3251 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-getall.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-getall.js
@@ -8,27 +8,39 @@ const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
-  common.expectsError(() => {
-    params.getAll.call(undefined);
-  }, {
-    code: 'ERR_INVALID_THIS',
-    type: TypeError,
-    message: 'Value of "this" must be of type URLSearchParams'
-  });
-  common.expectsError(() => {
-    params.getAll();
-  }, {
-    code: 'ERR_MISSING_ARGS',
-    type: TypeError,
-    message: 'The "name" argument must be specified'
-  });
+  common.expectsError(
+    () => {
+      params.getAll.call(undefined);
+    },
+    {
+      code: 'ERR_INVALID_THIS',
+      type: TypeError,
+      message: 'Value of "this" must be of type URLSearchParams'
+    }
+  );
+  common.expectsError(
+    () => {
+      params.getAll();
+    },
+    {
+      code: 'ERR_MISSING_ARGS',
+      type: TypeError,
+      message: 'The "name" argument must be specified'
+    }
+  );
 
   const obj = {
-    toString() { throw new Error('toString'); },
-    valueOf() { throw new Error('valueOf'); }
+    toString() {
+      throw new Error('toString');
+    },
+    valueOf() {
+      throw new Error('valueOf');
+    }
   };
   const sym = Symbol();
   assert.throws(() => params.getAll(obj), /^Error: toString$/);
-  assert.throws(() => params.getAll(sym),
-                /^TypeError: Cannot convert a Symbol value to a string$/);
+  assert.throws(
+    () => params.getAll(sym),
+    /^TypeError: Cannot convert a Symbol value to a string$/
+  );
 }
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-has.js b/test/parallel/test-whatwg-url-custom-searchparams-has.js
index 2697f199bcc98b..4d57d6c61ba1d6 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-has.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-has.js
@@ -8,27 +8,39 @@ const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
-  common.expectsError(() => {
-    params.has.call(undefined);
-  }, {
-    code: 'ERR_INVALID_THIS',
-    type: TypeError,
-    message: 'Value of "this" must be of type URLSearchParams'
-  });
-  common.expectsError(() => {
-    params.has();
-  }, {
-    code: 'ERR_MISSING_ARGS',
-    type: TypeError,
-    message: 'The "name" argument must be specified'
-  });
+  common.expectsError(
+    () => {
+      params.has.call(undefined);
+    },
+    {
+      code: 'ERR_INVALID_THIS',
+      type: TypeError,
+      message: 'Value of "this" must be of type URLSearchParams'
+    }
+  );
+  common.expectsError(
+    () => {
+      params.has();
+    },
+    {
+      code: 'ERR_MISSING_ARGS',
+      type: TypeError,
+      message: 'The "name" argument must be specified'
+    }
+  );
 
   const obj = {
-    toString() { throw new Error('toString'); },
-    valueOf() { throw new Error('valueOf'); }
+    toString() {
+      throw new Error('toString');
+    },
+    valueOf() {
+      throw new Error('valueOf');
+    }
   };
   const sym = Symbol();
   assert.throws(() => params.has(obj), /^Error: toString$/);
-  assert.throws(() => params.has(sym),
-                /^TypeError: Cannot convert a Symbol value to a string$/);
+  assert.throws(
+    () => params.has(sym),
+    /^TypeError: Cannot convert a Symbol value to a string$/
+  );
 }
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-inspect.js b/test/parallel/test-whatwg-url-custom-searchparams-inspect.js
index 6cc22caea62436..7d7cdc8dc84d24 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-inspect.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-inspect.js
@@ -8,23 +8,33 @@ const util = require('util');
 const URLSearchParams = require('url').URLSearchParams;
 
 const sp = new URLSearchParams('?a=a&b=b&b=c');
-assert.strictEqual(util.inspect(sp),
-                   "URLSearchParams { 'a' => 'a', 'b' => 'b', 'b' => 'c' }");
-assert.strictEqual(util.inspect(sp.keys()),
-                   "URLSearchParams Iterator { 'a', 'b', 'b' }");
-assert.strictEqual(util.inspect(sp.values()),
-                   "URLSearchParams Iterator { 'a', 'b', 'c' }");
-assert.strictEqual(util.inspect(sp.keys(), { breakLength: 1 }),
-                   "URLSearchParams Iterator {\n  'a',\n  'b',\n  'b' }");
+assert.strictEqual(
+  util.inspect(sp),
+  "URLSearchParams { 'a' => 'a', 'b' => 'b', 'b' => 'c' }"
+);
+assert.strictEqual(
+  util.inspect(sp.keys()),
+  "URLSearchParams Iterator { 'a', 'b', 'b' }"
+);
+assert.strictEqual(
+  util.inspect(sp.values()),
+  "URLSearchParams Iterator { 'a', 'b', 'c' }"
+);
+assert.strictEqual(
+  util.inspect(sp.keys(), { breakLength: 1 }),
+  "URLSearchParams Iterator {\n  'a',\n  'b',\n  'b' }"
+);
 
 const iterator = sp.entries();
-assert.strictEqual(util.inspect(iterator),
-                   "URLSearchParams Iterator { [ 'a', 'a' ], [ 'b', 'b' ], " +
-                                             "[ 'b', 'c' ] }");
+assert.strictEqual(
+  util.inspect(iterator),
+  "URLSearchParams Iterator { [ 'a', 'a' ], [ 'b', 'b' ], " + "[ 'b', 'c' ] }"
+);
 iterator.next();
-assert.strictEqual(util.inspect(iterator),
-                   "URLSearchParams Iterator { [ 'b', 'b' ], [ 'b', 'c' ] }");
+assert.strictEqual(
+  util.inspect(iterator),
+  "URLSearchParams Iterator { [ 'b', 'b' ], [ 'b', 'c' ] }"
+);
 iterator.next();
 iterator.next();
-assert.strictEqual(util.inspect(iterator),
-                   'URLSearchParams Iterator {  }');
+assert.strictEqual(util.inspect(iterator), 'URLSearchParams Iterator {  }');
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-keys.js b/test/parallel/test-whatwg-url-custom-searchparams-keys.js
index 00800cc79cbf7e..7d26d80353cdfc 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-keys.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-keys.js
@@ -28,17 +28,23 @@ assert.deepStrictEqual(keys.next(), {
   done: true
 });
 
-common.expectsError(() => {
-  keys.next.call(undefined);
-}, {
-  code: 'ERR_INVALID_THIS',
-  type: TypeError,
-  message: 'Value of "this" must be of type URLSearchParamsIterator'
-});
-common.expectsError(() => {
-  params.keys.call(undefined);
-}, {
-  code: 'ERR_INVALID_THIS',
-  type: TypeError,
-  message: 'Value of "this" must be of type URLSearchParams'
-});
+common.expectsError(
+  () => {
+    keys.next.call(undefined);
+  },
+  {
+    code: 'ERR_INVALID_THIS',
+    type: TypeError,
+    message: 'Value of "this" must be of type URLSearchParamsIterator'
+  }
+);
+common.expectsError(
+  () => {
+    params.keys.call(undefined);
+  },
+  {
+    code: 'ERR_INVALID_THIS',
+    type: TypeError,
+    message: 'Value of "this" must be of type URLSearchParams'
+  }
+);
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-set.js b/test/parallel/test-whatwg-url-custom-searchparams-set.js
index ccd3353ecd0e8e..0eef7b97a01659 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-set.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-set.js
@@ -8,30 +8,44 @@ const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
-  common.expectsError(() => {
-    params.set.call(undefined);
-  }, {
-    code: 'ERR_INVALID_THIS',
-    type: TypeError,
-    message: 'Value of "this" must be of type URLSearchParams'
-  });
-  common.expectsError(() => {
-    params.set('a');
-  }, {
-    code: 'ERR_MISSING_ARGS',
-    type: TypeError,
-    message: 'The "name" and "value" arguments must be specified'
-  });
+  common.expectsError(
+    () => {
+      params.set.call(undefined);
+    },
+    {
+      code: 'ERR_INVALID_THIS',
+      type: TypeError,
+      message: 'Value of "this" must be of type URLSearchParams'
+    }
+  );
+  common.expectsError(
+    () => {
+      params.set('a');
+    },
+    {
+      code: 'ERR_MISSING_ARGS',
+      type: TypeError,
+      message: 'The "name" and "value" arguments must be specified'
+    }
+  );
 
   const obj = {
-    toString() { throw new Error('toString'); },
-    valueOf() { throw new Error('valueOf'); }
+    toString() {
+      throw new Error('toString');
+    },
+    valueOf() {
+      throw new Error('valueOf');
+    }
   };
   const sym = Symbol();
   assert.throws(() => params.append(obj, 'b'), /^Error: toString$/);
   assert.throws(() => params.append('a', obj), /^Error: toString$/);
-  assert.throws(() => params.append(sym, 'b'),
-                /^TypeError: Cannot convert a Symbol value to a string$/);
-  assert.throws(() => params.append('a', sym),
-                /^TypeError: Cannot convert a Symbol value to a string$/);
+  assert.throws(
+    () => params.append(sym, 'b'),
+    /^TypeError: Cannot convert a Symbol value to a string$/
+  );
+  assert.throws(
+    () => params.append('a', sym),
+    /^TypeError: Cannot convert a Symbol value to a string$/
+  );
 }
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-sort.js b/test/parallel/test-whatwg-url-custom-searchparams-sort.js
index 49c3b065f957c6..7681e2736e6cad 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-sort.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-sort.js
@@ -18,15 +18,15 @@ for (let i = 10; i < 100; i++) {
   pairs.push([`a${i}`, 'b']);
   tests[0].output.push([`a${i}`, 'b']);
 }
-tests[0].input = pairs.sort(() => Math.random() > 0.5)
-  .map((pair) => pair.join('=')).join('&');
+tests[0].input = pairs
+  .sort(() => Math.random() > 0.5)
+  .map((pair) => pair.join('='))
+  .join('&');
 
-tests.push(
-  {
-    'input': 'z=a&=b&c=d',
-    'output': [['', 'b'], ['c', 'd'], ['z', 'a']]
-  }
-);
+tests.push({
+  input: 'z=a&=b&c=d',
+  output: [['', 'b'], ['c', 'd'], ['z', 'a']]
+});
 
 tests.forEach((val) => {
   test(() => {
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-stringifier.js b/test/parallel/test-whatwg-url-custom-searchparams-stringifier.js
index d2929ae557a079..f7d94dfdb8c8ff 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-stringifier.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-stringifier.js
@@ -7,11 +7,14 @@ const URLSearchParams = require('url').URLSearchParams;
 
 {
   const params = new URLSearchParams();
-  common.expectsError(() => {
-    params.toString.call(undefined);
-  }, {
-    code: 'ERR_INVALID_THIS',
-    type: TypeError,
-    message: 'Value of "this" must be of type URLSearchParams'
-  });
+  common.expectsError(
+    () => {
+      params.toString.call(undefined);
+    },
+    {
+      code: 'ERR_INVALID_THIS',
+      type: TypeError,
+      message: 'Value of "this" must be of type URLSearchParams'
+    }
+  );
 }
diff --git a/test/parallel/test-whatwg-url-custom-searchparams-values.js b/test/parallel/test-whatwg-url-custom-searchparams-values.js
index e10a9dc04fe0df..28e3764874573b 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams-values.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams-values.js
@@ -28,17 +28,23 @@ assert.deepStrictEqual(values.next(), {
   done: true
 });
 
-common.expectsError(() => {
-  values.next.call(undefined);
-}, {
-  code: 'ERR_INVALID_THIS',
-  type: TypeError,
-  message: 'Value of "this" must be of type URLSearchParamsIterator'
-});
-common.expectsError(() => {
-  params.values.call(undefined);
-}, {
-  code: 'ERR_INVALID_THIS',
-  type: TypeError,
-  message: 'Value of "this" must be of type URLSearchParams'
-});
+common.expectsError(
+  () => {
+    values.next.call(undefined);
+  },
+  {
+    code: 'ERR_INVALID_THIS',
+    type: TypeError,
+    message: 'Value of "this" must be of type URLSearchParamsIterator'
+  }
+);
+common.expectsError(
+  () => {
+    params.values.call(undefined);
+  },
+  {
+    code: 'ERR_INVALID_THIS',
+    type: TypeError,
+    message: 'Value of "this" must be of type URLSearchParams'
+  }
+);
diff --git a/test/parallel/test-whatwg-url-custom-searchparams.js b/test/parallel/test-whatwg-url-custom-searchparams.js
index f88c3b4a836b39..43ab1759ba9459 100644
--- a/test/parallel/test-whatwg-url-custom-searchparams.js
+++ b/test/parallel/test-whatwg-url-custom-searchparams.js
@@ -7,14 +7,34 @@ const assert = require('assert');
 const { URL, URLSearchParams } = require('url');
 const fixtures = require('../common/fixtures');
 
-const serialized = 'a=a&a=1&a=true&a=undefined&a=null&a=%EF%BF%BD' +
-                   '&a=%EF%BF%BD&a=%F0%9F%98%80&a=%EF%BF%BD%EF%BF%BD' +
-                   '&a=%5Bobject+Object%5D';
-const values = ['a', 1, true, undefined, null, '\uD83D', '\uDE00',
-                '\uD83D\uDE00', '\uDE00\uD83D', {}];
-const normalizedValues = ['a', '1', 'true', 'undefined', 'null', '\uFFFD',
-                          '\uFFFD', '\uD83D\uDE00', '\uFFFD\uFFFD',
-                          '[object Object]'];
+const serialized =
+  'a=a&a=1&a=true&a=undefined&a=null&a=%EF%BF%BD' +
+  '&a=%EF%BF%BD&a=%F0%9F%98%80&a=%EF%BF%BD%EF%BF%BD' +
+  '&a=%5Bobject+Object%5D';
+const values = [
+  'a',
+  1,
+  true,
+  undefined,
+  null,
+  '\uD83D',
+  '\uDE00',
+  '\uD83D\uDE00',
+  '\uDE00\uD83D',
+  {}
+];
+const normalizedValues = [
+  'a',
+  '1',
+  'true',
+  'undefined',
+  'null',
+  '\uFFFD',
+  '\uFFFD',
+  '\uD83D\uDE00',
+  '\uFFFD\uFFFD',
+  '[object Object]'
+];
 
 const m = new URL('http://example.org');
 const sp = m.searchParams;
@@ -74,10 +94,13 @@ sp.forEach(function() {
 }, m);
 
 {
-  const callbackErr = common.expectsError({
-    code: 'ERR_INVALID_CALLBACK',
-    type: TypeError
-  }, 2);
+  const callbackErr = common.expectsError(
+    {
+      code: 'ERR_INVALID_CALLBACK',
+      type: TypeError
+    },
+    2
+  );
   assert.throws(() => sp.forEach(), callbackErr);
   assert.throws(() => sp.forEach(1), callbackErr);
 }
diff --git a/test/parallel/test-whatwg-url-custom-setters.js b/test/parallel/test-whatwg-url-custom-setters.js
index e10ebb9fe66968..0fc8a817f29c64 100644
--- a/test/parallel/test-whatwg-url-custom-setters.js
+++ b/test/parallel/test-whatwg-url-custom-setters.js
@@ -14,8 +14,9 @@ const { test, assert_equals } = require('../common/wpt').harness;
 const fixtures = require('../common/fixtures');
 
 // TODO(joyeecheung): we should submit these to the upstream
-const additionalTestCases =
-  require(fixtures.path('url-setter-tests-additional.js'));
+const additionalTestCases = require(fixtures.path(
+  'url-setter-tests-additional.js'
+));
 
 {
   for (const attributeToBeSet in additionalTestCases) {
@@ -24,8 +25,9 @@ const additionalTestCases =
     }
     const testCases = additionalTestCases[attributeToBeSet];
     for (const testCase of testCases) {
-      let name = `Setting <${testCase.href}>.${attributeToBeSet}` +
-                 ` = "${testCase.new_value}"`;
+      let name =
+        `Setting <${testCase.href}>.${attributeToBeSet}` +
+        ` = "${testCase.new_value}"`;
       if ('comment' in testCase) {
         name += ` ${testCase.comment}`;
       }
@@ -43,19 +45,27 @@ const additionalTestCases =
 {
   const url = new URL('http://example.com/');
   const obj = {
-    toString() { throw new Error('toString'); },
-    valueOf() { throw new Error('valueOf'); }
+    toString() {
+      throw new Error('toString');
+    },
+    valueOf() {
+      throw new Error('valueOf');
+    }
   };
   const sym = Symbol();
   const props = Object.getOwnPropertyDescriptors(Object.getPrototypeOf(url));
   for (const [name, { set }] of Object.entries(props)) {
     if (set) {
-      assert.throws(() => url[name] = obj,
-                    /^Error: toString$/,
-                    `url.${name} = { toString() { throw ... } }`);
-      assert.throws(() => url[name] = sym,
-                    /^TypeError: Cannot convert a Symbol value to a string$/,
-                    `url.${name} = ${String(sym)}`);
+      assert.throws(
+        () => (url[name] = obj),
+        /^Error: toString$/,
+        `url.${name} = { toString() { throw ... } }`
+      );
+      assert.throws(
+        () => (url[name] = sym),
+        /^TypeError: Cannot convert a Symbol value to a string$/,
+        `url.${name} = ${String(sym)}`
+      );
     }
   }
 }
diff --git a/test/parallel/test-whatwg-url-custom-tostringtag.js b/test/parallel/test-whatwg-url-custom-tostringtag.js
index 784a3ebc7728e5..20fc802ab02327 100644
--- a/test/parallel/test-whatwg-url-custom-tostringtag.js
+++ b/test/parallel/test-whatwg-url-custom-tostringtag.js
@@ -21,13 +21,19 @@ const test = [
   // spec is changed.
   [Object.getPrototypeOf(url), 'URL'],
   [Object.getPrototypeOf(sp), 'URLSearchParams'],
-  [Object.getPrototypeOf(spIterator), 'URLSearchParams Iterator'],
+  [Object.getPrototypeOf(spIterator), 'URLSearchParams Iterator']
 ];
 
 test.forEach(([obj, expected]) => {
-  assert.strictEqual(obj[Symbol.toStringTag], expected,
-                     `${obj[Symbol.toStringTag]} !== ${expected}`);
+  assert.strictEqual(
+    obj[Symbol.toStringTag],
+    expected,
+    `${obj[Symbol.toStringTag]} !== ${expected}`
+  );
   const str = toString.call(obj);
-  assert.strictEqual(str, `[object ${expected}]`,
-                     `${str} !== [object ${expected}]`);
+  assert.strictEqual(
+    str,
+    `[object ${expected}]`,
+    `${str} !== [object ${expected}]`
+  );
 });
diff --git a/test/parallel/test-whatwg-url-origin.js b/test/parallel/test-whatwg-url-origin.js
index 5b1aa14cd07642..319a63a3f345a6 100644
--- a/test/parallel/test-whatwg-url-origin.js
+++ b/test/parallel/test-whatwg-url-origin.js
@@ -10,9 +10,12 @@ const URL = require('url').URL;
 const { test, assert_equals } = require('../common/wpt').harness;
 
 const request = {
-  response: require(
-    fixtures.path('wpt', 'url', 'resources', 'urltestdata.json')
-  )
+  response: require(fixtures.path(
+    'wpt',
+    'url',
+    'resources',
+    'urltestdata.json'
+  ))
 };
 
 /* The following tests are copied from WPT. Modifications to them should be
@@ -29,26 +32,30 @@ function runURLOriginTests() {
   //   request.send()
   //   request.responseType = "json"
   //   request.onload = setup.step_func(function() {
-         runURLTests(request.response)
+  runURLTests(request.response);
   //     setup.done()
   //   })
   // })
 }
 
 function bURL(url, base) {
-  return new URL(url, base || "about:blank")
+  return new URL(url, base || 'about:blank');
 }
 
 function runURLTests(urltests) {
-  for(var i = 0, l = urltests.length; i < l; i++) {
-    var expected = urltests[i]
-    if (typeof expected === "string" || !("origin" in expected)) continue
+  for (var i = 0, l = urltests.length; i < l; i++) {
+    var expected = urltests[i];
+    if (typeof expected === 'string' || !('origin' in expected)) continue;
     test(function() {
-      var url = bURL(expected.input, expected.base)
-      assert_equals(url.origin, expected.origin, "origin")
-    }, "Origin parsing: <" + expected.input + "> against <" + expected.base + ">")
+      var url = bURL(expected.input, expected.base);
+      assert_equals(url.origin, expected.origin, 'origin');
+    }, 'Origin parsing: <' +
+      expected.input +
+      '> against <' +
+      expected.base +
+      '>');
   }
 }
 
-runURLOriginTests()
+runURLOriginTests();
 /* eslint-enable */
diff --git a/test/parallel/test-whatwg-url-setters.js b/test/parallel/test-whatwg-url-setters.js
index 13422bd77690ed..9f802d9cb38032 100644
--- a/test/parallel/test-whatwg-url-setters.js
+++ b/test/parallel/test-whatwg-url-setters.js
@@ -12,7 +12,10 @@ const fixtures = require('../common/fixtures');
 
 const request = {
   response: require(fixtures.path(
-    'wpt', 'url', 'resources', 'setters_tests.json'
+    'wpt',
+    'url',
+    'resources',
+    'setters_tests.json'
   ))
 };
 
@@ -23,37 +26,38 @@ const request = {
 */
 /* eslint-disable */
 function startURLSettersTests() {
-//   var setup = async_test("Loading data…")
-//   setup.step(function() {
-//     var request = new XMLHttpRequest()
-//     request.open("GET", "setters_tests.json")
-//     request.send()
-//     request.responseType = "json"
-//     request.onload = setup.step_func(function() {
-         runURLSettersTests(request.response)
-//       setup.done()
-//     })
-//   })
+  //   var setup = async_test("Loading data…")
+  //   setup.step(function() {
+  //     var request = new XMLHttpRequest()
+  //     request.open("GET", "setters_tests.json")
+  //     request.send()
+  //     request.responseType = "json"
+  //     request.onload = setup.step_func(function() {
+  runURLSettersTests(request.response);
+  //       setup.done()
+  //     })
+  //   })
 }
 
 function runURLSettersTests(all_test_cases) {
   for (var attribute_to_be_set in all_test_cases) {
-    if (attribute_to_be_set == "comment") {
+    if (attribute_to_be_set == 'comment') {
       continue;
     }
     var test_cases = all_test_cases[attribute_to_be_set];
-    for(var i = 0, l = test_cases.length; i < l; i++) {
+    for (var i = 0, l = test_cases.length; i < l; i++) {
       var test_case = test_cases[i];
-      var name = `Setting <${test_case.href}>.${attribute_to_be_set}` +
-                 ` = '${test_case.new_value}'`;
-      if ("comment" in test_case) {
+      var name =
+        `Setting <${test_case.href}>.${attribute_to_be_set}` +
+        ` = '${test_case.new_value}'`;
+      if ('comment' in test_case) {
         name += ` ${test_case.comment}`;
       }
       test(function() {
         var url = new URL(test_case.href);
         url[attribute_to_be_set] = test_case.new_value;
         for (var attribute in test_case.expected) {
-          assert_equals(url[attribute], test_case.expected[attribute])
+          assert_equals(url[attribute], test_case.expected[attribute]);
         }
       }, `URL: ${name}`);
       // test(function() {
@@ -76,5 +80,5 @@ function runURLSettersTests(all_test_cases) {
   }
 }
 
-startURLSettersTests()
+startURLSettersTests();
 /* eslint-enable */
diff --git a/test/parallel/test-whatwg-url-toascii.js b/test/parallel/test-whatwg-url-toascii.js
index 4869ab3f1d3bd1..d67994f2336f5f 100644
--- a/test/parallel/test-whatwg-url-toascii.js
+++ b/test/parallel/test-whatwg-url-toascii.js
@@ -10,9 +10,7 @@ const { URL } = require('url');
 const { test, assert_equals, assert_throws } = require('../common/wpt').harness;
 
 const request = {
-  response: require(
-    fixtures.path('wpt', 'url', 'resources', 'toascii.json')
-  )
+  response: require(fixtures.path('wpt', 'url', 'resources', 'toascii.json'))
 };
 
 /* The following tests are copied from WPT. Modifications to them should be
@@ -27,61 +25,63 @@ const request = {
 //   request.send()
 //   request.responseType = "json"
 //   request.onload = t.step_func_done(() => {
-    runTests(request.response)
+runTests(request.response);
 //   })
 // }, "Loading data…")
 
 function makeURL(type, input) {
-  input = "https://" + input + "/x"
-  if(type === "url") {
-    return new URL(input)
+  input = 'https://' + input + '/x';
+  if (type === 'url') {
+    return new URL(input);
   } else {
-    const url = document.createElement(type)
-    url.href = input
-    return url
+    const url = document.createElement(type);
+    url.href = input;
+    return url;
   }
 }
 
 function runTests(tests) {
-  for(var i = 0, l = tests.length; i < l; i++) {
-    let hostTest = tests[i]
-    if (typeof hostTest === "string") {
-      continue // skip comments
+  for (var i = 0, l = tests.length; i < l; i++) {
+    let hostTest = tests[i];
+    if (typeof hostTest === 'string') {
+      continue; // skip comments
     }
-    const typeName = { "url": "URL", "a": "<a>", "area": "<area>" }
+    const typeName = { url: 'URL', a: '<a>', area: '<area>' };
     // ;["url", "a", "area"].forEach((type) => {
-    ;["url"].forEach((type) => {
+    ['url'].forEach((type) => {
       test(() => {
-        if(hostTest.output !== null) {
-          const url = makeURL("url", hostTest.input)
-          assert_equals(url.host, hostTest.output)
-          assert_equals(url.hostname, hostTest.output)
-          assert_equals(url.pathname, "/x")
-          assert_equals(url.href, "https://" + hostTest.output + "/x")
+        if (hostTest.output !== null) {
+          const url = makeURL('url', hostTest.input);
+          assert_equals(url.host, hostTest.output);
+          assert_equals(url.hostname, hostTest.output);
+          assert_equals(url.pathname, '/x');
+          assert_equals(url.href, 'https://' + hostTest.output + '/x');
         } else {
-          if(type === "url") {
-            assert_throws(new TypeError, () => makeURL("url", hostTest.input))
+          if (type === 'url') {
+            assert_throws(new TypeError(), () =>
+              makeURL('url', hostTest.input)
+            );
           } else {
-            const url = makeURL(type, hostTest.input)
-            assert_equals(url.host, "")
-            assert_equals(url.hostname, "")
-            assert_equals(url.pathname, "")
-            assert_equals(url.href, "https://" + hostTest.input + "/x")
+            const url = makeURL(type, hostTest.input);
+            assert_equals(url.host, '');
+            assert_equals(url.hostname, '');
+            assert_equals(url.pathname, '');
+            assert_equals(url.href, 'https://' + hostTest.input + '/x');
           }
         }
-      }, hostTest.input + " (using " + typeName[type] + ")")
-      ;["host", "hostname"].forEach((val) => {
+      }, hostTest.input + ' (using ' + typeName[type] + ')');
+      ['host', 'hostname'].forEach((val) => {
         test(() => {
-          const url = makeURL(type, "x")
-          url[val] = hostTest.input
-          if(hostTest.output !== null) {
-            assert_equals(url[val], hostTest.output)
+          const url = makeURL(type, 'x');
+          url[val] = hostTest.input;
+          if (hostTest.output !== null) {
+            assert_equals(url[val], hostTest.output);
           } else {
-            assert_equals(url[val], "x")
+            assert_equals(url[val], 'x');
           }
-        }, hostTest.input + " (using " + typeName[type] + "." + val + ")")
-      })
-    })
+        }, hostTest.input + ' (using ' + typeName[type] + '.' + val + ')');
+      });
+    });
   }
 }
 /* eslint-enable */
diff --git a/test/parallel/test-windows-abort-exitcode.js b/test/parallel/test-windows-abort-exitcode.js
index e2e6570c1c8119..faefd4b9853c23 100644
--- a/test/parallel/test-windows-abort-exitcode.js
+++ b/test/parallel/test-windows-abort-exitcode.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.isWindows)
-  common.skip('test is windows specific');
+if (!common.isWindows) common.skip('test is windows specific');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
@@ -15,8 +14,11 @@ if (process.argv[2] === 'child') {
   process.abort();
 } else {
   const child = spawn(process.execPath, [__filename, 'child']);
-  child.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(code, 134);
-    assert.strictEqual(signal, null);
-  }));
+  child.on(
+    'exit',
+    common.mustCall((code, signal) => {
+      assert.strictEqual(code, 134);
+      assert.strictEqual(signal, null);
+    })
+  );
 }
diff --git a/test/parallel/test-windows-failed-heap-allocation.js b/test/parallel/test-windows-failed-heap-allocation.js
index e03c9ee006eabd..35c60368db1589 100644
--- a/test/parallel/test-windows-failed-heap-allocation.js
+++ b/test/parallel/test-windows-failed-heap-allocation.js
@@ -16,9 +16,12 @@ if (process.argv[2] === 'heapBomb') {
 
 // --max-old-space-size=3 is the min 'old space' in V8, explodes fast
 const cmd = `"${process.execPath}" --max-old-space-size=3 "${__filename}"`;
-exec(`${cmd} heapBomb`, common.mustCall((err) => {
-  const msg = `Wrong exit code of ${err.code}! Expected 134 for abort`;
-  // Note: common.nodeProcessAborted() is not asserted here because it
-  // returns true on 134 as well as 0xC0000005 (V8's base::OS::Abort)
-  assert.strictEqual(err.code, 134, msg);
-}));
+exec(
+  `${cmd} heapBomb`,
+  common.mustCall((err) => {
+    const msg = `Wrong exit code of ${err.code}! Expected 134 for abort`;
+    // Note: common.nodeProcessAborted() is not asserted here because it
+    // returns true on 134 as well as 0xC0000005 (V8's base::OS::Abort)
+    assert.strictEqual(err.code, 134, msg);
+  })
+);
diff --git a/test/parallel/test-worker-cleanup-handles.js b/test/parallel/test-worker-cleanup-handles.js
index 2fd11398da07b7..dab9254eb07ff1 100644
--- a/test/parallel/test-worker-cleanup-handles.js
+++ b/test/parallel/test-worker-cleanup-handles.js
@@ -9,19 +9,24 @@ const fs = require('fs');
 if (isMainThread) {
   const w = new Worker(__filename);
   let fd = null;
-  w.on('message', common.mustCall((fd_) => {
-    assert.strictEqual(typeof fd_, 'number');
-    fd = fd_;
-  }));
-  w.on('exit', common.mustCall((code) => {
-    if (fd === -1) {
-      // This happens when server sockets don’t have file descriptors,
-      // i.e. on Windows.
-      return;
-    }
-    common.expectsError(() => fs.fstatSync(fd),
-                        { code: 'EBADF' });
-  }));
+  w.on(
+    'message',
+    common.mustCall((fd_) => {
+      assert.strictEqual(typeof fd_, 'number');
+      fd = fd_;
+    })
+  );
+  w.on(
+    'exit',
+    common.mustCall((code) => {
+      if (fd === -1) {
+        // This happens when server sockets don’t have file descriptors,
+        // i.e. on Windows.
+        return;
+      }
+      common.expectsError(() => fs.fstatSync(fd), { code: 'EBADF' });
+    })
+  );
 } else {
   const server = new Server();
   server.listen(0);
diff --git a/test/parallel/test-worker-debug.js b/test/parallel/test-worker-debug.js
index 2340c233a1470c..e4834a203f2fa6 100644
--- a/test/parallel/test-worker-debug.js
+++ b/test/parallel/test-worker-debug.js
@@ -9,10 +9,12 @@ const EventEmitter = require('events');
 const { Session } = require('inspector');
 const { pathToFileURL } = require('url');
 const {
-  Worker, isMainThread, parentPort, workerData
+  Worker,
+  isMainThread,
+  parentPort,
+  workerData
 } = require('worker_threads');
 
-
 const workerMessage = 'This is a message from a worker';
 
 function waitForMessage() {
@@ -25,7 +27,7 @@ function waitForMessage() {
 if (!isMainThread) {
   if (workerData === 1) {
     console.log(workerMessage);
-    debugger;  // eslint-disable-line no-debugger
+    debugger; // eslint-disable-line no-debugger
   } else if (workerData === 2) {
     parentPort.postMessage('running');
     waitForMessage();
@@ -36,10 +38,8 @@ if (!isMainThread) {
 function doPost(session, method, params) {
   return new Promise((resolve, reject) => {
     session.post(method, params, (error, result) => {
-      if (error)
-        reject(JSON.stringify(error));
-      else
-        resolve(result);
+      if (error) reject(JSON.stringify(error));
+      else resolve(result);
     });
   });
 }
@@ -49,15 +49,18 @@ function waitForEvent(emitter, event) {
 }
 
 function waitForWorkerAttach(session) {
-  return waitForEvent(session, 'NodeWorker.attachedToWorker')
-      .then(({ params }) => params);
+  return waitForEvent(session, 'NodeWorker.attachedToWorker').then(
+    ({ params }) => params
+  );
 }
 
 async function waitForWorkerDetach(session, id) {
   let sessionId;
   do {
-    const { params } =
-        await waitForEvent(session, 'NodeWorker.detachedFromWorker');
+    const { params } = await waitForEvent(
+      session,
+      'NodeWorker.detachedFromWorker'
+    );
     sessionId = params.sessionId;
   } while (sessionId !== id);
 }
@@ -78,11 +81,13 @@ class WorkerSession extends EventEmitter {
     this._id = id;
     this._requestCallbacks = new Map();
     this._nextCommandId = 1;
-    this._parentSession.on('NodeWorker.receivedMessageFromWorker',
-                           ({ params }) => {
-                             if (params.sessionId === this._id)
-                               this._processMessage(JSON.parse(params.message));
-                           });
+    this._parentSession.on(
+      'NodeWorker.receivedMessageFromWorker',
+      ({ params }) => {
+        if (params.sessionId === this._id)
+          this._processMessage(JSON.parse(params.message));
+      }
+    );
   }
 
   _processMessage(message) {
@@ -95,10 +100,8 @@ class WorkerSession extends EventEmitter {
     const callback = this._requestCallbacks.get(message.id);
     if (callback) {
       this._requestCallbacks.delete(message.id);
-      if (message.error)
-        callback[1](message.error.message);
-      else
-        callback[0](message.result);
+      if (message.error) callback[1](message.error.message);
+      else callback[0](message.result);
     }
   }
 
@@ -116,13 +119,13 @@ class WorkerSession extends EventEmitter {
       id: this._nextCommandId++,
       method
     };
-    if (parameters)
-      msg.params = parameters;
+    if (parameters) msg.params = parameters;
 
     return new Promise((resolve, reject) => {
       this._requestCallbacks.set(msg.id, [resolve, reject]);
       this._parentSession.post('NodeWorker.sendMessageToWorker', {
-        sessionId: this._id, message: JSON.stringify(msg)
+        sessionId: this._id,
+        message: JSON.stringify(msg)
       });
     });
   }
@@ -149,14 +152,22 @@ async function testBasicWorkerDebug(session, post) {
     waitForEvent(workerSession, 'Runtime.executionContextCreated'),
     waitForEvent(workerSession, 'Runtime.executionContextDestroyed')
   ]);
-  const consolePromise = waitForEvent(workerSession, 'Runtime.consoleAPICalled')
-      .then((notification) => notification.params.args[0].value);
+  const consolePromise = waitForEvent(
+    workerSession,
+    'Runtime.consoleAPICalled'
+  ).then((notification) => notification.params.args[0].value);
   await workerSession.post('Debugger.enable');
   await workerSession.post('Runtime.enable');
   await workerSession.waitForBreakAfterCommand(
-    'Runtime.runIfWaitingForDebugger', __filename, 2);
+    'Runtime.runIfWaitingForDebugger',
+    __filename,
+    2
+  );
   await workerSession.waitForBreakAfterCommand(
-    'Debugger.resume', __filename, 27);  // V8 line number is zero-based
+    'Debugger.resume',
+    __filename,
+    27
+  ); // V8 line number is zero-based
   assert.strictEqual(await consolePromise, workerMessage);
   workerSession.post('Debugger.resume');
   await Promise.all([worker, detached, contextEvents]);
@@ -167,7 +178,9 @@ async function testNoWaitOnStart(session, post) {
   await post('NodeWorker.enable', { waitForDebuggerOnStart: false });
   let worker;
   const promise = waitForWorkerAttach(session);
-  const exitPromise = runWorker(2, (w) => { worker = w; });
+  const exitPromise = runWorker(2, (w) => {
+    worker = w;
+  });
   const { waitingForDebugger } = await promise;
   assert.strictEqual(waitingForDebugger, false);
   worker.postMessage('resume');
@@ -186,8 +199,10 @@ async function testTwoWorkers(session, post) {
   let worker1Exited;
   const worker = await new Promise((resolve, reject) => {
     worker1Exited = runWorker(2, resolve);
-  }).then((worker) => new Promise(
-    (resolve) => worker.once('message', () => resolve(worker))));
+  }).then(
+    (worker) =>
+      new Promise((resolve) => worker.once('message', () => resolve(worker)))
+  );
   okToAttach = true;
   await post('NodeWorker.enable', { waitForDebuggerOnStart: true });
   const { waitingForDebugger: worker1Waiting } = await worker1attached;
@@ -195,8 +210,9 @@ async function testTwoWorkers(session, post) {
 
   const worker2Attached = waitForWorkerAttach(session);
   let worker2Done = false;
-  const worker2Exited = runWorker(1)
-      .then(() => assert.strictEqual(worker2Done, true));
+  const worker2Exited = runWorker(1).then(() =>
+    assert.strictEqual(worker2Done, true)
+  );
   const worker2AttachInfo = await worker2Attached;
   assert.strictEqual(worker2AttachInfo.waitingForDebugger, true);
   worker2Done = true;
diff --git a/test/parallel/test-worker-dns-terminate.js b/test/parallel/test-worker-dns-terminate.js
index 8526f739873e74..9223fa4021de52 100644
--- a/test/parallel/test-worker-dns-terminate.js
+++ b/test/parallel/test-worker-dns-terminate.js
@@ -3,13 +3,19 @@
 const common = require('../common');
 const { Worker } = require('worker_threads');
 
-const w = new Worker(`
+const w = new Worker(
+  `
 const dns = require('dns');
 dns.lookup('nonexistent.org', () => {});
 require('worker_threads').parentPort.postMessage('0');
-`, { eval: true });
+`,
+  { eval: true }
+);
 
-w.on('message', common.mustCall(() => {
-  // This should not crash the worker during a DNS request.
-  w.terminate(common.mustCall());
-}));
+w.on(
+  'message',
+  common.mustCall(() => {
+    // This should not crash the worker during a DNS request.
+    w.terminate(common.mustCall());
+  })
+);
diff --git a/test/parallel/test-worker-esmodule.js b/test/parallel/test-worker-esmodule.js
index de4657452c9c7f..69ec4f6782e0c7 100644
--- a/test/parallel/test-worker-esmodule.js
+++ b/test/parallel/test-worker-esmodule.js
@@ -6,6 +6,9 @@ const assert = require('assert');
 const { Worker } = require('worker_threads');
 
 const w = new Worker(fixtures.path('worker-script.mjs'));
-w.on('message', common.mustCall((message) => {
-  assert.strictEqual(message, 'Hello, world!');
-}));
+w.on(
+  'message',
+  common.mustCall((message) => {
+    assert.strictEqual(message, 'Hello, world!');
+  })
+);
diff --git a/test/parallel/test-worker-exit-code.js b/test/parallel/test-worker-exit-code.js
index f09b834f853b12..9da0945ad0835f 100644
--- a/test/parallel/test-worker-exit-code.js
+++ b/test/parallel/test-worker-exit-code.js
@@ -27,18 +27,28 @@ if (!process.env.HAS_STARTED_WORKER) {
 function parent() {
   const test = (arg, name = 'worker', exit, error = null) => {
     const w = new Worker(__filename);
-    w.on('exit', common.mustCall((code) => {
-      assert.strictEqual(
-        code, exit,
-        `wrong exit for ${arg}-${name}\nexpected:${exit} but got:${code}`);
-      console.log(`ok - ${arg} exited with ${exit}`);
-    }));
+    w.on(
+      'exit',
+      common.mustCall((code) => {
+        assert.strictEqual(
+          code,
+          exit,
+          `wrong exit for ${arg}-${name}\nexpected:${exit} but got:${code}`
+        );
+        console.log(`ok - ${arg} exited with ${exit}`);
+      })
+    );
     if (error) {
-      w.on('error', common.mustCall((err) => {
-        console.log(err);
-        assert(error.test(err),
-               `wrong error for ${arg}\nexpected:${error} but got:${err}`);
-      }));
+      w.on(
+        'error',
+        common.mustCall((err) => {
+          console.log(err);
+          assert(
+            error.test(err),
+            `wrong error for ${arg}\nexpected:${error} but got:${err}`
+          );
+        })
+      );
     }
     w.postMessage(arg);
   };
diff --git a/test/parallel/test-worker-memory.js b/test/parallel/test-worker-memory.js
index c70f12c7b3f9c0..4397a22efb78ac 100644
--- a/test/parallel/test-worker-memory.js
+++ b/test/parallel/test-worker-memory.js
@@ -11,17 +11,23 @@ const numWorkers = +process.env.JOBS || require('os').cpus().length;
 
 function run(n, done) {
   console.log(`run() called with n=${n} (numWorkers=${numWorkers})`);
-  if (n <= 0)
-    return done();
+  if (n <= 0) return done();
   const worker = new Worker(
-    'require(\'worker_threads\').parentPort.postMessage(2 + 2)',
-    { eval: true });
-  worker.on('message', common.mustCall((value) => {
-    assert.strictEqual(value, 4);
-  }));
-  worker.on('exit', common.mustCall(() => {
-    run(n - 1, done);
-  }));
+    "require('worker_threads').parentPort.postMessage(2 + 2)",
+    { eval: true }
+  );
+  worker.on(
+    'message',
+    common.mustCall((value) => {
+      assert.strictEqual(value, 4);
+    })
+  );
+  worker.on(
+    'exit',
+    common.mustCall(() => {
+      run(n - 1, done);
+    })
+  );
 }
 
 const startStats = process.memoryUsage();
@@ -35,9 +41,10 @@ for (let i = 0; i < numWorkers; ++i) {
       // 5 as a upper limit is generous, but the main point is that we
       // don't have the memory of 50 Isolates/Node.js environments just lying
       // around somewhere.
-      assert.ok(finishStats.rss / startStats.rss < 5,
-                'Unexpected memory overhead: ' +
-                util.inspect([startStats, finishStats]));
+      assert.ok(
+        finishStats.rss / startStats.rss < 5,
+        'Unexpected memory overhead: ' + util.inspect([startStats, finishStats])
+      );
     }
   });
 }
diff --git a/test/parallel/test-worker-message-channel-sharedarraybuffer.js b/test/parallel/test-worker-message-channel-sharedarraybuffer.js
index 86335fb38b1516..d13593968f8332 100644
--- a/test/parallel/test-worker-message-channel-sharedarraybuffer.js
+++ b/test/parallel/test-worker-message-channel-sharedarraybuffer.js
@@ -9,19 +9,25 @@ const { Worker } = require('worker_threads');
   const sharedArrayBuffer = new SharedArrayBuffer(12);
   const local = Buffer.from(sharedArrayBuffer);
 
-  const w = new Worker(`
+  const w = new Worker(
+    `
     const { parentPort } = require('worker_threads');
     parentPort.on('message', ({ sharedArrayBuffer }) => {
       const local = Buffer.from(sharedArrayBuffer);
       local.write('world!', 6);
       parentPort.postMessage('written!');
     });
-  `, { eval: true });
-  w.on('message', common.mustCall(() => {
-    assert.strictEqual(local.toString(), 'Hello world!');
-    global.gc();
-    w.terminate();
-  }));
+  `,
+    { eval: true }
+  );
+  w.on(
+    'message',
+    common.mustCall(() => {
+      assert.strictEqual(local.toString(), 'Hello world!');
+      global.gc();
+      w.terminate();
+    })
+  );
   w.postMessage({ sharedArrayBuffer });
   // This would be a race condition if the memory regions were overlapping
   local.write('Hello ');
diff --git a/test/parallel/test-worker-message-channel.js b/test/parallel/test-worker-message-channel.js
index 03cc3549a82ff9..499fe788035819 100644
--- a/test/parallel/test-worker-message-channel.js
+++ b/test/parallel/test-worker-message-channel.js
@@ -7,12 +7,15 @@ const { MessageChannel, MessagePort, Worker } = require('worker_threads');
 {
   const channel = new MessageChannel();
 
-  channel.port1.on('message', common.mustCall(({ typedArray }) => {
-    assert.deepStrictEqual(typedArray, new Uint8Array([0, 1, 2, 3, 4]));
-  }));
+  channel.port1.on(
+    'message',
+    common.mustCall(({ typedArray }) => {
+      assert.deepStrictEqual(typedArray, new Uint8Array([0, 1, 2, 3, 4]));
+    })
+  );
 
   const typedArray = new Uint8Array([0, 1, 2, 3, 4]);
-  channel.port2.postMessage({ typedArray }, [ typedArray.buffer ]);
+  channel.port2.postMessage({ typedArray }, [typedArray.buffer]);
   assert.strictEqual(typedArray.buffer.byteLength, 0);
   channel.port2.close();
 }
@@ -28,19 +31,25 @@ const { MessageChannel, MessagePort, Worker } = require('worker_threads');
 {
   const channel = new MessageChannel();
 
-  const w = new Worker(`
+  const w = new Worker(
+    `
     const { MessagePort } = require('worker_threads');
     const assert = require('assert');
     require('worker_threads').parentPort.on('message', ({ port }) => {
       assert(port instanceof MessagePort);
       port.postMessage('works');
     });
-  `, { eval: true });
-  w.postMessage({ port: channel.port2 }, [ channel.port2 ]);
+  `,
+    { eval: true }
+  );
+  w.postMessage({ port: channel.port2 }, [channel.port2]);
   assert(channel.port1 instanceof MessagePort);
   assert(channel.port2 instanceof MessagePort);
-  channel.port1.on('message', common.mustCall((message) => {
-    assert.strictEqual(message, 'works');
-    w.terminate();
-  }));
+  channel.port1.on(
+    'message',
+    common.mustCall((message) => {
+      assert.strictEqual(message, 'works');
+      w.terminate();
+    })
+  );
 }
diff --git a/test/parallel/test-worker-message-port-arraybuffer.js b/test/parallel/test-worker-message-port-arraybuffer.js
index 85b5d07c6362b4..fb50d9c75ef358 100644
--- a/test/parallel/test-worker-message-port-arraybuffer.js
+++ b/test/parallel/test-worker-message-port-arraybuffer.js
@@ -12,9 +12,12 @@ const { MessageChannel } = require('worker_threads');
   const typedArray = new Uint32Array(arrayBuffer);
   typedArray[0] = 0x12345678;
 
-  port1.postMessage(typedArray, [ arrayBuffer ]);
-  port2.on('message', common.mustCall((received) => {
-    assert.strictEqual(received[0], 0x12345678);
-    port2.close(common.mustCall());
-  }));
+  port1.postMessage(typedArray, [arrayBuffer]);
+  port2.on(
+    'message',
+    common.mustCall((received) => {
+      assert.strictEqual(received[0], 0x12345678);
+      port2.close(common.mustCall());
+    })
+  );
 }
diff --git a/test/parallel/test-worker-message-port-message-port-transferring.js b/test/parallel/test-worker-message-port-message-port-transferring.js
index 32d997b9dddab8..fd73ccce9309bb 100644
--- a/test/parallel/test-worker-message-port-message-port-transferring.js
+++ b/test/parallel/test-worker-message-port-message-port-transferring.js
@@ -8,16 +8,23 @@ const { MessageChannel } = require('worker_threads');
 {
   const { port1: basePort1, port2: basePort2 } = new MessageChannel();
   const {
-    port1: transferredPort1, port2: transferredPort2
+    port1: transferredPort1,
+    port2: transferredPort2
   } = new MessageChannel();
 
-  basePort1.postMessage({ transferredPort1 }, [ transferredPort1 ]);
-  basePort2.on('message', common.mustCall(({ transferredPort1 }) => {
-    transferredPort1.postMessage('foobar');
-    transferredPort2.on('message', common.mustCall((msg) => {
-      assert.strictEqual(msg, 'foobar');
-      transferredPort1.close(common.mustCall());
-      basePort1.close(common.mustCall());
-    }));
-  }));
+  basePort1.postMessage({ transferredPort1 }, [transferredPort1]);
+  basePort2.on(
+    'message',
+    common.mustCall(({ transferredPort1 }) => {
+      transferredPort1.postMessage('foobar');
+      transferredPort2.on(
+        'message',
+        common.mustCall((msg) => {
+          assert.strictEqual(msg, 'foobar');
+          transferredPort1.close(common.mustCall());
+          basePort1.close(common.mustCall());
+        })
+      );
+    })
+  );
 }
diff --git a/test/parallel/test-worker-message-port-transfer-closed.js b/test/parallel/test-worker-message-port-transfer-closed.js
index 32de1af1f97a81..1134849cd0d46e 100644
--- a/test/parallel/test-worker-message-port-transfer-closed.js
+++ b/test/parallel/test-worker-message-port-transfer-closed.js
@@ -15,21 +15,26 @@ port1.onmessage = common.mustNotCall();
 port2.onmessage = common.mustNotCall();
 
 function testSingle(closedPort, potentiallyOpenPort) {
-  assert.throws(common.mustCall(() => {
-    potentiallyOpenPort.postMessage(null, [arrayBuf, closedPort]);
-  }), common.mustCall((err) => {
-    assert.strictEqual(err.name, 'DataCloneError');
-    assert.strictEqual(err.message,
-                       'MessagePort in transfer list is already detached');
-    assert.strictEqual(err.code, 25);
-    assert.ok(err instanceof Error);
-
-    const DOMException = err.constructor;
-    assert.ok(err instanceof DOMException);
-    assert.strictEqual(DOMException.name, 'DOMException');
-
-    return true;
-  }));
+  assert.throws(
+    common.mustCall(() => {
+      potentiallyOpenPort.postMessage(null, [arrayBuf, closedPort]);
+    }),
+    common.mustCall((err) => {
+      assert.strictEqual(err.name, 'DataCloneError');
+      assert.strictEqual(
+        err.message,
+        'MessagePort in transfer list is already detached'
+      );
+      assert.strictEqual(err.code, 25);
+      assert.ok(err instanceof Error);
+
+      const DOMException = err.constructor;
+      assert.ok(err instanceof DOMException);
+      assert.strictEqual(DOMException.name, 'DOMException');
+
+      return true;
+    })
+  );
 
   // arrayBuf must not be transferred, even though it is present earlier in the
   // transfer list than the closedPort.
diff --git a/test/parallel/test-worker-message-port-transfer-self.js b/test/parallel/test-worker-message-port-transfer-self.js
index 6b8addf0229eac..f6a8ca9ce012f5 100644
--- a/test/parallel/test-worker-message-port-transfer-self.js
+++ b/test/parallel/test-worker-message-port-transfer-self.js
@@ -9,20 +9,23 @@ const tick = require('../common/tick');
 
 const { port1, port2 } = new MessageChannel();
 
-assert.throws(common.mustCall(() => {
-  port1.postMessage(null, [port1]);
-}), common.mustCall((err) => {
-  assert.strictEqual(err.name, 'DataCloneError');
-  assert.strictEqual(err.message, 'Transfer list contains source port');
-  assert.strictEqual(err.code, 25);
-  assert.ok(err instanceof Error);
-
-  const DOMException = err.constructor;
-  assert.ok(err instanceof DOMException);
-  assert.strictEqual(DOMException.name, 'DOMException');
-
-  return true;
-}));
+assert.throws(
+  common.mustCall(() => {
+    port1.postMessage(null, [port1]);
+  }),
+  common.mustCall((err) => {
+    assert.strictEqual(err.name, 'DataCloneError');
+    assert.strictEqual(err.message, 'Transfer list contains source port');
+    assert.strictEqual(err.code, 25);
+    assert.ok(err instanceof Error);
+
+    const DOMException = err.constructor;
+    assert.ok(err instanceof DOMException);
+    assert.strictEqual(DOMException.name, 'DOMException');
+
+    return true;
+  })
+);
 
 // The failed transfer should not affect the ports in anyway.
 port2.onmessage = common.mustCall((message) => {
diff --git a/test/parallel/test-worker-message-port-transfer-target.js b/test/parallel/test-worker-message-port-transfer-target.js
index 8e6354d8269771..073d61068ca127 100644
--- a/test/parallel/test-worker-message-port-transfer-target.js
+++ b/test/parallel/test-worker-message-port-transfer-target.js
@@ -9,10 +9,12 @@ const { port1, port2 } = new MessageChannel();
 
 const arrayBuf = new ArrayBuffer(10);
 
-common.expectWarning('Warning',
-                     'The target port was posted to itself, and the ' +
-                     'communication channel was lost',
-                     common.noWarnCode);
+common.expectWarning(
+  'Warning',
+  'The target port was posted to itself, and the ' +
+    'communication channel was lost',
+  common.noWarnCode
+);
 port2.onmessage = common.mustNotCall();
 port2.postMessage(null, [port1, arrayBuf]);
 
@@ -20,5 +22,7 @@ port2.postMessage(null, [port1, arrayBuf]);
 // message.
 assert.strictEqual(arrayBuf.byteLength, 0);
 
-setTimeout(common.mustNotCall('The communication channel is still open'),
-           common.platformTimeout(1000)).unref();
+setTimeout(
+  common.mustNotCall('The communication channel is still open'),
+  common.platformTimeout(1000)
+).unref();
diff --git a/test/parallel/test-worker-message-port.js b/test/parallel/test-worker-message-port.js
index 995868e9a770e0..770177d838d025 100644
--- a/test/parallel/test-worker-message-port.js
+++ b/test/parallel/test-worker-message-port.js
@@ -12,10 +12,13 @@ const { MessageChannel, MessagePort } = require('worker_threads');
 
   const input = { a: 1 };
   port1.postMessage(input);
-  port2.on('message', common.mustCall((received) => {
-    assert.deepStrictEqual(received, input);
-    port2.close(common.mustCall());
-  }));
+  port2.on(
+    'message',
+    common.mustCall((received) => {
+      assert.deepStrictEqual(received, input);
+      port2.close(common.mustCall());
+    })
+  );
 }
 
 {
@@ -41,10 +44,13 @@ const { MessageChannel, MessagePort } = require('worker_threads');
   // Check that the message still gets delivered if `port2` has its
   // `on('message')` handler attached at a later point in time.
   setImmediate(() => {
-    port2.on('message', common.mustCall((received) => {
-      assert.deepStrictEqual(received, input);
-      port2.close(common.mustCall());
-    }));
+    port2.on(
+      'message',
+      common.mustCall((received) => {
+        assert.deepStrictEqual(received, input);
+        port2.close(common.mustCall());
+      })
+    );
   });
 }
 
@@ -62,10 +68,13 @@ const { MessageChannel, MessagePort } = require('worker_threads');
     port2.removeListener('message', dummy);
     port1.postMessage(input);
     setImmediate(() => {
-      port2.on('message', common.mustCall((received) => {
-        assert.deepStrictEqual(received, input);
-        port2.close(common.mustCall());
-      }));
+      port2.on(
+        'message',
+        common.mustCall((received) => {
+          assert.deepStrictEqual(received, input);
+          port2.close(common.mustCall());
+        })
+      );
     });
   });
 }
@@ -74,7 +83,13 @@ const { MessageChannel, MessagePort } = require('worker_threads');
   assert.deepStrictEqual(
     Object.getOwnPropertyNames(MessagePort.prototype).sort(),
     [
-      'close', 'constructor', 'onmessage', 'postMessage', 'ref', 'start',
+      'close',
+      'constructor',
+      'onmessage',
+      'postMessage',
+      'ref',
+      'start',
       'unref'
-    ]);
+    ]
+  );
 }
diff --git a/test/parallel/test-worker-nexttick-terminate.js b/test/parallel/test-worker-nexttick-terminate.js
index 804285710b4bf4..abb0597d197bba 100644
--- a/test/parallel/test-worker-nexttick-terminate.js
+++ b/test/parallel/test-worker-nexttick-terminate.js
@@ -6,15 +6,21 @@ const { Worker } = require('worker_threads');
 // Checks that terminating in the middle of `process.nextTick()` does not
 // Crash the process.
 
-const w = new Worker(`
+const w = new Worker(
+  `
 require('worker_threads').parentPort.postMessage('0');
 process.nextTick(() => {
   while(1);
 });
-`, { eval: true });
+`,
+  { eval: true }
+);
 
-w.on('message', common.mustCall(() => {
-  setTimeout(() => {
-    w.terminate(common.mustCall());
-  }, 1);
-}));
+w.on(
+  'message',
+  common.mustCall(() => {
+    setTimeout(() => {
+      w.terminate(common.mustCall());
+    }, 1);
+  })
+);
diff --git a/test/parallel/test-worker-onmessage.js b/test/parallel/test-worker-onmessage.js
index 2ae3d90f852ba9..c054e85acf3509 100644
--- a/test/parallel/test-worker-onmessage.js
+++ b/test/parallel/test-worker-onmessage.js
@@ -8,10 +8,13 @@ const { Worker, parentPort } = require('worker_threads');
 if (!process.env.HAS_STARTED_WORKER) {
   process.env.HAS_STARTED_WORKER = 1;
   const w = new Worker(__filename);
-  w.on('message', common.mustCall((message) => {
-    assert.strictEqual(message, 4);
-    w.terminate();
-  }));
+  w.on(
+    'message',
+    common.mustCall((message) => {
+      assert.strictEqual(message, 4);
+      w.terminate();
+    })
+  );
   w.postMessage(2);
 } else {
   parentPort.onmessage = common.mustCall((message) => {
diff --git a/test/parallel/test-worker-parent-port-ref.js b/test/parallel/test-worker-parent-port-ref.js
index 48963f320f4450..3e7d35a62efe5f 100644
--- a/test/parallel/test-worker-parent-port-ref.js
+++ b/test/parallel/test-worker-parent-port-ref.js
@@ -11,9 +11,13 @@ const { isMainThread, parentPort, Worker } = require('worker_threads');
   if (isMainThread) {
     const worker = new Worker(__filename);
 
-    worker.on('exit', common.mustCall((code) => {
-      assert.strictEqual(code, 0);
-    }), 1);
+    worker.on(
+      'exit',
+      common.mustCall((code) => {
+        assert.strictEqual(code, 0);
+      }),
+      1
+    );
 
     worker.on('online', common.mustCall());
   } else {
diff --git a/test/parallel/test-worker-relative-path-double-dot.js b/test/parallel/test-worker-relative-path-double-dot.js
index ecd294a4d3cba4..5165a9ee904b6f 100644
--- a/test/parallel/test-worker-relative-path-double-dot.js
+++ b/test/parallel/test-worker-relative-path-double-dot.js
@@ -9,9 +9,12 @@ if (isMainThread) {
   const cwdName = path.relative('../', '.');
   const relativePath = path.relative('.', __filename);
   const w = new Worker(path.join('..', cwdName, relativePath));
-  w.on('message', common.mustCall((message) => {
-    assert.strictEqual(message, 'Hello, world!');
-  }));
+  w.on(
+    'message',
+    common.mustCall((message) => {
+      assert.strictEqual(message, 'Hello, world!');
+    })
+  );
 } else {
   parentPort.postMessage('Hello, world!');
 }
diff --git a/test/parallel/test-worker-relative-path.js b/test/parallel/test-worker-relative-path.js
index 30d2a5dde3e779..a9089d4d4b0905 100644
--- a/test/parallel/test-worker-relative-path.js
+++ b/test/parallel/test-worker-relative-path.js
@@ -7,9 +7,12 @@ const { Worker, isMainThread, parentPort } = require('worker_threads');
 
 if (isMainThread) {
   const w = new Worker('./' + path.relative('.', __filename));
-  w.on('message', common.mustCall((message) => {
-    assert.strictEqual(message, 'Hello, world!');
-  }));
+  w.on(
+    'message',
+    common.mustCall((message) => {
+      assert.strictEqual(message, 'Hello, world!');
+    })
+  );
 } else {
   parentPort.postMessage('Hello, world!');
 }
diff --git a/test/parallel/test-worker-stdio.js b/test/parallel/test-worker-stdio.js
index 366f9e694dd2fa..baaeada07759b1 100644
--- a/test/parallel/test-worker-stdio.js
+++ b/test/parallel/test-worker-stdio.js
@@ -33,11 +33,17 @@ if (isMainThread) {
   source.pipe(original);
   w.stdout.pipe(passed);
 
-  passed.on('finish', common.mustCall(() => {
-    assert.strictEqual(original.buffer.compare(passed.buffer), 0,
-                       `Original: ${util.inspect(original.buffer)}, ` +
-                       `Actual: ${util.inspect(passed.buffer)}`);
-  }));
+  passed.on(
+    'finish',
+    common.mustCall(() => {
+      assert.strictEqual(
+        original.buffer.compare(passed.buffer),
+        0,
+        `Original: ${util.inspect(original.buffer)}, ` +
+          `Actual: ${util.inspect(passed.buffer)}`
+      );
+    })
+  );
 } else {
   process.stdin.pipe(process.stdout);
 }
diff --git a/test/parallel/test-worker-syntax-error-file.js b/test/parallel/test-worker-syntax-error-file.js
index b1f8fd5f681343..db9afe96dd59e3 100644
--- a/test/parallel/test-worker-syntax-error-file.js
+++ b/test/parallel/test-worker-syntax-error-file.js
@@ -10,9 +10,12 @@ if (!process.env.HAS_STARTED_WORKER) {
   process.env.HAS_STARTED_WORKER = 1;
   const w = new Worker(fixtures.path('syntax', 'bad_syntax.js'));
   w.on('message', common.mustNotCall());
-  w.on('error', common.mustCall((err) => {
-    assert(/SyntaxError/.test(err));
-  }));
+  w.on(
+    'error',
+    common.mustCall((err) => {
+      assert(/SyntaxError/.test(err));
+    })
+  );
 } else {
   throw new Error('foo');
 }
diff --git a/test/parallel/test-worker-syntax-error.js b/test/parallel/test-worker-syntax-error.js
index d54888053900da..1e9a66e9586214 100644
--- a/test/parallel/test-worker-syntax-error.js
+++ b/test/parallel/test-worker-syntax-error.js
@@ -9,9 +9,12 @@ if (!process.env.HAS_STARTED_WORKER) {
   process.env.HAS_STARTED_WORKER = 1;
   const w = new Worker('abc)', { eval: true });
   w.on('message', common.mustNotCall());
-  w.on('error', common.mustCall((err) => {
-    assert(/SyntaxError/.test(err));
-  }));
+  w.on(
+    'error',
+    common.mustCall((err) => {
+      assert(/SyntaxError/.test(err));
+    })
+  );
 } else {
   throw new Error('foo');
 }
diff --git a/test/parallel/test-worker-type-check.js b/test/parallel/test-worker-type-check.js
index 43013bc538712a..c0b8b895a4a562 100644
--- a/test/parallel/test-worker-type-check.js
+++ b/test/parallel/test-worker-type-check.js
@@ -5,24 +5,15 @@ const common = require('../common');
 const { Worker } = require('worker_threads');
 
 {
-  [
-    undefined,
-    null,
-    false,
-    0,
-    Symbol('test'),
-    {},
-    [],
-    () => {}
-  ].forEach((val) => {
-    common.expectsError(
-      () => new Worker(val),
-      {
+  [undefined, null, false, 0, Symbol('test'), {}, [], () => {}].forEach(
+    (val) => {
+      common.expectsError(() => new Worker(val), {
         code: 'ERR_INVALID_ARG_TYPE',
         type: TypeError,
-        message: 'The "filename" argument must be of type string. ' +
-                 `Received type ${typeof val}`
-      }
-    );
-  });
+        message:
+          'The "filename" argument must be of type string. ' +
+          `Received type ${typeof val}`
+      });
+    }
+  );
 }
diff --git a/test/parallel/test-worker-uncaught-exception-async.js b/test/parallel/test-worker-uncaught-exception-async.js
index 862b1a66d619c3..5e58798c9d3a58 100644
--- a/test/parallel/test-worker-uncaught-exception-async.js
+++ b/test/parallel/test-worker-uncaught-exception-async.js
@@ -9,14 +9,20 @@ if (!process.env.HAS_STARTED_WORKER) {
   process.env.HAS_STARTED_WORKER = 1;
   const w = new Worker(__filename);
   w.on('message', common.mustNotCall());
-  w.on('error', common.mustCall((err) => {
-    console.log(err.message);
-    assert(/^Error: foo$/.test(err));
-  }));
-  w.on('exit', common.mustCall((code) => {
-    // uncaughtException is code 1
-    assert.strictEqual(code, 1);
-  }));
+  w.on(
+    'error',
+    common.mustCall((err) => {
+      console.log(err.message);
+      assert(/^Error: foo$/.test(err));
+    })
+  );
+  w.on(
+    'exit',
+    common.mustCall((code) => {
+      // uncaughtException is code 1
+      assert.strictEqual(code, 1);
+    })
+  );
 } else {
   // cannot use common.mustCall as it cannot catch this
   let called = false;
@@ -28,8 +34,10 @@ if (!process.env.HAS_STARTED_WORKER) {
     }
   });
 
-  setTimeout(() => assert.fail('Timeout executed after uncaughtException'),
-             2000);
+  setTimeout(
+    () => assert.fail('Timeout executed after uncaughtException'),
+    2000
+  );
 
   setImmediate(() => {
     throw new Error('foo');
diff --git a/test/parallel/test-worker-uncaught-exception.js b/test/parallel/test-worker-uncaught-exception.js
index 95c142b6c70d64..2e89e32f44b276 100644
--- a/test/parallel/test-worker-uncaught-exception.js
+++ b/test/parallel/test-worker-uncaught-exception.js
@@ -9,14 +9,20 @@ if (!process.env.HAS_STARTED_WORKER) {
   process.env.HAS_STARTED_WORKER = 1;
   const w = new Worker(__filename);
   w.on('message', common.mustNotCall());
-  w.on('error', common.mustCall((err) => {
-    console.log(err.message);
-    assert(/^Error: foo$/.test(err));
-  }));
-  w.on('exit', common.mustCall((code) => {
-    // uncaughtException is code 1
-    assert.strictEqual(code, 1);
-  }));
+  w.on(
+    'error',
+    common.mustCall((err) => {
+      console.log(err.message);
+      assert(/^Error: foo$/.test(err));
+    })
+  );
+  w.on(
+    'exit',
+    common.mustCall((code) => {
+      // uncaughtException is code 1
+      assert.strictEqual(code, 1);
+    })
+  );
 } else {
   // cannot use common.mustCall as it cannot catch this
   let called = false;
@@ -28,8 +34,10 @@ if (!process.env.HAS_STARTED_WORKER) {
     }
   });
 
-  setTimeout(() => assert.fail('Timeout executed after uncaughtException'),
-             2000);
+  setTimeout(
+    () => assert.fail('Timeout executed after uncaughtException'),
+    2000
+  );
 
   throw new Error('foo');
 }
diff --git a/test/parallel/test-worker-unsupported-path.js b/test/parallel/test-worker-unsupported-path.js
index 71999eb5fe44ec..ff37a70b42d538 100644
--- a/test/parallel/test-worker-unsupported-path.js
+++ b/test/parallel/test-worker-unsupported-path.js
@@ -7,23 +7,43 @@ const assert = require('assert');
 const { Worker } = require('worker_threads');
 
 {
-  const expectedErr = common.expectsError({
-    code: 'ERR_WORKER_UNSUPPORTED_EXTENSION',
-    type: TypeError
-  }, 3);
-  assert.throws(() => { new Worker('/b'); }, expectedErr);
-  assert.throws(() => { new Worker('/c.wasm'); }, expectedErr);
-  assert.throws(() => { new Worker('/d.txt'); }, expectedErr);
+  const expectedErr = common.expectsError(
+    {
+      code: 'ERR_WORKER_UNSUPPORTED_EXTENSION',
+      type: TypeError
+    },
+    3
+  );
+  assert.throws(() => {
+    new Worker('/b');
+  }, expectedErr);
+  assert.throws(() => {
+    new Worker('/c.wasm');
+  }, expectedErr);
+  assert.throws(() => {
+    new Worker('/d.txt');
+  }, expectedErr);
 }
 
 {
-  const expectedErr = common.expectsError({
-    code: 'ERR_WORKER_PATH',
-    type: TypeError
-  }, 4);
+  const expectedErr = common.expectsError(
+    {
+      code: 'ERR_WORKER_PATH',
+      type: TypeError
+    },
+    4
+  );
   const existingRelPathNoDot = path.relative('.', __filename);
-  assert.throws(() => { new Worker(existingRelPathNoDot); }, expectedErr);
-  assert.throws(() => { new Worker('relative_no_dot'); }, expectedErr);
-  assert.throws(() => { new Worker('file:///file_url'); }, expectedErr);
-  assert.throws(() => { new Worker('https://www.url.com'); }, expectedErr);
+  assert.throws(() => {
+    new Worker(existingRelPathNoDot);
+  }, expectedErr);
+  assert.throws(() => {
+    new Worker('relative_no_dot');
+  }, expectedErr);
+  assert.throws(() => {
+    new Worker('file:///file_url');
+  }, expectedErr);
+  assert.throws(() => {
+    new Worker('https://www.url.com');
+  }, expectedErr);
 }
diff --git a/test/parallel/test-worker-unsupported-things.js b/test/parallel/test-worker-unsupported-things.js
index 7946e9cf1c138b..25703d7f57e13d 100644
--- a/test/parallel/test-worker-unsupported-things.js
+++ b/test/parallel/test-worker-unsupported-things.js
@@ -6,9 +6,12 @@ const { Worker, isMainThread, parentPort } = require('worker_threads');
 
 if (isMainThread) {
   const w = new Worker(__filename);
-  w.on('message', common.mustCall((message) => {
-    assert.strictEqual(message, true);
-  }));
+  w.on(
+    'message',
+    common.mustCall((message) => {
+      assert.strictEqual(message, true);
+    })
+  );
 } else {
   {
     const before = process.title;
diff --git a/test/parallel/test-worker-workerdata-sharedarraybuffer.js b/test/parallel/test-worker-workerdata-sharedarraybuffer.js
index 09de361236cf67..b2e2daf983887a 100644
--- a/test/parallel/test-worker-workerdata-sharedarraybuffer.js
+++ b/test/parallel/test-worker-workerdata-sharedarraybuffer.js
@@ -9,7 +9,8 @@ const { Worker } = require('worker_threads');
   const sharedArrayBuffer = new SharedArrayBuffer(12);
   const local = Buffer.from(sharedArrayBuffer);
 
-  const w = new Worker(`
+  const w = new Worker(
+    `
     const { parentPort, workerData } = require('worker_threads');
     const local = Buffer.from(workerData.sharedArrayBuffer);
 
@@ -17,15 +18,20 @@ const { Worker } = require('worker_threads');
       local.write('world!', 6);
       parentPort.postMessage('written!');
     });
-  `, {
-    eval: true,
-    workerData: { sharedArrayBuffer }
-  });
-  w.on('message', common.mustCall(() => {
-    assert.strictEqual(local.toString(), 'Hello world!');
-    global.gc();
-    w.terminate();
-  }));
+  `,
+    {
+      eval: true,
+      workerData: { sharedArrayBuffer }
+    }
+  );
+  w.on(
+    'message',
+    common.mustCall(() => {
+      assert.strictEqual(local.toString(), 'Hello world!');
+      global.gc();
+      w.terminate();
+    })
+  );
   w.postMessage({});
   // This would be a race condition if the memory regions were overlapping
   local.write('Hello ');
diff --git a/test/parallel/test-worker.js b/test/parallel/test-worker.js
index 6cd64fce9b4eb8..9e63e1b023af99 100644
--- a/test/parallel/test-worker.js
+++ b/test/parallel/test-worker.js
@@ -6,9 +6,12 @@ const { Worker, isMainThread, parentPort } = require('worker_threads');
 
 if (isMainThread) {
   const w = new Worker(__filename);
-  w.on('message', common.mustCall((message) => {
-    assert.strictEqual(message, 'Hello, world!');
-  }));
+  w.on(
+    'message',
+    common.mustCall((message) => {
+      assert.strictEqual(message, 'Hello, world!');
+    })
+  );
 } else {
   setImmediate(() => {
     process.nextTick(() => {
diff --git a/test/parallel/test-wrap-js-stream-destroy.js b/test/parallel/test-wrap-js-stream-destroy.js
index 16d3e75e2ca7e3..6c93179e368618 100644
--- a/test/parallel/test-wrap-js-stream-destroy.js
+++ b/test/parallel/test-wrap-js-stream-destroy.js
@@ -24,24 +24,30 @@ const net = require('net');
 
   function createSocket() {
     let streamWrap;
-    const socket = new net.connect({
-      port,
-    }, () => {
-      socket.on('error', common.mustNotCall());
-      socket.on('end', common.mustCall());
-      socket.on('close', common.mustCall());
+    const socket = new net.connect(
+      {
+        port
+      },
+      () => {
+        socket.on('error', common.mustNotCall());
+        socket.on('end', common.mustCall());
+        socket.on('close', common.mustCall());
 
-      streamWrap.on('error', common.mustNotCall());
-      // The "end" events will be emitted which is as same as
-      // the same situation for an instance of `net.Socket` without
-      // `StreamWrap`.
-      streamWrap.on('end', common.mustCall());
-      // Destroying a socket in the server side should emit EOF and cause
-      // the corresponding client-side socket closed.
-      streamWrap.on('close', common.mustCall(() => {
-        server.close();
-      }));
-    });
+        streamWrap.on('error', common.mustNotCall());
+        // The "end" events will be emitted which is as same as
+        // the same situation for an instance of `net.Socket` without
+        // `StreamWrap`.
+        streamWrap.on('end', common.mustCall());
+        // Destroying a socket in the server side should emit EOF and cause
+        // the corresponding client-side socket closed.
+        streamWrap.on(
+          'close',
+          common.mustCall(() => {
+            server.close();
+          })
+        );
+      }
+    );
     streamWrap = new StreamWrap(socket);
   }
 }
@@ -52,9 +58,12 @@ const net = require('net');
   const server = net.createServer((socket) => {
     socket.on('error', common.mustNotCall());
     socket.on('end', common.mustCall());
-    socket.on('close', common.mustCall(() => {
-      server.close();
-    }));
+    socket.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+      })
+    );
     // Do not `socket.end()` and directly `socket.destroy()`.
   });
 
@@ -65,20 +74,23 @@ const net = require('net');
 
   function createSocket() {
     let streamWrap;
-    const socket = new net.connect({
-      port,
-    }, () => {
-      socket.on('error', common.mustNotCall());
-      socket.on('end', common.mustNotCall());
-      socket.on('close', common.mustCall());
+    const socket = new net.connect(
+      {
+        port
+      },
+      () => {
+        socket.on('error', common.mustNotCall());
+        socket.on('end', common.mustNotCall());
+        socket.on('close', common.mustCall());
 
-      streamWrap.on('error', common.mustNotCall());
-      streamWrap.on('end', common.mustNotCall());
-      // Destroying a socket in the server side should emit EOF and cause
-      // the corresponding client-side socket closed.
-      streamWrap.on('close', common.mustCall());
-      streamWrap.destroy();
-    });
+        streamWrap.on('error', common.mustNotCall());
+        streamWrap.on('end', common.mustNotCall());
+        // Destroying a socket in the server side should emit EOF and cause
+        // the corresponding client-side socket closed.
+        streamWrap.on('close', common.mustCall());
+        streamWrap.destroy();
+      }
+    );
     streamWrap = new StreamWrap(socket);
   }
 }
@@ -89,9 +101,12 @@ const net = require('net');
   const server = net.createServer((socket) => {
     socket.on('error', common.mustNotCall());
     socket.on('end', common.mustCall());
-    socket.on('close', common.mustCall(() => {
-      server.close();
-    }));
+    socket.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+      })
+    );
   });
 
   server.listen(() => {
@@ -101,18 +116,21 @@ const net = require('net');
 
   function createSocket() {
     let streamWrap;
-    const socket = new net.connect({
-      port,
-    }, () => {
-      socket.on('error', common.mustNotCall());
-      socket.on('end', common.mustNotCall());
-      socket.on('close', common.mustCall());
+    const socket = new net.connect(
+      {
+        port
+      },
+      () => {
+        socket.on('error', common.mustNotCall());
+        socket.on('end', common.mustNotCall());
+        socket.on('close', common.mustCall());
 
-      streamWrap.on('error', common.mustNotCall());
-      streamWrap.on('end', common.mustNotCall());
-      streamWrap.on('close', common.mustCall());
-      socket.destroy();
-    });
+        streamWrap.on('error', common.mustNotCall());
+        streamWrap.on('end', common.mustNotCall());
+        streamWrap.on('close', common.mustCall());
+        socket.destroy();
+      }
+    );
     streamWrap = new StreamWrap(socket);
   }
 }
diff --git a/test/parallel/test-wrap-js-stream-exceptions.js b/test/parallel/test-wrap-js-stream-exceptions.js
index 57ecd70189d106..41408420f31c90 100644
--- a/test/parallel/test-wrap-js-stream-exceptions.js
+++ b/test/parallel/test-wrap-js-stream-exceptions.js
@@ -5,15 +5,20 @@ const assert = require('assert');
 const JSStreamWrap = require('internal/wrap_js_stream');
 const { Duplex } = require('stream');
 
-process.once('uncaughtException', common.mustCall((err) => {
-  assert.strictEqual(err.message, 'exception!');
-}));
+process.once(
+  'uncaughtException',
+  common.mustCall((err) => {
+    assert.strictEqual(err.message, 'exception!');
+  })
+);
 
-const socket = new JSStreamWrap(new Duplex({
-  read: common.mustCall(),
-  write: common.mustCall((buffer, data, cb) => {
-    throw new Error('exception!');
+const socket = new JSStreamWrap(
+  new Duplex({
+    read: common.mustCall(),
+    write: common.mustCall((buffer, data, cb) => {
+      throw new Error('exception!');
+    })
   })
-}));
+);
 
 assert.throws(() => socket.end('foo'), /Error: write EPROTO/);
diff --git a/test/parallel/test-zlib-bytes-read.js b/test/parallel/test-zlib-bytes-read.js
index e8983efc454f1e..1f6d4fe101716b 100644
--- a/test/parallel/test-zlib-bytes-read.js
+++ b/test/parallel/test-zlib-bytes-read.js
@@ -24,8 +24,9 @@ function createWriter(target, buffer) {
 common.expectWarning(
   'DeprecationWarning',
   'zlib.bytesRead is deprecated and will change its meaning in the ' +
-  'future. Use zlib.bytesWritten instead.',
-  'DEP0108');
+    'future. Use zlib.bytesWritten instead.',
+  'DEP0108'
+);
 
 for (const method of [
   ['createGzip', 'createGunzip', false],
@@ -39,63 +40,97 @@ for (const method of [
   const comp = zlib[method[0]]();
   comp.on('data', function(d) {
     compData = Buffer.concat([compData, d]);
-    assert.strictEqual(this.bytesWritten, compWriter.size,
-                       `Should get write size on ${method[0]} data.`);
+    assert.strictEqual(
+      this.bytesWritten,
+      compWriter.size,
+      `Should get write size on ${method[0]} data.`
+    );
   });
-  comp.on('end', common.mustCall(function() {
-    assert.strictEqual(this.bytesWritten, compWriter.size,
-                       `Should get write size on ${method[0]} end.`);
-    assert.strictEqual(this.bytesWritten, expectStr.length,
-                       `Should get data size on ${method[0]} end.`);
+  comp.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(
+        this.bytesWritten,
+        compWriter.size,
+        `Should get write size on ${method[0]} end.`
+      );
+      assert.strictEqual(
+        this.bytesWritten,
+        expectStr.length,
+        `Should get data size on ${method[0]} end.`
+      );
 
-    {
-      let decompWriter;
-      let decompData = Buffer.alloc(0);
+      {
+        let decompWriter;
+        let decompData = Buffer.alloc(0);
 
-      const decomp = zlib[method[1]]();
-      decomp.on('data', function(d) {
-        decompData = Buffer.concat([decompData, d]);
-        assert.strictEqual(this.bytesWritten, decompWriter.size,
-                           `Should get write size on ${method[0]}/` +
-                           `${method[1]} data.`);
-      });
-      decomp.on('end', common.mustCall(function() {
-        assert.strictEqual(this.bytesWritten, compData.length,
-                           `Should get compressed size on ${method[0]}/` +
-                           `${method[1]} end.`);
-        assert.strictEqual(decompData.toString(), expectStr,
-                           `Should get original string on ${method[0]}/` +
-                           `${method[1]} end.`);
-      }));
-      decompWriter = createWriter(decomp, compData);
-    }
+        const decomp = zlib[method[1]]();
+        decomp.on('data', function(d) {
+          decompData = Buffer.concat([decompData, d]);
+          assert.strictEqual(
+            this.bytesWritten,
+            decompWriter.size,
+            `Should get write size on ${method[0]}/` + `${method[1]} data.`
+          );
+        });
+        decomp.on(
+          'end',
+          common.mustCall(function() {
+            assert.strictEqual(
+              this.bytesWritten,
+              compData.length,
+              `Should get compressed size on ${method[0]}/` +
+                `${method[1]} end.`
+            );
+            assert.strictEqual(
+              decompData.toString(),
+              expectStr,
+              `Should get original string on ${method[0]}/` +
+                `${method[1]} end.`
+            );
+          })
+        );
+        decompWriter = createWriter(decomp, compData);
+      }
 
-    // Some methods should allow extra data after the compressed data
-    if (method[2]) {
-      const compDataExtra = Buffer.concat([compData, Buffer.from('extra')]);
+      // Some methods should allow extra data after the compressed data
+      if (method[2]) {
+        const compDataExtra = Buffer.concat([compData, Buffer.from('extra')]);
 
-      let decompWriter;
-      let decompData = Buffer.alloc(0);
+        let decompWriter;
+        let decompData = Buffer.alloc(0);
 
-      const decomp = zlib[method[1]]();
-      decomp.on('data', function(d) {
-        decompData = Buffer.concat([decompData, d]);
-        assert.strictEqual(this.bytesWritten, decompWriter.size,
-                           `Should get write size on ${method[0]}/` +
-                           `${method[1]} data.`);
-      });
-      decomp.on('end', common.mustCall(function() {
-        assert.strictEqual(this.bytesWritten, compData.length,
-                           `Should get compressed size on ${method[0]}/` +
-                           `${method[1]} end.`);
-        // Checking legacy name.
-        assert.strictEqual(this.bytesWritten, this.bytesRead);
-        assert.strictEqual(decompData.toString(), expectStr,
-                           `Should get original string on ${method[0]}/` +
-                           `${method[1]} end.`);
-      }));
-      decompWriter = createWriter(decomp, compDataExtra);
-    }
-  }));
+        const decomp = zlib[method[1]]();
+        decomp.on('data', function(d) {
+          decompData = Buffer.concat([decompData, d]);
+          assert.strictEqual(
+            this.bytesWritten,
+            decompWriter.size,
+            `Should get write size on ${method[0]}/` + `${method[1]} data.`
+          );
+        });
+        decomp.on(
+          'end',
+          common.mustCall(function() {
+            assert.strictEqual(
+              this.bytesWritten,
+              compData.length,
+              `Should get compressed size on ${method[0]}/` +
+                `${method[1]} end.`
+            );
+            // Checking legacy name.
+            assert.strictEqual(this.bytesWritten, this.bytesRead);
+            assert.strictEqual(
+              decompData.toString(),
+              expectStr,
+              `Should get original string on ${method[0]}/` +
+                `${method[1]} end.`
+            );
+          })
+        );
+        decompWriter = createWriter(decomp, compDataExtra);
+      }
+    })
+  );
   compWriter = createWriter(comp, expectBuf);
 }
diff --git a/test/parallel/test-zlib-close-after-error.js b/test/parallel/test-zlib-close-after-error.js
index 63d418be09946d..f3b0eaf51e203f 100644
--- a/test/parallel/test-zlib-close-after-error.js
+++ b/test/parallel/test-zlib-close-after-error.js
@@ -7,10 +7,13 @@ const zlib = require('zlib');
 
 const decompress = zlib.createGunzip(15);
 
-decompress.on('error', common.mustCall((err) => {
-  assert.strictEqual(decompress._closed, true);
-  decompress.close();
-}));
+decompress.on(
+  'error',
+  common.mustCall((err) => {
+    assert.strictEqual(decompress._closed, true);
+    decompress.close();
+  })
+);
 
 assert.strictEqual(decompress._closed, false);
 decompress.write('something invalid');
diff --git a/test/parallel/test-zlib-close-after-write.js b/test/parallel/test-zlib-close-after-write.js
index d89102ed8c7fd9..3053c21580dd16 100644
--- a/test/parallel/test-zlib-close-after-write.js
+++ b/test/parallel/test-zlib-close-after-write.js
@@ -23,8 +23,11 @@
 const common = require('../common');
 const zlib = require('zlib');
 
-zlib.gzip('hello', common.mustCall(function(err, out) {
-  const unzip = zlib.createGunzip();
-  unzip.write(out);
-  unzip.close(common.mustCall());
-}));
+zlib.gzip(
+  'hello',
+  common.mustCall(function(err, out) {
+    const unzip = zlib.createGunzip();
+    unzip.write(out);
+    unzip.close(common.mustCall());
+  })
+);
diff --git a/test/parallel/test-zlib-const.js b/test/parallel/test-zlib-const.js
index d25a1ca6be033a..71fa56231ccbb0 100644
--- a/test/parallel/test-zlib-const.js
+++ b/test/parallel/test-zlib-const.js
@@ -4,35 +4,49 @@ const assert = require('assert');
 
 const zlib = require('zlib');
 
-assert.strictEqual(zlib.constants.Z_OK, 0,
-                   [
-                     'Expected Z_OK to be 0;',
-                     `got ${zlib.constants.Z_OK}`
-                   ].join(' '));
+assert.strictEqual(
+  zlib.constants.Z_OK,
+  0,
+  ['Expected Z_OK to be 0;', `got ${zlib.constants.Z_OK}`].join(' ')
+);
 zlib.constants.Z_OK = 1;
-assert.strictEqual(zlib.constants.Z_OK, 0,
-                   [
-                     'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.constants.Z_OK}`
-                   ].join(' '));
+assert.strictEqual(
+  zlib.constants.Z_OK,
+  0,
+  [
+    'Z_OK should be immutable.',
+    `Expected to get 0, got ${zlib.constants.Z_OK}`
+  ].join(' ')
+);
 
-assert.strictEqual(zlib.codes.Z_OK, 0,
-                   `Expected Z_OK to be 0; got ${zlib.codes.Z_OK}`);
+assert.strictEqual(
+  zlib.codes.Z_OK,
+  0,
+  `Expected Z_OK to be 0; got ${zlib.codes.Z_OK}`
+);
 zlib.codes.Z_OK = 1;
-assert.strictEqual(zlib.codes.Z_OK, 0,
-                   [
-                     'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.codes.Z_OK}`
-                   ].join(' '));
+assert.strictEqual(
+  zlib.codes.Z_OK,
+  0,
+  [
+    'Z_OK should be immutable.',
+    `Expected to get 0, got ${zlib.codes.Z_OK}`
+  ].join(' ')
+);
 zlib.codes = { Z_OK: 1 };
-assert.strictEqual(zlib.codes.Z_OK, 0,
-                   [
-                     'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.codes.Z_OK}`
-                   ].join(' '));
+assert.strictEqual(
+  zlib.codes.Z_OK,
+  0,
+  [
+    'Z_OK should be immutable.',
+    `Expected to get 0, got ${zlib.codes.Z_OK}`
+  ].join(' ')
+);
 
-assert.ok(Object.isFrozen(zlib.codes),
-          [
-            'Expected zlib.codes to be frozen, but Object.isFrozen',
-            `returned ${Object.isFrozen(zlib.codes)}`
-          ].join(' '));
+assert.ok(
+  Object.isFrozen(zlib.codes),
+  [
+    'Expected zlib.codes to be frozen, but Object.isFrozen',
+    `returned ${Object.isFrozen(zlib.codes)}`
+  ].join(' ')
+);
diff --git a/test/parallel/test-zlib-convenience-methods.js b/test/parallel/test-zlib-convenience-methods.js
index 1cc393914a947e..faa8430b624292 100644
--- a/test/parallel/test-zlib-convenience-methods.js
+++ b/test/parallel/test-zlib-convenience-methods.js
@@ -33,7 +33,7 @@ const expectBuf = Buffer.from(expectStr);
 
 const opts = {
   level: 9,
-  chunkSize: 1024,
+  chunkSize: 1024
 };
 
 const optsInfo = {
@@ -43,79 +43,127 @@ const optsInfo = {
 for (const [type, expect] of [
   ['string', expectStr],
   ['Buffer', expectBuf],
-  ...common.getBufferSources(expectBuf).map((obj) =>
-    [obj[Symbol.toStringTag], obj]
-  )
+  ...common
+    .getBufferSources(expectBuf)
+    .map((obj) => [obj[Symbol.toStringTag], obj])
 ]) {
   for (const method of [
     ['gzip', 'gunzip', 'Gzip', 'Gunzip'],
     ['gzip', 'unzip', 'Gzip', 'Unzip'],
     ['deflate', 'inflate', 'Deflate', 'Inflate'],
-    ['deflateRaw', 'inflateRaw', 'DeflateRaw', 'InflateRaw'],
+    ['deflateRaw', 'inflateRaw', 'DeflateRaw', 'InflateRaw']
   ]) {
-    zlib[method[0]](expect, opts, common.mustCall((err, result) => {
-      zlib[method[1]](result, opts, common.mustCall((err, result) => {
-        assert.strictEqual(result.toString(), expectStr,
-                           `Should get original string after ${method[0]}/` +
-                           `${method[1]} ${type} with options.`);
-      }));
-    }));
+    zlib[method[0]](
+      expect,
+      opts,
+      common.mustCall((err, result) => {
+        zlib[method[1]](
+          result,
+          opts,
+          common.mustCall((err, result) => {
+            assert.strictEqual(
+              result.toString(),
+              expectStr,
+              `Should get original string after ${method[0]}/` +
+                `${method[1]} ${type} with options.`
+            );
+          })
+        );
+      })
+    );
 
-    zlib[method[0]](expect, common.mustCall((err, result) => {
-      zlib[method[1]](result, common.mustCall((err, result) => {
-        assert.strictEqual(result.toString(), expectStr,
-                           `Should get original string after ${method[0]}/` +
-                           `${method[1]} ${type} without options.`);
-      }));
-    }));
+    zlib[method[0]](
+      expect,
+      common.mustCall((err, result) => {
+        zlib[method[1]](
+          result,
+          common.mustCall((err, result) => {
+            assert.strictEqual(
+              result.toString(),
+              expectStr,
+              `Should get original string after ${method[0]}/` +
+                `${method[1]} ${type} without options.`
+            );
+          })
+        );
+      })
+    );
 
-    zlib[method[0]](expect, optsInfo, common.mustCall((err, result) => {
-      assert.ok(result.engine instanceof zlib[method[2]],
-                `Should get engine ${method[2]} after ${method[0]} ` +
-                `${type} with info option.`);
+    zlib[method[0]](
+      expect,
+      optsInfo,
+      common.mustCall((err, result) => {
+        assert.ok(
+          result.engine instanceof zlib[method[2]],
+          `Should get engine ${method[2]} after ${method[0]} ` +
+            `${type} with info option.`
+        );
 
-      const compressed = result.buffer;
-      zlib[method[1]](compressed, optsInfo, common.mustCall((err, result) => {
-        assert.strictEqual(result.buffer.toString(), expectStr,
-                           `Should get original string after ${method[0]}/` +
-                           `${method[1]} ${type} with info option.`);
-        assert.ok(result.engine instanceof zlib[method[3]],
-                  `Should get engine ${method[3]} after ${method[0]} ` +
-                  `${type} with info option.`);
-      }));
-    }));
+        const compressed = result.buffer;
+        zlib[method[1]](
+          compressed,
+          optsInfo,
+          common.mustCall((err, result) => {
+            assert.strictEqual(
+              result.buffer.toString(),
+              expectStr,
+              `Should get original string after ${method[0]}/` +
+                `${method[1]} ${type} with info option.`
+            );
+            assert.ok(
+              result.engine instanceof zlib[method[3]],
+              `Should get engine ${method[3]} after ${method[0]} ` +
+                `${type} with info option.`
+            );
+          })
+        );
+      })
+    );
 
     {
       const compressed = zlib[`${method[0]}Sync`](expect, opts);
       const decompressed = zlib[`${method[1]}Sync`](compressed, opts);
-      assert.strictEqual(decompressed.toString(), expectStr,
-                         `Should get original string after ${method[0]}Sync/` +
-                         `${method[1]}Sync ${type} with options.`);
+      assert.strictEqual(
+        decompressed.toString(),
+        expectStr,
+        `Should get original string after ${method[0]}Sync/` +
+          `${method[1]}Sync ${type} with options.`
+      );
     }
 
-
     {
       const compressed = zlib[`${method[0]}Sync`](expect);
       const decompressed = zlib[`${method[1]}Sync`](compressed);
-      assert.strictEqual(decompressed.toString(), expectStr,
-                         `Should get original string after ${method[0]}Sync/` +
-                         `${method[1]}Sync ${type} without options.`);
+      assert.strictEqual(
+        decompressed.toString(),
+        expectStr,
+        `Should get original string after ${method[0]}Sync/` +
+          `${method[1]}Sync ${type} without options.`
+      );
     }
 
-
     {
       const compressed = zlib[`${method[0]}Sync`](expect, optsInfo);
-      assert.ok(compressed.engine instanceof zlib[method[2]],
-                `Should get engine ${method[2]} after ${method[0]} ` +
-                `${type} with info option.`);
-      const decompressed = zlib[`${method[1]}Sync`](compressed.buffer,
-                                                    optsInfo);
-      assert.strictEqual(decompressed.buffer.toString(), expectStr,
-                         `Should get original string after ${method[0]}Sync/` +
-                         `${method[1]}Sync ${type} without options.`);
-      assert.ok(decompressed.engine instanceof zlib[method[3]],
-                `Should get engine ${method[3]} after ${method[0]} ` +
-                `${type} with info option.`);
+      assert.ok(
+        compressed.engine instanceof zlib[method[2]],
+        `Should get engine ${method[2]} after ${method[0]} ` +
+          `${type} with info option.`
+      );
+      const decompressed = zlib[`${method[1]}Sync`](
+        compressed.buffer,
+        optsInfo
+      );
+      assert.strictEqual(
+        decompressed.buffer.toString(),
+        expectStr,
+        `Should get original string after ${method[0]}Sync/` +
+          `${method[1]}Sync ${type} without options.`
+      );
+      assert.ok(
+        decompressed.engine instanceof zlib[method[3]],
+        `Should get engine ${method[3]} after ${method[0]} ` +
+          `${type} with info option.`
+      );
     }
   }
 }
diff --git a/test/parallel/test-zlib-deflate-constructors.js b/test/parallel/test-zlib-deflate-constructors.js
index 5d5e9fb4a2edd1..b5fbde7537055b 100644
--- a/test/parallel/test-zlib-deflate-constructors.js
+++ b/test/parallel/test-zlib-deflate-constructors.js
@@ -13,202 +13,163 @@ assert.ok(zlib.DeflateRaw() instanceof zlib.DeflateRaw);
 assert.ok(new zlib.DeflateRaw() instanceof zlib.DeflateRaw);
 
 // Throws if `options.chunkSize` is invalid
-common.expectsError(
-  () => new zlib.Deflate({ chunkSize: 'test' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.chunkSize" property must be of type number. ' +
-             'Received type string'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ chunkSize: -Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.chunkSize" is out of range. It must ' +
-             'be a finite number. Received -Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ chunkSize: 0 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.chunkSize" is out of range. It must ' +
-             'be >= 64. Received 0'
-  }
-);
+common.expectsError(() => new zlib.Deflate({ chunkSize: 'test' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.chunkSize" property must be of type number. ' +
+    'Received type string'
+});
+
+common.expectsError(() => new zlib.Deflate({ chunkSize: -Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.chunkSize" is out of range. It must ' +
+    'be a finite number. Received -Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ chunkSize: 0 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.chunkSize" is out of range. It must ' +
+    'be >= 64. Received 0'
+});
 
 // Confirm that maximum chunk size cannot be exceeded because it is `Infinity`.
 assert.strictEqual(zlib.constants.Z_MAX_CHUNK, Infinity);
 
 // Throws if `options.windowBits` is invalid
-common.expectsError(
-  () => new zlib.Deflate({ windowBits: 'test' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.windowBits" property must be of type number. ' +
-             'Received type string'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ windowBits: -Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.windowBits" is out of range. It must ' +
-             'be a finite number. Received -Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ windowBits: Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.windowBits" is out of range. It must ' +
-             'be a finite number. Received Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ windowBits: 0 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.windowBits" is out of range. It must ' +
-             'be >= 8 and <= 15. Received 0'
-  }
-);
+common.expectsError(() => new zlib.Deflate({ windowBits: 'test' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.windowBits" property must be of type number. ' +
+    'Received type string'
+});
+
+common.expectsError(() => new zlib.Deflate({ windowBits: -Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.windowBits" is out of range. It must ' +
+    'be a finite number. Received -Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ windowBits: Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.windowBits" is out of range. It must ' +
+    'be a finite number. Received Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ windowBits: 0 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.windowBits" is out of range. It must ' +
+    'be >= 8 and <= 15. Received 0'
+});
 
 // Throws if `options.level` is invalid
-common.expectsError(
-  () => new zlib.Deflate({ level: 'test' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.level" property must be of type number. ' +
-             'Received type string'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ level: -Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.level" is out of range. It must ' +
-             'be a finite number. Received -Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ level: Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.level" is out of range. It must ' +
-             'be a finite number. Received Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ level: -2 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.level" is out of range. It must ' +
-             'be >= -1 and <= 9. Received -2'
-  }
-);
+common.expectsError(() => new zlib.Deflate({ level: 'test' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.level" property must be of type number. ' +
+    'Received type string'
+});
+
+common.expectsError(() => new zlib.Deflate({ level: -Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.level" is out of range. It must ' +
+    'be a finite number. Received -Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ level: Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.level" is out of range. It must ' +
+    'be a finite number. Received Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ level: -2 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.level" is out of range. It must ' +
+    'be >= -1 and <= 9. Received -2'
+});
 
 // Throws if `level` invalid in  `Deflate.prototype.params()`
-common.expectsError(
-  () => new zlib.Deflate().params('test'),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "level" argument must be of type number. ' +
-             'Received type string'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate().params(-Infinity),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "level" is out of range. It must ' +
-             'be a finite number. Received -Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate().params(Infinity),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "level" is out of range. It must ' +
-             'be a finite number. Received Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate().params(-2),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "level" is out of range. It must ' +
-             'be >= -1 and <= 9. Received -2'
-  }
-);
+common.expectsError(() => new zlib.Deflate().params('test'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "level" argument must be of type number. ' + 'Received type string'
+});
+
+common.expectsError(() => new zlib.Deflate().params(-Infinity), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "level" is out of range. It must ' +
+    'be a finite number. Received -Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate().params(Infinity), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "level" is out of range. It must ' +
+    'be a finite number. Received Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate().params(-2), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "level" is out of range. It must ' +
+    'be >= -1 and <= 9. Received -2'
+});
 
 // Throws if options.memLevel is invalid
-common.expectsError(
-  () => new zlib.Deflate({ memLevel: 'test' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.memLevel" property must be of type number. ' +
-             'Received type string'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ memLevel: -Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.memLevel" is out of range. It must ' +
-             'be a finite number. Received -Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ memLevel: Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.memLevel" is out of range. It must ' +
-             'be a finite number. Received Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ memLevel: -2 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.memLevel" is out of range. It must ' +
-             'be >= 1 and <= 9. Received -2'
-  }
-);
+common.expectsError(() => new zlib.Deflate({ memLevel: 'test' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.memLevel" property must be of type number. ' +
+    'Received type string'
+});
+
+common.expectsError(() => new zlib.Deflate({ memLevel: -Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.memLevel" is out of range. It must ' +
+    'be a finite number. Received -Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ memLevel: Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.memLevel" is out of range. It must ' +
+    'be a finite number. Received Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ memLevel: -2 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.memLevel" is out of range. It must ' +
+    'be >= 1 and <= 9. Received -2'
+});
 
 // Does not throw if opts.strategy is valid
 new zlib.Deflate({ strategy: zlib.constants.Z_FILTERED });
@@ -218,94 +179,75 @@ new zlib.Deflate({ strategy: zlib.constants.Z_FIXED });
 new zlib.Deflate({ strategy: zlib.constants.Z_DEFAULT_STRATEGY });
 
 // Throws if options.strategy is invalid
-common.expectsError(
-  () => new zlib.Deflate({ strategy: 'test' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.strategy" property must be of type number. ' +
-             'Received type string'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ strategy: -Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.strategy" is out of range. It must ' +
-             'be a finite number. Received -Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ strategy: Infinity }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.strategy" is out of range. It must ' +
-             'be a finite number. Received Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate({ strategy: -2 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.strategy" is out of range. It must ' +
-             'be >= 0 and <= 4. Received -2'
-  }
-);
+common.expectsError(() => new zlib.Deflate({ strategy: 'test' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.strategy" property must be of type number. ' +
+    'Received type string'
+});
+
+common.expectsError(() => new zlib.Deflate({ strategy: -Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.strategy" is out of range. It must ' +
+    'be a finite number. Received -Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ strategy: Infinity }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.strategy" is out of range. It must ' +
+    'be a finite number. Received Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate({ strategy: -2 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.strategy" is out of range. It must ' +
+    'be >= 0 and <= 4. Received -2'
+});
 
 // Throws TypeError if `strategy` is invalid in `Deflate.prototype.params()`
-common.expectsError(
-  () => new zlib.Deflate().params(0, 'test'),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "strategy" argument must be of type number. ' +
-             'Received type string'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate().params(0, -Infinity),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "strategy" is out of range. It must ' +
-             'be a finite number. Received -Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate().params(0, Infinity),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "strategy" is out of range. It must ' +
-             'be a finite number. Received Infinity'
-  }
-);
-
-common.expectsError(
-  () => new zlib.Deflate().params(0, -2),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "strategy" is out of range. It must ' +
-             'be >= 0 and <= 4. Received -2'
-  }
-);
+common.expectsError(() => new zlib.Deflate().params(0, 'test'), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "strategy" argument must be of type number. ' + 'Received type string'
+});
+
+common.expectsError(() => new zlib.Deflate().params(0, -Infinity), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "strategy" is out of range. It must ' +
+    'be a finite number. Received -Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate().params(0, Infinity), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "strategy" is out of range. It must ' +
+    'be a finite number. Received Infinity'
+});
+
+common.expectsError(() => new zlib.Deflate().params(0, -2), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "strategy" is out of range. It must ' +
+    'be >= 0 and <= 4. Received -2'
+});
 
 // Throws if opts.dictionary is not a Buffer
-common.expectsError(
-  () => new zlib.Deflate({ dictionary: 'not a buffer' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.dictionary" property must be one of type Buffer, ' +
-             'TypedArray, DataView, or ArrayBuffer. Received type string'
-  }
-);
+common.expectsError(() => new zlib.Deflate({ dictionary: 'not a buffer' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.dictionary" property must be one of type Buffer, ' +
+    'TypedArray, DataView, or ArrayBuffer. Received type string'
+});
diff --git a/test/parallel/test-zlib-dictionary-fail.js b/test/parallel/test-zlib-dictionary-fail.js
index ccec8d9d2c7245..70e04e43e70b5e 100644
--- a/test/parallel/test-zlib-dictionary-fail.js
+++ b/test/parallel/test-zlib-dictionary-fail.js
@@ -25,14 +25,17 @@ const assert = require('assert');
 const zlib = require('zlib');
 
 // String "test" encoded with dictionary "dict".
-const input = Buffer.from([0x78, 0xBB, 0x04, 0x09, 0x01, 0xA5]);
+const input = Buffer.from([0x78, 0xbb, 0x04, 0x09, 0x01, 0xa5]);
 
 {
   const stream = zlib.createInflate();
 
-  stream.on('error', common.mustCall(function(err) {
-    assert(/Missing dictionary/.test(err.message));
-  }));
+  stream.on(
+    'error',
+    common.mustCall(function(err) {
+      assert(/Missing dictionary/.test(err.message));
+    })
+  );
 
   stream.write(input);
 }
@@ -40,9 +43,12 @@ const input = Buffer.from([0x78, 0xBB, 0x04, 0x09, 0x01, 0xA5]);
 {
   const stream = zlib.createInflate({ dictionary: Buffer.from('fail') });
 
-  stream.on('error', common.mustCall(function(err) {
-    assert(/Bad dictionary/.test(err.message));
-  }));
+  stream.on(
+    'error',
+    common.mustCall(function(err) {
+      assert(/Bad dictionary/.test(err.message));
+    })
+  );
 
   stream.write(input);
 }
@@ -50,11 +56,14 @@ const input = Buffer.from([0x78, 0xBB, 0x04, 0x09, 0x01, 0xA5]);
 {
   const stream = zlib.createInflateRaw({ dictionary: Buffer.from('fail') });
 
-  stream.on('error', common.mustCall(function(err) {
-    // It's not possible to separate invalid dict and invalid data when using
-    // the raw format
-    assert(/invalid/.test(err.message));
-  }));
+  stream.on(
+    'error',
+    common.mustCall(function(err) {
+      // It's not possible to separate invalid dict and invalid data when using
+      // the raw format
+      assert(/invalid/.test(err.message));
+    })
+  );
 
   stream.write(input);
 }
diff --git a/test/parallel/test-zlib-dictionary.js b/test/parallel/test-zlib-dictionary.js
index b7f6a138555237..a2e79b4ace439e 100644
--- a/test/parallel/test-zlib-dictionary.js
+++ b/test/parallel/test-zlib-dictionary.js
@@ -26,21 +26,23 @@ const common = require('../common');
 const assert = require('assert');
 const zlib = require('zlib');
 
-const spdyDict = Buffer.from([
-  'optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-',
-  'languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi',
-  'f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser',
-  '-agent10010120020120220320420520630030130230330430530630740040140240340440',
-  '5406407408409410411412413414415416417500501502503504505accept-rangesageeta',
-  'glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic',
-  'ateallowcontent-basecontent-encodingcache-controlconnectiondatetrailertran',
-  'sfer-encodingupgradeviawarningcontent-languagecontent-lengthcontent-locati',
-  'oncontent-md5content-rangecontent-typeetagexpireslast-modifiedset-cookieMo',
-  'ndayTuesdayWednesdayThursdayFridaySaturdaySundayJanFebMarAprMayJunJulAugSe',
-  'pOctNovDecchunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplic',
-  'ation/xhtmltext/plainpublicmax-agecharset=iso-8859-1utf-8gzipdeflateHTTP/1',
-  '.1statusversionurl\0'
-].join(''));
+const spdyDict = Buffer.from(
+  [
+    'optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-',
+    'languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi',
+    'f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser',
+    '-agent10010120020120220320420520630030130230330430530630740040140240340440',
+    '5406407408409410411412413414415416417500501502503504505accept-rangesageeta',
+    'glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic',
+    'ateallowcontent-basecontent-encodingcache-controlconnectiondatetrailertran',
+    'sfer-encodingupgradeviawarningcontent-languagecontent-lengthcontent-locati',
+    'oncontent-md5content-rangecontent-typeetagexpireslast-modifiedset-cookieMo',
+    'ndayTuesdayWednesdayThursdayFridaySaturdaySundayJanFebMarAprMayJunJulAugSe',
+    'pOctNovDecchunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplic',
+    'ation/xhtmltext/plainpublicmax-agecharset=iso-8859-1utf-8gzipdeflateHTTP/1',
+    '.1statusversionurl\0'
+  ].join('')
+);
 
 const input = [
   'HTTP/1.1 200 Ok',
@@ -67,9 +69,12 @@ function basicDictionaryTest(spdyDict) {
     inflate.end();
   });
 
-  inflate.on('end', common.mustCall(function() {
-    assert.strictEqual(input, output);
-  }));
+  inflate.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(input, output);
+    })
+  );
 
   deflate.write(input);
   deflate.end();
@@ -83,8 +88,7 @@ function deflateResetDictionaryTest(spdyDict) {
   inflate.setEncoding('utf-8');
 
   deflate.on('data', function(chunk) {
-    if (doneReset)
-      inflate.write(chunk);
+    if (doneReset) inflate.write(chunk);
   });
 
   inflate.on('data', function(chunk) {
@@ -95,9 +99,12 @@ function deflateResetDictionaryTest(spdyDict) {
     inflate.end();
   });
 
-  inflate.on('end', common.mustCall(function() {
-    assert.strictEqual(input, output);
-  }));
+  inflate.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(input, output);
+    })
+  );
 
   deflate.write(input);
   deflate.flush(function() {
@@ -126,9 +133,12 @@ function rawDictionaryTest(spdyDict) {
     inflate.end();
   });
 
-  inflate.on('end', common.mustCall(function() {
-    assert.strictEqual(input, output);
-  }));
+  inflate.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(input, output);
+    })
+  );
 
   deflate.write(input);
   deflate.end();
@@ -142,8 +152,7 @@ function deflateRawResetDictionaryTest(spdyDict) {
   inflate.setEncoding('utf-8');
 
   deflate.on('data', function(chunk) {
-    if (doneReset)
-      inflate.write(chunk);
+    if (doneReset) inflate.write(chunk);
   });
 
   inflate.on('data', function(chunk) {
@@ -154,9 +163,12 @@ function deflateRawResetDictionaryTest(spdyDict) {
     inflate.end();
   });
 
-  inflate.on('end', common.mustCall(function() {
-    assert.strictEqual(input, output);
-  }));
+  inflate.on(
+    'end',
+    common.mustCall(function() {
+      assert.strictEqual(input, output);
+    })
+  );
 
   deflate.write(input);
   deflate.flush(function() {
diff --git a/test/parallel/test-zlib-empty-buffer.js b/test/parallel/test-zlib-empty-buffer.js
index e351db54571732..4f43f2e9d1c7b8 100644
--- a/test/parallel/test-zlib-empty-buffer.js
+++ b/test/parallel/test-zlib-empty-buffer.js
@@ -6,19 +6,21 @@ const assert = require('assert');
 const emptyBuffer = Buffer.alloc(0);
 
 (async function() {
-  for (const [ compress, decompress, method ] of [
-    [ zlib.deflateRawSync, zlib.inflateRawSync, 'raw sync' ],
-    [ zlib.deflateSync, zlib.inflateSync, 'deflate sync' ],
-    [ zlib.gzipSync, zlib.gunzipSync, 'gzip sync' ],
-    [ promisify(zlib.deflateRaw), promisify(zlib.inflateRaw), 'raw' ],
-    [ promisify(zlib.deflate), promisify(zlib.inflate), 'deflate' ],
-    [ promisify(zlib.gzip), promisify(zlib.gunzip), 'gzip' ]
+  for (const [compress, decompress, method] of [
+    [zlib.deflateRawSync, zlib.inflateRawSync, 'raw sync'],
+    [zlib.deflateSync, zlib.inflateSync, 'deflate sync'],
+    [zlib.gzipSync, zlib.gunzipSync, 'gzip sync'],
+    [promisify(zlib.deflateRaw), promisify(zlib.inflateRaw), 'raw'],
+    [promisify(zlib.deflate), promisify(zlib.inflate), 'deflate'],
+    [promisify(zlib.gzip), promisify(zlib.gunzip), 'gzip']
   ]) {
     const compressed = await compress(emptyBuffer);
     const decompressed = await decompress(compressed);
     assert.deepStrictEqual(
-      emptyBuffer, decompressed,
+      emptyBuffer,
+      decompressed,
       `Expected ${inspect(compressed)} to match ${inspect(decompressed)} ` +
-      `to match for ${method}`);
+        `to match for ${method}`
+    );
   }
 })();
diff --git a/test/parallel/test-zlib-failed-init.js b/test/parallel/test-zlib-failed-init.js
index 4834c82b7d3a74..cbb21a6727c9df 100644
--- a/test/parallel/test-zlib-failed-init.js
+++ b/test/parallel/test-zlib-failed-init.js
@@ -5,35 +5,29 @@ const common = require('../common');
 const assert = require('assert');
 const zlib = require('zlib');
 
-common.expectsError(
-  () => zlib.createGzip({ chunkSize: 0 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.chunkSize" is out of range. It must ' +
-             'be >= 64. Received 0'
-  }
-);
+common.expectsError(() => zlib.createGzip({ chunkSize: 0 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.chunkSize" is out of range. It must ' +
+    'be >= 64. Received 0'
+});
 
-common.expectsError(
-  () => zlib.createGzip({ windowBits: 0 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.windowBits" is out of range. It must ' +
-             'be >= 8 and <= 15. Received 0'
-  }
-);
+common.expectsError(() => zlib.createGzip({ windowBits: 0 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.windowBits" is out of range. It must ' +
+    'be >= 8 and <= 15. Received 0'
+});
 
-common.expectsError(
-  () => zlib.createGzip({ memLevel: 0 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.memLevel" is out of range. It must ' +
-             'be >= 1 and <= 9. Received 0'
-  }
-);
+common.expectsError(() => zlib.createGzip({ memLevel: 0 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.memLevel" is out of range. It must ' +
+    'be >= 1 and <= 9. Received 0'
+});
 
 {
   const stream = zlib.createGzip({ level: NaN });
diff --git a/test/parallel/test-zlib-flush-drain-longblock.js b/test/parallel/test-zlib-flush-drain-longblock.js
index 94d1d9d04d9369..36152a1afc073c 100644
--- a/test/parallel/test-zlib-flush-drain-longblock.js
+++ b/test/parallel/test-zlib-flush-drain-longblock.js
@@ -16,9 +16,12 @@ zipper.write('A'.repeat(17000));
 zipper.flush();
 
 let received = 0;
-unzipper.on('data', common.mustCall((d) => {
-  received += d.length;
-}, 2));
+unzipper.on(
+  'data',
+  common.mustCall((d) => {
+    received += d.length;
+  }, 2)
+);
 
 // Properly `.end()`ing the streams would interfere with checking that
 // `.flush()` works.
diff --git a/test/parallel/test-zlib-flush-drain.js b/test/parallel/test-zlib-flush-drain.js
index a470e32090f084..512eef77528555 100644
--- a/test/parallel/test-zlib-flush-drain.js
+++ b/test/parallel/test-zlib-flush-drain.js
@@ -37,12 +37,8 @@ deflater.on('drain', function() {
 });
 
 process.once('exit', function() {
-  assert.strictEqual(
-    beforeFlush, true);
-  assert.strictEqual(
-    afterFlush, false);
-  assert.strictEqual(
-    drainCount, 1);
-  assert.strictEqual(
-    flushCount, 1);
+  assert.strictEqual(beforeFlush, true);
+  assert.strictEqual(afterFlush, false);
+  assert.strictEqual(drainCount, 1);
+  assert.strictEqual(flushCount, 1);
 });
diff --git a/test/parallel/test-zlib-flush-flags.js b/test/parallel/test-zlib-flush-flags.js
index 67c58b95d3105e..fc53c29491aa55 100644
--- a/test/parallel/test-zlib-flush-flags.js
+++ b/test/parallel/test-zlib-flush-flags.js
@@ -4,44 +4,36 @@ const zlib = require('zlib');
 
 zlib.createGzip({ flush: zlib.constants.Z_SYNC_FLUSH });
 
-common.expectsError(
-  () => zlib.createGzip({ flush: 'foobar' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.flush" property must be of type number. ' +
-             'Received type string'
-  }
-);
+common.expectsError(() => zlib.createGzip({ flush: 'foobar' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.flush" property must be of type number. ' +
+    'Received type string'
+});
 
-common.expectsError(
-  () => zlib.createGzip({ flush: 10000 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.flush" is out of range. It must ' +
-             'be >= 0 and <= 5. Received 10000'
-  }
-);
+common.expectsError(() => zlib.createGzip({ flush: 10000 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.flush" is out of range. It must ' +
+    'be >= 0 and <= 5. Received 10000'
+});
 
 zlib.createGzip({ finishFlush: zlib.constants.Z_SYNC_FLUSH });
 
-common.expectsError(
-  () => zlib.createGzip({ finishFlush: 'foobar' }),
-  {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError,
-    message: 'The "options.finishFlush" property must be of type number. ' +
-             'Received type string'
-  }
-);
+common.expectsError(() => zlib.createGzip({ finishFlush: 'foobar' }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+  type: TypeError,
+  message:
+    'The "options.finishFlush" property must be of type number. ' +
+    'Received type string'
+});
 
-common.expectsError(
-  () => zlib.createGzip({ finishFlush: 10000 }),
-  {
-    code: 'ERR_OUT_OF_RANGE',
-    type: RangeError,
-    message: 'The value of "options.finishFlush" is out of range. It must ' +
-             'be >= 0 and <= 5. Received 10000'
-  }
-);
+common.expectsError(() => zlib.createGzip({ finishFlush: 10000 }), {
+  code: 'ERR_OUT_OF_RANGE',
+  type: RangeError,
+  message:
+    'The value of "options.finishFlush" is out of range. It must ' +
+    'be >= 0 and <= 5. Received 10000'
+});
diff --git a/test/parallel/test-zlib-flush-multiple-scheduled.js b/test/parallel/test-zlib-flush-multiple-scheduled.js
index 0b752557e441bc..6dc6cc4314001d 100644
--- a/test/parallel/test-zlib-flush-multiple-scheduled.js
+++ b/test/parallel/test-zlib-flush-multiple-scheduled.js
@@ -5,7 +5,10 @@ const assert = require('assert');
 const zlib = require('zlib');
 
 const {
-  Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH
+  Z_PARTIAL_FLUSH,
+  Z_SYNC_FLUSH,
+  Z_FULL_FLUSH,
+  Z_FINISH
 } = zlib.constants;
 
 async function getOutput(...sequenceOfFlushes) {
@@ -19,21 +22,32 @@ async function getOutput(...sequenceOfFlushes) {
   const data = [];
 
   return new Promise((resolve) => {
-    zipper.on('data', common.mustCall((d) => {
-      data.push(d);
-      if (data.length === 2) resolve(Buffer.concat(data));
-    }, 2));
+    zipper.on(
+      'data',
+      common.mustCall((d) => {
+        data.push(d);
+        if (data.length === 2) resolve(Buffer.concat(data));
+      }, 2)
+    );
   });
 }
 
 (async function() {
-  assert.deepStrictEqual(await getOutput(Z_SYNC_FLUSH),
-                         await getOutput(Z_SYNC_FLUSH, Z_PARTIAL_FLUSH));
-  assert.deepStrictEqual(await getOutput(Z_SYNC_FLUSH),
-                         await getOutput(Z_PARTIAL_FLUSH, Z_SYNC_FLUSH));
-
-  assert.deepStrictEqual(await getOutput(Z_FINISH),
-                         await getOutput(Z_FULL_FLUSH, Z_FINISH));
-  assert.deepStrictEqual(await getOutput(Z_FINISH),
-                         await getOutput(Z_SYNC_FLUSH, Z_FINISH));
+  assert.deepStrictEqual(
+    await getOutput(Z_SYNC_FLUSH),
+    await getOutput(Z_SYNC_FLUSH, Z_PARTIAL_FLUSH)
+  );
+  assert.deepStrictEqual(
+    await getOutput(Z_SYNC_FLUSH),
+    await getOutput(Z_PARTIAL_FLUSH, Z_SYNC_FLUSH)
+  );
+
+  assert.deepStrictEqual(
+    await getOutput(Z_FINISH),
+    await getOutput(Z_FULL_FLUSH, Z_FINISH)
+  );
+  assert.deepStrictEqual(
+    await getOutput(Z_FINISH),
+    await getOutput(Z_SYNC_FLUSH, Z_FINISH)
+  );
 })();
diff --git a/test/parallel/test-zlib-flush.js b/test/parallel/test-zlib-flush.js
index 965cb5c45b13ea..85f92e7ee026ec 100644
--- a/test/parallel/test-zlib-flush.js
+++ b/test/parallel/test-zlib-flush.js
@@ -23,8 +23,7 @@ deflater.write(chunk, function() {
     deflater.flush(function() {
       const bufs = [];
       let buf;
-      while (buf = deflater.read())
-        bufs.push(buf);
+      while ((buf = deflater.read())) bufs.push(buf);
       actualFull = Buffer.concat(bufs);
     });
   });
diff --git a/test/parallel/test-zlib-from-concatenated-gzip.js b/test/parallel/test-zlib-from-concatenated-gzip.js
index c73a29e649765b..42773d5c0cc56c 100644
--- a/test/parallel/test-zlib-from-concatenated-gzip.js
+++ b/test/parallel/test-zlib-from-concatenated-gzip.js
@@ -13,31 +13,34 @@ const def = 'def';
 const abcEncoded = zlib.gzipSync(abc);
 const defEncoded = zlib.gzipSync(def);
 
-const data = Buffer.concat([
-  abcEncoded,
-  defEncoded
-]);
+const data = Buffer.concat([abcEncoded, defEncoded]);
 
-assert.strictEqual(zlib.gunzipSync(data).toString(), (abc + def));
+assert.strictEqual(zlib.gunzipSync(data).toString(), abc + def);
 
-zlib.gunzip(data, common.mustCall((err, result) => {
-  assert.ifError(err);
-  assert.strictEqual(result.toString(), (abc + def));
-}));
+zlib.gunzip(
+  data,
+  common.mustCall((err, result) => {
+    assert.ifError(err);
+    assert.strictEqual(result.toString(), abc + def);
+  })
+);
 
-zlib.unzip(data, common.mustCall((err, result) => {
-  assert.ifError(err);
-  assert.strictEqual(result.toString(), (abc + def));
-}));
+zlib.unzip(
+  data,
+  common.mustCall((err, result) => {
+    assert.ifError(err);
+    assert.strictEqual(result.toString(), abc + def);
+  })
+);
 
 // Multi-member support does not apply to zlib inflate/deflate.
-zlib.unzip(Buffer.concat([
-  zlib.deflateSync('abc'),
-  zlib.deflateSync('def')
-]), common.mustCall((err, result) => {
-  assert.ifError(err);
-  assert.strictEqual(result.toString(), abc);
-}));
+zlib.unzip(
+  Buffer.concat([zlib.deflateSync('abc'), zlib.deflateSync('def')]),
+  common.mustCall((err, result) => {
+    assert.ifError(err);
+    assert.strictEqual(result.toString(), abc);
+  })
+);
 
 // files that have the "right" magic bytes for starting a new gzip member
 // in the middle of themselves, even if they are part of a single
@@ -54,32 +57,37 @@ fs.createReadStream(pmmFileGz)
     assert.ifError(err);
   })
   .on('data', (data) => pmmResultBuffers.push(data))
-  .on('finish', common.mustCall(() => {
-    // Result should match original random garbage
-    assert.deepStrictEqual(Buffer.concat(pmmResultBuffers), pmmExpected);
-  }));
+  .on(
+    'finish',
+    common.mustCall(() => {
+      // Result should match original random garbage
+      assert.deepStrictEqual(Buffer.concat(pmmResultBuffers), pmmExpected);
+    })
+  );
 
 // test that the next gzip member can wrap around the input buffer boundary
 [0, 1, 2, 3, 4, defEncoded.length].forEach((offset) => {
   const resultBuffers = [];
 
-  const unzip = zlib.createGunzip()
+  const unzip = zlib
+    .createGunzip()
     .on('error', (err) => {
       assert.ifError(err);
     })
     .on('data', (data) => resultBuffers.push(data))
-    .on('finish', common.mustCall(() => {
-      assert.strictEqual(
-        Buffer.concat(resultBuffers).toString(),
-        'abcdef',
-        `result should match original input (offset = ${offset})`
-      );
-    }));
+    .on(
+      'finish',
+      common.mustCall(() => {
+        assert.strictEqual(
+          Buffer.concat(resultBuffers).toString(),
+          'abcdef',
+          `result should match original input (offset = ${offset})`
+        );
+      })
+    );
 
   // first write: write "abc" + the first bytes of "def"
-  unzip.write(Buffer.concat([
-    abcEncoded, defEncoded.slice(0, offset)
-  ]));
+  unzip.write(Buffer.concat([abcEncoded, defEncoded.slice(0, offset)]));
 
   // write remaining bytes of "def"
   unzip.end(defEncoded.slice(offset));
diff --git a/test/parallel/test-zlib-from-gzip-with-trailing-garbage.js b/test/parallel/test-zlib-from-gzip-with-trailing-garbage.js
index 48d9e441429eeb..609ffa0a6d6967 100644
--- a/test/parallel/test-zlib-from-gzip-with-trailing-garbage.js
+++ b/test/parallel/test-zlib-from-gzip-with-trailing-garbage.js
@@ -14,14 +14,17 @@ let data = Buffer.concat([
 
 assert.strictEqual(zlib.gunzipSync(data).toString(), 'abcdef');
 
-zlib.gunzip(data, common.mustCall((err, result) => {
-  assert.ifError(err);
-  assert.strictEqual(
-    result.toString(),
-    'abcdef',
-    `result '${result.toString()}' should match original string`
-  );
-}));
+zlib.gunzip(
+  data,
+  common.mustCall((err, result) => {
+    assert.ifError(err);
+    assert.strictEqual(
+      result.toString(),
+      'abcdef',
+      `result '${result.toString()}' should match original string`
+    );
+  })
+);
 
 // if the trailing garbage happens to look like a gzip header, it should
 // throw an error.
@@ -37,14 +40,17 @@ assert.throws(
   /^Error: unknown compression method$/
 );
 
-zlib.gunzip(data, common.mustCall((err, result) => {
-  common.expectsError({
-    code: 'Z_DATA_ERROR',
-    type: Error,
-    message: 'unknown compression method'
-  })(err);
-  assert.strictEqual(result, undefined);
-}));
+zlib.gunzip(
+  data,
+  common.mustCall((err, result) => {
+    common.expectsError({
+      code: 'Z_DATA_ERROR',
+      type: Error,
+      message: 'unknown compression method'
+    })(err);
+    assert.strictEqual(result, undefined);
+  })
+);
 
 // In this case the trailing junk is too short to be a gzip segment
 // So we ignore it and decompression succeeds.
@@ -59,9 +65,12 @@ assert.throws(
   /^Error: unknown compression method$/
 );
 
-zlib.gunzip(data, common.mustCall((err, result) => {
-  assert(err instanceof Error);
-  assert.strictEqual(err.code, 'Z_DATA_ERROR');
-  assert.strictEqual(err.message, 'unknown compression method');
-  assert.strictEqual(result, undefined);
-}));
+zlib.gunzip(
+  data,
+  common.mustCall((err, result) => {
+    assert(err instanceof Error);
+    assert.strictEqual(err.code, 'Z_DATA_ERROR');
+    assert.strictEqual(err.message, 'unknown compression method');
+    assert.strictEqual(result, undefined);
+  })
+);
diff --git a/test/parallel/test-zlib-from-gzip.js b/test/parallel/test-zlib-from-gzip.js
index 99c3f1757e05d8..e1f57c685b8d8c 100644
--- a/test/parallel/test-zlib-from-gzip.js
+++ b/test/parallel/test-zlib-from-gzip.js
@@ -44,10 +44,13 @@ const inp = fs.createReadStream(fixture);
 const out = fs.createWriteStream(outputFile);
 
 inp.pipe(gunzip).pipe(out);
-out.on('close', common.mustCall(() => {
-  const actual = fs.readFileSync(outputFile);
-  assert.strictEqual(actual.length, expect.length);
-  for (let i = 0, l = actual.length; i < l; i++) {
-    assert.strictEqual(actual[i], expect[i], `byte[${i}]`);
-  }
-}));
+out.on(
+  'close',
+  common.mustCall(() => {
+    const actual = fs.readFileSync(outputFile);
+    assert.strictEqual(actual.length, expect.length);
+    for (let i = 0, l = actual.length; i < l; i++) {
+      assert.strictEqual(actual[i], expect[i], `byte[${i}]`);
+    }
+  })
+);
diff --git a/test/parallel/test-zlib-from-string.js b/test/parallel/test-zlib-from-string.js
index 617a8b55056ebd..e219a5f09d5495 100644
--- a/test/parallel/test-zlib-from-string.js
+++ b/test/parallel/test-zlib-from-string.js
@@ -26,56 +26,74 @@ const common = require('../common');
 const assert = require('assert');
 const zlib = require('zlib');
 
-const inputString = 'ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli' +
-                    't. Morbi faucibus, purus at gravida dictum, libero arcu ' +
-                    'convallis lacus, in commodo libero metus eu nisi. Nullam' +
-                    ' commodo, neque nec porta placerat, nisi est fermentum a' +
-                    'ugue, vitae gravida tellus sapien sit amet tellus. Aenea' +
-                    'n non diam orci. Proin quis elit turpis. Suspendisse non' +
-                    ' diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu' +
-                    'm arcu mi, sodales non suscipit id, ultrices ut massa. S' +
-                    'ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ';
-const expectedBase64Deflate = 'eJxdUUtOQzEMvMoc4OndgT0gJCT2buJWlpI4jePeqZfpmX' +
-                              'AKLRKbLOzx/HK73q6vOrhCunlF1qIDJhNUeW5I2ozT5OkD' +
-                              'lKWLJWkncJG5403HQXAkT3Jw29B9uIEmToMukglZ0vS6oc' +
-                              'iBh4JG8sV4oVLEUCitK2kxq1WzPnChHDzsaGKy491LofoA' +
-                              'bWh8do43oeuYhB5EPCjcLjzYJo48KrfQBvnJecNFJvHT1+' +
-                              'RSQsGoC7dn2t/xjhduTA1NWyQIZR0pbHwMDatnD+crPqKS' +
-                              'qGPHp1vnlsWM/07ubf7bheF7kqSj84Bm0R1fYTfaK8vqqq' +
-                              'fKBtNMhe3OZh6N95CTvMX5HJJi4xOVzCgUOIMSLH7wmeOH' +
-                              'aFE4RdpnGavKtrB5xzfO/Ll9';
-const expectedBase64Gzip = 'H4sIAAAAAAAAA11RS05DMQy8yhzg6d2BPSAkJPZu4laWkjiN4' +
-                           '96pl+mZcAotEpss7PH8crverq86uEK6eUXWogMmE1R5bkjajN' +
-                           'Pk6QOUpYslaSdwkbnjTcdBcCRPcnDb0H24gSZOgy6SCVnS9Lq' +
-                           'hyIGHgkbyxXihUsRQKK0raTGrVbM+cKEcPOxoYrLj3Uuh+gBt' +
-                           'aHx2jjeh65iEHkQ8KNwuPNgmjjwqt9AG+cl5w0Um8dPX5FJCw' +
-                           'agLt2fa3/GOF25MDU1bJAhlHSlsfAwNq2cP5ys+opKoY8enW+' +
-                           'eWxYz/Tu5t/tuF4XuSpKPzgGbRHV9hN9ory+qqp8oG00yF7c5' +
-                           'mHo33kJO8xfkckmLjE5XMKBQ4gxIsfvCZ44doUThF2mcZq8q2' +
-                           'sHnHNzRtagj5AQAA';
+const inputString =
+  'ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli' +
+  't. Morbi faucibus, purus at gravida dictum, libero arcu ' +
+  'convallis lacus, in commodo libero metus eu nisi. Nullam' +
+  ' commodo, neque nec porta placerat, nisi est fermentum a' +
+  'ugue, vitae gravida tellus sapien sit amet tellus. Aenea' +
+  'n non diam orci. Proin quis elit turpis. Suspendisse non' +
+  ' diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu' +
+  'm arcu mi, sodales non suscipit id, ultrices ut massa. S' +
+  'ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ';
+const expectedBase64Deflate =
+  'eJxdUUtOQzEMvMoc4OndgT0gJCT2buJWlpI4jePeqZfpmX' +
+  'AKLRKbLOzx/HK73q6vOrhCunlF1qIDJhNUeW5I2ozT5OkD' +
+  'lKWLJWkncJG5403HQXAkT3Jw29B9uIEmToMukglZ0vS6oc' +
+  'iBh4JG8sV4oVLEUCitK2kxq1WzPnChHDzsaGKy491LofoA' +
+  'bWh8do43oeuYhB5EPCjcLjzYJo48KrfQBvnJecNFJvHT1+' +
+  'RSQsGoC7dn2t/xjhduTA1NWyQIZR0pbHwMDatnD+crPqKS' +
+  'qGPHp1vnlsWM/07ubf7bheF7kqSj84Bm0R1fYTfaK8vqqq' +
+  'fKBtNMhe3OZh6N95CTvMX5HJJi4xOVzCgUOIMSLH7wmeOH' +
+  'aFE4RdpnGavKtrB5xzfO/Ll9';
+const expectedBase64Gzip =
+  'H4sIAAAAAAAAA11RS05DMQy8yhzg6d2BPSAkJPZu4laWkjiN4' +
+  '96pl+mZcAotEpss7PH8crverq86uEK6eUXWogMmE1R5bkjajN' +
+  'Pk6QOUpYslaSdwkbnjTcdBcCRPcnDb0H24gSZOgy6SCVnS9Lq' +
+  'hyIGHgkbyxXihUsRQKK0raTGrVbM+cKEcPOxoYrLj3Uuh+gBt' +
+  'aHx2jjeh65iEHkQ8KNwuPNgmjjwqt9AG+cl5w0Um8dPX5FJCw' +
+  'agLt2fa3/GOF25MDU1bJAhlHSlsfAwNq2cP5ys+opKoY8enW+' +
+  'eWxYz/Tu5t/tuF4XuSpKPzgGbRHV9hN9ory+qqp8oG00yF7c5' +
+  'mHo33kJO8xfkckmLjE5XMKBQ4gxIsfvCZ44doUThF2mcZq8q2' +
+  'sHnHNzRtagj5AQAA';
 
-zlib.deflate(inputString, common.mustCall((err, buffer) => {
-  assert.strictEqual(buffer.toString('base64'), expectedBase64Deflate);
-}));
+zlib.deflate(
+  inputString,
+  common.mustCall((err, buffer) => {
+    assert.strictEqual(buffer.toString('base64'), expectedBase64Deflate);
+  })
+);
 
-zlib.gzip(inputString, common.mustCall((err, buffer) => {
-  // Can't actually guarantee that we'll get exactly the same
-  // deflated bytes when we compress a string, since the header
-  // depends on stuff other than the input string itself.
-  // However, decrypting it should definitely yield the same
-  // result that we're expecting, and this should match what we get
-  // from inflating the known valid deflate data.
-  zlib.gunzip(buffer, common.mustCall((err, gunzipped) => {
-    assert.strictEqual(gunzipped.toString(), inputString);
-  }));
-}));
+zlib.gzip(
+  inputString,
+  common.mustCall((err, buffer) => {
+    // Can't actually guarantee that we'll get exactly the same
+    // deflated bytes when we compress a string, since the header
+    // depends on stuff other than the input string itself.
+    // However, decrypting it should definitely yield the same
+    // result that we're expecting, and this should match what we get
+    // from inflating the known valid deflate data.
+    zlib.gunzip(
+      buffer,
+      common.mustCall((err, gunzipped) => {
+        assert.strictEqual(gunzipped.toString(), inputString);
+      })
+    );
+  })
+);
 
 let buffer = Buffer.from(expectedBase64Deflate, 'base64');
-zlib.unzip(buffer, common.mustCall((err, buffer) => {
-  assert.strictEqual(buffer.toString(), inputString);
-}));
+zlib.unzip(
+  buffer,
+  common.mustCall((err, buffer) => {
+    assert.strictEqual(buffer.toString(), inputString);
+  })
+);
 
 buffer = Buffer.from(expectedBase64Gzip, 'base64');
-zlib.unzip(buffer, common.mustCall((err, buffer) => {
-  assert.strictEqual(buffer.toString(), inputString);
-}));
+zlib.unzip(
+  buffer,
+  common.mustCall((err, buffer) => {
+    assert.strictEqual(buffer.toString(), inputString);
+  })
+);
diff --git a/test/parallel/test-zlib-invalid-input-memory.js b/test/parallel/test-zlib-invalid-input-memory.js
index d626e6e5b8df38..8e5f118c560cd7 100644
--- a/test/parallel/test-zlib-invalid-input-memory.js
+++ b/test/parallel/test-zlib-invalid-input-memory.js
@@ -14,15 +14,18 @@ const ongc = common.mustCall();
   const input = Buffer.from('foobar');
   const strm = zlib.createInflate();
   strm.end(input);
-  strm.once('error', common.mustCall((err) => {
-    assert(err);
-    setImmediate(() => {
-      global.gc();
-      // Keep the event loop alive for seeing the async_hooks destroy hook
-      // we use for GC tracking...
-      // TODO(addaleax): This should maybe not be necessary?
-      setImmediate(() => {});
-    });
-  }));
+  strm.once(
+    'error',
+    common.mustCall((err) => {
+      assert(err);
+      setImmediate(() => {
+        global.gc();
+        // Keep the event loop alive for seeing the async_hooks destroy hook
+        // we use for GC tracking...
+        // TODO(addaleax): This should maybe not be necessary?
+        setImmediate(() => {});
+      });
+    })
+  );
   onGC(strm, { ongc });
 }
diff --git a/test/parallel/test-zlib-invalid-input.js b/test/parallel/test-zlib-invalid-input.js
index 1b081d919e9068..f5ca927b0dd915 100644
--- a/test/parallel/test-zlib-invalid-input.js
+++ b/test/parallel/test-zlib-invalid-input.js
@@ -26,33 +26,27 @@ const common = require('../common');
 const assert = require('assert');
 const zlib = require('zlib');
 
-const nonStringInputs = [
-  1,
-  true,
-  { a: 1 },
-  ['a']
-];
+const nonStringInputs = [1, true, { a: 1 }, ['a']];
 
 // zlib.Unzip classes need to get valid data, or else they'll throw.
-const unzips = [
-  zlib.Unzip(),
-  zlib.Gunzip(),
-  zlib.Inflate(),
-  zlib.InflateRaw()
-];
+const unzips = [zlib.Unzip(), zlib.Gunzip(), zlib.Inflate(), zlib.InflateRaw()];
 
-nonStringInputs.forEach(common.mustCall((input) => {
-  // zlib.gunzip should not throw an error when called with bad input.
-  zlib.gunzip(input, function(err, buffer) {
-    // zlib.gunzip should pass the error to the callback.
-    assert.ok(err);
-  });
-}, nonStringInputs.length));
+nonStringInputs.forEach(
+  common.mustCall((input) => {
+    // zlib.gunzip should not throw an error when called with bad input.
+    zlib.gunzip(input, function(err, buffer) {
+      // zlib.gunzip should pass the error to the callback.
+      assert.ok(err);
+    });
+  }, nonStringInputs.length)
+);
 
-unzips.forEach(common.mustCall((uz, i) => {
-  uz.on('error', common.mustCall());
-  uz.on('end', common.mustNotCall);
+unzips.forEach(
+  common.mustCall((uz, i) => {
+    uz.on('error', common.mustCall());
+    uz.on('end', common.mustNotCall);
 
-  // this will trigger error event
-  uz.write('this is not valid compressed data.');
-}, unzips.length));
+    // this will trigger error event
+    uz.write('this is not valid compressed data.');
+  }, unzips.length)
+);
diff --git a/test/parallel/test-zlib-not-string-or-buffer.js b/test/parallel/test-zlib-not-string-or-buffer.js
index bf59e86d5c3664..7d32549a64afea 100644
--- a/test/parallel/test-zlib-not-string-or-buffer.js
+++ b/test/parallel/test-zlib-not-string-or-buffer.js
@@ -6,24 +6,15 @@
 const common = require('../common');
 const zlib = require('zlib');
 
-[
-  undefined,
-  null,
-  true,
-  false,
-  0,
-  1,
-  [1, 2, 3],
-  { foo: 'bar' }
-].forEach((input) => {
-  common.expectsError(
-    () => zlib.deflateSync(input),
-    {
+[undefined, null, true, false, 0, 1, [1, 2, 3], { foo: 'bar' }].forEach(
+  (input) => {
+    common.expectsError(() => zlib.deflateSync(input), {
       code: 'ERR_INVALID_ARG_TYPE',
       type: TypeError,
-      message: 'The "buffer" argument must be one of type string, Buffer, ' +
-               'TypedArray, DataView, or ArrayBuffer. ' +
-               `Received type ${typeof input}`
-    }
-  );
-});
+      message:
+        'The "buffer" argument must be one of type string, Buffer, ' +
+        'TypedArray, DataView, or ArrayBuffer. ' +
+        `Received type ${typeof input}`
+    });
+  }
+);
diff --git a/test/parallel/test-zlib-object-write.js b/test/parallel/test-zlib-object-write.js
index 98f34b38bed850..a7bae808e69299 100644
--- a/test/parallel/test-zlib-object-write.js
+++ b/test/parallel/test-zlib-object-write.js
@@ -5,7 +5,4 @@ const assert = require('assert');
 const { Gunzip } = require('zlib');
 
 const gunzip = new Gunzip({ objectMode: true });
-assert.throws(
-  () => gunzip.write({}),
-  TypeError
-);
+assert.throws(() => gunzip.write({}), TypeError);
diff --git a/test/parallel/test-zlib-params.js b/test/parallel/test-zlib-params.js
index 293ceecf8fa02a..bc095c11bbadee 100644
--- a/test/parallel/test-zlib-params.js
+++ b/test/parallel/test-zlib-params.js
@@ -21,8 +21,7 @@ deflater.write(chunk1, function() {
     deflater.end(chunk2, function() {
       const bufs = [];
       let buf;
-      while (buf = deflater.read())
-        bufs.push(buf);
+      while ((buf = deflater.read())) bufs.push(buf);
       actual = Buffer.concat(bufs);
     });
   });
diff --git a/test/parallel/test-zlib-random-byte-pipes.js b/test/parallel/test-zlib-random-byte-pipes.js
index 9c679ab0a0a2fa..84a358ff7c0b2e 100644
--- a/test/parallel/test-zlib-random-byte-pipes.js
+++ b/test/parallel/test-zlib-random-byte-pipes.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -79,7 +78,10 @@ class RandomReadStream extends Stream {
     this._processing = true;
 
     if (!this._remaining) {
-      this._hash = this._hasher.digest('hex').toLowerCase().trim();
+      this._hash = this._hasher
+        .digest('hex')
+        .toLowerCase()
+        .trim();
       this._processing = false;
 
       this.emit('end');
@@ -91,7 +93,7 @@ class RandomReadStream extends Stream {
     let block = this._opt.block;
     const jitter = this._opt.jitter;
     if (jitter) {
-      block += Math.ceil(Math.random() * jitter - (jitter / 2));
+      block += Math.ceil(Math.random() * jitter - jitter / 2);
     }
     block = Math.min(block, this._remaining);
     const buf = Buffer.allocUnsafe(block);
@@ -135,20 +137,28 @@ class HashStream extends Stream {
     if (c) {
       this.write(c);
     }
-    this._hash = this._hasher.digest('hex').toLowerCase().trim();
+    this._hash = this._hasher
+      .digest('hex')
+      .toLowerCase()
+      .trim();
     this.emit('data', this._hash);
     this.emit('end');
   }
 }
 
-
 const inp = new RandomReadStream({ total: 1024, block: 256, jitter: 16 });
 const out = new HashStream();
 const gzip = zlib.createGzip();
 const gunz = zlib.createGunzip();
 
-inp.pipe(gzip).pipe(gunz).pipe(out);
-
-out.on('data', common.mustCall((c) => {
-  assert.strictEqual(c, inp._hash, `Hash '${c}' equals '${inp._hash}'.`);
-}));
+inp
+  .pipe(gzip)
+  .pipe(gunz)
+  .pipe(out);
+
+out.on(
+  'data',
+  common.mustCall((c) => {
+    assert.strictEqual(c, inp._hash, `Hash '${c}' equals '${inp._hash}'.`);
+  })
+);
diff --git a/test/parallel/test-zlib-truncated.js b/test/parallel/test-zlib-truncated.js
index e04ef7e3d8367a..2a929ff723c5fe 100644
--- a/test/parallel/test-zlib-truncated.js
+++ b/test/parallel/test-zlib-truncated.js
@@ -5,15 +5,16 @@ require('../common');
 const assert = require('assert');
 const zlib = require('zlib');
 
-const inputString = 'ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli' +
-                    't. Morbi faucibus, purus at gravida dictum, libero arcu ' +
-                    'convallis lacus, in commodo libero metus eu nisi. Nullam' +
-                    ' commodo, neque nec porta placerat, nisi est fermentum a' +
-                    'ugue, vitae gravida tellus sapien sit amet tellus. Aenea' +
-                    'n non diam orci. Proin quis elit turpis. Suspendisse non' +
-                    ' diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu' +
-                    'm arcu mi, sodales non suscipit id, ultrices ut massa. S' +
-                    'ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ';
+const inputString =
+  'ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli' +
+  't. Morbi faucibus, purus at gravida dictum, libero arcu ' +
+  'convallis lacus, in commodo libero metus eu nisi. Nullam' +
+  ' commodo, neque nec porta placerat, nisi est fermentum a' +
+  'ugue, vitae gravida tellus sapien sit amet tellus. Aenea' +
+  'n non diam orci. Proin quis elit turpis. Suspendisse non' +
+  ' diam ipsum. Suspendisse nec ullamcorper odio. Vestibulu' +
+  'm arcu mi, sodales non suscipit id, ultrices ut massa. S' +
+  'ed ac sem sit amet arcu malesuada fermentum. Nunc sed. ';
 
 const errMessage = /unexpected end of file/;
 
diff --git a/test/parallel/test-zlib-unused-weak.js b/test/parallel/test-zlib-unused-weak.js
index 7a5a6728533e18..1d21b26f15519f 100644
--- a/test/parallel/test-zlib-unused-weak.js
+++ b/test/parallel/test-zlib-unused-weak.js
@@ -7,12 +7,13 @@ const zlib = require('zlib');
 // Tests that native zlib handles start out their life as weak handles.
 
 const before = process.memoryUsage().external;
-for (let i = 0; i < 100; ++i)
-  zlib.createGzip();
+for (let i = 0; i < 100; ++i) zlib.createGzip();
 const afterCreation = process.memoryUsage().external;
 global.gc();
 const afterGC = process.memoryUsage().external;
 
-assert((afterGC - before) / (afterCreation - before) <= 0.05,
-       `Expected after-GC delta ${afterGC - before} to be less than 5 %` +
-       ` of before-GC delta ${afterCreation - before}`);
+assert(
+  (afterGC - before) / (afterCreation - before) <= 0.05,
+  `Expected after-GC delta ${afterGC - before} to be less than 5 %` +
+    ` of before-GC delta ${afterCreation - before}`
+);
diff --git a/test/parallel/test-zlib-unzip-one-byte-chunks.js b/test/parallel/test-zlib-unzip-one-byte-chunks.js
index be3b5dda818cf6..bbc08140f796a2 100644
--- a/test/parallel/test-zlib-unzip-one-byte-chunks.js
+++ b/test/parallel/test-zlib-unzip-one-byte-chunks.js
@@ -3,24 +3,28 @@ const common = require('../common');
 const assert = require('assert');
 const zlib = require('zlib');
 
-const data = Buffer.concat([
-  zlib.gzipSync('abc'),
-  zlib.gzipSync('def')
-]);
+const data = Buffer.concat([zlib.gzipSync('abc'), zlib.gzipSync('def')]);
 
 const resultBuffers = [];
 
-const unzip = zlib.createUnzip()
+const unzip = zlib
+  .createUnzip()
   .on('error', (err) => {
     assert.ifError(err);
   })
   .on('data', (data) => resultBuffers.push(data))
-  .on('finish', common.mustCall(() => {
-    assert.deepStrictEqual(Buffer.concat(resultBuffers).toString(), 'abcdef',
-                           `'${Buffer.concat(resultBuffers).toString()}' ` +
-                           'should match \'abcdef\' after ' +
-                           'zipping and unzipping');
-  }));
+  .on(
+    'finish',
+    common.mustCall(() => {
+      assert.deepStrictEqual(
+        Buffer.concat(resultBuffers).toString(),
+        'abcdef',
+        `'${Buffer.concat(resultBuffers).toString()}' ` +
+          "should match 'abcdef' after " +
+          'zipping and unzipping'
+      );
+    })
+  );
 
 for (let i = 0; i < data.length; i++) {
   // Write each single byte individually.
diff --git a/test/parallel/test-zlib-write-after-close.js b/test/parallel/test-zlib-write-after-close.js
index 160971b16bc30c..d37871c066e5c0 100644
--- a/test/parallel/test-zlib-write-after-close.js
+++ b/test/parallel/test-zlib-write-after-close.js
@@ -23,15 +23,15 @@
 const common = require('../common');
 const zlib = require('zlib');
 
-zlib.gzip('hello', common.mustCall(function(err, out) {
-  const unzip = zlib.createGunzip();
-  unzip.close(common.mustCall());
-  common.expectsError(
-    () => unzip.write(out),
-    {
+zlib.gzip(
+  'hello',
+  common.mustCall(function(err, out) {
+    const unzip = zlib.createGunzip();
+    unzip.close(common.mustCall());
+    common.expectsError(() => unzip.write(out), {
       code: 'ERR_STREAM_DESTROYED',
       type: Error,
       message: 'Cannot call write after a stream was destroyed'
-    }
-  );
-}));
+    });
+  })
+);
diff --git a/test/parallel/test-zlib-write-after-flush.js b/test/parallel/test-zlib-write-after-flush.js
index 6d8d787343426f..c9ba023aee46df 100644
--- a/test/parallel/test-zlib-write-after-flush.js
+++ b/test/parallel/test-zlib-write-after-flush.js
@@ -32,11 +32,14 @@ gzip.pipe(gunz);
 let output = '';
 const input = 'A line of data\n';
 gunz.setEncoding('utf8');
-gunz.on('data', (c) => output += c);
-gunz.on('end', common.mustCall(() => {
-  assert.strictEqual(output, input);
-  assert.strictEqual(gzip._nextFlush, -1);
-}));
+gunz.on('data', (c) => (output += c));
+gunz.on(
+  'end',
+  common.mustCall(() => {
+    assert.strictEqual(output, input);
+    assert.strictEqual(gzip._nextFlush, -1);
+  })
+);
 
 // make sure that flush/write doesn't trigger an assert failure
 gzip.flush();
diff --git a/test/parallel/test-zlib-zero-byte.js b/test/parallel/test-zlib-zero-byte.js
index 57eefcf2676c60..207fb990a64e9b 100644
--- a/test/parallel/test-zlib-zero-byte.js
+++ b/test/parallel/test-zlib-zero-byte.js
@@ -31,9 +31,12 @@ gz.on('data', function(c) {
   received += c.length;
 });
 
-gz.on('end', common.mustCall(function() {
-  assert.strictEqual(received, 20);
-}));
+gz.on(
+  'end',
+  common.mustCall(function() {
+    assert.strictEqual(received, 20);
+  })
+);
 gz.on('finish', common.mustCall());
 gz.write(emptyBuffer);
 gz.end();
diff --git a/test/parallel/test-zlib-zero-windowBits.js b/test/parallel/test-zlib-zero-windowBits.js
index a62e6148e33df7..dca75cd3fbbc2e 100644
--- a/test/parallel/test-zlib-zero-windowBits.js
+++ b/test/parallel/test-zlib-zero-windowBits.js
@@ -4,7 +4,6 @@ const common = require('../common');
 const assert = require('assert');
 const zlib = require('zlib');
 
-
 // windowBits is a special case in zlib. On the compression side, 0 is invalid.
 // On the decompression side, it indicates that zlib should use the value from
 // the header of the compressed stream.
@@ -27,7 +26,8 @@ const zlib = require('zlib');
   common.expectsError(() => zlib.createGzip({ windowBits: 0 }), {
     code: 'ERR_OUT_OF_RANGE',
     type: RangeError,
-    message: 'The value of "options.windowBits" is out of range. ' +
-             'It must be >= 8 and <= 15. Received 0'
+    message:
+      'The value of "options.windowBits" is out of range. ' +
+      'It must be >= 8 and <= 15. Received 0'
   });
 }
diff --git a/test/parallel/test-zlib.js b/test/parallel/test-zlib.js
index 1b6855a0b92062..26909d51ba2270 100644
--- a/test/parallel/test-zlib.js
+++ b/test/parallel/test-zlib.js
@@ -68,10 +68,11 @@ if (process.env.FAST) {
 }
 
 const tests = {};
-testFiles.forEach(common.mustCall((file) => {
-  tests[file] = fixtures.readSync(file);
-}, testFiles.length));
-
+testFiles.forEach(
+  common.mustCall((file) => {
+    tests[file] = fixtures.readSync(file);
+  }, testFiles.length)
+);
 
 // stream that saves everything
 class BufferStream extends stream.Stream {
@@ -166,11 +167,16 @@ zlib.createDeflateRaw({ windowBits: 8 });
   // that does not know about the silent 8-to-9 upgrade of windowBits
   // that most versions of zlib/Node perform, and which *still* results in
   // a valid 8-bit-window zlib stream.
-  node.pipe(zlib.createDeflateRaw({ windowBits: 9 }))
-      .pipe(zlib.createInflateRaw({ windowBits: 8 }))
-      .on('data', (chunk) => reinflated.push(chunk))
-      .on('end', common.mustCall(
-        () => assert(Buffer.concat(raw).equals(Buffer.concat(reinflated)))));
+  node
+    .pipe(zlib.createDeflateRaw({ windowBits: 9 }))
+    .pipe(zlib.createInflateRaw({ windowBits: 8 }))
+    .on('data', (chunk) => reinflated.push(chunk))
+    .on(
+      'end',
+      common.mustCall(() =>
+        assert(Buffer.concat(raw).equals(Buffer.concat(reinflated)))
+      )
+    );
 }
 
 // for each of the files, make sure that compressing and
@@ -178,45 +184,76 @@ zlib.createDeflateRaw({ windowBits: 8 });
 // of the options set above.
 
 const testKeys = Object.keys(tests);
-testKeys.forEach(common.mustCall((file) => {
-  const test = tests[file];
-  chunkSize.forEach(common.mustCall((chunkSize) => {
-    trickle.forEach(common.mustCall((trickle) => {
-      windowBits.forEach(common.mustCall((windowBits) => {
-        level.forEach(common.mustCall((level) => {
-          memLevel.forEach(common.mustCall((memLevel) => {
-            strategy.forEach(common.mustCall((strategy) => {
-              zlibPairs.forEach(common.mustCall((pair) => {
-                const Def = pair[0];
-                const Inf = pair[1];
-                const opts = { level, windowBits, memLevel, strategy };
-
-                const def = new Def(opts);
-                const inf = new Inf(opts);
-                const ss = new SlowStream(trickle);
-                const buf = new BufferStream();
-
-                // verify that the same exact buffer comes out the other end.
-                buf.on('data', common.mustCall((c) => {
-                  const msg = `${file} ${chunkSize} ${
-                    JSON.stringify(opts)} ${Def.name} -> ${Inf.name}`;
-                  let i;
-                  for (i = 0; i < Math.max(c.length, test.length); i++) {
-                    if (c[i] !== test[i]) {
-                      assert.fail(msg);
-                      break;
-                    }
-                  }
-                }));
-
-                // the magic happens here.
-                ss.pipe(def).pipe(inf).pipe(buf);
-                ss.end(test);
-              }, zlibPairs.length));
-            }, strategy.length));
-          }, memLevel.length));
-        }, level.length));
-      }, windowBits.length));
-    }, trickle.length));
-  }, chunkSize.length));
-}, testKeys.length));
+testKeys.forEach(
+  common.mustCall((file) => {
+    const test = tests[file];
+    chunkSize.forEach(
+      common.mustCall((chunkSize) => {
+        trickle.forEach(
+          common.mustCall((trickle) => {
+            windowBits.forEach(
+              common.mustCall((windowBits) => {
+                level.forEach(
+                  common.mustCall((level) => {
+                    memLevel.forEach(
+                      common.mustCall((memLevel) => {
+                        strategy.forEach(
+                          common.mustCall((strategy) => {
+                            zlibPairs.forEach(
+                              common.mustCall((pair) => {
+                                const Def = pair[0];
+                                const Inf = pair[1];
+                                const opts = {
+                                  level,
+                                  windowBits,
+                                  memLevel,
+                                  strategy
+                                };
+
+                                const def = new Def(opts);
+                                const inf = new Inf(opts);
+                                const ss = new SlowStream(trickle);
+                                const buf = new BufferStream();
+
+                                // verify that the same exact buffer comes out the other end.
+                                buf.on(
+                                  'data',
+                                  common.mustCall((c) => {
+                                    const msg = `${file} ${chunkSize} ${JSON.stringify(
+                                      opts
+                                    )} ${Def.name} -> ${Inf.name}`;
+                                    let i;
+                                    for (
+                                      i = 0;
+                                      i < Math.max(c.length, test.length);
+                                      i++
+                                    ) {
+                                      if (c[i] !== test[i]) {
+                                        assert.fail(msg);
+                                        break;
+                                      }
+                                    }
+                                  })
+                                );
+
+                                // the magic happens here.
+                                ss.pipe(def)
+                                  .pipe(inf)
+                                  .pipe(buf);
+                                ss.end(test);
+                              }, zlibPairs.length)
+                            );
+                          }, strategy.length)
+                        );
+                      }, memLevel.length)
+                    );
+                  }, level.length)
+                );
+              }, windowBits.length)
+            );
+          }, trickle.length)
+        );
+      }, chunkSize.length)
+    );
+  }, testKeys.length)
+);
diff --git a/test/pseudo-tty/no_dropped_stdio.js b/test/pseudo-tty/no_dropped_stdio.js
index f140860c0124f7..7d38ab72d09bbd 100644
--- a/test/pseudo-tty/no_dropped_stdio.js
+++ b/test/pseudo-tty/no_dropped_stdio.js
@@ -13,7 +13,10 @@ out += `${'o'.repeat(24)}O`;
 
 // In AIX, the child exits even before the python parent
 // can setup the readloop. Provide a reasonable delay.
-setTimeout(function() {
-  process.stdout.write(out);
-  process.exit(0);
-}, common.isAIX ? 200 : 0);
+setTimeout(
+  function() {
+    process.stdout.write(out);
+    process.exit(0);
+  },
+  common.isAIX ? 200 : 0
+);
diff --git a/test/pseudo-tty/no_interleaved_stdio.js b/test/pseudo-tty/no_interleaved_stdio.js
index 81ba49b9aecb83..072eb1b7460328 100644
--- a/test/pseudo-tty/no_interleaved_stdio.js
+++ b/test/pseudo-tty/no_interleaved_stdio.js
@@ -15,7 +15,10 @@ const err = '__This is some stderr__';
 
 // In AIX, the child exits even before the python parent
 // can setup the readloop. Provide a reasonable delay.
-setTimeout(function() {
-  process.stdout.write(out);
-  process.stderr.write(err);
-}, common.isAIX ? 200 : 0);
+setTimeout(
+  function() {
+    process.stdout.write(out);
+    process.stderr.write(err);
+  },
+  common.isAIX ? 200 : 0
+);
diff --git a/test/pseudo-tty/test-assert-colors.js b/test/pseudo-tty/test-assert-colors.js
index e843bcb218a078..ee1a0724a63f19 100644
--- a/test/pseudo-tty/test-assert-colors.js
+++ b/test/pseudo-tty/test-assert-colors.js
@@ -7,9 +7,10 @@ try {
   process.env.COLORTERM = '1';
   assert.deepStrictEqual([1, 2, 2, 2], [2, 2, 2, 2]);
 } catch (err) {
-  const expected = 'Expected values to be strictly deep-equal:\n' +
+  const expected =
+    'Expected values to be strictly deep-equal:\n' +
     '\u001b[32m+ actual\u001b[39m \u001b[31m- expected\u001b[39m' +
-      ' \u001b[34m...\u001b[39m Lines skipped\n\n' +
+    ' \u001b[34m...\u001b[39m Lines skipped\n\n' +
     '  [\n' +
     '\u001b[32m+\u001b[39m   1,\n' +
     '\u001b[31m-\u001b[39m   2,\n' +
diff --git a/test/pseudo-tty/test-assert-no-color.js b/test/pseudo-tty/test-assert-no-color.js
index 9412cdcc953ad7..6167e58ada1946 100644
--- a/test/pseudo-tty/test-assert-no-color.js
+++ b/test/pseudo-tty/test-assert-no-color.js
@@ -13,7 +13,7 @@ try {
     '\n' +
     '+ {}\n' +
     '- {\n' +
-    '-   foo: \'bar\'\n' +
+    "-   foo: 'bar'\n" +
     '- }';
   assert.strictEqual(error.message, expected);
 }
diff --git a/test/pseudo-tty/test-async-wrap-getasyncid-tty.js b/test/pseudo-tty/test-async-wrap-getasyncid-tty.js
index 80ffe9e7cce303..a33b5ea1ae45d1 100644
--- a/test/pseudo-tty/test-async-wrap-getasyncid-tty.js
+++ b/test/pseudo-tty/test-async-wrap-getasyncid-tty.js
@@ -12,22 +12,26 @@ const providers = { TTYWRAP };
 
 // Make sure that the TTYWRAP Provider is tested.
 {
-  const hooks = require('async_hooks').createHook({
-    init(id, type) {
-      if (type === 'NONE')
-        throw new Error('received a provider type of NONE');
-      delete providers[type];
-    },
-  }).enable();
-  process.on('beforeExit', common.mustCall(() => {
-    process.removeAllListeners('uncaughtException');
-    hooks.disable();
+  const hooks = require('async_hooks')
+    .createHook({
+      init(id, type) {
+        if (type === 'NONE')
+          throw new Error('received a provider type of NONE');
+        delete providers[type];
+      }
+    })
+    .enable();
+  process.on(
+    'beforeExit',
+    common.mustCall(() => {
+      process.removeAllListeners('uncaughtException');
+      hooks.disable();
 
-    const objKeys = Object.keys(providers);
-    if (objKeys.length > 0)
-      process._rawDebug(objKeys);
-    assert.strictEqual(objKeys.length, 0);
-  }));
+      const objKeys = Object.keys(providers);
+      if (objKeys.length > 0) process._rawDebug(objKeys);
+      assert.strictEqual(objKeys.length, 0);
+    })
+  );
 }
 
 function testInitialized(req, ctor_name) {
diff --git a/test/pseudo-tty/test-handle-wrap-isrefed-tty.js b/test/pseudo-tty/test-handle-wrap-isrefed-tty.js
index ca2f1132d093d8..950bce016bfedd 100644
--- a/test/pseudo-tty/test-handle-wrap-isrefed-tty.js
+++ b/test/pseudo-tty/test-handle-wrap-isrefed-tty.js
@@ -10,14 +10,13 @@ const tty = new ReadStream(0);
 const { internalBinding } = require('internal/test/binding');
 const isTTY = internalBinding('tty_wrap').isTTY;
 strictEqual(isTTY(0), true, 'tty_wrap: stdin is not a TTY');
-strictEqual(tty._handle.hasRef(),
-            true, 'tty_wrap: not initially refed');
+strictEqual(tty._handle.hasRef(), true, 'tty_wrap: not initially refed');
 tty.unref();
-strictEqual(tty._handle.hasRef(),
-            false, 'tty_wrap: unref() ineffective');
+strictEqual(tty._handle.hasRef(), false, 'tty_wrap: unref() ineffective');
 tty.ref();
-strictEqual(tty._handle.hasRef(),
-            true, 'tty_wrap: ref() ineffective');
-tty._handle.close(common.mustCall(() =>
-  strictEqual(tty._handle.hasRef(),
-              false, 'tty_wrap: not unrefed on close')));
+strictEqual(tty._handle.hasRef(), true, 'tty_wrap: ref() ineffective');
+tty._handle.close(
+  common.mustCall(() =>
+    strictEqual(tty._handle.hasRef(), false, 'tty_wrap: not unrefed on close')
+  )
+);
diff --git a/test/pseudo-tty/test-readable-tty-keepalive.js b/test/pseudo-tty/test-readable-tty-keepalive.js
index 4cf0b9fb2963f9..8d72b6bcc69087 100644
--- a/test/pseudo-tty/test-readable-tty-keepalive.js
+++ b/test/pseudo-tty/test-readable-tty-keepalive.js
@@ -11,10 +11,13 @@ process.stdin.setEncoding('utf8');
 
 const expectedInput = ['foo', 'bar', null];
 
-process.stdin.on('readable', common.mustCall(function() {
-  const data = process.stdin.read();
-  assert.strictEqual(data, expectedInput.shift());
-}, 3)); // first 2 data, then end
+process.stdin.on(
+  'readable',
+  common.mustCall(function() {
+    const data = process.stdin.read();
+    assert.strictEqual(data, expectedInput.shift());
+  }, 3)
+); // first 2 data, then end
 
 process.stdin.on('end', common.mustCall());
 
diff --git a/test/pseudo-tty/test-set-raw-mode-reset-process-exit.js b/test/pseudo-tty/test-set-raw-mode-reset-process-exit.js
index b6857eaebbdf60..a7d594ab0c9369 100644
--- a/test/pseudo-tty/test-set-raw-mode-reset-process-exit.js
+++ b/test/pseudo-tty/test-set-raw-mode-reset-process-exit.js
@@ -4,9 +4,11 @@ const child_process = require('child_process');
 
 // Tests that exiting through process.exit() resets the TTY mode.
 
-child_process.spawnSync(process.execPath, [
-  '-e', 'process.stdin.setRawMode(true); process.exit(0)'
-], { stdio: 'inherit' });
+child_process.spawnSync(
+  process.execPath,
+  ['-e', 'process.stdin.setRawMode(true); process.exit(0)'],
+  { stdio: 'inherit' }
+);
 
 const { stdout } = child_process.spawnSync('stty', {
   stdio: ['inherit', 'pipe', 'inherit'],
diff --git a/test/pseudo-tty/test-set-raw-mode-reset-signal.js b/test/pseudo-tty/test-set-raw-mode-reset-signal.js
index f953a01331c050..88bf3e6eeb57e6 100644
--- a/test/pseudo-tty/test-set-raw-mode-reset-signal.js
+++ b/test/pseudo-tty/test-set-raw-mode-reset-signal.js
@@ -4,21 +4,29 @@ const child_process = require('child_process');
 
 // Tests that exiting through a catchable signal resets the TTY mode.
 
-const proc = child_process.spawn(process.execPath, [
-  '-e', 'process.stdin.setRawMode(true); console.log("Y"); while(true) {}'
-], { stdio: ['inherit', 'pipe', 'inherit'] });
+const proc = child_process.spawn(
+  process.execPath,
+  ['-e', 'process.stdin.setRawMode(true); console.log("Y"); while(true) {}'],
+  { stdio: ['inherit', 'pipe', 'inherit'] }
+);
 
-proc.stdout.on('data', common.mustCall(() => {
-  proc.kill('SIGINT');
-}));
+proc.stdout.on(
+  'data',
+  common.mustCall(() => {
+    proc.kill('SIGINT');
+  })
+);
 
-proc.on('exit', common.mustCall(() => {
-  const { stdout } = child_process.spawnSync('stty', {
-    stdio: ['inherit', 'pipe', 'inherit'],
-    encoding: 'utf8'
-  });
+proc.on(
+  'exit',
+  common.mustCall(() => {
+    const { stdout } = child_process.spawnSync('stty', {
+      stdio: ['inherit', 'pipe', 'inherit'],
+      encoding: 'utf8'
+    });
 
-  if (stdout.match(/-echo\b/)) {
-    console.log(stdout);
-  }
-}));
+    if (stdout.match(/-echo\b/)) {
+      console.log(stdout);
+    }
+  })
+);
diff --git a/test/pseudo-tty/test-set-raw-mode-reset.js b/test/pseudo-tty/test-set-raw-mode-reset.js
index ab8f1125bfc602..ffb3b4ab79e8ce 100644
--- a/test/pseudo-tty/test-set-raw-mode-reset.js
+++ b/test/pseudo-tty/test-set-raw-mode-reset.js
@@ -5,9 +5,11 @@ const child_process = require('child_process');
 // Tests that exiting through normal means resets the TTY mode.
 // Refs: https://github.com/nodejs/node/issues/21020
 
-child_process.spawnSync(process.execPath, [
-  '-e', 'process.stdin.setRawMode(true)'
-], { stdio: 'inherit' });
+child_process.spawnSync(
+  process.execPath,
+  ['-e', 'process.stdin.setRawMode(true)'],
+  { stdio: 'inherit' }
+);
 
 const { stdout } = child_process.spawnSync('stty', {
   stdio: ['inherit', 'pipe', 'inherit'],
diff --git a/test/pseudo-tty/test-stderr-stdout-handle-sigwinch.js b/test/pseudo-tty/test-stderr-stdout-handle-sigwinch.js
index d5f187d1c3948d..3733121dccf94e 100644
--- a/test/pseudo-tty/test-stderr-stdout-handle-sigwinch.js
+++ b/test/pseudo-tty/test-stderr-stdout-handle-sigwinch.js
@@ -13,22 +13,28 @@ const wrap = (fn, ioStream, string) => {
       fn.call(ioStream);
     } catch (e) {
       // EINVAL happens on SmartOS if emulation is incomplete
-      if (!common.isSunOS || e.code !== 'EINVAL')
-        throw e;
+      if (!common.isSunOS || e.code !== 'EINVAL') throw e;
     }
   });
   return wrapped;
 };
 
-process.stderr._refreshSize = wrap(originalRefreshSizeStderr,
-                                   process.stderr,
-                                   'calling stderr._refreshSize');
-process.stdout._refreshSize = wrap(originalRefreshSizeStdout,
-                                   process.stdout,
-                                   'calling stdout._refreshSize');
+process.stderr._refreshSize = wrap(
+  originalRefreshSizeStderr,
+  process.stderr,
+  'calling stderr._refreshSize'
+);
+process.stdout._refreshSize = wrap(
+  originalRefreshSizeStdout,
+  process.stdout,
+  'calling stdout._refreshSize'
+);
 
 // In AIX, the child exits even before the python parent
 // can setup the readloop. Provide a reasonable delay.
-setTimeout(function() {
-  process.emit('SIGWINCH');
-}, common.isAIX ? 200 : 0);
+setTimeout(
+  function() {
+    process.emit('SIGWINCH');
+  },
+  common.isAIX ? 200 : 0
+);
diff --git a/test/pseudo-tty/test-tty-get-color-depth.js b/test/pseudo-tty/test-tty-get-color-depth.js
index d4062f5fdb6d39..5bca9fb5acfc6c 100644
--- a/test/pseudo-tty/test-tty-get-color-depth.js
+++ b/test/pseudo-tty/test-tty-get-color-depth.js
@@ -40,7 +40,7 @@ const writeStream = new WriteStream(fd);
   [{ TERM: 'fail' }, 1],
   [{ NODE_DISABLE_COLORS: '1' }, 1],
   [{ TERM: 'dumb' }, 1],
-  [{ TERM: 'dumb', COLORTERM: '1' }, 4],
+  [{ TERM: 'dumb', COLORTERM: '1' }, 4]
 ].forEach(([env, depth], i) => {
   const actual = writeStream.getColorDepth(env);
   assert.strictEqual(
@@ -53,8 +53,8 @@ const writeStream = new WriteStream(fd);
 // OS settings
 {
   const platform = Object.getOwnPropertyDescriptor(process, 'platform');
-  const [ value, depth1, depth2 ] = process.platform !== 'win32' ?
-    ['win32', 1, 4] : ['linux', 4, 1];
+  const [value, depth1, depth2] =
+    process.platform !== 'win32' ? ['win32', 1, 4] : ['linux', 4, 1];
 
   assert.strictEqual(writeStream.getColorDepth({}), depth1);
   Object.defineProperty(process, 'platform', { value });
diff --git a/test/pseudo-tty/test-tty-isatty.js b/test/pseudo-tty/test-tty-isatty.js
index 3a7b2940311221..263ed155732f2e 100644
--- a/test/pseudo-tty/test-tty-isatty.js
+++ b/test/pseudo-tty/test-tty-isatty.js
@@ -11,7 +11,10 @@ strictEqual(isatty(2), true, 'stderr reported to not be a tty, but it is');
 strictEqual(isatty(-1), false, '-1 reported to be a tty, but it is not');
 strictEqual(isatty(55555), false, '55555 reported to be a tty, but it is not');
 strictEqual(isatty(1.1), false, '1.1 reported to be a tty, but it is not');
-strictEqual(isatty('1'), false, '\'1\' reported to be a tty, but it is not');
+strictEqual(isatty('1'), false, "'1' reported to be a tty, but it is not");
 strictEqual(isatty({}), false, '{} reported to be a tty, but it is not');
-strictEqual(isatty(() => {}), false,
-            '() => {} reported to be a tty, but it is not');
+strictEqual(
+  isatty(() => {}),
+  false,
+  '() => {} reported to be a tty, but it is not'
+);
diff --git a/test/pseudo-tty/test-tty-stdout-end.js b/test/pseudo-tty/test-tty-stdout-end.js
index 2ec7ca9114db6f..5875a1b28574f5 100644
--- a/test/pseudo-tty/test-tty-stdout-end.js
+++ b/test/pseudo-tty/test-tty-stdout-end.js
@@ -1,10 +1,13 @@
 'use strict';
 const common = require('../common');
 
-process.on('uncaughtException', common.expectsError({
-  code: 'ERR_STDOUT_CLOSE',
-  type: Error,
-  message: 'process.stdout cannot be closed'
-}));
+process.on(
+  'uncaughtException',
+  common.expectsError({
+    code: 'ERR_STDOUT_CLOSE',
+    type: Error,
+    message: 'process.stdout cannot be closed'
+  })
+);
 
 process.stdout.end();
diff --git a/test/pseudo-tty/test-tty-window-size.js b/test/pseudo-tty/test-tty-window-size.js
index 2a9891bd19e68e..bff876c8f7e417 100644
--- a/test/pseudo-tty/test-tty-window-size.js
+++ b/test/pseudo-tty/test-tty-window-size.js
@@ -33,9 +33,12 @@ function monkeyPatchGetWindowSize(fn) {
   // window size from the handle.
   const stream = WriteStream(1);
 
-  stream.on('error', common.mustCall((err) => {
-    assert.strictEqual(err.syscall, 'getWindowSize');
-  }));
+  stream.on(
+    'error',
+    common.mustCall((err) => {
+      assert.strictEqual(err.syscall, 'getWindowSize');
+    })
+  );
 
   monkeyPatchGetWindowSize(function() {
     return -1;
@@ -54,10 +57,13 @@ function monkeyPatchGetWindowSize(fn) {
 
   const stream = WriteStream(1);
 
-  stream.on('resize', common.mustCall(() => {
-    assert.strictEqual(stream.columns, 82);
-    assert.strictEqual(stream.rows, 26);
-  }));
+  stream.on(
+    'resize',
+    common.mustCall(() => {
+      assert.strictEqual(stream.columns, 82);
+      assert.strictEqual(stream.rows, 26);
+    })
+  );
 
   assert.strictEqual(stream.columns, 80);
   assert.strictEqual(stream.rows, 24);
diff --git a/test/pummel/test-abort-fatal-error.js b/test/pummel/test-abort-fatal-error.js
index 176a16c9eac8de..62ea4180259821 100644
--- a/test/pummel/test-abort-fatal-error.js
+++ b/test/pummel/test-abort-fatal-error.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('no RLIMIT_NOFILE on Windows');
+if (common.isWindows) common.skip('no RLIMIT_NOFILE on Windows');
 
 const assert = require('assert');
 const exec = require('child_process').exec;
diff --git a/test/pummel/test-crypto-dh.js b/test/pummel/test-crypto-dh.js
index f64f982c0e1100..eb3320bbcdf1a9 100644
--- a/test/pummel/test-crypto-dh.js
+++ b/test/pummel/test-crypto-dh.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('node compiled without OpenSSL.');
+if (!common.hasCrypto) common.skip('node compiled without OpenSSL.');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -32,26 +31,30 @@ assert.throws(
     crypto.getDiffieHellman('unknown-group');
   },
   /^Error: Unknown group$/,
-  'crypto.getDiffieHellman(\'unknown-group\') ' +
-  'failed to throw the expected error.'
+  "crypto.getDiffieHellman('unknown-group') " +
+    'failed to throw the expected error.'
 );
 assert.throws(
   function() {
     crypto.getDiffieHellman('modp1').setPrivateKey('');
   },
-  new RegExp('^TypeError: crypto\\.getDiffieHellman\\(\\.\\.\\.\\)\\.' +
-  'setPrivateKey is not a function$'),
-  'crypto.getDiffieHellman(\'modp1\').setPrivateKey(\'\') ' +
-  'failed to throw the expected error.'
+  new RegExp(
+    '^TypeError: crypto\\.getDiffieHellman\\(\\.\\.\\.\\)\\.' +
+      'setPrivateKey is not a function$'
+  ),
+  "crypto.getDiffieHellman('modp1').setPrivateKey('') " +
+    'failed to throw the expected error.'
 );
 assert.throws(
   function() {
     crypto.getDiffieHellman('modp1').setPublicKey('');
   },
-  new RegExp('^TypeError: crypto\\.getDiffieHellman\\(\\.\\.\\.\\)\\.' +
-  'setPublicKey is not a function$'),
-  'crypto.getDiffieHellman(\'modp1\').setPublicKey(\'\') ' +
-  'failed to throw the expected error.'
+  new RegExp(
+    '^TypeError: crypto\\.getDiffieHellman\\(\\.\\.\\.\\)\\.' +
+      'setPublicKey is not a function$'
+  ),
+  "crypto.getDiffieHellman('modp1').setPublicKey('') " +
+    'failed to throw the expected error.'
 );
 
 const hashes = {
@@ -69,16 +72,17 @@ for (const name in hashes) {
   const group = crypto.getDiffieHellman(name);
   const private_key = group.getPrime('hex');
   const hash1 = hashes[name];
-  const hash2 = crypto.createHash('sha1')
-                    .update(private_key.toUpperCase()).digest('hex');
+  const hash2 = crypto
+    .createHash('sha1')
+    .update(private_key.toUpperCase())
+    .digest('hex');
   assert.strictEqual(hash1, hash2);
   assert.strictEqual(group.getGenerator('hex'), '02');
 }
 
 for (const name in hashes) {
   // modp1 is 768 bits, FIPS requires >= 1024
-  if (name === 'modp1' && common.hasFipsCrypto)
-    continue;
+  if (name === 'modp1' && common.hasFipsCrypto) continue;
   const group1 = crypto.getDiffieHellman(name);
   const group2 = crypto.getDiffieHellman(name);
   group1.generateKeys();
diff --git a/test/pummel/test-crypto-timing-safe-equal-benchmarks.js b/test/pummel/test-crypto-timing-safe-equal-benchmarks.js
index 0592b9a0d63674..b85d7d1780ad6d 100644
--- a/test/pummel/test-crypto-timing-safe-equal-benchmarks.js
+++ b/test/pummel/test-crypto-timing-safe-equal-benchmarks.js
@@ -1,17 +1,16 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.enoughTestMem)
-  common.skip('memory-intensive test');
+if (!common.enoughTestMem) common.skip('memory-intensive test');
 
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const crypto = require('crypto');
 
-const BENCHMARK_FUNC_PATH =
-  `${fixtures.fixturesDir}/crypto-timing-safe-equal-benchmark-func`;
+const BENCHMARK_FUNC_PATH = `${
+  fixtures.fixturesDir
+}/crypto-timing-safe-equal-benchmark-func`;
 function runOneBenchmark(...args) {
   const benchmarkFunc = require(BENCHMARK_FUNC_PATH);
   const result = benchmarkFunc(...args);
diff --git a/test/pummel/test-dh-regr.js b/test/pummel/test-dh-regr.js
index ff964ec13a47c6..c7db6ff300ebfe 100644
--- a/test/pummel/test-dh-regr.js
+++ b/test/pummel/test-dh-regr.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -43,7 +42,7 @@ for (let i = 0; i < 2000; i++) {
     aSecret,
     bSecret,
     'Secrets should be equal.\n' +
-    `aSecret: ${aSecret.toString('base64')}\n` +
-    `bSecret: ${bSecret.toString('base64')}`
+      `aSecret: ${aSecret.toString('base64')}\n` +
+      `bSecret: ${bSecret.toString('base64')}`
   );
 }
diff --git a/test/pummel/test-dtrace-jsstack.js b/test/pummel/test-dtrace-jsstack.js
index dc70354ee84a5d..a394b13a6d3b85 100644
--- a/test/pummel/test-dtrace-jsstack.js
+++ b/test/pummel/test-dtrace-jsstack.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.isSunOS)
-  common.skip('no DTRACE support');
+if (!common.isSunOS) common.skip('no DTRACE support');
 
 const assert = require('assert');
 const os = require('os');
@@ -30,7 +29,7 @@ const os = require('os');
 /*
  * Some functions to create a recognizable stack.
  */
-const frames = [ 'stalloogle', 'bagnoogle', 'doogle' ];
+const frames = ['stalloogle', 'bagnoogle', 'doogle'];
 
 const stalloogle = (str) => {
   global.expected = str;
@@ -44,8 +43,7 @@ const bagnoogle = (arg0, arg1) => {
 let done = false;
 
 const doogle = () => {
-  if (!done)
-    setTimeout(doogle, 10);
+  if (!done) setTimeout(doogle, 10);
 
   bagnoogle('The bfs command', '(almost) like ed(1)');
 };
@@ -57,8 +55,12 @@ const spawn = require('child_process').spawn;
  * when we call getloadavg() -- with the implicit assumption that our
  * deepest function is the only caller of os.loadavg().
  */
-const dtrace = spawn('dtrace', [ '-qwn', `syscall::getloadavg:entry/pid == ${
-  process.pid}/{ustack(100, 8192); exit(0); }` ]);
+const dtrace = spawn('dtrace', [
+  '-qwn',
+  `syscall::getloadavg:entry/pid == ${
+    process.pid
+  }/{ustack(100, 8192); exit(0); }`
+]);
 
 let output = '';
 
@@ -84,18 +86,19 @@ dtrace.on('exit', function(code) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
 
-    if (!line.includes(sentinel) || frames.length === 0)
-      continue;
+    if (!line.includes(sentinel) || frames.length === 0) continue;
 
     const frame = line.substr(line.indexOf(sentinel) + sentinel.length);
     const top = frames.shift();
 
-    assert(frame.startsWith(top),
-           `unexpected frame where ${top} was expected`);
+    assert(frame.startsWith(top), `unexpected frame where ${top} was expected`);
   }
 
-  assert.strictEqual(frames.length, 0,
-                     `did not find expected frame ${frames[0]}`);
+  assert.strictEqual(
+    frames.length,
+    0,
+    `did not find expected frame ${frames[0]}`
+  );
   process.exit(0);
 });
 
diff --git a/test/pummel/test-exec.js b/test/pummel/test-exec.js
index 7d631f87f2f74a..2bd5f739e20426 100644
--- a/test/pummel/test-exec.js
+++ b/test/pummel/test-exec.js
@@ -34,27 +34,25 @@ if (!common.isWindows) {
   SLEEP3_COMMAND = 'cmd /c choice /t 3 /c X /d X';
 }
 
-
 let success_count = 0;
 let error_count = 0;
 
-
-exec(
-  `"${process.execPath}" -p -e process.versions`,
-  function(err, stdout, stderr) {
-    if (err) {
-      error_count++;
-      console.log(`error!: ${err.code}`);
-      console.log(`stdout: ${JSON.stringify(stdout)}`);
-      console.log(`stderr: ${JSON.stringify(stderr)}`);
-      assert.strictEqual(err.killed, false);
-    } else {
-      success_count++;
-      console.dir(stdout);
-    }
+exec(`"${process.execPath}" -p -e process.versions`, function(
+  err,
+  stdout,
+  stderr
+) {
+  if (err) {
+    error_count++;
+    console.log(`error!: ${err.code}`);
+    console.log(`stdout: ${JSON.stringify(stdout)}`);
+    console.log(`stderr: ${JSON.stringify(stderr)}`);
+    assert.strictEqual(err.killed, false);
+  } else {
+    success_count++;
+    console.dir(stdout);
   }
-);
-
+});
 
 exec('thisisnotavalidcommand', function(err, stdout, stderr) {
   if (err) {
@@ -75,10 +73,9 @@ exec('thisisnotavalidcommand', function(err, stdout, stderr) {
   }
 });
 
-
 const sleeperStart = new Date();
 exec(SLEEP3_COMMAND, { timeout: 50 }, function(err, stdout, stderr) {
-  const diff = (new Date()) - sleeperStart;
+  const diff = new Date() - sleeperStart;
   console.log(`'sleep 3' with timeout 50 took ${diff} ms`);
   assert.ok(diff < 500);
   assert.ok(err);
@@ -88,10 +85,12 @@ exec(SLEEP3_COMMAND, { timeout: 50 }, function(err, stdout, stderr) {
   assert.strictEqual(stderr, '');
 });
 
-
 const startSleep3 = new Date();
-const killMeTwice = exec(SLEEP3_COMMAND, { timeout: 1000 },
-                         killMeTwiceCallback);
+const killMeTwice = exec(
+  SLEEP3_COMMAND,
+  { timeout: 1000 },
+  killMeTwiceCallback
+);
 
 process.nextTick(function() {
   console.log(`kill pid ${killMeTwice.pid}`);
@@ -103,7 +102,7 @@ process.nextTick(function() {
 });
 
 function killMeTwiceCallback(err, stdout, stderr) {
-  const diff = (new Date()) - startSleep3;
+  const diff = new Date() - startSleep3;
   // We should have already killed this process. Assert that the timeout still
   // works and that we are getting the proper callback parameters.
   assert.ok(err);
@@ -117,15 +116,16 @@ function killMeTwiceCallback(err, stdout, stderr) {
   assert.ok(diff < 1500);
 }
 
-
-exec('python -c "print 200000*\'C\'"', { maxBuffer: 1000 },
-     function(err, stdout, stderr) {
-       assert.ok(err);
-       assert.ok(/maxBuffer/.test(err.message));
-       assert.strictEqual(stdout, '');
-       assert.strictEqual(stderr, '');
-     });
-
+exec('python -c "print 200000*\'C\'"', { maxBuffer: 1000 }, function(
+  err,
+  stdout,
+  stderr
+) {
+  assert.ok(err);
+  assert.ok(/maxBuffer/.test(err.message));
+  assert.strictEqual(stdout, '');
+  assert.strictEqual(stderr, '');
+});
 
 process.on('exit', function() {
   assert.strictEqual(success_count, 1);
diff --git a/test/pummel/test-fs-watch-file.js b/test/pummel/test-fs-watch-file.js
index d8694418e9eea5..cc2f4c3819465c 100644
--- a/test/pummel/test-fs-watch-file.js
+++ b/test/pummel/test-fs-watch-file.js
@@ -56,7 +56,6 @@ process.on('exit', function() {
   assert.strictEqual(watchSeenFour, 1);
 });
 
-
 fs.writeFileSync(filepathOne, 'hello');
 
 assert.throws(
@@ -78,7 +77,6 @@ setTimeout(function() {
   fs.writeFileSync(filepathOne, 'world');
 }, 1000);
 
-
 process.chdir(testDir);
 
 fs.writeFileSync(filepathTwoAbs, 'howdy');
@@ -92,7 +90,8 @@ assert.throws(
   }
 );
 
-{ // Does not throw.
+{
+  // Does not throw.
   function a() {
     fs.unwatchFile(filepathTwo, a);
     ++watchSeenTwo;
@@ -109,7 +108,8 @@ setTimeout(function() {
   fs.writeFileSync(filepathTwoAbs, 'pardner');
 }, 1000);
 
-{ // Does not throw.
+{
+  // Does not throw.
   function b() {
     fs.unwatchFile(filenameThree, b);
     ++watchSeenThree;
@@ -131,7 +131,8 @@ setTimeout(function() {
   fs.writeFileSync(filenameFour, 'hey');
 }, 500);
 
-{ // Does not throw.
+{
+  // Does not throw.
   function a() {
     ++watchSeenFour;
     assert.strictEqual(watchSeenFour, 1);
diff --git a/test/pummel/test-fs-watch-non-recursive.js b/test/pummel/test-fs-watch-non-recursive.js
index da11b423a686e0..b970155a986ed6 100644
--- a/test/pummel/test-fs-watch-non-recursive.js
+++ b/test/pummel/test-fs-watch-non-recursive.js
@@ -31,13 +31,19 @@ const testsubdir = path.join(testDir, 'testsubdir');
 const filepath = path.join(testsubdir, 'watch.txt');
 
 function cleanup() {
-  try { fs.unlinkSync(filepath); } catch { }
-  try { fs.rmdirSync(testsubdir); } catch { }
+  try {
+    fs.unlinkSync(filepath);
+  } catch {}
+  try {
+    fs.rmdirSync(testsubdir);
+  } catch {}
 }
 process.on('exit', cleanup);
 cleanup();
 
-try { fs.mkdirSync(testsubdir, 0o700); } catch {}
+try {
+  fs.mkdirSync(testsubdir, 0o700);
+} catch {}
 
 // Need a grace period, else the mkdirSync() above fires off an event.
 setTimeout(function() {
diff --git a/test/pummel/test-fs-watch-system-limit.js b/test/pummel/test-fs-watch-system-limit.js
index 8b9cb62ad0a007..9acf5092772d7b 100644
--- a/test/pummel/test-fs-watch-system-limit.js
+++ b/test/pummel/test-fs-watch-system-limit.js
@@ -5,18 +5,16 @@ const child_process = require('child_process');
 const fs = require('fs');
 const stream = require('stream');
 
-if (!common.isLinux)
-  common.skip('The fs watch limit is OS-dependent');
-if (!common.enoughTestCpu)
-  common.skip('This test is resource-intensive');
+if (!common.isLinux) common.skip('The fs watch limit is OS-dependent');
+if (!common.enoughTestCpu) common.skip('This test is resource-intensive');
 
 try {
   // Ensure inotify limit is low enough for the test to actually exercise the
   // limit with small enough resources.
   const limit = Number(
-    fs.readFileSync('/proc/sys/fs/inotify/max_user_watches', 'utf8'));
-  if (limit > 16384)
-    common.skip('inotify limit is quite large');
+    fs.readFileSync('/proc/sys/fs/inotify/max_user_watches', 'utf8')
+  );
+  if (limit > 16384) common.skip('inotify limit is quite large');
 } catch (e) {
   if (e.code === 'ENOENT')
     common.skip('the inotify /proc subsystem does not exist');
@@ -34,34 +32,40 @@ function spawnProcesses() {
   for (let i = 0; i < 10; ++i) {
     const proc = child_process.spawn(
       process.execPath,
-      [ '-e',
+      [
+        '-e',
         `process.chdir(${JSON.stringify(__dirname)});
         for (const file of fs.readdirSync('.'))
           fs.watch(file, () => {});`
-      ], { stdio: ['inherit', 'inherit', 'pipe'] });
+      ],
+      { stdio: ['inherit', 'inherit', 'pipe'] }
+    );
     proc.stderr.pipe(gatherStderr);
     processes.push(proc);
   }
 
   setTimeout(() => {
-    if (!finished && processes.length < 200)
-      spawnProcesses();
+    if (!finished && processes.length < 200) spawnProcesses();
   }, 100);
 }
 
 spawnProcesses();
 
 let accumulated = '';
-gatherStderr.on('data', common.mustCallAtLeast((chunk) => {
-  accumulated += chunk;
-  if (accumulated.includes('Error:') && !finished) {
-    assert(
-      accumulated.includes('ENOSPC: System limit for number ' +
-                           'of file watchers reached') ||
-      accumulated.includes('EMFILE: '),
-      accumulated);
-    console.log(`done after ${processes.length} processes, cleaning up`);
-    finished = true;
-    processes.forEach((proc) => proc.kill());
-  }
-}, 1));
+gatherStderr.on(
+  'data',
+  common.mustCallAtLeast((chunk) => {
+    accumulated += chunk;
+    if (accumulated.includes('Error:') && !finished) {
+      assert(
+        accumulated.includes(
+          'ENOSPC: System limit for number ' + 'of file watchers reached'
+        ) || accumulated.includes('EMFILE: '),
+        accumulated
+      );
+      console.log(`done after ${processes.length} processes, cleaning up`);
+      finished = true;
+      processes.forEach((proc) => proc.kill());
+    }
+  }, 1)
+);
diff --git a/test/pummel/test-http-client-reconnect-bug.js b/test/pummel/test-http-client-reconnect-bug.js
index d3e540166c27a7..167581535b3b51 100644
--- a/test/pummel/test-http-client-reconnect-bug.js
+++ b/test/pummel/test-http-client-reconnect-bug.js
@@ -28,18 +28,21 @@ const server = net.createServer(function(socket) {
   socket.end();
 });
 
-server.on('listening', common.mustCall(function() {
-  const client = http.createClient(common.PORT);
+server.on(
+  'listening',
+  common.mustCall(function() {
+    const client = http.createClient(common.PORT);
 
-  client.on('error', common.mustCall());
-  client.on('end', common.mustCall());
+    client.on('error', common.mustCall());
+    client.on('end', common.mustCall());
 
-  const request = client.request('GET', '/', { 'host': 'localhost' });
-  request.end();
-  request.on('response', function(response) {
-    console.log(`STATUS: ${response.statusCode}`);
-  });
-}));
+    const request = client.request('GET', '/', { host: 'localhost' });
+    request.end();
+    request.on('response', function(response) {
+      console.log(`STATUS: ${response.statusCode}`);
+    });
+  })
+);
 
 server.listen(common.PORT);
 
diff --git a/test/pummel/test-http-many-keep-alive-connections.js b/test/pummel/test-http-many-keep-alive-connections.js
index cb9f9946844912..aae8b39c4ce8c2 100644
--- a/test/pummel/test-http-many-keep-alive-connections.js
+++ b/test/pummel/test-http-many-keep-alive-connections.js
@@ -41,25 +41,30 @@ server.once('connection', function(c) {
 });
 
 server.listen(common.PORT, function connect() {
-  const request = http.get({
-    port: common.PORT,
-    path: '/',
-    headers: {
-      'Connection': 'Keep-alive'
-    }
-  }, function(res) {
-    res.on('end', function() {
-      if (++responses < expected) {
-        connect();
-      } else {
-        server.close();
+  const request = http
+    .get(
+      {
+        port: common.PORT,
+        path: '/',
+        headers: {
+          Connection: 'Keep-alive'
+        }
+      },
+      function(res) {
+        res.on('end', function() {
+          if (++responses < expected) {
+            connect();
+          } else {
+            server.close();
+          }
+        });
+        res.resume();
       }
+    )
+    .on('error', function(e) {
+      console.log(e.message);
+      process.exit(1);
     });
-    res.resume();
-  }).on('error', function(e) {
-    console.log(e.message);
-    process.exit(1);
-  });
   request.agent.maxSockets = 1;
 });
 
diff --git a/test/pummel/test-https-ci-reneg-attack.js b/test/pummel/test-https-ci-reneg-attack.js
index 9411d24e077097..02a3a294e1af00 100644
--- a/test/pummel/test-https-ci-reneg-attack.js
+++ b/test/pummel/test-https-ci-reneg-attack.js
@@ -21,11 +21,9 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
@@ -66,7 +64,7 @@ function test(next) {
   });
 
   server.listen(common.PORT, function() {
-    const args = (`s_client -connect 127.0.0.1:${common.PORT}`).split(' ');
+    const args = `s_client -connect 127.0.0.1:${common.PORT}`.split(' ');
     const child = spawn(common.opensslCli, args);
 
     child.stdout.resume();
@@ -78,9 +76,9 @@ function test(next) {
 
     child.stderr.on('data', function(data) {
       if (seenError) return;
-      handshakes += ((String(data)).match(/verify return:1/g) || []).length;
+      handshakes += (String(data).match(/verify return:1/g) || []).length;
       if (handshakes === 2) spam();
-      renegs += ((String(data)).match(/RENEGOTIATING/g) || []).length;
+      renegs += (String(data).match(/RENEGOTIATING/g) || []).length;
     });
 
     child.on('exit', function() {
diff --git a/test/pummel/test-https-large-response.js b/test/pummel/test-https-large-response.js
index d72fd2a65ba877..179218db77c0b1 100644
--- a/test/pummel/test-https-large-response.js
+++ b/test/pummel/test-https-large-response.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -37,36 +36,48 @@ process.stdout.write('build body...');
 const body = 'hello world\n'.repeat(1024 * 1024);
 process.stdout.write('done\n');
 
-const server = https.createServer(options, common.mustCall(function(req, res) {
-  console.log('got request');
-  res.writeHead(200, { 'content-type': 'text/plain' });
-  res.end(body);
-}));
+const server = https.createServer(
+  options,
+  common.mustCall(function(req, res) {
+    console.log('got request');
+    res.writeHead(200, { 'content-type': 'text/plain' });
+    res.end(body);
+  })
+);
 
-server.listen(common.PORT, common.mustCall(function() {
-  https.get({
-    port: common.PORT,
-    rejectUnauthorized: false
-  }, common.mustCall(function(res) {
-    console.log('response!');
+server.listen(
+  common.PORT,
+  common.mustCall(function() {
+    https.get(
+      {
+        port: common.PORT,
+        rejectUnauthorized: false
+      },
+      common.mustCall(function(res) {
+        console.log('response!');
 
-    let count = 0;
+        let count = 0;
 
-    res.on('data', function(d) {
-      process.stdout.write('.');
-      count += d.length;
-      res.pause();
-      process.nextTick(function() {
-        res.resume();
-      });
-    });
+        res.on('data', function(d) {
+          process.stdout.write('.');
+          count += d.length;
+          res.pause();
+          process.nextTick(function() {
+            res.resume();
+          });
+        });
 
-    res.on('end', common.mustCall(function(d) {
-      process.stdout.write('\n');
-      console.log('expected: ', body.length);
-      console.log('     got: ', count);
-      server.close();
-      assert.strictEqual(count, body.length);
-    }));
-  }));
-}));
+        res.on(
+          'end',
+          common.mustCall(function(d) {
+            process.stdout.write('\n');
+            console.log('expected: ', body.length);
+            console.log('     got: ', count);
+            server.close();
+            assert.strictEqual(count, body.length);
+          })
+        );
+      })
+    );
+  })
+);
diff --git a/test/pummel/test-https-no-reader.js b/test/pummel/test-https-no-reader.js
index ad0b56c1f3c7b1..d1fe0d0b36b695 100644
--- a/test/pummel/test-https-no-reader.js
+++ b/test/pummel/test-https-no-reader.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -44,19 +43,22 @@ const server = https.createServer(options, function(req, res) {
 });
 
 server.listen(common.PORT, function() {
-  const req = https.request({
-    method: 'POST',
-    port: common.PORT,
-    rejectUnauthorized: false
-  }, function(res) {
-    res.read(0);
+  const req = https.request(
+    {
+      method: 'POST',
+      port: common.PORT,
+      rejectUnauthorized: false
+    },
+    function(res) {
+      res.read(0);
 
-    setTimeout(function() {
-      // Read buffer should be somewhere near high watermark
-      // (i.e. should not leak)
-      assert(res.readableLength < 100 * 1024);
-      process.exit(0);
-    }, 2000);
-  });
+      setTimeout(function() {
+        // Read buffer should be somewhere near high watermark
+        // (i.e. should not leak)
+        assert(res.readableLength < 100 * 1024);
+        process.exit(0);
+      }, 2000);
+    }
+  );
   req.end();
 });
diff --git a/test/pummel/test-keep-alive.js b/test/pummel/test-keep-alive.js
index b62d731c7b4006..5881098f3eedfd 100644
--- a/test/pummel/test-keep-alive.js
+++ b/test/pummel/test-keep-alive.js
@@ -23,8 +23,7 @@
 
 // This test requires the program 'wrk'
 const common = require('../common');
-if (common.isWindows)
-  common.skip('no `wrk` on windows');
+if (common.isWindows) common.skip('no `wrk` on windows');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
@@ -44,12 +43,14 @@ const server = http.createServer(function(req, res) {
 let keepAliveReqSec = 0;
 let normalReqSec = 0;
 
-
 function runAb(opts, callback) {
   const args = [
-    '-c', opts.concurrent || 100,
-    '-t', opts.threads || 2,
-    '-d', opts.duration || '10s',
+    '-c',
+    opts.concurrent || 100,
+    '-t',
+    opts.threads || 2,
+    '-d',
+    opts.duration || '10s'
   ];
 
   if (!opts.keepalive) {
@@ -57,8 +58,9 @@ function runAb(opts, callback) {
     args.push('Connection: close');
   }
 
-  args.push(url.format({ hostname: '127.0.0.1',
-                         port: common.PORT, protocol: 'http' }));
+  args.push(
+    url.format({ hostname: '127.0.0.1', port: common.PORT, protocol: 'http' })
+  );
 
   const child = spawn('wrk', args);
   child.stderr.pipe(process.stderr);
@@ -118,6 +120,6 @@ process.on('exit', function() {
     normalReqSec < keepAliveReqSec,
     true,
     'normalReqSec should be less than keepAliveReqSec, ' +
-    `but ${normalReqSec} is greater than ${keepAliveReqSec}`
+      `but ${normalReqSec} is greater than ${keepAliveReqSec}`
   );
 });
diff --git a/test/pummel/test-net-pause.js b/test/pummel/test-net-pause.js
index ea0e61264e32db..789e28faca37d2 100644
--- a/test/pummel/test-net-pause.js
+++ b/test/pummel/test-net-pause.js
@@ -69,13 +69,9 @@ server.on('listening', function() {
           console.log(`resume at: ${chars_recved}`);
           assert.strictEqual(chars_recved, recv.length);
           client.resume();
-
         }, 500);
-
       }, 500);
-
     }, 500);
-
   }, 500);
 
   client.on('end', function() {
diff --git a/test/pummel/test-net-pingpong-delay.js b/test/pummel/test-net-pingpong-delay.js
index 392a6e0fed751e..b3004f23e0b1d4 100644
--- a/test/pummel/test-net-pingpong-delay.js
+++ b/test/pummel/test-net-pingpong-delay.js
@@ -63,45 +63,52 @@ function pingPongTest(port, host, on_complete) {
     });
   });
 
-  server.listen(port, host, common.mustCall(function() {
-    const client = net.createConnection(port, host);
+  server.listen(
+    port,
+    host,
+    common.mustCall(function() {
+      const client = net.createConnection(port, host);
 
-    client.setEncoding('utf8');
+      client.setEncoding('utf8');
 
-    client.on('connect', function() {
-      assert.strictEqual(client.readyState, 'open');
-      client.write('PING');
-    });
-
-    client.on('data', function(data) {
-      console.log(data);
-      assert.strictEqual(data, 'PONG');
-      assert.strictEqual(client.readyState, 'open');
+      client.on('connect', function() {
+        assert.strictEqual(client.readyState, 'open');
+        client.write('PING');
+      });
 
-      setTimeout(function() {
+      client.on('data', function(data) {
+        console.log(data);
+        assert.strictEqual(data, 'PONG');
         assert.strictEqual(client.readyState, 'open');
-        if (count++ < N) {
-          client.write('PING');
-        } else {
-          console.log('closing client');
-          client.end();
-          client_ended = true;
-        }
-      }, DELAY);
-    });
 
-    client.on('timeout', function() {
-      console.error('client-side timeout!!');
-      assert.strictEqual(false, true);
-    });
+        setTimeout(function() {
+          assert.strictEqual(client.readyState, 'open');
+          if (count++ < N) {
+            client.write('PING');
+          } else {
+            console.log('closing client');
+            client.end();
+            client_ended = true;
+          }
+        }, DELAY);
+      });
+
+      client.on('timeout', function() {
+        console.error('client-side timeout!!');
+        assert.strictEqual(false, true);
+      });
 
-    client.on('close', common.mustCall(function() {
-      console.log('client.end');
-      assert.strictEqual(count, N + 1);
-      assert.ok(client_ended);
-      if (on_complete) on_complete();
-    }));
-  }));
+      client.on(
+        'close',
+        common.mustCall(function() {
+          console.log('client.end');
+          assert.strictEqual(count, N + 1);
+          assert.ok(client_ended);
+          if (on_complete) on_complete();
+        })
+      );
+    })
+  );
 }
 
 pingPongTest(common.PORT);
diff --git a/test/pummel/test-net-throttle.js b/test/pummel/test-net-throttle.js
index fb060c9d76d9d5..9300a3bf7c3889 100644
--- a/test/pummel/test-net-throttle.js
+++ b/test/pummel/test-net-throttle.js
@@ -39,8 +39,7 @@ const server = net.createServer(function(connection) {
   connection.write(body.slice(part_N, 2 * part_N));
   assert.strictEqual(connection.write(body.slice(2 * part_N, N)), false);
   console.log(`bufferSize: ${connection.bufferSize}`, 'expecting', N);
-  assert.ok(connection.bufferSize >= 0 &&
-            connection.writableLength <= N);
+  assert.ok(connection.bufferSize >= 0 && connection.writableLength <= N);
   connection.end();
 });
 
@@ -72,7 +71,6 @@ server.listen(common.PORT, function() {
   });
 });
 
-
 process.on('exit', function() {
   assert.strictEqual(chars_recved, N);
   assert.strictEqual(npauses > 2, true);
diff --git a/test/pummel/test-net-timeout.js b/test/pummel/test-net-timeout.js
index e87cdc0b8edf51..d26d0068dd1b62 100644
--- a/test/pummel/test-net-timeout.js
+++ b/test/pummel/test-net-timeout.js
@@ -41,7 +41,8 @@ const echo_server = net.createServer(function(socket) {
 
   socket.on('error', function(e) {
     throw new Error(
-      'Server side socket should not get error. We disconnect willingly.');
+      'Server side socket should not get error. We disconnect willingly.'
+    );
   });
 
   socket.on('data', function(d) {
diff --git a/test/pummel/test-net-timeout2.js b/test/pummel/test-net-timeout2.js
index 93fbe7bfab36cb..42edeba2e208ee 100644
--- a/test/pummel/test-net-timeout2.js
+++ b/test/pummel/test-net-timeout2.js
@@ -47,7 +47,6 @@ const server = net.createServer(function(socket) {
   }, 1000);
 });
 
-
 server.listen(common.PORT, function() {
   const s = net.connect(common.PORT);
   s.pipe(process.stdout);
diff --git a/test/pummel/test-net-write-callbacks.js b/test/pummel/test-net-write-callbacks.js
index a4a6096d633165..0037ab7b44fbce 100644
--- a/test/pummel/test-net-write-callbacks.js
+++ b/test/pummel/test-net-write-callbacks.js
@@ -43,12 +43,12 @@ let lastCalled = -1;
 function makeCallback(c) {
   let called = false;
   return function() {
-    if (called)
-      throw new Error(`called callback #${c} more than once`);
+    if (called) throw new Error(`called callback #${c} more than once`);
     called = true;
     if (c < lastCalled) {
       throw new Error(
-        `callbacks out of order. last=${lastCalled} current=${c}`);
+        `callbacks out of order. last=${lastCalled} current=${c}`
+      );
     }
     lastCalled = c;
     cbcount++;
diff --git a/test/pummel/test-next-tick-infinite-calls.js b/test/pummel/test-next-tick-infinite-calls.js
index 5ee44076dcc2f3..ef6548271a221e 100644
--- a/test/pummel/test-next-tick-infinite-calls.js
+++ b/test/pummel/test-next-tick-infinite-calls.js
@@ -28,9 +28,8 @@ let complete = 0;
 //  FATAL ERROR: JS Allocation failed - process out of memory
 // if the depth counter doesn't clear the nextTickQueue properly.
 (function runner() {
-  if (++complete < 1e8)
-    process.nextTick(runner);
-}());
+  if (++complete < 1e8) process.nextTick(runner);
+})();
 
 setImmediate(function() {
   console.log('ok');
diff --git a/test/pummel/test-regress-GH-814.js b/test/pummel/test-regress-GH-814.js
index d7af574e0ab87e..bdc9e5fedbec6a 100644
--- a/test/pummel/test-regress-GH-814.js
+++ b/test/pummel/test-regress-GH-814.js
@@ -41,13 +41,11 @@ const testFileName = require('path').join(tmpdir.path, 'GH-814_testFile.txt');
 const testFileFD = fs.openSync(testFileName, 'w');
 console.log(testFileName);
 
-
 const kBufSize = 128 * 1024;
 let PASS = true;
 const neverWrittenBuffer = newBuffer(kBufSize, 0x2e); // 0x2e === '.'
 const bufPool = [];
 
-
 const tail = require('child_process').spawn('tail', ['-f', testFileName]);
 tail.stdout.on('data', tailCB);
 
@@ -55,10 +53,8 @@ function tailCB(data) {
   PASS = !data.toString().includes('.');
 }
 
-
 const timeToQuit = Date.now() + 8e3; // Test during no more than this seconds.
 (function main() {
-
   if (PASS) {
     fs.write(testFileFD, newBuffer(kBufSize, 0x61), 0, kBufSize, -1, cb);
     global.gc();
@@ -77,10 +73,8 @@ const timeToQuit = Date.now() + 8e3; // Test during no more than this seconds.
     tail.kill();
     console.log("Buffer GC'ed test -> PASS (OK)");
   }
-
 })();
 
-
 function cb(err, written) {
   assert.ifError(err);
 }
diff --git a/test/pummel/test-regress-GH-814_2.js b/test/pummel/test-regress-GH-814_2.js
index 1b40ca7b37cdfa..487407b762fe8b 100644
--- a/test/pummel/test-regress-GH-814_2.js
+++ b/test/pummel/test-regress-GH-814_2.js
@@ -31,7 +31,6 @@ const testFileName = require('path').join(tmpdir.path, 'GH-814_test.txt');
 const testFD = fs.openSync(testFileName, 'w');
 console.error(`${testFileName}\n`);
 
-
 const tailProc = require('child_process').spawn('tail', ['-f', testFileName]);
 tailProc.stdout.on('data', tailCB);
 
@@ -46,7 +45,6 @@ function tailCB(data) {
   }
 }
 
-
 let PASS = true;
 const bufPool = [];
 const kBufSize = 16 * 1024 * 1024;
@@ -56,7 +54,6 @@ const timeToQuit = Date.now() + 5e3; // Test should last no more than this.
 writer();
 
 function writer() {
-
   if (PASS) {
     if (Date.now() > timeToQuit) {
       setTimeout(function() {
@@ -79,17 +76,14 @@ function writer() {
       process.nextTick(writer);
     }
   }
-
 }
 
 function writerCB(err, written) {
   assert.ifError(err);
 }
 
-
 // ******************* UTILITIES
 
-
 function newBuffer(size, value) {
   const buffer = Buffer.allocUnsafe(size);
   while (size--) {
diff --git a/test/pummel/test-regress-GH-892.js b/test/pummel/test-regress-GH-892.js
index 48201807e39e56..bb5961664db271 100644
--- a/test/pummel/test-regress-GH-892.js
+++ b/test/pummel/test-regress-GH-892.js
@@ -27,8 +27,7 @@
 // TLS server causes the child process to exit cleanly before having sent
 // the entire buffer.
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
@@ -51,9 +50,11 @@ function makeRequest() {
   // process.execArgv to track down nextTick recursion errors
   // more easily.  Also, this is handy when using this test to
   // view V8 opt/deopt behavior.
-  const args = process.execArgv.concat([ childScript,
-                                         common.PORT,
-                                         bytesExpected ]);
+  const args = process.execArgv.concat([
+    childScript,
+    common.PORT,
+    bytesExpected
+  ]);
 
   const child = spawn(process.execPath, args);
 
@@ -67,7 +68,6 @@ function makeRequest() {
   child.stderr.pipe(process.stderr);
   child.stdout.pipe(process.stdout);
 
-
   // Buffer the stderr so that we can check that it got 'DONE'
   child.stderr.setEncoding('ascii');
   child.stderr.on('data', function(d) {
@@ -75,7 +75,6 @@ function makeRequest() {
   });
 }
 
-
 const serverOptions = {
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
diff --git a/test/pummel/test-stream-pipe-multi.js b/test/pummel/test-stream-pipe-multi.js
index c89d9cc6353713..e467e141d8833e 100644
--- a/test/pummel/test-stream-pipe-multi.js
+++ b/test/pummel/test-stream-pipe-multi.js
@@ -63,7 +63,6 @@ FakeStream.prototype.close = function() {
   this.emit('close');
 };
 
-
 // expect all streams to close properly.
 process.on('exit', function() {
   assert.strictEqual(cnt, wclosed);
diff --git a/test/pummel/test-timers.js b/test/pummel/test-timers.js
index a6766b7a33c11d..1799453ecab2ca 100644
--- a/test/pummel/test-timers.js
+++ b/test/pummel/test-timers.js
@@ -33,18 +33,23 @@ clearInterval(null);
 
 assert.strictEqual(setTimeout instanceof Function, true);
 const starttime = new Date();
-setTimeout(common.mustCall(function() {
-  const endtime = new Date();
+setTimeout(
+  common.mustCall(function() {
+    const endtime = new Date();
 
-  const diff = endtime - starttime;
-  assert.ok(diff > 0);
-  console.error(`diff: ${diff}`);
+    const diff = endtime - starttime;
+    assert.ok(diff > 0);
+    console.error(`diff: ${diff}`);
 
-  assert.strictEqual(1000 - WINDOW < diff && diff < 1000 + WINDOW, true);
-}), 1000);
+    assert.strictEqual(1000 - WINDOW < diff && diff < 1000 + WINDOW, true);
+  }),
+  1000
+);
 
 // this timer shouldn't execute
-const id = setTimeout(function() { assert.strictEqual(true, false); }, 500);
+const id = setTimeout(function() {
+  assert.strictEqual(true, false);
+}, 500);
 clearTimeout(id);
 
 setInterval(function() {
@@ -60,41 +65,54 @@ setInterval(function() {
   assert.strictEqual(t - WINDOW < diff && diff < t + WINDOW, true);
 
   assert.strictEqual(interval_count <= 3, true);
-  if (interval_count === 3)
-    clearInterval(this);
+  if (interval_count === 3) clearInterval(this);
 }, 1000);
 
-
 // Single param:
-setTimeout(function(param) {
-  assert.strictEqual(param, 'test param');
-}, 1000, 'test param');
+setTimeout(
+  function(param) {
+    assert.strictEqual(param, 'test param');
+  },
+  1000,
+  'test param'
+);
 
 let interval_count2 = 0;
-setInterval(function(param) {
-  ++interval_count2;
-  assert.strictEqual(param, 'test param');
-
-  if (interval_count2 === 3)
-    clearInterval(this);
-}, 1000, 'test param');
+setInterval(
+  function(param) {
+    ++interval_count2;
+    assert.strictEqual(param, 'test param');
 
+    if (interval_count2 === 3) clearInterval(this);
+  },
+  1000,
+  'test param'
+);
 
 // Multiple param
-setTimeout(function(param1, param2) {
-  assert.strictEqual(param1, 'param1');
-  assert.strictEqual(param2, 'param2');
-}, 1000, 'param1', 'param2');
+setTimeout(
+  function(param1, param2) {
+    assert.strictEqual(param1, 'param1');
+    assert.strictEqual(param2, 'param2');
+  },
+  1000,
+  'param1',
+  'param2'
+);
 
 let interval_count3 = 0;
-setInterval(function(param1, param2) {
-  ++interval_count3;
-  assert.strictEqual(param1, 'param1');
-  assert.strictEqual(param2, 'param2');
-
-  if (interval_count3 === 3)
-    clearInterval(this);
-}, 1000, 'param1', 'param2');
+setInterval(
+  function(param1, param2) {
+    ++interval_count3;
+    assert.strictEqual(param1, 'param1');
+    assert.strictEqual(param2, 'param2');
+
+    if (interval_count3 === 3) clearInterval(this);
+  },
+  1000,
+  'param1',
+  'param2'
+);
 
 // setInterval(cb, 0) should be called multiple times.
 let count4 = 0;
@@ -102,7 +120,6 @@ const interval4 = setInterval(function() {
   if (++count4 > 10) clearInterval(interval4);
 }, 0);
 
-
 // we should be able to clearTimeout multiple times without breakage.
 let expectedTimeouts = 3;
 
@@ -118,7 +135,6 @@ clearTimeout(y);
 setTimeout(t, 200);
 clearTimeout(y);
 
-
 process.on('exit', function() {
   assert.strictEqual(interval_count, 3);
   assert.strictEqual(count4, 11);
diff --git a/test/pummel/test-tls-ci-reneg-attack.js b/test/pummel/test-tls-ci-reneg-attack.js
index 528ebe4516c71d..e23d03b46850e6 100644
--- a/test/pummel/test-tls-ci-reneg-attack.js
+++ b/test/pummel/test-tls-ci-reneg-attack.js
@@ -21,11 +21,9 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
@@ -64,7 +62,7 @@ function test(next) {
   });
 
   server.listen(common.PORT, function() {
-    const args = (`s_client -connect 127.0.0.1:${common.PORT}`).split(' ');
+    const args = `s_client -connect 127.0.0.1:${common.PORT}`.split(' ');
     const child = spawn(common.opensslCli, args);
 
     child.stdout.resume();
@@ -76,9 +74,9 @@ function test(next) {
 
     child.stderr.on('data', function(data) {
       if (seenError) return;
-      handshakes += ((String(data)).match(/verify return:1/g) || []).length;
+      handshakes += (String(data).match(/verify return:1/g) || []).length;
       if (handshakes === 2) spam();
-      renegs += ((String(data)).match(/RENEGOTIATING/g) || []).length;
+      renegs += (String(data).match(/RENEGOTIATING/g) || []).length;
     });
 
     child.on('exit', function() {
diff --git a/test/pummel/test-tls-securepair-client.js b/test/pummel/test-tls-securepair-client.js
index 09006228c25564..0170be0061a139 100644
--- a/test/pummel/test-tls-securepair-client.js
+++ b/test/pummel/test-tls-securepair-client.js
@@ -23,11 +23,9 @@
 
 const common = require('../common');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const net = require('net');
 const assert = require('assert');
@@ -46,10 +44,14 @@ function test1() {
 function test2() {
   function check(pair) {
     // "TLS Web Client Authentication"
-    assert.strictEqual(pair.cleartext.getPeerCertificate().ext_key_usage.length,
-                       1);
-    assert.strictEqual(pair.cleartext.getPeerCertificate().ext_key_usage[0],
-                       '1.3.6.1.5.5.7.3.2');
+    assert.strictEqual(
+      pair.cleartext.getPeerCertificate().ext_key_usage.length,
+      1
+    );
+    assert.strictEqual(
+      pair.cleartext.getPeerCertificate().ext_key_usage[0],
+      '1.3.6.1.5.5.7.3.2'
+    );
   }
   test('keys/agent4-key.pem', 'keys/agent4-cert.pem', check);
 }
@@ -58,14 +60,18 @@ function test(keyfn, certfn, check, next) {
   const key = fixtures.readSync(keyfn).toString();
   const cert = fixtures.readSync(certfn).toString();
 
-  const server = spawn(common.opensslCli, ['s_server',
-                                           '-accept', common.PORT,
-                                           '-cert', certfn,
-                                           '-key', keyfn]);
+  const server = spawn(common.opensslCli, [
+    's_server',
+    '-accept',
+    common.PORT,
+    '-cert',
+    certfn,
+    '-key',
+    keyfn
+  ]);
   server.stdout.pipe(process.stdout);
   server.stderr.pipe(process.stdout);
 
-
   let state = 'WAIT-ACCEPT';
 
   let serverStdoutBuffer = '';
@@ -84,7 +90,6 @@ function test(keyfn, certfn, check, next) {
 
       case 'WAIT-HELLO':
         if (/hello/.test(serverStdoutBuffer)) {
-
           // End the current SSL connection and exit.
           // See s_server(1ssl).
           server.stdin.write('Q');
@@ -98,7 +103,6 @@ function test(keyfn, certfn, check, next) {
     }
   });
 
-
   const timeout = setTimeout(function() {
     server.kill();
     process.exit(1);
@@ -113,7 +117,6 @@ function test(keyfn, certfn, check, next) {
     if (next) next();
   });
 
-
   function startClient() {
     const s = new net.Stream();
 
@@ -136,10 +139,14 @@ function test(keyfn, certfn, check, next) {
 
     pair.on('secure', function() {
       console.log('client: connected+secure!');
-      console.log('client pair.cleartext.getPeerCertificate(): %j',
-                  pair.cleartext.getPeerCertificate());
-      console.log('client pair.cleartext.getCipher(): %j',
-                  pair.cleartext.getCipher());
+      console.log(
+        'client pair.cleartext.getPeerCertificate(): %j',
+        pair.cleartext.getPeerCertificate()
+      );
+      console.log(
+        'client pair.cleartext.getCipher(): %j',
+        pair.cleartext.getCipher()
+      );
       if (check) check(pair);
       setTimeout(function() {
         pair.cleartext.write('hello\r\n', function() {
@@ -169,7 +176,6 @@ function test(keyfn, certfn, check, next) {
     });
   }
 
-
   process.on('exit', function() {
     assert.strictEqual(serverExitCode, 0);
     assert.strictEqual(state, 'WAIT-SERVER-CLOSE');
diff --git a/test/pummel/test-tls-server-large-request.js b/test/pummel/test-tls-server-large-request.js
index 5d3a0615bad6e2..3678e7f6070def 100644
--- a/test/pummel/test-tls-server-large-request.js
+++ b/test/pummel/test-tls-server-large-request.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -55,15 +54,24 @@ class Mediator extends stream.Writable {
 
 const mediator = new Mediator();
 
-const server = tls.Server(options, common.mustCall(function(socket) {
-  socket.pipe(mediator);
-}));
+const server = tls.Server(
+  options,
+  common.mustCall(function(socket) {
+    socket.pipe(mediator);
+  })
+);
 
-server.listen(common.PORT, common.mustCall(function() {
-  const client1 = tls.connect({
-    port: common.PORT,
-    rejectUnauthorized: false
-  }, common.mustCall(function() {
-    client1.end(request);
-  }));
-}));
+server.listen(
+  common.PORT,
+  common.mustCall(function() {
+    const client1 = tls.connect(
+      {
+        port: common.PORT,
+        rejectUnauthorized: false
+      },
+      common.mustCall(function() {
+        client1.end(request);
+      })
+    );
+  })
+);
diff --git a/test/pummel/test-tls-session-timeout.js b/test/pummel/test-tls-session-timeout.js
index 49c38102fc5c5c..004541a34cb50c 100644
--- a/test/pummel/test-tls-session-timeout.js
+++ b/test/pummel/test-tls-session-timeout.js
@@ -22,11 +22,9 @@
 'use strict';
 const common = require('../common');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
+if (!common.opensslCli) common.skip('node compiled without OpenSSL CLI.');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tmpdir = require('../common/tmpdir');
 
@@ -70,16 +68,19 @@ function doTest() {
     const tmpPath = join(tmpdir.path, ticketFileName);
     fs.writeFileSync(tmpPath, fixtures.readSync(ticketFileName));
     return tmpPath;
-  }());
+  })();
 
   // Expects a callback -- cb(connectionType : enum ['New'|'Reused'])
 
   function Client(cb) {
     const flags = [
       's_client',
-      '-connect', `localhost:${common.PORT}`,
-      '-sess_in', sessionFileName,
-      '-sess_out', sessionFileName
+      '-connect',
+      `localhost:${common.PORT}`,
+      '-sess_in',
+      sessionFileName,
+      '-sess_out',
+      sessionFileName
     ];
     const client = spawn(common.opensslCli, flags, {
       stdio: ['ignore', 'pipe', 'ignore']
@@ -108,8 +109,7 @@ function doTest() {
 
   const server = tls.createServer(options, function(cleartext) {
     cleartext.on('error', function(er) {
-      if (er.code !== 'ECONNRESET')
-        throw er;
+      if (er.code !== 'ECONNRESET') throw er;
     });
     cleartext.end();
   });
diff --git a/test/pummel/test-tls-throttle.js b/test/pummel/test-tls-throttle.js
index af588dfa91fb94..0a42162e5f3f03 100644
--- a/test/pummel/test-tls-throttle.js
+++ b/test/pummel/test-tls-throttle.js
@@ -24,8 +24,7 @@
 // seconds. Makes sure that pause and resume work properly.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const tls = require('tls');
@@ -40,9 +39,12 @@ const options = {
   cert: fixtures.readKey('agent2-cert.pem')
 };
 
-const server = tls.Server(options, common.mustCall(function(socket) {
-  socket.end(body);
-}));
+const server = tls.Server(
+  options,
+  common.mustCall(function(socket) {
+    socket.end(body);
+  })
+);
 
 let recvCount = 0;
 
@@ -62,7 +64,6 @@ server.listen(common.PORT, function() {
     });
   });
 
-
   client.on('close', function() {
     console.error('close');
     server.close();
@@ -70,16 +71,13 @@ server.listen(common.PORT, function() {
   });
 });
 
-
 function displayCounts() {
   console.log(`body.length: ${body.length}`);
   console.log(`  recvCount: ${recvCount}`);
 }
 
-
 const timeout = setTimeout(displayCounts, 10 * 1000);
 
-
 process.on('exit', function() {
   displayCounts();
   assert.strictEqual(body.length, recvCount);
diff --git a/test/pummel/test-vm-memleak.js b/test/pummel/test-vm-memleak.js
index 94e4055a767096..467016e9bbe276 100644
--- a/test/pummel/test-vm-memleak.js
+++ b/test/pummel/test-vm-memleak.js
@@ -37,8 +37,7 @@ assert(ok, 'Run this test with --max_old_space_size=32.');
 const interval = setInterval(function() {
   try {
     vm.runInNewContext('throw 1;');
-  } catch {
-  }
+  } catch {}
 
   const rss = process.memoryUsage().rss;
   maxMem = Math.max(rss, maxMem);
@@ -52,8 +51,7 @@ const interval = setInterval(function() {
 }, 1);
 
 function testContextLeak() {
-  for (let i = 0; i < 1000; i++)
-    vm.createContext({});
+  for (let i = 0; i < 1000; i++) vm.createContext({});
 }
 
 process.on('exit', function() {
diff --git a/test/pummel/test-watch-file.js b/test/pummel/test-watch-file.js
index 4a7282052065d6..1caeb94b2df46e 100644
--- a/test/pummel/test-watch-file.js
+++ b/test/pummel/test-watch-file.js
@@ -41,7 +41,6 @@ function watchFile() {
 
 watchFile();
 
-
 const fd = fs.openSync(f, 'w+');
 fs.writeSync(fd, 'xyz\n');
 fs.closeSync(fd);
diff --git a/test/sequential/test-async-wrap-getasyncid.js b/test/sequential/test-async-wrap-getasyncid.js
index 16868de5585d1d..6f5a875b3599d8 100644
--- a/test/sequential/test-async-wrap-getasyncid.js
+++ b/test/sequential/test-async-wrap-getasyncid.js
@@ -14,45 +14,48 @@ const { getSystemErrorName } = require('util');
 
 // Make sure that all Providers are tested.
 {
-  const hooks = require('async_hooks').createHook({
-    init(id, type) {
-      if (type === 'NONE')
-        throw new Error('received a provider type of NONE');
-      delete providers[type];
-    },
-  }).enable();
-  process.on('beforeExit', common.mustCall(() => {
-    // This garbage collection call verifies that the wraps being garbage
-    // collected doesn't resurrect the process again due to weirdly timed
-    // uv_close calls and other similar instruments in destructors.
-    global.gc();
-
-    process.removeAllListeners('uncaughtException');
-    hooks.disable();
-    delete providers.NONE;  // Should never be used.
-
-    // See test/pseudo-tty/test-async-wrap-getasyncid-tty.js
-    // Requires an 'actual' tty fd to be available.
-    delete providers.TTYWRAP;
-
-    // TODO(jasnell): Test for these
-    delete providers.HTTP2SESSION;
-    delete providers.HTTP2STREAM;
-    delete providers.HTTP2PING;
-    delete providers.HTTP2SETTINGS;
-    // TODO(addaleax): Test for these
-    delete providers.STREAMPIPE;
-    delete providers.MESSAGEPORT;
-    delete providers.WORKER;
-    if (!common.isMainThread)
-      delete providers.INSPECTORJSBINDING;
-    delete providers.KEYPAIRGENREQUEST;
-
-    const objKeys = Object.keys(providers);
-    if (objKeys.length > 0)
-      process._rawDebug(objKeys);
-    assert.strictEqual(objKeys.length, 0);
-  }));
+  const hooks = require('async_hooks')
+    .createHook({
+      init(id, type) {
+        if (type === 'NONE')
+          throw new Error('received a provider type of NONE');
+        delete providers[type];
+      }
+    })
+    .enable();
+  process.on(
+    'beforeExit',
+    common.mustCall(() => {
+      // This garbage collection call verifies that the wraps being garbage
+      // collected doesn't resurrect the process again due to weirdly timed
+      // uv_close calls and other similar instruments in destructors.
+      global.gc();
+
+      process.removeAllListeners('uncaughtException');
+      hooks.disable();
+      delete providers.NONE; // Should never be used.
+
+      // See test/pseudo-tty/test-async-wrap-getasyncid-tty.js
+      // Requires an 'actual' tty fd to be available.
+      delete providers.TTYWRAP;
+
+      // TODO(jasnell): Test for these
+      delete providers.HTTP2SESSION;
+      delete providers.HTTP2STREAM;
+      delete providers.HTTP2PING;
+      delete providers.HTTP2SETTINGS;
+      // TODO(addaleax): Test for these
+      delete providers.STREAMPIPE;
+      delete providers.MESSAGEPORT;
+      delete providers.WORKER;
+      if (!common.isMainThread) delete providers.INSPECTORJSBINDING;
+      delete providers.KEYPAIRGENREQUEST;
+
+      const objKeys = Object.keys(providers);
+      if (objKeys.length > 0) process._rawDebug(objKeys);
+      assert.strictEqual(objKeys.length, 0);
+    })
+  );
 }
 
 function testUninitialized(req, ctor_name) {
@@ -68,7 +71,6 @@ function testInitialized(req, ctor_name) {
   assert.strictEqual(req.constructor.name, ctor_name);
 }
 
-
 {
   const cares = internalBinding('cares_wrap');
   const dns = require('dns');
@@ -87,19 +89,16 @@ function testInitialized(req, ctor_name) {
   resolver.cancel();
 }
 
-
 {
   const FSEvent = internalBinding('fs_event_wrap').FSEvent;
   testInitialized(new FSEvent(), 'FSEvent');
 }
 
-
 {
   const JSStream = internalBinding('js_stream').JSStream;
   testInitialized(new JSStream(), 'JSStream');
 }
 
-
 {
   // We don't want to expose getAsyncId for promises but we need to construct
   // one so that the corresponding provider type is removed from the
@@ -107,8 +106,8 @@ function testInitialized(req, ctor_name) {
   new Promise((res) => res(5));
 }
 
-
-if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
+if (common.hasCrypto) {
+  // eslint-disable-line node-core/crypto-check
   const crypto = require('crypto');
 
   // The handle for PBKDF2 and RandomBytes isn't returned by the function call,
@@ -119,25 +118,32 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
   });
   crypto.pbkdf2('password', 'salt', 1, 20, 'sha256', mc);
 
-  crypto.randomBytes(1, common.mustCall(function rb() {
-    testInitialized(this, 'AsyncWrap');
-  }));
+  crypto.randomBytes(
+    1,
+    common.mustCall(function rb() {
+      testInitialized(this, 'AsyncWrap');
+    })
+  );
 
   if (typeof internalBinding('crypto').scrypt === 'function') {
-    crypto.scrypt('password', 'salt', 8, common.mustCall(function() {
-      testInitialized(this, 'AsyncWrap');
-    }));
+    crypto.scrypt(
+      'password',
+      'salt',
+      8,
+      common.mustCall(function() {
+        testInitialized(this, 'AsyncWrap');
+      })
+    );
   }
 }
 
-
 {
   const binding = internalBinding('fs');
   const path = require('path');
 
   const FSReqCallback = binding.FSReqCallback;
   const req = new FSReqCallback();
-  req.oncomplete = () => { };
+  req.oncomplete = () => {};
 
   testInitialized(req, 'FSReqCallback');
   binding.access(path.toNamespacedPath('../'), fs.F_OK, req);
@@ -146,13 +152,11 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
   testInitialized(new StatWatcher(), 'StatWatcher');
 }
 
-
 {
   const { HTTPParser } = internalBinding('http_parser');
   testInitialized(new HTTPParser(HTTPParser.REQUEST), 'HTTPParser');
 }
 
-
 {
   const Gzip = require('zlib').Gzip;
   testInitialized(new Gzip()._handle, 'Zlib');
@@ -167,19 +171,30 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
 {
   tmpdir.refresh();
 
-  const server = net.createServer(common.mustCall((socket) => {
-    server.close();
-  })).listen(common.PIPE, common.mustCall(() => {
-    const binding = internalBinding('pipe_wrap');
-    const handle = new binding.Pipe(binding.constants.SOCKET);
-    testInitialized(handle, 'Pipe');
-    const req = new binding.PipeConnectWrap();
-    testUninitialized(req, 'PipeConnectWrap');
-    req.address = common.PIPE;
-    req.oncomplete = common.mustCall(() => handle.close());
-    handle.connect(req, req.address, req.oncomplete);
-    testInitialized(req, 'PipeConnectWrap');
-  }));
+  const server = net
+    .createServer(
+      common.mustCall((socket) => {
+        server.close();
+      })
+    )
+    .listen(
+      common.PIPE,
+      common.mustCall(() => {
+        const binding = internalBinding('pipe_wrap');
+        const handle = new binding.Pipe(binding.constants.SOCKET);
+        testInitialized(handle, 'Pipe');
+        const req = new binding.PipeConnectWrap();
+        testUninitialized(req, 'PipeConnectWrap');
+        req.address = common.PIPE;
+        req.oncomplete = common.mustCall(() => handle.close());
+        handle.connect(
+          req,
+          req.address,
+          req.oncomplete
+        );
+        testInitialized(req, 'PipeConnectWrap');
+      })
+    );
 }
 
 {
@@ -209,54 +224,65 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
 {
   const stream_wrap = internalBinding('stream_wrap');
   const tcp_wrap = internalBinding('tcp_wrap');
-  const server = net.createServer(common.mustCall((socket) => {
-    server.close();
-    socket.on('data', () => {
-      socket.end();
-      socket.destroy();
-    });
-    socket.resume();
-  })).listen(0, common.localhostIPv4, common.mustCall(() => {
-    const handle = new tcp_wrap.TCP(tcp_wrap.constants.SOCKET);
-    const req = new tcp_wrap.TCPConnectWrap();
-    const sreq = new stream_wrap.ShutdownWrap();
-    testInitialized(handle, 'TCP');
-    testUninitialized(req, 'TCPConnectWrap');
-    testUninitialized(sreq, 'ShutdownWrap');
-
-    sreq.oncomplete = common.mustCall(() => {
-      handle.close();
-    });
-
-    req.oncomplete = common.mustCall(writeData);
-    function writeData() {
-      const wreq = new stream_wrap.WriteWrap();
-      wreq.handle = handle;
-      wreq.oncomplete = () => {
-        handle.shutdown(sreq);
-        testInitialized(sreq, 'ShutdownWrap');
-      };
-      const err = handle.writeLatin1String(wreq, 'hi'.repeat(100000));
-      if (err)
-        throw new Error(`write failed: ${getSystemErrorName(err)}`);
-      if (!stream_wrap.streamBaseState[stream_wrap.kLastWriteWasAsync]) {
-        testUninitialized(wreq, 'WriteWrap');
-        // Synchronous finish. Write more data until we hit an
-        // asynchronous write.
-        return writeData();
-      }
-      testInitialized(wreq, 'WriteWrap');
-    }
-    req.address = common.localhostIPv4;
-    req.port = server.address().port;
-    const err = handle.connect(req, req.address, req.port);
-    assert.strictEqual(err, 0);
-    testInitialized(req, 'TCPConnectWrap');
-  }));
+  const server = net
+    .createServer(
+      common.mustCall((socket) => {
+        server.close();
+        socket.on('data', () => {
+          socket.end();
+          socket.destroy();
+        });
+        socket.resume();
+      })
+    )
+    .listen(
+      0,
+      common.localhostIPv4,
+      common.mustCall(() => {
+        const handle = new tcp_wrap.TCP(tcp_wrap.constants.SOCKET);
+        const req = new tcp_wrap.TCPConnectWrap();
+        const sreq = new stream_wrap.ShutdownWrap();
+        testInitialized(handle, 'TCP');
+        testUninitialized(req, 'TCPConnectWrap');
+        testUninitialized(sreq, 'ShutdownWrap');
+
+        sreq.oncomplete = common.mustCall(() => {
+          handle.close();
+        });
+
+        req.oncomplete = common.mustCall(writeData);
+        function writeData() {
+          const wreq = new stream_wrap.WriteWrap();
+          wreq.handle = handle;
+          wreq.oncomplete = () => {
+            handle.shutdown(sreq);
+            testInitialized(sreq, 'ShutdownWrap');
+          };
+          const err = handle.writeLatin1String(wreq, 'hi'.repeat(100000));
+          if (err) throw new Error(`write failed: ${getSystemErrorName(err)}`);
+          if (!stream_wrap.streamBaseState[stream_wrap.kLastWriteWasAsync]) {
+            testUninitialized(wreq, 'WriteWrap');
+            // Synchronous finish. Write more data until we hit an
+            // asynchronous write.
+            return writeData();
+          }
+          testInitialized(wreq, 'WriteWrap');
+        }
+        req.address = common.localhostIPv4;
+        req.port = server.address().port;
+        const err = handle.connect(
+          req,
+          req.address,
+          req.port
+        );
+        assert.strictEqual(err, 0);
+        testInitialized(req, 'TCPConnectWrap');
+      })
+    );
 }
 
-
-if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
+if (common.hasCrypto) {
+  // eslint-disable-line node-core/crypto-check
   const { TCP, constants: TCPConstants } = internalBinding('tcp_wrap');
   const tcp = new TCP(TCPConstants.SOCKET);
 
@@ -269,7 +295,9 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
   // TLSWrap is exposed, but needs to be instantiated via tls_wrap.wrap().
   const tls_wrap = internalBinding('tls_wrap');
   testInitialized(
-    tls_wrap.wrap(tcp._externalStream, credentials.context, true), 'TLSWrap');
+    tls_wrap.wrap(tcp._externalStream, credentials.context, true),
+    'TLSWrap'
+  );
 }
 
 {
@@ -289,8 +317,7 @@ if (common.hasCrypto) { // eslint-disable-line node-core/crypto-check
   testInitialized(req, 'SendWrap');
 }
 
-if (process.config.variables.v8_enable_inspector !== 0 &&
-    common.isMainThread) {
+if (process.config.variables.v8_enable_inspector !== 0 && common.isMainThread) {
   const binding = process.binding('inspector');
   const handle = new binding.Connection(() => {});
   testInitialized(handle, 'Connection');
diff --git a/test/sequential/test-child-process-emfile.js b/test/sequential/test-child-process-emfile.js
index e81b3a0ffec9cb..0063706ddc4c57 100644
--- a/test/sequential/test-child-process-emfile.js
+++ b/test/sequential/test-child-process-emfile.js
@@ -21,8 +21,7 @@
 
 'use strict';
 const common = require('../common');
-if (common.isWindows)
-  common.skip('no RLIMIT_NOFILE on Windows');
+if (common.isWindows) common.skip('no RLIMIT_NOFILE on Windows');
 
 const assert = require('assert');
 const child_process = require('child_process');
@@ -33,10 +32,10 @@ if (ulimit > 64 || Number.isNaN(ulimit)) {
   // Sorry about this nonsense. It can be replaced if
   // https://github.com/nodejs/node-v0.x-archive/pull/2143#issuecomment-2847886
   // ever happens.
-  const result = child_process.spawnSync(
-    '/bin/sh',
-    ['-c', `ulimit -n 64 && '${process.execPath}' '${__filename}'`]
-  );
+  const result = child_process.spawnSync('/bin/sh', [
+    '-c',
+    `ulimit -n 64 && '${process.execPath}' '${__filename}'`
+  ]);
   assert.strictEqual(result.stdout.toString(), '');
   assert.strictEqual(result.stderr.toString(), '');
   assert.strictEqual(result.status, 0);
@@ -58,9 +57,12 @@ for (;;) {
 // Should emit an error, not throw.
 const proc = child_process.spawn(process.execPath, ['-e', '0']);
 
-proc.on('error', common.mustCall(function(err) {
-  assert.strictEqual(err.code, 'EMFILE');
-}));
+proc.on(
+  'error',
+  common.mustCall(function(err) {
+    assert.strictEqual(err.code, 'EMFILE');
+  })
+);
 
 proc.on('exit', common.mustNotCall('"exit" event should not be emitted'));
 
diff --git a/test/sequential/test-child-process-execsync.js b/test/sequential/test-child-process-execsync.js
index 8e4200dbe972b0..493c6829d70d2d 100644
--- a/test/sequential/test-child-process-execsync.js
+++ b/test/sequential/test-child-process-execsync.js
@@ -34,14 +34,12 @@ let err;
 let caught = false;
 
 // Verify that stderr is not accessed when a bad shell is used
-assert.throws(
-  function() { execSync('exit -1', { shell: 'bad_shell' }); },
-  /spawnSync bad_shell ENOENT/
-);
-assert.throws(
-  function() { execFileSync('exit -1', { shell: 'bad_shell' }); },
-  /spawnSync bad_shell ENOENT/
-);
+assert.throws(function() {
+  execSync('exit -1', { shell: 'bad_shell' });
+}, /spawnSync bad_shell ENOENT/);
+assert.throws(function() {
+  execFileSync('exit -1', { shell: 'bad_shell' });
+}, /spawnSync bad_shell ENOENT/);
 
 let cmd, ret;
 try {
@@ -52,8 +50,11 @@ try {
   assert.strictEqual(e.errno, 'ETIMEDOUT');
   err = e;
 } finally {
-  assert.strictEqual(ret, undefined,
-                     `should not have a return value, received ${ret}`);
+  assert.strictEqual(
+    ret,
+    undefined,
+    `should not have a return value, received ${ret}`
+  );
   assert.ok(caught, 'execSync should throw');
   const end = Date.now() - start;
   assert(end < SLEEP);
@@ -80,10 +81,7 @@ ret = execSync(cmd, { encoding: 'utf8' });
 
 assert.strictEqual(ret, `${msg}\n`);
 
-const args = [
-  '-e',
-  `console.log("${msg}");`
-];
+const args = ['-e', `console.log("${msg}");`];
 ret = execFileSync(process.execPath, args);
 
 assert.deepStrictEqual(ret, msgBuf);
@@ -124,21 +122,24 @@ assert.strictEqual(ret, `${msg}\n`);
     'stdout'
   ]);
 
-  assert.throws(() => {
-    execFileSync(process.execPath, args);
-  }, (err) => {
-    const msg = `Command failed: ${process.execPath} ${args.join(' ')}`;
-
-    assert(err instanceof Error);
-    assert.strictEqual(err.message, msg);
-    assert.strictEqual(err.status, 1);
-    assert.strictEqual(typeof err.pid, 'number');
-    spawnSyncKeys.forEach((key) => {
-      if (key === 'pid') return;
-      assert.deepStrictEqual(err[key], spawnSyncResult[key]);
-    });
-    return true;
-  });
+  assert.throws(
+    () => {
+      execFileSync(process.execPath, args);
+    },
+    (err) => {
+      const msg = `Command failed: ${process.execPath} ${args.join(' ')}`;
+
+      assert(err instanceof Error);
+      assert.strictEqual(err.message, msg);
+      assert.strictEqual(err.status, 1);
+      assert.strictEqual(typeof err.pid, 'number');
+      spawnSyncKeys.forEach((key) => {
+        if (key === 'pid') return;
+        assert.deepStrictEqual(err[key], spawnSyncResult[key]);
+      });
+      return true;
+    }
+  );
 }
 
 // Verify the shell option works properly
diff --git a/test/sequential/test-child-process-exit.js b/test/sequential/test-child-process-exit.js
index 64e188fbf87efc..fe0a4a69746c58 100644
--- a/test/sequential/test-child-process-exit.js
+++ b/test/sequential/test-child-process-exit.js
@@ -33,14 +33,13 @@ const ch = require('child_process');
 const gen = +(process.argv[2] || 0);
 const maxGen = 5;
 
-
 if (gen === maxGen) {
   console.error('hit maxGen, exiting', maxGen);
   return;
 }
 
 const child = ch.spawn(process.execPath, [__filename, gen + 1], {
-  stdio: [ 'ignore', 'pipe', 'ignore' ]
+  stdio: ['ignore', 'pipe', 'ignore']
 });
 assert.ok(!child.stdin);
 assert.ok(child.stdout);
diff --git a/test/sequential/test-child-process-fork-getconnections.js b/test/sequential/test-child-process-fork-getconnections.js
index 9a8f97c2bb2842..4916ba02d2c9df 100644
--- a/test/sequential/test-child-process-fork-getconnections.js
+++ b/test/sequential/test-child-process-fork-getconnections.js
@@ -53,13 +53,11 @@ if (process.argv[2] === 'child') {
       }
     }
   });
-
 } else {
   const child = fork(process.argv[1], ['child']);
 
   child.on('exit', function(code, signal) {
-    if (!subprocessKilled)
-      throw new Error('subprocess died unexpectedly!');
+    if (!subprocessKilled) throw new Error('subprocess died unexpectedly!');
   });
 
   const server = net.createServer();
@@ -79,7 +77,10 @@ if (process.argv[2] === 'child') {
   server.on('listening', function() {
     let j = count;
     while (j--) {
-      const client = net.connect(common.PORT, '127.0.0.1');
+      const client = net.connect(
+        common.PORT,
+        '127.0.0.1'
+      );
       client.on('close', function() {
         disconnected += 1;
       });
diff --git a/test/sequential/test-child-process-pass-fd.js b/test/sequential/test-child-process-pass-fd.js
index 98832c57a3df67..864a40eeda57bc 100644
--- a/test/sequential/test-child-process-pass-fd.js
+++ b/test/sequential/test-child-process-pass-fd.js
@@ -9,8 +9,10 @@ const common = require('../common');
 // This test is basically `test-cluster-net-send` but creating lots of workers
 // so the issue reproduces on OS X consistently.
 
-if ((process.config.variables.arm_version === '6') ||
-    (process.config.variables.arm_version === '7'))
+if (
+  process.config.variables.arm_version === '6' ||
+  process.config.variables.arm_version === '7'
+)
   common.skip('Too slow for armv6 and armv7 bots');
 
 const assert = require('assert');
@@ -28,9 +30,12 @@ function forkWorker() {
     worker.send('got');
 
     let recvData = '';
-    handle.on('data', common.mustCall((data) => {
-      recvData += data;
-    }));
+    handle.on(
+      'data',
+      common.mustCall((data) => {
+        recvData += data;
+      })
+    );
 
     handle.on('end', () => {
       assert.strictEqual(recvData, 'hello');
@@ -53,13 +58,14 @@ if (process.argv[2] !== 'child') {
   for (let i = 0; i < N; ++i) {
     forkWorker();
   }
-  process.on('exit', () => { assert.strictEqual(messageCallbackCount, N); });
+  process.on('exit', () => {
+    assert.strictEqual(messageCallbackCount, N);
+  });
 } else {
   let socket;
   let cbcalls = 0;
   function socketConnected() {
-    if (++cbcalls === 2)
-      process.send('handle', socket);
+    if (++cbcalls === 2) process.send('handle', socket);
   }
 
   // As a side-effect, listening for the message event will ref the IPC channel,
@@ -70,15 +76,23 @@ if (process.argv[2] !== 'child') {
   // thus no work to do, and will exit immediately, preventing process leaks.
   process.on('message', common.mustCall());
 
-  const server = net.createServer((c) => {
-    process.once('message', (msg) => {
-      assert.strictEqual(msg, 'got');
-      c.end('hello');
-    });
-    socketConnected();
-  }).unref();
+  const server = net
+    .createServer((c) => {
+      process.once('message', (msg) => {
+        assert.strictEqual(msg, 'got');
+        c.end('hello');
+      });
+      socketConnected();
+    })
+    .unref();
   server.listen(0, common.localhostIPv4, () => {
     const { port } = server.address();
-    socket = net.connect(port, common.localhostIPv4, socketConnected).unref();
+    socket = net
+      .connect(
+        port,
+        common.localhostIPv4,
+        socketConnected
+      )
+      .unref();
   });
 }
diff --git a/test/sequential/test-cluster-inspect-brk.js b/test/sequential/test-cluster-inspect-brk.js
index 95c9b3c51177e1..98d60eb3769ad1 100644
--- a/test/sequential/test-cluster-inspect-brk.js
+++ b/test/sequential/test-cluster-inspect-brk.js
@@ -11,7 +11,6 @@ const debuggerPort = common.PORT;
 
 if (cluster.isMaster) {
   function test(execArgv) {
-
     cluster.setupMaster({
       execArgv: execArgv,
       stdio: ['pipe', 'pipe', 'pipe', 'ipc', 'pipe']
@@ -20,13 +19,19 @@ if (cluster.isMaster) {
     const worker = cluster.fork();
 
     // Debugger listening on port [port].
-    worker.process.stderr.once('data', common.mustCall(function() {
-      worker.process.kill('SIGTERM');
-    }));
-
-    worker.process.on('exit', common.mustCall(function(code, signal) {
-      assert.strictEqual(signal, 'SIGTERM');
-    }));
+    worker.process.stderr.once(
+      'data',
+      common.mustCall(function() {
+        worker.process.kill('SIGTERM');
+      })
+    );
+
+    worker.process.on(
+      'exit',
+      common.mustCall(function(code, signal) {
+        assert.strictEqual(signal, 'SIGTERM');
+      })
+    );
   }
 
   test(['--inspect-brk']);
diff --git a/test/sequential/test-cluster-send-handle-large-payload.js b/test/sequential/test-cluster-send-handle-large-payload.js
index f0ffa63421bff6..b47738f36c1554 100644
--- a/test/sequential/test-cluster-send-handle-large-payload.js
+++ b/test/sequential/test-cluster-send-handle-large-payload.js
@@ -10,45 +10,63 @@ const payload = 'a'.repeat(800004);
 if (cluster.isMaster) {
   const server = net.createServer();
 
-  server.on('connection', common.mustCall((socket) => { socket.unref(); }));
+  server.on(
+    'connection',
+    common.mustCall((socket) => {
+      socket.unref();
+    })
+  );
 
   const worker = cluster.fork();
-  worker.on('message', common.mustCall(({ payload: received }, handle) => {
-    assert.strictEqual(payload, received);
-    assert(handle instanceof net.Socket);
-    server.close();
-    handle.destroy();
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    const port = server.address().port;
-    const socket = new net.Socket();
-    socket.connect(port, (err) => {
-      assert.ifError(err);
-      worker.send({ payload }, socket);
-    });
-  }));
+  worker.on(
+    'message',
+    common.mustCall(({ payload: received }, handle) => {
+      assert.strictEqual(payload, received);
+      assert(handle instanceof net.Socket);
+      server.close();
+      handle.destroy();
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const port = server.address().port;
+      const socket = new net.Socket();
+      socket.connect(
+        port,
+        (err) => {
+          assert.ifError(err);
+          worker.send({ payload }, socket);
+        }
+      );
+    })
+  );
 } else {
-  process.on('message', common.mustCall(({ payload: received }, handle) => {
-    assert.strictEqual(payload, received);
-    assert(handle instanceof net.Socket);
-
-    // On macOS, the parent process might not receive a message if it is sent
-    // to soon, and then subsequent messages are also sometimes not received.
-    //
-    // (Is this a bug or expected operating system behavior like the way a file
-    // watcher is returned before it's actually watching the file system on
-    // macOS?)
-    //
-    // Send a second message after a delay on macOS.
-    //
-    // Refs: https://github.com/nodejs/node/issues/14747
-    if (common.isOSX)
-      setTimeout(() => { process.send({ payload }, handle); }, 1000);
-    else
-      process.send({ payload }, handle);
-
-    // Prepare for a clean exit.
-    process.channel.unref();
-  }));
+  process.on(
+    'message',
+    common.mustCall(({ payload: received }, handle) => {
+      assert.strictEqual(payload, received);
+      assert(handle instanceof net.Socket);
+
+      // On macOS, the parent process might not receive a message if it is sent
+      // to soon, and then subsequent messages are also sometimes not received.
+      //
+      // (Is this a bug or expected operating system behavior like the way a file
+      // watcher is returned before it's actually watching the file system on
+      // macOS?)
+      //
+      // Send a second message after a delay on macOS.
+      //
+      // Refs: https://github.com/nodejs/node/issues/14747
+      if (common.isOSX)
+        setTimeout(() => {
+          process.send({ payload }, handle);
+        }, 1000);
+      else process.send({ payload }, handle);
+
+      // Prepare for a clean exit.
+      process.channel.unref();
+    })
+  );
 }
diff --git a/test/sequential/test-crypto-timing-safe-equal.js b/test/sequential/test-crypto-timing-safe-equal.js
index dcebef29d782b0..876586282b66a6 100644
--- a/test/sequential/test-crypto-timing-safe-equal.js
+++ b/test/sequential/test-crypto-timing-safe-equal.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const crypto = require('crypto');
diff --git a/test/sequential/test-debugger-repeat-last.js b/test/sequential/test-debugger-repeat-last.js
index 42638e5d2ebf12..159d185e3c965f 100644
--- a/test/sequential/test-debugger-repeat-last.js
+++ b/test/sequential/test-debugger-repeat-last.js
@@ -6,11 +6,7 @@ const spawn = require('child_process').spawn;
 const assert = require('assert');
 const fixture = path('debugger-repeat-last.js');
 
-const args = [
-  'inspect',
-  `--port=${common.PORT}`,
-  fixture
-];
+const args = ['inspect', `--port=${common.PORT}`, fixture];
 
 const proc = spawn(process.execPath, args, { stdio: 'pipe' });
 proc.stdout.setEncoding('utf8');
@@ -25,17 +21,23 @@ proc.stdout.on('data', (data) => {
 
   // Send 'n' as the first step.
   if (!sentCommand && stdout.includes('> 1 ')) {
-    setImmediate(() => { proc.stdin.write('n\n'); });
-    return sentCommand = true;
+    setImmediate(() => {
+      proc.stdin.write('n\n');
+    });
+    return (sentCommand = true);
   }
   // Send empty (repeat last command) until we reach line 5.
   if (sentCommand && !stdout.includes('> 5')) {
-    setImmediate(() => { proc.stdin.write('\n'); });
+    setImmediate(() => {
+      proc.stdin.write('\n');
+    });
     return true;
   }
   if (!sentExit && stdout.includes('> 5')) {
-    setTimeout(() => { proc.stdin.write('\n\n\n.exit\n\n\n'); }, 1);
-    return sentExit = true;
+    setTimeout(() => {
+      proc.stdin.write('\n\n\n.exit\n\n\n');
+    }, 1);
+    return (sentExit = true);
   }
 });
 
diff --git a/test/sequential/test-deprecation-flags.js b/test/sequential/test-deprecation-flags.js
index be159ceb384ee2..e5c2f69e079fc5 100644
--- a/test/sequential/test-deprecation-flags.js
+++ b/test/sequential/test-deprecation-flags.js
@@ -27,14 +27,11 @@ const execFile = require('child_process').execFile;
 const depmod = fixtures.path('deprecated.js');
 const node = process.execPath;
 
-const depUserlandFunction =
-  fixtures.path('deprecated-userland-function.js');
+const depUserlandFunction = fixtures.path('deprecated-userland-function.js');
 
-const depUserlandClass =
-  fixtures.path('deprecated-userland-class.js');
+const depUserlandClass = fixtures.path('deprecated-userland-class.js');
 
-const depUserlandSubClass =
-  fixtures.path('deprecated-userland-subclass.js');
+const depUserlandSubClass = fixtures.path('deprecated-userland-subclass.js');
 
 const normal = [depmod];
 const noDep = ['--no-deprecation', depmod];
diff --git a/test/sequential/test-dgram-bind-shared-ports.js b/test/sequential/test-dgram-bind-shared-ports.js
index 9f7e23ba0bdaf5..eeed34cbf976df 100644
--- a/test/sequential/test-dgram-bind-shared-ports.js
+++ b/test/sequential/test-dgram-bind-shared-ports.js
@@ -35,42 +35,61 @@ if (cluster.isMaster) {
   const worker1 = cluster.fork();
 
   if (common.isWindows) {
-    worker1.on('error', common.mustCall((err) => {
-      console.log(err);
-      assert.strictEqual(err.code, 'ENOTSUP');
-      worker1.kill();
-    }));
+    worker1.on(
+      'error',
+      common.mustCall((err) => {
+        console.log(err);
+        assert.strictEqual(err.code, 'ENOTSUP');
+        worker1.kill();
+      })
+    );
     return;
   }
 
-  worker1.on('message', common.mustCall((msg) => {
-    console.log(msg);
-    assert.strictEqual(msg, 'success');
-
-    const worker2 = cluster.fork({ WORKER2_NAME });
-    worker2.on('message', common.mustCall((msg) => {
+  worker1.on(
+    'message',
+    common.mustCall((msg) => {
       console.log(msg);
-      assert.strictEqual(msg, 'socket3:EADDRINUSE');
+      assert.strictEqual(msg, 'success');
 
-      // finish test
-      worker1.send(BYE);
-      worker2.send(BYE);
-    }));
-    worker2.on('exit', common.mustCall((code, signal) => {
+      const worker2 = cluster.fork({ WORKER2_NAME });
+      worker2.on(
+        'message',
+        common.mustCall((msg) => {
+          console.log(msg);
+          assert.strictEqual(msg, 'socket3:EADDRINUSE');
+
+          // finish test
+          worker1.send(BYE);
+          worker2.send(BYE);
+        })
+      );
+      worker2.on(
+        'exit',
+        common.mustCall((code, signal) => {
+          assert.strictEqual(signal, null);
+          assert.strictEqual(code, 0);
+        })
+      );
+    })
+  );
+  worker1.on(
+    'exit',
+    common.mustCall((code, signal) => {
       assert.strictEqual(signal, null);
       assert.strictEqual(code, 0);
-    }));
-  }));
-  worker1.on('exit', common.mustCall((code, signal) => {
-    assert.strictEqual(signal, null);
-    assert.strictEqual(code, 0);
-  }));
+    })
+  );
   // end master code
 } else {
   // worker code
-  process.on('message', common.mustCallAtLeast((msg) => {
-    if (msg === BYE) process.exit(0);
-  }), 1);
+  process.on(
+    'message',
+    common.mustCallAtLeast((msg) => {
+      if (msg === BYE) process.exit(0);
+    }),
+    1
+  );
 
   const isSecondWorker = process.env.WORKER2_NAME === WORKER2_NAME;
   const socket1 = dgram.createSocket('udp4', common.mustNotCall());
@@ -81,33 +100,37 @@ if (cluster.isMaster) {
   socket2.on('error', (err) => assert.fail(err));
 
   // First worker should bind, second should err
-  const socket3OnBind =
-    isSecondWorker ?
-      common.mustNotCall() :
-      common.mustCall(() => {
+  const socket3OnBind = isSecondWorker
+    ? common.mustNotCall()
+    : common.mustCall(() => {
         const port3 = socket3.address().port;
         assert.strictEqual(typeof port3, 'number');
         process.send('success');
       });
   // an error is expected only in the second worker
-  const socket3OnError =
-    !isSecondWorker ?
-      common.mustNotCall() :
-      common.mustCall((err) => {
+  const socket3OnError = !isSecondWorker
+    ? common.mustNotCall()
+    : common.mustCall((err) => {
         process.send(`socket3:${err.code}`);
       });
   const address = common.localhostIPv4;
   const opt1 = { address, port: 0, exclusive: false };
   const opt2 = { address, port: common.PORT, exclusive: false };
   const opt3 = { address, port: common.PORT + 1, exclusive: true };
-  socket1.bind(opt1, common.mustCall(() => {
-    const port1 = socket1.address().port;
-    assert.strictEqual(typeof port1, 'number');
-    socket2.bind(opt2, common.mustCall(() => {
-      const port2 = socket2.address().port;
-      assert.strictEqual(typeof port2, 'number');
-      socket3.on('error', socket3OnError);
-      socket3.bind(opt3, socket3OnBind);
-    }));
-  }));
+  socket1.bind(
+    opt1,
+    common.mustCall(() => {
+      const port1 = socket1.address().port;
+      assert.strictEqual(typeof port1, 'number');
+      socket2.bind(
+        opt2,
+        common.mustCall(() => {
+          const port2 = socket2.address().port;
+          assert.strictEqual(typeof port2, 'number');
+          socket3.on('error', socket3OnError);
+          socket3.bind(opt3, socket3OnBind);
+        })
+      );
+    })
+  );
 }
diff --git a/test/sequential/test-dgram-implicit-bind-failure.js b/test/sequential/test-dgram-implicit-bind-failure.js
index d77db12618f3bc..9876963e827964 100644
--- a/test/sequential/test-dgram-implicit-bind-failure.js
+++ b/test/sequential/test-dgram-implicit-bind-failure.js
@@ -8,7 +8,9 @@ const { kStateSymbol } = require('internal/dgram');
 
 // Monkey patch dns.lookup() so that it always fails.
 dns.lookup = function(address, family, callback) {
-  process.nextTick(() => { callback(new Error('fake DNS')); });
+  process.nextTick(() => {
+    callback(new Error('fake DNS'));
+  });
 };
 
 const socket = dgram.createSocket('udp4');
diff --git a/test/sequential/test-dgram-pingpong.js b/test/sequential/test-dgram-pingpong.js
index 33b01fbe22a9b9..d5663cc7298510 100644
--- a/test/sequential/test-dgram-pingpong.js
+++ b/test/sequential/test-dgram-pingpong.js
@@ -4,11 +4,13 @@ const assert = require('assert');
 const dgram = require('dgram');
 
 function pingPongTest(port, host) {
-
-  const server = dgram.createSocket('udp4', common.mustCall((msg, rinfo) => {
-    assert.strictEqual(msg.toString('ascii'), 'PING');
-    server.send('PONG', 0, 4, rinfo.port, rinfo.address);
-  }));
+  const server = dgram.createSocket(
+    'udp4',
+    common.mustCall((msg, rinfo) => {
+      assert.strictEqual(msg.toString('ascii'), 'PING');
+      server.send('PONG', 0, 4, rinfo.port, rinfo.address);
+    })
+  );
 
   server.on('error', function(e) {
     throw e;
diff --git a/test/sequential/test-fs-readfile-tostring-fail.js b/test/sequential/test-fs-readfile-tostring-fail.js
index da8f3930f618f9..f545a6d811404d 100644
--- a/test/sequential/test-fs-readfile-tostring-fail.js
+++ b/test/sequential/test-fs-readfile-tostring-fail.js
@@ -12,7 +12,7 @@ const fs = require('fs');
 const path = require('path');
 const cp = require('child_process');
 const kStringMaxLength = internalBinding('buffer').kStringMaxLength;
-if (common.isAIX && (Number(cp.execSync('ulimit -f')) * 512) < kStringMaxLength)
+if (common.isAIX && Number(cp.execSync('ulimit -f')) * 512 < kStringMaxLength)
   common.skip('intensive toString tests due to file size confinements');
 
 const tmpdir = require('../common/tmpdir');
@@ -31,21 +31,29 @@ for (let i = 0; i < 201; i++) {
 }
 
 stream.end();
-stream.on('finish', common.mustCall(function() {
-  fs.readFile(file, 'utf8', common.mustCall(function(err, buf) {
-    assert.ok(err instanceof Error);
-    if (err.message !== 'Array buffer allocation failed') {
-      const stringLengthHex = kStringMaxLength.toString(16);
-      common.expectsError({
-        message: 'Cannot create a string longer than ' +
-                 `0x${stringLengthHex} characters`,
-        code: 'ERR_STRING_TOO_LONG',
-        type: Error
-      })(err);
-    }
-    assert.strictEqual(buf, undefined);
-  }));
-}));
+stream.on(
+  'finish',
+  common.mustCall(function() {
+    fs.readFile(
+      file,
+      'utf8',
+      common.mustCall(function(err, buf) {
+        assert.ok(err instanceof Error);
+        if (err.message !== 'Array buffer allocation failed') {
+          const stringLengthHex = kStringMaxLength.toString(16);
+          common.expectsError({
+            message:
+              'Cannot create a string longer than ' +
+              `0x${stringLengthHex} characters`,
+            code: 'ERR_STRING_TOO_LONG',
+            type: Error
+          })(err);
+        }
+        assert.strictEqual(buf, undefined);
+      })
+    );
+  })
+);
 
 function destroy() {
   try {
diff --git a/test/sequential/test-fs-stat-sync-overflow.js b/test/sequential/test-fs-stat-sync-overflow.js
index 9c9109989a19c3..9dc3eaea4aa2aa 100644
--- a/test/sequential/test-fs-stat-sync-overflow.js
+++ b/test/sequential/test-fs-stat-sync-overflow.js
@@ -33,8 +33,9 @@ const { fixturesDir } = require('../common/fixtures');
 const assert = require('assert');
 const { exec } = require('child_process');
 
-const cmd =
-  `"${process.execPath}" "${fixturesDir}/test-fs-stat-sync-overflow.js"`;
+const cmd = `"${
+  process.execPath
+}" "${fixturesDir}/test-fs-stat-sync-overflow.js"`;
 
 exec(cmd, function(err, stdout, stderr) {
   assert(/RangeError: Maximum call stack size exceeded/.test(stderr));
diff --git a/test/sequential/test-fs-watch.js b/test/sequential/test-fs-watch.js
index 9755cc8bb11311..735f8e65fbbefc 100644
--- a/test/sequential/test-fs-watch.js
+++ b/test/sequential/test-fs-watch.js
@@ -31,10 +31,8 @@ const tmpdir = require('../common/tmpdir');
 if (!common.isMainThread)
   common.skip('process.chdir is not available in Workers');
 
-const expectFilePath = common.isWindows ||
-                       common.isLinux ||
-                       common.isOSX ||
-                       common.isAIX;
+const expectFilePath =
+  common.isWindows || common.isLinux || common.isOSX || common.isAIX;
 
 const testDir = tmpdir.path;
 
@@ -46,14 +44,17 @@ tmpdir.refresh();
   fs.writeFileSync(filepath, 'hello');
 
   const watcher = fs.watch(filepath);
-  watcher.on('change', common.mustCall(function(event, filename) {
-    assert.strictEqual(event, 'change');
+  watcher.on(
+    'change',
+    common.mustCall(function(event, filename) {
+      assert.strictEqual(event, 'change');
 
-    if (expectFilePath) {
-      assert.strictEqual(filename, 'watch.txt');
-    }
-    watcher.close();
-  }));
+      if (expectFilePath) {
+        assert.strictEqual(filename, 'watch.txt');
+      }
+      watcher.close();
+    })
+  );
 
   setImmediate(function() {
     fs.writeFileSync(filepath, 'world');
@@ -67,15 +68,17 @@ tmpdir.refresh();
 
   fs.writeFileSync(filepathAbs, 'howdy');
 
-  const watcher =
-    fs.watch('hasOwnProperty', common.mustCall(function(event, filename) {
+  const watcher = fs.watch(
+    'hasOwnProperty',
+    common.mustCall(function(event, filename) {
       assert.strictEqual(event, 'change');
 
       if (expectFilePath) {
         assert.strictEqual(filename, 'hasOwnProperty');
       }
       watcher.close();
-    }));
+    })
+  );
 
   setImmediate(function() {
     fs.writeFileSync(filepathAbs, 'pardner');
@@ -86,8 +89,9 @@ tmpdir.refresh();
   const testsubdir = fs.mkdtempSync(testDir + path.sep);
   const filepath = path.join(testsubdir, 'newfile.txt');
 
-  const watcher =
-    fs.watch(testsubdir, common.mustCall(function(event, filename) {
+  const watcher = fs.watch(
+    testsubdir,
+    common.mustCall(function(event, filename) {
       const renameEv = common.isSunOS || common.isAIX ? 'change' : 'rename';
       assert.strictEqual(event, renameEv);
       if (expectFilePath) {
@@ -96,13 +100,13 @@ tmpdir.refresh();
         assert.strictEqual(filename, null);
       }
       watcher.close();
-    }));
+    })
+  );
 
   setImmediate(function() {
     const fd = fs.openSync(filepath, 'w');
     fs.closeSync(fd);
   });
-
 }
 
 // https://github.com/joyent/node/issues/2293 - non-persistent watcher should
@@ -115,14 +119,17 @@ tmpdir.refresh();
 // https://github.com/joyent/node/issues/6690
 {
   let oldhandle;
-  assert.throws(() => {
-    const w = fs.watch(__filename, common.mustNotCall());
-    oldhandle = w._handle;
-    w._handle = { close: w._handle.close };
-    w.close();
-  }, {
-    message: 'handle must be a FSEvent',
-    code: 'ERR_ASSERTION'
-  });
+  assert.throws(
+    () => {
+      const w = fs.watch(__filename, common.mustNotCall());
+      oldhandle = w._handle;
+      w._handle = { close: w._handle.close };
+      w.close();
+    },
+    {
+      message: 'handle must be a FSEvent',
+      code: 'ERR_ASSERTION'
+    }
+  );
   oldhandle.close(); // clean up
 }
diff --git a/test/sequential/test-gc-http-client.js b/test/sequential/test-gc-http-client.js
index 2eea09652a50d9..bc6d8297f36832 100644
--- a/test/sequential/test-gc-http-client.js
+++ b/test/sequential/test-gc-http-client.js
@@ -19,20 +19,24 @@ let countGC = 0;
 console.log(`We should do ${todo} requests`);
 
 const server = http.createServer(serverHandler);
-server.listen(0, common.mustCall(() => {
-  for (let i = 0; i < 15; i++)
-    getall();
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    for (let i = 0; i < 15; i++) getall();
+  })
+);
 
 function getall() {
-  if (count === todo)
-    return;
-
-  const req = http.get({
-    hostname: 'localhost',
-    pathname: '/',
-    port: server.address().port
-  }, cb);
+  if (count === todo) return;
+
+  const req = http.get(
+    {
+      hostname: 'localhost',
+      pathname: '/',
+      port: server.address().port
+    },
+    cb
+  );
 
   count++;
   onGC(req, { ongc });
diff --git a/test/sequential/test-http-econnrefused.js b/test/sequential/test-http-econnrefused.js
index ff4508963b9877..67b4c0d8c9d521 100644
--- a/test/sequential/test-http-econnrefused.js
+++ b/test/sequential/test-http-econnrefused.js
@@ -32,7 +32,6 @@ const common = require('../common');
 const http = require('http');
 const assert = require('assert');
 
-
 const server = http.createServer(function(req, res) {
   let body = '';
 
@@ -48,16 +47,13 @@ const server = http.createServer(function(req, res) {
   });
 });
 
-
 server.on('listening', pingping);
 
-
 function serverOn() {
   console.error('Server ON');
   server.listen(common.PORT);
 }
 
-
 function serverOff() {
   console.error('Server OFF');
   server.close();
@@ -66,7 +62,6 @@ function serverOff() {
 
 const responses = [];
 
-
 function afterPing(result) {
   responses.push(result);
   console.error(`afterPing. responses.length = ${responses.length}`);
@@ -100,7 +95,6 @@ function afterPing(result) {
   }
 }
 
-
 function ping() {
   console.error('making req');
 
@@ -139,7 +133,6 @@ function ping() {
   });
 }
 
-
 function pingping() {
   ping();
   ping();
diff --git a/test/sequential/test-http-keep-alive-large-write.js b/test/sequential/test-http-keep-alive-large-write.js
index 4119c2353daa53..69d4441b45664f 100644
--- a/test/sequential/test-http-keep-alive-large-write.js
+++ b/test/sequential/test-http-keep-alive-large-write.js
@@ -10,38 +10,48 @@ const http = require('http');
 const writeSize = 3000000;
 let socket;
 
-const server = http.createServer(common.mustCall((req, res) => {
-  server.close();
-  const content = Buffer.alloc(writeSize, 0x44);
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    server.close();
+    const content = Buffer.alloc(writeSize, 0x44);
 
-  res.writeHead(200, {
-    'Content-Type': 'application/octet-stream',
-    'Content-Length': content.length.toString(),
-    'Vary': 'Accept-Encoding'
-  });
+    res.writeHead(200, {
+      'Content-Type': 'application/octet-stream',
+      'Content-Length': content.length.toString(),
+      Vary: 'Accept-Encoding'
+    });
 
-  socket = res.socket;
-  const onTimeout = socket._onTimeout;
-  socket._onTimeout = common.mustCallAtLeast(() => onTimeout.call(socket), 1);
-  res.write(content);
-  res.end();
-}));
+    socket = res.socket;
+    const onTimeout = socket._onTimeout;
+    socket._onTimeout = common.mustCallAtLeast(() => onTimeout.call(socket), 1);
+    res.write(content);
+    res.end();
+  })
+);
 server.on('timeout', () => {
   // TODO(apapirovski): This test is faulty on certain Windows systems
   // as no queue is ever created
-  assert(!socket._handle || socket._handle.writeQueueSize === 0,
-         'Should not timeout');
+  assert(
+    !socket._handle || socket._handle.writeQueueSize === 0,
+    'Should not timeout'
+  );
 });
 
-server.listen(0, common.mustCall(() => {
-  http.get({
-    path: '/',
-    port: server.address().port
-  }, (res) => {
-    res.once('data', () => {
-      socket._onTimeout();
-      res.on('data', () => {});
-    });
-    res.on('end', () => server.close());
-  });
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    http.get(
+      {
+        path: '/',
+        port: server.address().port
+      },
+      (res) => {
+        res.once('data', () => {
+          socket._onTimeout();
+          res.on('data', () => {});
+        });
+        res.on('end', () => server.close());
+      }
+    );
+  })
+);
diff --git a/test/sequential/test-http-keepalive-maxsockets.js b/test/sequential/test-http-keepalive-maxsockets.js
index 53d67b24797770..6a551a94c7c03f 100644
--- a/test/sequential/test-http-keepalive-maxsockets.js
+++ b/test/sequential/test-http-keepalive-maxsockets.js
@@ -25,7 +25,6 @@ const assert = require('assert');
 
 const http = require('http');
 
-
 const serverSockets = [];
 const server = http.createServer(function(req, res) {
   if (!serverSockets.includes(req.socket)) {
@@ -70,33 +69,35 @@ server.listen(0, function() {
   // make 10 requests in parallel,
   // then 10 more when they all finish.
   function makeReqs(n, cb) {
-    for (let i = 0; i < n; i++)
-      makeReq(i, then);
+    for (let i = 0; i < n; i++) makeReq(i, then);
 
     function then(er) {
-      if (er)
-        return cb(er);
-      else if (--n === 0)
-        setTimeout(cb, 100);
+      if (er) return cb(er);
+      else if (--n === 0) setTimeout(cb, 100);
     }
   }
 
   function makeReq(i, cb) {
-    http.request({
-      port: server.address().port,
-      path: `/${i}`,
-      agent: agent
-    }, function(res) {
-      let data = '';
-      res.setEncoding('ascii');
-      res.on('data', function(c) {
-        data += c;
-      });
-      res.on('end', function() {
-        assert.strictEqual(data, `/${i}`);
-        cb();
-      });
-    }).end();
+    http
+      .request(
+        {
+          port: server.address().port,
+          path: `/${i}`,
+          agent: agent
+        },
+        function(res) {
+          let data = '';
+          res.setEncoding('ascii');
+          res.on('data', function(c) {
+            data += c;
+          });
+          res.on('end', function() {
+            assert.strictEqual(data, `/${i}`);
+            cb();
+          });
+        }
+      )
+      .end();
   }
 
   function count(sockets) {
diff --git a/test/sequential/test-http-max-sockets.js b/test/sequential/test-http-max-sockets.js
index 24629448f7ac77..e12f20e6545cb0 100644
--- a/test/sequential/test-http-max-sockets.js
+++ b/test/sequential/test-http-max-sockets.js
@@ -60,11 +60,15 @@ server.listen(common.PORT, '127.0.0.1', function() {
 
     console.log(
       `Socket: ${agent.sockets[addrString].length}/${
-        agent.maxSockets} queued: ${
-        agent.requests[addrString] ? agent.requests[addrString].length : 0}`);
+        agent.maxSockets
+      } queued: ${
+        agent.requests[addrString] ? agent.requests[addrString].length : 0
+      }`
+    );
 
-    const agentRequests = agent.requests[addrString] ?
-      agent.requests[addrString].length : 0;
+    const agentRequests = agent.requests[addrString]
+      ? agent.requests[addrString].length
+      : 0;
 
     if (maxQueued < agentRequests) {
       maxQueued = agentRequests;
diff --git a/test/sequential/test-http-regr-gh-2928.js b/test/sequential/test-http-regr-gh-2928.js
index 3794eddaa09369..77e029468dc4f5 100644
--- a/test/sequential/test-http-regr-gh-2928.js
+++ b/test/sequential/test-http-regr-gh-2928.js
@@ -21,8 +21,7 @@ let gotRequests = 0;
 let gotResponses = 0;
 
 function execAndClose() {
-  if (parsers.length === 0)
-    return;
+  if (parsers.length === 0) return;
   process.stdout.write('.');
 
   const parser = parsers.pop();
@@ -53,13 +52,14 @@ function execAndClose() {
   };
 }
 
-const server = net.createServer(function(c) {
-  if (++gotRequests === COUNT)
-    server.close();
-  c.end('HTTP/1.1 200 OK\r\n\r\n', function() {
-    c.destroySoon();
-  });
-}).listen(common.PORT, execAndClose);
+const server = net
+  .createServer(function(c) {
+    if (++gotRequests === COUNT) server.close();
+    c.end('HTTP/1.1 200 OK\r\n\r\n', function() {
+      c.destroySoon();
+    });
+  })
+  .listen(common.PORT, execAndClose);
 
 process.on('exit', function() {
   assert.strictEqual(gotResponses, COUNT);
diff --git a/test/sequential/test-http-server-consumed-timeout.js b/test/sequential/test-http-server-consumed-timeout.js
index 56217226503be1..765240a8c730cc 100644
--- a/test/sequential/test-http-server-consumed-timeout.js
+++ b/test/sequential/test-http-server-consumed-timeout.js
@@ -27,25 +27,33 @@ const server = http.createServer((req, res) => {
   });
 });
 
-server.listen(0, common.mustCall(() => {
-  const req = http.request({
-    port: server.address().port,
-    method: 'POST'
-  }, (res) => {
-    const interval = setInterval(() => {
-      intervalWasInvoked = true;
-      // If machine is busy enough that the interval takes more than TIMEOUT ms
-      // to be invoked, skip the test.
-      const now = Date.now();
-      if (now - time > TIMEOUT)
-        return common.skip('interval is not invoked quickly enough for test');
-      time = now;
-      req.write('a');
-    }, common.platformTimeout(25));
-    setTimeout(() => {
-      clearInterval(interval);
-      req.end();
-    }, TIMEOUT);
-  });
-  req.write('.');
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const req = http.request(
+      {
+        port: server.address().port,
+        method: 'POST'
+      },
+      (res) => {
+        const interval = setInterval(() => {
+          intervalWasInvoked = true;
+          // If machine is busy enough that the interval takes more than TIMEOUT ms
+          // to be invoked, skip the test.
+          const now = Date.now();
+          if (now - time > TIMEOUT)
+            return common.skip(
+              'interval is not invoked quickly enough for test'
+            );
+          time = now;
+          req.write('a');
+        }, common.platformTimeout(25));
+        setTimeout(() => {
+          clearInterval(interval);
+          req.end();
+        }, TIMEOUT);
+      }
+    );
+    req.write('.');
+  })
+);
diff --git a/test/sequential/test-http-server-keep-alive-timeout-slow-client-headers.js b/test/sequential/test-http-server-keep-alive-timeout-slow-client-headers.js
index 453831ecba88a2..9343589ee8bd6e 100644
--- a/test/sequential/test-http-server-keep-alive-timeout-slow-client-headers.js
+++ b/test/sequential/test-http-server-keep-alive-timeout-slow-client-headers.js
@@ -5,53 +5,64 @@ const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  res.end();
-}, 2));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    res.end();
+  }, 2)
+);
 
 server.keepAliveTimeout = common.platformTimeout(100);
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-  const socket = net.connect({ port }, common.mustCall(() => {
-    request(common.mustCall(() => {
-      // Make a second request on the same socket, after the keep-alive timeout
-      // has been set on the server side.
-      request(common.mustCall());
-    }));
-  }));
-
-  server.on('timeout', common.mustCall(() => {
-    socket.end();
-    server.close();
-  }));
-
-  function request(callback) {
-    socket.setEncoding('utf8');
-    socket.on('data', onData);
-    let response = '';
-
-    // Simulate a client that sends headers slowly (with a period of inactivity
-    // that is longer than the keep-alive timeout).
-    socket.write('GET / HTTP/1.1\r\n' +
-                 `Host: localhost:${port}\r\n`);
-    setTimeout(() => {
-      socket.write('Connection: keep-alive\r\n' +
-                   '\r\n');
-    }, common.platformTimeout(300));
-
-    function onData(chunk) {
-      response += chunk;
-      if (chunk.includes('\r\n')) {
-        socket.removeListener('data', onData);
-        onHeaders();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+    const socket = net.connect(
+      { port },
+      common.mustCall(() => {
+        request(
+          common.mustCall(() => {
+            // Make a second request on the same socket, after the keep-alive timeout
+            // has been set on the server side.
+            request(common.mustCall());
+          })
+        );
+      })
+    );
+
+    server.on(
+      'timeout',
+      common.mustCall(() => {
+        socket.end();
+        server.close();
+      })
+    );
+
+    function request(callback) {
+      socket.setEncoding('utf8');
+      socket.on('data', onData);
+      let response = '';
+
+      // Simulate a client that sends headers slowly (with a period of inactivity
+      // that is longer than the keep-alive timeout).
+      socket.write('GET / HTTP/1.1\r\n' + `Host: localhost:${port}\r\n`);
+      setTimeout(() => {
+        socket.write('Connection: keep-alive\r\n' + '\r\n');
+      }, common.platformTimeout(300));
+
+      function onData(chunk) {
+        response += chunk;
+        if (chunk.includes('\r\n')) {
+          socket.removeListener('data', onData);
+          onHeaders();
+        }
       }
-    }
 
-    function onHeaders() {
-      assert.ok(response.includes('HTTP/1.1 200 OK\r\n'));
-      assert.ok(response.includes('Connection: keep-alive\r\n'));
-      callback();
+      function onHeaders() {
+        assert.ok(response.includes('HTTP/1.1 200 OK\r\n'));
+        assert.ok(response.includes('Connection: keep-alive\r\n'));
+        callback();
+      }
     }
-  }
-}));
+  })
+);
diff --git a/test/sequential/test-http-server-keep-alive-timeout-slow-server.js b/test/sequential/test-http-server-keep-alive-timeout-slow-server.js
index 1543c1415fa5e9..b44e1688b2746e 100644
--- a/test/sequential/test-http-server-keep-alive-timeout-slow-server.js
+++ b/test/sequential/test-http-server-keep-alive-timeout-slow-server.js
@@ -4,15 +4,17 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  if (req.url === '/first') {
-    res.end('ok');
-    return;
-  }
-  setTimeout(() => {
-    res.end('ok');
-  }, common.platformTimeout(500));
-}, 2));
+const server = http.createServer(
+  common.mustCall((req, res) => {
+    if (req.url === '/first') {
+      res.end('ok');
+      return;
+    }
+    setTimeout(() => {
+      res.end('ok');
+    }, common.platformTimeout(500));
+  }, 2)
+);
 
 server.keepAliveTimeout = common.platformTimeout(200);
 
@@ -23,28 +25,37 @@ const agent = new http.Agent({
 
 function request(path, callback) {
   const port = server.address().port;
-  const req = http.request({ agent, path, port }, common.mustCall((res) => {
-    assert.strictEqual(res.statusCode, 200);
-
-    res.setEncoding('utf8');
-
-    let result = '';
-    res.on('data', (chunk) => {
-      result += chunk;
-    });
-
-    res.on('end', common.mustCall(() => {
-      assert.strictEqual(result, 'ok');
-      callback();
-    }));
-  }));
+  const req = http.request(
+    { agent, path, port },
+    common.mustCall((res) => {
+      assert.strictEqual(res.statusCode, 200);
+
+      res.setEncoding('utf8');
+
+      let result = '';
+      res.on('data', (chunk) => {
+        result += chunk;
+      });
+
+      res.on(
+        'end',
+        common.mustCall(() => {
+          assert.strictEqual(result, 'ok');
+          callback();
+        })
+      );
+    })
+  );
   req.end();
 }
 
-server.listen(0, common.mustCall(() => {
-  request('/first', () => {
-    request('/second', () => {
-      server.close();
+server.listen(
+  0,
+  common.mustCall(() => {
+    request('/first', () => {
+      request('/second', () => {
+        server.close();
+      });
     });
-  });
-}));
+  })
+);
diff --git a/test/sequential/test-http2-large-file.js b/test/sequential/test-http2-large-file.js
index d1a44e8d6be53c..5b4372ecbcf0d5 100644
--- a/test/sequential/test-http2-large-file.js
+++ b/test/sequential/test-http2-large-file.js
@@ -4,8 +4,7 @@
 // See: https://github.com/nodejs/node/issues/19141
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http2 = require('http2');
 
@@ -16,24 +15,32 @@ server.on('stream', (stream) => {
   stream.end('ok');
 });
 
-server.listen(0, common.mustCall(() => {
-  let remaining = 1e8;
-  const chunk = 1e6;
-  const client = http2.connect(`http://localhost:${server.address().port}`,
-                               { settings: { initialWindowSize: 6553500 } });
-  const request = client.request({ ':method': 'POST' });
-  function writeChunk() {
-    if (remaining > 0) {
-      remaining -= chunk;
-      request.write(Buffer.alloc(chunk, 'a'), writeChunk);
-    } else {
-      request.end();
+server.listen(
+  0,
+  common.mustCall(() => {
+    let remaining = 1e8;
+    const chunk = 1e6;
+    const client = http2.connect(
+      `http://localhost:${server.address().port}`,
+      { settings: { initialWindowSize: 6553500 } }
+    );
+    const request = client.request({ ':method': 'POST' });
+    function writeChunk() {
+      if (remaining > 0) {
+        remaining -= chunk;
+        request.write(Buffer.alloc(chunk, 'a'), writeChunk);
+      } else {
+        request.end();
+      }
     }
-  }
-  writeChunk();
-  request.on('close', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-  request.resume();
-}));
+    writeChunk();
+    request.on(
+      'close',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+    request.resume();
+  })
+);
diff --git a/test/sequential/test-http2-max-session-memory.js b/test/sequential/test-http2-max-session-memory.js
index 644a20a3c88a50..a9048d81099894 100644
--- a/test/sequential/test-http2-max-session-memory.js
+++ b/test/sequential/test-http2-max-session-memory.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const http2 = require('http2');
 
@@ -12,37 +11,48 @@ const largeBuffer = Buffer.alloc(1e6);
 
 const server = http2.createServer({ maxSessionMemory: 1 });
 
-server.on('stream', common.mustCall((stream) => {
-  stream.on('error', (err) => {
-    if (err.code !== 'ECONNRESET')
-      throw err;
-  });
-  stream.respond();
-  stream.end(largeBuffer);
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`http://localhost:${server.address().port}`);
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.on('error', (err) => {
+      if (err.code !== 'ECONNRESET') throw err;
+    });
+    stream.respond();
+    stream.end(largeBuffer);
+  })
+);
 
-  {
-    const req = client.request();
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(`http://localhost:${server.address().port}`);
 
-    req.on('response', () => {
-      // This one should be rejected because the server is over budget
-      // on the current memory allocation
+    {
       const req = client.request();
-      req.on('error', common.expectsError({
-        code: 'ERR_HTTP2_STREAM_ERROR',
-        type: Error,
-        message: 'Stream closed with error code NGHTTP2_ENHANCE_YOUR_CALM'
-      }));
-      req.on('close', common.mustCall(() => {
-        server.close();
-        client.destroy();
-      }));
-    });
 
-    req.resume();
-    req.on('close', common.mustCall());
-  }
-}));
+      req.on('response', () => {
+        // This one should be rejected because the server is over budget
+        // on the current memory allocation
+        const req = client.request();
+        req.on(
+          'error',
+          common.expectsError({
+            code: 'ERR_HTTP2_STREAM_ERROR',
+            type: Error,
+            message: 'Stream closed with error code NGHTTP2_ENHANCE_YOUR_CALM'
+          })
+        );
+        req.on(
+          'close',
+          common.mustCall(() => {
+            server.close();
+            client.destroy();
+          })
+        );
+      });
+
+      req.resume();
+      req.on('close', common.mustCall());
+    }
+  })
+);
diff --git a/test/sequential/test-http2-ping-flood.js b/test/sequential/test-http2-ping-flood.js
index b414aca8a4703a..cfa1ee10399c62 100644
--- a/test/sequential/test-http2-ping-flood.js
+++ b/test/sequential/test-http2-ping-flood.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http2 = require('http2');
@@ -20,41 +19,52 @@ const server = http2.createServer();
 let interval;
 
 server.on('stream', common.mustNotCall());
-server.on('session', common.mustCall((session) => {
-  session.on('error', (e) => {
-    assert.strictEqual(e.code, 'ERR_HTTP2_ERROR');
-    assert(e.message.includes('Flooding was detected'));
-    clearInterval(interval);
-  });
-  session.on('close', common.mustCall(() => {
-    server.close();
-  }));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = net.connect(server.address().port);
-
-  // nghttp2 uses a limit of 10000 items in it's outbound queue.
-  // If this number is exceeded, a flooding error is raised.
-  // TODO(jasnell): Unfortunately, this test is inherently flaky because
-  // it is entirely dependent on how quickly the server is able to handle
-  // the inbound frames and whether those just happen to overflow nghttp2's
-  // outbound queue. The threshold at which the flood error occurs can vary
-  // from one system to another, and from one test run to another.
-  client.on('connect', common.mustCall(() => {
-    client.write(http2util.kClientMagic, () => {
-      client.write(kSettings.data, () => {
-        interval = setInterval(() => {
-          for (let n = 0; n < 10000; n++)
-            client.write(kPing.data);
-        }, 1);
-      });
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.on('error', (e) => {
+      assert.strictEqual(e.code, 'ERR_HTTP2_ERROR');
+      assert(e.message.includes('Flooding was detected'));
+      clearInterval(interval);
     });
-  }));
-
-  // An error event may or may not be emitted, depending on operating system
-  // and timing. We do not really care if one is emitted here or not, as the
-  // error on the server side is what we are testing for. Do not make this
-  // a common.mustCall() and there's no need to check the error details.
-  client.on('error', () => {});
-}));
+    session.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+      })
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = net.connect(server.address().port);
+
+    // nghttp2 uses a limit of 10000 items in it's outbound queue.
+    // If this number is exceeded, a flooding error is raised.
+    // TODO(jasnell): Unfortunately, this test is inherently flaky because
+    // it is entirely dependent on how quickly the server is able to handle
+    // the inbound frames and whether those just happen to overflow nghttp2's
+    // outbound queue. The threshold at which the flood error occurs can vary
+    // from one system to another, and from one test run to another.
+    client.on(
+      'connect',
+      common.mustCall(() => {
+        client.write(http2util.kClientMagic, () => {
+          client.write(kSettings.data, () => {
+            interval = setInterval(() => {
+              for (let n = 0; n < 10000; n++) client.write(kPing.data);
+            }, 1);
+          });
+        });
+      })
+    );
+
+    // An error event may or may not be emitted, depending on operating system
+    // and timing. We do not really care if one is emitted here or not, as the
+    // error on the server side is what we are testing for. Do not make this
+    // a common.mustCall() and there's no need to check the error details.
+    client.on('error', () => {});
+  })
+);
diff --git a/test/sequential/test-http2-session-timeout.js b/test/sequential/test-http2-session-timeout.js
index 14a31bad9bd0fc..fde354274cbaad 100644
--- a/test/sequential/test-http2-session-timeout.js
+++ b/test/sequential/test-http2-session-timeout.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const http2 = require('http2');
 
@@ -19,36 +18,39 @@ server.timeout = serverTimeout;
 server.on('request', (req, res) => res.end());
 server.on('timeout', mustNotCall);
 
-server.listen(0, common.mustCall(() => {
-  const port = server.address().port;
-
-  const url = `http://localhost:${port}`;
-  const client = http2.connect(url);
-  const startTime = process.hrtime();
-  makeReq();
-
-  function makeReq() {
-    const request = client.request({
-      ':path': '/foobar',
-      ':method': 'GET',
-      ':scheme': 'http',
-      ':authority': `localhost:${port}`,
-    });
-    request.resume();
-    request.end();
-
-    requests += 1;
-
-    request.on('end', () => {
-      const diff = process.hrtime(startTime);
-      const milliseconds = (diff[0] * 1e3 + diff[1] / 1e6);
-      if (milliseconds < serverTimeout * 2) {
-        makeReq();
-      } else {
-        server.removeListener('timeout', mustNotCall);
-        server.close();
-        client.close();
-      }
-    });
-  }
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    const port = server.address().port;
+
+    const url = `http://localhost:${port}`;
+    const client = http2.connect(url);
+    const startTime = process.hrtime();
+    makeReq();
+
+    function makeReq() {
+      const request = client.request({
+        ':path': '/foobar',
+        ':method': 'GET',
+        ':scheme': 'http',
+        ':authority': `localhost:${port}`
+      });
+      request.resume();
+      request.end();
+
+      requests += 1;
+
+      request.on('end', () => {
+        const diff = process.hrtime(startTime);
+        const milliseconds = diff[0] * 1e3 + diff[1] / 1e6;
+        if (milliseconds < serverTimeout * 2) {
+          makeReq();
+        } else {
+          server.removeListener('timeout', mustNotCall);
+          server.close();
+          client.close();
+        }
+      });
+    }
+  })
+);
diff --git a/test/sequential/test-http2-settings-flood.js b/test/sequential/test-http2-settings-flood.js
index 15b3696b9c298e..350358a642e43e 100644
--- a/test/sequential/test-http2-settings-flood.js
+++ b/test/sequential/test-http2-settings-flood.js
@@ -1,8 +1,7 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const http2 = require('http2');
@@ -19,40 +18,51 @@ const server = http2.createServer();
 let interval;
 
 server.on('stream', common.mustNotCall());
-server.on('session', common.mustCall((session) => {
-  session.on('error', (e) => {
-    assert.strictEqual(e.code, 'ERR_HTTP2_ERROR');
-    assert(e.message.includes('Flooding was detected'));
-    clearInterval(interval);
-  });
-
-  session.on('close', common.mustCall(() => {
-    server.close();
-  }));
-}));
-
-server.listen(0, common.mustCall(() => {
-  const client = net.connect(server.address().port);
-
-  // nghttp2 uses a limit of 10000 items in it's outbound queue.
-  // If this number is exceeded, a flooding error is raised.
-  // TODO(jasnell): Unfortunately, this test is inherently flaky because
-  // it is entirely dependent on how quickly the server is able to handle
-  // the inbound frames and whether those just happen to overflow nghttp2's
-  // outbound queue. The threshold at which the flood error occurs can vary
-  // from one system to another, and from one test run to another.
-  client.on('connect', common.mustCall(() => {
-    client.write(http2util.kClientMagic, () => {
-      interval = setInterval(() => {
-        for (let n = 0; n < 10000; n++)
-          client.write(kSettings.data);
-      }, 1);
+server.on(
+  'session',
+  common.mustCall((session) => {
+    session.on('error', (e) => {
+      assert.strictEqual(e.code, 'ERR_HTTP2_ERROR');
+      assert(e.message.includes('Flooding was detected'));
+      clearInterval(interval);
     });
-  }));
-
-  // An error event may or may not be emitted, depending on operating system
-  // and timing. We do not really care if one is emitted here or not, as the
-  // error on the server side is what we are testing for. Do not make this
-  // a common.mustCall() and there's no need to check the error details.
-  client.on('error', () => {});
-}));
+
+    session.on(
+      'close',
+      common.mustCall(() => {
+        server.close();
+      })
+    );
+  })
+);
+
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = net.connect(server.address().port);
+
+    // nghttp2 uses a limit of 10000 items in it's outbound queue.
+    // If this number is exceeded, a flooding error is raised.
+    // TODO(jasnell): Unfortunately, this test is inherently flaky because
+    // it is entirely dependent on how quickly the server is able to handle
+    // the inbound frames and whether those just happen to overflow nghttp2's
+    // outbound queue. The threshold at which the flood error occurs can vary
+    // from one system to another, and from one test run to another.
+    client.on(
+      'connect',
+      common.mustCall(() => {
+        client.write(http2util.kClientMagic, () => {
+          interval = setInterval(() => {
+            for (let n = 0; n < 10000; n++) client.write(kSettings.data);
+          }, 1);
+        });
+      })
+    );
+
+    // An error event may or may not be emitted, depending on operating system
+    // and timing. We do not really care if one is emitted here or not, as the
+    // error on the server side is what we are testing for. Do not make this
+    // a common.mustCall() and there's no need to check the error details.
+    client.on('error', () => {});
+  })
+);
diff --git a/test/sequential/test-http2-timeout-large-write-file.js b/test/sequential/test-http2-timeout-large-write-file.js
index bb366cfff04091..873ba68cbe95b9 100644
--- a/test/sequential/test-http2-timeout-large-write-file.js
+++ b/test/sequential/test-http2-timeout-large-write-file.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const fs = require('fs');
@@ -38,49 +37,65 @@ const server = http2.createSecureServer({
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
 });
-server.on('stream', common.mustCall((stream) => {
-  stream.respondWithFD(fd, {
-    'Content-Type': 'application/octet-stream',
-    'Content-Length': content.length.toString(),
-    'Vary': 'Accept-Encoding'
-  });
-  stream.end();
-}));
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    stream.respondWithFD(fd, {
+      'Content-Type': 'application/octet-stream',
+      'Content-Length': content.length.toString(),
+      Vary: 'Accept-Encoding'
+    });
+    stream.end();
+  })
+);
 server.setTimeout(serverTimeout);
 server.on('timeout', () => {
   assert.ok(!didReceiveData, 'Should not timeout');
 });
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`https://localhost:${server.address().port}`,
-                               { rejectUnauthorized: false });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(
+      `https://localhost:${server.address().port}`,
+      { rejectUnauthorized: false }
+    );
 
-  const req = client.request({ ':path': '/' });
-  req.end();
+    const req = client.request({ ':path': '/' });
+    req.end();
 
-  const resume = () => req.resume();
-  let receivedBufferLength = 0;
-  let firstReceivedAt;
-  req.on('data', common.mustCallAtLeast((buf) => {
-    if (receivedBufferLength === 0) {
-      didReceiveData = false;
-      firstReceivedAt = Date.now();
-    }
-    receivedBufferLength += buf.length;
-    if (receivedBufferLength >= minReadSize &&
-        receivedBufferLength < writeSize) {
-      didReceiveData = true;
-      receivedBufferLength = 0;
-      req.pause();
-      setTimeout(
-        resume,
-        serverTimeout + offsetTimeout - (Date.now() - firstReceivedAt)
-      );
-      offsetTimeout = 0;
-    }
-  }, 1));
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-}));
+    const resume = () => req.resume();
+    let receivedBufferLength = 0;
+    let firstReceivedAt;
+    req.on(
+      'data',
+      common.mustCallAtLeast((buf) => {
+        if (receivedBufferLength === 0) {
+          didReceiveData = false;
+          firstReceivedAt = Date.now();
+        }
+        receivedBufferLength += buf.length;
+        if (
+          receivedBufferLength >= minReadSize &&
+          receivedBufferLength < writeSize
+        ) {
+          didReceiveData = true;
+          receivedBufferLength = 0;
+          req.pause();
+          setTimeout(
+            resume,
+            serverTimeout + offsetTimeout - (Date.now() - firstReceivedAt)
+          );
+          offsetTimeout = 0;
+        }
+      }, 1)
+    );
+    req.on(
+      'end',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/sequential/test-http2-timeout-large-write.js b/test/sequential/test-http2-timeout-large-write.js
index 73114776df0a0e..7efdd1e39befa1 100644
--- a/test/sequential/test-http2-timeout-large-write.js
+++ b/test/sequential/test-http2-timeout-large-write.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const http2 = require('http2');
@@ -28,57 +27,73 @@ const server = http2.createSecureServer({
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
 });
-server.on('stream', common.mustCall((stream) => {
-  const content = Buffer.alloc(writeSize, 0x44);
+server.on(
+  'stream',
+  common.mustCall((stream) => {
+    const content = Buffer.alloc(writeSize, 0x44);
 
-  stream.respond({
-    'Content-Type': 'application/octet-stream',
-    'Content-Length': content.length.toString(),
-    'Vary': 'Accept-Encoding'
-  });
+    stream.respond({
+      'Content-Type': 'application/octet-stream',
+      'Content-Length': content.length.toString(),
+      Vary: 'Accept-Encoding'
+    });
 
-  stream.write(content);
-  stream.setTimeout(serverTimeout);
-  stream.on('timeout', () => {
-    assert.ok(!didReceiveData, 'Should not timeout');
-  });
-  stream.end();
-}));
+    stream.write(content);
+    stream.setTimeout(serverTimeout);
+    stream.on('timeout', () => {
+      assert.ok(!didReceiveData, 'Should not timeout');
+    });
+    stream.end();
+  })
+);
 server.setTimeout(serverTimeout);
 server.on('timeout', () => {
   assert.ok(!didReceiveData, 'Should not timeout');
 });
 
-server.listen(0, common.mustCall(() => {
-  const client = http2.connect(`https://localhost:${server.address().port}`,
-                               { rejectUnauthorized: false });
+server.listen(
+  0,
+  common.mustCall(() => {
+    const client = http2.connect(
+      `https://localhost:${server.address().port}`,
+      { rejectUnauthorized: false }
+    );
 
-  const req = client.request({ ':path': '/' });
-  req.end();
+    const req = client.request({ ':path': '/' });
+    req.end();
 
-  const resume = () => req.resume();
-  let receivedBufferLength = 0;
-  let firstReceivedAt;
-  req.on('data', common.mustCallAtLeast((buf) => {
-    if (receivedBufferLength === 0) {
-      didReceiveData = false;
-      firstReceivedAt = Date.now();
-    }
-    receivedBufferLength += buf.length;
-    if (receivedBufferLength >= minReadSize &&
-        receivedBufferLength < writeSize) {
-      didReceiveData = true;
-      receivedBufferLength = 0;
-      req.pause();
-      setTimeout(
-        resume,
-        serverTimeout + offsetTimeout - (Date.now() - firstReceivedAt)
-      );
-      offsetTimeout = 0;
-    }
-  }, 1));
-  req.on('end', common.mustCall(() => {
-    client.close();
-    server.close();
-  }));
-}));
+    const resume = () => req.resume();
+    let receivedBufferLength = 0;
+    let firstReceivedAt;
+    req.on(
+      'data',
+      common.mustCallAtLeast((buf) => {
+        if (receivedBufferLength === 0) {
+          didReceiveData = false;
+          firstReceivedAt = Date.now();
+        }
+        receivedBufferLength += buf.length;
+        if (
+          receivedBufferLength >= minReadSize &&
+          receivedBufferLength < writeSize
+        ) {
+          didReceiveData = true;
+          receivedBufferLength = 0;
+          req.pause();
+          setTimeout(
+            resume,
+            serverTimeout + offsetTimeout - (Date.now() - firstReceivedAt)
+          );
+          offsetTimeout = 0;
+        }
+      }, 1)
+    );
+    req.on(
+      'end',
+      common.mustCall(() => {
+        client.close();
+        server.close();
+      })
+    );
+  })
+);
diff --git a/test/sequential/test-https-keep-alive-large-write.js b/test/sequential/test-https-keep-alive-large-write.js
index 79381ba8735756..fc64397433c4c8 100644
--- a/test/sequential/test-https-keep-alive-large-write.js
+++ b/test/sequential/test-https-keep-alive-large-write.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
 const https = require('https');
 
@@ -12,36 +11,45 @@ const https = require('https');
 const writeSize = 30000000;
 let socket;
 
-const server = https.createServer({
-  key: fixtures.readKey('agent1-key.pem'),
-  cert: fixtures.readKey('agent1-cert.pem')
-}, common.mustCall((req, res) => {
-  const content = Buffer.alloc(writeSize, 0x44);
+const server = https.createServer(
+  {
+    key: fixtures.readKey('agent1-key.pem'),
+    cert: fixtures.readKey('agent1-cert.pem')
+  },
+  common.mustCall((req, res) => {
+    const content = Buffer.alloc(writeSize, 0x44);
 
-  res.writeHead(200, {
-    'Content-Type': 'application/octet-stream',
-    'Content-Length': content.length.toString(),
-    'Vary': 'Accept-Encoding'
-  });
+    res.writeHead(200, {
+      'Content-Type': 'application/octet-stream',
+      'Content-Length': content.length.toString(),
+      Vary: 'Accept-Encoding'
+    });
 
-  socket = res.socket;
-  const onTimeout = socket._onTimeout;
-  socket._onTimeout = common.mustCallAtLeast(() => onTimeout.call(socket), 1);
-  res.write(content);
-  res.end();
-}));
+    socket = res.socket;
+    const onTimeout = socket._onTimeout;
+    socket._onTimeout = common.mustCallAtLeast(() => onTimeout.call(socket), 1);
+    res.write(content);
+    res.end();
+  })
+);
 server.on('timeout', common.mustNotCall());
 
-server.listen(0, common.mustCall(() => {
-  https.get({
-    path: '/',
-    port: server.address().port,
-    rejectUnauthorized: false
-  }, (res) => {
-    res.once('data', () => {
-      socket._onTimeout();
-      res.on('data', () => {});
-    });
-    res.on('end', () => server.close());
-  });
-}));
+server.listen(
+  0,
+  common.mustCall(() => {
+    https.get(
+      {
+        path: '/',
+        port: server.address().port,
+        rejectUnauthorized: false
+      },
+      (res) => {
+        res.once('data', () => {
+          socket._onTimeout();
+          res.on('data', () => {});
+        });
+        res.on('end', () => server.close());
+      }
+    );
+  })
+);
diff --git a/test/sequential/test-https-server-keep-alive-timeout.js b/test/sequential/test-https-server-keep-alive-timeout.js
index 3c18d325c15b93..7a7c23e150a479 100644
--- a/test/sequential/test-https-server-keep-alive-timeout.js
+++ b/test/sequential/test-https-server-keep-alive-timeout.js
@@ -2,8 +2,7 @@
 
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 const https = require('https');
@@ -33,47 +32,66 @@ test(function serverKeepAliveTimeoutWithPipeline(cb) {
     serverOptions,
     common.mustCall((req, res) => {
       res.end();
-    }, 3));
-  server.setTimeout(500, common.mustCall((socket) => {
-    // End this test and call `run()` for the next test (if any).
-    socket.destroy();
-    server.close();
-    cb();
-  }));
+    }, 3)
+  );
+  server.setTimeout(
+    500,
+    common.mustCall((socket) => {
+      // End this test and call `run()` for the next test (if any).
+      socket.destroy();
+      server.close();
+      cb();
+    })
+  );
   server.keepAliveTimeout = 50;
-  server.listen(0, common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true,
-      rejectUnauthorized: false
-    };
-    const c = tls.connect(options, () => {
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-    });
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true,
+        rejectUnauthorized: false
+      };
+      const c = tls.connect(
+        options,
+        () => {
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+        }
+      );
+    })
+  );
 });
 
 test(function serverNoEndKeepAliveTimeoutWithPipeline(cb) {
   const server = https.createServer(serverOptions, common.mustCall(3));
-  server.setTimeout(500, common.mustCall((socket) => {
-    // End this test and call `run()` for the next test (if any).
-    socket.destroy();
-    server.close();
-    cb();
-  }));
+  server.setTimeout(
+    500,
+    common.mustCall((socket) => {
+      // End this test and call `run()` for the next test (if any).
+      socket.destroy();
+      server.close();
+      cb();
+    })
+  );
   server.keepAliveTimeout = 50;
-  server.listen(0, common.mustCall(() => {
-    const options = {
-      port: server.address().port,
-      allowHalfOpen: true,
-      rejectUnauthorized: false
-    };
-    const c = tls.connect(options, () => {
-      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-      c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
-    });
-  }));
+  server.listen(
+    0,
+    common.mustCall(() => {
+      const options = {
+        port: server.address().port,
+        allowHalfOpen: true,
+        rejectUnauthorized: false
+      };
+      const c = tls.connect(
+        options,
+        () => {
+          c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+          c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+        }
+      );
+    })
+  );
 });
diff --git a/test/sequential/test-init.js b/test/sequential/test-init.js
index 1b1b09ee833191..d331bf7f3d404d 100644
--- a/test/sequential/test-init.js
+++ b/test/sequential/test-init.js
@@ -36,10 +36,14 @@ process.env.TEST_INIT = 1;
 
 function test(file, expected) {
   const path = `"${process.execPath}" ${file}`;
-  child.exec(path, { env: process.env }, common.mustCall((err, out) => {
-    assert.ifError(err);
-    assert.strictEqual(out, expected, `'node ${file}' failed!`);
-  }));
+  child.exec(
+    path,
+    { env: process.env },
+    common.mustCall((err, out) => {
+      assert.ifError(err);
+      assert.strictEqual(out, expected, `'node ${file}' failed!`);
+    })
+  );
 }
 
 {
diff --git a/test/sequential/test-inspector-async-call-stack.js b/test/sequential/test-inspector-async-call-stack.js
index f6a48b339d4cc8..a5c33a42705e9d 100644
--- a/test/sequential/test-inspector-async-call-stack.js
+++ b/test/sequential/test-inspector-async-call-stack.js
@@ -36,19 +36,22 @@ session.post('Debugger.enable', () => {
     verifyAsyncHookDisabled('invalid message should not enable async hooks');
 
     session.post(setDepth, { maxDepth: 'five' }, () => {
-      verifyAsyncHookDisabled('invalid maxDepth (string) should not enable ' +
-                              'async hooks');
+      verifyAsyncHookDisabled(
+        'invalid maxDepth (string) should not enable ' + 'async hooks'
+      );
 
       session.post(setDepth, { maxDepth: NaN }, () => {
-        verifyAsyncHookDisabled('invalid maxDepth (NaN) should not enable ' +
-                                'async hooks');
+        verifyAsyncHookDisabled(
+          'invalid maxDepth (NaN) should not enable ' + 'async hooks'
+        );
 
         session.post(setDepth, { maxDepth: 10 }, () => {
           verifyAsyncHookEnabled('valid message should enable async hooks');
 
           session.post(setDepth, { maxDepth: 0 }, () => {
-            verifyAsyncHookDisabled('Setting maxDepth to 0 should disable ' +
-                                    'async hooks');
+            verifyAsyncHookDisabled(
+              'Setting maxDepth to 0 should disable ' + 'async hooks'
+            );
 
             runTestSet2(session);
           });
@@ -72,8 +75,9 @@ function runTestSet2(session) {
           verifyAsyncHookEnabled('valid message should enable async hooks');
 
           session.disconnect();
-          verifyAsyncHookDisabled('Disconnecting session should disable ' +
-                                  'async hooks');
+          verifyAsyncHookDisabled(
+            'Disconnecting session should disable ' + 'async hooks'
+          );
         });
       });
     });
diff --git a/test/sequential/test-inspector-async-hook-setup-at-inspect-brk.js b/test/sequential/test-inspector-async-hook-setup-at-inspect-brk.js
index a1b8f301e07d55..5d15421fdb48d1 100644
--- a/test/sequential/test-inspector-async-hook-setup-at-inspect-brk.js
+++ b/test/sequential/test-inspector-async-hook-setup-at-inspect-brk.js
@@ -15,30 +15,33 @@ setTimeout(() => {
 
 async function skipBreakpointAtStart(session) {
   await session.waitForBreakOnLine(3, '[eval]');
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
 }
 
 async function checkAsyncStackTrace(session) {
   console.error('[test]', 'Verify basic properties of asyncStackTrace');
   const paused = await session.waitForBreakOnLine(4, '[eval]');
-  assert(paused.params.asyncStackTrace,
-         `${Object.keys(paused.params)} contains "asyncStackTrace" property`);
+  assert(
+    paused.params.asyncStackTrace,
+    `${Object.keys(paused.params)} contains "asyncStackTrace" property`
+  );
   assert(paused.params.asyncStackTrace.description, 'Timeout');
-  assert(paused.params.asyncStackTrace.callFrames
-           .some((frame) => frame.functionName === 'Module._compile'));
+  assert(
+    paused.params.asyncStackTrace.callFrames.some(
+      (frame) => frame.functionName === 'Module._compile'
+    )
+  );
 }
 
 async function runTests() {
   const instance = new NodeInstance(undefined, script);
   const session = await instance.connectInspectorSession();
   await session.send([
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 10 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 10 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ]);
   await skipBreakpointAtStart(session);
   await checkAsyncStackTrace(session);
diff --git a/test/sequential/test-inspector-async-hook-setup-at-signal.js b/test/sequential/test-inspector-async-hook-setup-at-signal.js
index 139678a1e5a493..9d7db056107505 100644
--- a/test/sequential/test-inspector-async-hook-setup-at-signal.js
+++ b/test/sequential/test-inspector-async-hook-setup-at-signal.js
@@ -42,33 +42,38 @@ async function waitForInitialSetup(session) {
 async function setupTimeoutForStackTrace(session) {
   console.error('[test]', 'Setting up timeout for async stack trace');
   await session.send([
-    { 'method': 'Runtime.evaluate',
-      'params': { expression: 'setupTimeoutWithBreak()' } },
-    { 'method': 'Debugger.resume' }
+    {
+      method: 'Runtime.evaluate',
+      params: { expression: 'setupTimeoutWithBreak()' }
+    },
+    { method: 'Debugger.resume' }
   ]);
 }
 
 async function checkAsyncStackTrace(session) {
   console.error('[test]', 'Verify basic properties of asyncStackTrace');
   const paused = await session.waitForBreakOnLine(22, '[eval]');
-  assert(paused.params.asyncStackTrace,
-         `${Object.keys(paused.params)} contains "asyncStackTrace" property`);
+  assert(
+    paused.params.asyncStackTrace,
+    `${Object.keys(paused.params)} contains "asyncStackTrace" property`
+  );
   assert(paused.params.asyncStackTrace.description, 'Timeout');
-  assert(paused.params.asyncStackTrace.callFrames
-           .some((frame) => frame.functionName === 'setupTimeoutWithBreak'));
+  assert(
+    paused.params.asyncStackTrace.callFrames.some(
+      (frame) => frame.functionName === 'setupTimeoutWithBreak'
+    )
+  );
 }
 
 async function runTests() {
   const instance = await NodeInstance.startViaSignal(script);
   const session = await instance.connectInspectorSession();
   await session.send([
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 10 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 10 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ]);
 
   await waitForInitialSetup(session);
diff --git a/test/sequential/test-inspector-async-stack-traces-promise-then.js b/test/sequential/test-inspector-async-stack-traces-promise-then.js
index 11905431d5e524..cc6227e4db0bf8 100644
--- a/test/sequential/test-inspector-async-stack-traces-promise-then.js
+++ b/test/sequential/test-inspector-async-stack-traces-promise-then.js
@@ -22,27 +22,31 @@ async function runTests() {
   const instance = new NodeInstance(undefined, script);
   const session = await instance.connectInspectorSession();
   await session.send([
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 10 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 10 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ]);
 
   await session.waitForBreakOnLine(2, '[eval]');
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
 
   console.error('[test] Waiting for break1');
-  debuggerPausedAt(await session.waitForBreakOnLine(6, '[eval]'),
-                   'break1', 'runTest:5');
+  debuggerPausedAt(
+    await session.waitForBreakOnLine(6, '[eval]'),
+    'break1',
+    'runTest:5'
+  );
 
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
 
   console.error('[test] Waiting for break2');
-  debuggerPausedAt(await session.waitForBreakOnLine(9, '[eval]'),
-                   'break2', 'runTest:8');
+  debuggerPausedAt(
+    await session.waitForBreakOnLine(9, '[eval]'),
+    'break2',
+    'runTest:8'
+  );
 
   await session.runToCompletion();
   assert.strictEqual((await instance.expectShutdown()).exitCode, 0);
@@ -51,13 +55,15 @@ async function runTests() {
 function debuggerPausedAt(msg, functionName, previousTickLocation) {
   assert(
     !!msg.params.asyncStackTrace,
-    `${Object.keys(msg.params)} contains "asyncStackTrace" property`);
+    `${Object.keys(msg.params)} contains "asyncStackTrace" property`
+  );
 
   assert.strictEqual(msg.params.callFrames[0].functionName, functionName);
   assert.strictEqual(msg.params.asyncStackTrace.description, 'Promise.then');
 
   const frameLocations = msg.params.asyncStackTrace.callFrames.map(
-    (frame) => `${frame.functionName}:${frame.lineNumber}`);
+    (frame) => `${frame.functionName}:${frame.lineNumber}`
+  );
   assertArrayIncludes(frameLocations, previousTickLocation);
 }
 
@@ -66,7 +72,8 @@ function assertArrayIncludes(actual, expected) {
   const actualString = JSON.stringify(actual);
   assert(
     actual.includes(expected),
-    `Expected ${actualString} to contain ${expectedString}.`);
+    `Expected ${actualString} to contain ${expectedString}.`
+  );
 }
 
 runTests();
diff --git a/test/sequential/test-inspector-async-stack-traces-set-interval.js b/test/sequential/test-inspector-async-stack-traces-set-interval.js
index 240074f631f329..1fa23e826afd9d 100644
--- a/test/sequential/test-inspector-async-stack-traces-set-interval.js
+++ b/test/sequential/test-inspector-async-stack-traces-set-interval.js
@@ -11,30 +11,33 @@ const script = 'setInterval(() => { debugger; }, 50);';
 async function skipFirstBreakpoint(session) {
   console.log('[test]', 'Skipping the first breakpoint in the eval script');
   await session.waitForBreakOnLine(2, '[eval]');
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
 }
 
 async function checkAsyncStackTrace(session) {
   console.error('[test]', 'Verify basic properties of asyncStackTrace');
   const paused = await session.waitForBreakOnLine(2, '[eval]');
-  assert(paused.params.asyncStackTrace,
-         `${Object.keys(paused.params)} contains "asyncStackTrace" property`);
+  assert(
+    paused.params.asyncStackTrace,
+    `${Object.keys(paused.params)} contains "asyncStackTrace" property`
+  );
   assert(paused.params.asyncStackTrace.description, 'Timeout');
-  assert(paused.params.asyncStackTrace.callFrames
-           .some((frame) => frame.functionName === 'Module._compile'));
+  assert(
+    paused.params.asyncStackTrace.callFrames.some(
+      (frame) => frame.functionName === 'Module._compile'
+    )
+  );
 }
 
 async function runTests() {
   const instance = new NodeInstance(undefined, script);
   const session = await instance.connectInspectorSession();
   await session.send([
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 10 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 10 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ]);
 
   await skipFirstBreakpoint(session);
diff --git a/test/sequential/test-inspector-bindings.js b/test/sequential/test-inspector-bindings.js
index f5583c1d7bc6d6..7c30445951e0ff 100644
--- a/test/sequential/test-inspector-bindings.js
+++ b/test/sequential/test-inspector-bindings.js
@@ -20,12 +20,16 @@ function debuggedFunction() {
 let scopeCallback = null;
 
 function checkScope(session, scopeId) {
-  session.post('Runtime.getProperties', {
-    'objectId': scopeId,
-    'ownProperties': false,
-    'accessorPropertiesOnly': false,
-    'generatePreview': true
-  }, scopeCallback);
+  session.post(
+    'Runtime.getProperties',
+    {
+      objectId: scopeId,
+      ownProperties: false,
+      accessorPropertiesOnly: false,
+      generatePreview: true
+    },
+    scopeCallback
+  );
 }
 
 function debuggerPausedCallback(session, notification) {
@@ -52,7 +56,9 @@ async function testNoCrashWithExceptionInCallback() {
   const error = new Error('We expect this');
   console.log('Expecting warning to be emitted');
   const promise = new Promise(waitForWarningSkipAsyncStackTraces);
-  session.post('Console.enable', () => { throw error; });
+  session.post('Console.enable', () => {
+    throw error;
+  });
   assert.strictEqual(await promise, error);
   session.disconnect();
 }
@@ -71,25 +77,28 @@ function testSampleDebugSession() {
       actual = v.value.value;
       expected = expects[v.name][i];
       if (actual !== expected) {
-        failures.push(`Iteration ${i} variable: ${v.name} ` +
-          `expected: ${expected} actual: ${actual}`);
+        failures.push(
+          `Iteration ${i} variable: ${v.name} ` +
+            `expected: ${expected} actual: ${actual}`
+        );
       }
     }
   };
   const session = new inspector.Session();
   session.connect();
-  session.on('Debugger.paused',
-             (notification) => debuggerPausedCallback(session, notification));
+  session.on('Debugger.paused', (notification) =>
+    debuggerPausedCallback(session, notification)
+  );
   let cbAsSecondArgCalled = false;
   assert.throws(() => {
     session.post('Debugger.enable', function() {}, function() {});
   }, TypeError);
-  session.post('Debugger.enable', () => cbAsSecondArgCalled = true);
+  session.post('Debugger.enable', () => (cbAsSecondArgCalled = true));
   session.post('Debugger.setBreakpointByUrl', {
-    'lineNumber': 14,
-    'url': pathToFileURL(path.resolve(__dirname, __filename)).toString(),
-    'columnNumber': 0,
-    'condition': ''
+    lineNumber: 14,
+    url: pathToFileURL(path.resolve(__dirname, __filename)).toString(),
+    columnNumber: 0,
+    condition: ''
   });
 
   debuggedFunction();
@@ -107,8 +116,7 @@ async function testNoCrashConsoleLogBeforeThrow() {
   let attempt = 1;
   process.on('warning', common.mustCall(3));
   session.on('inspectorNotification', () => {
-    if (attempt++ > 3)
-      return;
+    if (attempt++ > 3) return;
     console.log('console.log in handler');
     throw new Error('Exception in handler');
   });
diff --git a/test/sequential/test-inspector-break-e.js b/test/sequential/test-inspector-break-e.js
index 954ce6b8978802..55c40366479330 100644
--- a/test/sequential/test-inspector-break-e.js
+++ b/test/sequential/test-inspector-break-e.js
@@ -10,9 +10,9 @@ async function runTests() {
   const instance = new NodeInstance(undefined, 'console.log(10)');
   const session = await instance.connectInspectorSession();
   await session.send([
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ]);
   await session.waitForBreakOnLine(2, '[eval]');
   await session.runToCompletion();
diff --git a/test/sequential/test-inspector-break-when-eval.js b/test/sequential/test-inspector-break-when-eval.js
index 9952650252310e..d8ec6d9fa7ef65 100644
--- a/test/sequential/test-inspector-break-when-eval.js
+++ b/test/sequential/test-inspector-break-when-eval.js
@@ -12,11 +12,10 @@ const script = fixtures.path('inspector-global-function.js');
 async function setupDebugger(session) {
   console.log('[test]', 'Setting up a debugger');
   const commands = [
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 0 } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' },
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 0 } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ];
   session.send(commands);
   await session.waitForNotification('Runtime.consoleAPICalled');
@@ -25,23 +24,27 @@ async function setupDebugger(session) {
 async function breakOnLine(session) {
   console.log('[test]', 'Breaking in the code');
   const commands = [
-    { 'method': 'Debugger.setBreakpointByUrl',
-      'params': { 'lineNumber': 9,
-                  'url': pathToFileURL(script).toString(),
-                  'columnNumber': 0,
-                  'condition': ''
+    {
+      method: 'Debugger.setBreakpointByUrl',
+      params: {
+        lineNumber: 9,
+        url: pathToFileURL(script).toString(),
+        columnNumber: 0,
+        condition: ''
       }
     },
-    { 'method': 'Runtime.evaluate',
-      'params': { 'expression': 'sum()',
-                  'objectGroup': 'console',
-                  'includeCommandLineAPI': true,
-                  'silent': false,
-                  'contextId': 1,
-                  'returnByValue': false,
-                  'generatePreview': true,
-                  'userGesture': true,
-                  'awaitPromise': false
+    {
+      method: 'Runtime.evaluate',
+      params: {
+        expression: 'sum()',
+        objectGroup: 'console',
+        includeCommandLineAPI: true,
+        silent: false,
+        contextId: 1,
+        returnByValue: false,
+        generatePreview: true,
+        userGesture: true,
+        awaitPromise: false
       }
     }
   ];
@@ -51,7 +54,7 @@ async function breakOnLine(session) {
 
 async function stepOverConsoleStatement(session) {
   console.log('[test]', 'Step over console statement and test output');
-  session.send({ 'method': 'Debugger.stepOver' });
+  session.send({ method: 'Debugger.stepOver' });
   await session.waitForConsoleOutput('log', [0, 3]);
   await session.waitForNotification('Debugger.paused');
 }
diff --git a/test/sequential/test-inspector-console.js b/test/sequential/test-inspector-console.js
index 3d36e9328dd529..229cd7a368e101 100644
--- a/test/sequential/test-inspector-console.js
+++ b/test/sequential/test-inspector-console.js
@@ -8,17 +8,17 @@ const { NodeInstance } = require('../common/inspector-helper.js');
 const assert = require('assert');
 
 async function runTest() {
-  const script = 'require(\'inspector\').console.log(\'hello world\');';
+  const script = "require('inspector').console.log('hello world');";
   const child = new NodeInstance('--inspect-brk=0', script, '');
 
   let out = '';
-  child.on('stdout', (line) => out += line);
+  child.on('stdout', (line) => (out += line));
 
   const session = await child.connectInspectorSession();
 
   const commands = [
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ];
 
   session.send(commands);
@@ -26,10 +26,12 @@ async function runTest() {
   const msg = await session.waitForNotification('Runtime.consoleAPICalled');
 
   assert.strictEqual(msg.params.type, 'log');
-  assert.deepStrictEqual(msg.params.args, [{
-    type: 'string',
-    value: 'hello world'
-  }]);
+  assert.deepStrictEqual(msg.params.args, [
+    {
+      type: 'string',
+      value: 'hello world'
+    }
+  ]);
   assert.strictEqual(out, '');
 
   session.disconnect();
diff --git a/test/sequential/test-inspector-contexts.js b/test/sequential/test-inspector-contexts.js
index 793868e3bc072c..1bb2e8dd03fa49 100644
--- a/test/sequential/test-inspector-contexts.js
+++ b/test/sequential/test-inspector-contexts.js
@@ -19,8 +19,9 @@ function notificationPromise(method) {
 async function testContextCreatedAndDestroyed() {
   console.log('Testing context created/destroyed notifications');
   {
-    const mainContextPromise =
-        notificationPromise('Runtime.executionContextCreated');
+    const mainContextPromise = notificationPromise(
+      'Runtime.executionContextCreated'
+    );
 
     session.post('Runtime.enable');
     const contextCreated = await mainContextPromise;
@@ -39,110 +40,116 @@ async function testContextCreatedAndDestroyed() {
       }
       strictEqual(expects, name);
     }
-    strictEqual(origin, '',
-                JSON.stringify(contextCreated));
-    strictEqual(auxData.isDefault, true,
-                JSON.stringify(contextCreated));
+    strictEqual(origin, '', JSON.stringify(contextCreated));
+    strictEqual(auxData.isDefault, true, JSON.stringify(contextCreated));
   }
 
   {
-    const vmContextCreatedPromise =
-        notificationPromise('Runtime.executionContextCreated');
+    const vmContextCreatedPromise = notificationPromise(
+      'Runtime.executionContextCreated'
+    );
 
     let contextDestroyed = null;
-    session.once('Runtime.executionContextDestroyed',
-                 (notification) => contextDestroyed = notification);
+    session.once(
+      'Runtime.executionContextDestroyed',
+      (notification) => (contextDestroyed = notification)
+    );
 
     runInNewContext('1 + 1');
 
     const contextCreated = await vmContextCreatedPromise;
     const { id, name, origin, auxData } = contextCreated.params.context;
-    strictEqual(name, 'VM Context 1',
-                JSON.stringify(contextCreated));
-    strictEqual(origin, '',
-                JSON.stringify(contextCreated));
-    strictEqual(auxData.isDefault, false,
-                JSON.stringify(contextCreated));
+    strictEqual(name, 'VM Context 1', JSON.stringify(contextCreated));
+    strictEqual(origin, '', JSON.stringify(contextCreated));
+    strictEqual(auxData.isDefault, false, JSON.stringify(contextCreated));
 
     // GC is unpredictable...
-    while (!contextDestroyed)
-      global.gc();
+    while (!contextDestroyed) global.gc();
 
-    strictEqual(contextDestroyed.params.executionContextId, id,
-                JSON.stringify(contextDestroyed));
+    strictEqual(
+      contextDestroyed.params.executionContextId,
+      id,
+      JSON.stringify(contextDestroyed)
+    );
   }
 
   {
-    const vmContextCreatedPromise =
-        notificationPromise('Runtime.executionContextCreated');
+    const vmContextCreatedPromise = notificationPromise(
+      'Runtime.executionContextCreated'
+    );
 
     let contextDestroyed = null;
-    session.once('Runtime.executionContextDestroyed',
-                 (notification) => contextDestroyed = notification);
-
-    runInNewContext('1 + 1', {}, {
-      contextName: 'Custom context',
-      contextOrigin: 'https://origin.example'
-    });
+    session.once(
+      'Runtime.executionContextDestroyed',
+      (notification) => (contextDestroyed = notification)
+    );
+
+    runInNewContext(
+      '1 + 1',
+      {},
+      {
+        contextName: 'Custom context',
+        contextOrigin: 'https://origin.example'
+      }
+    );
 
     const contextCreated = await vmContextCreatedPromise;
     const { name, origin, auxData } = contextCreated.params.context;
-    strictEqual(name, 'Custom context',
-                JSON.stringify(contextCreated));
-    strictEqual(origin, 'https://origin.example',
-                JSON.stringify(contextCreated));
-    strictEqual(auxData.isDefault, false,
-                JSON.stringify(contextCreated));
+    strictEqual(name, 'Custom context', JSON.stringify(contextCreated));
+    strictEqual(
+      origin,
+      'https://origin.example',
+      JSON.stringify(contextCreated)
+    );
+    strictEqual(auxData.isDefault, false, JSON.stringify(contextCreated));
 
     // GC is unpredictable...
-    while (!contextDestroyed)
-      global.gc();
+    while (!contextDestroyed) global.gc();
   }
 
   {
-    const vmContextCreatedPromise =
-        notificationPromise('Runtime.executionContextCreated');
+    const vmContextCreatedPromise = notificationPromise(
+      'Runtime.executionContextCreated'
+    );
 
     let contextDestroyed = null;
-    session.once('Runtime.executionContextDestroyed',
-                 (notification) => contextDestroyed = notification);
+    session.once(
+      'Runtime.executionContextDestroyed',
+      (notification) => (contextDestroyed = notification)
+    );
 
     createContext({}, { origin: 'https://nodejs.org' });
 
     const contextCreated = await vmContextCreatedPromise;
     const { name, origin, auxData } = contextCreated.params.context;
-    strictEqual(name, 'VM Context 2',
-                JSON.stringify(contextCreated));
-    strictEqual(origin, 'https://nodejs.org',
-                JSON.stringify(contextCreated));
-    strictEqual(auxData.isDefault, false,
-                JSON.stringify(contextCreated));
+    strictEqual(name, 'VM Context 2', JSON.stringify(contextCreated));
+    strictEqual(origin, 'https://nodejs.org', JSON.stringify(contextCreated));
+    strictEqual(auxData.isDefault, false, JSON.stringify(contextCreated));
 
     // GC is unpredictable...
-    while (!contextDestroyed)
-      global.gc();
+    while (!contextDestroyed) global.gc();
   }
 
   {
-    const vmContextCreatedPromise =
-        notificationPromise('Runtime.executionContextCreated');
+    const vmContextCreatedPromise = notificationPromise(
+      'Runtime.executionContextCreated'
+    );
 
     let contextDestroyed = null;
-    session.once('Runtime.executionContextDestroyed',
-                 (notification) => contextDestroyed = notification);
+    session.once(
+      'Runtime.executionContextDestroyed',
+      (notification) => (contextDestroyed = notification)
+    );
 
     createContext({}, { name: 'Custom context 2' });
 
     const contextCreated = await vmContextCreatedPromise;
     const { name, auxData } = contextCreated.params.context;
-    strictEqual(name, 'Custom context 2',
-                JSON.stringify(contextCreated));
-    strictEqual(auxData.isDefault, false,
-                JSON.stringify(contextCreated));
+    strictEqual(name, 'Custom context 2', JSON.stringify(contextCreated));
+    strictEqual(auxData.isDefault, false, JSON.stringify(contextCreated));
 
     // GC is unpredictable...
-    while (!contextDestroyed)
-      global.gc();
+    while (!contextDestroyed) global.gc();
   }
 }
 
diff --git a/test/sequential/test-inspector-debug-brk-flag.js b/test/sequential/test-inspector-debug-brk-flag.js
index 7fa85c269c9343..713531d35385af 100644
--- a/test/sequential/test-inspector-debug-brk-flag.js
+++ b/test/sequential/test-inspector-debug-brk-flag.js
@@ -9,18 +9,14 @@ const { NodeInstance } = require('../common/inspector-helper.js');
 
 async function testBreakpointOnStart(session) {
   const commands = [
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setPauseOnExceptions',
-      'params': { 'state': 'none' } },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 0 } },
-    { 'method': 'Profiler.enable' },
-    { 'method': 'Profiler.setSamplingInterval',
-      'params': { 'interval': 100 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setPauseOnExceptions', params: { state: 'none' } },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 0 } },
+    { method: 'Profiler.enable' },
+    { method: 'Profiler.setSamplingInterval', params: { interval: 100 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ];
 
   session.send(commands);
diff --git a/test/sequential/test-inspector-debug-end.js b/test/sequential/test-inspector-debug-end.js
index d73e7dccc1a8fe..26817542dba87e 100644
--- a/test/sequential/test-inspector-debug-end.js
+++ b/test/sequential/test-inspector-debug-end.js
@@ -6,22 +6,26 @@ const { strictEqual } = require('assert');
 const { NodeInstance } = require('../common/inspector-helper.js');
 
 async function testNoServerNoCrash() {
-  console.log('Test there\'s no crash stopping server that was not started');
-  const instance = new NodeInstance([],
-                                    `process._debugEnd();
-                                     process.exit(42);`);
+  console.log("Test there's no crash stopping server that was not started");
+  const instance = new NodeInstance(
+    [],
+    `process._debugEnd();
+                                     process.exit(42);`
+  );
   strictEqual(42, (await instance.expectShutdown()).exitCode);
 }
 
 async function testNoSessionNoCrash() {
-  console.log('Test there\'s no crash stopping server without connecting');
-  const instance = new NodeInstance('--inspect=0',
-                                    'process._debugEnd();process.exit(42);');
+  console.log("Test there's no crash stopping server without connecting");
+  const instance = new NodeInstance(
+    '--inspect=0',
+    'process._debugEnd();process.exit(42);'
+  );
   strictEqual(42, (await instance.expectShutdown()).exitCode);
 }
 
 async function testSessionNoCrash() {
-  console.log('Test there\'s no crash stopping server after connecting');
+  console.log("Test there's no crash stopping server after connecting");
   const script = `process._debugEnd();
                   process._debugProcess(process.pid);
                   setTimeout(() => {
@@ -31,7 +35,7 @@ async function testSessionNoCrash() {
 
   const instance = new NodeInstance('--inspect-brk=0', script);
   const session = await instance.connectInspectorSession();
-  await session.send({ 'method': 'Runtime.runIfWaitingForDebugger' });
+  await session.send({ method: 'Runtime.runIfWaitingForDebugger' });
   await session.waitForServerDisconnect();
   strictEqual(42, (await instance.expectShutdown()).exitCode);
 }
diff --git a/test/sequential/test-inspector-exception.js b/test/sequential/test-inspector-exception.js
index de089ec240f148..3343a93ebc4ce8 100644
--- a/test/sequential/test-inspector-exception.js
+++ b/test/sequential/test-inspector-exception.js
@@ -12,28 +12,25 @@ const { pathToFileURL } = require('url');
 const script = fixtures.path('throws_error.js');
 
 async function testBreakpointOnStart(session) {
-  console.log('[test]',
-              'Verifying debugger stops on start (--inspect-brk option)');
+  console.log(
+    '[test]',
+    'Verifying debugger stops on start (--inspect-brk option)'
+  );
   const commands = [
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setPauseOnExceptions',
-      'params': { 'state': 'none' } },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 0 } },
-    { 'method': 'Profiler.enable' },
-    { 'method': 'Profiler.setSamplingInterval',
-      'params': { 'interval': 100 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setPauseOnExceptions', params: { state: 'none' } },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 0 } },
+    { method: 'Profiler.enable' },
+    { method: 'Profiler.setSamplingInterval', params: { interval: 100 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ];
 
   await session.send(commands);
   await session.waitForBreakOnLine(21, pathToFileURL(script).toString());
 }
 
-
 async function runTest() {
   const child = new NodeInstance(undefined, undefined, script);
   const session = await child.connectInspectorSession();
diff --git a/test/sequential/test-inspector-has-inspector-false.js b/test/sequential/test-inspector-has-inspector-false.js
index cdb7ca9e19e79b..8d7df28d040b2e 100644
--- a/test/sequential/test-inspector-has-inspector-false.js
+++ b/test/sequential/test-inspector-has-inspector-false.js
@@ -11,5 +11,5 @@ const inspector = require('internal/util/inspector');
 
 inspector.sendInspectorCommand(
   common.mustNotCall('Inspector callback should not be called'),
-  common.mustCall(1),
+  common.mustCall(1)
 );
diff --git a/test/sequential/test-inspector-ip-detection.js b/test/sequential/test-inspector-ip-detection.js
index 4e0f9b871b8ab0..9bf8635a5d9348 100644
--- a/test/sequential/test-inspector-ip-detection.js
+++ b/test/sequential/test-inspector-ip-detection.js
@@ -10,8 +10,7 @@ const os = require('os');
 
 const ip = pickIPv4Address();
 
-if (!ip)
-  common.skip('No IP address found');
+if (!ip) common.skip('No IP address found');
 
 function checkIpAddress(ip, response) {
   const res = response[0];
@@ -25,8 +24,7 @@ function checkIpAddress(ip, response) {
 
 function pickIPv4Address() {
   for (const i of [].concat(...Object.values(os.networkInterfaces()))) {
-    if (i.family === 'IPv4' && i.address !== '127.0.0.1')
-      return i.address;
+    if (i.family === 'IPv4' && i.address !== '127.0.0.1') return i.address;
   }
 }
 
diff --git a/test/sequential/test-inspector-module.js b/test/sequential/test-inspector-module.js
index 26bb7fe9262889..19c9ecebf72385 100644
--- a/test/sequential/test-inspector-module.js
+++ b/test/sequential/test-inspector-module.js
@@ -21,50 +21,38 @@ session.connect();
 session.post('Runtime.evaluate', { expression: '2 + 2' });
 
 [1, {}, [], true, Infinity, undefined].forEach((i) => {
-  common.expectsError(
-    () => session.post(i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message:
-        'The "method" argument must be of type string. ' +
-        `Received type ${typeof i}`
-    }
-  );
+  common.expectsError(() => session.post(i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "method" argument must be of type string. ' +
+      `Received type ${typeof i}`
+  });
 });
 
 [1, true, Infinity].forEach((i) => {
-  common.expectsError(
-    () => session.post('test', i),
-    {
-      code: 'ERR_INVALID_ARG_TYPE',
-      type: TypeError,
-      message:
-        'The "params" argument must be of type Object. ' +
-        `Received type ${typeof i}`
-    }
-  );
+  common.expectsError(() => session.post('test', i), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message:
+      'The "params" argument must be of type Object. ' +
+      `Received type ${typeof i}`
+  });
 });
 
 [1, 'a', {}, [], true, Infinity].forEach((i) => {
-  common.expectsError(
-    () => session.post('test', {}, i),
-    {
-      code: 'ERR_INVALID_CALLBACK',
-      type: TypeError,
-      message: 'Callback must be a function'
-    }
-  );
+  common.expectsError(() => session.post('test', {}, i), {
+    code: 'ERR_INVALID_CALLBACK',
+    type: TypeError,
+    message: 'Callback must be a function'
+  });
 });
 
-common.expectsError(
-  () => session.connect(),
-  {
-    code: 'ERR_INSPECTOR_ALREADY_CONNECTED',
-    type: Error,
-    message: 'The inspector session is already connected'
-  }
-);
+common.expectsError(() => session.connect(), {
+  code: 'ERR_INSPECTOR_ALREADY_CONNECTED',
+  type: Error,
+  message: 'The inspector session is already connected'
+});
 
 session.disconnect();
 // Calling disconnect twice should not throw.
diff --git a/test/sequential/test-inspector-not-blocked-on-idle.js b/test/sequential/test-inspector-not-blocked-on-idle.js
index b5a16316dece9f..221b6fff5433f0 100644
--- a/test/sequential/test-inspector-not-blocked-on-idle.js
+++ b/test/sequential/test-inspector-not-blocked-on-idle.js
@@ -11,8 +11,8 @@ async function runTests() {
   await new Promise((resolve) => setTimeout(() => resolve(), 1000));
   const session = await node.connectInspectorSession();
   await session.send([
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.pause' }
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.pause' }
   ]);
   session.disconnect();
   node.kill();
diff --git a/test/sequential/test-inspector-open.js b/test/sequential/test-inspector-open.js
index a0d2eaf1f3415a..03c66c374be967 100644
--- a/test/sequential/test-inspector-open.js
+++ b/test/sequential/test-inspector-open.js
@@ -10,18 +10,21 @@ const fork = require('child_process').fork;
 const net = require('net');
 const url = require('url');
 
-if (process.env.BE_CHILD)
-  return beChild();
+if (process.env.BE_CHILD) return beChild();
 
-const child = fork(__filename,
-                   { env: Object.assign({}, process.env, { BE_CHILD: 1 }) });
+const child = fork(__filename, {
+  env: Object.assign({}, process.env, { BE_CHILD: 1 })
+});
 
-child.once('message', common.mustCall((msg) => {
-  assert.strictEqual(msg.cmd, 'started');
+child.once(
+  'message',
+  common.mustCall((msg) => {
+    assert.strictEqual(msg.cmd, 'started');
 
-  child.send({ cmd: 'open', args: [0] });
-  child.once('message', common.mustCall(firstOpen));
-}));
+    child.send({ cmd: 'open', args: [0] });
+    child.once('message', common.mustCall(firstOpen));
+  })
+);
 
 let firstPort;
 
@@ -76,9 +79,14 @@ function reopenAfterClose(msg) {
 }
 
 function ping(port, callback) {
-  net.connect(port)
-    .on('connect', function() { close(this); })
-    .on('error', function(err) { close(this, err); });
+  net
+    .connect(port)
+    .on('connect', function() {
+      close(this);
+    })
+    .on('error', function(err) {
+      close(this, err);
+    });
 
   function close(self, err) {
     self.end();
diff --git a/test/sequential/test-inspector-overwrite-config.js b/test/sequential/test-inspector-overwrite-config.js
index 49f48a59a04b4f..1142f1cad45dc2 100644
--- a/test/sequential/test-inspector-overwrite-config.js
+++ b/test/sequential/test-inspector-overwrite-config.js
@@ -14,8 +14,7 @@
 const common = require('../common');
 const assert = require('assert');
 
-if (!common.isMainThread)
-  common.skip('--require does not work with Workers');
+if (!common.isMainThread) common.skip('--require does not work with Workers');
 
 const inspector = require('inspector');
 const msg = 'Test inspector logging';
diff --git a/test/sequential/test-inspector-port-cluster.js b/test/sequential/test-inspector-port-cluster.js
index b58dbd83b6159a..82814f10a1a5f7 100644
--- a/test/sequential/test-inspector-port-cluster.js
+++ b/test/sequential/test-inspector-port-cluster.js
@@ -105,10 +105,7 @@ function testRunnerMain() {
   spawnMaster({
     execArgv: [`--inspect=${port}`],
     clusterSettings: { inspectPort: 'addTwo' },
-    workers: [
-      { expectedPort: port + 2 },
-      { expectedPort: port + 4 }
-    ]
+    workers: [{ expectedPort: port + 2 }, { expectedPort: port + 4 }]
   });
 
   port = debuggerPort + offset++ * 5;
@@ -164,9 +161,7 @@ function testRunnerMain() {
   spawnMaster({
     execArgv: [],
     clusterSettings: { inspectPort: port, execArgv: ['--inspect'] },
-    workers: [
-      { expectedPort: port }
-    ]
+    workers: [{ expectedPort: port }]
   });
 
   port = debuggerPort + offset++ * 5;
@@ -198,9 +193,7 @@ function testRunnerMain() {
     defaultPortCase = spawnMaster({
       execArgv: ['--inspect'],
       clusterSettings: { inspectPort: port + 2 },
-      workers: [
-        { expectedInitialPort: port + 2 }
-      ]
+      workers: [{ expectedInitialPort: port + 2 }]
     });
   });
 }
@@ -227,10 +220,9 @@ function masterProcessMain() {
 
     if (clusterSettings) {
       if (clusterSettings.inspectPort === 'addTwo') {
-        clusterSettings.inspectPort = common.mustCall(
-          () => { return debugPort += 2; },
-          workers.length
-        );
+        clusterSettings.inspectPort = common.mustCall(() => {
+          return (debugPort += 2);
+        }, workers.length);
       } else if (clusterSettings.inspectPort === 'string') {
         clusterSettings.inspectPort = 'string';
         cluster.setupMaster(clusterSettings);
@@ -322,17 +314,22 @@ function workerProcessMain() {
 
 function spawnMaster({ execArgv, workers, clusterSettings = {} }) {
   return new Promise((resolve) => {
-    childProcess.fork(__filename, {
-      env: Object.assign({}, process.env, {
-        workers: JSON.stringify(workers),
-        clusterSettings: JSON.stringify(clusterSettings),
-        testProcess: true
-      }),
-      execArgv
-    }).on('exit', common.mustCall((code, signal) => {
-      checkExitCode(code, signal);
-      resolve();
-    }));
+    childProcess
+      .fork(__filename, {
+        env: Object.assign({}, process.env, {
+          workers: JSON.stringify(workers),
+          clusterSettings: JSON.stringify(clusterSettings),
+          testProcess: true
+        }),
+        execArgv
+      })
+      .on(
+        'exit',
+        common.mustCall((code, signal) => {
+          checkExitCode(code, signal);
+          resolve();
+        })
+      );
   });
 }
 
diff --git a/test/sequential/test-inspector-port-zero.js b/test/sequential/test-inspector-port-zero.js
index 59027b5e30769d..ebe81c1dc2bb3c 100644
--- a/test/sequential/test-inspector-port-zero.js
+++ b/test/sequential/test-inspector-port-zero.js
@@ -14,8 +14,8 @@ function test(arg, port = '') {
   proc.stderr.setEncoding('utf8');
   let stdout = '';
   let stderr = '';
-  proc.stdout.on('data', (data) => stdout += data);
-  proc.stderr.on('data', (data) => stderr += data);
+  proc.stdout.on('data', (data) => (stdout += data));
+  proc.stderr.on('data', (data) => (stderr += data));
   proc.stdout.on('close', (hadErr) => assert(!hadErr));
   proc.stderr.on('close', (hadErr) => assert(!hadErr));
   proc.stderr.on('data', () => {
@@ -34,10 +34,16 @@ function test(arg, port = '') {
     };
     proc.stdout.on('close', mustCall(() => onclose()));
     proc.stderr.on('close', mustCall(() => onclose()));
-    proc.on('exit', mustCall((exitCode, signal) => assert.strictEqual(
-      exitCode,
-      0,
-      `exitCode: ${exitCode}, signal: ${signal}`)));
+    proc.on(
+      'exit',
+      mustCall((exitCode, signal) =>
+        assert.strictEqual(
+          exitCode,
+          0,
+          `exitCode: ${exitCode}, signal: ${signal}`
+        )
+      )
+    );
   }
 }
 
diff --git a/test/sequential/test-inspector-resource-name-to-url.js b/test/sequential/test-inspector-resource-name-to-url.js
index 41a98ba219b24c..3dc0ac336b5bfb 100644
--- a/test/sequential/test-inspector-resource-name-to-url.js
+++ b/test/sequential/test-inspector-resource-name-to-url.js
@@ -31,10 +31,13 @@ common.skipIfInspectorDisabled();
   }
 
   async function check(filename, expected) {
-    const promise =
-      new Promise((resolve) => session.once('inspectorNotification', resolve));
+    const promise = new Promise((resolve) =>
+      session.once('inspectorNotification', resolve)
+    );
     new vm.Script('42', { filename }).runInThisContext();
-    const { params: { url } } = await promise;
+    const {
+      params: { url }
+    } = await promise;
     strictEqual(url, expected);
   }
 })();
diff --git a/test/sequential/test-inspector-runtime-evaluate-with-timeout.js b/test/sequential/test-inspector-runtime-evaluate-with-timeout.js
index 1def39a82fead4..fe106d8bee292a 100644
--- a/test/sequential/test-inspector-runtime-evaluate-with-timeout.js
+++ b/test/sequential/test-inspector-runtime-evaluate-with-timeout.js
@@ -12,10 +12,12 @@ common.skipIfInspectorDisabled();
   const session = new Session();
   session.connect();
   session.post = promisify(session.post);
-  const result = await session.post('Runtime.evaluate', {
-    expression: 'for(;;);',
-    timeout: 0
-  }).catch((e) => e);
+  const result = await session
+    .post('Runtime.evaluate', {
+      expression: 'for(;;);',
+      timeout: 0
+    })
+    .catch((e) => e);
   strictEqual(result.message, 'Execution was terminated');
   session.disconnect();
 })();
diff --git a/test/sequential/test-inspector-scriptparsed-context.js b/test/sequential/test-inspector-scriptparsed-context.js
index 56cc41dd86a397..240cf09be0b360 100644
--- a/test/sequential/test-inspector-scriptparsed-context.js
+++ b/test/sequential/test-inspector-scriptparsed-context.js
@@ -32,50 +32,54 @@ const script = `
 `;
 
 async function getContext(session) {
-  const created =
-      await session.waitForNotification('Runtime.executionContextCreated');
+  const created = await session.waitForNotification(
+    'Runtime.executionContextCreated'
+  );
   return created.params.context;
 }
 
 async function checkScriptContext(session, context) {
-  const scriptParsed =
-      await session.waitForNotification('Debugger.scriptParsed');
+  const scriptParsed = await session.waitForNotification(
+    'Debugger.scriptParsed'
+  );
   assert.strictEqual(scriptParsed.params.executionContextId, context.id);
 }
 
 async function runTests() {
-  const instance = new NodeInstance(['--inspect-brk=0', '--expose-internals'],
-                                    script);
+  const instance = new NodeInstance(
+    ['--inspect-brk=0', '--expose-internals'],
+    script
+  );
   const session = await instance.connectInspectorSession();
   await session.send([
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Debugger.enable' },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ]);
   await session.waitForBreakOnLine(4, '[eval]');
 
-  await session.send({ 'method': 'Runtime.enable' });
+  await session.send({ method: 'Runtime.enable' });
   await getContext(session);
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
   const childContext = await getContext(session);
   await session.waitForBreakOnLine(13, '[eval]');
 
   console.error('[test]', 'Script is unbound');
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
   await session.waitForBreakOnLine(17, '[eval]');
 
   console.error('[test]', 'vm.runInContext associates script with context');
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
   await checkScriptContext(session, childContext);
   await session.waitForBreakOnLine(20, '[eval]');
 
   console.error('[test]', 'vm.runInNewContext associates script with context');
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
   const thirdContext = await getContext(session);
   await checkScriptContext(session, thirdContext);
   await session.waitForBreakOnLine(23, '[eval]');
 
   console.error('[test]', 'vm.runInNewContext can contain debugger statements');
-  await session.send({ 'method': 'Debugger.resume' });
+  await session.send({ method: 'Debugger.resume' });
   const fourthContext = await getContext(session);
   await checkScriptContext(session, fourthContext);
   await session.waitForBreakOnLine(0, 'evalmachine.<anonymous>');
diff --git a/test/sequential/test-inspector-stop-profile-after-done.js b/test/sequential/test-inspector-stop-profile-after-done.js
index cde1a0256067fe..ee3474554519c0 100644
--- a/test/sequential/test-inspector-stop-profile-after-done.js
+++ b/test/sequential/test-inspector-stop-profile-after-done.js
@@ -6,23 +6,30 @@ const assert = require('assert');
 const { NodeInstance } = require('../common/inspector-helper.js');
 
 async function runTests() {
-  const child = new NodeInstance(['--inspect-brk=0'],
-                                 `let c = 0;
+  const child = new NodeInstance(
+    ['--inspect-brk=0'],
+    `let c = 0;
                                   const interval = setInterval(() => {
                                    console.log(new Object());
                                    if (c++ === 10)
                                      clearInterval(interval);
-                                 }, ${common.platformTimeout(30)});`);
+                                 }, ${common.platformTimeout(30)});`
+  );
   const session = await child.connectInspectorSession();
 
   session.send([
-    { method: 'Profiler.setSamplingInterval',
-      params: { interval: common.platformTimeout(300) } },
+    {
+      method: 'Profiler.setSamplingInterval',
+      params: { interval: common.platformTimeout(300) }
+    },
     { method: 'Profiler.enable' },
     { method: 'Runtime.runIfWaitingForDebugger' },
-    { method: 'Profiler.start' }]);
-  while (await child.nextStderrString() !==
-         'Waiting for the debugger to disconnect...');
+    { method: 'Profiler.start' }
+  ]);
+  while (
+    (await child.nextStderrString()) !==
+    'Waiting for the debugger to disconnect...'
+  );
   await session.send({ method: 'Profiler.stop' });
   session.disconnect();
   assert.strictEqual((await child.expectShutdown()).exitCode, 0);
diff --git a/test/sequential/test-inspector-stops-no-file.js b/test/sequential/test-inspector-stops-no-file.js
index 9ec09fb15d93b4..cdf6c037ae91ae 100644
--- a/test/sequential/test-inspector-stops-no-file.js
+++ b/test/sequential/test-inspector-stops-no-file.js
@@ -3,9 +3,9 @@ require('../common');
 
 const spawn = require('child_process').spawn;
 
-const child = spawn(process.execPath,
-                    [ '--inspect', 'no-such-script.js' ],
-                    { 'stdio': 'inherit' });
+const child = spawn(process.execPath, ['--inspect', 'no-such-script.js'], {
+  stdio: 'inherit'
+});
 
 function signalHandler() {
   child.kill();
diff --git a/test/sequential/test-inspector.js b/test/sequential/test-inspector.js
index 00fdb000e9e251..a07ae8193294a8 100644
--- a/test/sequential/test-inspector.js
+++ b/test/sequential/test-inspector.js
@@ -16,19 +16,20 @@ function checkListResponse(response) {
   );
   assert.ok(response[0].devtoolsFrontendUrl);
   assert.ok(
-    /ws:\/\/localhost:\d+\/[0-9A-Fa-f]{8}-/
-      .test(response[0].webSocketDebuggerUrl),
-    response[0].webSocketDebuggerUrl);
+    /ws:\/\/localhost:\d+\/[0-9A-Fa-f]{8}-/.test(
+      response[0].webSocketDebuggerUrl
+    ),
+    response[0].webSocketDebuggerUrl
+  );
 }
 
 function checkVersion(response) {
   assert.ok(response);
   const expected = {
-    'Browser': `node.js/${process.version}`,
-    'Protocol-Version': '1.1',
+    Browser: `node.js/${process.version}`,
+    'Protocol-Version': '1.1'
   };
-  assert.strictEqual(JSON.stringify(response),
-                     JSON.stringify(expected));
+  assert.strictEqual(JSON.stringify(response), JSON.stringify(expected));
 }
 
 function checkBadPath(err) {
@@ -54,26 +55,23 @@ function assertScopeValues({ result }, expected) {
       unmatched.delete(actual.name);
     }
   }
-  if (unmatched.size)
-    assert.fail(Array.from(unmatched.values()));
+  if (unmatched.size) assert.fail(Array.from(unmatched.values()));
 }
 
 async function testBreakpointOnStart(session) {
-  console.log('[test]',
-              'Verifying debugger stops on start (--inspect-brk option)');
+  console.log(
+    '[test]',
+    'Verifying debugger stops on start (--inspect-brk option)'
+  );
   const commands = [
-    { 'method': 'Runtime.enable' },
-    { 'method': 'Debugger.enable' },
-    { 'method': 'Debugger.setPauseOnExceptions',
-      'params': { 'state': 'none' } },
-    { 'method': 'Debugger.setAsyncCallStackDepth',
-      'params': { 'maxDepth': 0 } },
-    { 'method': 'Profiler.enable' },
-    { 'method': 'Profiler.setSamplingInterval',
-      'params': { 'interval': 100 } },
-    { 'method': 'Debugger.setBlackboxPatterns',
-      'params': { 'patterns': [] } },
-    { 'method': 'Runtime.runIfWaitingForDebugger' }
+    { method: 'Runtime.enable' },
+    { method: 'Debugger.enable' },
+    { method: 'Debugger.setPauseOnExceptions', params: { state: 'none' } },
+    { method: 'Debugger.setAsyncCallStackDepth', params: { maxDepth: 0 } },
+    { method: 'Profiler.enable' },
+    { method: 'Profiler.setSamplingInterval', params: { interval: 100 } },
+    { method: 'Debugger.setBlackboxPatterns', params: { patterns: [] } },
+    { method: 'Runtime.runIfWaitingForDebugger' }
   ];
 
   await session.send(commands);
@@ -83,21 +81,26 @@ async function testBreakpointOnStart(session) {
 async function testBreakpoint(session) {
   console.log('[test]', 'Setting a breakpoint and verifying it is hit');
   const commands = [
-    { 'method': 'Debugger.setBreakpointByUrl',
-      'params': { 'lineNumber': 5,
-                  'url': session.scriptURL(),
-                  'columnNumber': 0,
-                  'condition': ''
+    {
+      method: 'Debugger.setBreakpointByUrl',
+      params: {
+        lineNumber: 5,
+        url: session.scriptURL(),
+        columnNumber: 0,
+        condition: ''
       }
     },
-    { 'method': 'Debugger.resume' },
+    { method: 'Debugger.resume' }
   ];
   await session.send(commands);
   const { scriptSource } = await session.send({
-    'method': 'Debugger.getScriptSource',
-    'params': { 'scriptId': session.mainScriptId } });
-  assert(scriptSource && (scriptSource.includes(session.script())),
-         `Script source is wrong: ${scriptSource}`);
+    method: 'Debugger.getScriptSource',
+    params: { scriptId: session.mainScriptId }
+  });
+  assert(
+    scriptSource && scriptSource.includes(session.script()),
+    `Script source is wrong: ${scriptSource}`
+  );
 
   await session.waitForConsoleOutput('log', ['A message', 5]);
   const paused = await session.waitForBreakOnLine(5, session.scriptURL());
@@ -105,25 +108,26 @@ async function testBreakpoint(session) {
 
   console.log('[test]', 'Verify we can read current application state');
   const response = await session.send({
-    'method': 'Runtime.getProperties',
-    'params': {
-      'objectId': scopeId,
-      'ownProperties': false,
-      'accessorPropertiesOnly': false,
-      'generatePreview': true
+    method: 'Runtime.getProperties',
+    params: {
+      objectId: scopeId,
+      ownProperties: false,
+      accessorPropertiesOnly: false,
+      generatePreview: true
     }
   });
   assertScopeValues(response, { t: 1001, k: 1 });
 
   let { result } = await session.send({
-    'method': 'Debugger.evaluateOnCallFrame', 'params': {
-      'callFrameId': '{"ordinal":0,"injectedScriptId":1}',
-      'expression': 'k + t',
-      'objectGroup': 'console',
-      'includeCommandLineAPI': true,
-      'silent': false,
-      'returnByValue': false,
-      'generatePreview': true
+    method: 'Debugger.evaluateOnCallFrame',
+    params: {
+      callFrameId: '{"ordinal":0,"injectedScriptId":1}',
+      expression: 'k + t',
+      objectGroup: 'console',
+      includeCommandLineAPI: true,
+      silent: false,
+      returnByValue: false,
+      generatePreview: true
     }
   });
   const expectedEvaluation = 1002;
@@ -134,8 +138,9 @@ async function testBreakpoint(session) {
   );
 
   result = (await session.send({
-    'method': 'Runtime.evaluate', 'params': {
-      'expression': '5 * 5'
+    method: 'Runtime.evaluate',
+    params: {
+      expression: '5 * 5'
     }
   })).result;
   const expectedResult = 25;
@@ -150,14 +155,15 @@ async function testI18NCharacters(session) {
   console.log('[test]', 'Verify sending and receiving UTF8 characters');
   const chars = 'טֶ字и';
   session.send({
-    'method': 'Debugger.evaluateOnCallFrame', 'params': {
-      'callFrameId': '{"ordinal":0,"injectedScriptId":1}',
-      'expression': `console.log("${chars}")`,
-      'objectGroup': 'console',
-      'includeCommandLineAPI': true,
-      'silent': false,
-      'returnByValue': false,
-      'generatePreview': true
+    method: 'Debugger.evaluateOnCallFrame',
+    params: {
+      callFrameId: '{"ordinal":0,"injectedScriptId":1}',
+      expression: `console.log("${chars}")`,
+      objectGroup: 'console',
+      includeCommandLineAPI: true,
+      silent: false,
+      returnByValue: false,
+      generatePreview: true
     }
   });
   await session.waitForConsoleOutput('log', [chars]);
@@ -172,122 +178,120 @@ async function testCommandLineAPI(session) {
   const printBModuleStr = JSON.stringify(printBModulePath);
 
   // we can use `require` outside of a callframe with require in scope
-  let result = await session.send(
-    {
-      'method': 'Runtime.evaluate', 'params': {
-        'expression': 'typeof require("fs").readFile === "function"',
-        'includeCommandLineAPI': true
-      }
-    });
+  let result = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      expression: 'typeof require("fs").readFile === "function"',
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
   assert.strictEqual(result.result.value, true);
 
   // the global require has the same properties as a normal `require`
-  result = await session.send(
-    {
-      'method': 'Runtime.evaluate', 'params': {
-        'expression': [
-          'typeof require.resolve === "function"',
-          'typeof require.extensions === "object"',
-          'typeof require.cache === "object"'
-        ].join(' && '),
-        'includeCommandLineAPI': true
-      }
-    });
+  result = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      expression: [
+        'typeof require.resolve === "function"',
+        'typeof require.extensions === "object"',
+        'typeof require.cache === "object"'
+      ].join(' && '),
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
   assert.strictEqual(result.result.value, true);
   // `require` twice returns the same value
-  result = await session.send(
-    {
-      'method': 'Runtime.evaluate', 'params': {
-        // 1. We require the same module twice
-        // 2. We mutate the exports so we can compare it later on
-        'expression': `
+  result = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      // 1. We require the same module twice
+      // 2. We mutate the exports so we can compare it later on
+      expression: `
           Object.assign(
             require(${testModuleStr}),
             { old: 'yes' }
           ) === require(${testModuleStr})`,
-        'includeCommandLineAPI': true
-      }
-    });
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
   assert.strictEqual(result.result.value, true);
   // after require the module appears in require.cache
-  result = await session.send(
-    {
-      'method': 'Runtime.evaluate', 'params': {
-        'expression': `JSON.stringify(
+  result = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      expression: `JSON.stringify(
           require.cache[${testModuleStr}].exports
         )`,
-        'includeCommandLineAPI': true
-      }
-    });
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
-  assert.deepStrictEqual(JSON.parse(result.result.value),
-                         { old: 'yes' });
+  assert.deepStrictEqual(JSON.parse(result.result.value), { old: 'yes' });
   // remove module from require.cache
-  result = await session.send(
-    {
-      'method': 'Runtime.evaluate', 'params': {
-        'expression': `delete require.cache[${testModuleStr}]`,
-        'includeCommandLineAPI': true
-      }
-    });
+  result = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      expression: `delete require.cache[${testModuleStr}]`,
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
   assert.strictEqual(result.result.value, true);
   // require again, should get fresh (empty) exports
-  result = await session.send(
-    {
-      'method': 'Runtime.evaluate', 'params': {
-        'expression': `JSON.stringify(require(${testModuleStr}))`,
-        'includeCommandLineAPI': true
-      }
-    });
+  result = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      expression: `JSON.stringify(require(${testModuleStr}))`,
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
   assert.deepStrictEqual(JSON.parse(result.result.value), {});
   // require 2nd module, exports an empty object
-  result = await session.send(
-    {
-      'method': 'Runtime.evaluate', 'params': {
-        'expression': `JSON.stringify(require(${printAModuleStr}))`,
-        'includeCommandLineAPI': true
-      }
-    });
+  result = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      expression: `JSON.stringify(require(${printAModuleStr}))`,
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
   assert.deepStrictEqual(JSON.parse(result.result.value), {});
   // both modules end up with the same module.parent
-  result = await session.send(
-    {
-      'method': 'Runtime.evaluate', 'params': {
-        'expression': `JSON.stringify({
+  result = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      expression: `JSON.stringify({
           parentsEqual:
             require.cache[${testModuleStr}].parent ===
             require.cache[${printAModuleStr}].parent,
           parentId: require.cache[${testModuleStr}].parent.id,
         })`,
-        'includeCommandLineAPI': true
-      }
-    });
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
   assert.deepStrictEqual(JSON.parse(result.result.value), {
     parentsEqual: true,
     parentId: '<inspector console>'
   });
   // the `require` in the module shadows the command line API's `require`
-  result = await session.send(
-    {
-      'method': 'Debugger.evaluateOnCallFrame', 'params': {
-        'callFrameId': '{"ordinal":0,"injectedScriptId":1}',
-        'expression': `(
+  result = await session.send({
+    method: 'Debugger.evaluateOnCallFrame',
+    params: {
+      callFrameId: '{"ordinal":0,"injectedScriptId":1}',
+      expression: `(
           require(${printBModuleStr}),
           require.cache[${printBModuleStr}].parent.id
         )`,
-        'includeCommandLineAPI': true
-      }
-    });
+      includeCommandLineAPI: true
+    }
+  });
   checkException(result);
-  assert.notStrictEqual(result.result.value,
-                        '<inspector console>');
+  assert.notStrictEqual(result.result.value, '<inspector console>');
 }
 
 async function runTest() {
diff --git a/test/sequential/test-module-loading.js b/test/sequential/test-module-loading.js
index 0e8aafe51b744f..20653655711982 100644
--- a/test/sequential/test-module-loading.js
+++ b/test/sequential/test-module-loading.js
@@ -82,7 +82,7 @@ const d2 = require('../fixtures/b/d');
   assert.ok(d4.D instanceof Function);
   assert.strictEqual(d4.D(), 'D');
 
-  assert.ok((new a.SomeClass()) instanceof c.SomeClass);
+  assert.ok(new a.SomeClass() instanceof c.SomeClass);
 }
 
 {
@@ -106,10 +106,9 @@ assert.strictEqual(require('../fixtures/packages/main').ok, 'ok');
 assert.strictEqual(require('../fixtures/packages/main-index').ok, 'ok');
 assert.strictEqual(require('../fixtures/packages/missing-main').ok, 'ok');
 
-assert.throws(
-  function() { require('../fixtures/packages/unparseable'); },
-  /^SyntaxError: Error parsing/
-);
+assert.throws(function() {
+  require('../fixtures/packages/unparseable');
+}, /^SyntaxError: Error parsing/);
 
 {
   console.error('test cycles containing a .. path');
@@ -130,8 +129,9 @@ require('../fixtures/node_modules/foo');
   const my_path = require('../fixtures/path');
   assert.ok(my_path.path_func instanceof Function);
   // this one does not exist and should throw
-  assert.throws(function() { require('./utils'); },
-                /^Error: Cannot find module '\.\/utils'$/);
+  assert.throws(function() {
+    require('./utils');
+  }, /^Error: Cannot find module '\.\/utils'$/);
 }
 
 let errorThrown = false;
@@ -148,15 +148,16 @@ console.error('load custom file types with extensions');
 require.extensions['.test'] = function(module, filename) {
   let content = fs.readFileSync(filename).toString();
   assert.strictEqual(content, 'this is custom source\n');
-  content = content.replace('this is custom source',
-                            'exports.test = \'passed\'');
+  content = content.replace('this is custom source', "exports.test = 'passed'");
   module._compile(content, filename);
 };
 
 assert.strictEqual(require('../fixtures/registerExt').test, 'passed');
 // unknown extension, load as .js
-assert.strictEqual(require('../fixtures/registerExt.hello.world').test,
-                   'passed');
+assert.strictEqual(
+  require('../fixtures/registerExt.hello.world').test,
+  'passed'
+);
 
 console.error('load custom file types that return non-strings');
 require.extensions['.test'] = function(module) {
@@ -192,10 +193,12 @@ try {
     require(`${loadOrder}file3`);
   } catch (e) {
     // Not a real .node module, but we know we require'd the right thing.
-    if (common.isOpenBSD) // OpenBSD errors with non-ELF object error
-      assert.ok(/File not an ELF object/.test(e.message.replace(backslash, '/')));
-    else
-      assert.ok(/file3\.node/.test(e.message.replace(backslash, '/')));
+    if (common.isOpenBSD)
+      // OpenBSD errors with non-ELF object error
+      assert.ok(
+        /File not an ELF object/.test(e.message.replace(backslash, '/'))
+      );
+    else assert.ok(/file3\.node/.test(e.message.replace(backslash, '/')));
   }
 
   assert.strictEqual(require(`${loadOrder}file4`).file4, 'file4.reg');
@@ -205,7 +208,9 @@ try {
     require(`${loadOrder}file7`);
   } catch (e) {
     if (common.isOpenBSD)
-      assert.ok(/File not an ELF object/.test(e.message.replace(backslash, '/')));
+      assert.ok(
+        /File not an ELF object/.test(e.message.replace(backslash, '/'))
+      );
     else
       assert.ok(/file7\/index\.node/.test(e.message.replace(backslash, '/')));
   }
@@ -233,7 +238,6 @@ try {
   });
 }
 
-
 {
   // now verify that module.children contains all the different
   // modules that we've required, and that all of them contain
@@ -305,7 +309,6 @@ try {
   });
 }
 
-
 process.on('exit', function() {
   assert.ok(a.A instanceof Function);
   assert.strictEqual(a.A(), 'A done');
@@ -327,7 +330,6 @@ process.on('exit', function() {
   console.log('exit');
 });
 
-
 // Loading files with a byte order marker.
 // See https://github.com/nodejs/node-v0.x-archive/issues/1440.
 assert.strictEqual(require('../fixtures/utf8-bom.js'), 42);
@@ -335,8 +337,12 @@ assert.strictEqual(require('../fixtures/utf8-bom.json'), 42);
 
 // Error on the first line of a module should
 // have the correct line number
-assert.throws(function() {
-  require('../fixtures/test-error-first-line-offset.js');
-}, function(err) {
-  return /test-error-first-line-offset\.js:1:/.test(err.stack);
-}, 'Expected appearance of proper offset in Error stack');
+assert.throws(
+  function() {
+    require('../fixtures/test-error-first-line-offset.js');
+  },
+  function(err) {
+    return /test-error-first-line-offset\.js:1:/.test(err.stack);
+  },
+  'Expected appearance of proper offset in Error stack'
+);
diff --git a/test/sequential/test-net-GH-5504.js b/test/sequential/test-net-GH-5504.js
index ebe987d0443b6c..e2179c31a88eba 100644
--- a/test/sequential/test-net-GH-5504.js
+++ b/test/sequential/test-net-GH-5504.js
@@ -34,37 +34,46 @@ const common = require('../common');
 // Make sure we don't keep trying to write or read more in that case.
 
 switch (process.argv[2]) {
-  case 'server': return server();
-  case 'client': return client();
-  case undefined: return parent();
-  default: throw new Error('invalid');
+  case 'server':
+    return server();
+  case 'client':
+    return client();
+  case undefined:
+    return parent();
+  default:
+    throw new Error('invalid');
 }
 
 function server() {
   const net = require('net');
   const content = Buffer.alloc(64 * 1024 * 1024, '#');
-  net.createServer(function(socket) {
-    this.close();
-    socket.on('end', function() {
-      console.error('end');
-    });
-    socket.on('_socketEnd', function() {
-      console.error('_socketEnd');
+  net
+    .createServer(function(socket) {
+      this.close();
+      socket.on('end', function() {
+        console.error('end');
+      });
+      socket.on('_socketEnd', function() {
+        console.error('_socketEnd');
+      });
+      socket.write(content);
+    })
+    .listen(common.PORT, common.localhostIPv4, function() {
+      console.log('listening');
     });
-    socket.write(content);
-  }).listen(common.PORT, common.localhostIPv4, function() {
-    console.log('listening');
-  });
 }
 
 function client() {
   const net = require('net');
-  const client = net.connect({
-    host: common.localhostIPv4,
-    port: common.PORT
-  }, function() {
-    client.destroy();
-  });
+  const client = net.connect(
+    {
+      host: common.localhostIPv4,
+      port: common.PORT
+    },
+    function() {
+      client.destroy();
+    }
+  );
 }
 
 function parent() {
@@ -81,12 +90,15 @@ function parent() {
   wrap(s.stdout, process.stdout, 'SERVER 1>');
   s.on('exit', common.mustCall());
 
-  s.stdout.once('data', common.mustCall(function() {
-    const c = spawn(node, [__filename, 'client']);
-    wrap(c.stderr, process.stderr, 'CLIENT 2>');
-    wrap(c.stdout, process.stdout, 'CLIENT 1>');
-    c.on('exit', common.mustCall());
-  }));
+  s.stdout.once(
+    'data',
+    common.mustCall(function() {
+      const c = spawn(node, [__filename, 'client']);
+      wrap(c.stderr, process.stderr, 'CLIENT 2>');
+      wrap(c.stdout, process.stdout, 'CLIENT 1>');
+      c.on('exit', common.mustCall());
+    })
+  );
 
   function wrap(inp, out, w) {
     inp.setEncoding('utf8');
diff --git a/test/sequential/test-net-better-error-messages-port.js b/test/sequential/test-net-better-error-messages-port.js
index 789b2e31801da1..048804550f9ded 100644
--- a/test/sequential/test-net-better-error-messages-port.js
+++ b/test/sequential/test-net-better-error-messages-port.js
@@ -7,8 +7,11 @@ const c = net.createConnection(common.PORT);
 
 c.on('connect', common.mustNotCall());
 
-c.on('error', common.mustCall(function(e) {
-  assert.strictEqual(e.code, 'ECONNREFUSED');
-  assert.strictEqual(e.port, common.PORT);
-  assert.strictEqual(e.address, '127.0.0.1');
-}));
+c.on(
+  'error',
+  common.mustCall(function(e) {
+    assert.strictEqual(e.code, 'ECONNREFUSED');
+    assert.strictEqual(e.port, common.PORT);
+    assert.strictEqual(e.address, '127.0.0.1');
+  })
+);
diff --git a/test/sequential/test-net-bytes-per-incoming-chunk-overhead.js b/test/sequential/test-net-bytes-per-incoming-chunk-overhead.js
index 8f766e8c7a4106..e9c6994b0afc7c 100644
--- a/test/sequential/test-net-bytes-per-incoming-chunk-overhead.js
+++ b/test/sequential/test-net-bytes-per-incoming-chunk-overhead.js
@@ -13,24 +13,31 @@ let baseRSS;
 const receivedChunks = [];
 const N = 250000;
 
-const server = net.createServer(common.mustCall((socket) => {
-  baseRSS = process.memoryUsage().rss;
+const server = net
+  .createServer(
+    common.mustCall((socket) => {
+      baseRSS = process.memoryUsage().rss;
 
-  socket.setNoDelay(true);
-  socket.on('data', (chunk) => {
-    receivedChunks.push(chunk);
-    if (receivedChunks.length < N) {
-      client.write('a');
-    } else {
-      client.end();
-      server.close();
-    }
-  });
-})).listen(0, common.mustCall(() => {
-  client = net.connect(server.address().port);
-  client.setNoDelay(true);
-  client.write('hello!');
-}));
+      socket.setNoDelay(true);
+      socket.on('data', (chunk) => {
+        receivedChunks.push(chunk);
+        if (receivedChunks.length < N) {
+          client.write('a');
+        } else {
+          client.end();
+          server.close();
+        }
+      });
+    })
+  )
+  .listen(
+    0,
+    common.mustCall(() => {
+      client = net.connect(server.address().port);
+      client.setNoDelay(true);
+      client.write('hello!');
+    })
+  );
 
 process.on('exit', () => {
   global.gc();
diff --git a/test/sequential/test-net-connect-local-error.js b/test/sequential/test-net-connect-local-error.js
index 6f5139aefb226d..cd84e3f7f862cb 100644
--- a/test/sequential/test-net-connect-local-error.js
+++ b/test/sequential/test-net-connect-local-error.js
@@ -28,7 +28,7 @@ function onError(err, options) {
   assert.strictEqual(
     err.message,
     `connect ${err.code} ${err.address}:${err.port} ` +
-    `- Local (${err.localAddress}:${err.localPort})`
+      `- Local (${err.localAddress}:${err.localPort})`
   );
 }
 
diff --git a/test/sequential/test-net-listen-shared-ports.js b/test/sequential/test-net-listen-shared-ports.js
index be33821bf6518c..cb2c2497994129 100644
--- a/test/sequential/test-net-listen-shared-ports.js
+++ b/test/sequential/test-net-listen-shared-ports.js
@@ -28,16 +28,22 @@ const net = require('net');
 if (cluster.isMaster) {
   const worker1 = cluster.fork();
 
-  worker1.on('message', common.mustCall(function(msg) {
-    assert.strictEqual(msg, 'success');
-    const worker2 = cluster.fork();
+  worker1.on(
+    'message',
+    common.mustCall(function(msg) {
+      assert.strictEqual(msg, 'success');
+      const worker2 = cluster.fork();
 
-    worker2.on('message', common.mustCall(function(msg) {
-      assert.strictEqual(msg, 'server2:EADDRINUSE');
-      worker1.kill();
-      worker2.kill();
-    }));
-  }));
+      worker2.on(
+        'message',
+        common.mustCall(function(msg) {
+          assert.strictEqual(msg, 'server2:EADDRINUSE');
+          worker1.kill();
+          worker2.kill();
+        })
+      );
+    })
+  );
 } else {
   const server1 = net.createServer(common.mustNotCall());
   const server2 = net.createServer(common.mustNotCall());
@@ -52,16 +58,20 @@ if (cluster.isMaster) {
     process.send(`server2:${err.code}`);
   });
 
-  server1.listen({
-    host: 'localhost',
-    port: common.PORT,
-    exclusive: false
-  }, common.mustCall(function() {
-    server2.listen({ port: common.PORT + 1, exclusive: true },
-                   common.mustCall(function() {
-                     // the first worker should succeed
-                     process.send('success');
-                   })
-    );
-  }));
+  server1.listen(
+    {
+      host: 'localhost',
+      port: common.PORT,
+      exclusive: false
+    },
+    common.mustCall(function() {
+      server2.listen(
+        { port: common.PORT + 1, exclusive: true },
+        common.mustCall(function() {
+          // the first worker should succeed
+          process.send('success');
+        })
+      );
+    })
+  );
 }
diff --git a/test/sequential/test-net-localport.js b/test/sequential/test-net-localport.js
index e90df73e524b51..03397425e8b271 100644
--- a/test/sequential/test-net-localport.js
+++ b/test/sequential/test-net-localport.js
@@ -3,18 +3,23 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-const server = net.createServer(function(socket) {
-  assert.strictEqual(socket.remotePort, common.PORT);
-  socket.end();
-  socket.on('close', function() {
-    server.close();
+const server = net
+  .createServer(function(socket) {
+    assert.strictEqual(socket.remotePort, common.PORT);
+    socket.end();
+    socket.on('close', function() {
+      server.close();
+    });
+  })
+  .listen(0)
+  .on('listening', function() {
+    const client = net
+      .connect({
+        host: '127.0.0.1',
+        port: this.address().port,
+        localPort: common.PORT
+      })
+      .on('connect', function() {
+        assert.strictEqual(client.localPort, common.PORT);
+      });
   });
-}).listen(0).on('listening', function() {
-  const client = net.connect({
-    host: '127.0.0.1',
-    port: this.address().port,
-    localPort: common.PORT,
-  }).on('connect', function() {
-    assert.strictEqual(client.localPort, common.PORT);
-  });
-});
diff --git a/test/sequential/test-net-reconnect-error.js b/test/sequential/test-net-reconnect-error.js
index e16d567c0ad1bb..8b8f937bf2e0a0 100644
--- a/test/sequential/test-net-reconnect-error.js
+++ b/test/sequential/test-net-reconnect-error.js
@@ -31,15 +31,20 @@ const c = net.createConnection(common.PORT);
 
 c.on('connect', common.mustNotCall('client should not have connected'));
 
-c.on('error', common.mustCall((e) => {
-  client_error_count++;
-  assert.strictEqual(e.code, 'ECONNREFUSED');
-}, N + 1));
+c.on(
+  'error',
+  common.mustCall((e) => {
+    client_error_count++;
+    assert.strictEqual(e.code, 'ECONNREFUSED');
+  }, N + 1)
+);
 
-c.on('close', common.mustCall(() => {
-  if (disconnect_count++ < N)
-    c.connect(common.PORT); // reconnect
-}, N + 1));
+c.on(
+  'close',
+  common.mustCall(() => {
+    if (disconnect_count++ < N) c.connect(common.PORT); // reconnect
+  }, N + 1)
+);
 
 process.on('exit', function() {
   assert.strictEqual(disconnect_count, N + 1);
diff --git a/test/sequential/test-net-response-size.js b/test/sequential/test-net-response-size.js
index c5d7e9b600e05d..2f3e6f3a73e8bb 100644
--- a/test/sequential/test-net-response-size.js
+++ b/test/sequential/test-net-response-size.js
@@ -45,7 +45,6 @@ if (process.argv[2] === 'server') {
   server.listen(common.PORT, '127.0.0.1', function() {
     console.log('Server running.');
   });
-
 } else {
   // Client
 
@@ -64,8 +63,8 @@ if (process.argv[2] === 'server') {
       }
 
       // Block the event loop for 1 second
-      const start = (new Date()).getTime();
-      while ((new Date()).getTime() < start + 1000) {}
+      const start = new Date().getTime();
+      while (new Date().getTime() < start + 1000) {}
 
       client.write(alittle);
 
diff --git a/test/sequential/test-net-server-address.js b/test/sequential/test-net-server-address.js
index 52a8c1ac820e24..07d1f9510dac5e 100644
--- a/test/sequential/test-net-server-address.js
+++ b/test/sequential/test-net-server-address.js
@@ -30,14 +30,17 @@ const server_ipv4 = net.createServer();
 
 server_ipv4.on('error', common.mustNotCall());
 
-server_ipv4
-  .listen(common.PORT + 1, common.localhostIPv4, common.mustCall(() => {
+server_ipv4.listen(
+  common.PORT + 1,
+  common.localhostIPv4,
+  common.mustCall(() => {
     const address_ipv4 = server_ipv4.address();
     assert.strictEqual(address_ipv4.address, common.localhostIPv4);
     assert.strictEqual(address_ipv4.port, common.PORT + 1);
     assert.strictEqual(address_ipv4.family, family_ipv4);
     server_ipv4.close();
-  }));
+  })
+);
 
 if (!common.hasIPv6) {
   common.printSkipMessage('ipv6 part of test, no IPv6 support');
@@ -51,13 +54,17 @@ const server_ipv6 = net.createServer();
 
 server_ipv6.on('error', common.mustNotCall());
 
-server_ipv6.listen(common.PORT + 2, localhost_ipv6, common.mustCall(() => {
-  const address_ipv6 = server_ipv6.address();
-  assert.strictEqual(address_ipv6.address, localhost_ipv6);
-  assert.strictEqual(address_ipv6.port, common.PORT + 2);
-  assert.strictEqual(address_ipv6.family, family_ipv6);
-  server_ipv6.close();
-}));
+server_ipv6.listen(
+  common.PORT + 2,
+  localhost_ipv6,
+  common.mustCall(() => {
+    const address_ipv6 = server_ipv6.address();
+    assert.strictEqual(address_ipv6.address, localhost_ipv6);
+    assert.strictEqual(address_ipv6.port, common.PORT + 2);
+    assert.strictEqual(address_ipv6.family, family_ipv6);
+    server_ipv6.close();
+  })
+);
 
 // Test without hostname or ip
 const anycast_ipv6 = '::';
@@ -66,13 +73,16 @@ const server1 = net.createServer();
 server1.on('error', common.mustNotCall());
 
 // Specify the port number
-server1.listen(common.PORT + 3, common.mustCall(() => {
-  const address = server1.address();
-  assert.strictEqual(address.address, anycast_ipv6);
-  assert.strictEqual(address.port, common.PORT + 3);
-  assert.strictEqual(address.family, family_ipv6);
-  server1.close();
-}));
+server1.listen(
+  common.PORT + 3,
+  common.mustCall(() => {
+    const address = server1.address();
+    assert.strictEqual(address.address, anycast_ipv6);
+    assert.strictEqual(address.port, common.PORT + 3);
+    assert.strictEqual(address.family, family_ipv6);
+    server1.close();
+  })
+);
 
 // Test without hostname or port
 const server2 = net.createServer();
@@ -80,12 +90,14 @@ const server2 = net.createServer();
 server2.on('error', common.mustNotCall());
 
 // Don't specify the port number
-server2.listen(common.mustCall(() => {
-  const address = server2.address();
-  assert.strictEqual(address.address, anycast_ipv6);
-  assert.strictEqual(address.family, family_ipv6);
-  server2.close();
-}));
+server2.listen(
+  common.mustCall(() => {
+    const address = server2.address();
+    assert.strictEqual(address.address, anycast_ipv6);
+    assert.strictEqual(address.family, family_ipv6);
+    server2.close();
+  })
+);
 
 // Test without hostname, but with a false-y port
 const server3 = net.createServer();
@@ -93,9 +105,12 @@ const server3 = net.createServer();
 server3.on('error', common.mustNotCall());
 
 // Specify a false-y port number
-server3.listen(0, common.mustCall(() => {
-  const address = server3.address();
-  assert.strictEqual(address.address, anycast_ipv6);
-  assert.strictEqual(address.family, family_ipv6);
-  server3.close();
-}));
+server3.listen(
+  0,
+  common.mustCall(() => {
+    const address = server3.address();
+    assert.strictEqual(address.address, anycast_ipv6);
+    assert.strictEqual(address.family, family_ipv6);
+    server3.close();
+  })
+);
diff --git a/test/sequential/test-net-server-bind.js b/test/sequential/test-net-server-bind.js
index 56216d0ed60619..db3322b7b7bc85 100644
--- a/test/sequential/test-net-server-bind.js
+++ b/test/sequential/test-net-server-bind.js
@@ -3,15 +3,16 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-
 // With only a callback, server should get a port assigned by the OS
 {
   const server = net.createServer(common.mustNotCall());
 
-  server.listen(common.mustCall(function() {
-    assert.ok(server.address().port > 100);
-    server.close();
-  }));
+  server.listen(
+    common.mustCall(function() {
+      assert.ok(server.address().port > 100);
+      server.close();
+    })
+  );
 }
 
 // No callback to listen(), assume we can bind in 100 ms
@@ -26,8 +27,7 @@ const net = require('net');
 
     if (address.family === 'IPv6')
       assert.strictEqual(server._connectionKey, `6::::${address.port}`);
-    else
-      assert.strictEqual(server._connectionKey, `4:0.0.0.0:${address.port}`);
+    else assert.strictEqual(server._connectionKey, `4:0.0.0.0:${address.port}`);
 
     server.close();
   }, 100);
@@ -37,28 +37,40 @@ const net = require('net');
 {
   const server = net.createServer(common.mustNotCall());
 
-  server.listen(common.PORT + 1, common.mustCall(function() {
-    assert.strictEqual(server.address().port, common.PORT + 1);
-    server.close();
-  }));
+  server.listen(
+    common.PORT + 1,
+    common.mustCall(function() {
+      assert.strictEqual(server.address().port, common.PORT + 1);
+      server.close();
+    })
+  );
 }
 
 // Backlog argument
 {
   const server = net.createServer(common.mustNotCall());
 
-  server.listen(common.PORT + 2, '0.0.0.0', 127, common.mustCall(function() {
-    assert.strictEqual(server.address().port, common.PORT + 2);
-    server.close();
-  }));
+  server.listen(
+    common.PORT + 2,
+    '0.0.0.0',
+    127,
+    common.mustCall(function() {
+      assert.strictEqual(server.address().port, common.PORT + 2);
+      server.close();
+    })
+  );
 }
 
 // Backlog argument without host argument
 {
   const server = net.createServer(common.mustNotCall());
 
-  server.listen(common.PORT + 3, 127, common.mustCall(function() {
-    assert.strictEqual(server.address().port, common.PORT + 3);
-    server.close();
-  }));
+  server.listen(
+    common.PORT + 3,
+    127,
+    common.mustCall(function() {
+      assert.strictEqual(server.address().port, common.PORT + 3);
+      server.close();
+    })
+  );
 }
diff --git a/test/sequential/test-next-tick-error-spin.js b/test/sequential/test-next-tick-error-spin.js
index 70d924cfa34b4b..dc23d53b3377e4 100644
--- a/test/sequential/test-next-tick-error-spin.js
+++ b/test/sequential/test-next-tick-error-spin.js
@@ -26,17 +26,19 @@ const assert = require('assert');
 if (process.argv[2] !== 'child') {
   const spawn = require('child_process').spawn;
   const child = spawn(process.execPath, [__filename, 'child'], {
-    stdio: 'pipe'// 'inherit'
+    stdio: 'pipe' // 'inherit'
   });
   const timer = setTimeout(function() {
     throw new Error('child is hung');
   }, common.platformTimeout(3000));
-  child.on('exit', common.mustCall(function(code) {
-    assert.strictEqual(code, 0);
-    clearTimeout(timer);
-  }));
+  child.on(
+    'exit',
+    common.mustCall(function(code) {
+      assert.strictEqual(code, 0);
+      clearTimeout(timer);
+    })
+  );
 } else {
-
   const domain = require('domain');
   const d = domain.create();
 
diff --git a/test/sequential/test-performance.js b/test/sequential/test-performance.js
index 72b78bea583bf0..7b181771fa4b04 100644
--- a/test/sequential/test-performance.js
+++ b/test/sequential/test-performance.js
@@ -33,13 +33,11 @@ assert(inited < 15000);
   });
 
   [undefined, null, 'foo', 1].forEach((i) => {
-    common.expectsError(
-      () => performance.measure('test', 'A', i),
-      {
-        code: 'ERR_INVALID_PERFORMANCE_MARK',
-        type: Error,
-        message: `The "${i}" performance mark has not been set`
-      });
+    common.expectsError(() => performance.measure('test', 'A', i), {
+      code: 'ERR_INVALID_PERFORMANCE_MARK',
+      type: Error,
+      message: `The "${i}" performance mark has not been set`
+    });
   });
 
   performance.clearMarks();
@@ -78,7 +76,7 @@ function checkDelay(cb) {
 
 function getTime() {
   const ts = process.hrtime();
-  return Math.ceil((ts[0] * 1e3) + (ts[1] / 1e6));
+  return Math.ceil(ts[0] * 1e3 + ts[1] / 1e6);
 }
 
 function checkNodeTiming(props) {
@@ -94,9 +92,12 @@ function checkNodeTiming(props) {
         `${prop}: ${Math.abs(delta)} >= ${delay}`
       );
     } else {
-      assert.strictEqual(performance.nodeTiming[prop], props[prop],
-                         `mismatch for performance property ${prop}: ` +
-                         `${performance.nodeTiming[prop]} vs ${props[prop]}`);
+      assert.strictEqual(
+        performance.nodeTiming[prop],
+        props[prop],
+        `mismatch for performance property ${prop}: ` +
+          `${performance.nodeTiming[prop]} vs ${props[prop]}`
+      );
     }
   }
 }
diff --git a/test/sequential/test-pipe.js b/test/sequential/test-pipe.js
index c5bff3563be1e6..8b8b5ba5b1df87 100644
--- a/test/sequential/test-pipe.js
+++ b/test/sequential/test-pipe.js
@@ -33,7 +33,6 @@ let listenCount = 0;
 let gotThanks = false;
 let tcpLengthSeen = 0;
 
-
 /*
  * 5MB of random buffer.
  */
@@ -42,52 +41,60 @@ for (let i = 0; i < buffer.length; i++) {
   buffer[i] = parseInt(Math.random() * 10000) % 256;
 }
 
+const web = http.Server(
+  common.mustCall((req, res) => {
+    web.close();
 
-const web = http.Server(common.mustCall((req, res) => {
-  web.close();
-
-  const socket = net.Stream();
-  socket.connect(tcpPort);
+    const socket = net.Stream();
+    socket.connect(tcpPort);
 
-  socket.on('connect', common.mustCall());
+    socket.on('connect', common.mustCall());
 
-  req.pipe(socket);
+    req.pipe(socket);
 
-  req.on('end', common.mustCall(() => {
-    res.writeHead(200);
-    res.write('thanks');
-    res.end();
-  }));
+    req.on(
+      'end',
+      common.mustCall(() => {
+        res.writeHead(200);
+        res.write('thanks');
+        res.end();
+      })
+    );
 
-  req.connection.on('error', (e) => {
-    assert.ifError(e);
-  });
-}));
+    req.connection.on('error', (e) => {
+      assert.ifError(e);
+    });
+  })
+);
 
 web.listen(webPort, startClient);
 
-
-const tcp = net.Server(common.mustCall((s) => {
-  tcp.close();
-
-  let i = 0;
-
-  s.on('data', (d) => {
-    tcpLengthSeen += d.length;
-    for (let j = 0; j < d.length; j++) {
-      assert.strictEqual(d[j], buffer[i]);
-      i++;
-    }
-  });
-
-  s.on('end', common.mustCall(() => {
-    s.end();
-  }));
-
-  s.on('error', (e) => {
-    assert.ifError(e);
-  });
-}));
+const tcp = net.Server(
+  common.mustCall((s) => {
+    tcp.close();
+
+    let i = 0;
+
+    s.on('data', (d) => {
+      tcpLengthSeen += d.length;
+      for (let j = 0; j < d.length; j++) {
+        assert.strictEqual(d[j], buffer[i]);
+        i++;
+      }
+    });
+
+    s.on(
+      'end',
+      common.mustCall(() => {
+        s.end();
+      })
+    );
+
+    s.on('error', (e) => {
+      assert.ifError(e);
+    });
+  })
+);
 
 tcp.listen(tcpPort, startClient);
 
@@ -95,18 +102,24 @@ function startClient() {
   listenCount++;
   if (listenCount < 2) return;
 
-  const req = http.request({
-    port: common.PORT,
-    method: 'GET',
-    path: '/',
-    headers: { 'content-length': buffer.length }
-  }, common.mustCall((res) => {
-    res.setEncoding('utf8');
-    res.on('data', common.mustCall((string) => {
-      assert.strictEqual(string, 'thanks');
-      gotThanks = true;
-    }));
-  }));
+  const req = http.request(
+    {
+      port: common.PORT,
+      method: 'GET',
+      path: '/',
+      headers: { 'content-length': buffer.length }
+    },
+    common.mustCall((res) => {
+      res.setEncoding('utf8');
+      res.on(
+        'data',
+        common.mustCall((string) => {
+          assert.strictEqual(string, 'thanks');
+          gotThanks = true;
+        })
+      );
+    })
+  );
   req.write(buffer);
   req.end();
 }
diff --git a/test/sequential/test-repl-timeout-throw.js b/test/sequential/test-repl-timeout-throw.js
index 3636b93ddfc2b2..d3f65a683bd1f2 100644
--- a/test/sequential/test-repl-timeout-throw.js
+++ b/test/sequential/test-repl-timeout-throw.js
@@ -4,7 +4,7 @@ const assert = require('assert');
 
 const spawn = require('child_process').spawn;
 
-const child = spawn(process.execPath, [ '-i' ], {
+const child = spawn(process.execPath, ['-i'], {
   stdio: [null, null, 2]
 });
 
@@ -13,16 +13,15 @@ child.stdout.setEncoding('utf8');
 child.stdout.on('data', function(c) {
   process.stdout.write(c);
   stdout += c;
-  if (stdout.includes('> THROW 2'))
-    child.stdin.end();
+  if (stdout.includes('> THROW 2')) child.stdin.end();
 });
 
-child.stdin.write = function(original) {
+child.stdin.write = (function(original) {
   return function(c) {
     process.stderr.write(c);
     return original.call(child.stdin, c);
   };
-}(child.stdin.write);
+})(child.stdin.write);
 
 child.stdout.once('data', function() {
   child.stdin.write('var throws = 0;');
@@ -38,22 +37,27 @@ child.stdout.once('data', function() {
   }
 
   function eeTest() {
-    child.stdin.write('setTimeout(function() {\n' +
-                      '  const events = require("events");\n' +
-                      '  var e = new events.EventEmitter;\n' +
-                      '  process.nextTick(function() {\n' +
-                      '    e.on("x", thrower);\n' +
-                      '    setTimeout(function() {\n' +
-                      '      e.emit("x");\n' +
-                      '    });\n' +
-                      '  });\n' +
-                      '});"";\n');
+    child.stdin.write(
+      'setTimeout(function() {\n' +
+        '  const events = require("events");\n' +
+        '  var e = new events.EventEmitter;\n' +
+        '  process.nextTick(function() {\n' +
+        '    e.on("x", thrower);\n' +
+        '    setTimeout(function() {\n' +
+        '      e.emit("x");\n' +
+        '    });\n' +
+        '  });\n' +
+        '});"";\n'
+    );
   }
 });
 
 child.on('close', function(c) {
   assert.strictEqual(c, 0);
   // make sure we got 3 throws, in the end.
-  const lastLine = stdout.trim().split(/\r?\n/).pop();
+  const lastLine = stdout
+    .trim()
+    .split(/\r?\n/)
+    .pop();
   assert.strictEqual(lastLine, '> 3');
 });
diff --git a/test/sequential/test-stream-writable-clear-buffer.js b/test/sequential/test-stream-writable-clear-buffer.js
index dc859e3fb6b362..bb4f2b01a561bd 100644
--- a/test/sequential/test-stream-writable-clear-buffer.js
+++ b/test/sequential/test-stream-writable-clear-buffer.js
@@ -27,7 +27,8 @@ for (let i = 1; i <= 5; i++) {
       testStream._writableState.bufferedRequestCount,
       testStream._writableState.getBuffer().length,
       'bufferedRequestCount variable is different from the actual length of' +
-      ' the buffer');
+        ' the buffer'
+    );
   });
 }
 
diff --git a/test/sequential/test-stream2-fs.js b/test/sequential/test-stream2-fs.js
index 3d06abc9214089..ed5e2c3e23f6e7 100644
--- a/test/sequential/test-stream2-fs.js
+++ b/test/sequential/test-stream2-fs.js
@@ -61,9 +61,12 @@ const w = new TestWriter();
 w.on('results', function(res) {
   console.error(res, w.length);
   assert.strictEqual(w.length, size);
-  assert.deepStrictEqual(res.map(function(c) {
-    return c.length;
-  }), expectLengths);
+  assert.deepStrictEqual(
+    res.map(function(c) {
+      return c.length;
+    }),
+    expectLengths
+  );
   console.log('ok');
 });
 
diff --git a/test/sequential/test-stream2-stderr-sync.js b/test/sequential/test-stream2-stderr-sync.js
index 40995394ac5530..a9d82c163e4688 100644
--- a/test/sequential/test-stream2-stderr-sync.js
+++ b/test/sequential/test-stream2-stderr-sync.js
@@ -39,8 +39,7 @@ function parent() {
     child.on('close', function() {
       assert.strictEqual(err, `child ${c}\nfoo\nbar\nbaz\n`);
       console.log(`ok ${++i} child #${c}`);
-      if (i === children.length)
-        console.log(`1..${i}`);
+      if (i === children.length) console.log(`1..${i}`);
     });
   });
 }
@@ -67,14 +66,14 @@ function child2() {
   const socket = new net.Socket({
     fd: 2,
     readable: false,
-    writable: true });
+    writable: true
+  });
   socket.write('child 2\n');
   socket.write('foo\n');
   socket.write('bar\n');
   socket.write('baz\n');
 }
 
-
 function child3() {
   console.error('child 3\nfoo\nbar\nbaz');
 }
@@ -83,7 +82,7 @@ function child4() {
   process.stderr.write('child 4\nfoo\nbar\nbaz\n');
 }
 
-const children = [ child0, child1, child2, child3, child4 ];
+const children = [child0, child1, child2, child3, child4];
 
 if (!process.argv[2]) {
   parent();
diff --git a/test/sequential/test-timers-block-eventloop.js b/test/sequential/test-timers-block-eventloop.js
index 811216fcb29e7d..7b910075ac0266 100644
--- a/test/sequential/test-timers-block-eventloop.js
+++ b/test/sequential/test-timers-block-eventloop.js
@@ -7,10 +7,12 @@ let called = false;
 const t1 = setInterval(() => {
   assert(!called);
   called = true;
-  setImmediate(common.mustCall(() => {
-    clearInterval(t1);
-    clearInterval(t2);
-  }));
+  setImmediate(
+    common.mustCall(() => {
+      clearInterval(t1);
+      clearInterval(t2);
+    })
+  );
 }, 10);
 
 const t2 = setInterval(() => {
diff --git a/test/sequential/test-timers-blocking-callback.js b/test/sequential/test-timers-blocking-callback.js
index 3d05a538ea5f6b..31b8679270b159 100644
--- a/test/sequential/test-timers-blocking-callback.js
+++ b/test/sequential/test-timers-blocking-callback.js
@@ -61,8 +61,7 @@ function blockingCallback(retry, callback) {
       }
       assert.fail(`timeout delayed by more than 100% (${latestDelay}ms)`);
     }
-    if (callback)
-      return callback();
+    if (callback) return callback();
   } else {
     // block by busy-looping to trigger the issue
     common.busyLoop(TIMEOUT);
@@ -87,22 +86,15 @@ function testAddingTimerToNonEmptyTimersList() {
   // of them.
   let retryOK = true;
   const retry = () => {
-    if (retryOK)
-      testAddingTimerToNonEmptyTimersList();
+    if (retryOK) testAddingTimerToNonEmptyTimersList();
     retryOK = false;
   };
 
   initTest();
   // Call setTimeout twice with the same timeout to make
   // sure the timers list is not empty when blockingCallback is called.
-  setTimeout(
-    blockingCallback.bind(null, retry),
-    TIMEOUT
-  );
-  setTimeout(
-    blockingCallback.bind(null, retry),
-    TIMEOUT
-  );
+  setTimeout(blockingCallback.bind(null, retry), TIMEOUT);
+  setTimeout(blockingCallback.bind(null, retry), TIMEOUT);
 }
 
 // Run the test for the empty timers list case, and then for the non-empty
diff --git a/test/sequential/test-tls-connect.js b/test/sequential/test-tls-connect.js
index 291747aea77b49..1979da0b872312 100644
--- a/test/sequential/test-tls-connect.js
+++ b/test/sequential/test-tls-connect.js
@@ -22,8 +22,7 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const fixtures = require('../common/fixtures');
 
@@ -37,11 +36,16 @@ const tls = require('tls');
   const key = fixtures.readSync('test_key.pem');
 
   const options = { cert: cert, key: key, port: common.PORT };
-  const conn = tls.connect(options, common.mustNotCall());
+  const conn = tls.connect(
+    options,
+    common.mustNotCall()
+  );
 
   conn.on(
     'error',
-    common.mustCall((e) => { assert.strictEqual(e.code, 'ECONNREFUSED'); })
+    common.mustCall((e) => {
+      assert.strictEqual(e.code, 'ECONNREFUSED');
+    })
   );
 }
 
@@ -51,11 +55,14 @@ const tls = require('tls');
   const key = fixtures.readSync('test_key.pem');
 
   assert.throws(() => {
-    tls.connect({
-      cert: cert,
-      key: key,
-      port: common.PORT,
-      ciphers: 'rick-128-roll'
-    }, common.mustNotCall());
+    tls.connect(
+      {
+        cert: cert,
+        key: key,
+        port: common.PORT,
+        ciphers: 'rick-128-roll'
+      },
+      common.mustNotCall()
+    );
   }, /no cipher match/i);
 }
diff --git a/test/sequential/test-tls-lookup.js b/test/sequential/test-tls-lookup.js
index 568ba1350675e1..aabad1e28c2d32 100644
--- a/test/sequential/test-tls-lookup.js
+++ b/test/sequential/test-tls-lookup.js
@@ -1,7 +1,6 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const tls = require('tls');
 
@@ -12,12 +11,15 @@ const tls = require('tls');
     lookup: input
   };
 
-  common.expectsError(function() {
-    tls.connect(opts);
-  }, {
-    code: 'ERR_INVALID_ARG_TYPE',
-    type: TypeError
-  });
+  common.expectsError(
+    function() {
+      tls.connect(opts);
+    },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError
+    }
+  );
 });
 
 connectDoesNotThrow(common.mustCall(() => {}));
diff --git a/test/sequential/test-util-debug.js b/test/sequential/test-util-debug.js
index c79f99ff283c28..48c59f75586e02 100644
--- a/test/sequential/test-util-debug.js
+++ b/test/sequential/test-util-debug.js
@@ -25,10 +25,8 @@ const assert = require('assert');
 
 const [, , modeArgv, sectionArgv] = process.argv;
 
-if (modeArgv === 'child')
-  child(sectionArgv);
-else
-  parent();
+if (modeArgv === 'child') child(sectionArgv);
+else parent();
 
 function parent() {
   test('foo,tud,bar', true, 'tud');
@@ -64,9 +62,11 @@ function test(environ, shouldWrite, section) {
   });
 
   if (shouldWrite) {
-    expectErr =
-      `${section.toUpperCase()} ${child.pid}: this { is: 'a' } /debugging/\n${
-        section.toUpperCase()} ${child.pid}: num=1 str=a obj={"foo":"bar"}\n`;
+    expectErr = `${section.toUpperCase()} ${
+      child.pid
+    }: this { is: 'a' } /debugging/\n${section.toUpperCase()} ${
+      child.pid
+    }: num=1 str=a obj={"foo":"bar"}\n`;
   }
 
   let err = '';
@@ -81,14 +81,16 @@ function test(environ, shouldWrite, section) {
     out += c;
   });
 
-  child.on('close', common.mustCall((c) => {
-    assert(!c);
-    assert.strictEqual(err, expectErr);
-    assert.strictEqual(out, expectOut);
-  }));
+  child.on(
+    'close',
+    common.mustCall((c) => {
+      assert(!c);
+      assert.strictEqual(err, expectErr);
+      assert.strictEqual(out, expectOut);
+    })
+  );
 }
 
-
 function child(section) {
   const util = require('util');
   const debug = util.debuglog(section);
diff --git a/test/tick-processor/test-tick-processor-builtin.js b/test/tick-processor/test-tick-processor-builtin.js
index 1f38abe08c32e2..93d85308459602 100644
--- a/test/tick-processor/test-tick-processor-builtin.js
+++ b/test/tick-processor/test-tick-processor-builtin.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const { isCPPSymbolsNotMapped } = require('./util');
 
-if (!common.enoughTestCpu)
-  common.skip('test is CPU-intensive');
+if (!common.enoughTestCpu) common.skip('test is CPU-intensive');
 
 if (isCPPSymbolsNotMapped) {
   common.skip('C++ symbols are not mapped for this os.');
diff --git a/test/tick-processor/test-tick-processor-cpp-core.js b/test/tick-processor/test-tick-processor-cpp-core.js
index e76d99ab09db7b..39586832f131f7 100644
--- a/test/tick-processor/test-tick-processor-cpp-core.js
+++ b/test/tick-processor/test-tick-processor-cpp-core.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const { isCPPSymbolsNotMapped } = require('./util');
 
-if (!common.enoughTestCpu)
-  common.skip('test is CPU-intensive');
+if (!common.enoughTestCpu) common.skip('test is CPU-intensive');
 
 if (isCPPSymbolsNotMapped) {
   common.skip('C++ symbols are not mapped for this os.');
diff --git a/test/tick-processor/test-tick-processor-polyfill-brokenfile.js b/test/tick-processor/test-tick-processor-polyfill-brokenfile.js
index d0a6eb9f81806e..3153c2b9ee956d 100644
--- a/test/tick-processor/test-tick-processor-polyfill-brokenfile.js
+++ b/test/tick-processor/test-tick-processor-polyfill-brokenfile.js
@@ -4,8 +4,7 @@ const { isCPPSymbolsNotMapped } = require('./util');
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
-if (!common.enoughTestCpu)
-  common.skip('test is CPU-intensive');
+if (!common.enoughTestCpu) common.skip('test is CPU-intensive');
 
 if (isCPPSymbolsNotMapped) {
   common.skip('C++ symbols are not mapped for this OS.');
@@ -15,7 +14,6 @@ if (isCPPSymbolsNotMapped) {
 // ensure prof-polyfill not stuck in infinite loop
 // and success process
 
-
 const assert = require('assert');
 const cp = require('child_process');
 const path = require('path');
@@ -33,28 +31,25 @@ const code = `function f() {
          };
          f();`;
 
-const proc = cp.spawn(process.execPath, [
-  '--no_logfile_per_isolate',
-  '--logfile=-',
-  '--prof',
-  '-pe', code
-], {
-  stdio: ['ignore', 'pipe', 'inherit']
-});
+const proc = cp.spawn(
+  process.execPath,
+  ['--no_logfile_per_isolate', '--logfile=-', '--prof', '-pe', code],
+  {
+    stdio: ['ignore', 'pipe', 'inherit']
+  }
+);
 
 let ticks = '';
-proc.stdout.on('data', (chunk) => ticks += chunk);
-
+proc.stdout.on('data', (chunk) => (ticks += chunk));
 
 function runPolyfill(content) {
   proc.kill();
   content += BROKEN_PART;
   fs.writeFileSync(LOG_FILE, content);
-  const child = cp.spawnSync(
-    `${process.execPath}`,
-    [
-      '--prof-process', LOG_FILE
-    ]);
+  const child = cp.spawnSync(`${process.execPath}`, [
+    '--prof-process',
+    LOG_FILE
+  ]);
   assert(WARN_REG_EXP.test(child.stderr.toString()));
   assert(WARN_DETAIL_REG_EXP.test(child.stderr.toString()));
   assert.strictEqual(child.status, 0);
diff --git a/test/tick-processor/test-tick-processor-preprocess-flag.js b/test/tick-processor/test-tick-processor-preprocess-flag.js
index 8b1ec9920f47ed..c3108c0d28a94e 100644
--- a/test/tick-processor/test-tick-processor-preprocess-flag.js
+++ b/test/tick-processor/test-tick-processor-preprocess-flag.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const { isCPPSymbolsNotMapped } = require('./util');
 
-if (!common.enoughTestCpu)
-  common.skip('test is CPU-intensive');
+if (!common.enoughTestCpu) common.skip('test is CPU-intensive');
 
 if (isCPPSymbolsNotMapped) {
   common.skip('C++ symbols are not mapped for this os.');
diff --git a/test/tick-processor/test-tick-processor-unknown.js b/test/tick-processor/test-tick-processor-unknown.js
index 182f8c957c820a..76e34e277b0c97 100644
--- a/test/tick-processor/test-tick-processor-unknown.js
+++ b/test/tick-processor/test-tick-processor-unknown.js
@@ -6,11 +6,9 @@ const common = require('../common');
 // the full 64 bits and the result is that it does not process the
 // addresses correctly and runs out of memory
 // Disabling until we get a fix upstreamed into V8
-if (common.isAIX)
-  common.skip('AIX address range too big for scripts.');
+if (common.isAIX) common.skip('AIX address range too big for scripts.');
 
-if (!common.enoughTestCpu)
-  common.skip('test is CPU-intensive');
+if (!common.enoughTestCpu) common.skip('test is CPU-intensive');
 
 const base = require('./tick-processor-base.js');
 
diff --git a/test/tick-processor/tick-processor-base.js b/test/tick-processor/tick-processor-base.js
index 33944655258bef..f46ac474071d78 100644
--- a/test/tick-processor/tick-processor-base.js
+++ b/test/tick-processor/tick-processor-base.js
@@ -11,17 +11,16 @@ const LOG_FILE = path.join(tmpdir.path, 'tick-processor.log');
 const RETRY_TIMEOUT = 150;
 
 function runTest(test) {
-  const proc = cp.spawn(process.execPath, [
-    '--no_logfile_per_isolate',
-    '--logfile=-',
-    '--prof',
-    '-pe', test.code
-  ], {
-    stdio: [ 'ignore', 'pipe', 'inherit' ]
-  });
+  const proc = cp.spawn(
+    process.execPath,
+    ['--no_logfile_per_isolate', '--logfile=-', '--prof', '-pe', test.code],
+    {
+      stdio: ['ignore', 'pipe', 'inherit']
+    }
+  );
 
   let ticks = '';
-  proc.stdout.on('data', (chunk) => ticks += chunk);
+  proc.stdout.on('data', (chunk) => (ticks += chunk));
 
   // Try to match after timeout
   setTimeout(() => {
@@ -33,18 +32,17 @@ function match(pattern, parent, ticks, flags = []) {
   // Store current ticks log
   fs.writeFileSync(LOG_FILE, ticks());
 
-  const proc = cp.spawn(process.execPath, [
-    '--prof-process',
-    '--call-graph-size=10',
-    ...flags,
-    LOG_FILE
-  ], {
-    stdio: [ 'ignore', 'pipe', 'inherit' ]
-  });
+  const proc = cp.spawn(
+    process.execPath,
+    ['--prof-process', '--call-graph-size=10', ...flags, LOG_FILE],
+    {
+      stdio: ['ignore', 'pipe', 'inherit']
+    }
+  );
 
   let out = '';
 
-  proc.stdout.on('data', (chunk) => out += chunk);
+  proc.stdout.on('data', (chunk) => (out += chunk));
   proc.stdout.once('end', () => {
     proc.once('exit', () => {
       fs.unlinkSync(LOG_FILE);
diff --git a/test/tick-processor/util.js b/test/tick-processor/util.js
index d25a2a7dcb132e..2b8b7f797412e9 100644
--- a/test/tick-processor/util.js
+++ b/test/tick-processor/util.js
@@ -10,9 +10,6 @@ const {
 } = require('../common');
 
 module.exports = {
-  isCPPSymbolsNotMapped: isWindows ||
-                         isSunOS ||
-                         isAIX ||
-                         isLinuxPPCBE ||
-                         isFreeBSD
+  isCPPSymbolsNotMapped:
+    isWindows || isSunOS || isAIX || isLinuxPPCBE || isFreeBSD
 };
diff --git a/test/v8-updates/test-linux-perf.js b/test/v8-updates/test-linux-perf.js
index 0a7f199e040d58..f2ca10f2a00517 100644
--- a/test/v8-updates/test-linux-perf.js
+++ b/test/v8-updates/test-linux-perf.js
@@ -10,8 +10,7 @@
 // perf installed. It will skip if those criteria are not met.
 
 const common = require('../common');
-if (!common.hasCrypto)
-  common.skip('missing crypto');
+if (!common.hasCrypto) common.skip('missing crypto');
 
 const assert = require('assert');
 const { spawnSync } = require('child_process');
@@ -30,21 +29,18 @@ const perfArgs = [
   process.execPath,
   '--perf-basic-prof',
   '--interpreted-frames-native-stack',
-  '--no-turbo-inlining',  // Otherwise simple functions might get inlined.
-  fixtures.path('linux-perf.js'),
+  '--no-turbo-inlining', // Otherwise simple functions might get inlined.
+  fixtures.path('linux-perf.js')
 ];
 
-const perfScriptArgs = [
-  'script',
-];
+const perfScriptArgs = ['script'];
 
 const options = {
   cwd: tmpdir.path,
-  encoding: 'utf-8',
+  encoding: 'utf-8'
 };
 
-if (!common.isLinux)
-  common.skip('only testing Linux for now');
+if (!common.isLinux) common.skip('only testing Linux for now');
 
 const perf = spawnSync('perf', perfArgs, options);
 
@@ -57,8 +53,7 @@ if (perf.status !== 0) {
 
 const perfScript = spawnSync('perf', perfScriptArgs, options);
 
-if (perf.error)
-  common.skip(`perf script aborted: ${perf.error.errno}`);
+if (perf.error) common.skip(`perf script aborted: ${perf.error.errno}`);
 
 if (perfScript.status !== 0) {
   common.skip(`Failed to execute perf script: ${perfScript.stderr}`);
@@ -71,11 +66,19 @@ const compiledFunctionTwoRe = /LazyCompile:\*functionTwo/;
 
 const output = perfScript.stdout;
 
-assert.ok(output.match(interpretedFunctionOneRe),
-          "Couldn't find interpreted functionOne()");
-assert.ok(output.match(compiledFunctionOneRe),
-          "Couldn't find compiled functionOne()");
-assert.ok(output.match(interpretedFunctionTwoRe),
-          "Couldn't find interpreted functionTwo()");
-assert.ok(output.match(compiledFunctionTwoRe),
-          "Couldn't find compiled functionTwo");
+assert.ok(
+  output.match(interpretedFunctionOneRe),
+  "Couldn't find interpreted functionOne()"
+);
+assert.ok(
+  output.match(compiledFunctionOneRe),
+  "Couldn't find compiled functionOne()"
+);
+assert.ok(
+  output.match(interpretedFunctionTwoRe),
+  "Couldn't find interpreted functionTwo()"
+);
+assert.ok(
+  output.match(compiledFunctionTwoRe),
+  "Couldn't find compiled functionTwo"
+);
diff --git a/test/v8-updates/test-postmortem-metadata.js b/test/v8-updates/test-postmortem-metadata.js
index a67e218c03e8af..f732c58310e81b 100644
--- a/test/v8-updates/test-postmortem-metadata.js
+++ b/test/v8-updates/test-postmortem-metadata.js
@@ -11,15 +11,12 @@ const { getSharedLibPath } = require('../common/shared-lib-util.js');
 
 // For shared lib case, check shared lib instead
 const args = [
-  process.config.variables.node_shared ?
-    getSharedLibPath() : process.execPath
+  process.config.variables.node_shared ? getSharedLibPath() : process.execPath
 ];
 
-if (common.isAIX)
-  args.unshift('-Xany', '-B');
+if (common.isAIX) args.unshift('-Xany', '-B');
 
-if (common.isOpenBSD)
-  common.skip('no v8 debug symbols on OpenBSD');
+if (common.isOpenBSD) common.skip('no v8 debug symbols on OpenBSD');
 
 const nm = spawnSync('nm', args);
 
@@ -32,15 +29,17 @@ if (stderr.length > 0) {
 }
 
 const symbolRe = /\s_?(v8dbg_.+)$/;
-const symbols = nm.stdout.toString().split('\n').reduce((filtered, line) => {
-  const match = line.match(symbolRe);
-  const symbol = match && match[1];
+const symbols = nm.stdout
+  .toString()
+  .split('\n')
+  .reduce((filtered, line) => {
+    const match = line.match(symbolRe);
+    const symbol = match && match[1];
 
-  if (symbol)
-    filtered.push(symbol);
+    if (symbol) filtered.push(symbol);
 
-  return filtered;
-}, []);
+    return filtered;
+  }, []);
 const missing = getExpectedSymbols().filter((symbol) => {
   return !symbols.includes(symbol);
 });
@@ -190,6 +189,6 @@ function getExpectedSymbols() {
     'v8dbg_StringEncodingMask',
     'v8dbg_StringRepresentationMask',
     'v8dbg_ThinStringTag',
-    'v8dbg_TwoByteStringTag',
+    'v8dbg_TwoByteStringTag'
   ];
 }