handle NaN properly in assertions

Fixes: chaijs#498

Author: thefourtheye

lib/chai/core/assertions.js

@@ -446,7 +446,7 @@ module.exports = function (chai, _) {
    * ### .NaN
    * Asserts that the target is `NaN`.
    *
-   *     expect('foo').to.be.NaN;
+   *     expect(NaN).to.be.NaN;
    *     expect(4).not.to.be.NaN;
    *
    * @name NaN
@@ -456,7 +456,7 @@ module.exports = function (chai, _) {
 
   Assertion.addProperty('NaN', function () {
     this.assert(
-        isNaN(flag(this, 'object'))
+        _.isNaN(flag(this, 'object'))
         , 'expected #{this} to be NaN'
         , 'expected #{this} not to be NaN'
     );

lib/chai/interface/assert.js

@@ -431,7 +431,7 @@ module.exports = function (chai, util) {
    * ### .isNaN
    * Asserts that value is NaN
    *
-   *    assert.isNaN('foo', 'foo is NaN');
+   *    assert.isNaN(NaN, 'NaN is NaN');
    *
    * @name isNaN
    * @param {Mixed} value

lib/chai/utils/index.js

@@ -158,3 +158,9 @@ exports.checkError = require('check-error');
  */
 
 exports.proxify = require('./proxify');
+
+/*!
+ * isNaN method
+ */
+
+exports.isNaN = require('./isNaN');

lib/chai/utils/isNaN.js

@@ -0,0 +1,26 @@
+/*!
+ * Chai - isNaN utility
+ * Copyright(c) 2012-2015 Sakthipriyan Vairamani <[email protected]>
+ * MIT Licensed
+ */
+
+/**
+ * ### isNaN(value)
+ *
+ * Checks if the given value is NaN or not.
+ *
+ *     utils.isNaN(NaN); // true
+ *
+ * @param {Value} The value which has to be checked if it is NaN
+ * @name isNaN
+ * @api private
+ */
+
+function isNaN(value) {
+  // Refer http://www.ecma-international.org/ecma-262/6.0/#sec-isnan-number
+  // section's NOTE.
+  return value !== value;
+}
+
+// If ECMAScript 6's Number.isNaN is present, prefer that.
+module.exports = Number.isNaN || isNaN;

test/assert.js

@@ -233,6 +233,9 @@ describe('assert', function () {
     assert.deepEqual({tea: 'chai'}, {tea: 'chai'});
     assert.deepStrictEqual({tea: 'chai'}, {tea: 'chai'});  // Alias of deepEqual
 
+    assert.deepEqual([NaN], [NaN]);
+    assert.deepEqual({tea: NaN}, {tea: NaN});
+
     err(function () {
       assert.deepEqual({tea: 'chai'}, {tea: 'black'});
     }, "expected { tea: \'chai\' } to deeply equal { tea: \'black\' }");
@@ -329,7 +332,19 @@ describe('assert', function () {
   });
 
   it('isNaN', function() {
-    assert.isNaN('hello');
+    assert.isNaN(NaN);
+
+    err(function (){
+      assert.isNaN(Infinity);
+    }, "expected Infinity to be NaN");
+
+    err(function (){
+      assert.isNaN(undefined);
+    }, "expected undefined to be NaN");
+
+    err(function (){
+      assert.isNaN({});
+    }, "expected {} to be NaN");
 
     err(function (){
       assert.isNaN(4);
@@ -338,10 +353,13 @@ describe('assert', function () {
 
   it('isNotNaN', function() {
     assert.isNotNaN(4);
+    assert.isNotNaN(Infinity);
+    assert.isNotNaN(undefined);
+    assert.isNotNaN({});
 
     err(function (){
-      assert.isNotNaN('hello');
-    }, "expected 'hello' not to be NaN");
+      assert.isNotNaN(NaN);
+    }, "expected NaN not to be NaN");
   });
 
   it('exists', function() {

test/expect.js

@@ -500,22 +500,41 @@ describe('expect', function () {
 
   it('NaN', function() {
     expect(NaN).to.be.NaN;
-    expect('foo').to.be.NaN;
-    expect({}).to.be.NaN;
+
+    expect(undefined).not.to.be.NaN;
+    expect(Infinity).not.to.be.NaN;
+    expect('foo').not.to.be.NaN;
+    expect({}).not.to.be.NaN;
     expect(4).not.to.be.NaN;
     expect([]).not.to.be.NaN;
 
+    err(function(){
+      expect(NaN).not.to.be.NaN;
+    }, "expected NaN not to be NaN");
+
+    err(function(){
+      expect(undefined).to.be.NaN;
+    }, "expected undefined to be NaN");
+
+    err(function(){
+      expect(Infinity).to.be.NaN;
+    }, "expected Infinity to be NaN");
+
+    err(function(){
+      expect('foo').to.be.NaN;
+    }, "expected 'foo' to be NaN");
+
+    err(function(){
+      expect({}).to.be.NaN;
+    }, "expected {} to be NaN");
+
     err(function(){
       expect(4).to.be.NaN;
     }, "expected 4 to be NaN");
 
     err(function(){
       expect([]).to.be.NaN;
     }, "expected [] to be NaN");
-
-    err(function(){
-      expect('foo').not.to.be.NaN;
-    }, "expected 'foo' not to be NaN");
   });
 
   it('finite', function() {

test/should.js

@@ -154,12 +154,38 @@ describe('should', function() {
   });
 
   it('NaN', function(){
-    'foo'.should.be.NaN;
+    NaN.should.be.NaN;
+
+    Infinity.should.not.be.NaN;
+    'foo'.should.not.be.NaN;
+    ({}).should.not.be.NaN;
+    should.not.equal(undefined, NaN);
     (4).should.not.be.NaN;
 
+    err(function(){
+      NaN.should.not.be.NaN;
+    }, "expected NaN not to be NaN");
+
+    err(function(){
+      Infinity.should.be.NaN;
+    }, "expected Infinity to be NaN");
+
+    err(function(){
+      'foo'.should.be.NaN;
+    }, "expected 'foo' to be NaN");
+
+    err(function(){
+      ({}).should.be.NaN;
+    }, "expected {} to be NaN");
+
+    err(function(){
+      should.equal(undefined, NaN);
+    }, "expected undefined to equal NaN");
+
     err(function(){
       (4).should.be.NaN;
-    }, "expected 4 to be NaN")
+    }, "expected 4 to be NaN");
+
   });
 
   it('undefined', function(){