Support differentiating -0 and +0 (sameValue assertion)

ECMAScript has two internal abstractions to compare values called sameValue and sameValueZero.

They are different than == and === as they return true for NaN values and compare -0 and +0.

Based on my experience with test262, and considering some personal goals I have for QUnit (still seeking funding for it) I believe it's fair to ship assertions that does the same comparisons, while I believe it's dangerous to simply modify strictEqual.

Object.is returns the exact result for sameValue, but that's an ES6 feature and not available on supported browsers. The results are the same as === but with special checks for NaN and bit precision zeros.

Here goes some data on how they would work:

The following code can provide some results, as it uses lodash's isEqual as well:
cc @jdalton

QUnit.assert.sameValue = function(a, b, message) {
  var result;

  if (a === b) {
    // -0 vs +0
    result = (a !== 0 || 1/a === 1/b);
  } else

  // NaN
  if (a !== a && b !== b) {
    result = true;
  }

  this.pushResult({
    result,
    actual: a,
    expected: b,
    message
  });
};

QUnit.assert.sameValueZero = function(a, b, message) {
  var result;

  if (a === b) {
    result = true;
  } else 

  // NaN
  if (a !== a && b !== b) {
    result = true;
  }

  this.pushResult({
    result,
    actual: a,
    expected: b,
    message
  });
};


var {test} = QUnit;

test("NaN", function(t) {
  t.ok(_.isEqual(NaN, NaN), "lodash equals");
  t.equal(NaN, NaN, "equal");
  t.strictEqual(NaN, NaN, "strictEqual");
  t.deepEqual(NaN, NaN, "deepEqual");
  t.propEqual(NaN, NaN, "propEqual");
  t.sameValue(NaN, NaN, "sameValue");
  t.sameValueZero(NaN, NaN, "sameValueZero");
});

test("-0 vs +0", function(t) {
  t.ok(_.isEqual(0, -0), "lodash equals");
  t.equal(0, -0);
  t.strictEqual(0, -0);
  t.deepEqual(0, -0);
  t.propEqual(0, -0);
  t.sameValue(0, -0, "sameValue");
  t.sameValueZero(0, -0);
});

test("-0", function(t) {
  t.ok(_.isEqual(0, -0), "lodash equals");
  t.equal(-0, -0);
  t.strictEqual(-0, -0);
  t.propEqual(-0, -0);
  t.deepEqual(-0, -0);
  t.sameValue(-0, -0);
  t.sameValueZero(-0, -0);
});

test("arrays", function(t) {
  t.ok(_.isEqual([1, 2], [1, 2]), "lodash equals");
  t.equal([1, 2], [1, 2], "equal");
  t.strictEqual([1, 2], [1, 2], "strictEqual");
  t.propEqual([1, 2], [1, 2], "propEqual");
  t.deepEqual([1, 2], [1, 2], "deepEqual");
  t.sameValue([1, 2], [1, 2], "sameValue");
  t.sameValueZero([1, 2], [1, 2], "sameValueZero");
});

Start by locating QUnit's assertion API and its existing assertion tests; the issue names no specific files or test entry points. Compare the proposed sameValue and sameValueZero cases for NaN, signed zero, and arrays, then verify the assertions through the project's test suite.