From 9c50464a0cbefdd402a6a3f46b5cbee6829041d3 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Fri, 19 Aug 2016 14:24:39 -0700
Subject: [PATCH 1/2] test: refactor test-util-inspect

* favor `assert.strictEqual()` and friends of `assert.equal()` etc.
* favor `.includes()` over `.indexOf()` for existence checks
---
 test/parallel/test-util-inspect.js | 342 ++++++++++++++++++-----------
 1 file changed, 209 insertions(+), 133 deletions(-)

diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index d7c8462e367e2c..cf1475f993ea5f 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -1,44 +1,44 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const util = require('util');
 const vm = require('vm');
 
-assert.equal(util.inspect(1), '1');
-assert.equal(util.inspect(false), 'false');
-assert.equal(util.inspect(''), "''");
-assert.equal(util.inspect('hello'), "'hello'");
-assert.equal(util.inspect(function() {}), '[Function]');
-assert.equal(util.inspect(undefined), 'undefined');
-assert.equal(util.inspect(null), 'null');
-assert.equal(util.inspect(/foo(bar\n)?/gi), '/foo(bar\\n)?/gi');
+assert.strictEqual(util.inspect(1), '1');
+assert.strictEqual(util.inspect(false), 'false');
+assert.strictEqual(util.inspect(''), "''");
+assert.strictEqual(util.inspect('hello'), "'hello'");
+assert.strictEqual(util.inspect(function() {}), '[Function]');
+assert.strictEqual(util.inspect(undefined), 'undefined');
+assert.strictEqual(util.inspect(null), 'null');
+assert.strictEqual(util.inspect(/foo(bar\n)?/gi), '/foo(bar\\n)?/gi');
 assert.strictEqual(util.inspect(new Date('Sun, 14 Feb 2010 11:48:40 GMT')),
   new Date('2010-02-14T12:48:40+01:00').toISOString());
 assert.strictEqual(util.inspect(new Date('')), (new Date('')).toString());
 
-assert.equal(util.inspect('\n\u0001'), "'\\n\\u0001'");
+assert.strictEqual(util.inspect('\n\u0001'), "'\\n\\u0001'");
 
-assert.equal(util.inspect([]), '[]');
-assert.equal(util.inspect(Object.create([])), 'Array {}');
-assert.equal(util.inspect([1, 2]), '[ 1, 2 ]');
-assert.equal(util.inspect([1, [2, 3]]), '[ 1, [ 2, 3 ] ]');
+assert.strictEqual(util.inspect([]), '[]');
+assert.strictEqual(util.inspect(Object.create([])), 'Array {}');
+assert.strictEqual(util.inspect([1, 2]), '[ 1, 2 ]');
+assert.strictEqual(util.inspect([1, [2, 3]]), '[ 1, [ 2, 3 ] ]');
 
-assert.equal(util.inspect({}), '{}');
-assert.equal(util.inspect({a: 1}), '{ a: 1 }');
-assert.equal(util.inspect({a: function() {}}), '{ a: [Function: a] }');
-assert.equal(util.inspect({a: 1, b: 2}), '{ a: 1, b: 2 }');
-assert.equal(util.inspect({'a': {}}), '{ a: {} }');
-assert.equal(util.inspect({'a': {'b': 2}}), '{ a: { b: 2 } }');
-assert.equal(util.inspect({'a': {'b': { 'c': { 'd': 2 }}}}),
+assert.strictEqual(util.inspect({}), '{}');
+assert.strictEqual(util.inspect({a: 1}), '{ a: 1 }');
+assert.strictEqual(util.inspect({a: function() {}}), '{ a: [Function: a] }');
+assert.strictEqual(util.inspect({a: 1, b: 2}), '{ a: 1, b: 2 }');
+assert.strictEqual(util.inspect({'a': {}}), '{ a: {} }');
+assert.strictEqual(util.inspect({'a': {'b': 2}}), '{ a: { b: 2 } }');
+assert.strictEqual(util.inspect({'a': {'b': { 'c': { 'd': 2 }}}}),
   '{ a: { b: { c: [Object] } } }');
-assert.equal(util.inspect({'a': {'b': { 'c': { 'd': 2 }}}}, false, null),
+assert.strictEqual(util.inspect({'a': {'b': { 'c': { 'd': 2 }}}}, false, null),
   '{ a: { b: { c: { d: 2 } } } }');
-assert.equal(util.inspect([1, 2, 3], true), '[ 1, 2, 3, [length]: 3 ]');
-assert.equal(util.inspect({'a': {'b': { 'c': 2}}}, false, 0),
+assert.strictEqual(util.inspect([1, 2, 3], true), '[ 1, 2, 3, [length]: 3 ]');
+assert.strictEqual(util.inspect({'a': {'b': { 'c': 2}}}, false, 0),
   '{ a: [Object] }');
-assert.equal(util.inspect({'a': {'b': { 'c': 2}}}, false, 1),
+assert.strictEqual(util.inspect({'a': {'b': { 'c': 2}}}, false, 1),
   '{ a: { b: [Object] } }');
-assert.equal(util.inspect(Object.create({},
+assert.strictEqual(util.inspect(Object.create({},
   {visible: {value: 1, enumerable: true}, hidden: {value: 2}})),
   '{ visible: 1 }'
 );
@@ -53,23 +53,29 @@ assert(!/Object/.test(
 for (const showHidden of [true, false]) {
   const ab = new ArrayBuffer(4);
   const dv = new DataView(ab, 1, 2);
-  assert.equal(util.inspect(ab, showHidden), 'ArrayBuffer { byteLength: 4 }');
-  assert.equal(util.inspect(new DataView(ab, 1, 2), showHidden),
+  assert.strictEqual(
+    util.inspect(ab, showHidden),
+    'ArrayBuffer { byteLength: 4 }'
+  );
+  assert.strictEqual(util.inspect(new DataView(ab, 1, 2), showHidden),
                'DataView {\n' +
                '  byteLength: 2,\n' +
                '  byteOffset: 1,\n' +
                '  buffer: ArrayBuffer { byteLength: 4 } }');
-  assert.equal(util.inspect(ab, showHidden), 'ArrayBuffer { byteLength: 4 }');
-  assert.equal(util.inspect(dv, showHidden),
+  assert.strictEqual(
+    util.inspect(ab, showHidden),
+    'ArrayBuffer { byteLength: 4 }'
+  );
+  assert.strictEqual(util.inspect(dv, showHidden),
                'DataView {\n' +
                '  byteLength: 2,\n' +
                '  byteOffset: 1,\n' +
                '  buffer: ArrayBuffer { byteLength: 4 } }');
   ab.x = 42;
   dv.y = 1337;
-  assert.equal(util.inspect(ab, showHidden),
+  assert.strictEqual(util.inspect(ab, showHidden),
                'ArrayBuffer { byteLength: 4, x: 42 }');
-  assert.equal(util.inspect(dv, showHidden),
+  assert.strictEqual(util.inspect(dv, showHidden),
                'DataView {\n' +
                '  byteLength: 2,\n' +
                '  byteOffset: 1,\n' +
@@ -81,23 +87,29 @@ for (const showHidden of [true, false]) {
 for (const showHidden of [true, false]) {
   const ab = vm.runInNewContext('new ArrayBuffer(4)');
   const dv = vm.runInNewContext('new DataView(ab, 1, 2)', { ab: ab });
-  assert.equal(util.inspect(ab, showHidden), 'ArrayBuffer { byteLength: 4 }');
-  assert.equal(util.inspect(new DataView(ab, 1, 2), showHidden),
+  assert.strictEqual(
+    util.inspect(ab, showHidden),
+    'ArrayBuffer { byteLength: 4 }'
+  );
+  assert.strictEqual(util.inspect(new DataView(ab, 1, 2), showHidden),
                'DataView {\n' +
                '  byteLength: 2,\n' +
                '  byteOffset: 1,\n' +
                '  buffer: ArrayBuffer { byteLength: 4 } }');
-  assert.equal(util.inspect(ab, showHidden), 'ArrayBuffer { byteLength: 4 }');
-  assert.equal(util.inspect(dv, showHidden),
+  assert.strictEqual(
+    util.inspect(ab, showHidden),
+    'ArrayBuffer { byteLength: 4 }'
+  );
+  assert.strictEqual(util.inspect(dv, showHidden),
                'DataView {\n' +
                '  byteLength: 2,\n' +
                '  byteOffset: 1,\n' +
                '  buffer: ArrayBuffer { byteLength: 4 } }');
   ab.x = 42;
   dv.y = 1337;
-  assert.equal(util.inspect(ab, showHidden),
+  assert.strictEqual(util.inspect(ab, showHidden),
                'ArrayBuffer { byteLength: 4, x: 42 }');
-  assert.equal(util.inspect(dv, showHidden),
+  assert.strictEqual(util.inspect(dv, showHidden),
                'DataView {\n' +
                '  byteLength: 2,\n' +
                '  byteOffset: 1,\n' +
@@ -120,7 +132,7 @@ for (const showHidden of [true, false]) {
     const array = new constructor(new ArrayBuffer(byteLength), 0, length);
     array[0] = 65;
     array[1] = 97;
-    assert.equal(util.inspect(array, true),
+    assert.strictEqual(util.inspect(array, true),
                  `${constructor.name} [\n` +
                  `  65,\n` +
                  `  97,\n` +
@@ -129,7 +141,10 @@ for (const showHidden of [true, false]) {
                  `  [byteLength]: ${byteLength},\n` +
                  `  [byteOffset]: 0,\n` +
                  `  [buffer]: ArrayBuffer { byteLength: ${byteLength} } ]`);
-    assert.equal(util.inspect(array, false), `${constructor.name} [ 65, 97 ]`);
+    assert.strictEqual(
+      util.inspect(array, false),
+      `${constructor.name} [ 65, 97 ]`
+    );
   });
 
 // Now check that declaring a TypedArray in a different context works the same
@@ -152,7 +167,7 @@ for (const showHidden of [true, false]) {
                                      });
     array[0] = 65;
     array[1] = 97;
-    assert.equal(util.inspect(array, true),
+    assert.strictEqual(util.inspect(array, true),
                  `${constructor.name} [\n` +
                  `  65,\n` +
                  `  97,\n` +
@@ -161,7 +176,10 @@ for (const showHidden of [true, false]) {
                  `  [byteLength]: ${byteLength},\n` +
                  `  [byteOffset]: 0,\n` +
                  `  [buffer]: ArrayBuffer { byteLength: ${byteLength} } ]`);
-    assert.equal(util.inspect(array, false), `${constructor.name} [ 65, 97 ]`);
+    assert.strictEqual(
+      util.inspect(array, false),
+      `${constructor.name} [ 65, 97 ]`
+    );
   });
 
 // Due to the hash seed randomization it's not deterministic the order that
@@ -173,7 +191,7 @@ for (const showHidden of [true, false]) {
       {visible: {value: 1, enumerable: true}, hidden: {value: 2}}), true);
   if (out !== '{ [hidden]: 2, visible: 1 }' &&
       out !== '{ visible: 1, [hidden]: 2 }') {
-    assert.ok(false);
+    common.fail(`unexpected value for out ${out}`);
   }
 }
 
@@ -184,11 +202,11 @@ for (const showHidden of [true, false]) {
         hidden: {value: 'secret'}}), true);
   if (out !== "{ [hidden]: 'secret', name: 'Tim' }" &&
       out !== "{ name: 'Tim', [hidden]: 'secret' }") {
-    assert(false);
+    common.fail(`unexpected value for out ${out}`);
   }
 }
 
-assert.equal(
+assert.strictEqual(
   util.inspect(Object.create(null,
     {name: {value: 'Tim', enumerable: true},
       hidden: {value: 'secret'}})),
@@ -197,18 +215,18 @@ assert.equal(
 
 
 // Dynamic properties
-assert.equal(util.inspect({get readonly() {}}),
+assert.strictEqual(util.inspect({get readonly() {}}),
   '{ readonly: [Getter] }');
 
-assert.equal(util.inspect({get readwrite() {}, set readwrite(val) {}}),
+assert.strictEqual(util.inspect({get readwrite() {}, set readwrite(val) {}}),
   '{ readwrite: [Getter/Setter] }');
 
-assert.equal(util.inspect({set writeonly(val) {}}),
+assert.strictEqual(util.inspect({set writeonly(val) {}}),
   '{ writeonly: [Setter] }');
 
 var value = {};
 value['a'] = value;
-assert.equal(util.inspect(value), '{ a: [Circular] }');
+assert.strictEqual(util.inspect(value), '{ a: [Circular] }');
 
 // Array with dynamic properties
 value = [1, 2, 3];
@@ -220,22 +238,22 @@ Object.defineProperty(
     get: () => { this.push(true); return this.length; }
   }
 );
-assert.equal(util.inspect(value), '[ 1, 2, 3, growingLength: [Getter] ]');
+assert.strictEqual(util.inspect(value), '[ 1, 2, 3, growingLength: [Getter] ]');
 
 // Function with properties
 value = function() {};
 value.aprop = 42;
-assert.equal(util.inspect(value), '{ [Function: value] aprop: 42 }');
+assert.strictEqual(util.inspect(value), '{ [Function: value] aprop: 42 }');
 
 // Regular expressions with properties
 value = /123/ig;
 value.aprop = 42;
-assert.equal(util.inspect(value), '{ /123/gi aprop: 42 }');
+assert.strictEqual(util.inspect(value), '{ /123/gi aprop: 42 }');
 
 // Dates with properties
 value = new Date('Sun, 14 Feb 2010 11:48:40 GMT');
 value.aprop = 42;
-assert.equal(util.inspect(value), '{ 2010-02-14T11:48:40.000Z aprop: 42 }'
+assert.strictEqual(util.inspect(value), '{ 2010-02-14T11:48:40.000Z aprop: 42 }'
 );
 
 // test the internal isDate implementation
@@ -244,19 +262,22 @@ var d = new Date2();
 var orig = util.inspect(d);
 Date2.prototype.foo = 'bar';
 var after = util.inspect(d);
-assert.equal(orig, after);
+assert.strictEqual(orig, after);
 
 // test positive/negative zero
-assert.equal(util.inspect(0), '0');
-assert.equal(util.inspect(-0), '-0');
+assert.strictEqual(util.inspect(0), '0');
+assert.strictEqual(util.inspect(-0), '-0');
 
 // test for sparse array
 var a = ['foo', 'bar', 'baz'];
-assert.equal(util.inspect(a), '[ \'foo\', \'bar\', \'baz\' ]');
+assert.strictEqual(util.inspect(a), '[ \'foo\', \'bar\', \'baz\' ]');
 delete a[1];
-assert.equal(util.inspect(a), '[ \'foo\', , \'baz\' ]');
-assert.equal(util.inspect(a, true), '[ \'foo\', , \'baz\', [length]: 3 ]');
-assert.equal(util.inspect(new Array(5)), '[ , , , ,  ]');
+assert.strictEqual(util.inspect(a), '[ \'foo\', , \'baz\' ]');
+assert.strictEqual(
+  util.inspect(a, true),
+  '[ \'foo\', , \'baz\', [length]: 3 ]'
+);
+assert.strictEqual(util.inspect(new Array(5)), '[ , , , ,  ]');
 
 // test for Array constructor in different context
 {
@@ -300,9 +321,12 @@ var getterAndSetter = Object.create(null, {
     set: function() {}
   }
 });
-assert.equal(util.inspect(getter, true), '{ [a]: [Getter] }');
-assert.equal(util.inspect(setter, true), '{ [b]: [Setter] }');
-assert.equal(util.inspect(getterAndSetter, true), '{ [c]: [Getter/Setter] }');
+assert.strictEqual(util.inspect(getter, true), '{ [a]: [Getter] }');
+assert.strictEqual(util.inspect(setter, true), '{ [b]: [Setter] }');
+assert.strictEqual(
+  util.inspect(getterAndSetter, true),
+  '{ [c]: [Getter/Setter] }'
+);
 
 // exceptions should print the error message, not '{}'
 const errors = [];
@@ -311,17 +335,17 @@ errors.push(new Error('FAIL'));
 errors.push(new TypeError('FAIL'));
 errors.push(new SyntaxError('FAIL'));
 errors.forEach(function(err) {
-  assert.equal(util.inspect(err), err.stack);
+  assert.strictEqual(util.inspect(err), err.stack);
 });
 try {
   undef(); // eslint-disable-line no-undef
 } catch (e) {
-  assert.equal(util.inspect(e), e.stack);
+  assert.strictEqual(util.inspect(e), e.stack);
 }
 var ex = util.inspect(new Error('FAIL'), true);
-assert.ok(ex.indexOf('Error: FAIL') != -1);
-assert.ok(ex.indexOf('[stack]') != -1);
-assert.ok(ex.indexOf('[message]') != -1);
+assert.strictEqual(ex.includes('Error: FAIL'), true);
+assert.strictEqual(ex.includes('[stack]'), true);
+assert.strictEqual(ex.includes('[message]'), true);
 // Doesn't capture stack trace
 function BadCustomError(msg) {
   Error.call(this);
@@ -331,11 +355,14 @@ function BadCustomError(msg) {
                         { value: 'BadCustomError', enumerable: false });
 }
 util.inherits(BadCustomError, Error);
-assert.equal(util.inspect(new BadCustomError('foo')), '[BadCustomError: foo]');
+assert.strictEqual(
+  util.inspect(new BadCustomError('foo')),
+  '[BadCustomError: foo]'
+);
 
 // GH-1941
 // should not throw:
-assert.equal(util.inspect(Object.create(Date.prototype)), 'Date {}');
+assert.strictEqual(util.inspect(Object.create(Date.prototype)), 'Date {}');
 
 // GH-1944
 assert.doesNotThrow(function() {
@@ -366,7 +393,7 @@ assert.doesNotThrow(function() {
 // GH-2225
 {
   const x = { inspect: util.inspect };
-  assert.ok(util.inspect(x).indexOf('inspect') != -1);
+  assert.strictEqual(util.inspect(x).includes('inspect'), true);
 }
 
 // util.inspect should not display the escaped value of a key.
@@ -380,9 +407,14 @@ var w = {
 var y = ['a', 'b', 'c'];
 y['\\\\\\'] = 'd';
 
-assert.ok(util.inspect(w),
-          '{ \'\\\': 1, \'\\\\\': 2, \'\\\\\\\': 3, \'\\\\\\\\\': 4 }');
-assert.ok(util.inspect(y), '[ \'a\', \'b\', \'c\', \'\\\\\\\': \'d\' ]');
+assert.strictEqual(
+  util.inspect(w),
+  '{ \'\\\': 1, \'\\\\\': 2, \'\\\\\\\': 3, \'\\\\\\\\\': 4 }'
+);
+assert.strictEqual(
+  util.inspect(y),
+  '[ \'a\', \'b\', \'c\', \'\\\\\\\': \'d\' ]'
+);
 
 // util.inspect.styles and util.inspect.colors
 function test_color_style(style, input, implicit) {
@@ -395,7 +427,10 @@ function test_color_style(style, input, implicit) {
   var with_color = util.inspect(input, false, 0, true);
   var expect = '\u001b[' + color[0] + 'm' + without_color +
                '\u001b[' + color[1] + 'm';
-  assert.equal(with_color, expect, 'util.inspect color for style ' + style);
+  assert.strictEqual(
+    with_color,
+    expect,
+    `util.inspect color for style ${style}`);
 }
 
 test_color_style('special', function() {});
@@ -419,30 +454,59 @@ assert.doesNotThrow(function() {
   let subject = { foo: 'bar', hello: 31, a: { b: { c: { d: 0 } } } };
   Object.defineProperty(subject, 'hidden', { enumerable: false, value: null });
 
-  assert(util.inspect(subject, { showHidden: false }).indexOf('hidden') === -1);
-  assert(util.inspect(subject, { showHidden: true }).indexOf('hidden') !== -1);
-  assert(util.inspect(subject, { colors: false }).indexOf('\u001b[32m') === -1);
-  assert(util.inspect(subject, { colors: true }).indexOf('\u001b[32m') !== -1);
-  assert(util.inspect(subject, { depth: 2 }).indexOf('c: [Object]') !== -1);
-  assert(util.inspect(subject, { depth: 0 }).indexOf('a: [Object]') !== -1);
-  assert(util.inspect(subject, { depth: null }).indexOf('{ d: 0 }') !== -1);
+  assert.strictEqual(
+    util.inspect(subject, { showHidden: false }).includes('hidden'),
+    false
+  );
+  assert.strictEqual(
+    util.inspect(subject, { showHidden: true }).includes('hidden'),
+    true
+  );
+  assert.strictEqual(
+    util.inspect(subject, { colors: false }).includes('\u001b[32m'),
+    false
+  );
+  assert.strictEqual(
+    util.inspect(subject, { colors: true }).includes('\u001b[32m'),
+    true
+  );
+  assert.strictEqual(
+    util.inspect(subject, { depth: 2 }).includes('c: [Object]'),
+    true
+  );
+  assert.strictEqual(
+    util.inspect(subject, { depth: 0 }).includes('a: [Object]'),
+    true
+  );
+  assert.strictEqual(
+    util.inspect(subject, { depth: null }).includes('{ d: 0 }'),
+    true
+  );
 
   // "customInspect" option can enable/disable calling inspect() on objects
   subject = { inspect: function() { return 123; } };
 
-  assert(util.inspect(subject,
-                      { customInspect: true }).indexOf('123') !== -1);
-  assert(util.inspect(subject,
-                      { customInspect: true }).indexOf('inspect') === -1);
-  assert(util.inspect(subject,
-                      { customInspect: false }).indexOf('123') === -1);
-  assert(util.inspect(subject,
-                      { customInspect: false }).indexOf('inspect') !== -1);
+  assert.strictEqual(
+    util.inspect(subject, { customInspect: true }).includes('123'),
+    true
+  );
+  assert.strictEqual(
+    util.inspect(subject, { customInspect: true }).includes('inspect'),
+    false
+  );
+  assert.strictEqual(
+    util.inspect(subject, { customInspect: false }).includes('123'),
+    false
+  );
+  assert.strictEqual(
+    util.inspect(subject, { customInspect: false }).includes('inspect'),
+    true
+  );
 
   // custom inspect() functions should be able to return other Objects
   subject.inspect = function() { return { foo: 'bar' }; };
 
-  assert.equal(util.inspect(subject), '{ foo: \'bar\' }');
+  assert.strictEqual(util.inspect(subject), '{ foo: \'bar\' }');
 
   subject.inspect = function(depth, opts) {
     assert.strictEqual(opts.customInspectOptions, true);
@@ -459,7 +523,7 @@ function test_lines(input) {
 
   var without_color = util.inspect(input);
   var with_color = util.inspect(input, {colors: true});
-  assert.equal(count_lines(without_color), count_lines(with_color));
+  assert.strictEqual(count_lines(without_color), count_lines(with_color));
 }
 
 test_lines([1, 2, 3, 4, 5, 6, 7]);
@@ -480,84 +544,96 @@ test_lines({
 });
 
 // test boxed primitives output the correct values
-assert.equal(util.inspect(new String('test')), '[String: \'test\']');
-assert.equal(util.inspect(Object(Symbol('test'))), '[Symbol: Symbol(test)]');
-assert.equal(util.inspect(new Boolean(false)), '[Boolean: false]');
-assert.equal(util.inspect(new Boolean(true)), '[Boolean: true]');
-assert.equal(util.inspect(new Number(0)), '[Number: 0]');
-assert.equal(util.inspect(new Number(-0)), '[Number: -0]');
-assert.equal(util.inspect(new Number(-1.1)), '[Number: -1.1]');
-assert.equal(util.inspect(new Number(13.37)), '[Number: 13.37]');
+assert.strictEqual(util.inspect(new String('test')), '[String: \'test\']');
+assert.strictEqual(
+  util.inspect(Object(Symbol('test'))),
+  '[Symbol: Symbol(test)]'
+);
+assert.strictEqual(util.inspect(new Boolean(false)), '[Boolean: false]');
+assert.strictEqual(util.inspect(new Boolean(true)), '[Boolean: true]');
+assert.strictEqual(util.inspect(new Number(0)), '[Number: 0]');
+assert.strictEqual(util.inspect(new Number(-0)), '[Number: -0]');
+assert.strictEqual(util.inspect(new Number(-1.1)), '[Number: -1.1]');
+assert.strictEqual(util.inspect(new Number(13.37)), '[Number: 13.37]');
 
 // test boxed primitives with own properties
 var str = new String('baz');
 str.foo = 'bar';
-assert.equal(util.inspect(str), '{ [String: \'baz\'] foo: \'bar\' }');
+assert.strictEqual(util.inspect(str), '{ [String: \'baz\'] foo: \'bar\' }');
 
 var bool = new Boolean(true);
 bool.foo = 'bar';
-assert.equal(util.inspect(bool), '{ [Boolean: true] foo: \'bar\' }');
+assert.strictEqual(util.inspect(bool), '{ [Boolean: true] foo: \'bar\' }');
 
 var num = new Number(13.37);
 num.foo = 'bar';
-assert.equal(util.inspect(num), '{ [Number: 13.37] foo: \'bar\' }');
+assert.strictEqual(util.inspect(num), '{ [Number: 13.37] foo: \'bar\' }');
 
 // test es6 Symbol
 if (typeof Symbol !== 'undefined') {
-  assert.equal(util.inspect(Symbol()), 'Symbol()');
-  assert.equal(util.inspect(Symbol(123)), 'Symbol(123)');
-  assert.equal(util.inspect(Symbol('hi')), 'Symbol(hi)');
-  assert.equal(util.inspect([Symbol()]), '[ Symbol() ]');
-  assert.equal(util.inspect({ foo: Symbol() }), '{ foo: Symbol() }');
+  assert.strictEqual(util.inspect(Symbol()), 'Symbol()');
+  assert.strictEqual(util.inspect(Symbol(123)), 'Symbol(123)');
+  assert.strictEqual(util.inspect(Symbol('hi')), 'Symbol(hi)');
+  assert.strictEqual(util.inspect([Symbol()]), '[ Symbol() ]');
+  assert.strictEqual(util.inspect({ foo: Symbol() }), '{ foo: Symbol() }');
 
   const options = { showHidden: true };
   let subject = {};
 
   subject[Symbol('symbol')] = 42;
 
-  assert.equal(util.inspect(subject), '{}');
-  assert.equal(util.inspect(subject, options), '{ [Symbol(symbol)]: 42 }');
+  assert.strictEqual(util.inspect(subject), '{}');
+  assert.strictEqual(
+    util.inspect(subject, options),
+    '{ [Symbol(symbol)]: 42 }'
+  );
 
   subject = [1, 2, 3];
   subject[Symbol('symbol')] = 42;
 
-  assert.equal(util.inspect(subject), '[ 1, 2, 3 ]');
-  assert.equal(util.inspect(subject, options),
+  assert.strictEqual(util.inspect(subject), '[ 1, 2, 3 ]');
+  assert.strictEqual(util.inspect(subject, options),
       '[ 1, 2, 3, [length]: 3, [Symbol(symbol)]: 42 ]');
 }
 
 // test Set
-assert.equal(util.inspect(new Set()), 'Set {}');
-assert.equal(util.inspect(new Set([1, 2, 3])), 'Set { 1, 2, 3 }');
+assert.strictEqual(util.inspect(new Set()), 'Set {}');
+assert.strictEqual(util.inspect(new Set([1, 2, 3])), 'Set { 1, 2, 3 }');
 var set = new Set(['foo']);
 set.bar = 42;
-assert.equal(util.inspect(set, true), 'Set { \'foo\', [size]: 1, bar: 42 }');
+assert.strictEqual(
+  util.inspect(set, true),
+  'Set { \'foo\', [size]: 1, bar: 42 }'
+);
 
 // test Map
 {
-  assert.equal(util.inspect(new Map()), 'Map {}');
-  assert.equal(util.inspect(new Map([[1, 'a'], [2, 'b'], [3, 'c']])),
+  assert.strictEqual(util.inspect(new Map()), 'Map {}');
+  assert.strictEqual(util.inspect(new Map([[1, 'a'], [2, 'b'], [3, 'c']])),
                'Map { 1 => \'a\', 2 => \'b\', 3 => \'c\' }');
   const map = new Map([['foo', null]]);
   map.bar = 42;
-  assert.equal(util.inspect(map, true),
+  assert.strictEqual(util.inspect(map, true),
                'Map { \'foo\' => null, [size]: 1, bar: 42 }');
 }
 
 // test Promise
-assert.equal(util.inspect(Promise.resolve(3)), 'Promise { 3 }');
-assert.equal(util.inspect(Promise.reject(3)), 'Promise { <rejected> 3 }');
-assert.equal(util.inspect(new Promise(function() {})), 'Promise { <pending> }');
+assert.strictEqual(util.inspect(Promise.resolve(3)), 'Promise { 3 }');
+assert.strictEqual(util.inspect(Promise.reject(3)), 'Promise { <rejected> 3 }');
+assert.strictEqual(
+  util.inspect(new Promise(function() {})),
+  'Promise { <pending> }'
+);
 var promise = Promise.resolve('foo');
 promise.bar = 42;
-assert.equal(util.inspect(promise), 'Promise { \'foo\', bar: 42 }');
+assert.strictEqual(util.inspect(promise), 'Promise { \'foo\', bar: 42 }');
 
 // Make sure it doesn't choke on polyfills. Unlike Set/Map, there is no standard
 // interface to synchronously inspect a Promise, so our techniques only work on
 // a bonafide native Promise.
 var oldPromise = Promise;
 global.Promise = function() { this.bar = 42; };
-assert.equal(util.inspect(new Promise()), '{ bar: 42 }');
+assert.strictEqual(util.inspect(new Promise()), '{ bar: 42 }');
 global.Promise = oldPromise;
 
 // Map/Set Iterators
@@ -591,7 +667,7 @@ function checkAlignment(container) {
     var npos = line.search(/\d/);
     if (npos !== -1) {
       if (pos !== undefined)
-        assert.equal(pos, npos, 'container items not aligned');
+        assert.strictEqual(pos, npos, 'container items not aligned');
       pos = npos;
     }
   });
@@ -624,22 +700,22 @@ checkAlignment(new Map(big_array.map(function(y) { return [y, null]; })));
 
   const x = new ObjectSubclass();
   x.foo = 42;
-  assert.equal(util.inspect(x),
+  assert.strictEqual(util.inspect(x),
                'ObjectSubclass { foo: 42 }');
-  assert.equal(util.inspect(new ArraySubclass(1, 2, 3)),
+  assert.strictEqual(util.inspect(new ArraySubclass(1, 2, 3)),
                'ArraySubclass [ 1, 2, 3 ]');
-  assert.equal(util.inspect(new SetSubclass([1, 2, 3])),
+  assert.strictEqual(util.inspect(new SetSubclass([1, 2, 3])),
                'SetSubclass { 1, 2, 3 }');
-  assert.equal(util.inspect(new MapSubclass([['foo', 42]])),
+  assert.strictEqual(util.inspect(new MapSubclass([['foo', 42]])),
               'MapSubclass { \'foo\' => 42 }');
-  assert.equal(util.inspect(new PromiseSubclass(function() {})),
+  assert.strictEqual(util.inspect(new PromiseSubclass(function() {})),
                'PromiseSubclass { <pending> }');
 }
 
 // Corner cases.
 {
   const x = { constructor: 42 };
-  assert.equal(util.inspect(x), '{ constructor: 42 }');
+  assert.strictEqual(util.inspect(x), '{ constructor: 42 }');
 }
 
 {
@@ -650,17 +726,17 @@ checkAlignment(new Map(big_array.map(function(y) { return [y, null]; })));
     },
     enumerable: true
   });
-  assert.equal(util.inspect(x), '{ constructor: [Getter] }');
+  assert.strictEqual(util.inspect(x), '{ constructor: [Getter] }');
 }
 
 {
   const x = new function() {};
-  assert.equal(util.inspect(x), '{}');
+  assert.strictEqual(util.inspect(x), '{}');
 }
 
 {
   const x = Object.create(null);
-  assert.equal(util.inspect(x), '{}');
+  assert.strictEqual(util.inspect(x), '{}');
 }
 
 // The following maxArrayLength tests were introduced after v6.0.0 was released.

From 72ad09a761762c4a9e3018f38dc1a6d88a9afef7 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Mon, 22 Aug 2016 14:19:58 -0700
Subject: [PATCH 2/2] squash: use assert() where it makes sense

---
 test/parallel/test-util-inspect.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index cf1475f993ea5f..3632df86654fb0 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -343,9 +343,9 @@ try {
   assert.strictEqual(util.inspect(e), e.stack);
 }
 var ex = util.inspect(new Error('FAIL'), true);
-assert.strictEqual(ex.includes('Error: FAIL'), true);
-assert.strictEqual(ex.includes('[stack]'), true);
-assert.strictEqual(ex.includes('[message]'), true);
+assert(ex.includes('Error: FAIL'));
+assert(ex.includes('[stack]'));
+assert(ex.includes('[message]'));
 // Doesn't capture stack trace
 function BadCustomError(msg) {
   Error.call(this);