test, eslintrc: s/assert.equal/assert.strictEqual/

.eslintrc

@@ -62,17 +62,21 @@ rules:
   no-new-require: 2
   no-path-concat: 2
   no-restricted-modules: [2, sys, _linklist]
-  no-restricted-properties: [2, {
-    object: assert,
-    property: deepEqual,
-    message: Please use assert.deepStrictEqual().
-  }, {
-    property: __defineGetter__,
-    message: __defineGetter__ is deprecated.
-  }, {
-    property: __defineSetter__,
-    message: __defineSetter__ is deprecated.
-  }]
+  no-restricted-properties:
+    - 2
+    - object: assert
+      property: deepEqual
+      message: Use assert.deepStrictEqual().
+    - object: assert
+      property: equal
+      message: Use assert.strictEqual() rather than assert.equal().
+    - object: assert
+      property: notEqual
+      message: Use assert.notStrictEqual() rather than assert.notEqual().
+    - property: __defineGetter__
+      message: __defineGetter__ is deprecated.
+    - property: __defineSetter__,
+      message: __defineSetter__ is deprecated.
 
   # Stylistic Issues
   # http://eslint.org/docs/rules/#stylistic-issues
@@ -86,7 +90,7 @@ rules:
   func-name-matching: 2
   indent: [2, 2, {ArrayExpression: first,
                   CallExpression: {arguments: first},
-                  MemberExpression: 1, 
+                  MemberExpression: 1,
                   ObjectExpression: first,
                   SwitchCase: 1}]
   key-spacing: [2, {mode: minimum}]

lib/assert.js

@@ -109,7 +109,7 @@ assert.ok = ok;
 // The equality assertion tests shallow, coercive equality with
 // ==.
 // assert.equal(actual, expected, message_opt);
-
+/* eslint-disable no-restricted-properties */
 assert.equal = function equal(actual, expected, message) {
   if (actual != expected) fail(actual, expected, message, '==', assert.equal);
 };
@@ -127,7 +127,6 @@ assert.notEqual = function notEqual(actual, expected, message) {
 // The equivalence assertion tests a deep equality relation.
 // assert.deepEqual(actual, expected, message_opt);
 
-/* eslint-disable no-restricted-properties */
 assert.deepEqual = function deepEqual(actual, expected, message) {
   if (!_deepEqual(actual, expected, false)) {
     fail(actual, expected, message, 'deepEqual', assert.deepEqual);

test/disabled/test-fs-largefile.js

@@ -9,22 +9,22 @@ const path = require('path'),
     message = 'Large File';
 
 fs.truncateSync(fd, offset);
-assert.equal(fs.statSync(filepath).size, offset);
+assert.strictEqual(fs.statSync(filepath).size, offset);
 var writeBuf = Buffer.from(message);
 fs.writeSync(fd, writeBuf, 0, writeBuf.length, offset);
 var readBuf = Buffer.allocUnsafe(writeBuf.length);
 fs.readSync(fd, readBuf, 0, readBuf.length, offset);
-assert.equal(readBuf.toString(), message);
+assert.strictEqual(readBuf.toString(), message);
 fs.readSync(fd, readBuf, 0, 1, 0);
-assert.equal(readBuf[0], 0);
+assert.strictEqual(readBuf[0], 0);
 
 var exceptionRaised = false;
 try {
   fs.writeSync(fd, writeBuf, 0, writeBuf.length, 42.000001);
 } catch (err) {
   console.log(err);
   exceptionRaised = true;
-  assert.equal(err.message, 'Not an integer');
+  assert.strictEqual(err.message, 'Not an integer');
 }
 assert.ok(exceptionRaised);
 fs.close(fd);

test/disabled/test-http-abort-stream-end.js

@@ -36,6 +36,6 @@ s.listen(common.PORT, function() {
 
 process.on('exit', function() {
   assert(aborted);
-  assert.equal(size, maxSize);
+  assert.strictEqual(size, maxSize);
   console.log('ok');
 });

test/disabled/test-readline.js

@@ -49,12 +49,12 @@ var rl = readlineFakeStream();
 var written_bytes_length, refreshed;
 
 rl.write('foo');
-assert.equal(3, rl.cursor);
+assert.strictEqual(3, rl.cursor);
 [key.xterm, key.rxvt, key.gnome, key.putty].forEach(function(key) {
   rl.write.apply(rl, key.home);
-  assert.equal(0, rl.cursor);
+  assert.strictEqual(0, rl.cursor);
   rl.write.apply(rl, key.end);
-  assert.equal(3, rl.cursor);
+  assert.strictEqual(3, rl.cursor);
 });
 
 rl = readlineFakeStream();
@@ -76,9 +76,9 @@ rl.write.apply(rl, key.xterm.home);
 ].forEach(function(action) {
   written_bytes_length = rl.written_bytes.length;
   rl.write.apply(rl, action.key);
-  assert.equal(action.cursor, rl.cursor);
+  assert.strictEqual(action.cursor, rl.cursor);
   refreshed = written_bytes_length !== rl.written_bytes.length;
-  assert.equal(true, refreshed);
+  assert.strictEqual(true, refreshed);
 });
 
 rl = readlineFakeStream();
@@ -93,7 +93,7 @@ rl.write.apply(rl, key.xterm.home);
   ''
 ].forEach(function(expectedLine) {
   rl.write.apply(rl, key.xterm.metad);
-  assert.equal(0, rl.cursor);
-  assert.equal(expectedLine, rl.line);
+  assert.strictEqual(0, rl.cursor);
+  assert.strictEqual(expectedLine, rl.line);
 });
 rl.close();

test/disabled/test-sendfd.js

@@ -63,7 +63,7 @@ var logChild = function(d) {
 // validate any data sent back by the child. We send the write end of the
 // pipe to the child and close it off in our process.
 var pipeFDs = netBinding.pipe();
-assert.equal(pipeFDs.length, 2);
+assert.strictEqual(pipeFDs.length, 2);
 
 var seenOrdinals = [];
 
@@ -72,8 +72,8 @@ pipeReadStream.on('data', function(data) {
   data.toString('utf8').trim().split('\n').forEach(function(d) {
     var rd = JSON.parse(d);
 
-    assert.equal(rd.pid, cpp);
-    assert.equal(seenOrdinals.indexOf(rd.ord), -1);
+    assert.strictEqual(rd.pid, cpp);
+    assert.strictEqual(seenOrdinals.indexOf(rd.ord), -1);
 
     seenOrdinals.unshift(rd.ord);
   });
@@ -119,8 +119,8 @@ cp.on('exit', function(code, signal) {
   srv.close();
   // fs.unlinkSync(SOCK_PATH);
 
-  assert.equal(code, 0);
-  assert.equal(seenOrdinals.length, 2);
+  assert.strictEqual(code, 0);
+  assert.strictEqual(seenOrdinals.length, 2);
 });
 
 // vim:ts=2 sw=2 et

test/disabled/test-setuidgid.js

@@ -16,7 +16,7 @@ assert.notStrictEqual(newuid, olduid, 'uids expected to be different');
 try {
   process.setuid('nobody1234');
 } catch (e) {
-  assert.equal(e.message,
+  assert.strictEqual(e.message,
                'failed to resolve group',
                'unexpected error message'
   );

test/fixtures/GH-892-request.js

@@ -16,7 +16,7 @@ var options = {
 };
 
 var req = https.request(options, function(res) {
-  assert.equal(200, res.statusCode);
+  assert.strictEqual(200, res.statusCode);
   gotResponse = true;
   console.error('DONE');
   res.resume();

test/fixtures/b/c.js

@@ -4,7 +4,7 @@ const assert = require('assert');
 
 const package = require('./package');
 
-assert.equal('world', package.hello);
+assert.strictEqual('world', package.hello);
 
 console.error('load fixtures/b/c.js');
 

test/internet/test-dns-txt-sigsegv.js

@@ -4,6 +4,6 @@ const assert = require('assert');
 const dns = require('dns');
 
 dns.resolveTxt('www.microsoft.com', function(err, records) {
-  assert.equal(err, null);
-  assert.equal(records.length, 0);
+  assert.strictEqual(err, null);
+  assert.strictEqual(records.length, 0);
 });

test/message/error_exit.js

@@ -6,4 +6,4 @@ process.on('exit', function(code) {
   console.error('Exiting with code=%d', code);
 });
 
-assert.equal(1, 2);
+assert.strictEqual(1, 2);

test/message/error_exit.out

@@ -3,7 +3,7 @@ Exiting with code=1
 assert.js:*
   throw new assert.AssertionError({
   ^
-AssertionError: 1 == 2
+AssertionError: 1 === 2
     at Object.<anonymous> (*test*message*error_exit.js:*:*)
     at Module._compile (module.js:*:*)
     at Object.Module._extensions..js (module.js:*:*)

test/parallel/test-assert.js

@@ -333,9 +333,9 @@ try {
   threw = true;
   assert.ok(e instanceof TypeError, 'type');
 }
-assert.equal(true, threw,
-             'a.throws with an explicit error is eating extra errors',
-             a.AssertionError);
+assert.strictEqual(true, threw,
+                   'a.throws with an explicit error is eating extra errors',
+                   a.AssertionError);
 threw = false;
 
 // doesNotThrow should pass through all errors
@@ -345,8 +345,8 @@ try {
   threw = true;
   assert.ok(e instanceof TypeError);
 }
-assert.equal(true, threw,
-             'a.doesNotThrow with an explicit error is eating extra errors');
+assert.strictEqual(true, threw, 'a.doesNotThrow with an explicit error is ' +
+                   'eating extra errors');
 
 // key difference is that throwing our correct error makes an assertion error
 try {
@@ -355,8 +355,8 @@ try {
   threw = true;
   assert.ok(e instanceof a.AssertionError);
 }
-assert.equal(true, threw,
-             'a.doesNotThrow is not catching type matching errors');
+assert.strictEqual(true, threw,
+                   'a.doesNotThrow is not catching type matching errors');
 
 assert.throws(function() { assert.ifError(new Error('test error')); });
 assert.doesNotThrow(function() { assert.ifError(null); });
@@ -461,10 +461,10 @@ circular.x = circular;
 
 function testAssertionMessage(actual, expected) {
   try {
-    assert.equal(actual, '');
+    assert.strictEqual(actual, '');
   } catch (e) {
-    assert.equal(e.toString(),
-                 ['AssertionError:', expected, '==', '\'\''].join(' '));
+    assert.strictEqual(e.toString(),
+                       ['AssertionError:', expected, '===', '\'\''].join(' '));
     assert.ok(e.generatedMessage, 'Message not marked as generated');
   }
 }
@@ -499,24 +499,24 @@ try {
   });
 } catch (e) {
   threw = true;
-  assert.equal(e.message, 'Missing expected exception..');
+  assert.strictEqual(e.message, 'Missing expected exception..');
 }
 assert.ok(threw);
 
 // #5292
 try {
-  assert.equal(1, 2);
+  assert.strictEqual(1, 2);
 } catch (e) {
-  assert.equal(e.toString().split('\n')[0], 'AssertionError: 1 == 2');
+  assert.strictEqual(e.toString().split('\n')[0], 'AssertionError: 1 === 2');
   assert.ok(e.generatedMessage, 'Message not marked as generated');
 }
 
 try {
-  assert.equal(1, 2, 'oh no');
+  assert.strictEqual(1, 2, 'oh no');
 } catch (e) {
-  assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no');
-  assert.equal(e.generatedMessage, false,
-               'Message incorrectly marked as generated');
+  assert.strictEqual(e.toString().split('\n')[0], 'AssertionError: oh no');
+  assert.strictEqual(e.generatedMessage, false,
+                     'Message incorrectly marked as generated');
 }
 
 // Verify that throws() and doesNotThrow() throw on non-function block
@@ -527,8 +527,8 @@ function testBlockTypeError(method, block) {
     method(block);
     threw = false;
   } catch (e) {
-    assert.equal(e.toString(),
-                 'TypeError: "block" argument must be a function');
+    assert.strictEqual(e.toString(),
+                       'TypeError: "block" argument must be a function');
   }
 
   assert.ok(threw);