test: improve chained property readability

A new version of ESLint flags chained properties on multiple lines that
were not flagged by the previous version of ESLint. In preparation for
turning that feature on, adjust alignment to that expected by the
linter.

This change happened to be predominantly around assertions using
`assert()` and `assert.equal()`. These were changed to
`assert.strictEqual()` where possible.

PR-URL: https://github.com/nodejs/node/pull/7920
Reviewed-By: Michaël Zasso <mic.besace@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

test/parallel/test-buffer-includes.js

@@ -79,44 +79,64 @@ assert(!b.includes(Buffer.from('f'), 6));
 assert(!Buffer.from('ff').includes(Buffer.from('f'), 1, 'ucs2'));
 
 // test hex encoding
-assert(
+assert.strictEqual(
   Buffer.from(b.toString('hex'), 'hex')
-    .includes('64', 0, 'hex'));
+    .includes('64', 0, 'hex'),
-assert(
+  true
+);
+assert.strictEqual(
   Buffer.from(b.toString('hex'), 'hex')
-    .includes(Buffer.from('64', 'hex'), 0, 'hex'));
+    .includes(Buffer.from('64', 'hex'), 0, 'hex'),
+  true
+);
 
 // test base64 encoding
-assert(
+assert.strictEqual(
   Buffer.from(b.toString('base64'), 'base64')
-    .includes('ZA==', 0, 'base64'));
+    .includes('ZA==', 0, 'base64'),
-assert(
+  true
+);
+assert.strictEqual(
   Buffer.from(b.toString('base64'), 'base64')
-    .includes(Buffer.from('ZA==', 'base64'), 0, 'base64'));
+    .includes(Buffer.from('ZA==', 'base64'), 0, 'base64'),
+  true
+);
 
 // test ascii encoding
-assert(
+assert.strictEqual(
   Buffer.from(b.toString('ascii'), 'ascii')
-    .includes('d', 0, 'ascii'));
+    .includes('d', 0, 'ascii'),
-assert(
+  true
+);
+assert.strictEqual(
   Buffer.from(b.toString('ascii'), 'ascii')
-    .includes(Buffer.from('d', 'ascii'), 0, 'ascii'));
+    .includes(Buffer.from('d', 'ascii'), 0, 'ascii'),
+  true
+);
 
 // test latin1 encoding
-assert(
+assert.strictEqual(
   Buffer.from(b.toString('latin1'), 'latin1')
-    .includes('d', 0, 'latin1'));
+    .includes('d', 0, 'latin1'),
-assert(
+  true
+);
+assert.strictEqual(
   Buffer.from(b.toString('latin1'), 'latin1')
-    .includes(Buffer.from('d', 'latin1'), 0, 'latin1'));
+    .includes(Buffer.from('d', 'latin1'), 0, 'latin1'),
+  true
+);
 
 // test binary encoding
-assert(
+assert.strictEqual(
   Buffer.from(b.toString('binary'), 'binary')
-    .includes('d', 0, 'binary'));
+    .includes('d', 0, 'binary'),
-assert(
+  true
+);
+assert.strictEqual(
   Buffer.from(b.toString('binary'), 'binary')
-    .includes(Buffer.from('d', 'binary'), 0, 'binary'));
+    .includes(Buffer.from('d', 'binary'), 0, 'binary'),
+  true
+);
 
 
 // test usc2 encoding

test/parallel/test-buffer-indexof.js

@@ -79,62 +79,94 @@ assert.equal(b.indexOf(Buffer.from('f'), 6), -1);
 assert.equal(Buffer.from('ff').indexOf(Buffer.from('f'), 1, 'ucs2'), -1);
 
 // test hex encoding
-assert.equal(
+assert.strictEqual(
   Buffer.from(b.toString('hex'), 'hex')
-    .indexOf('64', 0, 'hex'), 3);
+    .indexOf('64', 0, 'hex'),
-assert.equal(
+  3
+);
+assert.strictEqual(
   Buffer.from(b.toString('hex'), 'hex')
-    .indexOf(Buffer.from('64', 'hex'), 0, 'hex'), 3);
+    .indexOf(Buffer.from('64', 'hex'), 0, 'hex'),
+  3
+);
 
 // test base64 encoding
-assert.equal(
+assert.strictEqual(
   Buffer.from(b.toString('base64'), 'base64')
-    .indexOf('ZA==', 0, 'base64'), 3);
+    .indexOf('ZA==', 0, 'base64'),
-assert.equal(
+  3
+);
+assert.strictEqual(
   Buffer.from(b.toString('base64'), 'base64')
-    .indexOf(Buffer.from('ZA==', 'base64'), 0, 'base64'), 3);
+    .indexOf(Buffer.from('ZA==', 'base64'), 0, 'base64'),
+  3
+);
 
 // test ascii encoding
-assert.equal(
+assert.strictEqual(
   Buffer.from(b.toString('ascii'), 'ascii')
-    .indexOf('d', 0, 'ascii'), 3);
+    .indexOf('d', 0, 'ascii'),
-assert.equal(
+  3
+);
+assert.strictEqual(
   Buffer.from(b.toString('ascii'), 'ascii')
-    .indexOf(Buffer.from('d', 'ascii'), 0, 'ascii'), 3);
+    .indexOf(Buffer.from('d', 'ascii'), 0, 'ascii'),
+  3
+);
 
 // test latin1 encoding
-assert.equal(
+assert.strictEqual(
   Buffer.from(b.toString('latin1'), 'latin1')
-    .indexOf('d', 0, 'latin1'), 3);
+    .indexOf('d', 0, 'latin1'),
-assert.equal(
+  3
+);
+assert.strictEqual(
   Buffer.from(b.toString('latin1'), 'latin1')
-    .indexOf(Buffer.from('d', 'latin1'), 0, 'latin1'), 3);
+    .indexOf(Buffer.from('d', 'latin1'), 0, 'latin1'),
-assert.equal(
+  3
+);
+assert.strictEqual(
   Buffer.from('aa\u00e8aa', 'latin1')
-    .indexOf('\u00e8', 'latin1'), 2);
+    .indexOf('\u00e8', 'latin1'),
-assert.equal(
+  2
+);
+assert.strictEqual(
   Buffer.from('\u00e8', 'latin1')
-    .indexOf('\u00e8', 'latin1'), 0);
+    .indexOf('\u00e8', 'latin1'),
-assert.equal(
+  0
+);
+assert.strictEqual(
   Buffer.from('\u00e8', 'latin1')
-    .indexOf(Buffer.from('\u00e8', 'latin1'), 'latin1'), 0);
+    .indexOf(Buffer.from('\u00e8', 'latin1'), 'latin1'),
+  0
+);
 
 // test binary encoding
-assert.equal(
+assert.strictEqual(
   Buffer.from(b.toString('binary'), 'binary')
-    .indexOf('d', 0, 'binary'), 3);
+    .indexOf('d', 0, 'binary'),
-assert.equal(
+  3
+);
+assert.strictEqual(
   Buffer.from(b.toString('binary'), 'binary')
-    .indexOf(Buffer.from('d', 'binary'), 0, 'binary'), 3);
+    .indexOf(Buffer.from('d', 'binary'), 0, 'binary'),
-assert.equal(
+  3
+);
+assert.strictEqual(
   Buffer.from('aa\u00e8aa', 'binary')
-    .indexOf('\u00e8', 'binary'), 2);
+    .indexOf('\u00e8', 'binary'),
-assert.equal(
+  2
+);
+assert.strictEqual(
   Buffer.from('\u00e8', 'binary')
-    .indexOf('\u00e8', 'binary'), 0);
+    .indexOf('\u00e8', 'binary'),
-assert.equal(
+  0
+);
+assert.strictEqual(
   Buffer.from('\u00e8', 'binary')
-    .indexOf(Buffer.from('\u00e8', 'binary'), 'binary'), 0);
+    .indexOf(Buffer.from('\u00e8', 'binary'), 'binary'),
+  0
+);
 
 
 // test optional offset with passed encoding

test/parallel/test-cluster-worker-forced-exit.js

@@ -29,20 +29,16 @@ checkForced();
 
 function checkUnforced() {
   cluster.fork()
-  .on('online', function() {
+    .on('online', function() { this.disconnect(); })
-    this.disconnect();
-  })
     .on('exit', common.mustCall(function(status) {
-    assert.equal(status, SENTINEL);
+      assert.strictEqual(status, SENTINEL);
     }));
 }
 
 function checkForced() {
   cluster.fork()
-  .on('online', function() {
+    .on('online', function() { this.process.disconnect(); })
-    this.process.disconnect();
-  })
     .on('exit', common.mustCall(function(status) {
-    assert.equal(status, 0);
+      assert.strictEqual(status, 0);
     }));
 }

test/parallel/test-crypto-binary-default.js

@@ -324,19 +324,23 @@ var rfc2202_sha1 = [
 
 for (let i = 0, l = rfc2202_md5.length; i < l; i++) {
   if (!common.hasFipsCrypto) {
-    assert.equal(rfc2202_md5[i]['hmac'],
+    assert.strictEqual(
+      rfc2202_md5[i]['hmac'],
       crypto.createHmac('md5', rfc2202_md5[i]['key'])
         .update(rfc2202_md5[i]['data'])
         .digest('hex'),
-                 'Test HMAC-MD5 : Test case ' + (i + 1) + ' rfc 2202');
+      'Test HMAC-MD5 : Test case ' + (i + 1) + ' rfc 2202'
+    );
   }
 }
 for (let i = 0, l = rfc2202_sha1.length; i < l; i++) {
-  assert.equal(rfc2202_sha1[i]['hmac'],
+  assert.strictEqual(
+    rfc2202_sha1[i]['hmac'],
     crypto.createHmac('sha1', rfc2202_sha1[i]['key'])
       .update(rfc2202_sha1[i]['data'])
       .digest('hex'),
-               'Test HMAC-SHA1 : Test case ' + (i + 1) + ' rfc 2202');
+    'Test HMAC-SHA1 : Test case ' + (i + 1) + ' rfc 2202'
+  );
 }
 
 // Test hashing

test/parallel/test-crypto-hmac.js

@@ -351,17 +351,21 @@ var rfc2202_sha1 = [
 
 if (!common.hasFipsCrypto) {
   for (let i = 0, l = rfc2202_md5.length; i < l; i++) {
-    assert.equal(rfc2202_md5[i]['hmac'],
+    assert.strictEqual(
+      rfc2202_md5[i]['hmac'],
       crypto.createHmac('md5', rfc2202_md5[i]['key'])
         .update(rfc2202_md5[i]['data'])
         .digest('hex'),
-                 'Test HMAC-MD5 : Test case ' + (i + 1) + ' rfc 2202');
+      'Test HMAC-MD5 : Test case ' + (i + 1) + ' rfc 2202'
+    );
   }
 }
 for (let i = 0, l = rfc2202_sha1.length; i < l; i++) {
-  assert.equal(rfc2202_sha1[i]['hmac'],
+  assert.strictEqual(
+    rfc2202_sha1[i]['hmac'],
     crypto.createHmac('sha1', rfc2202_sha1[i]['key'])
       .update(rfc2202_sha1[i]['data'])
       .digest('hex'),
-               'Test HMAC-SHA1 : Test case ' + (i + 1) + ' rfc 2202');
+    'Test HMAC-SHA1 : Test case ' + (i + 1) + ' rfc 2202'
+  );
 }

test/parallel/test-readline-interface.js

@@ -346,14 +346,22 @@ function isWarned(emitter) {
   assert.equal(internalReadline.getStringWidth('A\ud83c\ude00BC'), 5);
 
   // check if vt control chars are stripped
-  assert.equal(internalReadline
+  assert.strictEqual(
-               .stripVTControlCharacters('\u001b[31m> \u001b[39m'), '> ');
+    internalReadline.stripVTControlCharacters('\u001b[31m> \u001b[39m'),
-  assert.equal(internalReadline
+    '> '
-               .stripVTControlCharacters('\u001b[31m> \u001b[39m> '), '> > ');
+  );
-  assert.equal(internalReadline
+  assert.strictEqual(
-               .stripVTControlCharacters('\u001b[31m\u001b[39m'), '');
+    internalReadline.stripVTControlCharacters('\u001b[31m> \u001b[39m> '),
-  assert.equal(internalReadline
+    '> > '
-               .stripVTControlCharacters('> '), '> ');
+  );
+  assert.strictEqual(
+    internalReadline.stripVTControlCharacters('\u001b[31m\u001b[39m'),
+    ''
+  );
+  assert.strictEqual(
+    internalReadline.stripVTControlCharacters('> '),
+    '> '
+  );
   assert.equal(internalReadline.getStringWidth('\u001b[31m> \u001b[39m'), 2);
   assert.equal(internalReadline.getStringWidth('\u001b[31m> \u001b[39m> '), 4);
   assert.equal(internalReadline.getStringWidth('\u001b[31m\u001b[39m'), 0);