assert.equal() -> assert.strictEqual()

Vitaly Puzrin · Vitaly Puzrin · commit e0c4e4e3dea0 · 2016-04-04T08:49:30.000+03:00
diff --git a/test/issues/0017.js b/test/issues/0017.js
@@ -9,5 +9,5 @@ var readFileSync = require('fs').readFileSync;
 test('Non-specific "!" tags should resolve to !!str', function () {
   var data = yaml.safeLoad(readFileSync(require('path').join(__dirname, '/0017.yml'), 'utf8'));
 
-  assert.equal(typeof data, 'string');
+  assert.strictEqual(typeof data, 'string');
 });
diff --git a/test/issues/0019.js b/test/issues/0019.js
@@ -10,5 +10,5 @@ test('Timestamp parsing is one month off', function () {
   var data = yaml.safeLoad(readFileSync(require('path').join(__dirname, '/0019.yml'), 'utf8'));
 
   // JS month starts with 0 (0 => Jan, 1 => Feb, ...)
-  assert.equal(data.xmas.getTime(), Date.UTC(2011, 11, 24));
+  assert.strictEqual(data.xmas.getTime(), Date.UTC(2011, 11, 24));
 });
diff --git a/test/issues/0026.js b/test/issues/0026.js
@@ -9,5 +9,5 @@ var readFileSync = require('fs').readFileSync;
 test('should convert new line into white space', function () {
   var data = yaml.safeLoad(readFileSync(require('path').join(__dirname, '/0026.yml'), 'utf8'));
 
-  assert.equal(data.test, 'a b c\n');
+  assert.strictEqual(data.test, 'a b c\n');
 });
diff --git a/test/issues/0046.js b/test/issues/0046.js
@@ -11,18 +11,18 @@ test('Timestamps are incorrectly parsed in local time', function () {
       date1, date2;
 
   date1 = data.date1; // date1: 2010-10-20T20:45:00Z
-  assert.equal(date1.getUTCFullYear(), 2010, 'year');
-  assert.equal(date1.getUTCMonth(), 9, 'month');
-  assert.equal(date1.getUTCDate(), 20, 'date');
-  assert.equal(date1.getUTCHours(), 20);
-  assert.equal(date1.getUTCMinutes(), 45);
-  assert.equal(date1.getUTCSeconds(), 0);
+  assert.strictEqual(date1.getUTCFullYear(), 2010, 'year');
+  assert.strictEqual(date1.getUTCMonth(), 9, 'month');
+  assert.strictEqual(date1.getUTCDate(), 20, 'date');
+  assert.strictEqual(date1.getUTCHours(), 20);
+  assert.strictEqual(date1.getUTCMinutes(), 45);
+  assert.strictEqual(date1.getUTCSeconds(), 0);
 
   date2 = data.date2; // date2: 2010-10-20T20:45:00+0100
-  assert.equal(date2.getUTCFullYear(), 2010, 'year');
-  assert.equal(date2.getUTCMonth(), 9, 'month');
-  assert.equal(date2.getUTCDate(), 20, 'date');
-  assert.equal(date2.getUTCHours(), 19);
-  assert.equal(date2.getUTCMinutes(), 45);
-  assert.equal(date2.getUTCSeconds(), 0);
+  assert.strictEqual(date2.getUTCFullYear(), 2010, 'year');
+  assert.strictEqual(date2.getUTCMonth(), 9, 'month');
+  assert.strictEqual(date2.getUTCDate(), 20, 'date');
+  assert.strictEqual(date2.getUTCHours(), 19);
+  assert.strictEqual(date2.getUTCMinutes(), 45);
+  assert.strictEqual(date2.getUTCSeconds(), 0);
 });
diff --git a/test/issues/0054.js b/test/issues/0054.js
@@ -23,6 +23,6 @@ test("Incorrect utf-8 handling on require('file.yaml')", function () {
   // make sure none of the strings were corrupted.
   //
   for (index = 0; index < 40; index += 1) {
-    assert.equal(data[index], expected, ('Line ' + index + ' is corrupted'));
+    assert.strictEqual(data[index], expected, ('Line ' + index + ' is corrupted'));
   }
 });
diff --git a/test/issues/0110.js b/test/issues/0110.js
@@ -20,9 +20,9 @@ test('Circular and cross references', function () {
 
   var obtained = yaml.load(yaml.dump(source));
 
-  assert.equal(obtained.crossObject, obtained.a);
-  assert.equal(obtained.crossArray, obtained.b);
-  assert.equal(obtained.c.circularObject, obtained);
-  assert.equal(obtained.d[0], obtained.d);
-  assert.equal(obtained.d[1], obtained);
+  assert.strictEqual(obtained.crossObject, obtained.a);
+  assert.strictEqual(obtained.crossArray, obtained.b);
+  assert.strictEqual(obtained.c.circularObject, obtained);
+  assert.strictEqual(obtained.d[0], obtained.d);
+  assert.strictEqual(obtained.d[1], obtained);
 });
diff --git a/test/issues/0123.js b/test/issues/0123.js
@@ -17,8 +17,8 @@ test('RegExps should be properly closed', function () {
   // Accept the old (slightly incorrect) V8, as well as the new V8 result
   // TODO: Remove when/if Node 0.12 and below is no longer supported.
   if (regexpStr === '/fo/g/g') {
-    assert.equal(regexpStr, '/fo/g/g');
+    assert.strictEqual(regexpStr, '/fo/g/g');
   } else {
-    assert.equal(regexpStr, '/fo\\/g/g');
+    assert.strictEqual(regexpStr, '/fo\\/g/g');
   }
 });
diff --git a/test/issues/0194.js b/test/issues/0194.js
@@ -17,5 +17,5 @@ test('Don\'t throw on warning', function () {
 
   yaml.safeLoad(src, { onWarning: function (e) { warnings.push(e); } });
 
-  assert.equal(warnings.length, 1);
+  assert.strictEqual(warnings.length, 1);
 });
diff --git a/test/issues/0205.js b/test/issues/0205.js
@@ -11,8 +11,8 @@ test('Duplicated objects within array', function () {
 
   var obtained = yaml.load(yaml.dump(arrayWithRefs));
 
-  assert.equal(obtained[0].test, 'canary');
-  assert.equal(obtained[0], obtained[1]);
+  assert.strictEqual(obtained[0].test, 'canary');
+  assert.strictEqual(obtained[0], obtained[1]);
 });
 
 test('Duplicated arrays within array', function () {
@@ -21,7 +21,7 @@ test('Duplicated arrays within array', function () {
 
   var obtained = yaml.load(yaml.dump(arrayWithRefs));
 
-  assert.equal(obtained[0][0], 0);
-  assert.equal(obtained[0][1], 1);
-  assert.equal(obtained[0], obtained[1]);
+  assert.strictEqual(obtained[0][0], 0);
+  assert.strictEqual(obtained[0][1], 1);
+  assert.strictEqual(obtained[0], obtained[1]);
 });
diff --git a/test/issues/0217.js b/test/issues/0217.js
@@ -25,7 +25,7 @@ test('Folding Javascript functions preserves content', function () {
   // Tests loading a function, then tests dumping and loading.
   function assertFunctionPreserved(functionString, inputs, expectedOutputs, name) {
     var f = yaml.load('!<tag:yaml.org,2002:js/function> "' + functionString + '"');
-    assert.equal(typeof f, 'function', name + ' should be loaded as a function');
+    assert.strictEqual(typeof f, 'function', name + ' should be loaded as a function');
 
     assert.deepEqual(inputs.map(f), expectedOutputs,
       name + ' should be loaded correctly');
diff --git a/test/issues/0248-listener.js b/test/issues/0248-listener.js
@@ -12,13 +12,13 @@ test('Listener informed on a very simple scalar.', function () {
   yaml.load('a_simple_scalar', { listener: l });
 
   // 2 open events then 2 close events
-  assert.equal(history.length, 4);
-  assert.equal(history[0][0], 'open');
-  assert.equal(history[1][0], 'open');
-  assert.equal(history[2][0], 'close');
-  assert.equal(history[3][0], 'close');
-  assert.equal(history[0][1], 0);
-  assert.equal(history[3][1], 16);
+  assert.strictEqual(history.length, 4);
+  assert.strictEqual(history[0][0], 'open');
+  assert.strictEqual(history[1][0], 'open');
+  assert.strictEqual(history[2][0], 'close');
+  assert.strictEqual(history[3][0], 'close');
+  assert.strictEqual(history[0][1], 0);
+  assert.strictEqual(history[3][1], 16);
 });
 
 test('Listener informed on a map with a list.', function () {
@@ -30,33 +30,33 @@ test('Listener informed on a map with a list.', function () {
   yaml.load('{ a: 1, b: [ 0, xyz ] }', { listener: l });
 
   var i = -1;
-  assert.equal(history[++i][0], 'open'); // doc
-  assert.equal(history[++i][0], 'open'); // map
+  assert.strictEqual(history[++i][0], 'open'); // doc
+  assert.strictEqual(history[++i][0], 'open'); // map
 
-  assert.equal(history[++i][0], 'open'); // key
-  assert.equal(history[++i][0], 'close');
-  assert.equal(history[i][2], 'a');
+  assert.strictEqual(history[++i][0], 'open'); // key
+  assert.strictEqual(history[++i][0], 'close');
+  assert.strictEqual(history[i][2], 'a');
 
-  assert.equal(history[++i][0], 'open'); // a value
-  assert.equal(history[++i][0], 'close');
-  assert.equal(history[i][2], 1);
+  assert.strictEqual(history[++i][0], 'open'); // a value
+  assert.strictEqual(history[++i][0], 'close');
+  assert.strictEqual(history[i][2], 1);
 
-  assert.equal(history[++i][0], 'open'); // key
-  assert.equal(history[++i][0], 'close');
-  assert.equal(history[i][2], 'b');
+  assert.strictEqual(history[++i][0], 'open'); // key
+  assert.strictEqual(history[++i][0], 'close');
+  assert.strictEqual(history[i][2], 'b');
 
-  assert.equal(history[++i][0], 'open'); // b value (list)
-  assert.equal(history[++i][0], 'open'); // item in list
-  assert.equal(history[++i][0], 'close');
-  assert.equal(history[i][2], 0);
-  assert.equal(history[++i][0], 'open'); // item in list
-  assert.equal(history[++i][0], 'close');
+  assert.strictEqual(history[++i][0], 'open'); // b value (list)
+  assert.strictEqual(history[++i][0], 'open'); // item in list
+  assert.strictEqual(history[++i][0], 'close');
+  assert.strictEqual(history[i][2], 0);
+  assert.strictEqual(history[++i][0], 'open'); // item in list
+  assert.strictEqual(history[++i][0], 'close');
 
-  assert.equal(history[++i][0], 'close'); // b value (list) end
+  assert.strictEqual(history[++i][0], 'close'); // b value (list) end
   assert.deepEqual(history[i][2], [ 0, 'xyz' ]);
 
-  assert.equal(history[++i][0], 'close'); // map end
-  assert.equal(history[++i][0], 'close'); // doc end
+  assert.strictEqual(history[++i][0], 'close'); // map end
+  assert.strictEqual(history[++i][0], 'close'); // doc end
 
-  assert.equal(history.length, ++i);
+  assert.strictEqual(history.length, ++i);
 });
diff --git a/test/units/dump-scalar-styles.js b/test/units/dump-scalar-styles.js
@@ -33,69 +33,69 @@ suite('Scalar style dump:', function () {
         '100% safe non-first characters? Of course!',
         'Jack & Jill <well@example.com>'
       ].forEach(function (string) {
-        assert.equal(yaml.safeDump(string), string + '\n');
+        assert.strictEqual(yaml.safeDump(string), string + '\n');
       });
     });
 
     test('disallows flow indicators inside flow collections', function () {
-      assert.equal(yaml.safeDump({ quote: 'mispell [sic]' }, { flowLevel: 0 }),
+      assert.strictEqual(yaml.safeDump({ quote: 'mispell [sic]' }, { flowLevel: 0 }),
         "{quote: 'mispell [sic]'}\n");
-      assert.equal(yaml.safeDump({ key: 'no commas, either' }, { flowLevel: 0 }),
+      assert.strictEqual(yaml.safeDump({ key: 'no commas, either' }, { flowLevel: 0 }),
         "{key: 'no commas, either'}\n");
     });
   });
 
   suite('Single- and double-quoted styles', function () {
     test('quote strings of ambiguous type', function () {
-      assert.equal(yaml.safeDump('Yes'), '\'Yes\'\n');
-      assert.equal(yaml.safeDump('true'), '\'true\'\n');
-      assert.equal(yaml.safeDump('42'), '\'42\'\n');
-      assert.equal(yaml.safeDump('99.9'), '\'99.9\'\n');
-      assert.equal(yaml.safeDump('127.0001'), '\'127.0001\'\n');
-      assert.equal(yaml.safeDump('1.23015e+3'), '\'1.23015e+3\'\n');
+      assert.strictEqual(yaml.safeDump('Yes'), '\'Yes\'\n');
+      assert.strictEqual(yaml.safeDump('true'), '\'true\'\n');
+      assert.strictEqual(yaml.safeDump('42'), '\'42\'\n');
+      assert.strictEqual(yaml.safeDump('99.9'), '\'99.9\'\n');
+      assert.strictEqual(yaml.safeDump('127.0001'), '\'127.0001\'\n');
+      assert.strictEqual(yaml.safeDump('1.23015e+3'), '\'1.23015e+3\'\n');
     });
 
     test('quote leading/trailing whitespace', function () {
-      assert.equal(yaml.safeDump(' leading space'), '\' leading space\'\n');
-      assert.equal(yaml.safeDump('trailing space '), '\'trailing space \'\n');
+      assert.strictEqual(yaml.safeDump(' leading space'), '\' leading space\'\n');
+      assert.strictEqual(yaml.safeDump('trailing space '), '\'trailing space \'\n');
     });
 
     test('quote leading quotes', function () {
-      assert.equal(yaml.safeDump("'singles double'"), "'''singles double'''\n");
-      assert.equal(yaml.safeDump('"single double'), '\'"single double\'\n');
+      assert.strictEqual(yaml.safeDump("'singles double'"), "'''singles double'''\n");
+      assert.strictEqual(yaml.safeDump('"single double'), '\'"single double\'\n');
     });
 
     test('escape non-printables', function () {
-      assert.equal(yaml.safeDump('a\nb\u0001c'), '"a\\nb\\x01c"\n');
+      assert.strictEqual(yaml.safeDump('a\nb\u0001c'), '"a\\nb\\x01c"\n');
     });
   });
 
   suite('Literal style', function () {
     var content = 'a\nb \n\n c\n  d', indented = indent(content);
 
     test('preserves trailing newlines using chomping', function () {
-      assert.equal(yaml.safeDump({ a: '\n', b: '\n\n', c: 'c\n', d: 'd\nd' }),
+      assert.strictEqual(yaml.safeDump({ a: '\n', b: '\n\n', c: 'c\n', d: 'd\nd' }),
         'a: |+\n\nb: |+\n\n\nc: |\n  c\nd: |-\n  d\n  d\n');
-      assert.equal(yaml.safeDump('\n'),               '|+\n' + '\n');
-      assert.equal(yaml.safeDump('\n\n'),             '|+\n' + '\n\n');
+      assert.strictEqual(yaml.safeDump('\n'),               '|+\n' + '\n');
+      assert.strictEqual(yaml.safeDump('\n\n'),             '|+\n' + '\n\n');
 
-      assert.equal(yaml.safeDump(content),            '|-\n' + indented + '\n');
-      assert.equal(yaml.safeDump(content + '\n'),     '|\n'  + indented + '\n');
-      assert.equal(yaml.safeDump(content + '\n\n'),   '|+\n' + indented + '\n\n');
-      assert.equal(yaml.safeDump(content + '\n\n\n'), '|+\n' + indented + '\n\n\n');
+      assert.strictEqual(yaml.safeDump(content),            '|-\n' + indented + '\n');
+      assert.strictEqual(yaml.safeDump(content + '\n'),     '|\n'  + indented + '\n');
+      assert.strictEqual(yaml.safeDump(content + '\n\n'),   '|+\n' + indented + '\n\n');
+      assert.strictEqual(yaml.safeDump(content + '\n\n\n'), '|+\n' + indented + '\n\n\n');
     });
 
     test('accepts leading whitespace', function () {
-      assert.equal(yaml.safeDump('   ' + content), '|2-\n   ' + indented + '\n');
+      assert.strictEqual(yaml.safeDump('   ' + content), '|2-\n   ' + indented + '\n');
     });
 
     test('falls back to quoting when required indent indicator is too large', function () {
-      assert.equal(yaml.safeDump(' these go\nup to\neleven', { indent: 11 }),
+      assert.strictEqual(yaml.safeDump(' these go\nup to\neleven', { indent: 11 }),
         '" these go\\nup to\\neleven"\n');
     });
 
     test('does not use block style for multiline key', function () {
-      assert.equal(yaml.safeDump({
+      assert.strictEqual(yaml.safeDump({
         'push\nand': {
           you: 'pull'
         }
@@ -150,25 +150,25 @@ suite('Scalar style dump:', function () {
       }
 
       test('wraps lines and ignores more-indented lines ', function () {
-        assert.equal(dumpNarrow(content),            '>-\n' + indented + '\n');
+        assert.strictEqual(dumpNarrow(content),            '>-\n' + indented + '\n');
       });
 
       test('preserves trailing newlines using chomping', function () {
-        assert.equal(dumpNarrow(content + '\n'),     '>\n'  + indented + '\n');
-        assert.equal(dumpNarrow(content + '\n\n'),   '>+\n' + indented + '\n\n');
-        assert.equal(dumpNarrow(content + '\n\n\n'), '>+\n' + indented + '\n\n\n');
+        assert.strictEqual(dumpNarrow(content + '\n'),     '>\n'  + indented + '\n');
+        assert.strictEqual(dumpNarrow(content + '\n\n'),   '>+\n' + indented + '\n\n');
+        assert.strictEqual(dumpNarrow(content + '\n\n\n'), '>+\n' + indented + '\n\n\n');
       });
     }());
 
     // Dump and check that dump-then-load preserves content (is the identity function).
     function dump(input, opts) {
       var output = yaml.safeDump(input, opts);
-      assert.equal(yaml.safeLoad(output), input, 'Dump then load should preserve content');
+      assert.strictEqual(yaml.safeLoad(output), input, 'Dump then load should preserve content');
       return output;
     }
 
     test('should not cut off a long word at the start of a line', function () {
-      assert.equal(dump('123\n' + repeat('1234567890', 9) + ' hello\ngoodbye'),
+      assert.strictEqual(dump('123\n' + repeat('1234567890', 9) + ' hello\ngoodbye'),
         '>-\n' + indent(
           '123\n' +
           '\n' +
@@ -181,7 +181,7 @@ suite('Scalar style dump:', function () {
     test('preserves consecutive spaces', function () {
       var alphabet = 'a bc  def  ghi' + repeat(' ', 70) + 'jk  lmn o\n'
         + ' p  qrstu     v' + repeat(' ', 80) + '\nw x\n' + 'yz  ';
-      assert.equal(dump(alphabet),
+      assert.strictEqual(dump(alphabet),
         '>-\n' + indent(
           'a bc  def \n' +
           'ghi' + repeat(' ', 70) + 'jk \n' +
@@ -195,7 +195,7 @@ suite('Scalar style dump:', function () {
         [ 2, 3, 5, 7, 11, 13, 17 ]
         .map(function (n) { return repeat(' ', n); })
         .join('\n');
-      assert.equal(dump(indeed),
+      assert.strictEqual(dump(indeed),
       '>-\n' + indent(
         'word. word. word. word. word. word. word. word. word. word. word. word. word.\n' +
         'word. word. word. word. word. word. word. word. word. word. word. word. word.\n' +
@@ -229,13 +229,13 @@ suite('Scalar style dump:', function () {
     test('should not fold when lineWidth === -1', function () {
       var content = [ prefix, line, line + line, line ].join('\n');
 
-      assert.equal(dump(content, { lineWidth: -1 }), '|-\n' + indent(content) + '\n');
+      assert.strictEqual(dump(content, { lineWidth: -1 }), '|-\n' + indent(content) + '\n');
     });
 
     test('falls back to literal style when no lines are foldable', function () {
       var content = [ prefix, '    ' + line, '    ' + line ].join('\n');
 
-      assert.equal(dump(content), '|-\n' + indent(content) + '\n');
+      assert.strictEqual(dump(content), '|-\n' + indent(content) + '\n');
     });
   });
 });

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,6 @@ test("Incorrect utf-8 handling on require('file.yaml')", function () {`
`23`	`23`	`// make sure none of the strings were corrupted.`
`24`	`24`	`//`
`25`	`25`	`for (index = 0; index < 40; index += 1) {`
`26`		`- assert.equal(data[index], expected, ('Line ' + index + ' is corrupted'));`
	`26`	`+ assert.strictEqual(data[index], expected, ('Line ' + index + ' is corrupted'));`
`27`	`27`	`}`
`28`	`28`	`});`