diff --git a/.eslintrc.yaml b/.eslintrc.yaml
index 0139d63a78a04f..2b0e4875670101 100644
--- a/.eslintrc.yaml
+++ b/.eslintrc.yaml
@@ -62,6 +62,9 @@ rules:
   no-delete-var: 2
   no-undef: 2
   no-unused-vars: [2, {args: none}]
+  no-use-before-define: [2, {classes: true,
+                             functions: false,
+                             variables: false}]
 
   # Node.js and CommonJS
   # http://eslint.org/docs/rules/#nodejs-and-commonjs
diff --git a/README.md b/README.md
index 25e54f17dc89b9..aa5dd351bbfe75 100644
--- a/README.md
+++ b/README.md
@@ -240,6 +240,8 @@ more information about the governance of the Node.js project, see
 
 * [abouthiroppy](https://github.com/abouthiroppy) -
 **Yuta Hiroto** <hello@about-hiroppy.com> (he/him)
+* [addaleax](https://github.com/addaleax) -
+**Anna Henningsen** <anna@addaleax.net> (she/her)
 * [ak239](https://github.com/ak239) -
 **Aleksei Koziatinskii** <ak239spb@gmail.com>
 * [andrasq](https://github.com/andrasq) -
@@ -256,12 +258,20 @@ more information about the governance of the Node.js project, see
 **Benjamin Gruenbaum** <benjamingr@gmail.com>
 * [bmeck](https://github.com/bmeck) -
 **Bradley Farias** <bradley.meck@gmail.com>
+* [bnoordhuis](https://github.com/bnoordhuis) -
+**Ben Noordhuis** <info@bnoordhuis.nl>
 * [brendanashworth](https://github.com/brendanashworth) -
 **Brendan Ashworth** <brendan.ashworth@me.com>
 * [bzoz](https://github.com/bzoz) -
 **Bartosz Sosnowski** <bartosz@janeasystems.com>
 * [calvinmetcalf](https://github.com/calvinmetcalf) -
 **Calvin Metcalf** <calvin.metcalf@gmail.com>
+* [ChALkeR](https://github.com/ChALkeR) -
+**Сковорода Никита Андреевич** <chalkerx@gmail.com> (he/him)
+* [chrisdickinson](https://github.com/chrisdickinson) -
+**Chris Dickinson** <christopher.s.dickinson@gmail.com>
+* [cjihrig](https://github.com/cjihrig) -
+**Colin Ihrig** <cjihrig@gmail.com>
 * [claudiorodriguez](https://github.com/claudiorodriguez) -
 **Claudio Rodriguez** <cjrodr@yahoo.com>
 * [danbev](https://github.com/danbev) -
@@ -276,22 +286,36 @@ more information about the governance of the Node.js project, see
 **Alexander Makarenko** <estliberitas@gmail.com>
 * [eugeneo](https://github.com/eugeneo) -
 **Eugene Ostroukhov** <eostroukhov@google.com>
+* [evanlucas](https://github.com/evanlucas) -
+**Evan Lucas** <evanlucas@me.com> (he/him)
+* [fhinkel](https://github.com/fhinkel) -
+**Franziska Hinkelmann** <franziska.hinkelmann@gmail.com>
 * [firedfox](https://github.com/firedfox) -
 **Daniel Wang** <wangyang0123@gmail.com>
+* [Fishrock123](https://github.com/Fishrock123) -
+**Jeremiah Senkpiel** <fishrock123@rocketmail.com>
 * [geek](https://github.com/geek) -
 **Wyatt Preul** <wpreul@gmail.com>
 * [gibfahn](https://github.com/gibfahn) -
 **Gibson Fahnestock** <gibfahn@gmail.com> (he/him)
+* [gireeshpunathil](https://github.com/gireeshpunathil) -
+**Gireesh Punathil** <gpunathi@in.ibm.com> (he/him)
 * [iarna](https://github.com/iarna) -
 **Rebecca Turner** <me@re-becca.org>
 * [imran-iq](https://github.com/imran-iq) -
 **Imran Iqbal** <imran@imraniqbal.org>
 * [imyller](https://github.com/imyller) -
 **Ilkka Myller** <ilkka.myller@nodefield.com>
+* [indutny](https://github.com/indutny) -
+**Fedor Indutny** <fedor.indutny@gmail.com>
+* [isaacs](https://github.com/isaacs) -
+**Isaac Z. Schlueter** <i@izs.me>
 * [italoacasas](https://github.com/italoacasas) -
 **Italo A. Casas** <me@italoacasas.com> (he/him)
 * [JacksonTian](https://github.com/JacksonTian) -
 **Jackson Tian** <shyvo1987@gmail.com>
+* [jasnell](https://github.com/jasnell) -
+**James M Snell** <jasnell@gmail.com> (he/him)
 * [jasongin](https://github.com/jasongin) -
 **Jason Ginchereau** <jasongin@microsoft.com>
 * [jbergstroem](https://github.com/jbergstroem) -
@@ -304,6 +328,8 @@ more information about the governance of the Node.js project, see
 **João Reis** <reis@janeasystems.com>
 * [joshgav](https://github.com/joshgav) -
 **Josh Gavant** <josh.gavant@outlook.com>
+* [joyeecheung](https://github.com/joyeecheung) -
+**Joyee Cheung** <joyeec9h3@gmail.com> (she/her)
 * [julianduque](https://github.com/julianduque) -
 **Julian Duque** <julianduquej@gmail.com> (he/him)
 * [JungMinu](https://github.com/JungMinu) -
@@ -322,22 +348,38 @@ more information about the governance of the Node.js project, see
 **Aleksey Smolenchuk** <lxe@lxe.co>
 * [matthewloring](https://github.com/matthewloring) -
 **Matthew Loring** <mattloring@google.com>
+* [mcollina](https://github.com/mcollina) -
+**Matteo Collina** <matteo.collina@gmail.com> (he/him)
+* [mhdawson](https://github.com/mhdawson) -
+**Michael Dawson** <michael_dawson@ca.ibm.com> (he/him)
 * [micnic](https://github.com/micnic) -
 **Nicu Micleușanu** <micnic90@gmail.com> (he/him)
 * [mikeal](https://github.com/mikeal) -
 **Mikeal Rogers** <mikeal.rogers@gmail.com>
+* [misterdjules](https://github.com/misterdjules) -
+**Julien Gilli** <jgilli@nodejs.org>
 * [monsanto](https://github.com/monsanto) -
 **Christopher Monsanto** <chris@monsan.to>
+* [mscdex](https://github.com/mscdex) -
+**Brian White** <mscdex@mscdex.net>
+* [MylesBorins](https://github.com/MylesBorins) -
+**Myles Borins** <myles.borins@gmail.com> (he/him)
 * [not-an-aardvark](https://github.com/not-an-aardvark) -
 **Teddy Katz** <teddy.katz@gmail.com>
+* [ofrobots](https://github.com/ofrobots) -
+**Ali Ijaz Sheikh** <ofrobots@google.com>
 * [Olegas](https://github.com/Olegas) -
 **Oleg Elifantiev** <oleg@elifantiev.ru>
+* [orangemocha](https://github.com/orangemocha) -
+**Alexis Campailla** <orangemocha@nodejs.org>
 * [othiym23](https://github.com/othiym23) -
 **Forrest L Norvell** <ogd@aoaioxxysz.net> (he/him)
 * [petkaantonov](https://github.com/petkaantonov) -
 **Petka Antonov** <petka_antonov@hotmail.com>
 * [phillipj](https://github.com/phillipj) -
 **Phillip Johnsen** <johphi@gmail.com>
+* [piscisaureus](https://github.com/piscisaureus) -
+**Bert Belder** <bertbelder@gmail.com>
 * [pmq20](https://github.com/pmq20) -
 **Minqi Pan** <pmq2001@gmail.com>
 * [princejwesley](https://github.com/princejwesley) -
@@ -360,6 +402,8 @@ more information about the governance of the Node.js project, see
 **Ron Korving** <ron@ronkorving.nl>
 * [RReverser](https://github.com/RReverser) -
 **Ingvar Stepanyan** <me@rreverser.com>
+* [rvagg](https://github.com/rvagg) -
+**Rod Vagg** <rod@vagg.org>
 * [saghul](https://github.com/saghul) -
 **Saúl Ibarra Corretgé** <saghul@gmail.com>
 * [sam-github](https://github.com/sam-github) -
@@ -368,14 +412,20 @@ more information about the governance of the Node.js project, see
 **Santiago Gimeno** <santiago.gimeno@gmail.com>
 * [seishun](https://github.com/seishun) -
 **Nikolai Vavilov** <vvnicholas@gmail.com>
+* [shigeki](https://github.com/shigeki) -
+**Shigeki Ohtsu** <ohtsu@ohtsu.org> (he/him)
 * [silverwind](https://github.com/silverwind) -
 **Roman Reiss** <me@silverwind.io>
 * [srl295](https://github.com/srl295) -
 **Steven R Loomis** <srloomis@us.ibm.com>
 * [stefanmb](https://github.com/stefanmb) -
 **Stefan Budeanu** <stefan@budeanu.com>
+* [targos](https://github.com/targos) -
+**Michaël Zasso** <targos@protonmail.com> (he/him)
 * [tellnes](https://github.com/tellnes) -
 **Christian Tellnes** <christian@tellnes.no>
+* [thefourtheye](https://github.com/thefourtheye) -
+**Sakthipriyan Vairamani** <thechargingvolcano@gmail.com> (he/him)
 * [thekemkid](https://github.com/thekemkid) -
 **Glen Keane** <glenkeane.94@gmail.com> (he/him)
 * [thlorenz](https://github.com/thlorenz) -
@@ -384,6 +434,10 @@ more information about the governance of the Node.js project, see
 **Timothy Gu** <timothygu99@gmail.com> (he/him)
 * [tniessen](https://github.com/tniessen) -
 **Tobias Nießen** <tniessen@tnie.de>
+* [trevnorris](https://github.com/trevnorris) -
+**Trevor Norris** <trev.norris@gmail.com>
+* [Trott](https://github.com/Trott) -
+**Rich Trott** <rtrott@gmail.com> (he/him)
 * [tunniclm](https://github.com/tunniclm) -
 **Mike Tunnicliffe** <m.j.tunnicliffe@gmail.com>
 * [vkurchatkin](https://github.com/vkurchatkin) -
@@ -399,9 +453,8 @@ more information about the governance of the Node.js project, see
 * [yosuke-furukawa](https://github.com/yosuke-furukawa) -
 **Yosuke Furukawa** <yosuke.furukawa@gmail.com>
 
-Collaborators (which includes CTC members) follow the
-[COLLABORATOR_GUIDE.md](./COLLABORATOR_GUIDE.md) in maintaining the Node.js
-project.
+Collaborators follow the [COLLABORATOR_GUIDE.md](./COLLABORATOR_GUIDE.md) in
+maintaining the Node.js project.
 
 ### Release Team
 
diff --git a/configure b/configure
index 3948f18bcac7f4..7074021cf5bfee 100755
--- a/configure
+++ b/configure
@@ -40,6 +40,7 @@ import nodedownload
 # imports in tools/
 sys.path.insert(0, os.path.join(root_dir, 'tools'))
 import getmoduleversion
+from gyp_node import run_gyp
 
 # parse our options
 parser = optparse.OptionParser()
@@ -972,7 +973,10 @@ def configure_openssl(o):
     ]
   else:
     o['variables']['openssl_fips'] = ''
-
+    try:
+      os.remove('config_fips.gypi')
+    except OSError:
+      pass
 
   if options.without_ssl:
     def without_ssl_error(option):
@@ -1370,7 +1374,7 @@ config = '\n'.join(map('='.join, config.iteritems())) + '\n'
 
 write('config.mk', do_not_edit + config)
 
-gyp_args = [sys.executable, 'tools/gyp_node.py', '--no-parallel']
+gyp_args = ['--no-parallel']
 
 if options.use_xcode:
   gyp_args += ['-f', 'xcode']
@@ -1389,4 +1393,4 @@ gyp_args += args
 if warn.warned:
   warn('warnings were emitted in the configure phase')
 
-sys.exit(subprocess.call(gyp_args))
+run_gyp(gyp_args)
diff --git a/deps/v8/include/v8-version.h b/deps/v8/include/v8-version.h
index e2c861431c1091..aa916fc1259186 100644
--- a/deps/v8/include/v8-version.h
+++ b/deps/v8/include/v8-version.h
@@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 5
 #define V8_MINOR_VERSION 1
 #define V8_BUILD_NUMBER 281
-#define V8_PATCH_LEVEL 104
+#define V8_PATCH_LEVEL 105
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h
index ec45c91d77e728..2184b4a4b9cb07 100644
--- a/deps/v8/include/v8.h
+++ b/deps/v8/include/v8.h
@@ -6869,6 +6869,11 @@ class V8_EXPORT TryCatch {
    */
   void SetVerbose(bool value);
 
+  /**
+   * Returns true if verbosity is enabled.
+   */
+  bool IsVerbose() const;
+
   /**
    * Set whether or not this TryCatch should capture a Message object
    * which holds source information about where the exception
diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc
index 50848c780dff0c..3fbf688b5fcf6b 100644
--- a/deps/v8/src/api.cc
+++ b/deps/v8/src/api.cc
@@ -2395,6 +2395,10 @@ void v8::TryCatch::SetVerbose(bool value) {
   is_verbose_ = value;
 }
 
+bool v8::TryCatch::IsVerbose() const {
+  return is_verbose_;
+}
+
 
 void v8::TryCatch::SetCaptureMessage(bool value) {
   capture_message_ = value;
diff --git a/doc/api/child_process.md b/doc/api/child_process.md
index 25ee478ad104d2..6aab69b7ceb681 100644
--- a/doc/api/child_process.md
+++ b/doc/api/child_process.md
@@ -408,7 +408,7 @@ grep.on('close', (code) => {
 ```
 
 
-Example of checking for failed exec:
+Example of checking for failed `spawn`:
 
 ```js
 const spawn = require('child_process').spawn;
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 16fabfacf663e1..92b5b6a5fae1b6 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -359,7 +359,7 @@ added: v6.11.0
 
 Load an OpenSSL configuration file on startup. Among other uses, this can be
 used to enable FIPS-compliant crypto if Node.js is built with `./configure
-\-\-openssl\-fips`.
+--openssl-fips`.
 
 If the [`--openssl-config`][] command line option is used, the environment
 variable is ignored.
diff --git a/doc/api/console.md b/doc/api/console.md
index 5b687140253d26..f3652a56561316 100644
--- a/doc/api/console.md
+++ b/doc/api/console.md
@@ -227,9 +227,7 @@ console.log('count:', count);
 // Prints: count: 5, to stdout
 ```
 
-If formatting elements (e.g. `%d`) are not found in the first string then
-[`util.inspect()`][] is called on each argument and the resulting string
-values are concatenated. See [`util.format()`][] for more information.
+See [`util.format()`][] for more information.
 
 ### console.time(label)
 <!-- YAML
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 56969fc1d67dff..2591dc57fd49ab 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -979,6 +979,9 @@ added: v0.4.2
 Change the file timestamps of a file referenced by the supplied file
 descriptor.
 
+*Note*: This function does not work on AIX versions before 7.1, it will return
+the error `UV_ENOSYS`.
+
 ## fs.futimesSync(fd, atime, mtime)
 <!-- YAML
 added: v0.4.2
diff --git a/doc/api/path.md b/doc/api/path.md
index 27ca6be6fed7ac..dfe68f1d3cfcb6 100644
--- a/doc/api/path.md
+++ b/doc/api/path.md
@@ -447,7 +447,7 @@ path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb');
 // Returns: '..\\..\\impl\\bbb'
 ```
 
-A [`TypeError`][] is thrown if neither `from` nor `to` is a string.
+A [`TypeError`][] is thrown if either `from` or `to` is not a string.
 
 ## path.resolve([...paths])
 <!-- YAML
diff --git a/doc/api/stream.md b/doc/api/stream.md
index 69efa51158ff9e..f8be9d4a3dff8d 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -2060,6 +2060,7 @@ readable buffer so there is nothing for a user to consume.
 [HTTP responses, on the server]: http.html#http_class_http_serverresponse
 [http-incoming-message]: http.html#http_class_http_incomingmessage
 [Readable]: #stream_class_stream_readable
+[zlib]: zlib.html
 [stream-_flush]: #stream_transform_flush_callback
 [stream-_read]: #stream_readable_read_size_1
 [stream-_transform]: #stream_transform_transform_chunk_encoding_callback
diff --git a/doc/api/util.md b/doc/api/util.md
index ec5ec635d16fdf..0ab3ba0390bc9d 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -116,16 +116,17 @@ util.format('%s:%s', 'foo');
 // Returns: 'foo:%s'
 ```
 
-If there are more arguments passed to the `util.format()` method than the
-number of placeholders, the extra arguments are coerced into strings (for
-objects and symbols, `util.inspect()` is used) then concatenated to the
-returned string, each delimited by a space.
+If there are more arguments passed to the `util.format()` method than the number
+of placeholders, the extra arguments are coerced into strings then concatenated
+to the returned string, each delimited by a space. Excessive arguments whose
+`typeof` is `'object'` or `'symbol'` (except `null`) will be transformed by
+`util.inspect()`.
 
 ```js
 util.format('%s:%s', 'foo', 'bar', 'baz'); // 'foo:bar baz'
 ```
 
-If the first argument is not a format string then `util.format()` returns
+If the first argument is not a string then `util.format()` returns
 a string that is the concatenation of all arguments separated by spaces.
 Each argument is converted to a string using `util.inspect()`.
 
diff --git a/doc/onboarding-extras.md b/doc/onboarding-extras.md
index ff35907bbcb0e3..269a10149e2426 100644
--- a/doc/onboarding-extras.md
+++ b/doc/onboarding-extras.md
@@ -6,6 +6,7 @@
 | --- | --- |
 | `benchmark/*` | @nodejs/benchmarking, @mscdex |
 | `bootstrap_node.js` | @fishrock123 |
+| `doc/*`, `*.md` | @nodejs/documentation |
 | `lib/assert` | @nodejs/testing |
 | `lib/buffer` | @nodejs/buffer |
 | `lib/child_process` | @bnoordhuis, @cjihrig |
diff --git a/lib/_debugger.js b/lib/_debugger.js
index d3bf1f9ffa2dab..a3ceb457b0a7ee 100644
--- a/lib/_debugger.js
+++ b/lib/_debugger.js
@@ -993,7 +993,8 @@ Interface.prototype.debugEval = function(code, context, filename, callback) {
     return;
   }
 
-  var frame = client.currentFrame === NO_FRAME ? frame : undefined;
+  var frame = client.currentFrame;
+  if (frame !== NO_FRAME) frame = undefined;
 
   self.pause();
 
diff --git a/lib/_tls_wrap.js b/lib/_tls_wrap.js
index 1960910258bd7d..1973f155f349b0 100644
--- a/lib/_tls_wrap.js
+++ b/lib/_tls_wrap.js
@@ -402,7 +402,7 @@ TLSSocket.prototype._init = function(socket, wrap) {
 
   // lib/net.js expect this value to be non-zero if write hasn't been flushed
   // immediately
-  // TODO(indutny): rewise this solution, it might be 1 before handshake and
+  // TODO(indutny): revise this solution, it might be 1 before handshake and
   // represent real writeQueueSize during regular writes.
   ssl.writeQueueSize = 1;
 
@@ -705,7 +705,7 @@ TLSSocket.prototype.getProtocol = function() {
 // outcomes:
 //
 //   A) verifyError returns null meaning the client's certificate is signed
-//   by one of the server's CAs. The server know's the client idenity now
+//   by one of the server's CAs. The server now knows the client's identity
 //   and the client is authorized.
 //
 //   B) For some reason the client's certificate is not acceptable -
@@ -984,7 +984,7 @@ function normalizeConnectArgs(listArgs) {
   var cb = args[1];
 
   // If args[0] was options, then normalize dealt with it.
-  // If args[0] is port, or args[0], args[1]  is host,port, we need to
+  // If args[0] is port, or args[0], args[1] is host, port, we need to
   // find the options and merge them in, normalize's options has only
   // the host/port/path args that it knows about, not the tls options.
   // This means that options.host overrides a host arg.
diff --git a/lib/buffer.js b/lib/buffer.js
index 65bed256e39229..398bf95f340514 100644
--- a/lib/buffer.js
+++ b/lib/buffer.js
@@ -58,7 +58,7 @@ function alignPool() {
 }
 
 /**
- * The Buffer() construtor is "soft deprecated" ... that is, it is deprecated
+ * The Buffer() constructor is "soft deprecated" ... that is, it is deprecated
  * in the documentation and should not be used moving forward. Rather,
  * developers should use one of the three new factory APIs: Buffer.from(),
  * Buffer.allocUnsafe() or Buffer.alloc() based on their specific needs. There
@@ -124,7 +124,7 @@ Buffer.alloc = function(size, fill, encoding) {
     // Since we are filling anyway, don't zero fill initially.
     // Only pay attention to encoding if it's a string. This
     // prevents accidentally sending in a number that would
-    // be interpretted as a start offset.
+    // be interpreted as a start offset.
     if (typeof encoding !== 'string')
       encoding = undefined;
     return createUnsafeBuffer(size).fill(fill, encoding);
diff --git a/lib/fs.js b/lib/fs.js
index bcebdb34c9b8b6..3f3d27c40719ea 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -1651,7 +1651,7 @@ fs.realpathSync = function realpathSync(p, options) {
     }
   }
 
-  // walk down the path, swapping out linked pathparts for their real
+  // walk down the path, swapping out linked path parts for their real
   // values
   // NB: p.length changes.
   while (pos < p.length) {
@@ -1765,7 +1765,7 @@ fs.realpath = function realpath(p, options, callback) {
     }
   }
 
-  // walk down the path, swapping out linked pathparts for their real
+  // walk down the path, swapping out linked path parts for their real
   // values
   function LOOP() {
     // stop if scanned past end of path
diff --git a/lib/internal/bootstrap_node.js b/lib/internal/bootstrap_node.js
index 55dd4057ac95ce..de215dc2dce62b 100644
--- a/lib/internal/bootstrap_node.js
+++ b/lib/internal/bootstrap_node.js
@@ -443,11 +443,9 @@
     return NativeModule._source.hasOwnProperty(id);
   };
 
-  const EXPOSE_INTERNALS = process.execArgv.some(function(arg) {
-    return arg.match(/^--expose[-_]internals$/);
-  });
+  const config = process.binding('config');
 
-  if (EXPOSE_INTERNALS) {
+  if (config.exposeInternals) {
     NativeModule.nonInternalExists = NativeModule.exists;
 
     NativeModule.isInternal = function(id) {
diff --git a/lib/internal/child_process.js b/lib/internal/child_process.js
index 6033e9705e4969..f11d81c6d90b6b 100644
--- a/lib/internal/child_process.js
+++ b/lib/internal/child_process.js
@@ -29,6 +29,9 @@ module.exports = {
   getSocketList
 };
 
+const MAX_HANDLE_RETRANSMISSIONS = 3;
+
+
 // this object contain function to convert TCP objects to native handle objects
 // and back again.
 const handleConversion = {
@@ -94,17 +97,18 @@ const handleConversion = {
       return handle;
     },
 
-    postSend: function(handle, options, target) {
+    postSend: function(message, handle, options, callback, target) {
       // Store the handle after successfully sending it, so it can be closed
       // when the NODE_HANDLE_ACK is received. If the handle could not be sent,
       // just close it.
       if (handle && !options.keepOpen) {
         if (target) {
-          // There can only be one _pendingHandle as passing handles are
+          // There can only be one _pendingMessage as passing handles are
           // processed one at a time: handles are stored in _handleQueue while
           // waiting for the NODE_HANDLE_ACK of the current passing handle.
-          assert(!target._pendingHandle);
-          target._pendingHandle = handle;
+          assert(!target._pendingMessage);
+          target._pendingMessage =
+              { callback, message, handle, options, retransmissions: 0 };
         } else {
           handle.close();
         }
@@ -267,6 +271,11 @@ function getHandleWrapType(stream) {
   return false;
 }
 
+function closePendingHandle(target) {
+  target._pendingMessage.handle.close();
+  target._pendingMessage = null;
+}
+
 
 ChildProcess.prototype.spawn = function(options) {
   const self = this;
@@ -437,7 +446,7 @@ class Control extends EventEmitter {
 function setupChannel(target, channel) {
   target._channel = channel;
   target._handleQueue = null;
-  target._pendingHandle = null;
+  target._pendingMessage = null;
 
   const control = new Control(channel);
 
@@ -489,16 +498,31 @@ function setupChannel(target, channel) {
   // handlers will go through this
   target.on('internalMessage', function(message, handle) {
     // Once acknowledged - continue sending handles.
-    if (message.cmd === 'NODE_HANDLE_ACK') {
-      if (target._pendingHandle) {
-        target._pendingHandle.close();
-        target._pendingHandle = null;
+    if (message.cmd === 'NODE_HANDLE_ACK' ||
+        message.cmd === 'NODE_HANDLE_NACK') {
+
+      if (target._pendingMessage) {
+        if (message.cmd === 'NODE_HANDLE_ACK') {
+          closePendingHandle(target);
+        } else if (target._pendingMessage.retransmissions++ ===
+                   MAX_HANDLE_RETRANSMISSIONS) {
+          closePendingHandle(target);
+          process.emitWarning('Handle did not reach the receiving process ' +
+                              'correctly', 'SentHandleNotReceivedWarning');
+        }
       }
 
       assert(Array.isArray(target._handleQueue));
       var queue = target._handleQueue;
       target._handleQueue = null;
 
+      if (target._pendingMessage) {
+        target._send(target._pendingMessage.message,
+                     target._pendingMessage.handle,
+                     target._pendingMessage.options,
+                     target._pendingMessage.callback);
+      }
+
       for (var i = 0; i < queue.length; i++) {
         var args = queue[i];
         target._send(args.message, args.handle, args.options, args.callback);
@@ -513,6 +537,12 @@ function setupChannel(target, channel) {
 
     if (message.cmd !== 'NODE_HANDLE') return;
 
+    // It is possible that the handle is not received because of some error on
+    // ancillary data reception such as MSG_CTRUNC. In this case, report the
+    // sender about it by sending a NODE_HANDLE_NACK message.
+    if (!handle)
+      return target._send({ cmd: 'NODE_HANDLE_NACK' }, null, true);
+
     // Acknowledge handle receival. Don't emit error events (for example if
     // the other side has disconnected) because this call to send() is not
     // initiated by the user and it shouldn't be fatal to be unable to ACK
@@ -623,7 +653,8 @@ function setupChannel(target, channel) {
         net._setSimultaneousAccepts(handle);
       }
     } else if (this._handleQueue &&
-               !(message && message.cmd === 'NODE_HANDLE_ACK')) {
+               !(message && (message.cmd === 'NODE_HANDLE_ACK' ||
+                             message.cmd === 'NODE_HANDLE_NACK'))) {
       // Queue request anyway to avoid out-of-order messages.
       this._handleQueue.push({
         callback: callback,
@@ -645,7 +676,7 @@ function setupChannel(target, channel) {
         if (!this._handleQueue)
           this._handleQueue = [];
         if (obj && obj.postSend)
-          obj.postSend(handle, options, target);
+          obj.postSend(message, handle, options, callback, target);
       }
 
       req.oncomplete = function() {
@@ -662,7 +693,7 @@ function setupChannel(target, channel) {
     } else {
       // Cleanup handle on error
       if (obj && obj.postSend)
-        obj.postSend(handle, options);
+        obj.postSend(message, handle, options, callback);
 
       if (!options.swallowErrors) {
         const ex = errnoException(err, 'write');
@@ -711,10 +742,8 @@ function setupChannel(target, channel) {
     // This marks the fact that the channel is actually disconnected.
     this._channel = null;
 
-    if (this._pendingHandle) {
-      this._pendingHandle.close();
-      this._pendingHandle = null;
-    }
+    if (this._pendingMessage)
+      closePendingHandle(this);
 
     var fired = false;
     function finish() {
diff --git a/lib/internal/socket_list.js b/lib/internal/socket_list.js
index 0f4be6df239dd6..0b0d462cc0847a 100644
--- a/lib/internal/socket_list.js
+++ b/lib/internal/socket_list.js
@@ -5,7 +5,7 @@ module.exports = {SocketListSend, SocketListReceive};
 const EventEmitter = require('events');
 const util = require('util');
 
-// This object keep track of the socket there are sended
+// This object keeps track of the sockets that are sent
 function SocketListSend(slave, key) {
   EventEmitter.call(this);
 
@@ -54,7 +54,7 @@ SocketListSend.prototype.getConnections = function getConnections(callback) {
   });
 };
 
-// This object keep track of the socket there are received
+// This object keeps track of the sockets there are received
 function SocketListReceive(slave, key) {
   EventEmitter.call(this);
 
@@ -95,7 +95,7 @@ util.inherits(SocketListReceive, EventEmitter);
 SocketListReceive.prototype.add = function(obj) {
   this.connections++;
 
-  // Notify previous owner of socket about its state change
+  // Notify the previous owner of the socket about its state change
   obj.socket.once('close', () => {
     this.connections--;
 
diff --git a/lib/internal/v8_prof_polyfill.js b/lib/internal/v8_prof_polyfill.js
index 34cd10337f12a1..e77f1f76bcb9ee 100644
--- a/lib/internal/v8_prof_polyfill.js
+++ b/lib/internal/v8_prof_polyfill.js
@@ -105,12 +105,13 @@ function versionCheck() {
 function macCppfiltNm(out) {
   // Re-grouped copy-paste from `tickprocessor.js`
   const FUNC_RE = /^([0-9a-fA-F]{8,16} [iItT] )(.*)$/gm;
+  const CLEAN_RE = /^[0-9a-fA-F]{8,16} [iItT] /;
   let entries = out.match(FUNC_RE);
   if (entries === null)
     return out;
 
   entries = entries.map((entry) => {
-    return entry.replace(/^[0-9a-fA-F]{8,16} [iItT] /, '')
+    return entry.replace(CLEAN_RE, '')
   });
 
   let filtered;
@@ -123,7 +124,7 @@ function macCppfiltNm(out) {
   }
 
   let i = 0;
-  filtered = filtered.split(/\n/g);
+  filtered = filtered.split('\n');
   return out.replace(FUNC_RE, (all, prefix, postfix) => {
     return prefix + (filtered[i++] || postfix);
   });
diff --git a/lib/path.js b/lib/path.js
index 3ed587e0e0e167..dc8a33f4996e5f 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -767,7 +767,9 @@ const win32 = {
         }
       }
     } else if (code === 47/*/*/ || code === 92/*\*/) {
-      return path[0];
+      // `path` contains just a path separator, exit early to avoid
+      // unnecessary work
+      return path;
     }
 
     for (var i = len - 1; i >= offset; --i) {
@@ -885,6 +887,7 @@ const win32 = {
 
   extname: function extname(path) {
     assertPath(path);
+    var start = 0;
     var startDot = -1;
     var startPart = 0;
     var end = -1;
@@ -892,7 +895,20 @@ const win32 = {
     // Track the state of characters (if any) we see before our first dot and
     // after any path separator we find
     var preDotState = 0;
-    for (var i = path.length - 1; i >= 0; --i) {
+
+    // Check for a drive letter prefix so as not to mistake the following
+    // path separator as an extra separator at the end of the path that can be
+    // disregarded
+    if (path.length >= 2) {
+      const code = path.charCodeAt(0);
+      if (path.charCodeAt(1) === 58/*:*/ &&
+          ((code >= 65/*A*/ && code <= 90/*Z*/) ||
+           (code >= 97/*a*/ && code <= 122/*z*/))) {
+        start = startPart = 2;
+      }
+    }
+
+    for (var i = path.length - 1; i >= start; --i) {
       const code = path.charCodeAt(i);
       if (code === 47/*/*/ || code === 92/*\*/) {
         // If we reached a path separator that was not part of a set of path
@@ -956,15 +972,12 @@ const win32 = {
     var len = path.length;
     var rootEnd = 0;
     var code = path.charCodeAt(0);
-    var isAbsolute = false;
 
     // Try to match a root
     if (len > 1) {
       if (code === 47/*/*/ || code === 92/*\*/) {
         // Possible UNC root
 
-        isAbsolute = true;
-
         code = path.charCodeAt(1);
         rootEnd = 1;
         if (code === 47/*/*/ || code === 92/*\*/) {
@@ -1020,16 +1033,15 @@ const win32 = {
               if (len === 3) {
                 // `path` contains just a drive root, exit early to avoid
                 // unnecessary work
-                ret.root = ret.dir = path.slice(0, 3);
+                ret.root = ret.dir = path;
                 return ret;
               }
-              isAbsolute = true;
               rootEnd = 3;
             }
           } else {
             // `path` contains just a drive root, exit early to avoid
             // unnecessary work
-            ret.root = ret.dir = path.slice(0, 2);
+            ret.root = ret.dir = path;
             return ret;
           }
         }
@@ -1037,7 +1049,7 @@ const win32 = {
     } else if (code === 47/*/*/ || code === 92/*\*/) {
       // `path` contains just a path separator, exit early to avoid
       // unnecessary work
-      ret.root = ret.dir = path[0];
+      ret.root = ret.dir = path;
       return ret;
     }
 
@@ -1045,7 +1057,7 @@ const win32 = {
       ret.root = path.slice(0, rootEnd);
 
     var startDot = -1;
-    var startPart = 0;
+    var startPart = rootEnd;
     var end = -1;
     var matchedSlash = true;
     var i = path.length - 1;
@@ -1094,26 +1106,21 @@ const win32 = {
          startDot === end - 1 &&
          startDot === startPart + 1)) {
       if (end !== -1) {
-        if (startPart === 0 && isAbsolute)
-          ret.base = ret.name = path.slice(rootEnd, end);
-        else
-          ret.base = ret.name = path.slice(startPart, end);
+        ret.base = ret.name = path.slice(startPart, end);
       }
     } else {
-      if (startPart === 0 && isAbsolute) {
-        ret.name = path.slice(rootEnd, startDot);
-        ret.base = path.slice(rootEnd, end);
-      } else {
-        ret.name = path.slice(startPart, startDot);
-        ret.base = path.slice(startPart, end);
-      }
+      ret.name = path.slice(startPart, startDot);
+      ret.base = path.slice(startPart, end);
       ret.ext = path.slice(startDot, end);
     }
 
-    if (startPart > 0)
+    // If the directory is the root, use the entire root as the `dir` including
+    // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
+    // trailing slash (`C:\abc\def` -> `C:\abc`).
+    if (startPart > 0 && startPart !== rootEnd)
       ret.dir = path.slice(0, startPart - 1);
-    else if (isAbsolute)
-      ret.dir = path.slice(0, rootEnd);
+    else
+      ret.dir = ret.root;
 
     return ret;
   },
diff --git a/lib/repl.js b/lib/repl.js
index 9f544759a6581f..eb539cca0ef456 100644
--- a/lib/repl.js
+++ b/lib/repl.js
@@ -216,7 +216,7 @@ function REPLServer(prompt,
 
   if (breakEvalOnSigint && eval_) {
     // Allowing this would not reflect user expectations.
-    // breakEvalOnSigint affects only the behaviour of the default eval().
+    // breakEvalOnSigint affects only the behavior of the default eval().
     throw new Error('Cannot specify both breakEvalOnSigint and eval for REPL');
   }
 
@@ -817,7 +817,7 @@ REPLServer.prototype.complete = function() {
 function complete(line, callback) {
   // There may be local variables to evaluate, try a nested REPL
   if (this.bufferedCommand !== undefined && this.bufferedCommand.length) {
-    // Get a new array of inputed lines
+    // Get a new array of inputted lines
     var tmp = this.lines.slice();
     // Kill off all function declarations to push all local variables into
     // global scope
@@ -846,6 +846,7 @@ function complete(line, callback) {
   var completeOn, i, group, c;
 
   // REPL commands (e.g. ".break").
+  var filter;
   var match = null;
   match = line.match(/^\s*\.(\w*)$/);
   if (match) {
@@ -865,7 +866,7 @@ function complete(line, callback) {
 
     completeOn = match[1];
     var subdir = match[2] || '';
-    var filter = match[1];
+    filter = match[1];
     var dir, files, f, name, base, ext, abs, subfiles, s;
     group = [];
     var paths = module.paths.concat(require('module').globalPaths);
diff --git a/lib/timers.js b/lib/timers.js
index 94567f7990b994..7c9a721c68cef5 100644
--- a/lib/timers.js
+++ b/lib/timers.js
@@ -367,7 +367,7 @@ exports.setTimeout = function(callback, after, arg1, arg2, arg3) {
 function createSingleTimeout(callback, after, args) {
   after *= 1; // coalesce to number or NaN
   if (!(after >= 1 && after <= TIMEOUT_MAX))
-    after = 1; // schedule on next tick, follows browser behaviour
+    after = 1; // schedule on next tick, follows browser behavior
 
   var timer = new Timeout(after, callback, args);
   if (process.domain)
@@ -383,20 +383,20 @@ function ontimeout(timer) {
   var args = timer._timerArgs;
   var callback = timer._onTimeout;
   if (!args)
-    callback.call(timer);
+    timer._onTimeout();
   else {
     switch (args.length) {
       case 1:
-        callback.call(timer, args[0]);
+        timer._onTimeout(args[0]);
         break;
       case 2:
-        callback.call(timer, args[0], args[1]);
+        timer._onTimeout(args[0], args[1]);
         break;
       case 3:
-        callback.call(timer, args[0], args[1], args[2]);
+        timer._onTimeout(args[0], args[1], args[2]);
         break;
       default:
-        callback.apply(timer, args);
+        Function.prototype.apply.call(callback, timer, args);
     }
   }
   if (timer._repeat)
@@ -454,7 +454,7 @@ exports.setInterval = function(callback, repeat, arg1, arg2, arg3) {
 function createRepeatTimeout(callback, repeat, args) {
   repeat *= 1; // coalesce to number or NaN
   if (!(repeat >= 1 && repeat <= TIMEOUT_MAX))
-    repeat = 1; // schedule on next tick, follows browser behaviour
+    repeat = 1; // schedule on next tick, follows browser behavior
 
   var timer = new Timeout(repeat, callback, args);
   timer._repeat = repeat;
@@ -678,7 +678,7 @@ function runCallback(timer) {
       return timer._callback(argv[0], argv[1], argv[2]);
     // more than 3 arguments run slower with .apply
     default:
-      return timer._callback.apply(timer, argv);
+      return Function.prototype.apply.call(timer._callback, timer, argv);
   }
 }
 
diff --git a/lib/tls.js b/lib/tls.js
index bb4719d9b02c93..d8cbd63f751d6c 100644
--- a/lib/tls.js
+++ b/lib/tls.js
@@ -10,7 +10,7 @@ const Buffer = require('buffer').Buffer;
 
 // Allow {CLIENT_RENEG_LIMIT} client-initiated session renegotiations
 // every {CLIENT_RENEG_WINDOW} seconds. An error event is emitted if more
-// renegotations are seen. The settings are applied to all remote client
+// renegotiations are seen. The settings are applied to all remote client
 // connections.
 exports.CLIENT_RENEG_LIMIT = 3;
 exports.CLIENT_RENEG_WINDOW = 600;
diff --git a/lib/tty.js b/lib/tty.js
index f9b8a34e95d97a..e836beb900f155 100644
--- a/lib/tty.js
+++ b/lib/tty.js
@@ -50,7 +50,7 @@ function WriteStream(fd) {
 
   // Prevents interleaved or dropped stdout/stderr output for terminals.
   // As noted in the following reference, local TTYs tend to be quite fast and
-  // this behaviour has become expected due historical functionality on OS X,
+  // this behavior has become expected due historical functionality on OS X,
   // even though it was originally intended to change in v1.0.2 (Libuv 1.2.1).
   // Ref: https://github.com/nodejs/node/pull/1771#issuecomment-119351671
   this._handle.setBlocking(process.env.NODE_TTY_UNSAFE_ASYNC !== '1');
diff --git a/lib/url.js b/lib/url.js
index 42d1b60aec0100..e69786403449e1 100644
--- a/lib/url.js
+++ b/lib/url.js
@@ -436,7 +436,7 @@ function autoEscapeStr(rest) {
   var lastEscapedPos = 0;
   for (var i = 0; i < rest.length; ++i) {
     // Manual switching is faster than using a Map/Object.
-    // `escaped` contains substring up to the last escaped cahracter.
+    // `escaped` contains substring up to the last escaped character.
     switch (rest.charCodeAt(i)) {
       case 9:   // '\t'
         // Concat if there are ordinary characters in the middle.
diff --git a/node.gyp b/node.gyp
index 8bf26e276b2648..8be54752a28a41 100644
--- a/node.gyp
+++ b/node.gyp
@@ -488,7 +488,7 @@
                 '<(OBJ_DIR)/node/src/node_dtrace_ustack.o'
               ],
               'conditions': [
-                [ 'target_arch=="ia32"', {
+                [ 'target_arch=="ia32" or target_arch=="arm"', {
                   'action': [
                     'dtrace', '-32', '-I<(SHARED_INTERMEDIATE_DIR)', '-Isrc',
                     '-C', '-G', '-s', 'src/v8ustack.d', '-o', '<@(_outputs)',
diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index 44d0926ba6b178..d40d4b3256f193 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -372,6 +372,69 @@ struct CaresAsyncData {
   uv_async_t async_handle;
 };
 
+void SetupCaresChannel(Environment* env) {
+  struct ares_options options;
+  memset(&options, 0, sizeof(options));
+  options.flags = ARES_FLAG_NOCHECKRESP;
+  options.sock_state_cb = ares_sockstate_cb;
+  options.sock_state_cb_data = env;
+
+  /* We do the call to ares_init_option for caller. */
+  int r = ares_init_options(env->cares_channel_ptr(),
+                            &options,
+                            ARES_OPT_FLAGS | ARES_OPT_SOCK_STATE_CB);
+
+  if (r != ARES_SUCCESS) {
+    ares_library_cleanup();
+    return env->ThrowError(ToErrorCodeString(r));
+  }
+}
+
+
+/**
+ * This function is to check whether current servers are fallback servers
+ * when cares initialized.
+ *
+ * The fallback servers of cares is [ "127.0.0.1" ] with no user additional
+ * setting.
+ */
+void AresEnsureServers(Environment* env) {
+  /* if last query is OK or servers are set by user self, do not check */
+  if (env->cares_query_last_ok() || !env->cares_is_servers_default()) {
+    return;
+  }
+
+  ares_channel channel = env->cares_channel();
+  ares_addr_node* servers = nullptr;
+
+  ares_get_servers(channel, &servers);
+
+  /* if no server or multi-servers, ignore */
+  if (servers == nullptr) return;
+  if (servers->next != nullptr) {
+    ares_free_data(servers);
+    env->set_cares_is_servers_default(false);
+    return;
+  }
+
+  /* if the only server is not 127.0.0.1, ignore */
+  if (servers[0].family != AF_INET ||
+      servers[0].addr.addr4.s_addr != htonl(INADDR_LOOPBACK)) {
+    ares_free_data(servers);
+    env->set_cares_is_servers_default(false);
+    return;
+  }
+
+  ares_free_data(servers);
+  servers = nullptr;
+
+  /* destroy channel and reset channel */
+  ares_destroy(channel);
+
+  SetupCaresChannel(env);
+}
+
+
 class QueryWrap : public AsyncWrap {
  public:
   QueryWrap(Environment* env, Local<Object> req_wrap_obj)
@@ -402,6 +465,13 @@ class QueryWrap : public AsyncWrap {
     return static_cast<void*>(this);
   }
 
+  static void AresQuery(Environment* env, const char* name,
+                        int dnsclass, int type, ares_callback callback,
+                        void* arg) {
+    AresEnsureServers(env);
+    ares_query(env->cares_channel(), name, dnsclass, type, callback, arg);
+  }
+
   static void CaresAsyncClose(uv_handle_t* handle) {
     uv_async_t* async = reinterpret_cast<uv_async_t*>(handle);
     auto data = static_cast<struct CaresAsyncData*>(async->data);
@@ -453,6 +523,7 @@ class QueryWrap : public AsyncWrap {
                               async_handle,
                               CaresAsyncCb));
 
+    wrap->env()->set_cares_query_last_ok(status != ARES_ECONNREFUSED);
     async_handle->data = data;
     uv_async_send(async_handle);
   }
@@ -478,6 +549,7 @@ class QueryWrap : public AsyncWrap {
                               async_handle,
                               CaresAsyncCb));
 
+    wrap->env()->set_cares_query_last_ok(status != ARES_ECONNREFUSED);
     async_handle->data = data;
     uv_async_send(async_handle);
   }
@@ -522,12 +594,7 @@ class QueryAWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_a,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_a, Callback, GetQueryArg());
     return 0;
   }
 
@@ -570,12 +637,7 @@ class QueryAaaaWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_aaaa,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(),  name, ns_c_in, ns_t_aaaa, Callback, GetQueryArg());
     return 0;
   }
 
@@ -618,12 +680,7 @@ class QueryCnameWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_cname,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_cname, Callback, GetQueryArg());
     return 0;
   }
 
@@ -659,12 +716,7 @@ class QueryMxWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_mx,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_mx, Callback, GetQueryArg());
     return 0;
   }
 
@@ -710,12 +762,7 @@ class QueryNsWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_ns,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_ns, Callback, GetQueryArg());
     return 0;
   }
 
@@ -748,12 +795,7 @@ class QueryTxtWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_txt,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_txt, Callback, GetQueryArg());
     return 0;
   }
 
@@ -805,12 +847,7 @@ class QuerySrvWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_srv,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_srv, Callback, GetQueryArg());
     return 0;
   }
 
@@ -861,12 +898,7 @@ class QueryPtrWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_ptr,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_ptr, Callback, GetQueryArg());
     return 0;
   }
 
@@ -904,12 +936,7 @@ class QueryNaptrWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_naptr,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_naptr, Callback, GetQueryArg());
     return 0;
   }
 
@@ -968,12 +995,7 @@ class QuerySoaWrap: public QueryWrap {
   }
 
   int Send(const char* name) override {
-    ares_query(env()->cares_channel(),
-               name,
-               ns_c_in,
-               ns_t_soa,
-               Callback,
-               GetQueryArg());
+    AresQuery(env(), name, ns_c_in, ns_t_soa, Callback, GetQueryArg());
     return 0;
   }
 
@@ -1434,6 +1456,9 @@ static void SetServers(const FunctionCallbackInfo<Value>& args) {
 
   delete[] servers;
 
+  if (err == ARES_SUCCESS)
+    env->set_cares_is_servers_default(false);
+
   args.GetReturnValue().Set(err);
 }
 
@@ -1468,20 +1493,7 @@ static void Initialize(Local<Object> target,
   if (r != ARES_SUCCESS)
     return env->ThrowError(ToErrorCodeString(r));
 
-  struct ares_options options;
-  memset(&options, 0, sizeof(options));
-  options.flags = ARES_FLAG_NOCHECKRESP;
-  options.sock_state_cb = ares_sockstate_cb;
-  options.sock_state_cb_data = env;
-
-  /* We do the call to ares_init_option for caller. */
-  r = ares_init_options(env->cares_channel_ptr(),
-                        &options,
-                        ARES_OPT_FLAGS | ARES_OPT_SOCK_STATE_CB);
-  if (r != ARES_SUCCESS) {
-    ares_library_cleanup();
-    return env->ThrowError(ToErrorCodeString(r));
-  }
+  SetupCaresChannel(env);
 
   /* Initialize the timeout timer. The timer won't be started until the */
   /* first socket is opened. */
diff --git a/src/env-inl.h b/src/env-inl.h
index 735dbca6857fa1..e2876de44a9390 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -219,6 +219,8 @@ inline Environment::Environment(v8::Local<v8::Context> context,
     : isolate_(context->GetIsolate()),
       isolate_data_(IsolateData::GetOrCreate(context->GetIsolate(), loop)),
       timer_base_(uv_now(loop)),
+      cares_query_last_ok_(true),
+      cares_is_servers_default_(true),
       using_domains_(false),
       printed_error_(false),
       trace_sync_io_(false),
@@ -453,6 +455,22 @@ inline ares_channel* Environment::cares_channel_ptr() {
   return &cares_channel_;
 }
 
+inline bool Environment::cares_query_last_ok() {
+  return cares_query_last_ok_;
+}
+
+inline void Environment::set_cares_query_last_ok(bool ok) {
+  cares_query_last_ok_ = ok;
+}
+
+inline bool Environment::cares_is_servers_default() {
+  return cares_is_servers_default_;
+}
+
+inline void Environment::set_cares_is_servers_default(bool is_default) {
+  cares_is_servers_default_ = is_default;
+}
+
 inline node_ares_task_list* Environment::cares_task_list() {
   return &cares_task_list_;
 }
diff --git a/src/env.h b/src/env.h
index bb4dab070606a8..940c97fe4ddbf1 100644
--- a/src/env.h
+++ b/src/env.h
@@ -437,6 +437,10 @@ class Environment {
   inline uv_timer_t* cares_timer_handle();
   inline ares_channel cares_channel();
   inline ares_channel* cares_channel_ptr();
+  inline bool cares_query_last_ok();
+  inline void set_cares_query_last_ok(bool ok);
+  inline bool cares_is_servers_default();
+  inline void set_cares_is_servers_default(bool is_default);
   inline node_ares_task_list* cares_task_list();
 
   inline bool using_domains() const;
@@ -555,6 +559,8 @@ class Environment {
   const uint64_t timer_base_;
   uv_timer_t cares_timer_handle_;
   ares_channel cares_channel_;
+  bool cares_query_last_ok_;
+  bool cares_is_servers_default_;
   node_ares_task_list cares_task_list_;
   bool using_domains_;
   bool printed_error_;
diff --git a/src/node.cc b/src/node.cc
index 73ed460f361b44..984c228205378d 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -199,6 +199,12 @@ bool trace_warnings = false;
 // that is used by lib/module.js
 bool config_preserve_symlinks = false;
 
+// Set in node.cc by ParseArgs when --expose-internals or --expose_internals is
+// used.
+// Used in node_config.cc to set a constant on process.binding('config')
+// that is used by lib/internal/bootstrap_node.js
+bool config_expose_internals = false;
+
 // process-relative uptime base, initialized at start-up
 static double prog_start_time;
 static bool debugger_running;
@@ -2596,9 +2602,9 @@ void FatalException(Isolate* isolate,
 
 void FatalException(Isolate* isolate, const TryCatch& try_catch) {
   HandleScope scope(isolate);
-  // TODO(bajtos) do not call FatalException if try_catch is verbose
-  // (requires V8 API to expose getter for try_catch.is_verbose_)
-  FatalException(isolate, try_catch.Exception(), try_catch.Message());
+  if (!try_catch.IsVerbose()) {
+    FatalException(isolate, try_catch.Exception(), try_catch.Message());
+  }
 }
 
 
@@ -3317,6 +3323,7 @@ void SetupProcessObject(Environment* env,
     READONLY_PROPERTY(process, "_forceRepl", True(env->isolate()));
   }
 
+  // -r, --require
   if (preload_module_count) {
     CHECK(preload_modules);
     Local<Array> array = Array::New(env->isolate());
@@ -3339,10 +3346,12 @@ void SetupProcessObject(Environment* env,
     READONLY_PROPERTY(process, "noDeprecation", True(env->isolate()));
   }
 
+  // --no-warnings
   if (no_process_warnings) {
     READONLY_PROPERTY(process, "noProcessWarnings", True(env->isolate()));
   }
 
+  // --trace-warnings
   if (trace_warnings) {
     READONLY_PROPERTY(process, "traceProcessWarnings", True(env->isolate()));
   }
@@ -3893,7 +3902,7 @@ static void ParseArgs(int* argc,
 #endif
     } else if (strcmp(arg, "--expose-internals") == 0 ||
                strcmp(arg, "--expose_internals") == 0) {
-      // consumed in js
+      config_expose_internals = true;
     } else if (strcmp(arg, "--") == 0) {
       index += 1;
       break;
@@ -4416,7 +4425,7 @@ void Init(int* argc,
   // If icu_data_dir is empty here, it will load the 'minimal' data.
   if (!i18n::InitializeICUDirectory(icu_data_dir)) {
     FatalError(nullptr, "Could not initialize ICU "
-                     "(check NODE_ICU_DATA or --icu-data-dir parameters)");
+                     "(check NODE_ICU_DATA or --icu-data-dir parameters)\n");
   }
 #endif
   // The const_cast doesn't violate conceptual const-ness.  V8 doesn't modify
diff --git a/src/node.h b/src/node.h
index 55ad8031104d3c..103ff98709a395 100644
--- a/src/node.h
+++ b/src/node.h
@@ -282,7 +282,7 @@ inline void NODE_SET_PROTOTYPE_METHOD(v8::Local<v8::FunctionTemplate> recv,
       v8::FunctionTemplate::New(isolate, callback, v8::Local<v8::Value>(), s);
   v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name);
   t->SetClassName(fn_name);
-  recv->PrototypeTemplate()->Set(v8::String::NewFromUtf8(isolate, name), t);
+  recv->PrototypeTemplate()->Set(fn_name, t);
 }
 #define NODE_SET_PROTOTYPE_METHOD node::NODE_SET_PROTOTYPE_METHOD
 
diff --git a/src/node_config.cc b/src/node_config.cc
index 401345f6a608be..4408bc3cf33ffc 100644
--- a/src/node_config.cc
+++ b/src/node_config.cc
@@ -44,6 +44,9 @@ void InitConfig(Local<Object> target,
 
   if (config_preserve_symlinks)
     READONLY_BOOLEAN_PROPERTY("preserveSymlinks");
+
+  if (config_expose_internals)
+    READONLY_BOOLEAN_PROPERTY("exposeInternals");
 }  // InitConfig
 
 }  // namespace node
diff --git a/src/node_crypto_bio.cc b/src/node_crypto_bio.cc
index a862573c280acb..ba19eb6ef2385a 100644
--- a/src/node_crypto_bio.cc
+++ b/src/node_crypto_bio.cc
@@ -6,6 +6,7 @@
 #include <string.h>
 
 namespace node {
+namespace crypto {
 
 const BIO_METHOD NodeBIO::method = {
   BIO_TYPE_MEM,
@@ -467,4 +468,5 @@ NodeBIO::~NodeBIO() {
   write_head_ = nullptr;
 }
 
+}  // namespace crypto
 }  // namespace node
diff --git a/src/node_crypto_bio.h b/src/node_crypto_bio.h
index ed6b46b53237cf..fd70fcc546178f 100644
--- a/src/node_crypto_bio.h
+++ b/src/node_crypto_bio.h
@@ -11,6 +11,7 @@
 #include "v8.h"
 
 namespace node {
+namespace crypto {
 
 class NodeBIO {
  public:
@@ -135,6 +136,7 @@ class NodeBIO {
   Buffer* write_head_;
 };
 
+}  // namespace crypto
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/node_crypto_clienthello-inl.h b/src/node_crypto_clienthello-inl.h
index 108383bf2d542a..0bb668de7a97f1 100644
--- a/src/node_crypto_clienthello-inl.h
+++ b/src/node_crypto_clienthello-inl.h
@@ -7,6 +7,7 @@
 #include "util-inl.h"
 
 namespace node {
+namespace crypto {
 
 inline void ClientHelloParser::Reset() {
   frame_len_ = 0;
@@ -53,6 +54,7 @@ inline bool ClientHelloParser::IsPaused() const {
   return state_ == kPaused;
 }
 
+}  // namespace crypto
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/node_crypto_clienthello.cc b/src/node_crypto_clienthello.cc
index 365e61c4f73647..93f0c1de05aebb 100644
--- a/src/node_crypto_clienthello.cc
+++ b/src/node_crypto_clienthello.cc
@@ -2,6 +2,7 @@
 #include "node_crypto_clienthello-inl.h"
 
 namespace node {
+namespace crypto {
 
 void ClientHelloParser::Parse(const uint8_t* data, size_t avail) {
   switch (state_) {
@@ -223,4 +224,5 @@ bool ClientHelloParser::ParseTLSClientHello(const uint8_t* data, size_t avail) {
   return true;
 }
 
+}  // namespace crypto
 }  // namespace node
diff --git a/src/node_crypto_clienthello.h b/src/node_crypto_clienthello.h
index 3550807c20d05f..0b0c8b1712c3ee 100644
--- a/src/node_crypto_clienthello.h
+++ b/src/node_crypto_clienthello.h
@@ -9,6 +9,7 @@
 #include <stdlib.h>  // nullptr
 
 namespace node {
+namespace crypto {
 
 class ClientHelloParser {
  public:
@@ -112,6 +113,7 @@ class ClientHelloParser {
   const uint8_t* tls_ticket_;
 };
 
+}  // namespace crypto
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/node_internals.h b/src/node_internals.h
index cb71720e8205d9..e93244a94c6927 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -43,6 +43,12 @@ extern std::string openssl_config;
 // that is used by lib/module.js
 extern bool config_preserve_symlinks;
 
+// Set in node.cc by ParseArgs when --expose-internals or --expose_internals is
+// used.
+// Used in node_config.cc to set a constant on process.binding('config')
+// that is used by lib/internal/bootstrap_node.js
+extern bool config_expose_internals;
+
 // Forward declaration
 class Environment;
 
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index 8eab962a66f61c..78ba7126dfebb0 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -117,10 +117,10 @@ void TLSWrap::NewSessionDoneCb() {
 
 void TLSWrap::InitSSL() {
   // Initialize SSL
-  enc_in_ = NodeBIO::New();
-  enc_out_ = NodeBIO::New();
-  NodeBIO::FromBIO(enc_in_)->AssignEnvironment(env());
-  NodeBIO::FromBIO(enc_out_)->AssignEnvironment(env());
+  enc_in_ = crypto::NodeBIO::New();
+  enc_out_ = crypto::NodeBIO::New();
+  crypto::NodeBIO::FromBIO(enc_in_)->AssignEnvironment(env());
+  crypto::NodeBIO::FromBIO(enc_out_)->AssignEnvironment(env());
 
   SSL_set_bio(ssl_, enc_in_, enc_out_);
 
@@ -149,7 +149,7 @@ void TLSWrap::InitSSL() {
     SSL_set_accept_state(ssl_);
   } else if (is_client()) {
     // Enough space for server response (hello, cert)
-    NodeBIO::FromBIO(enc_in_)->set_initial(kInitialClientBufferLength);
+    crypto::NodeBIO::FromBIO(enc_in_)->set_initial(kInitialClientBufferLength);
     SSL_set_connect_state(ssl_);
   } else {
     // Unexpected
@@ -157,7 +157,7 @@ void TLSWrap::InitSSL() {
   }
 
   // Initialize ring for queud clear data
-  clear_in_ = new NodeBIO();
+  clear_in_ = new crypto::NodeBIO();
   clear_in_->AssignEnvironment(env());
 }
 
@@ -289,7 +289,9 @@ void TLSWrap::EncOut() {
   char* data[kSimultaneousBufferCount];
   size_t size[arraysize(data)];
   size_t count = arraysize(data);
-  write_size_ = NodeBIO::FromBIO(enc_out_)->PeekMultiple(data, size, &count);
+  write_size_ = crypto::NodeBIO::FromBIO(enc_out_)->PeekMultiple(data,
+                                                                 size,
+                                                                 &count);
   CHECK(write_size_ != 0 && count != 0);
 
   Local<Object> req_wrap_obj =
@@ -335,7 +337,7 @@ void TLSWrap::EncOutCb(WriteWrap* req_wrap, int status) {
   }
 
   // Commit
-  NodeBIO::FromBIO(wrap->enc_out_)->Read(nullptr, wrap->write_size_);
+  crypto::NodeBIO::FromBIO(wrap->enc_out_)->Read(nullptr, wrap->write_size_);
 
   // Ensure that the progress will be made and `InvokeQueued` will be called.
   wrap->ClearIn();
@@ -653,7 +655,7 @@ void TLSWrap::OnAllocImpl(size_t suggested_size, uv_buf_t* buf, void* ctx) {
   }
 
   size_t size = 0;
-  buf->base = NodeBIO::FromBIO(wrap->enc_in_)->PeekWritable(&size);
+  buf->base = crypto::NodeBIO::FromBIO(wrap->enc_in_)->PeekWritable(&size);
   buf->len = size;
 }
 
@@ -717,7 +719,7 @@ void TLSWrap::DoRead(ssize_t nread,
   }
 
   // Commit read data
-  NodeBIO* enc_in = NodeBIO::FromBIO(enc_in_);
+  crypto::NodeBIO* enc_in = crypto::NodeBIO::FromBIO(enc_in_);
   enc_in->Commit(nread);
 
   // Parse ClientHello first
@@ -788,7 +790,7 @@ void TLSWrap::EnableSessionCallbacks(
         "EnableSessionCallbacks after destroySSL");
   }
   wrap->enable_session_callbacks();
-  NodeBIO::FromBIO(wrap->enc_in_)->set_initial(kMaxHelloLength);
+  crypto::NodeBIO::FromBIO(wrap->enc_in_)->set_initial(kMaxHelloLength);
   wrap->hello_parser_.Start(SSLWrap<TLSWrap>::OnClientHello,
                             OnClientHelloParseEnd,
                             wrap);
diff --git a/src/tls_wrap.h b/src/tls_wrap.h
index fbf664edd530c0..95d26bb91734e3 100644
--- a/src/tls_wrap.h
+++ b/src/tls_wrap.h
@@ -17,10 +17,10 @@
 namespace node {
 
 // Forward-declarations
-class NodeBIO;
 class WriteWrap;
 namespace crypto {
 class SecureContext;
+class NodeBIO;
 }
 
 class TLSWrap : public AsyncWrap,
@@ -151,7 +151,7 @@ class TLSWrap : public AsyncWrap,
   StreamBase* stream_;
   BIO* enc_in_;
   BIO* enc_out_;
-  NodeBIO* clear_in_;
+  crypto::NodeBIO* clear_in_;
   size_t write_size_;
   typedef ListHead<WriteItem, &WriteItem::member_> WriteItemList;
   WriteItemList write_item_queue_;
diff --git a/src/util.h b/src/util.h
index ecd5b128c8c394..f415141a58e997 100644
--- a/src/util.h
+++ b/src/util.h
@@ -93,14 +93,6 @@ template <typename T> using remove_reference = std::remove_reference<T>;
     }                                                                         \
   } while (0)
 
-// FIXME(bnoordhuis) cctests don't link in node::Abort() and node::Assert().
-#ifdef GTEST_DONT_DEFINE_ASSERT_EQ
-#undef ABORT
-#undef CHECK
-#define ABORT ABORT_NO_BACKTRACE
-#define CHECK assert
-#endif
-
 #ifdef NDEBUG
 #define ASSERT(expr)
 #else
diff --git a/test/.eslintrc.yaml b/test/.eslintrc.yaml
index 8414b828137e5d..4fea04d632f2d4 100644
--- a/test/.eslintrc.yaml
+++ b/test/.eslintrc.yaml
@@ -6,6 +6,9 @@ rules:
   no-var: 2
   prefer-const: 2
 
+  # Custom rules in tools/eslint-rules
+  prefer-common-mustnotcall: 2
+
   ## common module is mandatory in tests
   required-modules: [2, common]
   prefer-assert-methods: 2
diff --git a/test/addons/async-hello-world/binding.cc b/test/addons/async-hello-world/binding.cc
index 70fee63aa5e648..da2bd417cd9a6f 100644
--- a/test/addons/async-hello-world/binding.cc
+++ b/test/addons/async-hello-world/binding.cc
@@ -55,7 +55,6 @@ void AfterAsync(uv_work_t* r) {
 
 void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
-  v8::HandleScope scope(isolate);
 
   async_req* req = new async_req;
   req->req.data = req;
diff --git a/test/addons/async-hello-world/test.js b/test/addons/async-hello-world/test.js
index a6aa8aa20fffbc..fbd0d7eeb7ef13 100644
--- a/test/addons/async-hello-world/test.js
+++ b/test/addons/async-hello-world/test.js
@@ -6,5 +6,5 @@ const binding = require(`./build/${common.buildType}/binding`);
 binding(5, common.mustCall(function(err, val) {
   assert.strictEqual(err, null);
   assert.strictEqual(val, 10);
-  process.nextTick(common.mustCall(function() {}));
+  process.nextTick(common.mustCall());
 }));
diff --git a/test/addons/at-exit/binding.cc b/test/addons/at-exit/binding.cc
index c9b26a348ad8fe..d90b3f70c2560b 100644
--- a/test/addons/at-exit/binding.cc
+++ b/test/addons/at-exit/binding.cc
@@ -1,4 +1,3 @@
-#undef NDEBUG
 #include <assert.h>
 #include <stdlib.h>
 #include <node.h>
diff --git a/test/addons/hello-world-function-export/binding.cc b/test/addons/hello-world-function-export/binding.cc
index c113e0489bde0e..9a93a806e7156e 100644
--- a/test/addons/hello-world-function-export/binding.cc
+++ b/test/addons/hello-world-function-export/binding.cc
@@ -3,7 +3,6 @@
 
 void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
-  v8::HandleScope scope(isolate);
   args.GetReturnValue().Set(v8::String::NewFromUtf8(isolate, "world"));
 }
 
diff --git a/test/addons/hello-world/binding.cc b/test/addons/hello-world/binding.cc
index 5651dc8f50a317..83823ae8363cd9 100644
--- a/test/addons/hello-world/binding.cc
+++ b/test/addons/hello-world/binding.cc
@@ -3,7 +3,6 @@
 
 void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
-  v8::HandleScope scope(isolate);
   args.GetReturnValue().Set(v8::String::NewFromUtf8(isolate, "world"));
 }
 
diff --git a/test/addons/repl-domain-abort/binding.cc b/test/addons/repl-domain-abort/binding.cc
index a507b6fd01e1d1..0c37359e2142ff 100644
--- a/test/addons/repl-domain-abort/binding.cc
+++ b/test/addons/repl-domain-abort/binding.cc
@@ -4,14 +4,12 @@
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::Local;
-using v8::HandleScope;
 using v8::Isolate;
 using v8::Object;
 using v8::Value;
 
 void Method(const FunctionCallbackInfo<Value>& args) {
   Isolate* isolate = args.GetIsolate();
-  HandleScope scope(isolate);
   node::MakeCallback(isolate,
                      isolate->GetCurrentContext()->Global(),
                      args[0].As<Function>(),
diff --git a/test/addons/repl-domain-abort/test.js b/test/addons/repl-domain-abort/test.js
index 969beec0d12442..1d0e5202b6a6f2 100644
--- a/test/addons/repl-domain-abort/test.js
+++ b/test/addons/repl-domain-abort/test.js
@@ -33,7 +33,7 @@ dInput._read = function _read(size) {
 };
 
 dOutput._write = function _write(chunk, encoding, cb) {
-  if (chunk.toString().indexOf('cb_ran') === 0)
+  if (chunk.toString().startsWith('cb_ran'))
     cb_ran = true;
   cb();
 };
diff --git a/test/common/README.md b/test/common/README.md
index 267d28140c5003..01d19116bdac29 100644
--- a/test/common/README.md
+++ b/test/common/README.md
@@ -182,9 +182,9 @@ Gets IP of localhost
 
 Array of IPV6 hosts.
 
-### mustCall([fn][, expected])
-* fn [&lt;Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
-* expected [&lt;Number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) default = 1
+### mustCall([fn][, exact])
+* `fn` [&lt;Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) default = `common.noop`
+* `exact` [&lt;Number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) default = 1
 * return [&lt;Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
 
 Returns a function that calls `fn`. If the returned function has not been called
@@ -193,6 +193,23 @@ fail.
 
 If `fn` is not provided, `common.noop` will be used.
 
+### mustCallAtLeast([fn][, minimum])
+* `fn` [&lt;Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) default = `common.noop`
+* `minimum` [&lt;Number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) default = 1
+* return [&lt;Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
+
+Returns a function that calls `fn`. If the returned function has not been called
+at least `minimum` number of times when the test is complete, then the test will
+fail.
+
+If `fn` is not provided, `common.noop` will be used.
+
+### mustNotCall([msg])
+* `msg` [&lt;String>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) default = 'function should not have been called'
+* return [&lt;Function>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
+
+Returns a function that triggers an `AssertionError` if it is invoked. `msg` is used as the error message for the `AssertionError`.
+
 ### nodeProcessAborted(exitCode, signal)
 * `exitCode` [&lt;Number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type)
 * `signal` [&lt;String>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type)
diff --git a/test/common/index.js b/test/common/index.js
index 455d50fe6c344a..ec889b4aff2dc5 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -12,6 +12,9 @@ const Timer = process.binding('timer_wrap').Timer;
 const testRoot = process.env.NODE_TEST_DIR ?
   fs.realpathSync(process.env.NODE_TEST_DIR) : path.resolve(__dirname, '..');
 
+const noop = () => {};
+
+exports.noop = noop;
 exports.fixturesDir = path.join(__dirname, '..', 'fixtures');
 exports.tmpDirName = 'tmp';
 // PORT should match the definition in test/testpy/__init__.py.
@@ -403,13 +406,19 @@ function runCallChecks(exitCode) {
   if (exitCode !== 0) return;
 
   const failed = mustCallChecks.filter(function(context) {
-    return context.actual !== context.expected;
+    if ('minimum' in context) {
+      context.messageSegment = `at least ${context.minimum}`;
+      return context.actual < context.minimum;
+    } else {
+      context.messageSegment = `exactly ${context.exact}`;
+      return context.actual !== context.exact;
+    }
   });
 
   failed.forEach(function(context) {
-    console.log('Mismatched %s function calls. Expected %d, actual %d.',
+    console.log('Mismatched %s function calls. Expected %s, actual %d.',
                 context.name,
-                context.expected,
+                context.messageSegment,
                 context.actual);
     console.log(context.stack.split('\n').slice(2).join('\n'));
   });
@@ -417,15 +426,29 @@ function runCallChecks(exitCode) {
   if (failed.length) process.exit(1);
 }
 
+exports.mustCall = function(fn, exact) {
+  return _mustCallInner(fn, exact, 'exact');
+};
+
+exports.mustCallAtLeast = function(fn, minimum) {
+  return _mustCallInner(fn, minimum, 'minimum');
+};
+
+function _mustCallInner(fn, criteria, field) {
+  if (typeof fn === 'number') {
+    criteria = fn;
+    fn = noop;
+  } else if (fn === undefined) {
+    fn = noop;
+  }
 
-exports.mustCall = function(fn, expected) {
-  if (expected === undefined)
-    expected = 1;
-  else if (typeof expected !== 'number')
-    throw new TypeError(`Invalid expected value: ${expected}`);
+  if (criteria === undefined)
+    criteria = 1;
+  else if (typeof criteria !== 'number')
+    throw new TypeError(`Invalid ${field} value: ${criteria}`);
 
   const context = {
-    expected: expected,
+    [field]: criteria,
     actual: 0,
     stack: (new Error()).stack,
     name: fn.name || '<anonymous>'
@@ -440,7 +463,7 @@ exports.mustCall = function(fn, expected) {
     context.actual++;
     return fn.apply(this, arguments);
   };
-};
+}
 
 exports.hasMultiLocalhost = function hasMultiLocalhost() {
   const TCP = process.binding('tcp_wrap').TCP;
@@ -487,9 +510,9 @@ util.inherits(ArrayStream, stream.Stream);
 exports.ArrayStream = ArrayStream;
 ArrayStream.prototype.readable = true;
 ArrayStream.prototype.writable = true;
-ArrayStream.prototype.pause = function() {};
-ArrayStream.prototype.resume = function() {};
-ArrayStream.prototype.write = function() {};
+ArrayStream.prototype.pause = noop;
+ArrayStream.prototype.resume = noop;
+ArrayStream.prototype.write = noop;
 
 // Returns true if the exit code "exitCode" and/or signal name "signal"
 // represent the exit code and/or signal name of a node process that aborted,
diff --git a/test/debugger/test-debugger-client.js b/test/debugger/test-debugger-client.js
index 660d8e286ee250..89b22bc2a054fc 100644
--- a/test/debugger/test-debugger-client.js
+++ b/test/debugger/test-debugger-client.js
@@ -129,7 +129,7 @@ addTest(function(client, done) {
 
 let connectCount = 0;
 const script = 'setTimeout(function() { console.log("blah"); });' +
-               'setInterval(function() {}, 1000000);';
+               'setInterval(common.noop, 1000000);';
 
 let nodeProcess;
 
@@ -172,7 +172,7 @@ function doTest(cb, done) {
         console.error('>>> connecting...');
         c.connect(debug.port);
         c.on('break', function() {
-          c.reqContinue(function() {});
+          c.reqContinue(common.noop);
         });
         c.on('ready', function() {
           connectCount++;
diff --git a/test/disabled/test-sendfd.js b/test/disabled/test-sendfd.js
index 9e3a01733f69a7..68d40993716093 100644
--- a/test/disabled/test-sendfd.js
+++ b/test/disabled/test-sendfd.js
@@ -29,12 +29,13 @@
 var common = require('../common');
 var assert = require('assert');
 
-var buffer = require('buffer');
-var child_process = require('child_process');
-var fs = require('fs');
-var net = require('net');
-var netBinding = process.binding('net');
-var path = require('path');
+const buffer = require('buffer');
+const child_process = require('child_process');
+const fs = require('fs');
+const net = require('net');
+
+const netBinding = process.binding('net');
+const path = require('path');
 
 var DATA = {
   'ppid' : process.pid,
@@ -73,7 +74,7 @@ pipeReadStream.on('data', function(data) {
     var rd = JSON.parse(d);
 
     assert.strictEqual(rd.pid, cpp);
-    assert.strictEqual(seenOrdinals.indexOf(rd.ord), -1);
+    assert.strictEqual(seenOrdinals.includes(rd.ord), false)
 
     seenOrdinals.unshift(rd.ord);
   });
@@ -91,7 +92,7 @@ var srv = net.createServer(function(s) {
   var str = JSON.stringify(DATA) + '\n';
 
   DATA.ord = DATA.ord + 1;
-  var buf = buffer.Buffer.allocUnsafe(str.length);
+  var buf = Buffer.allocUnsafe(str.length);
   buf.write(JSON.stringify(DATA) + '\n', 'utf8');
 
   s.write(str, 'utf8', pipeFDs[1]);
diff --git a/test/doctool/test-doctool-html.js b/test/doctool/test-doctool-html.js
index b28d34b57e6edc..35fa921a3e9971 100644
--- a/test/doctool/test-doctool-html.js
+++ b/test/doctool/test-doctool-html.js
@@ -106,15 +106,15 @@ testData.forEach((item) => {
           const actual = output.replace(spaces, '');
           // Assert that the input stripped of all whitespace contains the
           // expected list
-          assert.notStrictEqual(actual.indexOf(expected), -1);
+          assert(actual.includes(expected));
 
           // Testing the insertion of Google Analytics script when
           // an analytics id is provided. Should not be present by default
           if (includeAnalytics) {
-            assert.notStrictEqual(actual.indexOf('google-analytics.com'), -1,
-                                  'Google Analytics script was not present');
+            assert(actual.includes('google-analytics.com'),
+                   'Google Analytics script was not present');
           } else {
-            assert.strictEqual(actual.indexOf('google-analytics.com'), -1,
+            assert.strictEqual(actual.includes('google-analytics.com'), false,
                                'Google Analytics script was present');
           }
         }));
diff --git a/test/fixtures/child-process-persistent.js b/test/fixtures/child-process-persistent.js
index 45a50f5a263ad6..c5b1f26d84f8b9 100644
--- a/test/fixtures/child-process-persistent.js
+++ b/test/fixtures/child-process-persistent.js
@@ -1 +1 @@
-setInterval(function() {}, 500);
+setInterval(common.noop, 500);
diff --git a/test/fixtures/failmustcall1.js b/test/fixtures/failmustcall1.js
new file mode 100644
index 00000000000000..a54740eb296267
--- /dev/null
+++ b/test/fixtures/failmustcall1.js
@@ -0,0 +1,3 @@
+const common = require('../common');
+const f = common.mustCall( () => {}, 2);
+f();
diff --git a/test/fixtures/failmustcall2.js b/test/fixtures/failmustcall2.js
new file mode 100644
index 00000000000000..89f8d23922e78a
--- /dev/null
+++ b/test/fixtures/failmustcall2.js
@@ -0,0 +1,3 @@
+const common = require('../common');
+const f = common.mustCallAtLeast(() => {}, 2);
+f();
diff --git a/test/internet/test-dgram-broadcast-multi-process.js b/test/internet/test-dgram-broadcast-multi-process.js
index c05d0cf5b9512e..392ded3a710c29 100644
--- a/test/internet/test-dgram-broadcast-multi-process.js
+++ b/test/internet/test-dgram-broadcast-multi-process.js
@@ -4,7 +4,6 @@ const assert = require('assert');
 const dgram = require('dgram');
 const util = require('util');
 const networkInterfaces = require('os').networkInterfaces();
-const Buffer = require('buffer').Buffer;
 const fork = require('child_process').fork;
 const LOCAL_BROADCAST_HOST = '255.255.255.255';
 const TIMEOUT = common.platformTimeout(5000);
diff --git a/test/internet/test-dns.js b/test/internet/test-dns.js
index ba40146c58342b..68365e59c107c3 100644
--- a/test/internet/test-dns.js
+++ b/test/internet/test-dns.js
@@ -360,7 +360,7 @@ TEST(function test_resolveTxt(done) {
     if (err) throw err;
     assert.strictEqual(records.length, 1);
     assert.ok(util.isArray(records[0]));
-    assert.strictEqual(records[0][0].indexOf('v=spf1'), 0);
+    assert(records[0][0].startsWith('v=spf1'));
     done();
   });
 
diff --git a/test/internet/test-tls-add-ca-cert.js b/test/internet/test-tls-add-ca-cert.js
index 440d4b9a1afb1b..f57f1617ef83d9 100644
--- a/test/internet/test-tls-add-ca-cert.js
+++ b/test/internet/test-tls-add-ca-cert.js
@@ -10,10 +10,11 @@ if (!common.hasCrypto) {
 
 const assert = require('assert');
 const fs = require('fs');
+const path = require('path');
 const tls = require('tls');
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 function loadPEM(n) {
diff --git a/test/known_issues/test-dgram-bind-shared-ports-after-port-0.js b/test/known_issues/test-dgram-bind-shared-ports-after-port-0.js
new file mode 100644
index 00000000000000..7b750c765ba226
--- /dev/null
+++ b/test/known_issues/test-dgram-bind-shared-ports-after-port-0.js
@@ -0,0 +1,56 @@
+'use strict';
+const common = require('../common');
+
+// This test should fail because at present `cluster` does not know how to share
+// a socket when `worker1` binds with `port: 0`, and others try to bind to the
+// assigned port number from `worker1`
+//
+// *Note*: since this is a `known_issue` we try to swallow all errors except
+// the one we are interested in
+
+const assert = require('assert');
+const cluster = require('cluster');
+const dgram = require('dgram');
+const BYE = 'bye';
+
+if (cluster.isMaster) {
+  const worker1 = cluster.fork();
+
+  // verify that Windows doesn't support this scenario
+  worker1.on('error', (err) => {
+    if (err.code === 'ENOTSUP') throw err;
+  });
+
+  worker1.on('message', (msg) => {
+    if (typeof msg !== 'object') process.exit(0);
+    if (msg.message !== 'success') process.exit(0);
+    if (typeof msg.port1 !== 'number') process.exit(0);
+
+    const worker2 = cluster.fork({ PRT1: msg.port1 });
+    worker2.on('message', () => process.exit(0));
+    worker2.on('exit', (code, signal) => {
+      // this is the droid we are looking for
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
+
+    // cleanup anyway
+    process.on('exit', () => {
+      worker1.send(BYE);
+      worker2.send(BYE);
+    });
+  });
+  // end master code
+} else {
+  // worker code
+  process.on('message', (msg) => msg === BYE && process.exit(0));
+
+  // first worker will bind to '0', second will try the assigned port and fail
+  const PRT1 = process.env.PRT1 || 0;
+  const socket1 = dgram.createSocket('udp4', () => {});
+  socket1.on('error', PRT1 === 0 ? () => {} : assert.fail);
+  socket1.bind(
+    { address: common.localhostIPv4, port: PRT1, exclusive: false },
+    () => process.send({ message: 'success', port1: socket1.address().port })
+  );
+}
diff --git a/test/parallel/parallel.status b/test/parallel/parallel.status
index 97e7803f4d40a5..b2eccf8eb69c75 100644
--- a/test/parallel/parallel.status
+++ b/test/parallel/parallel.status
@@ -5,6 +5,7 @@ prefix parallel
 # sample-test                        : PASS,FLAKY
 
 [true] # This section applies to all platforms
+test-fs-read-buffer-tostring-fail      : PASS,FLAKY
 
 [$system==win32]
 
diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js
index 3a81c6f810425a..ac55f6f5113857 100644
--- a/test/parallel/test-assert.js
+++ b/test/parallel/test-assert.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const a = require('assert');
 
@@ -515,6 +515,7 @@ testAssertionMessage(/a/, '/a/');
 testAssertionMessage(/abc/gim, '/abc/gim');
 testAssertionMessage(function f() {}, '[Function: f]');
 testAssertionMessage(function() {}, '[Function]');
+testAssertionMessage(common.noop, '[Function: noop]');
 testAssertionMessage({}, '{}');
 testAssertionMessage(circular, '{ y: 1, x: [Circular] }');
 testAssertionMessage({a: undefined, b: null}, '{ a: undefined, b: null }');
diff --git a/test/parallel/test-buffer-alloc.js b/test/parallel/test-buffer-alloc.js
index 7ebe34b21edb1e..39ce4c4a928109 100644
--- a/test/parallel/test-buffer-alloc.js
+++ b/test/parallel/test-buffer-alloc.js
@@ -3,7 +3,6 @@ const common = require('../common');
 const assert = require('assert');
 const vm = require('vm');
 
-const Buffer = require('buffer').Buffer;
 const SlowBuffer = require('buffer').SlowBuffer;
 
 const b = Buffer.allocUnsafe(1024);
diff --git a/test/parallel/test-buffer-arraybuffer.js b/test/parallel/test-buffer-arraybuffer.js
index 8f32a2de3c8971..d1e6eaa07033c4 100644
--- a/test/parallel/test-buffer-arraybuffer.js
+++ b/test/parallel/test-buffer-arraybuffer.js
@@ -3,7 +3,6 @@
 require('../common');
 const assert = require('assert');
 
-const Buffer = require('buffer').Buffer;
 const LENGTH = 16;
 
 const ab = new ArrayBuffer(LENGTH);
diff --git a/test/parallel/test-buffer-badhex.js b/test/parallel/test-buffer-badhex.js
index c3d151ba18c694..94de97181d38e0 100644
--- a/test/parallel/test-buffer-badhex.js
+++ b/test/parallel/test-buffer-badhex.js
@@ -1,7 +1,6 @@
 'use strict';
 require('../common');
 const assert = require('assert');
-const Buffer = require('buffer').Buffer;
 
 // Test hex strings and bad hex strings
 {
diff --git a/test/parallel/test-buffer-bytelength.js b/test/parallel/test-buffer-bytelength.js
index 9bb3b759e0208f..17fe2931aa8585 100644
--- a/test/parallel/test-buffer-bytelength.js
+++ b/test/parallel/test-buffer-bytelength.js
@@ -2,7 +2,6 @@
 
 require('../common');
 const assert = require('assert');
-const Buffer = require('buffer').Buffer;
 const SlowBuffer = require('buffer').SlowBuffer;
 const vm = require('vm');
 
diff --git a/test/parallel/test-buffer-fakes.js b/test/parallel/test-buffer-fakes.js
index 758ebbf0053732..d126d39aa95263 100644
--- a/test/parallel/test-buffer-fakes.js
+++ b/test/parallel/test-buffer-fakes.js
@@ -2,7 +2,6 @@
 
 require('../common');
 const assert = require('assert');
-const Buffer = require('buffer').Buffer;
 
 function FakeBuffer() { }
 Object.setPrototypeOf(FakeBuffer, Buffer);
diff --git a/test/parallel/test-buffer-includes.js b/test/parallel/test-buffer-includes.js
index 112cf546502372..142602ab46cb9f 100644
--- a/test/parallel/test-buffer-includes.js
+++ b/test/parallel/test-buffer-includes.js
@@ -2,8 +2,6 @@
 require('../common');
 const assert = require('assert');
 
-const Buffer = require('buffer').Buffer;
-
 const b = Buffer.from('abcdef');
 const buf_a = Buffer.from('a');
 const buf_bc = Buffer.from('bc');
diff --git a/test/parallel/test-buffer-indexof.js b/test/parallel/test-buffer-indexof.js
index e389b09e384500..7aab6e609e56d7 100644
--- a/test/parallel/test-buffer-indexof.js
+++ b/test/parallel/test-buffer-indexof.js
@@ -2,8 +2,6 @@
 require('../common');
 const assert = require('assert');
 
-const Buffer = require('buffer').Buffer;
-
 const b = Buffer.from('abcdef');
 const buf_a = Buffer.from('a');
 const buf_bc = Buffer.from('bc');
diff --git a/test/parallel/test-buffer-new.js b/test/parallel/test-buffer-new.js
index 919f31238d2d18..95dd922a271a1a 100644
--- a/test/parallel/test-buffer-new.js
+++ b/test/parallel/test-buffer-new.js
@@ -2,6 +2,5 @@
 
 require('../common');
 const assert = require('assert');
-const Buffer = require('buffer').Buffer;
 
 assert.throws(() => new Buffer(42, 'utf8'), /first argument must be a string/);
diff --git a/test/parallel/test-buffer-sharedarraybuffer.js b/test/parallel/test-buffer-sharedarraybuffer.js
index f1bac72079b313..582841d679c8d1 100644
--- a/test/parallel/test-buffer-sharedarraybuffer.js
+++ b/test/parallel/test-buffer-sharedarraybuffer.js
@@ -4,7 +4,6 @@
 
 require('../common');
 const assert = require('assert');
-const Buffer = require('buffer').Buffer;
 
 const sab = new SharedArrayBuffer(24);
 const arr1 = new Uint16Array(sab);
diff --git a/test/parallel/test-buffer-slow.js b/test/parallel/test-buffer-slow.js
index 69981d4dc38b73..7d37c709e380f0 100644
--- a/test/parallel/test-buffer-slow.js
+++ b/test/parallel/test-buffer-slow.js
@@ -3,7 +3,6 @@
 require('../common');
 const assert = require('assert');
 const buffer = require('buffer');
-const Buffer = buffer.Buffer;
 const SlowBuffer = buffer.SlowBuffer;
 
 const ones = [1, 1, 1, 1];
diff --git a/test/parallel/test-child-process-disconnect.js b/test/parallel/test-child-process-disconnect.js
index ee9488d1cd0b05..d4fa99557cec11 100644
--- a/test/parallel/test-child-process-disconnect.js
+++ b/test/parallel/test-child-process-disconnect.js
@@ -57,7 +57,7 @@ if (process.argv[2] === 'child') {
   }));
 
   // the process should also self terminate without using signals
-  child.on('exit', common.mustCall(function() {}));
+  child.on('exit', common.mustCall());
 
   // when child is listening
   child.on('message', function(obj) {
diff --git a/test/parallel/test-child-process-exec-cwd.js b/test/parallel/test-child-process-exec-cwd.js
index 95feb42314fc8d..d8d64776551278 100644
--- a/test/parallel/test-child-process-exec-cwd.js
+++ b/test/parallel/test-child-process-exec-cwd.js
@@ -15,5 +15,5 @@ if (common.isWindows) {
 
 exec(pwdcommand, {cwd: dir}, common.mustCall(function(err, stdout, stderr) {
   assert.ifError(err);
-  assert.strictEqual(stdout.indexOf(dir), 0);
+  assert(stdout.startsWith(dir));
 }));
diff --git a/test/parallel/test-child-process-fork-ref2.js b/test/parallel/test-child-process-fork-ref2.js
index 9f59aa344aa2c9..cf50a17ad00c64 100644
--- a/test/parallel/test-child-process-fork-ref2.js
+++ b/test/parallel/test-child-process-fork-ref2.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const fork = require('child_process').fork;
 
 if (process.argv[2] === 'child') {
@@ -8,7 +8,7 @@ if (process.argv[2] === 'child') {
 
   setTimeout(function() {
     console.log('child -> will this keep it alive?');
-    process.on('message', function() { });
+    process.on('message', common.mustNotCall());
   }, 400);
 
 } else {
diff --git a/test/parallel/test-child-process-kill.js b/test/parallel/test-child-process-kill.js
index e0e951610dc146..02bd739f0beb27 100644
--- a/test/parallel/test-child-process-kill.js
+++ b/test/parallel/test-child-process-kill.js
@@ -4,9 +4,9 @@ const assert = require('assert');
 const spawn = require('child_process').spawn;
 const cat = spawn(common.isWindows ? 'cmd' : 'cat');
 
-cat.stdout.on('end', common.mustCall(function() {}));
+cat.stdout.on('end', common.mustCall());
 cat.stderr.on('data', common.mustNotCall());
-cat.stderr.on('end', common.mustCall(function() {}));
+cat.stderr.on('end', common.mustCall());
 
 cat.on('exit', common.mustCall(function(code, signal) {
   assert.strictEqual(code, null);
diff --git a/test/parallel/test-child-process-send-type-error.js b/test/parallel/test-child-process-send-type-error.js
index b92d1ee90bffaf..0cff911dc98e49 100644
--- a/test/parallel/test-child-process-send-type-error.js
+++ b/test/parallel/test-child-process-send-type-error.js
@@ -1,10 +1,9 @@
 'use strict';
-require('../common');
+const common = require('../common');
+
 const assert = require('assert');
 const cp = require('child_process');
 
-function noop() {}
-
 function fail(proc, args) {
   assert.throws(() => {
     proc.send.apply(proc, args);
@@ -13,8 +12,13 @@ function fail(proc, args) {
 
 let target = process;
 
-if (process.argv[2] !== 'child')
+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);
+  }));
+}
 
 fail(target, ['msg', null, null]);
 fail(target, ['msg', null, '']);
@@ -22,4 +26,4 @@ fail(target, ['msg', null, 'foo']);
 fail(target, ['msg', null, 0]);
 fail(target, ['msg', null, NaN]);
 fail(target, ['msg', null, 1]);
-fail(target, ['msg', null, null, noop]);
+fail(target, ['msg', null, null, common.mustNotCall()]);
diff --git a/test/parallel/test-child-process-stdin.js b/test/parallel/test-child-process-stdin.js
index 3da722ec71de2d..d811bc46b540e7 100644
--- a/test/parallel/test-child-process-stdin.js
+++ b/test/parallel/test-child-process-stdin.js
@@ -22,11 +22,11 @@ cat.stdout.on('data', function(chunk) {
   response += chunk;
 });
 
-cat.stdout.on('end', common.mustCall(function() {}));
+cat.stdout.on('end', common.mustCall());
 
 cat.stderr.on('data', common.mustNotCall());
 
-cat.stderr.on('end', common.mustCall(function() {}));
+cat.stderr.on('end', common.mustCall());
 
 cat.on('exit', common.mustCall(function(status) {
   assert.strictEqual(0, status);
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 5e32314cc87a33..71333bdbd534ab 100644
--- a/test/parallel/test-child-process-stdio-big-write-end.js
+++ b/test/parallel/test-child-process-stdio-big-write-end.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 let bufsize = 0;
 
@@ -22,10 +22,10 @@ function parent() {
   child.stdout.on('data', function(c) {
     n += c;
   });
-  child.stdout.on('end', function() {
+  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-cluster-basic.js b/test/parallel/test-cluster-basic.js
index fa3c051ae17290..6d1b93f0ef375a 100644
--- a/test/parallel/test-cluster-basic.js
+++ b/test/parallel/test-cluster-basic.js
@@ -1,5 +1,6 @@
 'use strict';
 const common = require('../common');
+
 const assert = require('assert');
 const cluster = require('cluster');
 
@@ -14,7 +15,7 @@ function forEach(obj, fn) {
 
 
 if (cluster.isWorker) {
-  require('http').Server(common.noop).listen(0, '127.0.0.1');
+  require('http').Server(common.mustNotCall()).listen(0, '127.0.0.1');
 } else if (cluster.isMaster) {
 
   const checks = {
diff --git a/test/parallel/test-cluster-eaccess.js b/test/parallel/test-cluster-eaccess.js
index 3682bac69064df..66ea101556db18 100644
--- a/test/parallel/test-cluster-eaccess.js
+++ b/test/parallel/test-cluster-eaccess.js
@@ -14,10 +14,10 @@ if (cluster.isMaster) {
   const worker = cluster.fork();
 
   // makes sure master is able to fork the worker
-  cluster.on('fork', common.mustCall(function() {}));
+  cluster.on('fork', common.mustCall());
 
   // makes sure the worker is ready
-  worker.on('online', common.mustCall(function() {}));
+  worker.on('online', common.mustCall());
 
   worker.on('message', common.mustCall(function(err) {
     // disconnect first, so that we will not leave zombies
diff --git a/test/parallel/test-cluster-setup-master-emit.js b/test/parallel/test-cluster-setup-master-emit.js
index 5b828e7b8e360f..a93441c116dff4 100644
--- a/test/parallel/test-cluster-setup-master-emit.js
+++ b/test/parallel/test-cluster-setup-master-emit.js
@@ -22,5 +22,5 @@ function emitAndCatch2(next) {
 }
 
 emitAndCatch(common.mustCall(function() {
-  emitAndCatch2(common.mustCall(function() {}));
+  emitAndCatch2(common.mustCall());
 }));
diff --git a/test/parallel/test-cluster-worker-destroy.js b/test/parallel/test-cluster-worker-destroy.js
index 62000254247a1f..4c03d4d440322d 100644
--- a/test/parallel/test-cluster-worker-destroy.js
+++ b/test/parallel/test-cluster-worker-destroy.js
@@ -17,8 +17,8 @@ if (cluster.isMaster) {
   worker2 = cluster.fork();
 
   [worker1, worker2].forEach(function(worker) {
-    worker.on('disconnect', common.mustCall(function() {}));
-    worker.on('exit', common.mustCall(function() {}));
+    worker.on('disconnect', common.mustCall());
+    worker.on('exit', common.mustCall());
   });
 } else {
   if (cluster.worker.id === 1) {
diff --git a/test/parallel/test-cluster-worker-wait-server-close.js b/test/parallel/test-cluster-worker-wait-server-close.js
index 1d19398a3d8799..f91003e9a5c33e 100644
--- a/test/parallel/test-cluster-worker-wait-server-close.js
+++ b/test/parallel/test-cluster-worker-wait-server-close.js
@@ -20,7 +20,7 @@ if (cluster.isWorker) {
 
   // Although not typical, the worker process can exit before the disconnect
   // event fires. Use this to keep the process open until the event has fired.
-  const keepOpen = setInterval(function() {}, 9999);
+  const keepOpen = setInterval(common.noop, 9999);
 
   // Check worker events and properties
   process.once('disconnect', function() {
diff --git a/test/parallel/test-common.js b/test/parallel/test-common.js
index 17f41840e4ffa5..f955585143593c 100644
--- a/test/parallel/test-common.js
+++ b/test/parallel/test-common.js
@@ -2,14 +2,54 @@
 const common = require('../common');
 const assert = require('assert');
 
+const {join} = require('path');
+const {execFile} = require('child_process');
+
 common.globalCheck = false;
 global.gc = 42;  // Not a valid global unless --expose_gc is set.
 assert.deepStrictEqual(common.leakedGlobals(), ['gc']);
 
 assert.throws(function() {
-  common.mustCall(function() {}, 'foo');
-}, /^TypeError: Invalid expected value: foo$/);
+  common.mustCall(common.noop, 'foo');
+}, /^TypeError: Invalid exact value: foo$/);
 
 assert.throws(function() {
-  common.mustCall(function() {}, /foo/);
-}, /^TypeError: Invalid expected value: \/foo\/$/);
+  common.mustCall(common.noop, /foo/);
+}, /^TypeError: Invalid exact value: \/foo\/$/);
+
+const fnOnce = common.mustCall(() => {});
+fnOnce();
+const fnTwice = common.mustCall(() => {}, 2);
+fnTwice();
+fnTwice();
+const fnAtLeast1Called1 = common.mustCallAtLeast(() => {}, 1);
+fnAtLeast1Called1();
+const fnAtLeast1Called2 = common.mustCallAtLeast(() => {}, 1);
+fnAtLeast1Called2();
+fnAtLeast1Called2();
+const fnAtLeast2Called2 = common.mustCallAtLeast(() => {}, 2);
+fnAtLeast2Called2();
+fnAtLeast2Called2();
+const fnAtLeast2Called3 = common.mustCallAtLeast(() => {}, 2);
+fnAtLeast2Called3();
+fnAtLeast2Called3();
+fnAtLeast2Called3();
+
+const failFixtures = [
+  [
+    join(common.fixturesDir, 'failmustcall1.js'),
+    'Mismatched <anonymous> function calls. Expected exactly 2, actual 1.'
+  ], [
+    join(common.fixturesDir, 'failmustcall2.js'),
+    'Mismatched <anonymous> function calls. Expected at least 2, actual 1.'
+  ]
+];
+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);
+  }));
+}
diff --git a/test/parallel/test-console.js b/test/parallel/test-console.js
index 4618bbd28cf091..7d298674273ecf 100644
--- a/test/parallel/test-console.js
+++ b/test/parallel/test-console.js
@@ -115,8 +115,8 @@ assert.strictEqual("{ foo: 'bar', inspect: [Function: inspect] }\n",
                    strings.shift());
 assert.strictEqual("{ foo: 'bar', inspect: [Function: inspect] }\n",
                    strings.shift());
-assert.notStrictEqual(-1, strings.shift().indexOf('foo: [Object]'));
-assert.strictEqual(-1, strings.shift().indexOf('baz'));
+assert.ok(strings.shift().includes('foo: [Object]'));
+assert.strictEqual(strings.shift().includes('baz'), false);
 assert.ok(/^label: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.ok(/^__proto__: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.ok(/^constructor: \d+\.\d{3}ms$/.test(strings.shift().trim()));
diff --git a/test/parallel/test-crypto-fips.js b/test/parallel/test-crypto-fips.js
index b5d89593b923d2..6dffbe3e1352b3 100644
--- a/test/parallel/test-crypto-fips.js
+++ b/test/parallel/test-crypto-fips.js
@@ -21,6 +21,10 @@ function compiledWithFips() {
   return process.config.variables.openssl_fips ? true : false;
 }
 
+function sharedOpenSSL() {
+  return process.config.variables.node_shared_openssl;
+}
+
 function addToEnv(newVar, value) {
   const envCopy = {};
   for (const e in process.env) {
@@ -85,29 +89,43 @@ testHelper(
   'require("crypto").fips',
   process.env);
 
-// OpenSSL config file should be able to turn on FIPS mode
-testHelper(
-  'stdout',
-  [`--openssl-config=${CNF_FIPS_ON}`],
-  compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
-  'require("crypto").fips',
-  process.env);
-
-// OPENSSL_CONF should be able to turn on FIPS mode
-testHelper(
-  'stdout',
-  [],
-  compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
-  'require("crypto").fips',
-  addToEnv('OPENSSL_CONF', CNF_FIPS_ON));
-
-// --openssl-config option should override OPENSSL_CONF
-testHelper(
-  'stdout',
-  [`--openssl-config=${CNF_FIPS_ON}`],
-  compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
-  'require("crypto").fips',
-  addToEnv('OPENSSL_CONF', CNF_FIPS_OFF));
+// If Node was configured using --shared-openssl fips support might be
+// available depending on how OpenSSL was built. If fips support is
+// available the tests that toggle the fips_mode on/off using the config
+// file option will succeed and return 1 instead of 0.
+//
+// Note that this case is different from when calling the fips setter as the
+// configuration file is handled by OpenSSL, so it is not possible for us
+// to try to call the fips setter, to try to detect this situation, as
+// that would throw an error:
+// ("Error: Cannot set FIPS mode in a non-FIPS build.").
+// Due to this uncertanty the following tests are skipped when configured
+// with --shared-openssl.
+if (!sharedOpenSSL()) {
+  // OpenSSL config file should be able to turn on FIPS mode
+  testHelper(
+    'stdout',
+    [`--openssl-config=${CNF_FIPS_ON}`],
+    compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
+    'require("crypto").fips',
+    process.env);
+
+  // OPENSSL_CONF should be able to turn on FIPS mode
+  testHelper(
+    'stdout',
+    [],
+    compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
+    'require("crypto").fips',
+    addToEnv('OPENSSL_CONF', CNF_FIPS_ON));
+
+  // --openssl-config option should override OPENSSL_CONF
+  testHelper(
+    'stdout',
+    [`--openssl-config=${CNF_FIPS_ON}`],
+    compiledWithFips() ? FIPS_ENABLED : FIPS_DISABLED,
+    'require("crypto").fips',
+    addToEnv('OPENSSL_CONF', CNF_FIPS_OFF));
+}
 
 testHelper(
   'stdout',
diff --git a/test/parallel/test-crypto-random.js b/test/parallel/test-crypto-random.js
index 28b8847e56478c..29928ad6e18a82 100644
--- a/test/parallel/test-crypto-random.js
+++ b/test/parallel/test-crypto-random.js
@@ -17,7 +17,7 @@ const expectedErrorRegexp = /^TypeError: size must be a number >= 0$/;
 [crypto.randomBytes, crypto.pseudoRandomBytes].forEach(function(f) {
   [-1, undefined, null, false, true, {}, []].forEach(function(value) {
     assert.throws(function() { f(value); }, expectedErrorRegexp);
-    assert.throws(function() { f(value, function() {}); }, expectedErrorRegexp);
+    assert.throws(function() { f(value, common.noop); }, expectedErrorRegexp);
   });
 
   [0, 1, 2, 4, 16, 256, 1024].forEach(function(len) {
diff --git a/test/parallel/test-dgram-close-is-not-callback.js b/test/parallel/test-dgram-close-is-not-callback.js
index 416c5b305e1c49..70700a16c6a798 100644
--- a/test/parallel/test-dgram-close-is-not-callback.js
+++ b/test/parallel/test-dgram-close-is-not-callback.js
@@ -17,5 +17,5 @@ const portGetter = dgram.createSocket('udp4')
     socket.close('bad argument');
     portGetter.close();
 
-    socket.on('close', common.mustCall(function() {}));
+    socket.on('close', common.mustCall());
   }));
diff --git a/test/parallel/test-dgram-close.js b/test/parallel/test-dgram-close.js
index 482cf529e6720f..f4845da479286a 100644
--- a/test/parallel/test-dgram-close.js
+++ b/test/parallel/test-dgram-close.js
@@ -18,8 +18,8 @@ const portGetter = dgram.createSocket('udp4')
                 portGetter.address().port,
                 portGetter.address().address);
 
-    assert.strictEqual(socket.close(common.mustCall(function() {})), socket);
-    socket.on('close', common.mustCall(function() {}));
+    assert.strictEqual(socket.close(common.mustCall()), socket);
+    socket.on('close', common.mustCall());
     socket = null;
 
     // Verify that accessing handle after closure doesn't throw
diff --git a/test/parallel/test-dgram-error-message-address.js b/test/parallel/test-dgram-error-message-address.js
index 211adcffcc67b5..84b21d0f851347 100644
--- a/test/parallel/test-dgram-error-message-address.js
+++ b/test/parallel/test-dgram-error-message-address.js
@@ -26,7 +26,7 @@ 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.notStrictEqual(allowed.indexOf(e.code), -1);
+  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');
diff --git a/test/parallel/test-dgram-oob-buffer.js b/test/parallel/test-dgram-oob-buffer.js
index b49baa2e0d8dad..f93533479b2d93 100644
--- a/test/parallel/test-dgram-oob-buffer.js
+++ b/test/parallel/test-dgram-oob-buffer.js
@@ -10,15 +10,14 @@ const socket = dgram.createSocket('udp4');
 const buf = Buffer.from([1, 2, 3, 4]);
 const portGetter = dgram.createSocket('udp4')
   .bind(0, 'localhost', common.mustCall(() => {
-    const address = portGetter.address();
+    const { address, port } = portGetter.address();
     portGetter.close(common.mustCall(() => {
-      function ok() {}
-      socket.send(buf, 0, 0, address.port, address.address, ok);
-      socket.send(buf, 0, 4, address.port, address.address, ok);
-      socket.send(buf, 1, 3, address.port, address.address, ok);
-      socket.send(buf, 3, 1, address.port, address.address, ok);
+      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, address.port, address.address, ok);
+      socket.send(buf, 4, 0, port, address, common.mustNotCall());
 
       socket.close();
     }));
diff --git a/test/parallel/test-dgram-send-empty-buffer.js b/test/parallel/test-dgram-send-empty-buffer.js
index 56a0383eb14c9e..0486b2bdbe3959 100644
--- a/test/parallel/test-dgram-send-empty-buffer.js
+++ b/test/parallel/test-dgram-send-empty-buffer.js
@@ -22,6 +22,6 @@ client.bind(0, common.mustCall(function() {
 
   const buf = Buffer.alloc(0);
   let interval = setInterval(function() {
-    client.send(buf, 0, 0, port, '127.0.0.1', common.mustCall(function() {}));
+    client.send(buf, 0, 0, port, '127.0.0.1', common.mustCall());
   }, 10);
 }));
diff --git a/test/parallel/test-dns-lookup.js b/test/parallel/test-dns-lookup.js
index a720c46e02a630..a1fad873e33f37 100644
--- a/test/parallel/test-dns-lookup.js
+++ b/test/parallel/test-dns-lookup.js
@@ -24,7 +24,7 @@ assert.throws(() => {
     hints: 100,
     family: 0,
     all: false
-  }, () => {});
+  }, common.mustNotCall());
 }, /^TypeError: Invalid argument: hints must use valid flags$/);
 
 assert.throws(() => {
@@ -32,7 +32,7 @@ assert.throws(() => {
     hints: 0,
     family: 20,
     all: false
-  }, () => {});
+  }, common.mustNotCall());
 }, /^TypeError: Invalid argument: family must be 4 or 6$/);
 
 assert.doesNotThrow(() => {
diff --git a/test/parallel/test-domain-crypto.js b/test/parallel/test-domain-crypto.js
index dfa2636816aff4..7f009b45df5639 100644
--- a/test/parallel/test-domain-crypto.js
+++ b/test/parallel/test-domain-crypto.js
@@ -17,7 +17,7 @@ global.domain = require('domain');
 
 // should not throw a 'TypeError: undefined is not a function' exception
 crypto.randomBytes(8);
-crypto.randomBytes(8, function() {});
+crypto.randomBytes(8, common.mustCall());
 crypto.pseudoRandomBytes(8);
-crypto.pseudoRandomBytes(8, function() {});
-crypto.pbkdf2('password', 'salt', 8, 8, function() {});
+crypto.pseudoRandomBytes(8, common.mustCall());
+crypto.pbkdf2('password', 'salt', 8, 8, 'sha1', common.mustCall());
diff --git a/test/parallel/test-domain-exit-dispose.js b/test/parallel/test-domain-exit-dispose.js
index e1797cb660a0c0..a9c69ac3396712 100644
--- a/test/parallel/test-domain-exit-dispose.js
+++ b/test/parallel/test-domain-exit-dispose.js
@@ -22,7 +22,7 @@ function err() {
   function err2() {
     // this timeout should never be called, since the domain gets
     // disposed when the error happens.
-    setTimeout(common.mustCall(() => {}, 0), 1);
+    setTimeout(common.mustNotCall(), 1);
 
     // this function doesn't exist, and throws an error as a result.
     err3(); // eslint-disable-line no-undef
diff --git a/test/parallel/test-domain-timers.js b/test/parallel/test-domain-timers.js
index 7d51b61fd04be6..bb130ae0808589 100644
--- a/test/parallel/test-domain-timers.js
+++ b/test/parallel/test-domain-timers.js
@@ -3,8 +3,6 @@ const common = require('../common');
 const domain = require('domain');
 const assert = require('assert');
 
-let timeout;
-
 const timeoutd = domain.create();
 
 timeoutd.on('error', common.mustCall(function(e) {
@@ -32,4 +30,4 @@ immediated.run(function() {
   });
 });
 
-timeout = setTimeout(function() {}, 10 * 1000);
+const timeout = setTimeout(common.mustNotCall(), 10 * 1000);
diff --git a/test/parallel/test-domain-top-level-error-handler-throw.js b/test/parallel/test-domain-top-level-error-handler-throw.js
index 53a73eac426232..86df8db5b7423f 100644
--- a/test/parallel/test-domain-top-level-error-handler-throw.js
+++ b/test/parallel/test-domain-top-level-error-handler-throw.js
@@ -37,11 +37,8 @@ if (process.argv[2] === 'child') {
     });
 
     child.on('close', function onChildClosed() {
-      assert.notStrictEqual(
-        stderrOutput.indexOf(domainErrHandlerExMessage),
-        -1
-      );
-      assert.strictEqual(stderrOutput.indexOf(internalExMessage), -1);
+      assert(stderrOutput.includes(domainErrHandlerExMessage));
+      assert.strictEqual(stderrOutput.includes(internalExMessage), false);
     });
 
     child.on('exit', function onChildExited(exitCode, signal) {
diff --git a/test/parallel/test-domain-uncaught-exception.js b/test/parallel/test-domain-uncaught-exception.js
index 594cee542f80fb..bb6dd33e37b73a 100644
--- a/test/parallel/test-domain-uncaught-exception.js
+++ b/test/parallel/test-domain-uncaught-exception.js
@@ -190,7 +190,7 @@ if (process.argv[2] === 'child') {
 
       if (test.messagesReceived) {
         test.messagesReceived.forEach(function(receivedMessage) {
-          if (test.expectedMessages.indexOf(receivedMessage) === -1) {
+          if (!test.expectedMessages.includes(receivedMessage)) {
             assert(false, `test ${test.fn.name} should not have sent message: ${
                           receivedMessage} but did`);
           }
diff --git a/test/parallel/test-domain.js b/test/parallel/test-domain.js
index ab286429f5c5d5..0233eb88eb268b 100644
--- a/test/parallel/test-domain.js
+++ b/test/parallel/test-domain.js
@@ -238,7 +238,7 @@ let fst = fs.createReadStream('stream for nonexistent file');
 d.add(fst);
 expectCaught++;
 
-[42, null, , false, function() {}, 'string'].forEach(function(something) {
+[42, null, undefined, false, () => {}, 'string'].forEach(function(something) {
   const d = new domain.Domain();
   d.run(function() {
     process.nextTick(function() {
diff --git a/test/parallel/test-env-var-no-warnings.js b/test/parallel/test-env-var-no-warnings.js
index 1df31d8920753d..37774f2a161a52 100644
--- a/test/parallel/test-env-var-no-warnings.js
+++ b/test/parallel/test-env-var-no-warnings.js
@@ -29,7 +29,7 @@ if (process.argv[2] === 'child') {
   test({ NODE_NO_WARNINGS: false });
   test({ NODE_NO_WARNINGS: {} });
   test({ NODE_NO_WARNINGS: [] });
-  test({ NODE_NO_WARNINGS: function() {} });
+  test({ NODE_NO_WARNINGS: common.noop });
   test({ NODE_NO_WARNINGS: 0 });
   test({ NODE_NO_WARNINGS: -1 });
   test({ NODE_NO_WARNINGS: '0' });
diff --git a/test/parallel/test-event-emitter-check-listener-leaks.js b/test/parallel/test-event-emitter-check-listener-leaks.js
index 5b9787f1b83bba..0f5f3757c64932 100644
--- a/test/parallel/test-event-emitter-check-listener-leaks.js
+++ b/test/parallel/test-event-emitter-check-listener-leaks.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const events = require('events');
 
@@ -7,40 +7,40 @@ let e = new events.EventEmitter();
 
 // default
 for (let i = 0; i < 10; i++) {
-  e.on('default', function() {});
+  e.on('default', common.noop);
 }
 assert.ok(!e._events['default'].hasOwnProperty('warned'));
-e.on('default', function() {});
+e.on('default', common.noop);
 assert.ok(e._events['default'].warned);
 
 // symbol
 const symbol = Symbol('symbol');
 e.setMaxListeners(1);
-e.on(symbol, function() {});
+e.on(symbol, common.noop);
 assert.ok(!e._events[symbol].hasOwnProperty('warned'));
-e.on(symbol, function() {});
+e.on(symbol, common.noop);
 assert.ok(e._events[symbol].hasOwnProperty('warned'));
 
 // specific
 e.setMaxListeners(5);
 for (let i = 0; i < 5; i++) {
-  e.on('specific', function() {});
+  e.on('specific', common.noop);
 }
 assert.ok(!e._events['specific'].hasOwnProperty('warned'));
-e.on('specific', function() {});
+e.on('specific', common.noop);
 assert.ok(e._events['specific'].warned);
 
 // only one
 e.setMaxListeners(1);
-e.on('only one', function() {});
+e.on('only one', common.noop);
 assert.ok(!e._events['only one'].hasOwnProperty('warned'));
-e.on('only one', function() {});
+e.on('only one', common.noop);
 assert.ok(e._events['only one'].hasOwnProperty('warned'));
 
 // unlimited
 e.setMaxListeners(0);
 for (let i = 0; i < 1000; i++) {
-  e.on('unlimited', function() {});
+  e.on('unlimited', common.noop);
 }
 assert.ok(!e._events['unlimited'].hasOwnProperty('warned'));
 
@@ -49,26 +49,26 @@ events.EventEmitter.defaultMaxListeners = 42;
 e = new events.EventEmitter();
 
 for (let i = 0; i < 42; ++i) {
-  e.on('fortytwo', function() {});
+  e.on('fortytwo', common.noop);
 }
 assert.ok(!e._events['fortytwo'].hasOwnProperty('warned'));
-e.on('fortytwo', function() {});
+e.on('fortytwo', common.noop);
 assert.ok(e._events['fortytwo'].hasOwnProperty('warned'));
 delete e._events['fortytwo'].warned;
 
 events.EventEmitter.defaultMaxListeners = 44;
-e.on('fortytwo', function() {});
+e.on('fortytwo', common.noop);
 assert.ok(!e._events['fortytwo'].hasOwnProperty('warned'));
-e.on('fortytwo', function() {});
+e.on('fortytwo', common.noop);
 assert.ok(e._events['fortytwo'].hasOwnProperty('warned'));
 
 // but _maxListeners still has precedence over defaultMaxListeners
 events.EventEmitter.defaultMaxListeners = 42;
 e = new events.EventEmitter();
 e.setMaxListeners(1);
-e.on('uno', function() {});
+e.on('uno', common.noop);
 assert.ok(!e._events['uno'].hasOwnProperty('warned'));
-e.on('uno', function() {});
+e.on('uno', common.noop);
 assert.ok(e._events['uno'].hasOwnProperty('warned'));
 
 // chainable
diff --git a/test/parallel/test-event-emitter-get-max-listeners.js b/test/parallel/test-event-emitter-get-max-listeners.js
index 9acc71fd7920e3..98ac02e87130b5 100644
--- a/test/parallel/test-event-emitter-get-max-listeners.js
+++ b/test/parallel/test-event-emitter-get-max-listeners.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const EventEmitter = require('events');
 
@@ -15,5 +15,5 @@ assert.strictEqual(emitter.getMaxListeners(), 3);
 
 // https://github.com/nodejs/node/issues/523 - second call should not throw.
 const recv = {};
-EventEmitter.prototype.on.call(recv, 'event', function() {});
-EventEmitter.prototype.on.call(recv, 'event', function() {});
+EventEmitter.prototype.on.call(recv, 'event', common.noop);
+EventEmitter.prototype.on.call(recv, 'event', common.noop);
diff --git a/test/parallel/test-event-emitter-listener-count.js b/test/parallel/test-event-emitter-listener-count.js
index ebfed8b2ee33b1..50247f42770ba8 100644
--- a/test/parallel/test-event-emitter-listener-count.js
+++ b/test/parallel/test-event-emitter-listener-count.js
@@ -1,15 +1,15 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const EventEmitter = require('events');
 
 const emitter = new EventEmitter();
-emitter.on('foo', function() {});
-emitter.on('foo', function() {});
-emitter.on('baz', function() {});
+emitter.on('foo', common.noop);
+emitter.on('foo', common.noop);
+emitter.on('baz', common.noop);
 // Allow any type
-emitter.on(123, function() {});
+emitter.on(123, common.noop);
 
 assert.strictEqual(EventEmitter.listenerCount(emitter, 'foo'), 2);
 assert.strictEqual(emitter.listenerCount('foo'), 2);
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 62b06f67d92f28..16d9e28bb1eb44 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
@@ -18,5 +18,5 @@ process.on('warning', common.mustCall((warning) => {
   assert.ok(warning.message.includes('2 null listeners added.'));
 }));
 
-e.on(null, function() {});
-e.on(null, function() {});
+e.on(null, common.noop);
+e.on(null, common.noop);
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 97bf189270395b..bd1a8bec7758b0 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
@@ -20,5 +20,5 @@ process.on('warning', common.mustCall((warning) => {
   assert.ok(warning.message.includes('2 Symbol(symbol) listeners added.'));
 }));
 
-e.on(symbol, function() {});
-e.on(symbol, function() {});
+e.on(symbol, common.noop);
+e.on(symbol, common.noop);
diff --git a/test/parallel/test-event-emitter-max-listeners-warning.js b/test/parallel/test-event-emitter-max-listeners-warning.js
index 21f4ee0cc6bcde..f0cdac1919d209 100644
--- a/test/parallel/test-event-emitter-max-listeners-warning.js
+++ b/test/parallel/test-event-emitter-max-listeners-warning.js
@@ -18,6 +18,6 @@ process.on('warning', common.mustCall((warning) => {
   assert.ok(warning.message.includes('2 event-type listeners added.'));
 }));
 
-e.on('event-type', function() {});
-e.on('event-type', function() {});  // Trigger warning.
-e.on('event-type', function() {});  // Verify that warning is emitted only once.
+e.on('event-type', common.noop);
+e.on('event-type', common.noop);  // Trigger warning.
+e.on('event-type', common.noop);  // 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 2946c48f8fb30e..88156e90a0b347 100644
--- a/test/parallel/test-event-emitter-max-listeners.js
+++ b/test/parallel/test-event-emitter-max-listeners.js
@@ -4,7 +4,7 @@ const assert = require('assert');
 const events = require('events');
 const e = new events.EventEmitter();
 
-e.on('maxListeners', common.mustCall(function() {}));
+e.on('maxListeners', common.mustCall());
 
 // Should not corrupt the 'maxListeners' queue.
 e.setMaxListeners(42);
diff --git a/test/parallel/test-event-emitter-once.js b/test/parallel/test-event-emitter-once.js
index e304bccb6e2d42..c23a6c6769c0e6 100644
--- a/test/parallel/test-event-emitter-once.js
+++ b/test/parallel/test-event-emitter-once.js
@@ -24,7 +24,7 @@ e.once('e', common.mustCall(function() {
   e.emit('e');
 }));
 
-e.once('e', common.mustCall(function() {}));
+e.once('e', common.mustCall());
 
 e.emit('e');
 
diff --git a/test/parallel/test-event-emitter-remove-all-listeners.js b/test/parallel/test-event-emitter-remove-all-listeners.js
index e793cedb0dd4cf..8c4d2caa74fb58 100644
--- a/test/parallel/test-event-emitter-remove-all-listeners.js
+++ b/test/parallel/test-event-emitter-remove-all-listeners.js
@@ -70,9 +70,9 @@ function listener() {}
   ee.on('removeListener', function(name, listener) {
     assert.strictEqual(expectLength--, this.listeners('baz').length);
   });
-  ee.on('baz', function() {});
-  ee.on('baz', function() {});
-  ee.on('baz', function() {});
+  ee.on('baz', common.noop);
+  ee.on('baz', common.noop);
+  ee.on('baz', common.noop);
   assert.strictEqual(ee.listeners('baz').length, expectLength + 1);
   ee.removeAllListeners('baz');
   assert.strictEqual(ee.listeners('baz').length, 0);
diff --git a/test/parallel/test-event-emitter-subclass.js b/test/parallel/test-event-emitter-subclass.js
index eb2018e78e4b85..c0ce3392f7298f 100644
--- a/test/parallel/test-event-emitter-subclass.js
+++ b/test/parallel/test-event-emitter-subclass.js
@@ -13,7 +13,7 @@ function MyEE(cb) {
   EventEmitter.call(this);
 }
 
-const myee = new MyEE(common.mustCall(function() {}));
+const myee = new MyEE(common.mustCall());
 
 
 util.inherits(ErrorEE, EventEmitter);
@@ -41,6 +41,6 @@ MyEE2.prototype = new EventEmitter();
 const ee1 = new MyEE2();
 const ee2 = new MyEE2();
 
-ee1.on('x', function() {});
+ee1.on('x', common.noop);
 
 assert.strictEqual(ee2.listenerCount('x'), 0);
diff --git a/test/parallel/test-event-emitter-symbols.js b/test/parallel/test-event-emitter-symbols.js
index 9a2ae72f64464c..98d44ff3fa2afb 100644
--- a/test/parallel/test-event-emitter-symbols.js
+++ b/test/parallel/test-event-emitter-symbols.js
@@ -6,7 +6,7 @@ const assert = require('assert');
 
 const ee = new EventEmitter();
 const foo = Symbol('foo');
-const listener = common.mustCall(function() {});
+const listener = common.mustCall();
 
 ee.on(foo, listener);
 assert.deepStrictEqual(ee.listeners(foo), [listener]);
diff --git a/test/parallel/test-fs-makeStatsCallback.js b/test/parallel/test-fs-makeStatsCallback.js
index 67e6b18dd3d4f7..607fcdadee0b96 100644
--- a/test/parallel/test-fs-makeStatsCallback.js
+++ b/test/parallel/test-fs-makeStatsCallback.js
@@ -13,7 +13,7 @@ function testMakeStatsCallback(cb) {
 }
 
 // Verify the case where a callback function is provided
-assert.doesNotThrow(testMakeStatsCallback(common.noop));
+assert.doesNotThrow(testMakeStatsCallback(common.mustCall()));
 
 // Passing undefined/nothing calls rethrow() internally
 assert.doesNotThrow(testMakeStatsCallback());
diff --git a/test/parallel/test-fs-mkdir.js b/test/parallel/test-fs-mkdir.js
index e70880ef981d7e..cf744215a04ea4 100644
--- a/test/parallel/test-fs-mkdir.js
+++ b/test/parallel/test-fs-mkdir.js
@@ -56,4 +56,4 @@ common.refreshTmpDir();
 
 // Keep the event loop alive so the async mkdir() requests
 // have a chance to run (since they don't ref the event loop).
-process.nextTick(function() {});
+process.nextTick(common.noop);
diff --git a/test/parallel/test-fs-mkdtemp.js b/test/parallel/test-fs-mkdtemp.js
index d4773aa37b7bf5..5ce340afa5ad0f 100644
--- a/test/parallel/test-fs-mkdtemp.js
+++ b/test/parallel/test-fs-mkdtemp.js
@@ -4,7 +4,6 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
-const Buffer = require('buffer').Buffer;
 
 common.refreshTmpDir();
 
diff --git a/test/parallel/test-fs-read-file-assert-encoding.js b/test/parallel/test-fs-read-file-assert-encoding.js
index 897bcd3bc98795..ac0f45f98b30d4 100644
--- a/test/parallel/test-fs-read-file-assert-encoding.js
+++ b/test/parallel/test-fs-read-file-assert-encoding.js
@@ -1,6 +1,6 @@
 'use strict';
-require('../common');
 
+const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
@@ -8,6 +8,6 @@ const encoding = 'foo-8';
 const filename = 'bar.txt';
 
 assert.throws(
-  fs.readFile.bind(fs, filename, { encoding }, () => {}),
-  new RegExp(`Error: Unknown encoding: ${encoding}$`)
+  fs.readFile.bind(fs, filename, { encoding }, common.mustNotCall()),
+  new RegExp(`^Error: Unknown encoding: ${encoding}$`)
 );
diff --git a/test/parallel/test-fs-read-stream-inherit.js b/test/parallel/test-fs-read-stream-inherit.js
index d71dc3d4381272..b0bbde153539cc 100644
--- a/test/parallel/test-fs-read-stream-inherit.js
+++ b/test/parallel/test-fs-read-stream-inherit.js
@@ -39,7 +39,7 @@ let paused = false;
   });
 
 
-  file.on('end', common.mustCall(function() {}));
+  file.on('end', common.mustCall());
 
 
   file.on('close', common.mustCall(function() {
@@ -139,7 +139,7 @@ let paused = false;
   let file7 =
     fs.createReadStream(rangeFile, Object.create({autoClose: false }));
   assert.strictEqual(file7.autoClose, false);
-  file7.on('data', function() {});
+  file7.on('data', common.noop);
   file7.on('end', common.mustCall(function() {
     process.nextTick(common.mustCall(function() {
       assert(!file7.closed);
@@ -169,8 +169,8 @@ let paused = false;
 {
   const options = Object.create({fd: 13337, autoClose: false});
   const file8 = fs.createReadStream(null, options);
-  file8.on('data', function() {});
-  file8.on('error', common.mustCall(function() {}));
+  file8.on('data', common.noop);
+  file8.on('error', common.mustCall());
   process.on('exit', function() {
     assert(!file8.closed);
     assert(!file8.destroyed);
@@ -181,8 +181,8 @@ let paused = false;
 // Make sure stream is destroyed when file does not exist.
 {
   const file9 = fs.createReadStream('/path/to/file/that/does/not/exist');
-  file9.on('data', function() {});
-  file9.on('error', common.mustCall(function() {}));
+  file9.on('data', common.noop);
+  file9.on('error', common.mustCall());
 
   process.on('exit', function() {
     assert(!file9.closed);
diff --git a/test/parallel/test-fs-read-stream.js b/test/parallel/test-fs-read-stream.js
index d17703fabe6a27..5948845fcd8cbc 100644
--- a/test/parallel/test-fs-read-stream.js
+++ b/test/parallel/test-fs-read-stream.js
@@ -138,7 +138,7 @@ pauseRes.pause();
 pauseRes.resume();
 
 let file7 = fs.createReadStream(rangeFile, {autoClose: false });
-file7.on('data', function() {});
+file7.on('data', common.noop);
 file7.on('end', function() {
   process.nextTick(function() {
     assert(!file7.closed);
@@ -161,13 +161,13 @@ function file7Next() {
 
 // Just to make sure autoClose won't close the stream because of error.
 const file8 = fs.createReadStream(null, {fd: 13337, autoClose: false });
-file8.on('data', function() {});
-file8.on('error', common.mustCall(function() {}));
+file8.on('data', common.noop);
+file8.on('error', common.mustCall());
 
 // Make sure stream is destroyed when file does not exist.
 const file9 = fs.createReadStream('/path/to/file/that/does/not/exist');
-file9.on('data', function() {});
-file9.on('error', common.mustCall(function() {}));
+file9.on('data', common.noop);
+file9.on('error', common.mustCall());
 
 process.on('exit', function() {
   assert(file7.closed);
diff --git a/test/parallel/test-fs-watchfile.js b/test/parallel/test-fs-watchfile.js
index fcd28be0c1f126..c99510fcbb4fe9 100644
--- a/test/parallel/test-fs-watchfile.js
+++ b/test/parallel/test-fs-watchfile.js
@@ -1,21 +1,21 @@
 'use strict';
-
 const common = require('../common');
+
+const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
-const assert = require('assert');
 
 // Basic usage tests.
 assert.throws(function() {
   fs.watchFile('./some-file');
-}, /"watchFile\(\)" requires a listener function/);
+}, /^Error: "watchFile\(\)" requires a listener function$/);
 
 assert.throws(function() {
   fs.watchFile('./another-file', {}, 'bad listener');
-}, /"watchFile\(\)" requires a listener function/);
+}, /^Error: "watchFile\(\)" requires a listener function$/);
 
 assert.throws(function() {
-  fs.watchFile(new Object(), function() {});
+  fs.watchFile(new Object(), common.mustNotCall());
 }, /Path must be a string/);
 
 const enoentFile = path.join(common.tmpDir, 'non-existent-file');
diff --git a/test/parallel/test-fs-write-string-coerce.js b/test/parallel/test-fs-write-string-coerce.js
index afeab5b05464ea..e257dfc0c73ee0 100644
--- a/test/parallel/test-fs-write-string-coerce.js
+++ b/test/parallel/test-fs-write-string-coerce.js
@@ -2,7 +2,6 @@
 const common = require('../common');
 const assert = require('assert');
 const path = require('path');
-const Buffer = require('buffer').Buffer;
 const fs = require('fs');
 
 common.refreshTmpDir();
diff --git a/test/parallel/test-fs-write.js b/test/parallel/test-fs-write.js
index 9960a91a4f7515..c792de880bc321 100644
--- a/test/parallel/test-fs-write.js
+++ b/test/parallel/test-fs-write.js
@@ -2,7 +2,6 @@
 const common = require('../common');
 const assert = require('assert');
 const path = require('path');
-const Buffer = require('buffer').Buffer;
 const fs = require('fs');
 const fn = path.join(common.tmpDir, 'write.txt');
 const fn2 = path.join(common.tmpDir, 'write2.txt');
diff --git a/test/parallel/test-handle-wrap-close-abort.js b/test/parallel/test-handle-wrap-close-abort.js
index e9f69195ad29cd..492907ee05540f 100644
--- a/test/parallel/test-handle-wrap-close-abort.js
+++ b/test/parallel/test-handle-wrap-close-abort.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../common');
 
-process.on('uncaughtException', common.mustCall(function() {}, 2));
+process.on('uncaughtException', common.mustCall(common.noop, 2));
 
 setTimeout(function() {
   process.nextTick(function() {
diff --git a/test/parallel/test-http-abort-client.js b/test/parallel/test-http-abort-client.js
index 8d3960376761e5..c44681cf9a9884 100644
--- a/test/parallel/test-http-abort-client.js
+++ b/test/parallel/test-http-abort-client.js
@@ -38,6 +38,6 @@ server.listen(0, common.mustCall(function() {
     });
 
     // it would be nice if this worked:
-    res.on('close', common.mustCall(function() {}));
+    res.on('close', common.mustCall());
   }));
 }));
diff --git a/test/parallel/test-http-client-aborted-event.js b/test/parallel/test-http-client-aborted-event.js
index 951a128f51b261..a9036a927df1e6 100644
--- a/test/parallel/test-http-client-aborted-event.js
+++ b/test/parallel/test-http-client-aborted-event.js
@@ -13,6 +13,6 @@ server.listen(0, common.mustCall(function() {
     headers: { connection: 'keep-alive' }
   }, common.mustCall(function(res) {
     server.close();
-    res.on('aborted', common.mustCall(function() {}));
+    res.on('aborted', common.mustCall());
   }));
 }));
diff --git a/test/parallel/test-http-client-agent.js b/test/parallel/test-http-client-agent.js
index b90694523745d4..6d30a2236ef485 100644
--- a/test/parallel/test-http-client-agent.js
+++ b/test/parallel/test-http-client-agent.js
@@ -34,7 +34,8 @@ function request(i) {
     socket.on('close', function() {
       ++count;
       if (count < max) {
-        assert.strictEqual(http.globalAgent.sockets[name].indexOf(socket), -1);
+        assert.strictEqual(http.globalAgent.sockets[name].includes(socket),
+                           false);
       } else {
         assert(!http.globalAgent.sockets.hasOwnProperty(name));
         assert(!http.globalAgent.requests.hasOwnProperty(name));
diff --git a/test/parallel/test-http-client-default-headers-exist.js b/test/parallel/test-http-client-default-headers-exist.js
index 06923b6c79c5c0..410f83449fc1b6 100644
--- a/test/parallel/test-http-client-default-headers-exist.js
+++ b/test/parallel/test-http-client-default-headers-exist.js
@@ -25,9 +25,9 @@ const server = http.createServer(function(req, res) {
 
   const requestHeaders = Object.keys(req.headers);
   requestHeaders.forEach(function(header) {
-    assert.notStrictEqual(
-      expectedHeaders[req.method].indexOf(header.toLowerCase()),
-      -1,
+    assert.strictEqual(
+      expectedHeaders[req.method].includes(header.toLowerCase()),
+      true,
       `${header} should not exist for method ${req.method}`
     );
   });
diff --git a/test/parallel/test-http-eof-on-connect.js b/test/parallel/test-http-eof-on-connect.js
index f67e45ed403225..7e244354c1cb88 100644
--- a/test/parallel/test-http-eof-on-connect.js
+++ b/test/parallel/test-http-eof-on-connect.js
@@ -1,5 +1,27 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// 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.
+
 'use strict';
-require('../common');
+
+const common = require('../common');
 const net = require('net');
 const http = require('http');
 
@@ -7,7 +29,7 @@ const http = require('http');
 // It is separate from test-http-malformed-request.js because it is only
 // reproduceable on the first packet on the first connection to a server.
 
-const server = http.createServer(function(req, res) {});
+const server = http.createServer(common.mustNotCall());
 server.listen(0);
 
 server.on('listening', function() {
diff --git a/test/parallel/test-http-full-response.js b/test/parallel/test-http-full-response.js
index 0e834cee5b8932..292368ae16662c 100644
--- a/test/parallel/test-http-full-response.js
+++ b/test/parallel/test-http-full-response.js
@@ -21,7 +21,7 @@ function runAb(opts, callback) {
   const command = `ab ${opts} http://127.0.0.1:${server.address().port}/`;
   exec(command, function(err, stdout, stderr) {
     if (err) {
-      if (/ab|apr/mi.test(stderr)) {
+      if (/ab|apr/i.test(stderr)) {
         common.skip(`problem spawning \`ab\`.\n${stderr}`);
         process.reallyExit(0);
       }
@@ -29,13 +29,13 @@ function runAb(opts, callback) {
       return;
     }
 
-    let m = /Document Length:\s*(\d+) bytes/mi.exec(stdout);
+    let m = /Document Length:\s*(\d+) bytes/i.exec(stdout);
     const documentLength = parseInt(m[1]);
 
-    m = /Complete requests:\s*(\d+)/mi.exec(stdout);
+    m = /Complete requests:\s*(\d+)/i.exec(stdout);
     const completeRequests = parseInt(m[1]);
 
-    m = /HTML transferred:\s*(\d+) bytes/mi.exec(stdout);
+    m = /HTML transferred:\s*(\d+) bytes/i.exec(stdout);
     const htmlTransfered = parseInt(m[1]);
 
     assert.strictEqual(bodyLength, documentLength);
diff --git a/test/parallel/test-http-invalidheaderfield.js b/test/parallel/test-http-invalidheaderfield.js
index aaed46c69cd592..21be4c4d6d95e0 100644
--- a/test/parallel/test-http-invalidheaderfield.js
+++ b/test/parallel/test-http-invalidheaderfield.js
@@ -1,5 +1,6 @@
 'use strict';
-require('../common');
+const common = require('../common');
+
 const assert = require('assert');
 const EventEmitter = require('events');
 const http = require('http');
@@ -28,7 +29,7 @@ server.listen(0, function() {
         port: server.address().port,
         headers: {'testing 123': 123}
       };
-      http.get(options, function() {});
+      http.get(options, common.mustNotCall());
     },
     function(err) {
       ee.emit('done');
diff --git a/test/parallel/test-http-keepalive-maxsockets.js b/test/parallel/test-http-keepalive-maxsockets.js
index fd01fa02750853..de3bdea54f1f5d 100644
--- a/test/parallel/test-http-keepalive-maxsockets.js
+++ b/test/parallel/test-http-keepalive-maxsockets.js
@@ -7,7 +7,7 @@ const http = require('http');
 
 const serverSockets = [];
 const server = http.createServer(function(req, res) {
-  if (serverSockets.indexOf(req.socket) === -1) {
+  if (!serverSockets.includes(req.socket)) {
     serverSockets.push(req.socket);
   }
   res.end(req.url);
diff --git a/test/parallel/test-http-methods.js b/test/parallel/test-http-methods.js
index 6ba02807f8706b..fb49add6a2ad24 100644
--- a/test/parallel/test-http-methods.js
+++ b/test/parallel/test-http-methods.js
@@ -6,7 +6,7 @@ const util = require('util');
 
 assert(Array.isArray(http.METHODS));
 assert(http.METHODS.length > 0);
-assert.notStrictEqual(http.METHODS.indexOf('GET'), -1);
-assert.notStrictEqual(http.METHODS.indexOf('HEAD'), -1);
-assert.notStrictEqual(http.METHODS.indexOf('POST'), -1);
+assert(http.METHODS.includes('GET'));
+assert(http.METHODS.includes('HEAD'));
+assert(http.METHODS.includes('POST'));
 assert.deepStrictEqual(util._extend([], http.METHODS), http.METHODS.sort());
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 214287a6ffc157..7249230cfadbb7 100644
--- a/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js
+++ b/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js
@@ -24,7 +24,7 @@ for (const enc of ['utf8', 'utf16le', 'latin1', 'UTF-8']) {
       const headerEnd = received.indexOf('\r\n\r\n', 'utf8');
       assert.notStrictEqual(headerEnd, -1);
 
-      const header = received.toString('utf8', 0, headerEnd).split(/\r\n/g);
+      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');
diff --git a/test/parallel/test-http-pause-resume-one-end.js b/test/parallel/test-http-pause-resume-one-end.js
index 6b98246cc271ac..5f5ab4b309e078 100644
--- a/test/parallel/test-http-pause-resume-one-end.js
+++ b/test/parallel/test-http-pause-resume-one-end.js
@@ -22,6 +22,6 @@ server.listen(0, common.mustCall(function() {
       });
     }));
 
-    res.on('end', common.mustCall(function() {}));
+    res.on('end', common.mustCall());
   }));
 }));
diff --git a/test/parallel/test-http-set-timeout-server.js b/test/parallel/test-http-set-timeout-server.js
index 8f301af5a9dcc4..98072ab9c61b7e 100644
--- a/test/parallel/test-http-set-timeout-server.js
+++ b/test/parallel/test-http-set-timeout-server.js
@@ -1,5 +1,6 @@
 'use strict';
 const common = require('../common');
+
 const assert = require('assert');
 const http = require('http');
 const net = require('net');
@@ -9,137 +10,118 @@ const tests = [];
 function test(fn) {
   if (!tests.length)
     process.nextTick(run);
-  tests.push(fn);
+  tests.push(common.mustCall(fn));
 }
 
 function run() {
   const fn = tests.shift();
   if (fn) {
-    console.log('# %s', fn.name);
     fn(run);
-  } else {
-    console.log('ok');
   }
 }
 
 test(function serverTimeout(cb) {
-  let caughtTimeout = false;
-  process.on('exit', function() {
-    assert(caughtTimeout);
-  });
-  const server = http.createServer(function(req, res) {
+  const server = http.createServer(common.mustCall((req, res) => {
     // just do nothing, we should get a timeout event.
-  });
-  server.listen(common.mustCall(function() {
-    http.get({ port: server.address().port }).on('error', function() {});
   }));
-  const s = server.setTimeout(50, function(socket) {
-    caughtTimeout = true;
-    socket.destroy();
-    server.close();
-    cb();
-  });
-  assert.ok(s instanceof http.Server);
+  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) {
-  let caughtTimeout = false;
-  process.on('exit', function() {
-    assert(caughtTimeout);
-  });
-  const server = http.createServer(function(req, res) {
+  const server = http.createServer(common.mustCall((req, res) => {
     // just do nothing, we should get a timeout event.
-    const s = req.setTimeout(50, function() {
-      caughtTimeout = true;
-      req.socket.destroy();
+    const s = req.setTimeout(50, common.mustCall((socket) => {
+      socket.destroy();
       server.close();
       cb();
-    });
+    }));
     assert.ok(s instanceof http.IncomingMessage);
-  });
-  server.listen(common.mustCall(function() {
-    const port = server.address().port;
-    const req = http.request({ port: port, method: 'POST' });
-    req.on('error', function() {});
+  }));
+  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) {
-  let caughtTimeout = false;
-  process.on('exit', function() {
-    assert(caughtTimeout);
-  });
-  const server = http.createServer(function(req, res) {
+  const server = http.createServer(common.mustCall((req, res) => {
     // just do nothing, we should get a timeout event.
-    const s = res.setTimeout(50, function() {
-      caughtTimeout = true;
-      res.socket.destroy();
+    const s = res.setTimeout(50, common.mustCall((socket) => {
+      socket.destroy();
       server.close();
       cb();
-    });
+    }));
     assert.ok(s instanceof http.OutgoingMessage);
-  });
-  server.listen(common.mustCall(function() {
-    const port = server.address().port;
-    http.get({ port: port }).on('error', function() {});
+  }));
+  server.listen(common.mustCall(() => {
+    http.get({
+      port: server.address().port
+    }).on('error', common.mustCall());
   }));
 });
 
 test(function serverRequestNotTimeoutAfterEnd(cb) {
-  let caughtTimeoutOnRequest = false;
-  let caughtTimeoutOnResponse = false;
-  process.on('exit', function() {
-    assert(!caughtTimeoutOnRequest);
-    assert(caughtTimeoutOnResponse);
-  });
-  const server = http.createServer(function(req, res) {
+  const server = http.createServer(common.mustCall((req, res) => {
     // just do nothing, we should get a timeout event.
-    const s = req.setTimeout(50, function(socket) {
-      caughtTimeoutOnRequest = true;
-    });
+    const s = req.setTimeout(50, common.mustNotCall());
     assert.ok(s instanceof http.IncomingMessage);
-    res.on('timeout', function(socket) {
-      caughtTimeoutOnResponse = true;
-    });
-  });
-  server.on('timeout', function(socket) {
+    res.on('timeout', common.mustCall());
+  }));
+  server.on('timeout', common.mustCall((socket) => {
     socket.destroy();
     server.close();
     cb();
-  });
-  server.listen(common.mustCall(function() {
-    const port = server.address().port;
-    http.get({ port: port }).on('error', function() {});
+  }));
+  server.listen(common.mustCall(() => {
+    http.get({
+      port: server.address().port
+    }).on('error', common.mustCall());
   }));
 });
 
 test(function serverResponseTimeoutWithPipeline(cb) {
   let caughtTimeout = '';
   let secReceived = false;
-  process.on('exit', function() {
+  process.on('exit', () => {
     assert.strictEqual(caughtTimeout, '/2');
   });
-  const server = http.createServer(function(req, res) {
+  const server = http.createServer((req, res) => {
     if (req.url === '/2')
       secReceived = true;
-    const s = res.setTimeout(50, function() {
+    const s = res.setTimeout(50, () => {
       caughtTimeout += req.url;
     });
     assert.ok(s instanceof http.OutgoingMessage);
     if (req.url === '/1') res.end();
   });
-  server.on('timeout', function(socket) {
+  server.on('timeout', common.mustCall((socket) => {
     if (secReceived) {
       socket.destroy();
       server.close();
       cb();
     }
-  });
-  server.listen(common.mustCall(function() {
-    const port = server.address().port;
-    const c = net.connect({ port: port, allowHalfOpen: true }, function() {
+  }));
+  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');
@@ -148,33 +130,23 @@ test(function serverResponseTimeoutWithPipeline(cb) {
 });
 
 test(function idleTimeout(cb) {
-  let caughtTimeoutOnRequest = false;
-  let caughtTimeoutOnResponse = false;
-  let caughtTimeoutOnServer = false;
-  process.on('exit', function() {
-    assert(!caughtTimeoutOnRequest);
-    assert(!caughtTimeoutOnResponse);
-    assert(caughtTimeoutOnServer);
-  });
-  const server = http.createServer(function(req, res) {
-    req.on('timeout', function(socket) {
-      caughtTimeoutOnRequest = true;
-    });
-    res.on('timeout', function(socket) {
-      caughtTimeoutOnResponse = true;
-    });
+  const server = http.createServer(common.mustCall((req, res) => {
+    req.on('timeout', common.mustNotCall());
+    res.on('timeout', common.mustNotCall());
     res.end();
-  });
-  const s = server.setTimeout(50, function(socket) {
-    caughtTimeoutOnServer = true;
+  }));
+  const s = server.setTimeout(50, common.mustCall((socket) => {
     socket.destroy();
     server.close();
     cb();
-  });
+  }));
   assert.ok(s instanceof http.Server);
-  server.listen(common.mustCall(function() {
-    const port = server.address().port;
-    const c = net.connect({ port: port, allowHalfOpen: true }, function() {
+  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-upgrade-server.js b/test/parallel/test-http-upgrade-server.js
index c641f1576e8703..72c9313b846184 100644
--- a/test/parallel/test-http-upgrade-server.js
+++ b/test/parallel/test-http-upgrade-server.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const util = require('util');
@@ -16,7 +16,7 @@ function createTestServer() {
 }
 
 function testServer() {
-  http.Server.call(this, function() {});
+  http.Server.call(this, common.noop);
 
   this.on('connection', function() {
     requests_recv++;
diff --git a/test/parallel/test-http-write-head.js b/test/parallel/test-http-write-head.js
index 2ceba8965c0ea4..c6b2a5e41ce820 100644
--- a/test/parallel/test-http-write-head.js
+++ b/test/parallel/test-http-write-head.js
@@ -46,7 +46,7 @@ function runTest() {
   http.get({ port: this.address().port }, common.mustCall((response) => {
     response.on('end', common.mustCall(() => {
       assert.strictEqual(response.headers['test'], '2');
-      assert.notStrictEqual(response.rawHeaders.indexOf('Test'), -1);
+      assert(response.rawHeaders.includes('Test'));
       s.close();
     }));
     response.resume();
diff --git a/test/parallel/test-https-close.js b/test/parallel/test-https-close.js
index a9b2a579637408..20f03a591cd992 100644
--- a/test/parallel/test-https-close.js
+++ b/test/parallel/test-https-close.js
@@ -31,7 +31,7 @@ server.on('connection', function(connection) {
 });
 
 function shutdown() {
-  server.close(common.mustCall(function() {}));
+  server.close(common.mustCall());
 
   for (const key in connections) {
     connections[key].destroy();
diff --git a/test/parallel/test-internal-modules-expose.js b/test/parallel/test-internal-modules-expose.js
index 02ddfd87c363fc..ab48e36881268c 100644
--- a/test/parallel/test-internal-modules-expose.js
+++ b/test/parallel/test-internal-modules-expose.js
@@ -3,5 +3,9 @@
 
 require('../common');
 const assert = require('assert');
+const config = process.binding('config');
+
+console.log(config, process.argv);
 
 assert.strictEqual(typeof require('internal/freelist').FreeList, 'function');
+assert.strictEqual(config.exposeInternals, true);
diff --git a/test/parallel/test-net-connect-options-ipv6.js b/test/parallel/test-net-connect-options-ipv6.js
index e9d8a78cbbefef..2164f550ce941f 100644
--- a/test/parallel/test-net-connect-options-ipv6.js
+++ b/test/parallel/test-net-connect-options-ipv6.js
@@ -15,7 +15,7 @@ let localhostTries = 10;
 
 const server = net.createServer({allowHalfOpen: true}, function(socket) {
   socket.resume();
-  socket.on('end', common.mustCall(function() {}));
+  socket.on('end', common.mustCall());
   socket.end();
 });
 
diff --git a/test/parallel/test-net-connect-options.js b/test/parallel/test-net-connect-options.js
index e794c40859856a..09db7ccea97bfb 100644
--- a/test/parallel/test-net-connect-options.js
+++ b/test/parallel/test-net-connect-options.js
@@ -7,7 +7,7 @@ const server = net.createServer({
   allowHalfOpen: true
 }, common.mustCall(function(socket) {
   socket.resume();
-  socket.on('end', common.mustCall(function() {}));
+  socket.on('end', common.mustCall());
   socket.end();
 }));
 
diff --git a/test/parallel/test-net-listen-close-server-callback-is-not-function.js b/test/parallel/test-net-listen-close-server-callback-is-not-function.js
index 243ec038f75aeb..459ca3e5384445 100644
--- a/test/parallel/test-net-listen-close-server-callback-is-not-function.js
+++ b/test/parallel/test-net-listen-close-server-callback-is-not-function.js
@@ -4,7 +4,7 @@ const net = require('net');
 
 const server = net.createServer(common.mustNotCall());
 
-server.on('close', common.mustCall(function() {}));
+server.on('close', common.mustCall());
 
 server.listen(0, common.mustNotCall());
 
diff --git a/test/parallel/test-net-server-bind.js b/test/parallel/test-net-server-bind.js
deleted file mode 100644
index 2804271f6f19d4..00000000000000
--- a/test/parallel/test-net-server-bind.js
+++ /dev/null
@@ -1,86 +0,0 @@
-'use strict';
-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
-
-let address0;
-const server0 = net.createServer(function(socket) { });
-
-server0.listen(function() {
-  address0 = server0.address();
-  console.log('address0 %j', address0);
-  server0.close();
-});
-
-
-// No callback to listen(), assume we can bind in 100 ms
-
-let address1;
-let connectionKey1;
-const server1 = net.createServer(function(socket) { });
-
-server1.listen(common.PORT);
-
-setTimeout(function() {
-  address1 = server1.address();
-  connectionKey1 = server1._connectionKey;
-  console.log('address1 %j', address1);
-  server1.close();
-}, 100);
-
-
-// Callback to listen()
-
-let address2;
-const server2 = net.createServer(function(socket) { });
-
-server2.listen(common.PORT + 1, function() {
-  address2 = server2.address();
-  console.log('address2 %j', address2);
-  server2.close();
-});
-
-
-// Backlog argument
-
-let address3;
-const server3 = net.createServer(function(socket) { });
-
-server3.listen(common.PORT + 2, '0.0.0.0', 127, function() {
-  address3 = server3.address();
-  console.log('address3 %j', address3);
-  server3.close();
-});
-
-
-// Backlog argument without host argument
-
-let address4;
-const server4 = net.createServer(function(socket) { });
-
-server4.listen(common.PORT + 3, 127, function() {
-  address4 = server4.address();
-  console.log('address4 %j', address4);
-  server4.close();
-});
-
-
-process.on('exit', function() {
-  assert.ok(address0.port > 100);
-  assert.strictEqual(common.PORT, address1.port);
-
-  let expectedConnectionKey1;
-
-  if (address1.family === 'IPv6')
-    expectedConnectionKey1 = `6::::${address1.port}`;
-  else
-    expectedConnectionKey1 = `4:0.0.0.0:${address1.port}`;
-
-  assert.strictEqual(connectionKey1, expectedConnectionKey1);
-  assert.strictEqual(common.PORT + 1, address2.port);
-  assert.strictEqual(common.PORT + 2, address3.port);
-  assert.strictEqual(common.PORT + 3, address4.port);
-});
diff --git a/test/parallel/test-net-server-connections.js b/test/parallel/test-net-server-connections.js
index 7ee1df1a544b95..491a97bddc3ffa 100644
--- a/test/parallel/test-net-server-connections.js
+++ b/test/parallel/test-net-server-connections.js
@@ -6,7 +6,6 @@ const net = require('net');
 
 // test that server.connections property is no longer enumerable now that it
 // has been marked as deprecated
-
 const server = new net.Server();
 
-assert.strictEqual(Object.keys(server).indexOf('connections'), -1);
+assert.strictEqual(Object.keys(server).includes('connections'), false);
diff --git a/test/parallel/test-net-socket-destroy-twice.js b/test/parallel/test-net-socket-destroy-twice.js
index 749964751b39ad..3763acdf7ce3ed 100644
--- a/test/parallel/test-net-socket-destroy-twice.js
+++ b/test/parallel/test-net-socket-destroy-twice.js
@@ -11,5 +11,5 @@ conn.on('error', common.mustCall(() => {
   conn.destroy();
 }));
 
-conn.on('close', common.mustCall(function() {}));
+conn.on('close', common.mustCall());
 server.close();
diff --git a/test/parallel/test-next-tick.js b/test/parallel/test-next-tick.js
index 001e8a2e471e03..a57b6444fc9835 100644
--- a/test/parallel/test-next-tick.js
+++ b/test/parallel/test-next-tick.js
@@ -4,15 +4,15 @@ const assert = require('assert');
 
 process.nextTick(common.mustCall(function() {
   process.nextTick(common.mustCall(function() {
-    process.nextTick(common.mustCall(function() {}));
+    process.nextTick(common.mustCall());
   }));
 }));
 
 setTimeout(common.mustCall(function() {
-  process.nextTick(common.mustCall(function() {}));
+  process.nextTick(common.mustCall());
 }), 50);
 
-process.nextTick(common.mustCall(function() {}));
+process.nextTick(common.mustCall());
 
 const obj = {};
 
diff --git a/test/parallel/test-path-parse-format.js b/test/parallel/test-path-parse-format.js
index af175ba340deeb..a914f815410d2e 100644
--- a/test/parallel/test-path-parse-format.js
+++ b/test/parallel/test-path-parse-format.js
@@ -4,24 +4,33 @@ const assert = require('assert');
 const path = require('path');
 
 const winPaths = [
-  'C:\\path\\dir\\index.html',
-  'C:\\another_path\\DIR\\1\\2\\33\\\\index',
-  'another_path\\DIR with spaces\\1\\2\\33\\index',
-  '\\foo\\C:',
-  'file',
-  '.\\file',
-  'C:\\',
-  '',
+  // [path, root]
+  ['C:\\path\\dir\\index.html', 'C:\\'],
+  ['C:\\another_path\\DIR\\1\\2\\33\\\\index', 'C:\\'],
+  ['another_path\\DIR with spaces\\1\\2\\33\\index', ''],
+  ['\\', '\\'],
+  ['\\foo\\C:', '\\'],
+  ['file', ''],
+  ['file:stream', ''],
+  ['.\\file', ''],
+  ['C:', 'C:'],
+  ['C:.', 'C:'],
+  ['C:..', 'C:'],
+  ['C:abc', 'C:'],
+  ['C:\\', 'C:\\'],
+  ['C:\\abc', 'C:\\' ],
+  ['', ''],
 
   // unc
-  '\\\\server\\share\\file_path',
-  '\\\\server two\\shared folder\\file path.zip',
-  '\\\\teela\\admin$\\system32',
-  '\\\\?\\UNC\\server\\share'
+  ['\\\\server\\share\\file_path', '\\\\server\\share\\'],
+  ['\\\\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: '/'}]
+  ['/foo/bar', { root: '/' }],
 ];
 
 const winSpecialCaseFormatTests = [
@@ -35,26 +44,27 @@ const winSpecialCaseFormatTests = [
 ];
 
 const unixPaths = [
-  '/home/user/dir/file.txt',
-  '/home/user/a dir/another File.zip',
-  '/home/user/a dir//another&File.',
-  '/home/user/a$$$dir//another File.zip',
-  'user/dir/another File.zip',
-  'file',
-  '.\\file',
-  './file',
-  'C:\\foo',
-  '/',
-  '',
-  '.',
-  '..',
-  '/foo',
-  '/foo.',
-  '/foo.bar',
-  '/.',
-  '/.foo',
-  '/.foo.bar',
-  '/foo/bar.baz',
+  // [path, root]
+  ['/home/user/dir/file.txt', '/'],
+  ['/home/user/a dir/another File.zip', '/'],
+  ['/home/user/a dir//another&File.', '/'],
+  ['/home/user/a$$$dir//another File.zip', '/'],
+  ['user/dir/another File.zip', ''],
+  ['file', ''],
+  ['.\\file', ''],
+  ['./file', ''],
+  ['C:\\foo', ''],
+  ['/', '/'],
+  ['', ''],
+  ['.', ''],
+  ['..', ''],
+  ['/foo', '/'],
+  ['/foo.', '/'],
+  ['/foo.bar', '/'],
+  ['/.', '/'],
+  ['/.foo', '/'],
+  ['/.foo.bar', '/'],
+  ['/foo/bar.baz', '/']
 ];
 
 const unixSpecialCaseFormatTests = [
@@ -144,7 +154,7 @@ trailingTests.forEach(function(test) {
     if (!failed) {
       for (let i = 0; i < actualKeys.length; ++i) {
         const key = actualKeys[i];
-        if (expectedKeys.indexOf(key) === -1 || actual[key] !== expected[key]) {
+        if (!expectedKeys.includes(key) || actual[key] !== expected[key]) {
           failed = true;
           break;
         }
@@ -165,7 +175,7 @@ function checkErrors(path) {
 }
 
 function checkParseFormat(path, paths) {
-  paths.forEach(function(element) {
+  paths.forEach(function([element, root]) {
     const output = path.parse(element);
     assert.strictEqual(typeof output.root, 'string');
     assert.strictEqual(typeof output.dir, 'string');
@@ -173,6 +183,8 @@ function checkParseFormat(path, paths) {
     assert.strictEqual(typeof output.ext, 'string');
     assert.strictEqual(typeof output.name, 'string');
     assert.strictEqual(path.format(output), element);
+    assert.strictEqual(output.root, root);
+    assert(output.dir.startsWith(output.root));
     assert.strictEqual(output.dir, output.dir ? path.dirname(element) : '');
     assert.strictEqual(output.base, path.basename(element));
     assert.strictEqual(output.ext, path.extname(element));
diff --git a/test/parallel/test-path.js b/test/parallel/test-path.js
index 46f36e36e7ec12..825f10d49d4153 100644
--- a/test/parallel/test-path.js
+++ b/test/parallel/test-path.js
@@ -51,6 +51,16 @@ assert.strictEqual(path.win32.basename('aaa\\bbb', 'bbb'), 'bbb');
 assert.strictEqual(path.win32.basename('aaa\\bbb\\\\\\\\', 'bbb'), 'bbb');
 assert.strictEqual(path.win32.basename('aaa\\bbb', 'bb'), 'b');
 assert.strictEqual(path.win32.basename('aaa\\bbb', 'b'), 'bb');
+assert.strictEqual(path.win32.basename('C:'), '');
+assert.strictEqual(path.win32.basename('C:.'), '.');
+assert.strictEqual(path.win32.basename('C:\\'), '');
+assert.strictEqual(path.win32.basename('C:\\dir\\base.ext'), 'base.ext');
+assert.strictEqual(path.win32.basename('C:\\basename.ext'), 'basename.ext');
+assert.strictEqual(path.win32.basename('C:basename.ext'), 'basename.ext');
+assert.strictEqual(path.win32.basename('C:basename.ext\\'), 'basename.ext');
+assert.strictEqual(path.win32.basename('C:basename.ext\\\\'), 'basename.ext');
+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'),
@@ -99,6 +109,8 @@ assert.strictEqual(path.win32.dirname('c:foo\\'), 'c:');
 assert.strictEqual(path.win32.dirname('c:foo\\bar'), 'c:foo');
 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'),
@@ -166,6 +178,7 @@ assert.strictEqual(path.win32.dirname('foo'), '.');
   ['file./', '.'],
   ['file.//', '.'],
 ].forEach((test) => {
+  const expected = test[1];
   [path.posix.extname, path.win32.extname].forEach((extname) => {
     let input = test[0];
     let os;
@@ -176,12 +189,19 @@ assert.strictEqual(path.win32.dirname('foo'), '.');
       os = 'posix';
     }
     const actual = extname(input);
-    const expected = test[1];
     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}`);
+  }
 });
 assert.strictEqual(failures.length, 0, failures.join(''));
 
@@ -385,6 +405,12 @@ 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('/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:\\.'), 'C:\\');
+assert.strictEqual(path.win32.normalize('file:stream'), 'file:stream');
 
 assert.strictEqual(path.posix.normalize('./fixtures///b/../b/c.js'),
                    'fixtures/b/c.js');
diff --git a/test/parallel/test-process-getgroups.js b/test/parallel/test-process-getgroups.js
index 390f188cf5bf4d..fae363e2196628 100644
--- a/test/parallel/test-process-getgroups.js
+++ b/test/parallel/test-process-getgroups.js
@@ -24,7 +24,7 @@ if (typeof process.getgroups === 'function') {
 }
 
 function check(a, b) {
-  for (let i = 0; i < a.length; ++i) assert.notStrictEqual(b.indexOf(a[i]), -1);
+  for (let i = 0; i < a.length; ++i) assert(b.includes(a[i]));
 }
 
 function unique(groups) {
diff --git a/test/parallel/test-process-next-tick.js b/test/parallel/test-process-next-tick.js
index e67ebae0a29559..383b87a030a0b5 100644
--- a/test/parallel/test-process-next-tick.js
+++ b/test/parallel/test-process-next-tick.js
@@ -10,7 +10,7 @@ for (let i = 0; i < N; ++i) {
   process.nextTick(common.mustCall(cb));
 }
 
-process.on('uncaughtException', common.mustCall(function() {}, N));
+process.on('uncaughtException', common.mustCall(common.noop, N));
 
 process.on('exit', function() {
   process.removeAllListeners('uncaughtException');
diff --git a/test/parallel/test-promises-unhandled-rejections.js b/test/parallel/test-promises-unhandled-rejections.js
index 87dc743625a0ab..8fe3d46864ee24 100644
--- a/test/parallel/test-promises-unhandled-rejections.js
+++ b/test/parallel/test-promises-unhandled-rejections.js
@@ -164,7 +164,7 @@ asyncTest('Catching a promise rejection after setImmediate is not' +
   });
   _reject(e);
   setImmediate(function() {
-    promise.then(common.fail, function() {});
+    promise.then(common.fail, common.noop);
   });
 });
 
@@ -240,7 +240,7 @@ asyncTest(
   function(done) {
     const e = new Error();
     onUnhandledFail(done);
-    Promise.reject(e).then(common.fail, function() {});
+    Promise.reject(e).then(common.fail, common.noop);
   }
 );
 
@@ -252,7 +252,7 @@ asyncTest(
     onUnhandledFail(done);
     new Promise(function(_, reject) {
       reject(e);
-    }).then(common.fail, function() {});
+    }).then(common.fail, common.noop);
   }
 );
 
@@ -262,7 +262,7 @@ asyncTest('Attaching a promise catch in a process.nextTick is soon enough to' +
   onUnhandledFail(done);
   const promise = Promise.reject(e);
   process.nextTick(function() {
-    promise.then(common.fail, function() {});
+    promise.then(common.fail, common.noop);
   });
 });
 
@@ -274,7 +274,7 @@ asyncTest('Attaching a promise catch in a process.nextTick is soon enough to' +
     reject(e);
   });
   process.nextTick(function() {
-    promise.then(common.fail, function() {});
+    promise.then(common.fail, common.noop);
   });
 });
 
@@ -385,7 +385,7 @@ 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(common.fail, function() {});
+  Promise.all([Promise.reject(e)]).then(common.fail, common.noop);
 });
 
 asyncTest(
@@ -401,7 +401,7 @@ asyncTest(
     });
     p = Promise.all([p]);
     process.nextTick(function() {
-      p.then(common.fail, function() {});
+      p.then(common.fail, common.noop);
     });
   }
 );
@@ -455,7 +455,7 @@ asyncTest('Waiting for some combination of process.nextTick + promise' +
     Promise.resolve().then(function() {
       process.nextTick(function() {
         Promise.resolve().then(function() {
-          a.catch(function() {});
+          a.catch(common.noop);
         });
       });
     });
@@ -474,7 +474,7 @@ asyncTest('Waiting for some combination of process.nextTick + promise' +
       Promise.resolve().then(function() {
         process.nextTick(function() {
           Promise.resolve().then(function() {
-            a.catch(function() {});
+            a.catch(common.noop);
           });
         });
       });
@@ -494,7 +494,7 @@ asyncTest('Waiting for some combination of process.nextTick + promise ' +
       Promise.resolve().then(function() {
         process.nextTick(function() {
           Promise.resolve().then(function() {
-            a.catch(function() {});
+            a.catch(common.noop);
           });
         });
       });
@@ -514,7 +514,7 @@ asyncTest('Waiting for some combination of promise microtasks + ' +
     process.nextTick(function() {
       Promise.resolve().then(function() {
         process.nextTick(function() {
-          a.catch(function() {});
+          a.catch(common.noop);
         });
       });
     });
@@ -535,7 +535,7 @@ asyncTest(
         process.nextTick(function() {
           Promise.resolve().then(function() {
             process.nextTick(function() {
-              a.catch(function() {});
+              a.catch(common.noop);
             });
           });
         });
@@ -556,7 +556,7 @@ asyncTest('Waiting for some combination of promise microtasks +' +
       process.nextTick(function() {
         Promise.resolve().then(function() {
           process.nextTick(function() {
-            a.catch(function() {});
+            a.catch(common.noop);
           });
         });
       });
@@ -575,7 +575,7 @@ asyncTest('setImmediate + promise microtasks is too late to attach a catch' +
   let p = Promise.reject(e);
   setImmediate(function() {
     Promise.resolve().then(function() {
-      p.catch(function() {});
+      p.catch(common.noop);
     });
   });
 });
@@ -592,7 +592,7 @@ asyncTest('setImmediate + promise microtasks is too late to attach a catch' +
       Promise.resolve().then(function() {
         Promise.resolve().then(function() {
           Promise.resolve().then(function() {
-            p.catch(function() {});
+            p.catch(common.noop);
           });
         });
       });
@@ -614,7 +614,7 @@ asyncTest('setImmediate + promise microtasks is too late to attach a catch' +
       Promise.resolve().then(function() {
         Promise.resolve().then(function() {
           Promise.resolve().then(function() {
-            p.catch(function() {});
+            p.catch(common.noop);
           });
         });
       });
@@ -682,7 +682,7 @@ asyncTest('Throwing an error inside a rejectionHandled handler goes to' +
   const p = Promise.reject(e);
   setTimeout(function() {
     try {
-      p.catch(function() {});
+      p.catch(common.noop);
     } catch (e) {
       done(new Error('fail'));
     }
diff --git a/test/parallel/test-querystring.js b/test/parallel/test-querystring.js
index bc28eddd2a8a3a..6b636c337927de 100644
--- a/test/parallel/test-querystring.js
+++ b/test/parallel/test-querystring.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 // test using assert
@@ -72,7 +72,7 @@ extendedFunction.prototype = {a: 'b'};
 const qsWeirdObjects = [
   [{regexp: /./g}, 'regexp=', {'regexp': ''}],
   [{regexp: new RegExp('.', 'g')}, 'regexp=', {'regexp': ''}],
-  [{fn: function() {}}, 'fn=', {'fn': ''}],
+  [{fn: common.noop}, 'fn=', {'fn': ''}],
   [{fn: new Function('')}, 'fn=', {'fn': ''}],
   [{math: Math}, 'math=', {'math': ''}],
   [{e: extendedFunction}, 'e=', {'e': ''}],
diff --git a/test/parallel/test-readline-interface.js b/test/parallel/test-readline-interface.js
index e89da72a6fb738..0e7e96a565a83d 100644
--- a/test/parallel/test-readline-interface.js
+++ b/test/parallel/test-readline-interface.js
@@ -11,10 +11,10 @@ function FakeInput() {
   EventEmitter.call(this);
 }
 inherits(FakeInput, EventEmitter);
-FakeInput.prototype.resume = function() {};
-FakeInput.prototype.pause = function() {};
-FakeInput.prototype.write = function() {};
-FakeInput.prototype.end = function() {};
+FakeInput.prototype.resume = common.noop;
+FakeInput.prototype.pause = common.noop;
+FakeInput.prototype.write = common.noop;
+FakeInput.prototype.end = common.noop;
 
 function isWarned(emitter) {
   for (const name in emitter) {
@@ -541,7 +541,7 @@ function isWarned(emitter) {
     });
 
     const rl = readline.createInterface({
-      input: new Readable({ read: () => {} }),
+      input: new Readable({ read: common.mustCall() }),
       output: output,
       prompt: '$ ',
       terminal: terminal
diff --git a/test/parallel/test-regress-GH-5051.js b/test/parallel/test-regress-GH-5051.js
index ecaf55d625b815..f0a2d7aa7f1825 100644
--- a/test/parallel/test-regress-GH-5051.js
+++ b/test/parallel/test-regress-GH-5051.js
@@ -1,11 +1,11 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const agent = require('http').globalAgent;
 
 // small stub just so we can call addRequest directly
 const req = {
-  getHeader: function() {}
+  getHeader: common.noop
 };
 
 agent.maxSockets = 0;
diff --git a/test/parallel/test-repl-.save.load.js b/test/parallel/test-repl-.save.load.js
index 449dd28e90d59e..283fc142f9650a 100644
--- a/test/parallel/test-repl-.save.load.js
+++ b/test/parallel/test-repl-.save.load.js
@@ -77,7 +77,7 @@ putIn.write = function(data) {
   // make sure I get a failed to load message and not some crazy error
   assert.strictEqual(data, 'Failed to load:' + loadFile + '\n');
   // eat me to avoid work
-  putIn.write = function() {};
+  putIn.write = common.noop;
 };
 putIn.run(['.load ' + loadFile]);
 
@@ -86,7 +86,7 @@ loadFile = common.tmpDir;
 putIn.write = function(data) {
   assert.strictEqual(data, 'Failed to load:' + loadFile +
                      ' is not a valid file\n');
-  putIn.write = function() {};
+  putIn.write = common.noop;
 };
 putIn.run(['.load ' + loadFile]);
 
@@ -102,7 +102,7 @@ putIn.write = function(data) {
   // make sure I get a failed to save message and not some other error
   assert.strictEqual(data, 'Failed to save:' + invalidFileName + '\n');
   // reset to no-op
-  putIn.write = function() {};
+  putIn.write = common.noop;
 };
 
 // save it to a file
diff --git a/test/parallel/test-repl-history-perm.js b/test/parallel/test-repl-history-perm.js
index 69b973db2b79bc..4ccb139f6da738 100644
--- a/test/parallel/test-repl-history-perm.js
+++ b/test/parallel/test-repl-history-perm.js
@@ -19,7 +19,7 @@ const Duplex = require('stream').Duplex;
 // and mode 600.
 
 const stream = new Duplex();
-stream.pause = stream.resume = function() {};
+stream.pause = stream.resume = common.noop;
 // ends immediately
 stream._read = function() {
   this.push(null);
diff --git a/test/parallel/test-repl-mode.js b/test/parallel/test-repl-mode.js
index 7c113e2fc620c5..cf492a7e4b3f93 100644
--- a/test/parallel/test-repl-mode.js
+++ b/test/parallel/test-repl-mode.js
@@ -52,7 +52,7 @@ function testAutoMode() {
 
 function initRepl(mode) {
   const input = new Stream();
-  input.write = input.pause = input.resume = function() {};
+  input.write = input.pause = input.resume = common.noop;
   input.readable = true;
 
   const output = new Stream();
diff --git a/test/parallel/test-repl-setprompt.js b/test/parallel/test-repl-setprompt.js
index 8dcc4fe94452da..55e643306df70f 100644
--- a/test/parallel/test-repl-setprompt.js
+++ b/test/parallel/test-repl-setprompt.js
@@ -23,6 +23,6 @@ child.stdin.end(`e.setPrompt("${p}");${os.EOL}`);
 child.on('close', function(code, signal) {
   assert.strictEqual(code, 0);
   assert.ok(!signal);
-  const lines = data.split(/\n/);
+  const lines = data.split('\n');
   assert.strictEqual(lines.pop(), p);
 });
diff --git a/test/parallel/test-repl-tab-complete.js b/test/parallel/test-repl-tab-complete.js
index e2b9b363fa53c6..11858564ef1035 100644
--- a/test/parallel/test-repl-tab-complete.js
+++ b/test/parallel/test-repl-tab-complete.js
@@ -186,7 +186,7 @@ putIn.run(['.clear']);
 testMe.complete('require(\'', common.mustCall(function(error, data) {
   assert.strictEqual(error, null);
   repl._builtinLibs.forEach(function(lib) {
-    assert.notStrictEqual(data[0].indexOf(lib), -1, `${lib} not found`);
+    assert(data[0].includes(lib), `${lib} not found`);
   });
 }));
 
@@ -194,7 +194,7 @@ testMe.complete('require(\'n', common.mustCall(function(error, data) {
   assert.strictEqual(error, null);
   assert.strictEqual(data.length, 2);
   assert.strictEqual(data[1], 'n');
-  assert.notStrictEqual(data[0].indexOf('net'), -1);
+  assert(data[0].includes('net'));
   // It's possible to pick up non-core modules too
   data[0].forEach(function(completion) {
     if (completion)
@@ -239,9 +239,9 @@ putIn.run(['.clear']);
 
 putIn.run(['var ary = [1,2,3];']);
 testMe.complete('ary.', common.mustCall(function(error, data) {
-  assert.strictEqual(data[0].indexOf('ary.0'), -1);
-  assert.strictEqual(data[0].indexOf('ary.1'), -1);
-  assert.strictEqual(data[0].indexOf('ary.2'), -1);
+  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
@@ -249,9 +249,9 @@ 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].indexOf('obj.1'), -1);
-  assert.strictEqual(data[0].indexOf('obj.1a'), -1);
-  assert.notStrictEqual(data[0].indexOf('obj.a'), -1);
+  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
@@ -265,9 +265,9 @@ putIn.run(['.clear']);
 putIn.run(['var obj = {1:"a","1a":"b",a:"b"};']);
 
 testMe.complete(' obj.', common.mustCall((error, data) => {
-  assert.strictEqual(data[0].indexOf('obj.1'), -1);
-  assert.strictEqual(data[0].indexOf('obj.1a'), -1);
-  assert.notStrictEqual(data[0].indexOf('obj.a'), -1);
+  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
diff --git a/test/parallel/test-repl.js b/test/parallel/test-repl.js
index 2fc888de67b1f8..6fc9d020185c77 100644
--- a/test/parallel/test-repl.js
+++ b/test/parallel/test-repl.js
@@ -200,7 +200,7 @@ function error_test() {
     { client: client_unix, send: 'blah()',
       expect: `1\n${prompt_unix}` },
     // Functions should not evaluate twice (#2773)
-    { client: client_unix, send: 'var I = [1,2,3,function() {}]; I.pop()',
+    { client: client_unix, send: 'var I = [1,2,3,common.noop]; I.pop()',
       expect: '[Function]' },
     // Multiline object
     { client: client_unix, send: '{ a: ',
diff --git a/test/parallel/test-signal-handler.js b/test/parallel/test-signal-handler.js
index 004878ac741595..a040d7cc4c2145 100644
--- a/test/parallel/test-signal-handler.js
+++ b/test/parallel/test-signal-handler.js
@@ -9,7 +9,7 @@ if (common.isWindows) {
 
 console.log(`process.pid: ${process.pid}`);
 
-process.on('SIGUSR1', common.mustCall(function() {}));
+process.on('SIGUSR1', common.mustCall());
 
 process.on('SIGUSR1', common.mustCall(function() {
   setTimeout(function() {
@@ -31,5 +31,5 @@ setInterval(function() {
 // has been previously registered, and `process.listeners(SIGNAL).length === 1`
 process.on('SIGHUP', common.mustNotCall());
 process.removeAllListeners('SIGHUP');
-process.on('SIGHUP', common.mustCall(function() {}));
+process.on('SIGHUP', common.mustCall());
 process.kill(process.pid, 'SIGHUP');
diff --git a/test/parallel/test-stdin-script-child.js b/test/parallel/test-stdin-script-child.js
index 81eb3ea5b4aaac..f215682fe4c345 100644
--- a/test/parallel/test-stdin-script-child.js
+++ b/test/parallel/test-stdin-script-child.js
@@ -18,7 +18,7 @@ child.stdout.on('data', function(c) {
 
 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) {
diff --git a/test/parallel/test-stream-big-push.js b/test/parallel/test-stream-big-push.js
index 9083820d42b546..849014ad707823 100644
--- a/test/parallel/test-stream-big-push.js
+++ b/test/parallel/test-stream-big-push.js
@@ -28,7 +28,7 @@ function _read() {
 
 r._read = common.mustCall(_read, 3);
 
-r.on('end', common.mustCall(function() {}));
+r.on('end', common.mustCall());
 
 // push some data in to start.
 // we've never gotten any read event at this point.
diff --git a/test/parallel/test-stream-end-paused.js b/test/parallel/test-stream-end-paused.js
index 4b585fdb999890..007066242b00d1 100644
--- a/test/parallel/test-stream-end-paused.js
+++ b/test/parallel/test-stream-end-paused.js
@@ -19,7 +19,7 @@ stream.on('data', function() {
 stream.pause();
 
 setTimeout(common.mustCall(function() {
-  stream.on('end', common.mustCall(function() {}));
+  stream.on('end', common.mustCall());
   stream.resume();
 }), 1);
 
diff --git a/test/parallel/test-stream-events-prepend.js b/test/parallel/test-stream-events-prepend.js
index 63d9a32807c5d5..254d9a3690aee5 100644
--- a/test/parallel/test-stream-events-prepend.js
+++ b/test/parallel/test-stream-events-prepend.js
@@ -23,7 +23,7 @@ Readable.prototype._read = function() {
 };
 
 const w = new Writable();
-w.on('pipe', common.mustCall(function() {}));
+w.on('pipe', common.mustCall());
 
 const r = new Readable();
 r.pipe(w);
diff --git a/test/parallel/test-stream-pipe-after-end.js b/test/parallel/test-stream-pipe-after-end.js
index 79ebb2c0e0990d..fe41d54cabc5f0 100644
--- a/test/parallel/test-stream-pipe-after-end.js
+++ b/test/parallel/test-stream-pipe-after-end.js
@@ -42,11 +42,11 @@ const piper = new TestReadable();
 piper.read();
 
 setTimeout(common.mustCall(function() {
-  ender.on('end', 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(function() {}));
+  w.on('finish', common.mustCall());
   piper.pipe(w);
 }), 1);
diff --git a/test/parallel/test-stream-pipe-error-handling.js b/test/parallel/test-stream-pipe-error-handling.js
index db79f6e5f36c70..0f6f855a43ae80 100644
--- a/test/parallel/test-stream-pipe-error-handling.js
+++ b/test/parallel/test-stream-pipe-error-handling.js
@@ -79,11 +79,11 @@ const Stream = require('stream').Stream;
     }), 1);
   });
 
-  w.on('error', common.mustCall(function() {}));
-  w._write = function() {};
+  w.on('error', common.mustCall());
+  w._write = common.noop;
 
   r.pipe(w);
   // Removing some OTHER random listener should not do anything
-  w.removeListener('error', function() {});
+  w.removeListener('error', common.noop);
   removed = true;
 }
diff --git a/test/parallel/test-stream-readable-event.js b/test/parallel/test-stream-readable-event.js
index 626858ab914857..422c79d1c1b35d 100644
--- a/test/parallel/test-stream-readable-event.js
+++ b/test/parallel/test-stream-readable-event.js
@@ -19,7 +19,7 @@ const Readable = require('stream').Readable;
   setTimeout(function() {
     // we're testing what we think we are
     assert(!r._readableState.reading);
-    r.on('readable', common.mustCall(function() {}));
+    r.on('readable', common.mustCall());
   }, 1);
 }
 
@@ -39,7 +39,7 @@ const Readable = require('stream').Readable;
   setTimeout(function() {
     // assert we're testing what we think we are
     assert(r._readableState.reading);
-    r.on('readable', common.mustCall(function() {}));
+    r.on('readable', common.mustCall());
   }, 1);
 }
 
@@ -59,6 +59,6 @@ const Readable = require('stream').Readable;
   setTimeout(function() {
     // assert we're testing what we think we are
     assert(!r._readableState.reading);
-    r.on('readable', common.mustCall(function() {}));
+    r.on('readable', common.mustCall());
   }, 1);
 }
diff --git a/test/parallel/test-stream-wrap.js b/test/parallel/test-stream-wrap.js
index dbcb58a98cd8b2..5312596afac40d 100644
--- a/test/parallel/test-stream-wrap.js
+++ b/test/parallel/test-stream-wrap.js
@@ -28,4 +28,4 @@ function testShutdown(callback) {
   req.handle.shutdown(req);
 }
 
-testShutdown(common.mustCall(function() {}));
+testShutdown(common.mustCall());
diff --git a/test/pummel/test-stream2-basic.js b/test/parallel/test-stream2-basic.js
similarity index 90%
rename from test/pummel/test-stream2-basic.js
rename to test/parallel/test-stream2-basic.js
index 46cc2f63086fbe..1bea98ff136799 100644
--- a/test/pummel/test-stream2-basic.js
+++ b/test/parallel/test-stream2-basic.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const R = require('_stream_readable');
 const assert = require('assert');
 
@@ -85,9 +85,6 @@ function run() {
   const fn = next[1];
   console.log('# %s', name);
   fn({
-    same: assert.deepStrictEqual,
-    ok: assert,
-    equal: assert.strictEqual,
     end: function() {
       count--;
       run();
@@ -125,7 +122,7 @@ test('a most basic test', function(t) {
                    'xxxxxxxxxxxxxxxxxxxxx' ];
 
   r.on('end', function() {
-    t.same(reads, expect);
+    assert.deepStrictEqual(reads, expect);
     t.end();
   });
 
@@ -158,7 +155,7 @@ test('pipe', function(t) {
   const w = new TestWriter();
 
   w.on('end', function(received) {
-    t.same(received, expect);
+    assert.deepStrictEqual(received, expect);
     t.end();
   });
 
@@ -189,10 +186,10 @@ test('pipe', function(t) {
     w[0].on('write', function() {
       if (--writes === 0) {
         r.unpipe();
-        t.equal(r._readableState.pipes, null);
+        assert.strictEqual(r._readableState.pipes, null);
         w[0].end();
         r.pipe(w[1]);
-        t.equal(r._readableState.pipes, w[1]);
+        assert.strictEqual(r._readableState.pipes, w[1]);
       }
     });
 
@@ -201,18 +198,18 @@ test('pipe', function(t) {
     let ended0 = false;
     let ended1 = false;
     w[0].on('end', function(results) {
-      t.equal(ended0, false);
+      assert.strictEqual(ended0, false);
       ended0 = true;
       ended++;
-      t.same(results, expect[0]);
+      assert.deepStrictEqual(results, expect[0]);
     });
 
     w[1].on('end', function(results) {
-      t.equal(ended1, false);
+      assert.strictEqual(ended1, false);
       ended1 = true;
       ended++;
-      t.equal(ended, 2);
-      t.same(results, expect[1]);
+      assert.strictEqual(ended, 2);
+      assert.deepStrictEqual(results, expect[1]);
       t.end();
     });
 
@@ -239,11 +236,11 @@ test('multipipe', function(t) {
 
   let c = 2;
   w[0].on('end', function(received) {
-    t.same(received, expect, 'first');
+    assert.deepStrictEqual(received, expect, 'first');
     if (--c === 0) t.end();
   });
   w[1].on('end', function(received) {
-    t.same(received, expect, 'second');
+    assert.deepStrictEqual(received, expect, 'second');
     if (--c === 0) t.end();
   });
 
@@ -284,13 +281,13 @@ test('multipipe', function(t) {
 
     w[0].on('end', function(results) {
       ended++;
-      t.same(results, expect[0]);
+      assert.deepStrictEqual(results, expect[0]);
     });
 
     w[1].on('end', function(results) {
       ended++;
-      t.equal(ended, 2);
-      t.same(results, expect[1]);
+      assert.strictEqual(ended, 2);
+      assert.deepStrictEqual(results, expect[1]);
       t.end();
     });
 
@@ -300,10 +297,8 @@ test('multipipe', function(t) {
 });
 
 test('back pressure respected', function(t) {
-  function noop() {}
-
   const r = new R({ objectMode: true });
-  r._read = noop;
+  r._read = common.mustNotCall();
   let counter = 0;
   r.push(['one']);
   r.push(['two']);
@@ -321,7 +316,7 @@ test('back pressure respected', function(t) {
       r.pipe(w3);
     });
   };
-  w1.end = noop;
+  w1.end = common.mustNotCall();
 
   r.pipe(w1);
 
@@ -347,7 +342,7 @@ test('back pressure respected', function(t) {
 
     return false;
   };
-  w2.end = noop;
+  w2.end = common.mustCall();
 
   let w3 = new R();
   w3.write = function(chunk) {
@@ -380,7 +375,7 @@ test('read(0) for ended streams', function(t) {
   const r = new R();
   let written = false;
   let ended = false;
-  r._read = function(n) {};
+  r._read = common.mustNotCall();
 
   r.push(Buffer.from('foo'));
   r.push(null);
@@ -443,16 +438,16 @@ test('adding readable triggers data flow', function(t) {
   });
 
   r.on('end', function() {
-    t.equal(readCalled, 3);
-    t.ok(onReadable);
+    assert.strictEqual(readCalled, 3);
+    assert.ok(onReadable);
     t.end();
   });
 });
 
 test('chainable', function(t) {
   const r = new R();
-  r._read = function() {};
+  r._read = common.mustCall();
   const r2 = r.setEncoding('utf8').pause().resume().pause();
-  t.equal(r, r2);
+  assert.strictEqual(r, r2);
   t.end();
 });
diff --git a/test/parallel/test-stream2-finish-pipe.js b/test/parallel/test-stream2-finish-pipe.js
index 87edf5a5fa6437..d3e84eb6b47398 100644
--- a/test/parallel/test-stream2-finish-pipe.js
+++ b/test/parallel/test-stream2-finish-pipe.js
@@ -1,7 +1,6 @@
 'use strict';
 require('../common');
 const stream = require('stream');
-const Buffer = require('buffer').Buffer;
 
 const r = new stream.Readable();
 r._read = function(size) {
diff --git a/test/parallel/test-stream2-objects.js b/test/parallel/test-stream2-objects.js
index cab838fbfc9acb..cea3a4845105df 100644
--- a/test/parallel/test-stream2-objects.js
+++ b/test/parallel/test-stream2-objects.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const Readable = require('_stream_readable');
 const Writable = require('_stream_writable');
 const assert = require('assert');
@@ -54,7 +54,7 @@ function toArray(callback) {
 
 function fromArray(list) {
   const r = new Readable({ objectMode: true });
-  r._read = noop;
+  r._read = common.mustNotCall();
   list.forEach(function(chunk) {
     r.push(chunk);
   });
@@ -63,8 +63,6 @@ function fromArray(list) {
   return r;
 }
 
-function noop() {}
-
 test('can read objects from stream', function(t) {
   const r = fromArray([{ one: '1'}, { two: '2' }]);
 
@@ -144,7 +142,7 @@ test('can read strings as objects', function(t) {
   const r = new Readable({
     objectMode: true
   });
-  r._read = noop;
+  r._read = common.mustNotCall();
   const list = ['one', 'two', 'three'];
   list.forEach(function(str) {
     r.push(str);
@@ -162,7 +160,7 @@ test('read(0) for object streams', function(t) {
   const r = new Readable({
     objectMode: true
   });
-  r._read = noop;
+  r._read = common.mustNotCall();
 
   r.push('foobar');
   r.push(null);
@@ -178,7 +176,7 @@ test('falsey values', function(t) {
   const r = new Readable({
     objectMode: true
   });
-  r._read = noop;
+  r._read = common.mustNotCall();
 
   r.push(false);
   r.push(0);
@@ -229,7 +227,7 @@ test('high watermark push', function(t) {
     highWaterMark: 6,
     objectMode: true
   });
-  r._read = function(n) {};
+  r._read = common.mustNotCall();
   for (let i = 0; i < 6; i++) {
     const bool = r.push(i);
     assert.strictEqual(bool, i !== 5);
diff --git a/test/parallel/test-stream2-read-sync-stack.js b/test/parallel/test-stream2-read-sync-stack.js
index d4e11af3b8f7c1..314dc375f20b3b 100644
--- a/test/parallel/test-stream2-read-sync-stack.js
+++ b/test/parallel/test-stream2-read-sync-stack.js
@@ -20,6 +20,6 @@ r.on('readable', function onReadable() {
   r.read(N * 2);
 });
 
-r.on('end', common.mustCall(function() {}));
+r.on('end', common.mustCall());
 
 r.read(0);
diff --git a/test/parallel/test-stream2-readable-legacy-drain.js b/test/parallel/test-stream2-readable-legacy-drain.js
index d6db6ba232c693..ebacbc3939c4f1 100644
--- a/test/parallel/test-stream2-readable-legacy-drain.js
+++ b/test/parallel/test-stream2-readable-legacy-drain.js
@@ -12,7 +12,7 @@ r._read = function(n) {
   return r.push(++reads === N ? null : Buffer.allocUnsafe(1));
 };
 
-r.on('end', common.mustCall(function() {}));
+r.on('end', common.mustCall());
 
 const w = new Stream();
 w.writable = true;
@@ -29,7 +29,7 @@ function drain() {
   w.emit('drain');
 }
 
-w.end = common.mustCall(function() {});
+w.end = common.mustCall();
 
 // Just for kicks, let's mess with the drain count.
 // This verifies that even if it gets negative in the
diff --git a/test/parallel/test-stream2-readable-non-empty-end.js b/test/parallel/test-stream2-readable-non-empty-end.js
index 46481fe1dcda4c..0df461eb5f2919 100644
--- a/test/parallel/test-stream2-readable-non-empty-end.js
+++ b/test/parallel/test-stream2-readable-non-empty-end.js
@@ -40,7 +40,7 @@ test.read(0);
 function next() {
   // now let's make 'end' happen
   test.removeListener('end', thrower);
-  test.on('end', common.mustCall(function() {}));
+  test.on('end', common.mustCall());
 
   // one to get the last byte
   let r = test.read();
diff --git a/test/parallel/test-stream2-readable-wrap-empty.js b/test/parallel/test-stream2-readable-wrap-empty.js
index 5b2dae3c5327fa..3282f5da6cfae1 100644
--- a/test/parallel/test-stream2-readable-wrap-empty.js
+++ b/test/parallel/test-stream2-readable-wrap-empty.js
@@ -5,13 +5,13 @@ const Readable = require('_stream_readable');
 const EE = require('events').EventEmitter;
 
 const oldStream = new EE();
-oldStream.pause = function() {};
-oldStream.resume = function() {};
+oldStream.pause = common.noop;
+oldStream.resume = common.noop;
 
 const newStream = new Readable().wrap(oldStream);
 
 newStream
-  .on('readable', function() {})
-  .on('end', common.mustCall(function() {}));
+  .on('readable', common.noop)
+  .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 aa091dc3d806f0..f7ae81c4ba83b5 100644
--- a/test/parallel/test-stream2-readable-wrap.js
+++ b/test/parallel/test-stream2-readable-wrap.js
@@ -12,7 +12,7 @@ function runTest(highWaterMark, objectMode, produce) {
                            objectMode: objectMode });
   assert.strictEqual(r, r.wrap(old));
 
-  r.on('end', common.mustCall(function() {}));
+  r.on('end', common.mustCall());
 
   old.pause = function() {
     old.emit('pause');
diff --git a/test/parallel/test-stream2-writable.js b/test/parallel/test-stream2-writable.js
index dd470db9624050..136d4dc3dcef7e 100644
--- a/test/parallel/test-stream2-writable.js
+++ b/test/parallel/test-stream2-writable.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const W = require('_stream_writable');
 const D = require('_stream_duplex');
 const assert = require('assert');
@@ -283,7 +283,7 @@ test('encoding should be ignored for buffers', function(t) {
 
 test('writables are not pipable', function(t) {
   const w = new W();
-  w._write = function() {};
+  w._write = common.noop;
   let gotError = false;
   w.on('error', function() {
     gotError = true;
@@ -295,8 +295,8 @@ test('writables are not pipable', function(t) {
 
 test('duplexes are pipable', function(t) {
   const d = new D();
-  d._read = function() {};
-  d._write = function() {};
+  d._read = common.noop;
+  d._write = common.noop;
   let gotError = false;
   d.on('error', function() {
     gotError = true;
@@ -308,7 +308,7 @@ test('duplexes are pipable', function(t) {
 
 test('end(chunk) two times is an error', function(t) {
   const w = new W();
-  w._write = function() {};
+  w._write = common.noop;
   let gotError = false;
   w.on('error', function(er) {
     gotError = true;
diff --git a/test/parallel/test-timers-uncaught-exception.js b/test/parallel/test-timers-uncaught-exception.js
index 4304a984189b81..75d264a1ec86fa 100644
--- a/test/parallel/test-timers-uncaught-exception.js
+++ b/test/parallel/test-timers-uncaught-exception.js
@@ -10,7 +10,7 @@ setTimeout(common.mustCall(function() {
 }), 1);
 
 // ...but the second one should still run
-setTimeout(common.mustCall(function() {}), 1);
+setTimeout(common.mustCall(), 1);
 
 function uncaughtException(err) {
   assert.strictEqual(err.message, errorMsg);
diff --git a/test/parallel/test-timers-unref-call.js b/test/parallel/test-timers-unref-call.js
index 5384441838763a..8dfda0c5a85e39 100644
--- a/test/parallel/test-timers-unref-call.js
+++ b/test/parallel/test-timers-unref-call.js
@@ -1,11 +1,11 @@
 'use strict';
-require('../common');
+const common = require('../common');
 
 const Timer = process.binding('timer_wrap').Timer;
 Timer.now = function() { return ++Timer.now.ticks; };
 Timer.now.ticks = 0;
 
-const t = setInterval(function() {}, 1);
+const t = setInterval(common.noop, 1);
 const o = { _idleStart: 0, _idleTimeout: 1 };
 t.unref.call(o);
 
diff --git a/test/parallel/test-timers-unref-remove-other-unref-timers.js b/test/parallel/test-timers-unref-remove-other-unref-timers.js
index 7b4f55abe79a82..221f5bb6fd93ab 100644
--- a/test/parallel/test-timers-unref-remove-other-unref-timers.js
+++ b/test/parallel/test-timers-unref-remove-other-unref-timers.js
@@ -29,4 +29,4 @@ timers.enroll(foo, 50);
 timers._unrefActive(foo);
 
 // Keep the process open.
-setTimeout(function() {}, 100);
+setTimeout(common.noop, 100);
diff --git a/test/parallel/test-timers-unref.js b/test/parallel/test-timers-unref.js
index 2bde08f914d790..aeccacece885a4 100644
--- a/test/parallel/test-timers-unref.js
+++ b/test/parallel/test-timers-unref.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 let interval_fired = false;
@@ -13,11 +13,11 @@ const LONG_TIME = 10 * 1000;
 const SHORT_TIME = 100;
 
 assert.doesNotThrow(function() {
-  setTimeout(function() {}, 10).unref().ref().unref();
+  setTimeout(common.noop, 10).unref().ref().unref();
 }, 'ref and unref are chainable');
 
 assert.doesNotThrow(function() {
-  setInterval(function() {}, 10).unref().ref().unref();
+  setInterval(common.noop, 10).unref().ref().unref();
 }, 'ref and unref are chainable');
 
 setInterval(function() {
@@ -56,7 +56,7 @@ setInterval(function() {
 
 // Should not assert on args.Holder()->InternalFieldCount() > 0. See #4261.
 {
-  const t = setInterval(function() {}, 1);
+  const t = setInterval(common.noop, 1);
   process.nextTick(t.unref.bind({}));
   process.nextTick(t.unref.bind(t));
 }
diff --git a/test/parallel/test-timers-user-call.js b/test/parallel/test-timers-user-call.js
new file mode 100644
index 00000000000000..4ff24e688b5aa3
--- /dev/null
+++ b/test/parallel/test-timers-user-call.js
@@ -0,0 +1,40 @@
+// Make sure `setTimeout()` and friends don't throw if the user-supplied
+// function has .call() and .apply() monkey-patched to undesirable values.
+
+// Refs: https://github.com/nodejs/node/issues/12956
+
+'use strict';
+
+const common = require('../common');
+
+{
+  const fn = common.mustCall(10);
+  fn.call = 'not a function';
+  fn.apply = 'also not a function';
+  setTimeout(fn, 1);
+  setTimeout(fn, 1, 'oneArg');
+  setTimeout(fn, 1, 'two', 'args');
+  setTimeout(fn, 1, 'three', '(3)', 'args');
+  setTimeout(fn, 1, 'more', 'than', 'three', 'args');
+
+  setImmediate(fn, 1);
+  setImmediate(fn, 1, 'oneArg');
+  setImmediate(fn, 1, 'two', 'args');
+  setImmediate(fn, 1, 'three', '(3)', 'args');
+  setImmediate(fn, 1, 'more', 'than', 'three', 'args');
+}
+
+{
+  const testInterval = (...args) => {
+    const fn = common.mustCall(() => { clearInterval(interval); });
+    fn.call = 'not a function';
+    fn.apply = 'also not a function';
+    const interval = setInterval(fn, 1, ...args);
+  };
+
+  testInterval();
+  testInterval('oneArg');
+  testInterval('two', 'args');
+  testInterval('three', '(3)', 'args');
+  testInterval('more', 'than', 'three', 'args');
+}
diff --git a/test/parallel/test-timers-zero-timeout.js b/test/parallel/test-timers-zero-timeout.js
index 5d72cfe85fb870..c3edd92260e2db 100644
--- a/test/parallel/test-timers-zero-timeout.js
+++ b/test/parallel/test-timers-zero-timeout.js
@@ -5,7 +5,7 @@ const assert = require('assert');
 // https://github.com/joyent/node/issues/2079 - zero timeout drops extra args
 {
   setTimeout(common.mustCall(f), 0, 'foo', 'bar', 'baz');
-  setTimeout(function() {}, 0);
+  setTimeout(common.noop, 0);
 
   function f(a, b, c) {
     assert.strictEqual(a, 'foo');
diff --git a/test/parallel/test-timers.js b/test/parallel/test-timers.js
index 7ace816c2ceaeb..daabfcf29ddf19 100644
--- a/test/parallel/test-timers.js
+++ b/test/parallel/test-timers.js
@@ -56,5 +56,5 @@ setTimeout(common.mustCall(function() {
 }), 2);
 
 // Test 10 ms timeout separately.
-setTimeout(common.mustCall(function() {}), 10);
+setTimeout(common.mustCall(), 10);
 setInterval(common.mustCall(function() { clearInterval(this); }), 10);
diff --git a/test/parallel/test-tls-alert-handling.js b/test/parallel/test-tls-alert-handling.js
index 5268f520f13958..d089ad223b1fd8 100644
--- a/test/parallel/test-tls-alert-handling.js
+++ b/test/parallel/test-tls-alert-handling.js
@@ -11,12 +11,13 @@ if (!common.hasCrypto) {
   return;
 }
 
-const tls = require('tls');
-const net = require('net');
 const fs = require('fs');
+const net = require('net');
+const path = require('path');
+const tls = require('tls');
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 function loadPEM(n) {
diff --git a/test/parallel/test-tls-alert.js b/test/parallel/test-tls-alert.js
index 4b9fba55a27efc..2b762b6cc48fc7 100644
--- a/test/parallel/test-tls-alert.js
+++ b/test/parallel/test-tls-alert.js
@@ -1,6 +1,5 @@
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 
 if (!common.opensslCli) {
   common.skip('node compiled without OpenSSL CLI.');
@@ -11,15 +10,17 @@ if (!common.hasCrypto) {
   common.skip('missing crypto');
   return;
 }
-const tls = require('tls');
 
+const assert = require('assert');
+const { spawn } = require('child_process');
 const fs = require('fs');
-const spawn = require('child_process').spawn;
+const path = require('path');
+const tls = require('tls');
 
 let success = false;
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 function loadPEM(n) {
diff --git a/test/parallel/test-tls-alpn-server-client.js b/test/parallel/test-tls-alpn-server-client.js
index a397550d96863a..3d3453d32fdb82 100644
--- a/test/parallel/test-tls-alpn-server-client.js
+++ b/test/parallel/test-tls-alpn-server-client.js
@@ -14,10 +14,11 @@ if (!process.features.tls_alpn || !process.features.tls_npn) {
 
 const assert = require('assert');
 const fs = require('fs');
+const path = require('path');
 const tls = require('tls');
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 function loadPEM(n) {
diff --git a/test/parallel/test-tls-cert-regression.js b/test/parallel/test-tls-cert-regression.js
index ff5827bcf844ee..3cf7423b7d9807 100644
--- a/test/parallel/test-tls-cert-regression.js
+++ b/test/parallel/test-tls-cert-regression.js
@@ -42,5 +42,5 @@ function test(cert, key, cb) {
 }
 
 test(cert, key, common.mustCall(function() {
-  test(Buffer.from(cert), Buffer.from(key), common.mustCall(function() {}));
+  test(Buffer.from(cert), Buffer.from(key), common.mustCall());
 }));
diff --git a/test/parallel/test-tls-client-verify.js b/test/parallel/test-tls-client-verify.js
index 643126488da869..d10c0e16c548fe 100644
--- a/test/parallel/test-tls-client-verify.js
+++ b/test/parallel/test-tls-client-verify.js
@@ -1,16 +1,17 @@
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 
 if (!common.hasCrypto) {
   common.skip('missing crypto');
   return;
 }
-const tls = require('tls');
 
+const assert = require('assert');
 const fs = require('fs');
+const path = require('path');
+const tls = require('tls');
 
-const hosterr = /Hostname\/IP doesn't match certificate's altnames/g;
+const hosterr = /Hostname\/IP doesn't match certificate's altnames/;
 const testCases =
   [{ ca: ['ca1-cert'],
      key: 'agent2-key',
@@ -44,7 +45,7 @@ const testCases =
   ];
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 
diff --git a/test/parallel/test-tls-cnnic-whitelist.js b/test/parallel/test-tls-cnnic-whitelist.js
index a33e631ddf7437..084531748656e2 100644
--- a/test/parallel/test-tls-cnnic-whitelist.js
+++ b/test/parallel/test-tls-cnnic-whitelist.js
@@ -8,9 +8,9 @@ if (!common.hasCrypto) {
 }
 
 const assert = require('assert');
-const tls = require('tls');
 const fs = require('fs');
 const path = require('path');
+const tls = require('tls');
 
 function filenamePEM(n) {
   return path.join(common.fixturesDir, 'keys', `${n}.pem`);
diff --git a/test/parallel/test-tls-connect-simple.js b/test/parallel/test-tls-connect-simple.js
index f169773c77a26e..84cbe633eda7c8 100644
--- a/test/parallel/test-tls-connect-simple.js
+++ b/test/parallel/test-tls-connect-simple.js
@@ -18,8 +18,8 @@ const options = {
 
 const server = tls.Server(options, common.mustCall(function(socket) {
   if (++serverConnected === 2) {
-    server.close(common.mustCall(function() {}));
-    server.on('close', common.mustCall(function() {}));
+    server.close(common.mustCall());
+    server.on('close', common.mustCall());
   }
 }, 2));
 
diff --git a/test/parallel/test-tls-connect.js b/test/parallel/test-tls-connect.js
index 082e2e48a9dcc0..0a6af35e7d1f5a 100644
--- a/test/parallel/test-tls-connect.js
+++ b/test/parallel/test-tls-connect.js
@@ -20,7 +20,7 @@ const path = require('path');
   const options = {cert: cert, key: key, port: common.PORT};
   const conn = tls.connect(options, common.fail);
 
-  conn.on('error', common.mustCall(function() {}));
+  conn.on('error', common.mustCall());
 }
 
 // SSL_accept/SSL_connect error handling
@@ -37,5 +37,5 @@ const path = require('path');
     assert.ok(false); // callback should never be executed
   });
 
-  conn.on('error', common.mustCall(function() {}));
+  conn.on('error', common.mustCall());
 }
diff --git a/test/parallel/test-tls-delayed-attach-error.js b/test/parallel/test-tls-delayed-attach-error.js
index c7b6bf33127a5e..35da6d0e42efed 100644
--- a/test/parallel/test-tls-delayed-attach-error.js
+++ b/test/parallel/test-tls-delayed-attach-error.js
@@ -23,7 +23,7 @@ const server = net.createServer(common.mustCall(function(c) {
       secureContext: tls.createSecureContext(options)
     });
 
-    s.on('_tlsError', common.mustCall(function() {}));
+    s.on('_tlsError', common.mustCall());
 
     s.on('close', function() {
       server.close();
diff --git a/test/parallel/test-tls-env-extra-ca.js b/test/parallel/test-tls-env-extra-ca.js
index 8c561d921cb802..e2de272184e5f4 100644
--- a/test/parallel/test-tls-env-extra-ca.js
+++ b/test/parallel/test-tls-env-extra-ca.js
@@ -9,18 +9,19 @@ if (!common.hasCrypto) {
 }
 
 const assert = require('assert');
+const fs = require('fs');
 const tls = require('tls');
+
 const fork = require('child_process').fork;
-const fs = require('fs');
 
 if (process.env.CHILD) {
   const copts = {
     port: process.env.PORT,
-    checkServerIdentity: function() {},
+    checkServerIdentity: common.mustCall(),
   };
-  const client = tls.connect(copts, function() {
+  const client = tls.connect(copts, common.mustCall(function() {
     client.end('hi');
-  });
+  }));
   return;
 }
 
@@ -29,10 +30,10 @@ const options = {
   cert: fs.readFileSync(`${common.fixturesDir}/keys/agent1-cert.pem`),
 };
 
-const server = tls.createServer(options, function(s) {
+const server = tls.createServer(options, common.mustCall(function(s) {
   s.end('bye');
   server.close();
-}).listen(0, common.mustCall(function() {
+})).listen(0, common.mustCall(function() {
   const env = {
     CHILD: 'yes',
     PORT: this.address().port,
diff --git a/test/parallel/test-tls-interleave.js b/test/parallel/test-tls-interleave.js
index 60d778b77de268..1bbba9aff73d44 100644
--- a/test/parallel/test-tls-interleave.js
+++ b/test/parallel/test-tls-interleave.js
@@ -38,7 +38,7 @@ const server = tls.createServer(options, function(c) {
 
       data = data.toString();
       while (data.length !== 0) {
-        assert.strictEqual(data.indexOf(writes[receivedWrites]), 0);
+        assert(data.startsWith(writes[receivedWrites]));
         data = data.slice(writes[receivedWrites].length);
 
         if (++receivedWrites === writes.length) {
diff --git a/test/parallel/test-tls-invoke-queued.js b/test/parallel/test-tls-invoke-queued.js
index 08053e026249e6..6bbf2369ff18a0 100644
--- a/test/parallel/test-tls-invoke-queued.js
+++ b/test/parallel/test-tls-invoke-queued.js
@@ -1,31 +1,31 @@
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 
 if (!common.hasCrypto) {
   common.skip('missing crypto');
   return;
 }
-const tls = require('tls');
 
+const assert = require('assert');
 const fs = require('fs');
-
+const tls = require('tls');
 
 let received = '';
 
 const server = tls.createServer({
   key: fs.readFileSync(`${common.fixturesDir}/keys/agent1-key.pem`),
   cert: fs.readFileSync(`${common.fixturesDir}/keys/agent1-cert.pem`)
-}, function(c) {
-  c._write('hello ', null, function() {
-    c._write('world!', null, function() {
+}, common.mustCall(function(c) {
+  c._write('hello ', null, common.mustCall(function() {
+    c._write('world!', null, common.mustCall(function() {
       c.destroy();
-    });
-    c._write(' gosh', null, function() {});
-  });
+    }));
+    // Data on next _write() will be written but callback will not be invoked
+    c._write(' gosh', null, common.mustNotCall());
+  }));
 
   server.close();
-}).listen(0, common.mustCall(function() {
+})).listen(0, common.mustCall(function() {
   const c = tls.connect(this.address().port, {
     rejectUnauthorized: false
   }, common.mustCall(function() {
diff --git a/test/parallel/test-tls-legacy-onselect.js b/test/parallel/test-tls-legacy-onselect.js
index 9af65c43a0661c..6540639cc93e7c 100644
--- a/test/parallel/test-tls-legacy-onselect.js
+++ b/test/parallel/test-tls-legacy-onselect.js
@@ -10,7 +10,7 @@ const net = require('net');
 
 const server = net.Server(common.mustCall(function(raw) {
   const pair = tls.createSecurePair(null, true, false, false);
-  pair.on('error', function() {});
+  pair.on('error', common.noop);
   pair.ssl.setSNICallback(common.mustCall(function() {
     raw.destroy();
     server.close();
diff --git a/test/parallel/test-tls-npn-server-client.js b/test/parallel/test-tls-npn-server-client.js
index cdaeb7cf4ccb33..7cb8723ff5f9e6 100644
--- a/test/parallel/test-tls-npn-server-client.js
+++ b/test/parallel/test-tls-npn-server-client.js
@@ -1,22 +1,24 @@
 'use strict';
+
+const common = require('../common');
+
 if (!process.features.tls_npn) {
   common.skip('Skipping because node compiled without NPN feature of OpenSSL.');
   return;
 }
 
-const common = require('../common');
-const assert = require('assert');
-const fs = require('fs');
-
 if (!common.hasCrypto) {
   common.skip('missing crypto');
   return;
 }
-const tls = require('tls');
 
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const tls = require('tls');
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 function loadPEM(n) {
diff --git a/test/parallel/test-tls-passphrase.js b/test/parallel/test-tls-passphrase.js
index f2f6f5ccdacda8..f8fc4c9313d9da 100644
--- a/test/parallel/test-tls-passphrase.js
+++ b/test/parallel/test-tls-passphrase.js
@@ -39,14 +39,14 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'passphrase',
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: rawKey,
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
@@ -54,7 +54,7 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'ignored',
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   // Buffer[]
   tls.connect({
@@ -63,14 +63,14 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'passphrase',
     cert: [cert],
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: [rawKey],
     cert: [cert],
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
@@ -78,7 +78,7 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'ignored',
     cert: [cert],
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   // string
   tls.connect({
@@ -87,14 +87,14 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'passphrase',
     cert: cert.toString(),
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: rawKey.toString(),
     cert: cert.toString(),
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
@@ -102,7 +102,7 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'ignored',
     cert: cert.toString(),
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   // String[]
   tls.connect({
@@ -111,14 +111,14 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'passphrase',
     cert: [cert.toString()],
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: [rawKey.toString()],
     cert: [cert.toString()],
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
@@ -126,7 +126,7 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'ignored',
     cert: [cert.toString()],
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   // Object[]
   tls.connect({
@@ -134,7 +134,7 @@ server.listen(0, common.mustCall(function() {
     key: [{pem: passKey, passphrase: 'passphrase'}],
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
@@ -142,7 +142,7 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'ignored',
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
@@ -150,28 +150,28 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'passphrase',
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: [{pem: passKey.toString(), passphrase: 'passphrase'}],
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: [{pem: rawKey, passphrase: 'ignored'}],
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: [{pem: rawKey.toString(), passphrase: 'ignored'}],
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
@@ -179,7 +179,7 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'ignored',
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
@@ -187,21 +187,21 @@ server.listen(0, common.mustCall(function() {
     passphrase: 'ignored',
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: [{pem: rawKey}],
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 
   tls.connect({
     port: this.address().port,
     key: [{pem: rawKey.toString()}],
     cert: cert,
     rejectUnauthorized: false
-  }, common.mustCall(function() {}));
+  }, common.mustCall());
 })).unref();
 
 const errMessagePassword = /bad password read/;
diff --git a/test/parallel/test-tls-server-verify.js b/test/parallel/test-tls-server-verify.js
index eba57d65de295e..2ecc3cc5a015d2 100644
--- a/test/parallel/test-tls-server-verify.js
+++ b/test/parallel/test-tls-server-verify.js
@@ -6,6 +6,11 @@ if (!common.opensslCli) {
   return;
 }
 
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+  return;
+}
+
 // 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
 // with various keys. Depending on the certificate authority and other
@@ -14,6 +19,14 @@ if (!common.opensslCli) {
 // - accepted and "unauthorized", or
 // - accepted and "authorized".
 
+const assert = require('assert');
+const { spawn } = require('child_process');
+const { SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION } =
+  require('crypto').constants;
+const fs = require('fs');
+const path = require('path');
+const tls = require('tls');
+
 const testCases =
   [{ title: 'Do not request certs. Everyone is unauthorized.',
      requestCert: false,
@@ -98,22 +111,9 @@ const testCases =
   }
   ];
 
-if (!common.hasCrypto) {
-  common.skip('missing crypto');
-  return;
-}
-const tls = require('tls');
-
-const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION =
-  require('crypto').constants.SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
-
-const assert = require('assert');
-const fs = require('fs');
-const spawn = require('child_process').spawn;
-
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 
@@ -196,7 +196,7 @@ function runClient(prefix, port, options, cb) {
   client.stdout.on('data', function(d) {
     out += d;
 
-    if (!goodbye && /_unauthed/g.test(out)) {
+    if (!goodbye && /_unauthed/.test(out)) {
       console.error(`${prefix}  * unauthed`);
       goodbye = true;
       client.kill();
@@ -204,7 +204,7 @@ function runClient(prefix, port, options, cb) {
       rejected = false;
     }
 
-    if (!goodbye && /_authed/g.test(out)) {
+    if (!goodbye && /_authed/.test(out)) {
       console.error(`${prefix}  * authed`);
       goodbye = true;
       client.kill();
diff --git a/test/parallel/test-tls-sni-option.js b/test/parallel/test-tls-sni-option.js
index 632419701004a6..e1ecfb9620f5ef 100644
--- a/test/parallel/test-tls-sni-option.js
+++ b/test/parallel/test-tls-sni-option.js
@@ -1,21 +1,24 @@
 'use strict';
+
+const common = require('../common');
+
 if (!process.features.tls_sni) {
   common.skip('node compiled without OpenSSL or with old OpenSSL version.');
   return;
 }
 
-const common = require('../common');
-const assert = require('assert');
-const fs = require('fs');
-
 if (!common.hasCrypto) {
   common.skip('missing crypto');
   return;
 }
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
 const tls = require('tls');
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 function loadPEM(n) {
diff --git a/test/parallel/test-tls-sni-server-client.js b/test/parallel/test-tls-sni-server-client.js
index a8c52ef5668184..4e1ab6484c0eec 100644
--- a/test/parallel/test-tls-sni-server-client.js
+++ b/test/parallel/test-tls-sni-server-client.js
@@ -1,21 +1,23 @@
 'use strict';
+const common = require('../common');
+
 if (!process.features.tls_sni) {
   common.skip('node compiled without OpenSSL or with old OpenSSL version.');
   return;
 }
 
-const common = require('../common');
-const assert = require('assert');
-const fs = require('fs');
-
 if (!common.hasCrypto) {
   common.skip('missing crypto');
   return;
 }
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
 const tls = require('tls');
 
 function filenamePEM(n) {
-  return require('path').join(common.fixturesDir, 'keys', `${n}.pem`);
+  return path.join(common.fixturesDir, 'keys', `${n}.pem`);
 }
 
 function loadPEM(n) {
diff --git a/test/parallel/test-tls-startcom-wosign-whitelist.js b/test/parallel/test-tls-startcom-wosign-whitelist.js
index 21dbb55c156e8e..601c0e4393c2eb 100644
--- a/test/parallel/test-tls-startcom-wosign-whitelist.js
+++ b/test/parallel/test-tls-startcom-wosign-whitelist.js
@@ -1,15 +1,16 @@
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 
 if (!common.hasCrypto) {
   common.skip('missing crypto');
   return;
 }
 
-const tls = require('tls');
+const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
+const tls = require('tls');
+
 let finished = 0;
 
 function filenamePEM(n) {
diff --git a/test/parallel/test-url.js b/test/parallel/test-url.js
index 4e123305b5fddb..251557f8ac98af 100644
--- a/test/parallel/test-url.js
+++ b/test/parallel/test-url.js
@@ -1,6 +1,6 @@
 /* eslint-disable max-len */
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const url = require('url');
@@ -1684,7 +1684,7 @@ const throws = [
   true,
   false,
   0,
-  function() {}
+  common.noop
 ];
 for (let i = 0; i < throws.length; i++) {
   assert.throws(function() { url.format(throws[i]); }, TypeError);
diff --git a/test/parallel/test-util.js b/test/parallel/test-util.js
index 3b7e78ea1e464e..867cae95935caf 100644
--- a/test/parallel/test-util.js
+++ b/test/parallel/test-util.js
@@ -12,7 +12,7 @@ assert.strictEqual(true, util.isArray(new Array(5)));
 assert.strictEqual(true, util.isArray(new Array('with', 'some', 'entries')));
 assert.strictEqual(true, util.isArray(context('Array')()));
 assert.strictEqual(false, util.isArray({}));
-assert.strictEqual(false, util.isArray({ push: function() {} }));
+assert.strictEqual(false, util.isArray({ push: common.noop }));
 assert.strictEqual(false, util.isArray(/regexp/));
 assert.strictEqual(false, util.isArray(new Error()));
 assert.strictEqual(false, util.isArray(Object.create(Array.prototype)));
@@ -61,7 +61,7 @@ assert.strictEqual(false, util.isPrimitive(new Error()));
 assert.strictEqual(false, util.isPrimitive(new Date()));
 assert.strictEqual(false, util.isPrimitive([]));
 assert.strictEqual(false, util.isPrimitive(/regexp/));
-assert.strictEqual(false, util.isPrimitive(function() {}));
+assert.strictEqual(false, util.isPrimitive(common.noop));
 assert.strictEqual(false, util.isPrimitive(new Number(1)));
 assert.strictEqual(false, util.isPrimitive(new String('bla')));
 assert.strictEqual(false, util.isPrimitive(new Boolean(true)));
@@ -117,7 +117,7 @@ assert.strictEqual(util.isSymbol(), false);
 assert.strictEqual(util.isSymbol('string'), false);
 
 assert.strictEqual(util.isFunction(() => {}), true);
-assert.strictEqual(util.isFunction(function() {}), true);
+assert.strictEqual(util.isFunction(common.noop), true);
 assert.strictEqual(util.isFunction(), false);
 assert.strictEqual(util.isFunction('string'), false);
 
diff --git a/test/parallel/test-vm-cached-data.js b/test/parallel/test-vm-cached-data.js
index c4fa55cb0b2a6d..cedc68bea06372 100644
--- a/test/parallel/test-vm-cached-data.js
+++ b/test/parallel/test-vm-cached-data.js
@@ -3,7 +3,6 @@ require('../common');
 const assert = require('assert');
 const vm = require('vm');
 const spawnSync = require('child_process').spawnSync;
-const Buffer = require('buffer').Buffer;
 
 function getSource(tag) {
   return `(function ${tag}() { return '${tag}'; })`;
diff --git a/test/parallel/test-vm-function-declaration.js b/test/parallel/test-vm-function-declaration.js
index c2aff80f02b524..ff594644c68de0 100644
--- a/test/parallel/test-vm-function-declaration.js
+++ b/test/parallel/test-vm-function-declaration.js
@@ -7,7 +7,7 @@ const o = vm.createContext({ console: console });
 
 // Function declaration and expression should both be copied to the
 // sandboxed context.
-let code = 'var a = function() {};\n';
+let code = 'var a = function () {};\n';
 code += 'function b(){}\n';
 
 // Grab the global b function as the completion value, to ensure that
diff --git a/test/parallel/test-zlib-close-after-write.js b/test/parallel/test-zlib-close-after-write.js
index d25ccfe381f113..8977fd36add703 100644
--- a/test/parallel/test-zlib-close-after-write.js
+++ b/test/parallel/test-zlib-close-after-write.js
@@ -5,5 +5,5 @@ const zlib = require('zlib');
 zlib.gzip('hello', common.mustCall(function(err, out) {
   const unzip = zlib.createGunzip();
   unzip.write(out);
-  unzip.close(common.mustCall(function() {}));
+  unzip.close(common.mustCall());
 }));
diff --git a/test/parallel/test-zlib-write-after-close.js b/test/parallel/test-zlib-write-after-close.js
index fdad1708c81ff0..e169a06639917f 100644
--- a/test/parallel/test-zlib-write-after-close.js
+++ b/test/parallel/test-zlib-write-after-close.js
@@ -5,6 +5,6 @@ const zlib = require('zlib');
 
 zlib.gzip('hello', common.mustCall(function(err, out) {
   const unzip = zlib.createGunzip();
-  unzip.close(common.mustCall(function() {}));
+  unzip.close(common.mustCall());
   assert.throws(() => unzip.write(out), /^Error: zlib binding closed$/);
 }));
diff --git a/test/parallel/test-zlib-zero-byte.js b/test/parallel/test-zlib-zero-byte.js
index cd4cf41f98ac07..95b75e739fd115 100644
--- a/test/parallel/test-zlib-zero-byte.js
+++ b/test/parallel/test-zlib-zero-byte.js
@@ -13,6 +13,6 @@ gz.on('data', function(c) {
 gz.on('end', common.mustCall(function() {
   assert.strictEqual(received, 20);
 }));
-gz.on('finish', common.mustCall(function() {}));
+gz.on('finish', common.mustCall());
 gz.write(emptyBuffer);
 gz.end();
diff --git a/test/pummel/test-dtrace-jsstack.js b/test/pummel/test-dtrace-jsstack.js
index ad58aaf7615081..9833324e072f93 100644
--- a/test/pummel/test-dtrace-jsstack.js
+++ b/test/pummel/test-dtrace-jsstack.js
@@ -65,14 +65,14 @@ dtrace.on('exit', function(code) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
 
-    if (line.indexOf(sentinel) === -1 || frames.length === 0)
+    if (!line.includes(sentinel) || frames.length === 0)
       continue;
 
     const frame = line.substr(line.indexOf(sentinel) + sentinel.length);
     const top = frames.shift();
 
-    assert.strictEqual(frame.indexOf(top), 0,
-                       `unexpected frame where ${top} was expected`);
+    assert(frame.startsWith(top),
+           `unexpected frame where ${top} was expected`);
   }
 
   assert.strictEqual(frames.length, 0,
diff --git a/test/pummel/test-http-client-reconnect-bug.js b/test/pummel/test-http-client-reconnect-bug.js
index ae29a11fa83d49..cb376fe3dac49c 100644
--- a/test/pummel/test-http-client-reconnect-bug.js
+++ b/test/pummel/test-http-client-reconnect-bug.js
@@ -11,7 +11,7 @@ server.on('listening', common.mustCall(function() {
   const client = http.createClient(common.PORT);
 
   client.on('error', common.mustCall(function(err) {}));
-  client.on('end', common.mustCall(function() {}));
+  client.on('end', common.mustCall());
 
   const request = client.request('GET', '/', {'host': 'localhost'});
   request.end();
diff --git a/test/pummel/test-https-no-reader.js b/test/pummel/test-https-no-reader.js
index a08676277af6ce..437b4e3c4acefe 100644
--- a/test/pummel/test-https-no-reader.js
+++ b/test/pummel/test-https-no-reader.js
@@ -8,7 +8,6 @@ if (!common.hasCrypto) {
 }
 const https = require('https');
 
-const Buffer = require('buffer').Buffer;
 const fs = require('fs');
 const path = require('path');
 
diff --git a/test/pummel/test-keep-alive.js b/test/pummel/test-keep-alive.js
index a9e91e201bb19b..f8ea1e8d4d79ab 100644
--- a/test/pummel/test-keep-alive.js
+++ b/test/pummel/test-keep-alive.js
@@ -58,10 +58,10 @@ function runAb(opts, callback) {
       return;
     }
 
-    let matches = /Requests\/sec:\s*(\d+)\./mi.exec(stdout);
+    let matches = /Requests\/sec:\s*(\d+)\./i.exec(stdout);
     const reqSec = parseInt(matches[1]);
 
-    matches = /Keep-Alive requests:\s*(\d+)/mi.exec(stdout);
+    matches = /Keep-Alive requests:\s*(\d+)/i.exec(stdout);
     let keepAliveRequests;
     if (matches) {
       keepAliveRequests = parseInt(matches[1]);
diff --git a/test/pummel/test-net-connect-memleak.js b/test/pummel/test-net-connect-memleak.js
index f16034e4773510..6799b412b693a0 100644
--- a/test/pummel/test-net-connect-memleak.js
+++ b/test/pummel/test-net-connect-memleak.js
@@ -10,7 +10,7 @@ assert.strictEqual(
   'function',
   'Run this test with --expose-gc'
 );
-net.createServer(function() {}).listen(common.PORT);
+net.createServer(common.noop).listen(common.PORT);
 
 let before = 0;
 {
diff --git a/test/pummel/test-regress-GH-814.js b/test/pummel/test-regress-GH-814.js
index a3700c500b4f53..58ba57dc6c88e8 100644
--- a/test/pummel/test-regress-GH-814.js
+++ b/test/pummel/test-regress-GH-814.js
@@ -29,7 +29,7 @@ const tail = require('child_process').spawn('tail', ['-f', testFileName]);
 tail.stdout.on('data', tailCB);
 
 function tailCB(data) {
-  PASS = data.toString().indexOf('.') < 0;
+  PASS = !data.toString().includes('.');
 }
 
 
diff --git a/test/pummel/test-regress-GH-814_2.js b/test/pummel/test-regress-GH-814_2.js
index da315e3fc2b007..48f5de63efdc1c 100644
--- a/test/pummel/test-regress-GH-814_2.js
+++ b/test/pummel/test-regress-GH-814_2.js
@@ -13,7 +13,7 @@ const tailProc = require('child_process').spawn('tail', ['-f', testFileName]);
 tailProc.stdout.on('data', tailCB);
 
 function tailCB(data) {
-  PASS = data.toString().indexOf('.') < 0;
+  PASS = !data.toString().includes('.');
 
   if (PASS) {
     //console.error('i');
diff --git a/test/pummel/test-tls-securepair-client.js b/test/pummel/test-tls-securepair-client.js
index 0b2e45302b5cc2..234ee6a09117b0 100644
--- a/test/pummel/test-tls-securepair-client.js
+++ b/test/pummel/test-tls-securepair-client.js
@@ -63,7 +63,7 @@ function test(keyfn, certfn, check, next) {
     console.error(state);
     switch (state) {
       case 'WAIT-ACCEPT':
-        if (/ACCEPT/g.test(serverStdoutBuffer)) {
+        if (/ACCEPT/.test(serverStdoutBuffer)) {
           // Give s_server half a second to start up.
           setTimeout(startClient, 500);
           state = 'WAIT-HELLO';
@@ -71,7 +71,7 @@ function test(keyfn, certfn, check, next) {
         break;
 
       case 'WAIT-HELLO':
-        if (/hello/g.test(serverStdoutBuffer)) {
+        if (/hello/.test(serverStdoutBuffer)) {
 
           // End the current SSL connection and exit.
           // See s_server(1ssl).
diff --git a/test/sequential/test-child-process-pass-fd.js b/test/sequential/test-child-process-pass-fd.js
index 404ae854a15953..b2481270faf065 100644
--- a/test/sequential/test-child-process-pass-fd.js
+++ b/test/sequential/test-child-process-pass-fd.js
@@ -45,7 +45,7 @@ if (process.argv[2] !== 'child') {
   // the only thing keeping this worker alive will be IPC. This is important,
   // because it means a worker with no parent will have no referenced handles,
   // thus no work to do, and will exit immediately, preventing process leaks.
-  process.on('message', function() {});
+  process.on('message', common.mustCall());
 
   const server = net.createServer((c) => {
     process.once('message', function(msg) {
diff --git a/test/sequential/test-dgram-bind-shared-ports.js b/test/sequential/test-dgram-bind-shared-ports.js
index df294ef03e0e57..7e4f4e850aafbb 100644
--- a/test/sequential/test-dgram-bind-shared-ports.js
+++ b/test/sequential/test-dgram-bind-shared-ports.js
@@ -1,56 +1,92 @@
 'use strict';
 const common = require('../common');
+
+// This test asserts the semantics of dgram::socket.bind({ exclusive })
+// when called from a cluster.Worker
+
 const assert = require('assert');
 const cluster = require('cluster');
 const dgram = require('dgram');
-
-function noop() { }
+const BYE = 'bye';
+const WORKER2_NAME = 'wrker2';
 
 if (cluster.isMaster) {
   const worker1 = cluster.fork();
 
   if (common.isWindows) {
-    const checkErrType = (er) => {
-      assert.strictEqual(er.code, 'ENOTSUP');
+    worker1.on('error', common.mustCall((err) => {
+      console.log(err);
+      assert.strictEqual(err.code, 'ENOTSUP');
       worker1.kill();
-    };
-
-    worker1.on('error', common.mustCall(checkErrType, 1));
+    }));
     return;
   }
 
-  worker1.on('message', (msg) => {
+  worker1.on('message', common.mustCall((msg) => {
+    console.log(msg);
     assert.strictEqual(msg, 'success');
-    const worker2 = cluster.fork();
 
-    worker2.on('message', (msg) => {
-      assert.strictEqual(msg, 'socket2:EADDRINUSE');
-      worker1.kill();
-      worker2.kill();
-    });
-  });
+    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);
+  }));
+  // end master code
 } else {
-  const socket1 = dgram.createSocket('udp4', noop);
-  const socket2 = dgram.createSocket('udp4', noop);
-
-  socket1.on('error', (err) => {
-    // no errors expected
-    process.send(`socket1:${err.code}`);
-  });
-
-  socket2.on('error', (err) => {
-    // an error is expected on the second worker
-    process.send(`socket2:${err.code}`);
-  });
-
-  socket1.bind({
-    address: 'localhost',
-    port: common.PORT,
-    exclusive: false
-  }, () => {
-    socket2.bind({ port: common.PORT + 1, exclusive: true }, () => {
-      // the first worker should succeed
+  // worker code
+  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());
+  const socket2 = dgram.createSocket('udp4', common.mustNotCall());
+  const socket3 = dgram.createSocket('udp4', common.mustNotCall());
+
+  socket1.on('error', (err) => assert.fail(undefined, undefined, err));
+  socket2.on('error', (err) => assert.fail(undefined, undefined, err));
+
+  // First worker should bind, second should err
+  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) => {
+      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);
+    }));
+  }));
 }
diff --git a/test/sequential/test-fs-watch.js b/test/sequential/test-fs-watch.js
index 1780099eba4f9b..70c165ea7992be 100644
--- a/test/sequential/test-fs-watch.js
+++ b/test/sequential/test-fs-watch.js
@@ -1,3 +1,24 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// 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.
+
 'use strict';
 const common = require('../common');
 const assert = require('assert');
@@ -109,7 +130,7 @@ fs.watch(__filename, {persistent: false}, function() {
 // https://github.com/joyent/node/issues/6690
 let oldhandle;
 assert.throws(function() {
-  const w = fs.watch(__filename, function(event, filename) { });
+  const w = fs.watch(__filename, common.mustNotCall());
   oldhandle = w._handle;
   w._handle = { close: w._handle.close };
   w.close();
@@ -117,7 +138,7 @@ assert.throws(function() {
 oldhandle.close(); // clean up
 
 assert.throws(function() {
-  const w = fs.watchFile(__filename, {persistent: false}, function() {});
+  const w = fs.watchFile(__filename, {persistent: false}, common.mustNotCall());
   oldhandle = w._handle;
   w._handle = { stop: w._handle.stop };
   w.stop();
diff --git a/test/sequential/test-https-set-timeout-server.js b/test/sequential/test-https-set-timeout-server.js
index 6c7afa5df9b304..d2b44a0303da46 100644
--- a/test/sequential/test-https-set-timeout-server.js
+++ b/test/sequential/test-https-set-timeout-server.js
@@ -6,7 +6,9 @@ if (!common.hasCrypto) {
   common.skip('missing crypto');
   return;
 }
+
 const https = require('https');
+const http = require('http');
 
 const tls = require('tls');
 const fs = require('fs');
@@ -21,150 +23,161 @@ const serverOptions = {
 function test(fn) {
   if (!tests.length)
     process.nextTick(run);
-  tests.push(fn);
+  tests.push(common.mustCall(fn));
 }
 
 function run() {
   const fn = tests.shift();
   if (fn) {
-    console.log('# %s', fn.name);
     fn(run);
-  } else {
-    console.log('ok');
   }
 }
 
 test(function serverTimeout(cb) {
-  const server = https.createServer(serverOptions, function(req, res) {
-    // just do nothing, we should get a timeout event.
-  });
-  server.listen(0, common.mustCall(function() {
-    const s = server.setTimeout(50, common.mustCall(function(socket) {
+  const server = https.createServer(
+    serverOptions,
+    common.mustCall((req, res) => {
+      // just do nothing, we should get a timeout event.
+    }));
+  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: this.address().port,
+      port: server.address().port,
       rejectUnauthorized: false
-    }).on('error', function() {});
+    }).on('error', common.noop);
   }));
 });
 
 test(function serverRequestTimeout(cb) {
-  function handler(req, res) {
-    // just do nothing, we should get a timeout event.
-    req.setTimeout(50, common.mustCall(function() {
-      req.socket.destroy();
-      server.close();
-      cb();
+  const server = https.createServer(
+    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();
+      }));
+      assert.ok(s instanceof http.IncomingMessage);
     }));
-  }
-
-  let server = https.createServer(serverOptions, common.mustCall(handler));
-  server.listen(0, function() {
+  server.listen(common.mustCall(() => {
     const req = https.request({
-      port: this.address().port,
+      port: server.address().port,
       method: 'POST',
       rejectUnauthorized: false
     });
-    req.on('error', function() {});
+    req.on('error', common.noop);
     req.write('Hello');
     // req is in progress
-  });
+  }));
 });
 
 test(function serverResponseTimeout(cb) {
-  function handler(req, res) {
-    // just do nothing, we should get a timeout event.
-    res.setTimeout(50, common.mustCall(function() {
-      res.socket.destroy();
-      server.close();
-      cb();
+  const server = https.createServer(
+    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();
+      }));
+      assert.ok(s instanceof http.OutgoingMessage);
     }));
-  }
-
-  let server = https.createServer(serverOptions, common.mustCall(handler));
-  server.listen(0, function() {
+  server.listen(common.mustCall(() => {
     https.get({
-      port: this.address().port,
+      port: server.address().port,
       rejectUnauthorized: false
-    }).on('error', function() {});
-  });
+    }).on('error', common.mustCall());
+  }));
 });
 
 test(function serverRequestNotTimeoutAfterEnd(cb) {
-  function handler(req, res) {
-    // just do nothing, we should get a timeout event.
-    req.setTimeout(50, common.mustNotCall());
-    res.on('timeout', common.mustCall(function(socket) {}));
-  }
-  const server = https.createServer(serverOptions, common.mustCall(handler));
-  server.on('timeout', function(socket) {
+  const server = https.createServer(
+    serverOptions,
+    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(0, function() {
+  }));
+  server.listen(common.mustCall(() => {
     https.get({
-      port: this.address().port,
+      port: server.address().port,
       rejectUnauthorized: false
-    }).on('error', function() {});
-  });
+    }).on('error', common.mustCall());
+  }));
 });
 
 test(function serverResponseTimeoutWithPipeline(cb) {
   let caughtTimeout = '';
-  process.on('exit', function() {
+  let secReceived = false;
+  process.on('exit', () => {
     assert.strictEqual(caughtTimeout, '/2');
   });
-  const server = https.createServer(serverOptions, function(req, res) {
-    res.setTimeout(50, function() {
+  const server = https.createServer(serverOptions, (req, res) => {
+    if (req.url === '/2')
+      secReceived = true;
+    const s = res.setTimeout(50, () => {
       caughtTimeout += req.url;
     });
+    assert.ok(s instanceof http.OutgoingMessage);
     if (req.url === '/1') res.end();
   });
-  server.on('timeout', function(socket) {
-    socket.destroy();
-    server.close();
-    cb();
-  });
-  server.listen(0, function() {
+  server.on('timeout', common.mustCall((socket) => {
+    if (secReceived) {
+      socket.destroy();
+      server.close();
+      cb();
+    }
+  }));
+  server.listen(common.mustCall(() => {
     const options = {
-      port: this.address().port,
+      port: server.address().port,
       allowHalfOpen: true,
       rejectUnauthorized: false
     };
-    const c = tls.connect(options, function() {
+    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) {
-  const server = https.createServer(serverOptions,
-                                    common.mustCall(function(req, res) {
-                                      req.on('timeout', common.mustNotCall());
-                                      res.on('timeout', common.mustNotCall());
-                                      res.end();
-                                    }));
-  server.setTimeout(50, common.mustCall(function(socket) {
+  const server = https.createServer(
+    serverOptions,
+    common.mustCall((req, res) => {
+      req.on('timeout', common.mustNotCall());
+      res.on('timeout', common.mustNotCall());
+      res.end();
+    }));
+  const s = server.setTimeout(50, common.mustCall((socket) => {
     socket.destroy();
     server.close();
     cb();
   }));
-  server.listen(0, function() {
+  assert.ok(s instanceof https.Server);
+  server.listen(common.mustCall(() => {
     const options = {
-      port: this.address().port,
+      port: server.address().port,
       allowHalfOpen: true,
       rejectUnauthorized: false
     };
-    tls.connect(options, function() {
-      this.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+    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/sequential/test-net-server-bind.js b/test/sequential/test-net-server-bind.js
new file mode 100644
index 00000000000000..56216d0ed60619
--- /dev/null
+++ b/test/sequential/test-net-server-bind.js
@@ -0,0 +1,64 @@
+'use strict';
+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();
+  }));
+}
+
+// No callback to listen(), assume we can bind in 100 ms
+{
+  const server = net.createServer(common.mustNotCall());
+
+  server.listen(common.PORT);
+
+  setTimeout(function() {
+    const address = server.address();
+    assert.strictEqual(address.port, common.PORT);
+
+    if (address.family === 'IPv6')
+      assert.strictEqual(server._connectionKey, `6::::${address.port}`);
+    else
+      assert.strictEqual(server._connectionKey, `4:0.0.0.0:${address.port}`);
+
+    server.close();
+  }, 100);
+}
+
+// Callback to listen()
+{
+  const server = net.createServer(common.mustNotCall());
+
+  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();
+  }));
+}
+
+// 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();
+  }));
+}
diff --git a/test/sequential/test-regress-GH-4027.js b/test/sequential/test-regress-GH-4027.js
index 8d9c6bb1ad795a..a1332e71c4c320 100644
--- a/test/sequential/test-regress-GH-4027.js
+++ b/test/sequential/test-regress-GH-4027.js
@@ -8,10 +8,11 @@ common.refreshTmpDir();
 
 const filename = path.join(common.tmpDir, 'watched');
 fs.writeFileSync(filename, 'quis custodiet ipsos custodes');
-setTimeout(fs.unlinkSync, 100, filename);
 
 fs.watchFile(filename, { interval: 50 }, common.mustCall(function(curr, prev) {
   assert.strictEqual(prev.nlink, 1);
   assert.strictEqual(curr.nlink, 0);
   fs.unwatchFile(filename);
 }));
+
+setTimeout(fs.unlinkSync, common.platformTimeout(300), filename);
diff --git a/tools/eslint-rules/align-multiline-assignment.js b/tools/eslint-rules/align-multiline-assignment.js
index 80896b5e96296d..8e2f5ed1ee7e90 100644
--- a/tools/eslint-rules/align-multiline-assignment.js
+++ b/tools/eslint-rules/align-multiline-assignment.js
@@ -54,7 +54,6 @@ function testAssignment(context, node) {
 function testDeclaration(context, node) {
   node.declarations.forEach((declaration) => {
     const msg = checkExpressionAlignment(declaration.init);
-    // const start = declaration.init.loc.start;
     if (msg)
       context.report(node, msg);
   });
diff --git a/tools/eslint-rules/prefer-common-mustnotcall.js b/tools/eslint-rules/prefer-common-mustnotcall.js
new file mode 100644
index 00000000000000..6bc428ed59a8b8
--- /dev/null
+++ b/tools/eslint-rules/prefer-common-mustnotcall.js
@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Prefer common.mustNotCall(msg) over common.mustCall(fn, 0)
+ * @author James M Snell <jasnell@gmail.com>
+ */
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const msg = 'Please use common.mustNotCall(msg) instead of ' +
+            'common.mustCall(fn, 0) or common.mustCall(0).';
+
+function isCommonMustCall(node) {
+  return node &&
+         node.callee &&
+         node.callee.object &&
+         node.callee.object.name === 'common' &&
+         node.callee.property &&
+         node.callee.property.name === 'mustCall';
+}
+
+function isArgZero(argument) {
+  return argument &&
+         typeof argument.value === 'number' &&
+         argument.value === 0;
+}
+
+module.exports = function(context) {
+  return {
+    CallExpression(node) {
+      if (isCommonMustCall(node) &&
+          (isArgZero(node.arguments[0]) ||  //  catch common.mustCall(0)
+           isArgZero(node.arguments[1]))) { //  catch common.mustCall(fn, 0)
+        context.report(node, msg);
+      }
+    }
+  };
+};
diff --git a/tools/gyp_node.py b/tools/gyp_node.py
index 1f0b2eaebe2c22..043053c3daa9d9 100755
--- a/tools/gyp_node.py
+++ b/tools/gyp_node.py
@@ -13,14 +13,6 @@
 output_dir = os.path.join(os.path.abspath(node_root), 'out')
 
 def run_gyp(args):
-  rc = gyp.main(args)
-  if rc != 0:
-    print 'Error running GYP'
-    sys.exit(rc)
-
-if __name__ == '__main__':
-  args = sys.argv[1:]
-
   # GYP bug.
   # On msvs it will crash if it gets an absolute path.
   # On Mac/make it will crash if it doesn't get an absolute path.
@@ -58,5 +50,11 @@ def run_gyp(args):
   args.append('-Dlinux_use_bundled_gold=0')
   args.append('-Dlinux_use_gold_flags=0')
 
-  gyp_args = list(args)
-  run_gyp(gyp_args)
+  rc = gyp.main(args)
+  if rc != 0:
+    print 'Error running GYP'
+    sys.exit(rc)
+
+
+if __name__ == '__main__':
+  run_gyp(sys.argv[1:])
diff --git a/tools/icu/iculslocs.cc b/tools/icu/iculslocs.cc
index 2471e3f8583011..05c1747a31e163 100644
--- a/tools/icu/iculslocs.cc
+++ b/tools/icu/iculslocs.cc
@@ -55,6 +55,7 @@ Japanese, it doesn't *claim* to have Japanese.
 #include <unicode/ustdio.h>
 #include <unicode/ures.h>
 #include <unicode/udata.h>
+#include <unicode/putil.h>
 
 const char* PROG = "iculslocs";
 const char* NAME = U_ICUDATA_NAME;  // assume ICU data