1 files changed, 209 insertions, 0 deletions
diff --git a/tests/lib/vendor/qunit-assert-close/qunit-assert-close.js b/tests/lib/vendor/qunit-assert-close/qunit-assert-close.js
new file mode 100644
index 000000000..69d405205
--- /dev/null
+++ b/tests/lib/vendor/qunit-assert-close/qunit-assert-close.js
@@ -0,0 +1,209 @@
+//  With custom modifications - all are marked with
+//  a "Custom modification" comment.
+(function(factory) {
+
+  // NOTE:
+  // All techniques except for the "browser globals" fallback will extend the
+  // provided QUnit object but return the isolated API methods
+
+  // For AMD: Register as an anonymous AMD module with a named dependency on "qunit".
+  if (typeof define === "function" && define.amd) {
+    define(["qunit"], factory);
+  }
+  // For Node.js
+  else if (typeof module !== "undefined" && module && module.exports && typeof require === "function") {
+    module.exports = factory(require("qunitjs"));
+  }
+
+  // Custom modification: remove the non-Node.js CommonJS part due to its
+  // usage of QUnit.extend.
+  //
+  // For browser globals
+  else {
+    factory(QUnit);
+  }
+
+}(function(QUnit) {
+
+  /**
+   * Find an appropriate `Assert` context to `push` results to.
+   * @param * context - An unknown context, possibly `Assert`, `Test`, or neither
+   * @private
+   */
+  function _getPushContext(context) {
+    var pushContext;
+
+    if (context && typeof context.push === "function") {
+      // `context` is an `Assert` context
+      pushContext = context;
+    }
+    else if (context && context.assert && typeof context.assert.push === "function") {
+      // `context` is a `Test` context
+      pushContext = context.assert;
+    }
+    else if (
+      QUnit && QUnit.config && QUnit.config.current && QUnit.config.current.assert &&
+      typeof QUnit.config.current.assert.push === "function"
+    ) {
+      // `context` is an unknown context but we can find the `Assert` context via QUnit
+      pushContext = QUnit.config.current.assert;
+    }
+    else if (QUnit && typeof QUnit.push === "function") {
+      pushContext = QUnit.push;
+    }
+    else {
+      throw new Error("Could not find the QUnit `Assert` context to push results");
+    }
+
+    return pushContext;
+  }
+
+  /**
+   * Checks that the first two arguments are equal, or are numbers close enough to be considered equal
+   * based on a specified maximum allowable difference.
+   *
+   * @example assert.close(3.141, Math.PI, 0.001);
+   *
+   * @param Number actual
+   * @param Number expected
+   * @param Number maxDifference (the maximum inclusive difference allowed between the actual and expected numbers)
+   * @param String message (optional)
+   */
+  function close(actual, expected, maxDifference, message) {
+    var actualDiff = (actual === expected) ? 0 : Math.abs(actual - expected),
+        result = actualDiff <= maxDifference,
+        pushContext = _getPushContext(this);
+
+    message = message || (actual + " should be within " + maxDifference + " (inclusive) of " + expected + (result ? "" : ". Actual: " + actualDiff));
+
+    // Custom modification: push -> pushResult
+    pushContext.pushResult({
+      result: result,
+      actual: actual,
+      expected: expected,
+      message: message
+    });
+  }
+
+
+  /**
+   * Checks that the first two arguments are equal, or are numbers close enough to be considered equal
+   * based on a specified maximum allowable difference percentage.
+   *
+   * @example assert.close.percent(155, 150, 3.4);  // Difference is ~3.33%
+   *
+   * @param Number actual
+   * @param Number expected
+   * @param Number maxPercentDifference (the maximum inclusive difference percentage allowed between the actual and expected numbers)
+   * @param String message (optional)
+   */
+  close.percent = function closePercent(actual, expected, maxPercentDifference, message) {
+    var actualDiff, result,
+        pushContext = _getPushContext(this);
+
+    if (actual === expected) {
+      actualDiff = 0;
+      result = actualDiff <= maxPercentDifference;
+    }
+    else if (actual !== 0 && expected !== 0 && expected !== Infinity && expected !== -Infinity) {
+      actualDiff = Math.abs(100 * (actual - expected) / expected);
+      result = actualDiff <= maxPercentDifference;
+    }
+    else {
+      // Dividing by zero (0)!  Should return `false` unless the max percentage was `Infinity`
+      actualDiff = Infinity;
+      result = maxPercentDifference === Infinity;
+    }
+    message = message || (actual + " should be within " + maxPercentDifference + "% (inclusive) of " + expected + (result ? "" : ". Actual: " + actualDiff + "%"));
+
+    // Custom modification: push -> pushResult
+    pushContext.pushResult({
+      result: result,
+      actual: actual,
+      expected: expected,
+      message: message
+    });
+  };
+
+
+  /**
+   * Checks that the first two arguments are numbers with differences greater than the specified
+   * minimum difference.
+   *
+   * @example assert.notClose(3.1, Math.PI, 0.001);
+   *
+   * @param Number actual
+   * @param Number expected
+   * @param Number minDifference (the minimum exclusive difference allowed between the actual and expected numbers)
+   * @param String message (optional)
+   */
+  function notClose(actual, expected, minDifference, message) {
+    var actualDiff = Math.abs(actual - expected),
+        result = actualDiff > minDifference,
+        pushContext = _getPushContext(this);
+
+    message = message || (actual + " should not be within " + minDifference + " (exclusive) of " + expected + (result ? "" : ". Actual: " + actualDiff));
+
+    // Custom modification: push -> pushResult
+    pushContext.pushResult({
+      result: result,
+      actual: actual,
+      expected: expected,
+      message: message
+    });
+  }
+
+
+  /**
+   * Checks that the first two arguments are numbers with differences greater than the specified
+   * minimum difference percentage.
+   *
+   * @example assert.notClose.percent(156, 150, 3.5);  // Difference is 4.0%
+   *
+   * @param Number actual
+   * @param Number expected
+   * @param Number minPercentDifference (the minimum exclusive difference percentage allowed between the actual and expected numbers)
+   * @param String message (optional)
+   */
+  notClose.percent = function notClosePercent(actual, expected, minPercentDifference, message) {
+    var actualDiff, result,
+        pushContext = _getPushContext(this);
+
+    if (actual === expected) {
+      actualDiff = 0;
+      result = actualDiff > minPercentDifference;
+    }
+    else if (actual !== 0 && expected !== 0 && expected !== Infinity && expected !== -Infinity) {
+      actualDiff = Math.abs(100 * (actual - expected) / expected);
+      result = actualDiff > minPercentDifference;
+    }
+    else {
+      // Dividing by zero (0)!  Should only return `true` if the min percentage was `Infinity`
+      actualDiff = Infinity;
+      result = minPercentDifference !== Infinity;
+    }
+    message = message || (actual + " should not be within " + minPercentDifference + "% (exclusive) of " + expected + (result ? "" : ". Actual: " + actualDiff + "%"));
+
+    // Custom modification: push -> pushResult
+    pushContext.pushResult({
+      result: result,
+      actual: actual,
+      expected: expected,
+      message: message
+    });
+  };
+
+  var key;
+  var api = {
+    close: close,
+    notClose: notClose,
+    closePercent: close.percent,
+    notClosePercent: notClose.percent
+  };
+
+  for (key in api) {
+    QUnit.assert[key] = api[key];
+  }
+
+  return api;
+}));