| (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
| // http://wiki.commonjs.org/wiki/Unit_Testing/1.0 |
| // |
| // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! |
| // |
| // Originally from narwhal.js (http://narwhaljs.org) |
| // Copyright (c) 2009 Thomas Robinson <280north.com> |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the 'Software'), to |
| // deal in the Software without restriction, including without limitation the |
| // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| // sell copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| |
| // when used in node, this will actually load the util module we depend on |
| // versus loading the builtin util module as happens otherwise |
| // this is a bug in node module loading as far as I am concerned |
| var util = require('util/'); |
| |
| var pSlice = Array.prototype.slice; |
| var hasOwn = Object.prototype.hasOwnProperty; |
| |
| // 1. The assert module provides functions that throw |
| // AssertionError's when particular conditions are not met. The |
| // assert module must conform to the following interface. |
| |
| var assert = module.exports = ok; |
| |
| // 2. The AssertionError is defined in assert. |
| // new assert.AssertionError({ message: message, |
| // actual: actual, |
| // expected: expected }) |
| |
| assert.AssertionError = function AssertionError(options) { |
| this.name = 'AssertionError'; |
| this.actual = options.actual; |
| this.expected = options.expected; |
| this.operator = options.operator; |
| if (options.message) { |
| this.message = options.message; |
| this.generatedMessage = false; |
| } else { |
| this.message = getMessage(this); |
| this.generatedMessage = true; |
| } |
| var stackStartFunction = options.stackStartFunction || fail; |
| |
| if (Error.captureStackTrace) { |
| Error.captureStackTrace(this, stackStartFunction); |
| } |
| else { |
| // non v8 browsers so we can have a stacktrace |
| var err = new Error(); |
| if (err.stack) { |
| var out = err.stack; |
| |
| // try to strip useless frames |
| var fn_name = stackStartFunction.name; |
| var idx = out.indexOf('\n' + fn_name); |
| if (idx >= 0) { |
| // once we have located the function frame |
| // we need to strip out everything before it (and its line) |
| var next_line = out.indexOf('\n', idx + 1); |
| out = out.substring(next_line + 1); |
| } |
| |
| this.stack = out; |
| } |
| } |
| }; |
| |
| // assert.AssertionError instanceof Error |
| util.inherits(assert.AssertionError, Error); |
| |
| function replacer(key, value) { |
| if (util.isUndefined(value)) { |
| return '' + value; |
| } |
| if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) { |
| return value.toString(); |
| } |
| if (util.isFunction(value) || util.isRegExp(value)) { |
| return value.toString(); |
| } |
| return value; |
| } |
| |
| function truncate(s, n) { |
| if (util.isString(s)) { |
| return s.length < n ? s : s.slice(0, n); |
| } else { |
| return s; |
| } |
| } |
| |
| function getMessage(self) { |
| return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' + |
| self.operator + ' ' + |
| truncate(JSON.stringify(self.expected, replacer), 128); |
| } |
| |
| // At present only the three keys mentioned above are used and |
| // understood by the spec. Implementations or sub modules can pass |
| // other keys to the AssertionError's constructor - they will be |
| // ignored. |
| |
| // 3. All of the following functions must throw an AssertionError |
| // when a corresponding condition is not met, with a message that |
| // may be undefined if not provided. All assertion methods provide |
| // both the actual and expected values to the assertion error for |
| // display purposes. |
| |
| function fail(actual, expected, message, operator, stackStartFunction) { |
| throw new assert.AssertionError({ |
| message: message, |
| actual: actual, |
| expected: expected, |
| operator: operator, |
| stackStartFunction: stackStartFunction |
| }); |
| } |
| |
| // EXTENSION! allows for well behaved errors defined elsewhere. |
| assert.fail = fail; |
| |
| // 4. Pure assertion tests whether a value is truthy, as determined |
| // by !!guard. |
| // assert.ok(guard, message_opt); |
| // This statement is equivalent to assert.equal(true, !!guard, |
| // message_opt);. To test strictly for the value true, use |
| // assert.strictEqual(true, guard, message_opt);. |
| |
| function ok(value, message) { |
| if (!value) fail(value, true, message, '==', assert.ok); |
| } |
| assert.ok = ok; |
| |
| // 5. The equality assertion tests shallow, coercive equality with |
| // ==. |
| // assert.equal(actual, expected, message_opt); |
| |
| assert.equal = function equal(actual, expected, message) { |
| if (actual != expected) fail(actual, expected, message, '==', assert.equal); |
| }; |
| |
| // 6. The non-equality assertion tests for whether two objects are not equal |
| // with != assert.notEqual(actual, expected, message_opt); |
| |
| assert.notEqual = function notEqual(actual, expected, message) { |
| if (actual == expected) { |
| fail(actual, expected, message, '!=', assert.notEqual); |
| } |
| }; |
| |
| // 7. The equivalence assertion tests a deep equality relation. |
| // assert.deepEqual(actual, expected, message_opt); |
| |
| assert.deepEqual = function deepEqual(actual, expected, message) { |
| if (!_deepEqual(actual, expected)) { |
| fail(actual, expected, message, 'deepEqual', assert.deepEqual); |
| } |
| }; |
| |
| function _deepEqual(actual, expected) { |
| // 7.1. All identical values are equivalent, as determined by ===. |
| if (actual === expected) { |
| return true; |
| |
| } else if (util.isBuffer(actual) && util.isBuffer(expected)) { |
| if (actual.length != expected.length) return false; |
| |
| for (var i = 0; i < actual.length; i++) { |
| if (actual[i] !== expected[i]) return false; |
| } |
| |
| return true; |
| |
| // 7.2. If the expected value is a Date object, the actual value is |
| // equivalent if it is also a Date object that refers to the same time. |
| } else if (util.isDate(actual) && util.isDate(expected)) { |
| return actual.getTime() === expected.getTime(); |
| |
| // 7.3 If the expected value is a RegExp object, the actual value is |
| // equivalent if it is also a RegExp object with the same source and |
| // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). |
| } else if (util.isRegExp(actual) && util.isRegExp(expected)) { |
| return actual.source === expected.source && |
| actual.global === expected.global && |
| actual.multiline === expected.multiline && |
| actual.lastIndex === expected.lastIndex && |
| actual.ignoreCase === expected.ignoreCase; |
| |
| // 7.4. Other pairs that do not both pass typeof value == 'object', |
| // equivalence is determined by ==. |
| } else if (!util.isObject(actual) && !util.isObject(expected)) { |
| return actual == expected; |
| |
| // 7.5 For all other Object pairs, including Array objects, equivalence is |
| // determined by having the same number of owned properties (as verified |
| // with Object.prototype.hasOwnProperty.call), the same set of keys |
| // (although not necessarily the same order), equivalent values for every |
| // corresponding key, and an identical 'prototype' property. Note: this |
| // accounts for both named and indexed properties on Arrays. |
| } else { |
| return objEquiv(actual, expected); |
| } |
| } |
| |
| function isArguments(object) { |
| return Object.prototype.toString.call(object) == '[object Arguments]'; |
| } |
| |
| function objEquiv(a, b) { |
| if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b)) |
| return false; |
| // an identical 'prototype' property. |
| if (a.prototype !== b.prototype) return false; |
| //~~~I've managed to break Object.keys through screwy arguments passing. |
| // Converting to array solves the problem. |
| if (isArguments(a)) { |
| if (!isArguments(b)) { |
| return false; |
| } |
| a = pSlice.call(a); |
| b = pSlice.call(b); |
| return _deepEqual(a, b); |
| } |
| try { |
| var ka = objectKeys(a), |
| kb = objectKeys(b), |
| key, i; |
| } catch (e) {//happens when one is a string literal and the other isn't |
| return false; |
| } |
| // having the same number of owned properties (keys incorporates |
| // hasOwnProperty) |
| if (ka.length != kb.length) |
| return false; |
| //the same set of keys (although not necessarily the same order), |
| ka.sort(); |
| kb.sort(); |
| //~~~cheap key test |
| for (i = ka.length - 1; i >= 0; i--) { |
| if (ka[i] != kb[i]) |
| return false; |
| } |
| //equivalent values for every corresponding key, and |
| //~~~possibly expensive deep test |
| for (i = ka.length - 1; i >= 0; i--) { |
| key = ka[i]; |
| if (!_deepEqual(a[key], b[key])) return false; |
| } |
| return true; |
| } |
| |
| // 8. The non-equivalence assertion tests for any deep inequality. |
| // assert.notDeepEqual(actual, expected, message_opt); |
| |
| assert.notDeepEqual = function notDeepEqual(actual, expected, message) { |
| if (_deepEqual(actual, expected)) { |
| fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); |
| } |
| }; |
| |
| // 9. The strict equality assertion tests strict equality, as determined by ===. |
| // assert.strictEqual(actual, expected, message_opt); |
| |
| assert.strictEqual = function strictEqual(actual, expected, message) { |
| if (actual !== expected) { |
| fail(actual, expected, message, '===', assert.strictEqual); |
| } |
| }; |
| |
| // 10. The strict non-equality assertion tests for strict inequality, as |
| // determined by !==. assert.notStrictEqual(actual, expected, message_opt); |
| |
| assert.notStrictEqual = function notStrictEqual(actual, expected, message) { |
| if (actual === expected) { |
| fail(actual, expected, message, '!==', assert.notStrictEqual); |
| } |
| }; |
| |
| function expectedException(actual, expected) { |
| if (!actual || !expected) { |
| return false; |
| } |
| |
| if (Object.prototype.toString.call(expected) == '[object RegExp]') { |
| return expected.test(actual); |
| } else if (actual instanceof expected) { |
| return true; |
| } else if (expected.call({}, actual) === true) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| function _throws(shouldThrow, block, expected, message) { |
| var actual; |
| |
| if (util.isString(expected)) { |
| message = expected; |
| expected = null; |
| } |
| |
| try { |
| block(); |
| } catch (e) { |
| actual = e; |
| } |
| |
| message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + |
| (message ? ' ' + message : '.'); |
| |
| if (shouldThrow && !actual) { |
| fail(actual, expected, 'Missing expected exception' + message); |
| } |
| |
| if (!shouldThrow && expectedException(actual, expected)) { |
| fail(actual, expected, 'Got unwanted exception' + message); |
| } |
| |
| if ((shouldThrow && actual && expected && |
| !expectedException(actual, expected)) || (!shouldThrow && actual)) { |
| throw actual; |
| } |
| } |
| |
| // 11. Expected to throw an error: |
| // assert.throws(block, Error_opt, message_opt); |
| |
| assert.throws = function(block, /*optional*/error, /*optional*/message) { |
| _throws.apply(this, [true].concat(pSlice.call(arguments))); |
| }; |
| |
| // EXTENSION! This is annoying to write outside this module. |
| assert.doesNotThrow = function(block, /*optional*/message) { |
| _throws.apply(this, [false].concat(pSlice.call(arguments))); |
| }; |
| |
| assert.ifError = function(err) { if (err) {throw err;}}; |
| |
| var objectKeys = Object.keys || function (obj) { |
| var keys = []; |
| for (var key in obj) { |
| if (hasOwn.call(obj, key)) keys.push(key); |
| } |
| return keys; |
| }; |
| |
| },{"util/":5}],2:[function(require,module,exports){ |
| if (typeof Object.create === 'function') { |
| // implementation from standard node.js 'util' module |
| module.exports = function inherits(ctor, superCtor) { |
| ctor.super_ = superCtor |
| ctor.prototype = Object.create(superCtor.prototype, { |
| constructor: { |
| value: ctor, |
| enumerable: false, |
| writable: true, |
| configurable: true |
| } |
| }); |
| }; |
| } else { |
| // old school shim for old browsers |
| module.exports = function inherits(ctor, superCtor) { |
| ctor.super_ = superCtor |
| var TempCtor = function () {} |
| TempCtor.prototype = superCtor.prototype |
| ctor.prototype = new TempCtor() |
| ctor.prototype.constructor = ctor |
| } |
| } |
| |
| },{}],3:[function(require,module,exports){ |
| // shim for using process in browser |
| |
| var process = module.exports = {}; |
| |
| process.nextTick = (function () { |
| var canSetImmediate = typeof window !== 'undefined' |
| && window.setImmediate; |
| var canPost = typeof window !== 'undefined' |
| && window.postMessage && window.addEventListener |
| ; |
| |
| if (canSetImmediate) { |
| return function (f) { return window.setImmediate(f) }; |
| } |
| |
| if (canPost) { |
| var queue = []; |
| window.addEventListener('message', function (ev) { |
| var source = ev.source; |
| if ((source === window || source === null) && ev.data === 'process-tick') { |
| ev.stopPropagation(); |
| if (queue.length > 0) { |
| var fn = queue.shift(); |
| fn(); |
| } |
| } |
| }, true); |
| |
| return function nextTick(fn) { |
| queue.push(fn); |
| window.postMessage('process-tick', '*'); |
| }; |
| } |
| |
| return function nextTick(fn) { |
| setTimeout(fn, 0); |
| }; |
| })(); |
| |
| process.title = 'browser'; |
| process.browser = true; |
| process.env = {}; |
| process.argv = []; |
| |
| function noop() {} |
| |
| process.on = noop; |
| process.addListener = noop; |
| process.once = noop; |
| process.off = noop; |
| process.removeListener = noop; |
| process.removeAllListeners = noop; |
| process.emit = noop; |
| |
| process.binding = function (name) { |
| throw new Error('process.binding is not supported'); |
| } |
| |
| // TODO(shtylman) |
| process.cwd = function () { return '/' }; |
| process.chdir = function (dir) { |
| throw new Error('process.chdir is not supported'); |
| }; |
| |
| },{}],4:[function(require,module,exports){ |
| module.exports = function isBuffer(arg) { |
| return arg && typeof arg === 'object' |
| && typeof arg.copy === 'function' |
| && typeof arg.fill === 'function' |
| && typeof arg.readUInt8 === 'function'; |
| } |
| },{}],5:[function(require,module,exports){ |
| (function (process,global){ |
| // Copyright Joyent, Inc. and other Node contributors. |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a |
| // copy of this software and associated documentation files (the |
| // "Software"), to deal in the Software without restriction, including |
| // without limitation the rights to use, copy, modify, merge, publish, |
| // distribute, sublicense, and/or sell copies of the Software, and to permit |
| // persons to whom the Software is furnished to do so, subject to the |
| // following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included |
| // in all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
| // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
| // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| // USE OR OTHER DEALINGS IN THE SOFTWARE. |
| |
| var formatRegExp = /%[sdj%]/g; |
| exports.format = function(f) { |
| if (!isString(f)) { |
| var objects = []; |
| for (var i = 0; i < arguments.length; i++) { |
| objects.push(inspect(arguments[i])); |
| } |
| return objects.join(' '); |
| } |
| |
| var i = 1; |
| var args = arguments; |
| var len = args.length; |
| var str = String(f).replace(formatRegExp, function(x) { |
| if (x === '%%') return '%'; |
| if (i >= len) return x; |
| switch (x) { |
| case '%s': return String(args[i++]); |
| case '%d': return Number(args[i++]); |
| case '%j': |
| try { |
| return JSON.stringify(args[i++]); |
| } catch (_) { |
| return '[Circular]'; |
| } |
| default: |
| return x; |
| } |
| }); |
| for (var x = args[i]; i < len; x = args[++i]) { |
| if (isNull(x) || !isObject(x)) { |
| str += ' ' + x; |
| } else { |
| str += ' ' + inspect(x); |
| } |
| } |
| return str; |
| }; |
| |
| |
| // Mark that a method should not be used. |
| // Returns a modified function which warns once by default. |
| // If --no-deprecation is set, then it is a no-op. |
| exports.deprecate = function(fn, msg) { |
| // Allow for deprecating things in the process of starting up. |
| if (isUndefined(global.process)) { |
| return function() { |
| return exports.deprecate(fn, msg).apply(this, arguments); |
| }; |
| } |
| |
| if (process.noDeprecation === true) { |
| return fn; |
| } |
| |
| var warned = false; |
| function deprecated() { |
| if (!warned) { |
| if (process.throwDeprecation) { |
| throw new Error(msg); |
| } else if (process.traceDeprecation) { |
| console.trace(msg); |
| } else { |
| console.error(msg); |
| } |
| warned = true; |
| } |
| return fn.apply(this, arguments); |
| } |
| |
| return deprecated; |
| }; |
| |
| |
| var debugs = {}; |
| var debugEnviron; |
| exports.debuglog = function(set) { |
| if (isUndefined(debugEnviron)) |
| debugEnviron = process.env.NODE_DEBUG || ''; |
| set = set.toUpperCase(); |
| if (!debugs[set]) { |
| if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { |
| var pid = process.pid; |
| debugs[set] = function() { |
| var msg = exports.format.apply(exports, arguments); |
| console.error('%s %d: %s', set, pid, msg); |
| }; |
| } else { |
| debugs[set] = function() {}; |
| } |
| } |
| return debugs[set]; |
| }; |
| |
| |
| /** |
| * Echos the value of a value. Trys to print the value out |
| * in the best way possible given the different types. |
| * |
| * @param {Object} obj The object to print out. |
| * @param {Object} opts Optional options object that alters the output. |
| */ |
| /* legacy: obj, showHidden, depth, colors*/ |
| function inspect(obj, opts) { |
| // default options |
| var ctx = { |
| seen: [], |
| stylize: stylizeNoColor |
| }; |
| // legacy... |
| if (arguments.length >= 3) ctx.depth = arguments[2]; |
| if (arguments.length >= 4) ctx.colors = arguments[3]; |
| if (isBoolean(opts)) { |
| // legacy... |
| ctx.showHidden = opts; |
| } else if (opts) { |
| // got an "options" object |
| exports._extend(ctx, opts); |
| } |
| // set default options |
| if (isUndefined(ctx.showHidden)) ctx.showHidden = false; |
| if (isUndefined(ctx.depth)) ctx.depth = 2; |
| if (isUndefined(ctx.colors)) ctx.colors = false; |
| if (isUndefined(ctx.customInspect)) ctx.customInspect = true; |
| if (ctx.colors) ctx.stylize = stylizeWithColor; |
| return formatValue(ctx, obj, ctx.depth); |
| } |
| exports.inspect = inspect; |
| |
| |
| // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics |
| inspect.colors = { |
| 'bold' : [1, 22], |
| 'italic' : [3, 23], |
| 'underline' : [4, 24], |
| 'inverse' : [7, 27], |
| 'white' : [37, 39], |
| 'grey' : [90, 39], |
| 'black' : [30, 39], |
| 'blue' : [34, 39], |
| 'cyan' : [36, 39], |
| 'green' : [32, 39], |
| 'magenta' : [35, 39], |
| 'red' : [31, 39], |
| 'yellow' : [33, 39] |
| }; |
| |
| // Don't use 'blue' not visible on cmd.exe |
| inspect.styles = { |
| 'special': 'cyan', |
| 'number': 'yellow', |
| 'boolean': 'yellow', |
| 'undefined': 'grey', |
| 'null': 'bold', |
| 'string': 'green', |
| 'date': 'magenta', |
| // "name": intentionally not styling |
| 'regexp': 'red' |
| }; |
| |
| |
| function stylizeWithColor(str, styleType) { |
| var style = inspect.styles[styleType]; |
| |
| if (style) { |
| return '\u001b[' + inspect.colors[style][0] + 'm' + str + |
| '\u001b[' + inspect.colors[style][1] + 'm'; |
| } else { |
| return str; |
| } |
| } |
| |
| |
| function stylizeNoColor(str, styleType) { |
| return str; |
| } |
| |
| |
| function arrayToHash(array) { |
| var hash = {}; |
| |
| array.forEach(function(val, idx) { |
| hash[val] = true; |
| }); |
| |
| return hash; |
| } |
| |
| |
| function formatValue(ctx, value, recurseTimes) { |
| // Provide a hook for user-specified inspect functions. |
| // Check that value is an object with an inspect function on it |
| if (ctx.customInspect && |
| value && |
| isFunction(value.inspect) && |
| // Filter out the util module, it's inspect function is special |
| value.inspect !== exports.inspect && |
| // Also filter out any prototype objects using the circular check. |
| !(value.constructor && value.constructor.prototype === value)) { |
| var ret = value.inspect(recurseTimes, ctx); |
| if (!isString(ret)) { |
| ret = formatValue(ctx, ret, recurseTimes); |
| } |
| return ret; |
| } |
| |
| // Primitive types cannot have properties |
| var primitive = formatPrimitive(ctx, value); |
| if (primitive) { |
| return primitive; |
| } |
| |
| // Look up the keys of the object. |
| var keys = Object.keys(value); |
| var visibleKeys = arrayToHash(keys); |
| |
| if (ctx.showHidden) { |
| keys = Object.getOwnPropertyNames(value); |
| } |
| |
| // IE doesn't make error fields non-enumerable |
| // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx |
| if (isError(value) |
| && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { |
| return formatError(value); |
| } |
| |
| // Some type of object without properties can be shortcutted. |
| if (keys.length === 0) { |
| if (isFunction(value)) { |
| var name = value.name ? ': ' + value.name : ''; |
| return ctx.stylize('[Function' + name + ']', 'special'); |
| } |
| if (isRegExp(value)) { |
| return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); |
| } |
| if (isDate(value)) { |
| return ctx.stylize(Date.prototype.toString.call(value), 'date'); |
| } |
| if (isError(value)) { |
| return formatError(value); |
| } |
| } |
| |
| var base = '', array = false, braces = ['{', '}']; |
| |
| // Make Array say that they are Array |
| if (isArray(value)) { |
| array = true; |
| braces = ['[', ']']; |
| } |
| |
| // Make functions say that they are functions |
| if (isFunction(value)) { |
| var n = value.name ? ': ' + value.name : ''; |
| base = ' [Function' + n + ']'; |
| } |
| |
| // Make RegExps say that they are RegExps |
| if (isRegExp(value)) { |
| base = ' ' + RegExp.prototype.toString.call(value); |
| } |
| |
| // Make dates with properties first say the date |
| if (isDate(value)) { |
| base = ' ' + Date.prototype.toUTCString.call(value); |
| } |
| |
| // Make error with message first say the error |
| if (isError(value)) { |
| base = ' ' + formatError(value); |
| } |
| |
| if (keys.length === 0 && (!array || value.length == 0)) { |
| return braces[0] + base + braces[1]; |
| } |
| |
| if (recurseTimes < 0) { |
| if (isRegExp(value)) { |
| return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); |
| } else { |
| return ctx.stylize('[Object]', 'special'); |
| } |
| } |
| |
| ctx.seen.push(value); |
| |
| var output; |
| if (array) { |
| output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); |
| } else { |
| output = keys.map(function(key) { |
| return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); |
| }); |
| } |
| |
| ctx.seen.pop(); |
| |
| return reduceToSingleString(output, base, braces); |
| } |
| |
| |
| function formatPrimitive(ctx, value) { |
| if (isUndefined(value)) |
| return ctx.stylize('undefined', 'undefined'); |
| if (isString(value)) { |
| var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') |
| .replace(/'/g, "\\'") |
| .replace(/\\"/g, '"') + '\''; |
| return ctx.stylize(simple, 'string'); |
| } |
| if (isNumber(value)) |
| return ctx.stylize('' + value, 'number'); |
| if (isBoolean(value)) |
| return ctx.stylize('' + value, 'boolean'); |
| // For some reason typeof null is "object", so special case here. |
| if (isNull(value)) |
| return ctx.stylize('null', 'null'); |
| } |
| |
| |
| function formatError(value) { |
| return '[' + Error.prototype.toString.call(value) + ']'; |
| } |
| |
| |
| function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { |
| var output = []; |
| for (var i = 0, l = value.length; i < l; ++i) { |
| if (hasOwnProperty(value, String(i))) { |
| output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, |
| String(i), true)); |
| } else { |
| output.push(''); |
| } |
| } |
| keys.forEach(function(key) { |
| if (!key.match(/^\d+$/)) { |
| output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, |
| key, true)); |
| } |
| }); |
| return output; |
| } |
| |
| |
| function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { |
| var name, str, desc; |
| desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; |
| if (desc.get) { |
| if (desc.set) { |
| str = ctx.stylize('[Getter/Setter]', 'special'); |
| } else { |
| str = ctx.stylize('[Getter]', 'special'); |
| } |
| } else { |
| if (desc.set) { |
| str = ctx.stylize('[Setter]', 'special'); |
| } |
| } |
| if (!hasOwnProperty(visibleKeys, key)) { |
| name = '[' + key + ']'; |
| } |
| if (!str) { |
| if (ctx.seen.indexOf(desc.value) < 0) { |
| if (isNull(recurseTimes)) { |
| str = formatValue(ctx, desc.value, null); |
| } else { |
| str = formatValue(ctx, desc.value, recurseTimes - 1); |
| } |
| if (str.indexOf('\n') > -1) { |
| if (array) { |
| str = str.split('\n').map(function(line) { |
| return ' ' + line; |
| }).join('\n').substr(2); |
| } else { |
| str = '\n' + str.split('\n').map(function(line) { |
| return ' ' + line; |
| }).join('\n'); |
| } |
| } |
| } else { |
| str = ctx.stylize('[Circular]', 'special'); |
| } |
| } |
| if (isUndefined(name)) { |
| if (array && key.match(/^\d+$/)) { |
| return str; |
| } |
| name = JSON.stringify('' + key); |
| if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { |
| name = name.substr(1, name.length - 2); |
| name = ctx.stylize(name, 'name'); |
| } else { |
| name = name.replace(/'/g, "\\'") |
| .replace(/\\"/g, '"') |
| .replace(/(^"|"$)/g, "'"); |
| name = ctx.stylize(name, 'string'); |
| } |
| } |
| |
| return name + ': ' + str; |
| } |
| |
| |
| function reduceToSingleString(output, base, braces) { |
| var numLinesEst = 0; |
| var length = output.reduce(function(prev, cur) { |
| numLinesEst++; |
| if (cur.indexOf('\n') >= 0) numLinesEst++; |
| return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; |
| }, 0); |
| |
| if (length > 60) { |
| return braces[0] + |
| (base === '' ? '' : base + '\n ') + |
| ' ' + |
| output.join(',\n ') + |
| ' ' + |
| braces[1]; |
| } |
| |
| return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; |
| } |
| |
| |
| // NOTE: These type checking functions intentionally don't use `instanceof` |
| // because it is fragile and can be easily faked with `Object.create()`. |
| function isArray(ar) { |
| return Array.isArray(ar); |
| } |
| exports.isArray = isArray; |
| |
| function isBoolean(arg) { |
| return typeof arg === 'boolean'; |
| } |
| exports.isBoolean = isBoolean; |
| |
| function isNull(arg) { |
| return arg === null; |
| } |
| exports.isNull = isNull; |
| |
| function isNullOrUndefined(arg) { |
| return arg == null; |
| } |
| exports.isNullOrUndefined = isNullOrUndefined; |
| |
| function isNumber(arg) { |
| return typeof arg === 'number'; |
| } |
| exports.isNumber = isNumber; |
| |
| function isString(arg) { |
| return typeof arg === 'string'; |
| } |
| exports.isString = isString; |
| |
| function isSymbol(arg) { |
| return typeof arg === 'symbol'; |
| } |
| exports.isSymbol = isSymbol; |
| |
| function isUndefined(arg) { |
| return arg === void 0; |
| } |
| exports.isUndefined = isUndefined; |
| |
| function isRegExp(re) { |
| return isObject(re) && objectToString(re) === '[object RegExp]'; |
| } |
| exports.isRegExp = isRegExp; |
| |
| function isObject(arg) { |
| return typeof arg === 'object' && arg !== null; |
| } |
| exports.isObject = isObject; |
| |
| function isDate(d) { |
| return isObject(d) && objectToString(d) === '[object Date]'; |
| } |
| exports.isDate = isDate; |
| |
| function isError(e) { |
| return isObject(e) && |
| (objectToString(e) === '[object Error]' || e instanceof Error); |
| } |
| exports.isError = isError; |
| |
| function isFunction(arg) { |
| return typeof arg === 'function'; |
| } |
| exports.isFunction = isFunction; |
| |
| function isPrimitive(arg) { |
| return arg === null || |
| typeof arg === 'boolean' || |
| typeof arg === 'number' || |
| typeof arg === 'string' || |
| typeof arg === 'symbol' || // ES6 symbol |
| typeof arg === 'undefined'; |
| } |
| exports.isPrimitive = isPrimitive; |
| |
| exports.isBuffer = require('./support/isBuffer'); |
| |
| function objectToString(o) { |
| return Object.prototype.toString.call(o); |
| } |
| |
| |
| function pad(n) { |
| return n < 10 ? '0' + n.toString(10) : n.toString(10); |
| } |
| |
| |
| var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', |
| 'Oct', 'Nov', 'Dec']; |
| |
| // 26 Feb 16:19:34 |
| function timestamp() { |
| var d = new Date(); |
| var time = [pad(d.getHours()), |
| pad(d.getMinutes()), |
| pad(d.getSeconds())].join(':'); |
| return [d.getDate(), months[d.getMonth()], time].join(' '); |
| } |
| |
| |
| // log is just a thin wrapper to console.log that prepends a timestamp |
| exports.log = function() { |
| console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); |
| }; |
| |
| |
| /** |
| * Inherit the prototype methods from one constructor into another. |
| * |
| * The Function.prototype.inherits from lang.js rewritten as a standalone |
| * function (not on Function.prototype). NOTE: If this file is to be loaded |
| * during bootstrapping this function needs to be rewritten using some native |
| * functions as prototype setup using normal JavaScript does not work as |
| * expected during bootstrapping (see mirror.js in r114903). |
| * |
| * @param {function} ctor Constructor function which needs to inherit the |
| * prototype. |
| * @param {function} superCtor Constructor function to inherit prototype from. |
| */ |
| exports.inherits = require('inherits'); |
| |
| exports._extend = function(origin, add) { |
| // Don't do anything if add isn't an object |
| if (!add || !isObject(add)) return origin; |
| |
| var keys = Object.keys(add); |
| var i = keys.length; |
| while (i--) { |
| origin[keys[i]] = add[keys[i]]; |
| } |
| return origin; |
| }; |
| |
| function hasOwnProperty(obj, prop) { |
| return Object.prototype.hasOwnProperty.call(obj, prop); |
| } |
| |
| }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./support/isBuffer":4,"_process":3,"inherits":2}],6:[function(require,module,exports){ |
| (function (global){ |
| /* |
| * Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com> |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| (function () { |
| 'use strict'; |
| |
| /* To bundle all code into browserified JS file, call `require` to the each test file explicitly. |
| * And export it to the global namespace as `promiseTests`. |
| */ |
| global.promiseTests = { |
| tests2_1_2: function () { |
| return require('./promises-tests/lib/tests/2.1.2'); |
| }, |
| |
| tests2_1_3: function () { |
| return require('./promises-tests/lib/tests/2.1.3'); |
| }, |
| |
| tests2_2_1: function () { |
| return require('./promises-tests/lib/tests/2.2.1'); |
| }, |
| |
| tests2_2_2: function () { |
| return require('./promises-tests/lib/tests/2.2.2'); |
| }, |
| |
| tests2_2_3: function () { |
| return require('./promises-tests/lib/tests/2.2.3'); |
| }, |
| |
| tests2_2_4: function () { |
| return require('./promises-tests/lib/tests/2.2.4'); |
| }, |
| |
| tests2_2_5: function () { |
| return require('./promises-tests/lib/tests/2.2.5'); |
| }, |
| |
| tests2_2_6: function () { |
| return require('./promises-tests/lib/tests/2.2.6'); |
| }, |
| |
| tests2_2_7: function () { |
| return require('./promises-tests/lib/tests/2.2.7'); |
| }, |
| |
| tests2_3_1: function () { |
| return require('./promises-tests/lib/tests/2.3.1'); |
| }, |
| |
| tests2_3_2: function () { |
| return require('./promises-tests/lib/tests/2.3.2'); |
| }, |
| |
| tests2_3_3: function () { |
| return require('./promises-tests/lib/tests/2.3.3'); |
| }, |
| |
| tests2_3_4: function () { |
| return require('./promises-tests/lib/tests/2.3.4'); |
| } |
| }; |
| }()); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./promises-tests/lib/tests/2.1.2":7,"./promises-tests/lib/tests/2.1.3":8,"./promises-tests/lib/tests/2.2.1":9,"./promises-tests/lib/tests/2.2.2":10,"./promises-tests/lib/tests/2.2.3":11,"./promises-tests/lib/tests/2.2.4":12,"./promises-tests/lib/tests/2.2.5":13,"./promises-tests/lib/tests/2.2.6":14,"./promises-tests/lib/tests/2.2.7":15,"./promises-tests/lib/tests/2.3.1":16,"./promises-tests/lib/tests/2.3.2":17,"./promises-tests/lib/tests/2.3.3":18,"./promises-tests/lib/tests/2.3.4":19}],7:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var testFulfilled = require("./helpers/testThreeCases").testFulfilled; |
| |
| var adapter = global.adapter; |
| var deferred = adapter.deferred; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| |
| describe("2.1.2.1: When fulfilled, a promise: must not transition to any other state.", function () { |
| testFulfilled(dummy, function (promise, done) { |
| var onFulfilledCalled = false; |
| |
| promise.then(function onFulfilled() { |
| onFulfilledCalled = true; |
| }, function onRejected() { |
| assert.strictEqual(onFulfilledCalled, false); |
| done(); |
| }); |
| |
| setTimeout(done, 100); |
| }); |
| |
| specify("trying to fulfill then immediately reject", function (done) { |
| var d = deferred(); |
| var onFulfilledCalled = false; |
| |
| d.promise.then(function onFulfilled() { |
| onFulfilledCalled = true; |
| }, function onRejected() { |
| assert.strictEqual(onFulfilledCalled, false); |
| done(); |
| }); |
| |
| d.resolve(dummy); |
| d.reject(dummy); |
| setTimeout(done, 100); |
| }); |
| |
| specify("trying to fulfill then reject, delayed", function (done) { |
| var d = deferred(); |
| var onFulfilledCalled = false; |
| |
| d.promise.then(function onFulfilled() { |
| onFulfilledCalled = true; |
| }, function onRejected() { |
| assert.strictEqual(onFulfilledCalled, false); |
| done(); |
| }); |
| |
| setTimeout(function () { |
| d.resolve(dummy); |
| d.reject(dummy); |
| }, 50); |
| setTimeout(done, 100); |
| }); |
| |
| specify("trying to fulfill immediately then reject delayed", function (done) { |
| var d = deferred(); |
| var onFulfilledCalled = false; |
| |
| d.promise.then(function onFulfilled() { |
| onFulfilledCalled = true; |
| }, function onRejected() { |
| assert.strictEqual(onFulfilledCalled, false); |
| done(); |
| }); |
| |
| d.resolve(dummy); |
| setTimeout(function () { |
| d.reject(dummy); |
| }, 50); |
| setTimeout(done, 100); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./helpers/testThreeCases":21,"assert":1}],8:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var testRejected = require("./helpers/testThreeCases").testRejected; |
| |
| var adapter = global.adapter; |
| var deferred = adapter.deferred; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| |
| describe("2.1.3.1: When rejected, a promise: must not transition to any other state.", function () { |
| testRejected(dummy, function (promise, done) { |
| var onRejectedCalled = false; |
| |
| promise.then(function onFulfilled() { |
| assert.strictEqual(onRejectedCalled, false); |
| done(); |
| }, function onRejected() { |
| onRejectedCalled = true; |
| }); |
| |
| setTimeout(done, 100); |
| }); |
| |
| specify("trying to reject then immediately fulfill", function (done) { |
| var d = deferred(); |
| var onRejectedCalled = false; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(onRejectedCalled, false); |
| done(); |
| }, function onRejected() { |
| onRejectedCalled = true; |
| }); |
| |
| d.reject(dummy); |
| d.resolve(dummy); |
| setTimeout(done, 100); |
| }); |
| |
| specify("trying to reject then fulfill, delayed", function (done) { |
| var d = deferred(); |
| var onRejectedCalled = false; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(onRejectedCalled, false); |
| done(); |
| }, function onRejected() { |
| onRejectedCalled = true; |
| }); |
| |
| setTimeout(function () { |
| d.reject(dummy); |
| d.resolve(dummy); |
| }, 50); |
| setTimeout(done, 100); |
| }); |
| |
| specify("trying to reject immediately then fulfill delayed", function (done) { |
| var d = deferred(); |
| var onRejectedCalled = false; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(onRejectedCalled, false); |
| done(); |
| }, function onRejected() { |
| onRejectedCalled = true; |
| }); |
| |
| d.reject(dummy); |
| setTimeout(function () { |
| d.resolve(dummy); |
| }, 50); |
| setTimeout(done, 100); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./helpers/testThreeCases":21,"assert":1}],9:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| |
| describe("2.2.1: Both `onFulfilled` and `onRejected` are optional arguments.", function () { |
| describe("2.2.1.1: If `onFulfilled` is not a function, it must be ignored.", function () { |
| describe("applied to a directly-rejected promise", function () { |
| function testNonFunction(nonFunction, stringRepresentation) { |
| specify("`onFulfilled` is " + stringRepresentation, function (done) { |
| rejected(dummy).then(nonFunction, function () { |
| done(); |
| }); |
| }); |
| } |
| |
| testNonFunction(undefined, "`undefined`"); |
| testNonFunction(null, "`null`"); |
| testNonFunction(false, "`false`"); |
| testNonFunction(5, "`5`"); |
| testNonFunction({}, "an object"); |
| }); |
| |
| describe("applied to a promise rejected and then chained off of", function () { |
| function testNonFunction(nonFunction, stringRepresentation) { |
| specify("`onFulfilled` is " + stringRepresentation, function (done) { |
| rejected(dummy).then(function () { }, undefined).then(nonFunction, function () { |
| done(); |
| }); |
| }); |
| } |
| |
| testNonFunction(undefined, "`undefined`"); |
| testNonFunction(null, "`null`"); |
| testNonFunction(false, "`false`"); |
| testNonFunction(5, "`5`"); |
| testNonFunction({}, "an object"); |
| }); |
| }); |
| |
| describe("2.2.1.2: If `onRejected` is not a function, it must be ignored.", function () { |
| describe("applied to a directly-fulfilled promise", function () { |
| function testNonFunction(nonFunction, stringRepresentation) { |
| specify("`onRejected` is " + stringRepresentation, function (done) { |
| resolved(dummy).then(function () { |
| done(); |
| }, nonFunction); |
| }); |
| } |
| |
| testNonFunction(undefined, "`undefined`"); |
| testNonFunction(null, "`null`"); |
| testNonFunction(false, "`false`"); |
| testNonFunction(5, "`5`"); |
| testNonFunction({}, "an object"); |
| }); |
| |
| describe("applied to a promise fulfilled and then chained off of", function () { |
| function testNonFunction(nonFunction, stringRepresentation) { |
| specify("`onFulfilled` is " + stringRepresentation, function (done) { |
| resolved(dummy).then(undefined, function () { }).then(function () { |
| done(); |
| }, nonFunction); |
| }); |
| } |
| |
| testNonFunction(undefined, "`undefined`"); |
| testNonFunction(null, "`null`"); |
| testNonFunction(false, "`false`"); |
| testNonFunction(5, "`5`"); |
| testNonFunction({}, "an object"); |
| }); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],10:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var testFulfilled = require("./helpers/testThreeCases").testFulfilled; |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var deferred = adapter.deferred; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| var sentinel = { sentinel: "sentinel" }; // a sentinel fulfillment value to test for with strict equality |
| |
| describe("2.2.2: If `onFulfilled` is a function,", function () { |
| describe("2.2.2.1: it must be called after `promise` is fulfilled, with `promise`’s fulfillment value as its " + |
| "first argument.", function () { |
| testFulfilled(sentinel, function (promise, done) { |
| promise.then(function onFulfilled(value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("2.2.2.2: it must not be called before `promise` is fulfilled", function () { |
| specify("fulfilled after a delay", function (done) { |
| var d = deferred(); |
| var isFulfilled = false; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(isFulfilled, true); |
| done(); |
| }); |
| |
| setTimeout(function () { |
| d.resolve(dummy); |
| isFulfilled = true; |
| }, 50); |
| }); |
| |
| specify("never fulfilled", function (done) { |
| var d = deferred(); |
| var onFulfilledCalled = false; |
| |
| d.promise.then(function onFulfilled() { |
| onFulfilledCalled = true; |
| done(); |
| }); |
| |
| setTimeout(function () { |
| assert.strictEqual(onFulfilledCalled, false); |
| done(); |
| }, 150); |
| }); |
| }); |
| |
| describe("2.2.2.3: it must not be called more than once.", function () { |
| specify("already-fulfilled", function (done) { |
| var timesCalled = 0; |
| |
| resolved(dummy).then(function onFulfilled() { |
| assert.strictEqual(++timesCalled, 1); |
| done(); |
| }); |
| }); |
| |
| specify("trying to fulfill a pending promise more than once, immediately", function (done) { |
| var d = deferred(); |
| var timesCalled = 0; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(++timesCalled, 1); |
| done(); |
| }); |
| |
| d.resolve(dummy); |
| d.resolve(dummy); |
| }); |
| |
| specify("trying to fulfill a pending promise more than once, delayed", function (done) { |
| var d = deferred(); |
| var timesCalled = 0; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(++timesCalled, 1); |
| done(); |
| }); |
| |
| setTimeout(function () { |
| d.resolve(dummy); |
| d.resolve(dummy); |
| }, 50); |
| }); |
| |
| specify("trying to fulfill a pending promise more than once, immediately then delayed", function (done) { |
| var d = deferred(); |
| var timesCalled = 0; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(++timesCalled, 1); |
| done(); |
| }); |
| |
| d.resolve(dummy); |
| setTimeout(function () { |
| d.resolve(dummy); |
| }, 50); |
| }); |
| |
| specify("when multiple `then` calls are made, spaced apart in time", function (done) { |
| var d = deferred(); |
| var timesCalled = [0, 0, 0]; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(++timesCalled[0], 1); |
| }); |
| |
| setTimeout(function () { |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(++timesCalled[1], 1); |
| }); |
| }, 50); |
| |
| setTimeout(function () { |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(++timesCalled[2], 1); |
| done(); |
| }); |
| }, 100); |
| |
| setTimeout(function () { |
| d.resolve(dummy); |
| }, 150); |
| }); |
| |
| specify("when `then` is interleaved with fulfillment", function (done) { |
| var d = deferred(); |
| var timesCalled = [0, 0]; |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(++timesCalled[0], 1); |
| }); |
| |
| d.resolve(dummy); |
| |
| d.promise.then(function onFulfilled() { |
| assert.strictEqual(++timesCalled[1], 1); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./helpers/testThreeCases":21,"assert":1}],11:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var testRejected = require("./helpers/testThreeCases").testRejected; |
| |
| var adapter = global.adapter; |
| var rejected = adapter.rejected; |
| var deferred = adapter.deferred; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| var sentinel = { sentinel: "sentinel" }; // a sentinel fulfillment value to test for with strict equality |
| |
| describe("2.2.3: If `onRejected` is a function,", function () { |
| describe("2.2.3.1: it must be called after `promise` is rejected, with `promise`’s rejection reason as its " + |
| "first argument.", function () { |
| testRejected(sentinel, function (promise, done) { |
| promise.then(null, function onRejected(reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("2.2.3.2: it must not be called before `promise` is rejected", function () { |
| specify("rejected after a delay", function (done) { |
| var d = deferred(); |
| var isRejected = false; |
| |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(isRejected, true); |
| done(); |
| }); |
| |
| setTimeout(function () { |
| d.reject(dummy); |
| isRejected = true; |
| }, 50); |
| }); |
| |
| specify("never rejected", function (done) { |
| var d = deferred(); |
| var onRejectedCalled = false; |
| |
| d.promise.then(null, function onRejected() { |
| onRejectedCalled = true; |
| done(); |
| }); |
| |
| setTimeout(function () { |
| assert.strictEqual(onRejectedCalled, false); |
| done(); |
| }, 150); |
| }); |
| }); |
| |
| describe("2.2.3.3: it must not be called more than once.", function () { |
| specify("already-rejected", function (done) { |
| var timesCalled = 0; |
| |
| rejected(dummy).then(null, function onRejected() { |
| assert.strictEqual(++timesCalled, 1); |
| done(); |
| }); |
| }); |
| |
| specify("trying to reject a pending promise more than once, immediately", function (done) { |
| var d = deferred(); |
| var timesCalled = 0; |
| |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(++timesCalled, 1); |
| done(); |
| }); |
| |
| d.reject(dummy); |
| d.reject(dummy); |
| }); |
| |
| specify("trying to reject a pending promise more than once, delayed", function (done) { |
| var d = deferred(); |
| var timesCalled = 0; |
| |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(++timesCalled, 1); |
| done(); |
| }); |
| |
| setTimeout(function () { |
| d.reject(dummy); |
| d.reject(dummy); |
| }, 50); |
| }); |
| |
| specify("trying to reject a pending promise more than once, immediately then delayed", function (done) { |
| var d = deferred(); |
| var timesCalled = 0; |
| |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(++timesCalled, 1); |
| done(); |
| }); |
| |
| d.reject(dummy); |
| setTimeout(function () { |
| d.reject(dummy); |
| }, 50); |
| }); |
| |
| specify("when multiple `then` calls are made, spaced apart in time", function (done) { |
| var d = deferred(); |
| var timesCalled = [0, 0, 0]; |
| |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(++timesCalled[0], 1); |
| }); |
| |
| setTimeout(function () { |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(++timesCalled[1], 1); |
| }); |
| }, 50); |
| |
| setTimeout(function () { |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(++timesCalled[2], 1); |
| done(); |
| }); |
| }, 100); |
| |
| setTimeout(function () { |
| d.reject(dummy); |
| }, 150); |
| }); |
| |
| specify("when `then` is interleaved with rejection", function (done) { |
| var d = deferred(); |
| var timesCalled = [0, 0]; |
| |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(++timesCalled[0], 1); |
| }); |
| |
| d.reject(dummy); |
| |
| d.promise.then(null, function onRejected() { |
| assert.strictEqual(++timesCalled[1], 1); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./helpers/testThreeCases":21,"assert":1}],12:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var testFulfilled = require("./helpers/testThreeCases").testFulfilled; |
| var testRejected = require("./helpers/testThreeCases").testRejected; |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| var deferred = adapter.deferred; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| |
| describe("2.2.4: `onFulfilled` or `onRejected` must not be called until the execution context stack contains only " + |
| "platform code.", function () { |
| describe("`then` returns before the promise becomes fulfilled or rejected", function () { |
| testFulfilled(dummy, function (promise, done) { |
| var thenHasReturned = false; |
| |
| promise.then(function onFulfilled() { |
| assert.strictEqual(thenHasReturned, true); |
| done(); |
| }); |
| |
| thenHasReturned = true; |
| }); |
| testRejected(dummy, function (promise, done) { |
| var thenHasReturned = false; |
| |
| promise.then(null, function onRejected() { |
| assert.strictEqual(thenHasReturned, true); |
| done(); |
| }); |
| |
| thenHasReturned = true; |
| }); |
| }); |
| |
| describe("Clean-stack execution ordering tests (fulfillment case)", function () { |
| specify("when `onFulfilled` is added immediately before the promise is fulfilled", |
| function () { |
| var d = deferred(); |
| var onFulfilledCalled = false; |
| |
| d.promise.then(function onFulfilled() { |
| onFulfilledCalled = true; |
| }); |
| |
| d.resolve(dummy); |
| |
| assert.strictEqual(onFulfilledCalled, false); |
| }); |
| |
| specify("when `onFulfilled` is added immediately after the promise is fulfilled", |
| function () { |
| var d = deferred(); |
| var onFulfilledCalled = false; |
| |
| d.resolve(dummy); |
| |
| d.promise.then(function onFulfilled() { |
| onFulfilledCalled = true; |
| }); |
| |
| assert.strictEqual(onFulfilledCalled, false); |
| }); |
| |
| specify("when one `onFulfilled` is added inside another `onFulfilled`", function (done) { |
| var promise = resolved(); |
| var firstOnFulfilledFinished = false; |
| |
| promise.then(function () { |
| promise.then(function () { |
| assert.strictEqual(firstOnFulfilledFinished, true); |
| done(); |
| }); |
| firstOnFulfilledFinished = true; |
| }); |
| }); |
| |
| specify("when `onFulfilled` is added inside an `onRejected`", function (done) { |
| var promise = rejected(); |
| var promise2 = resolved(); |
| var firstOnRejectedFinished = false; |
| |
| promise.then(null, function () { |
| promise2.then(function () { |
| assert.strictEqual(firstOnRejectedFinished, true); |
| done(); |
| }); |
| firstOnRejectedFinished = true; |
| }); |
| }); |
| |
| specify("when the promise is fulfilled asynchronously", function (done) { |
| var d = deferred(); |
| var firstStackFinished = false; |
| |
| setTimeout(function () { |
| d.resolve(dummy); |
| firstStackFinished = true; |
| }, 0); |
| |
| d.promise.then(function () { |
| assert.strictEqual(firstStackFinished, true); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("Clean-stack execution ordering tests (rejection case)", function () { |
| specify("when `onRejected` is added immediately before the promise is rejected", |
| function () { |
| var d = deferred(); |
| var onRejectedCalled = false; |
| |
| d.promise.then(null, function onRejected() { |
| onRejectedCalled = true; |
| }); |
| |
| d.reject(dummy); |
| |
| assert.strictEqual(onRejectedCalled, false); |
| }); |
| |
| specify("when `onRejected` is added immediately after the promise is rejected", |
| function () { |
| var d = deferred(); |
| var onRejectedCalled = false; |
| |
| d.reject(dummy); |
| |
| d.promise.then(null, function onRejected() { |
| onRejectedCalled = true; |
| }); |
| |
| assert.strictEqual(onRejectedCalled, false); |
| }); |
| |
| specify("when `onRejected` is added inside an `onFulfilled`", function (done) { |
| var promise = resolved(); |
| var promise2 = rejected(); |
| var firstOnFulfilledFinished = false; |
| |
| promise.then(function () { |
| promise2.then(null, function () { |
| assert.strictEqual(firstOnFulfilledFinished, true); |
| done(); |
| }); |
| firstOnFulfilledFinished = true; |
| }); |
| }); |
| |
| specify("when one `onRejected` is added inside another `onRejected`", function (done) { |
| var promise = rejected(); |
| var firstOnRejectedFinished = false; |
| |
| promise.then(null, function () { |
| promise.then(null, function () { |
| assert.strictEqual(firstOnRejectedFinished, true); |
| done(); |
| }); |
| firstOnRejectedFinished = true; |
| }); |
| }); |
| |
| specify("when the promise is rejected asynchronously", function (done) { |
| var d = deferred(); |
| var firstStackFinished = false; |
| |
| setTimeout(function () { |
| d.reject(dummy); |
| firstStackFinished = true; |
| }, 0); |
| |
| d.promise.then(null, function () { |
| assert.strictEqual(firstStackFinished, true); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./helpers/testThreeCases":21,"assert":1}],13:[function(require,module,exports){ |
| (function (global){ |
| /*jshint strict: false */ |
| |
| var assert = require("assert"); |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| |
| describe("2.2.5 `onFulfilled` and `onRejected` must be called as functions (i.e. with no `this` value).", function () { |
| describe("strict mode", function () { |
| specify("fulfilled", function (done) { |
| resolved(dummy).then(function onFulfilled() { |
| "use strict"; |
| |
| assert.strictEqual(this, undefined); |
| done(); |
| }); |
| }); |
| |
| specify("rejected", function (done) { |
| rejected(dummy).then(null, function onRejected() { |
| "use strict"; |
| |
| assert.strictEqual(this, undefined); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("sloppy mode", function () { |
| specify("fulfilled", function (done) { |
| resolved(dummy).then(function onFulfilled() { |
| assert.strictEqual(this, global); |
| done(); |
| }); |
| }); |
| |
| specify("rejected", function (done) { |
| rejected(dummy).then(null, function onRejected() { |
| assert.strictEqual(this, global); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"assert":1}],14:[function(require,module,exports){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var sinon = require("sinon"); |
| var testFulfilled = require("./helpers/testThreeCases").testFulfilled; |
| var testRejected = require("./helpers/testThreeCases").testRejected; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| var other = { other: "other" }; // a value we don't want to be strict equal to |
| var sentinel = { sentinel: "sentinel" }; // a sentinel fulfillment value to test for with strict equality |
| var sentinel2 = { sentinel2: "sentinel2" }; |
| var sentinel3 = { sentinel3: "sentinel3" }; |
| |
| function callbackAggregator(times, ultimateCallback) { |
| var soFar = 0; |
| return function () { |
| if (++soFar === times) { |
| ultimateCallback(); |
| } |
| }; |
| } |
| |
| describe("2.2.6: `then` may be called multiple times on the same promise.", function () { |
| describe("2.2.6.1: If/when `promise` is fulfilled, all respective `onFulfilled` callbacks must execute in the " + |
| "order of their originating calls to `then`.", function () { |
| describe("multiple boring fulfillment handlers", function () { |
| testFulfilled(sentinel, function (promise, done) { |
| var handler1 = sinon.stub().returns(other); |
| var handler2 = sinon.stub().returns(other); |
| var handler3 = sinon.stub().returns(other); |
| |
| var spy = sinon.spy(); |
| promise.then(handler1, spy); |
| promise.then(handler2, spy); |
| promise.then(handler3, spy); |
| |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| |
| sinon.assert.calledWith(handler1, sinon.match.same(sentinel)); |
| sinon.assert.calledWith(handler2, sinon.match.same(sentinel)); |
| sinon.assert.calledWith(handler3, sinon.match.same(sentinel)); |
| sinon.assert.notCalled(spy); |
| |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("multiple fulfillment handlers, one of which throws", function () { |
| testFulfilled(sentinel, function (promise, done) { |
| var handler1 = sinon.stub().returns(other); |
| var handler2 = sinon.stub().throws(other); |
| var handler3 = sinon.stub().returns(other); |
| |
| var spy = sinon.spy(); |
| promise.then(handler1, spy); |
| promise.then(handler2, spy); |
| promise.then(handler3, spy); |
| |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| |
| sinon.assert.calledWith(handler1, sinon.match.same(sentinel)); |
| sinon.assert.calledWith(handler2, sinon.match.same(sentinel)); |
| sinon.assert.calledWith(handler3, sinon.match.same(sentinel)); |
| sinon.assert.notCalled(spy); |
| |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("results in multiple branching chains with their own fulfillment values", function () { |
| testFulfilled(dummy, function (promise, done) { |
| var semiDone = callbackAggregator(3, done); |
| |
| promise.then(function () { |
| return sentinel; |
| }).then(function (value) { |
| assert.strictEqual(value, sentinel); |
| semiDone(); |
| }); |
| |
| promise.then(function () { |
| throw sentinel2; |
| }).then(null, function (reason) { |
| assert.strictEqual(reason, sentinel2); |
| semiDone(); |
| }); |
| |
| promise.then(function () { |
| return sentinel3; |
| }).then(function (value) { |
| assert.strictEqual(value, sentinel3); |
| semiDone(); |
| }); |
| }); |
| }); |
| |
| describe("`onFulfilled` handlers are called in the original order", function () { |
| testFulfilled(dummy, function (promise, done) { |
| var handler1 = sinon.spy(function handler1() {}); |
| var handler2 = sinon.spy(function handler2() {}); |
| var handler3 = sinon.spy(function handler3() {}); |
| |
| promise.then(handler1); |
| promise.then(handler2); |
| promise.then(handler3); |
| |
| promise.then(function () { |
| sinon.assert.callOrder(handler1, handler2, handler3); |
| done(); |
| }); |
| }); |
| |
| describe("even when one handler is added inside another handler", function () { |
| testFulfilled(dummy, function (promise, done) { |
| var handler1 = sinon.spy(function handler1() {}); |
| var handler2 = sinon.spy(function handler2() {}); |
| var handler3 = sinon.spy(function handler3() {}); |
| |
| promise.then(function () { |
| handler1(); |
| promise.then(handler3); |
| }); |
| promise.then(handler2); |
| |
| promise.then(function () { |
| // Give implementations a bit of extra time to flush their internal queue, if necessary. |
| setTimeout(function () { |
| sinon.assert.callOrder(handler1, handler2, handler3); |
| done(); |
| }, 15); |
| }); |
| }); |
| }); |
| }); |
| }); |
| |
| describe("2.2.6.2: If/when `promise` is rejected, all respective `onRejected` callbacks must execute in the " + |
| "order of their originating calls to `then`.", function () { |
| describe("multiple boring rejection handlers", function () { |
| testRejected(sentinel, function (promise, done) { |
| var handler1 = sinon.stub().returns(other); |
| var handler2 = sinon.stub().returns(other); |
| var handler3 = sinon.stub().returns(other); |
| |
| var spy = sinon.spy(); |
| promise.then(spy, handler1); |
| promise.then(spy, handler2); |
| promise.then(spy, handler3); |
| |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| |
| sinon.assert.calledWith(handler1, sinon.match.same(sentinel)); |
| sinon.assert.calledWith(handler2, sinon.match.same(sentinel)); |
| sinon.assert.calledWith(handler3, sinon.match.same(sentinel)); |
| sinon.assert.notCalled(spy); |
| |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("multiple rejection handlers, one of which throws", function () { |
| testRejected(sentinel, function (promise, done) { |
| var handler1 = sinon.stub().returns(other); |
| var handler2 = sinon.stub().throws(other); |
| var handler3 = sinon.stub().returns(other); |
| |
| var spy = sinon.spy(); |
| promise.then(spy, handler1); |
| promise.then(spy, handler2); |
| promise.then(spy, handler3); |
| |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| |
| sinon.assert.calledWith(handler1, sinon.match.same(sentinel)); |
| sinon.assert.calledWith(handler2, sinon.match.same(sentinel)); |
| sinon.assert.calledWith(handler3, sinon.match.same(sentinel)); |
| sinon.assert.notCalled(spy); |
| |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("results in multiple branching chains with their own fulfillment values", function () { |
| testRejected(sentinel, function (promise, done) { |
| var semiDone = callbackAggregator(3, done); |
| |
| promise.then(null, function () { |
| return sentinel; |
| }).then(function (value) { |
| assert.strictEqual(value, sentinel); |
| semiDone(); |
| }); |
| |
| promise.then(null, function () { |
| throw sentinel2; |
| }).then(null, function (reason) { |
| assert.strictEqual(reason, sentinel2); |
| semiDone(); |
| }); |
| |
| promise.then(null, function () { |
| return sentinel3; |
| }).then(function (value) { |
| assert.strictEqual(value, sentinel3); |
| semiDone(); |
| }); |
| }); |
| }); |
| |
| describe("`onRejected` handlers are called in the original order", function () { |
| testRejected(dummy, function (promise, done) { |
| var handler1 = sinon.spy(function handler1() {}); |
| var handler2 = sinon.spy(function handler2() {}); |
| var handler3 = sinon.spy(function handler3() {}); |
| |
| promise.then(null, handler1); |
| promise.then(null, handler2); |
| promise.then(null, handler3); |
| |
| promise.then(null, function () { |
| sinon.assert.callOrder(handler1, handler2, handler3); |
| done(); |
| }); |
| }); |
| |
| describe("even when one handler is added inside another handler", function () { |
| testRejected(dummy, function (promise, done) { |
| var handler1 = sinon.spy(function handler1() {}); |
| var handler2 = sinon.spy(function handler2() {}); |
| var handler3 = sinon.spy(function handler3() {}); |
| |
| promise.then(null, function () { |
| handler1(); |
| promise.then(null, handler3); |
| }); |
| promise.then(null, handler2); |
| |
| promise.then(null, function () { |
| // Give implementations a bit of extra time to flush their internal queue, if necessary. |
| setTimeout(function () { |
| sinon.assert.callOrder(handler1, handler2, handler3); |
| done(); |
| }, 15); |
| }); |
| }); |
| }); |
| }); |
| }); |
| }); |
| |
| },{"./helpers/testThreeCases":21,"assert":1,"sinon":23}],15:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var testFulfilled = require("./helpers/testThreeCases").testFulfilled; |
| var testRejected = require("./helpers/testThreeCases").testRejected; |
| var reasons = require("./helpers/reasons"); |
| |
| var adapter = global.adapter; |
| var deferred = adapter.deferred; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| var sentinel = { sentinel: "sentinel" }; // a sentinel fulfillment value to test for with strict equality |
| var other = { other: "other" }; // a value we don't want to be strict equal to |
| |
| describe("2.2.7: `then` must return a promise: `promise2 = promise1.then(onFulfilled, onRejected)`", function () { |
| specify("is a promise", function () { |
| var promise1 = deferred().promise; |
| var promise2 = promise1.then(); |
| |
| assert(typeof promise2 === "object" || typeof promise2 === "function"); |
| assert.notStrictEqual(promise2, null); |
| assert.strictEqual(typeof promise2.then, "function"); |
| }); |
| |
| describe("2.2.7.1: If either `onFulfilled` or `onRejected` returns a value `x`, run the Promise Resolution " + |
| "Procedure `[[Resolve]](promise2, x)`", function () { |
| specify("see separate 3.3 tests", function () { }); |
| }); |
| |
| describe("2.2.7.2: If either `onFulfilled` or `onRejected` throws an exception `e`, `promise2` must be rejected " + |
| "with `e` as the reason.", function () { |
| function testReason(expectedReason, stringRepresentation) { |
| describe("The reason is " + stringRepresentation, function () { |
| testFulfilled(dummy, function (promise1, done) { |
| var promise2 = promise1.then(function onFulfilled() { |
| throw expectedReason; |
| }); |
| |
| promise2.then(null, function onPromise2Rejected(actualReason) { |
| assert.strictEqual(actualReason, expectedReason); |
| done(); |
| }); |
| }); |
| testRejected(dummy, function (promise1, done) { |
| var promise2 = promise1.then(null, function onRejected() { |
| throw expectedReason; |
| }); |
| |
| promise2.then(null, function onPromise2Rejected(actualReason) { |
| assert.strictEqual(actualReason, expectedReason); |
| done(); |
| }); |
| }); |
| }); |
| } |
| |
| Object.keys(reasons).forEach(function (stringRepresentation) { |
| testReason(reasons[stringRepresentation], stringRepresentation); |
| }); |
| }); |
| |
| describe("2.2.7.3: If `onFulfilled` is not a function and `promise1` is fulfilled, `promise2` must be fulfilled " + |
| "with the same value.", function () { |
| |
| function testNonFunction(nonFunction, stringRepresentation) { |
| describe("`onFulfilled` is " + stringRepresentation, function () { |
| testFulfilled(sentinel, function (promise1, done) { |
| var promise2 = promise1.then(nonFunction); |
| |
| promise2.then(function onPromise2Fulfilled(value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| } |
| |
| testNonFunction(undefined, "`undefined`"); |
| testNonFunction(null, "`null`"); |
| testNonFunction(false, "`false`"); |
| testNonFunction(5, "`5`"); |
| testNonFunction({}, "an object"); |
| testNonFunction([function () { return other; }], "an array containing a function"); |
| }); |
| |
| describe("2.2.7.4: If `onRejected` is not a function and `promise1` is rejected, `promise2` must be rejected " + |
| "with the same reason.", function () { |
| |
| function testNonFunction(nonFunction, stringRepresentation) { |
| describe("`onRejected` is " + stringRepresentation, function () { |
| testRejected(sentinel, function (promise1, done) { |
| var promise2 = promise1.then(null, nonFunction); |
| |
| promise2.then(null, function onPromise2Rejected(reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| } |
| |
| testNonFunction(undefined, "`undefined`"); |
| testNonFunction(null, "`null`"); |
| testNonFunction(false, "`false`"); |
| testNonFunction(5, "`5`"); |
| testNonFunction({}, "an object"); |
| testNonFunction([function () { return other; }], "an array containing a function"); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./helpers/reasons":20,"./helpers/testThreeCases":21,"assert":1}],16:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| |
| describe("2.3.1: If `promise` and `x` refer to the same object, reject `promise` with a `TypeError' as the reason.", |
| function () { |
| specify("via return from a fulfilled promise", function (done) { |
| var promise = resolved(dummy).then(function () { |
| return promise; |
| }); |
| |
| promise.then(null, function (reason) { |
| assert(reason instanceof TypeError); |
| done(); |
| }); |
| }); |
| |
| specify("via return from a rejected promise", function (done) { |
| var promise = rejected(dummy).then(null, function () { |
| return promise; |
| }); |
| |
| promise.then(null, function (reason) { |
| assert(reason instanceof TypeError); |
| done(); |
| }); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"assert":1}],17:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| var deferred = adapter.deferred; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| var sentinel = { sentinel: "sentinel" }; // a sentinel fulfillment value to test for with strict equality |
| |
| function testPromiseResolution(xFactory, test) { |
| specify("via return from a fulfilled promise", function (done) { |
| var promise = resolved(dummy).then(function onBasePromiseFulfilled() { |
| return xFactory(); |
| }); |
| |
| test(promise, done); |
| }); |
| |
| specify("via return from a rejected promise", function (done) { |
| var promise = rejected(dummy).then(null, function onBasePromiseRejected() { |
| return xFactory(); |
| }); |
| |
| test(promise, done); |
| }); |
| } |
| |
| describe("2.3.2: If `x` is a promise, adopt its state", function () { |
| describe("2.3.2.1: If `x` is pending, `promise` must remain pending until `x` is fulfilled or rejected.", |
| function () { |
| function xFactory() { |
| return deferred().promise; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| var wasFulfilled = false; |
| var wasRejected = false; |
| |
| promise.then( |
| function onPromiseFulfilled() { |
| wasFulfilled = true; |
| }, |
| function onPromiseRejected() { |
| wasRejected = true; |
| } |
| ); |
| |
| setTimeout(function () { |
| assert.strictEqual(wasFulfilled, false); |
| assert.strictEqual(wasRejected, false); |
| done(); |
| }, 100); |
| }); |
| }); |
| |
| describe("2.3.2.2: If/when `x` is fulfilled, fulfill `promise` with the same value.", function () { |
| describe("`x` is already-fulfilled", function () { |
| function xFactory() { |
| return resolved(sentinel); |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function onPromiseFulfilled(value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`x` is eventually-fulfilled", function () { |
| var d = null; |
| |
| function xFactory() { |
| d = deferred(); |
| setTimeout(function () { |
| d.resolve(sentinel); |
| }, 50); |
| return d.promise; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function onPromiseFulfilled(value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| |
| describe("2.3.2.3: If/when `x` is rejected, reject `promise` with the same reason.", function () { |
| describe("`x` is already-rejected", function () { |
| function xFactory() { |
| return rejected(sentinel); |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function onPromiseRejected(reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`x` is eventually-rejected", function () { |
| var d = null; |
| |
| function xFactory() { |
| d = deferred(); |
| setTimeout(function () { |
| d.reject(sentinel); |
| }, 50); |
| return d.promise; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function onPromiseRejected(reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"assert":1}],18:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var thenables = require("./helpers/thenables"); |
| var reasons = require("./helpers/reasons"); |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| var deferred = adapter.deferred; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| var sentinel = { sentinel: "sentinel" }; // a sentinel fulfillment value to test for with strict equality |
| var other = { other: "other" }; // a value we don't want to be strict equal to |
| var sentinelArray = [sentinel]; // a sentinel fulfillment value to test when we need an array |
| |
| function testPromiseResolution(xFactory, test) { |
| specify("via return from a fulfilled promise", function (done) { |
| var promise = resolved(dummy).then(function onBasePromiseFulfilled() { |
| return xFactory(); |
| }); |
| |
| test(promise, done); |
| }); |
| |
| specify("via return from a rejected promise", function (done) { |
| var promise = rejected(dummy).then(null, function onBasePromiseRejected() { |
| return xFactory(); |
| }); |
| |
| test(promise, done); |
| }); |
| } |
| |
| function testCallingResolvePromise(yFactory, stringRepresentation, test) { |
| describe("`y` is " + stringRepresentation, function () { |
| describe("`then` calls `resolvePromise` synchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise) { |
| resolvePromise(yFactory()); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, test); |
| }); |
| |
| describe("`then` calls `resolvePromise` asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise) { |
| setTimeout(function () { |
| resolvePromise(yFactory()); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, test); |
| }); |
| }); |
| } |
| |
| function testCallingRejectPromise(r, stringRepresentation, test) { |
| describe("`r` is " + stringRepresentation, function () { |
| describe("`then` calls `rejectPromise` synchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| rejectPromise(r); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, test); |
| }); |
| |
| describe("`then` calls `rejectPromise` asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| setTimeout(function () { |
| rejectPromise(r); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, test); |
| }); |
| }); |
| } |
| |
| function testCallingResolvePromiseFulfillsWith(yFactory, stringRepresentation, fulfillmentValue) { |
| testCallingResolvePromise(yFactory, stringRepresentation, function (promise, done) { |
| promise.then(function onPromiseFulfilled(value) { |
| assert.strictEqual(value, fulfillmentValue); |
| done(); |
| }); |
| }); |
| } |
| |
| function testCallingResolvePromiseRejectsWith(yFactory, stringRepresentation, rejectionReason) { |
| testCallingResolvePromise(yFactory, stringRepresentation, function (promise, done) { |
| promise.then(null, function onPromiseRejected(reason) { |
| assert.strictEqual(reason, rejectionReason); |
| done(); |
| }); |
| }); |
| } |
| |
| function testCallingRejectPromiseRejectsWith(reason, stringRepresentation) { |
| testCallingRejectPromise(reason, stringRepresentation, function (promise, done) { |
| promise.then(null, function onPromiseRejected(rejectionReason) { |
| assert.strictEqual(rejectionReason, reason); |
| done(); |
| }); |
| }); |
| } |
| |
| describe("2.3.3: Otherwise, if `x` is an object or function,", function () { |
| describe("2.3.3.1: Let `then` be `x.then`", function () { |
| describe("`x` is an object with null prototype", function () { |
| var numberOfTimesThenWasRetrieved = null; |
| |
| beforeEach(function () { |
| numberOfTimesThenWasRetrieved = 0; |
| }); |
| |
| function xFactory() { |
| return Object.create(null, { |
| then: { |
| get: function () { |
| ++numberOfTimesThenWasRetrieved; |
| return function thenMethodForX(onFulfilled) { |
| onFulfilled(); |
| }; |
| } |
| } |
| }); |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function () { |
| assert.strictEqual(numberOfTimesThenWasRetrieved, 1); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`x` is an object with normal Object.prototype", function () { |
| var numberOfTimesThenWasRetrieved = null; |
| |
| beforeEach(function () { |
| numberOfTimesThenWasRetrieved = 0; |
| }); |
| |
| function xFactory() { |
| return Object.create(Object.prototype, { |
| then: { |
| get: function () { |
| ++numberOfTimesThenWasRetrieved; |
| return function thenMethodForX(onFulfilled) { |
| onFulfilled(); |
| }; |
| } |
| } |
| }); |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function () { |
| assert.strictEqual(numberOfTimesThenWasRetrieved, 1); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`x` is a function", function () { |
| var numberOfTimesThenWasRetrieved = null; |
| |
| beforeEach(function () { |
| numberOfTimesThenWasRetrieved = 0; |
| }); |
| |
| function xFactory() { |
| function x() { } |
| |
| Object.defineProperty(x, "then", { |
| get: function () { |
| ++numberOfTimesThenWasRetrieved; |
| return function thenMethodForX(onFulfilled) { |
| onFulfilled(); |
| }; |
| } |
| }); |
| |
| return x; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function () { |
| assert.strictEqual(numberOfTimesThenWasRetrieved, 1); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| |
| describe("2.3.3.2: If retrieving the property `x.then` results in a thrown exception `e`, reject `promise` with " + |
| "`e` as the reason.", function () { |
| function testRejectionViaThrowingGetter(e, stringRepresentation) { |
| function xFactory() { |
| return Object.create(Object.prototype, { |
| then: { |
| get: function () { |
| throw e; |
| } |
| } |
| }); |
| } |
| |
| describe("`e` is " + stringRepresentation, function () { |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, e); |
| done(); |
| }); |
| }); |
| }); |
| } |
| |
| Object.keys(reasons).forEach(function (stringRepresentation) { |
| testRejectionViaThrowingGetter(reasons[stringRepresentation], stringRepresentation); |
| }); |
| }); |
| |
| describe("2.3.3.3: If `then` is a function, call it with `x` as `this`, first argument `resolvePromise`, and " + |
| "second argument `rejectPromise`", function () { |
| describe("Calls with `x` as `this` and two function arguments", function () { |
| function xFactory() { |
| var x = { |
| then: function (onFulfilled, onRejected) { |
| assert.strictEqual(this, x); |
| assert.strictEqual(typeof onFulfilled, "function"); |
| assert.strictEqual(typeof onRejected, "function"); |
| onFulfilled(); |
| } |
| }; |
| return x; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function () { |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("Uses the original value of `then`", function () { |
| var numberOfTimesThenWasRetrieved = null; |
| |
| beforeEach(function () { |
| numberOfTimesThenWasRetrieved = 0; |
| }); |
| |
| function xFactory() { |
| return Object.create(Object.prototype, { |
| then: { |
| get: function () { |
| if (numberOfTimesThenWasRetrieved === 0) { |
| return function (onFulfilled) { |
| onFulfilled(); |
| }; |
| } |
| return null; |
| } |
| } |
| }); |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function () { |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("2.3.3.3.1: If/when `resolvePromise` is called with value `y`, run `[[Resolve]](promise, y)`", |
| function () { |
| describe("`y` is not a thenable", function () { |
| testCallingResolvePromiseFulfillsWith(function () { return undefined; }, "`undefined`", undefined); |
| testCallingResolvePromiseFulfillsWith(function () { return null; }, "`null`", null); |
| testCallingResolvePromiseFulfillsWith(function () { return false; }, "`false`", false); |
| testCallingResolvePromiseFulfillsWith(function () { return 5; }, "`5`", 5); |
| testCallingResolvePromiseFulfillsWith(function () { return sentinel; }, "an object", sentinel); |
| testCallingResolvePromiseFulfillsWith(function () { return sentinelArray; }, "an array", sentinelArray); |
| }); |
| |
| describe("`y` is a thenable", function () { |
| Object.keys(thenables.fulfilled).forEach(function (stringRepresentation) { |
| function yFactory() { |
| return thenables.fulfilled[stringRepresentation](sentinel); |
| } |
| |
| testCallingResolvePromiseFulfillsWith(yFactory, stringRepresentation, sentinel); |
| }); |
| |
| Object.keys(thenables.rejected).forEach(function (stringRepresentation) { |
| function yFactory() { |
| return thenables.rejected[stringRepresentation](sentinel); |
| } |
| |
| testCallingResolvePromiseRejectsWith(yFactory, stringRepresentation, sentinel); |
| }); |
| }); |
| |
| describe("`y` is a thenable for a thenable", function () { |
| Object.keys(thenables.fulfilled).forEach(function (outerStringRepresentation) { |
| var outerThenableFactory = thenables.fulfilled[outerStringRepresentation]; |
| |
| Object.keys(thenables.fulfilled).forEach(function (innerStringRepresentation) { |
| var innerThenableFactory = thenables.fulfilled[innerStringRepresentation]; |
| |
| var stringRepresentation = outerStringRepresentation + " for " + innerStringRepresentation; |
| |
| function yFactory() { |
| return outerThenableFactory(innerThenableFactory(sentinel)); |
| } |
| |
| testCallingResolvePromiseFulfillsWith(yFactory, stringRepresentation, sentinel); |
| }); |
| |
| Object.keys(thenables.rejected).forEach(function (innerStringRepresentation) { |
| var innerThenableFactory = thenables.rejected[innerStringRepresentation]; |
| |
| var stringRepresentation = outerStringRepresentation + " for " + innerStringRepresentation; |
| |
| function yFactory() { |
| return outerThenableFactory(innerThenableFactory(sentinel)); |
| } |
| |
| testCallingResolvePromiseRejectsWith(yFactory, stringRepresentation, sentinel); |
| }); |
| }); |
| }); |
| }); |
| |
| describe("2.3.3.3.2: If/when `rejectPromise` is called with reason `r`, reject `promise` with `r`", |
| function () { |
| Object.keys(reasons).forEach(function (stringRepresentation) { |
| testCallingRejectPromiseRejectsWith(reasons[stringRepresentation], stringRepresentation); |
| }); |
| }); |
| |
| describe("2.3.3.3.3: If both `resolvePromise` and `rejectPromise` are called, or multiple calls to the same " + |
| "argument are made, the first call takes precedence, and any further calls are ignored.", |
| function () { |
| describe("calling `resolvePromise` then `rejectPromise`, both synchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| resolvePromise(sentinel); |
| rejectPromise(other); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` synchronously then `rejectPromise` asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| resolvePromise(sentinel); |
| |
| setTimeout(function () { |
| rejectPromise(other); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` then `rejectPromise`, both asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| setTimeout(function () { |
| resolvePromise(sentinel); |
| }, 0); |
| |
| setTimeout(function () { |
| rejectPromise(other); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` with an asynchronously-fulfilled promise, then calling " + |
| "`rejectPromise`, both synchronously", function () { |
| function xFactory() { |
| var d = deferred(); |
| setTimeout(function () { |
| d.resolve(sentinel); |
| }, 50); |
| |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| resolvePromise(d.promise); |
| rejectPromise(other); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` with an asynchronously-rejected promise, then calling " + |
| "`rejectPromise`, both synchronously", function () { |
| function xFactory() { |
| var d = deferred(); |
| setTimeout(function () { |
| d.reject(sentinel); |
| }, 50); |
| |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| resolvePromise(d.promise); |
| rejectPromise(other); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `rejectPromise` then `resolvePromise`, both synchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| rejectPromise(sentinel); |
| resolvePromise(other); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `rejectPromise` synchronously then `resolvePromise` asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| rejectPromise(sentinel); |
| |
| setTimeout(function () { |
| resolvePromise(other); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `rejectPromise` then `resolvePromise`, both asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| setTimeout(function () { |
| rejectPromise(sentinel); |
| }, 0); |
| |
| setTimeout(function () { |
| resolvePromise(other); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` twice synchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise) { |
| resolvePromise(sentinel); |
| resolvePromise(other); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` twice, first synchronously then asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise) { |
| resolvePromise(sentinel); |
| |
| setTimeout(function () { |
| resolvePromise(other); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` twice, both times asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise) { |
| setTimeout(function () { |
| resolvePromise(sentinel); |
| }, 0); |
| |
| setTimeout(function () { |
| resolvePromise(other); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` with an asynchronously-fulfilled promise, then calling it again, both " + |
| "times synchronously", function () { |
| function xFactory() { |
| var d = deferred(); |
| setTimeout(function () { |
| d.resolve(sentinel); |
| }, 50); |
| |
| return { |
| then: function (resolvePromise) { |
| resolvePromise(d.promise); |
| resolvePromise(other); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `resolvePromise` with an asynchronously-rejected promise, then calling it again, both " + |
| "times synchronously", function () { |
| function xFactory() { |
| var d = deferred(); |
| setTimeout(function () { |
| d.reject(sentinel); |
| }, 50); |
| |
| return { |
| then: function (resolvePromise) { |
| resolvePromise(d.promise); |
| resolvePromise(other); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `rejectPromise` twice synchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| rejectPromise(sentinel); |
| rejectPromise(other); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `rejectPromise` twice, first synchronously then asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| rejectPromise(sentinel); |
| |
| setTimeout(function () { |
| rejectPromise(other); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("calling `rejectPromise` twice, both times asynchronously", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| setTimeout(function () { |
| rejectPromise(sentinel); |
| }, 0); |
| |
| setTimeout(function () { |
| rejectPromise(other); |
| }, 0); |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("saving and abusing `resolvePromise` and `rejectPromise`", function () { |
| var savedResolvePromise, savedRejectPromise; |
| |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| savedResolvePromise = resolvePromise; |
| savedRejectPromise = rejectPromise; |
| } |
| }; |
| } |
| |
| beforeEach(function () { |
| savedResolvePromise = null; |
| savedRejectPromise = null; |
| }); |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| var timesFulfilled = 0; |
| var timesRejected = 0; |
| |
| promise.then( |
| function () { |
| ++timesFulfilled; |
| }, |
| function () { |
| ++timesRejected; |
| } |
| ); |
| |
| if (savedResolvePromise && savedRejectPromise) { |
| savedResolvePromise(dummy); |
| savedResolvePromise(dummy); |
| savedRejectPromise(dummy); |
| savedRejectPromise(dummy); |
| } |
| |
| setTimeout(function () { |
| savedResolvePromise(dummy); |
| savedResolvePromise(dummy); |
| savedRejectPromise(dummy); |
| savedRejectPromise(dummy); |
| }, 50); |
| |
| setTimeout(function () { |
| assert.strictEqual(timesFulfilled, 1); |
| assert.strictEqual(timesRejected, 0); |
| done(); |
| }, 100); |
| }); |
| }); |
| }); |
| |
| describe("2.3.3.3.4: If calling `then` throws an exception `e`,", function () { |
| describe("2.3.3.3.4.1: If `resolvePromise` or `rejectPromise` have been called, ignore it.", function () { |
| describe("`resolvePromise` was called with a non-thenable", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise) { |
| resolvePromise(sentinel); |
| throw other; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`resolvePromise` was called with an asynchronously-fulfilled promise", function () { |
| function xFactory() { |
| var d = deferred(); |
| setTimeout(function () { |
| d.resolve(sentinel); |
| }, 50); |
| |
| return { |
| then: function (resolvePromise) { |
| resolvePromise(d.promise); |
| throw other; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`resolvePromise` was called with an asynchronously-rejected promise", function () { |
| function xFactory() { |
| var d = deferred(); |
| setTimeout(function () { |
| d.reject(sentinel); |
| }, 50); |
| |
| return { |
| then: function (resolvePromise) { |
| resolvePromise(d.promise); |
| throw other; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`rejectPromise` was called", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| rejectPromise(sentinel); |
| throw other; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`resolvePromise` then `rejectPromise` were called", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| resolvePromise(sentinel); |
| rejectPromise(other); |
| throw other; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`rejectPromise` then `resolvePromise` were called", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| rejectPromise(sentinel); |
| resolvePromise(other); |
| throw other; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| |
| describe("2.3.3.3.4.2: Otherwise, reject `promise` with `e` as the reason.", function () { |
| describe("straightforward case", function () { |
| function xFactory() { |
| return { |
| then: function () { |
| throw sentinel; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`resolvePromise` is called asynchronously before the `throw`", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise) { |
| setTimeout(function () { |
| resolvePromise(other); |
| }, 0); |
| throw sentinel; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| |
| describe("`rejectPromise` is called asynchronously before the `throw`", function () { |
| function xFactory() { |
| return { |
| then: function (resolvePromise, rejectPromise) { |
| setTimeout(function () { |
| rejectPromise(other); |
| }, 0); |
| throw sentinel; |
| } |
| }; |
| } |
| |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(null, function (reason) { |
| assert.strictEqual(reason, sentinel); |
| done(); |
| }); |
| }); |
| }); |
| }); |
| }); |
| }); |
| |
| describe("2.3.3.4: If `then` is not a function, fulfill promise with `x`", function () { |
| function testFulfillViaNonFunction(then, stringRepresentation) { |
| var x = null; |
| |
| beforeEach(function () { |
| x = { then: then }; |
| }); |
| |
| function xFactory() { |
| return x; |
| } |
| |
| describe("`then` is " + stringRepresentation, function () { |
| testPromiseResolution(xFactory, function (promise, done) { |
| promise.then(function (value) { |
| assert.strictEqual(value, x); |
| done(); |
| }); |
| }); |
| }); |
| } |
| |
| testFulfillViaNonFunction(5, "`5`"); |
| testFulfillViaNonFunction({}, "an object"); |
| testFulfillViaNonFunction([function () { }], "an array containing a function"); |
| testFulfillViaNonFunction(/a-b/i, "a regular expression"); |
| testFulfillViaNonFunction(Object.create(Function.prototype), "an object inheriting from `Function.prototype`"); |
| }); |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./helpers/reasons":20,"./helpers/thenables":22,"assert":1}],19:[function(require,module,exports){ |
| "use strict"; |
| |
| var assert = require("assert"); |
| var testFulfilled = require("./helpers/testThreeCases").testFulfilled; |
| var testRejected = require("./helpers/testThreeCases").testRejected; |
| |
| var dummy = { dummy: "dummy" }; // we fulfill or reject with this when we don't intend to test against it |
| |
| describe("2.3.4: If `x` is not an object or function, fulfill `promise` with `x`", function () { |
| function testValue(expectedValue, stringRepresentation, beforeEachHook, afterEachHook) { |
| describe("The value is " + stringRepresentation, function () { |
| if (typeof beforeEachHook === "function") { |
| beforeEach(beforeEachHook); |
| } |
| if (typeof afterEachHook === "function") { |
| afterEach(afterEachHook); |
| } |
| |
| testFulfilled(dummy, function (promise1, done) { |
| var promise2 = promise1.then(function onFulfilled() { |
| return expectedValue; |
| }); |
| |
| promise2.then(function onPromise2Fulfilled(actualValue) { |
| assert.strictEqual(actualValue, expectedValue); |
| done(); |
| }); |
| }); |
| testRejected(dummy, function (promise1, done) { |
| var promise2 = promise1.then(null, function onRejected() { |
| return expectedValue; |
| }); |
| |
| promise2.then(function onPromise2Fulfilled(actualValue) { |
| assert.strictEqual(actualValue, expectedValue); |
| done(); |
| }); |
| }); |
| }); |
| } |
| |
| testValue(undefined, "`undefined`"); |
| testValue(null, "`null`"); |
| testValue(false, "`false`"); |
| testValue(true, "`true`"); |
| testValue(0, "`0`"); |
| |
| testValue( |
| true, |
| "`true` with `Boolean.prototype` modified to have a `then` method", |
| function () { |
| Boolean.prototype.then = function () {}; |
| }, |
| function () { |
| delete Boolean.prototype.then; |
| } |
| ); |
| |
| testValue( |
| 1, |
| "`1` with `Number.prototype` modified to have a `then` method", |
| function () { |
| Number.prototype.then = function () {}; |
| }, |
| function () { |
| delete Number.prototype.then; |
| } |
| ); |
| }); |
| |
| },{"./helpers/testThreeCases":21,"assert":1}],20:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| // This module exports some valid rejection reason factories, keyed by human-readable versions of their names. |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| |
| var dummy = { dummy: "dummy" }; |
| |
| exports["`undefined`"] = function () { |
| return undefined; |
| }; |
| |
| exports["`null`"] = function () { |
| return null; |
| }; |
| |
| exports["`false`"] = function () { |
| return false; |
| }; |
| |
| exports["`0`"] = function () { |
| return 0; |
| }; |
| |
| exports["an error"] = function () { |
| return new Error(); |
| }; |
| |
| exports["an error without a stack"] = function () { |
| var error = new Error(); |
| delete error.stack; |
| |
| return error; |
| }; |
| |
| exports["a date"] = function () { |
| return new Date(); |
| }; |
| |
| exports["an object"] = function () { |
| return {}; |
| }; |
| |
| exports["an always-pending thenable"] = function () { |
| return { then: function () { } }; |
| }; |
| |
| exports["a fulfilled promise"] = function () { |
| return resolved(dummy); |
| }; |
| |
| exports["a rejected promise"] = function () { |
| return rejected(dummy); |
| }; |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],21:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| var deferred = adapter.deferred; |
| |
| exports.testFulfilled = function (value, test) { |
| specify("already-fulfilled", function (done) { |
| test(resolved(value), done); |
| }); |
| |
| specify("immediately-fulfilled", function (done) { |
| var d = deferred(); |
| test(d.promise, done); |
| d.resolve(value); |
| }); |
| |
| specify("eventually-fulfilled", function (done) { |
| var d = deferred(); |
| test(d.promise, done); |
| setTimeout(function () { |
| d.resolve(value); |
| }, 50); |
| }); |
| }; |
| |
| exports.testRejected = function (reason, test) { |
| specify("already-rejected", function (done) { |
| test(rejected(reason), done); |
| }); |
| |
| specify("immediately-rejected", function (done) { |
| var d = deferred(); |
| test(d.promise, done); |
| d.reject(reason); |
| }); |
| |
| specify("eventually-rejected", function (done) { |
| var d = deferred(); |
| test(d.promise, done); |
| setTimeout(function () { |
| d.reject(reason); |
| }, 50); |
| }); |
| }; |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],22:[function(require,module,exports){ |
| (function (global){ |
| "use strict"; |
| |
| var adapter = global.adapter; |
| var resolved = adapter.resolved; |
| var rejected = adapter.rejected; |
| var deferred = adapter.deferred; |
| |
| var other = { other: "other" }; // a value we don't want to be strict equal to |
| |
| exports.fulfilled = { |
| "a synchronously-fulfilled custom thenable": function (value) { |
| return { |
| then: function (onFulfilled) { |
| onFulfilled(value); |
| } |
| }; |
| }, |
| |
| "an asynchronously-fulfilled custom thenable": function (value) { |
| return { |
| then: function (onFulfilled) { |
| setTimeout(function () { |
| onFulfilled(value); |
| }, 0); |
| } |
| }; |
| }, |
| |
| "a synchronously-fulfilled one-time thenable": function (value) { |
| var numberOfTimesThenRetrieved = 0; |
| return Object.create(null, { |
| then: { |
| get: function () { |
| if (numberOfTimesThenRetrieved === 0) { |
| ++numberOfTimesThenRetrieved; |
| return function (onFulfilled) { |
| onFulfilled(value); |
| }; |
| } |
| return null; |
| } |
| } |
| }); |
| }, |
| |
| "a thenable that tries to fulfill twice": function (value) { |
| return { |
| then: function (onFulfilled) { |
| onFulfilled(value); |
| onFulfilled(other); |
| } |
| }; |
| }, |
| |
| "a thenable that fulfills but then throws": function (value) { |
| return { |
| then: function (onFulfilled) { |
| onFulfilled(value); |
| throw other; |
| } |
| }; |
| }, |
| |
| "an already-fulfilled promise": function (value) { |
| return resolved(value); |
| }, |
| |
| "an eventually-fulfilled promise": function (value) { |
| var d = deferred(); |
| setTimeout(function () { |
| d.resolve(value); |
| }, 50); |
| return d.promise; |
| } |
| }; |
| |
| exports.rejected = { |
| "a synchronously-rejected custom thenable": function (reason) { |
| return { |
| then: function (onFulfilled, onRejected) { |
| onRejected(reason); |
| } |
| }; |
| }, |
| |
| "an asynchronously-rejected custom thenable": function (reason) { |
| return { |
| then: function (onFulfilled, onRejected) { |
| setTimeout(function () { |
| onRejected(reason); |
| }, 0); |
| } |
| }; |
| }, |
| |
| "a synchronously-rejected one-time thenable": function (reason) { |
| var numberOfTimesThenRetrieved = 0; |
| return Object.create(null, { |
| then: { |
| get: function () { |
| if (numberOfTimesThenRetrieved === 0) { |
| ++numberOfTimesThenRetrieved; |
| return function (onFulfilled, onRejected) { |
| onRejected(reason); |
| }; |
| } |
| return null; |
| } |
| } |
| }); |
| }, |
| |
| "a thenable that immediately throws in `then`": function (reason) { |
| return { |
| then: function () { |
| throw reason; |
| } |
| }; |
| }, |
| |
| "an object with a throwing `then` accessor": function (reason) { |
| return Object.create(null, { |
| then: { |
| get: function () { |
| throw reason; |
| } |
| } |
| }); |
| }, |
| |
| "an already-rejected promise": function (reason) { |
| return rejected(reason); |
| }, |
| |
| "an eventually-rejected promise": function (reason) { |
| var d = deferred(); |
| setTimeout(function () { |
| d.reject(reason); |
| }, 50); |
| return d.promise; |
| } |
| }; |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],23:[function(require,module,exports){ |
| /*jslint eqeqeq: false, onevar: false, forin: true, nomen: false, regexp: false, plusplus: false*/ |
| /*global module, require, __dirname, document*/ |
| /** |
| * Sinon core utilities. For internal use only. |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| var sinon = (function (formatio) { |
| var div = typeof document != "undefined" && document.createElement("div"); |
| var hasOwn = Object.prototype.hasOwnProperty; |
| |
| function isDOMNode(obj) { |
| var success = false; |
| |
| try { |
| obj.appendChild(div); |
| success = div.parentNode == obj; |
| } catch (e) { |
| return false; |
| } finally { |
| try { |
| obj.removeChild(div); |
| } catch (e) { |
| // Remove failed, not much we can do about that |
| } |
| } |
| |
| return success; |
| } |
| |
| function isElement(obj) { |
| return div && obj && obj.nodeType === 1 && isDOMNode(obj); |
| } |
| |
| function isFunction(obj) { |
| return typeof obj === "function" || !!(obj && obj.constructor && obj.call && obj.apply); |
| } |
| |
| function isReallyNaN(val) { |
| return typeof val === 'number' && isNaN(val); |
| } |
| |
| function mirrorProperties(target, source) { |
| for (var prop in source) { |
| if (!hasOwn.call(target, prop)) { |
| target[prop] = source[prop]; |
| } |
| } |
| } |
| |
| function isRestorable (obj) { |
| return typeof obj === "function" && typeof obj.restore === "function" && obj.restore.sinon; |
| } |
| |
| var sinon = { |
| wrapMethod: function wrapMethod(object, property, method) { |
| if (!object) { |
| throw new TypeError("Should wrap property of object"); |
| } |
| |
| if (typeof method != "function") { |
| throw new TypeError("Method wrapper should be function"); |
| } |
| |
| var wrappedMethod = object[property], |
| error; |
| |
| if (!isFunction(wrappedMethod)) { |
| error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " + |
| property + " as function"); |
| } else if (wrappedMethod.restore && wrappedMethod.restore.sinon) { |
| error = new TypeError("Attempted to wrap " + property + " which is already wrapped"); |
| } else if (wrappedMethod.calledBefore) { |
| var verb = !!wrappedMethod.returns ? "stubbed" : "spied on"; |
| error = new TypeError("Attempted to wrap " + property + " which is already " + verb); |
| } |
| |
| if (error) { |
| if (wrappedMethod && wrappedMethod._stack) { |
| error.stack += '\n--------------\n' + wrappedMethod._stack; |
| } |
| throw error; |
| } |
| |
| // IE 8 does not support hasOwnProperty on the window object and Firefox has a problem |
| // when using hasOwn.call on objects from other frames. |
| var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwn.call(object, property); |
| object[property] = method; |
| method.displayName = property; |
| // Set up a stack trace which can be used later to find what line of |
| // code the original method was created on. |
| method._stack = (new Error('Stack Trace for original')).stack; |
| |
| method.restore = function () { |
| // For prototype properties try to reset by delete first. |
| // If this fails (ex: localStorage on mobile safari) then force a reset |
| // via direct assignment. |
| if (!owned) { |
| delete object[property]; |
| } |
| if (object[property] === method) { |
| object[property] = wrappedMethod; |
| } |
| }; |
| |
| method.restore.sinon = true; |
| mirrorProperties(method, wrappedMethod); |
| |
| return method; |
| }, |
| |
| extend: function extend(target) { |
| for (var i = 1, l = arguments.length; i < l; i += 1) { |
| for (var prop in arguments[i]) { |
| if (arguments[i].hasOwnProperty(prop)) { |
| target[prop] = arguments[i][prop]; |
| } |
| |
| // DONT ENUM bug, only care about toString |
| if (arguments[i].hasOwnProperty("toString") && |
| arguments[i].toString != target.toString) { |
| target.toString = arguments[i].toString; |
| } |
| } |
| } |
| |
| return target; |
| }, |
| |
| create: function create(proto) { |
| var F = function () {}; |
| F.prototype = proto; |
| return new F(); |
| }, |
| |
| deepEqual: function deepEqual(a, b) { |
| if (sinon.match && sinon.match.isMatcher(a)) { |
| return a.test(b); |
| } |
| |
| if (typeof a != 'object' || typeof b != 'object') { |
| if (isReallyNaN(a) && isReallyNaN(b)) { |
| return true; |
| } else { |
| return a === b; |
| } |
| } |
| |
| if (isElement(a) || isElement(b)) { |
| return a === b; |
| } |
| |
| if (a === b) { |
| return true; |
| } |
| |
| if ((a === null && b !== null) || (a !== null && b === null)) { |
| return false; |
| } |
| |
| if (a instanceof RegExp && b instanceof RegExp) { |
| return (a.source === b.source) && (a.global === b.global) && |
| (a.ignoreCase === b.ignoreCase) && (a.multiline === b.multiline); |
| } |
| |
| var aString = Object.prototype.toString.call(a); |
| if (aString != Object.prototype.toString.call(b)) { |
| return false; |
| } |
| |
| if (aString == "[object Date]") { |
| return a.valueOf() === b.valueOf(); |
| } |
| |
| var prop, aLength = 0, bLength = 0; |
| |
| if (aString == "[object Array]" && a.length !== b.length) { |
| return false; |
| } |
| |
| for (prop in a) { |
| aLength += 1; |
| |
| if (!(prop in b)) { |
| return false; |
| } |
| |
| if (!deepEqual(a[prop], b[prop])) { |
| return false; |
| } |
| } |
| |
| for (prop in b) { |
| bLength += 1; |
| } |
| |
| return aLength == bLength; |
| }, |
| |
| functionName: function functionName(func) { |
| var name = func.displayName || func.name; |
| |
| // Use function decomposition as a last resort to get function |
| // name. Does not rely on function decomposition to work - if it |
| // doesn't debugging will be slightly less informative |
| // (i.e. toString will say 'spy' rather than 'myFunc'). |
| if (!name) { |
| var matches = func.toString().match(/function ([^\s\(]+)/); |
| name = matches && matches[1]; |
| } |
| |
| return name; |
| }, |
| |
| functionToString: function toString() { |
| if (this.getCall && this.callCount) { |
| var thisValue, prop, i = this.callCount; |
| |
| while (i--) { |
| thisValue = this.getCall(i).thisValue; |
| |
| for (prop in thisValue) { |
| if (thisValue[prop] === this) { |
| return prop; |
| } |
| } |
| } |
| } |
| |
| return this.displayName || "sinon fake"; |
| }, |
| |
| getConfig: function (custom) { |
| var config = {}; |
| custom = custom || {}; |
| var defaults = sinon.defaultConfig; |
| |
| for (var prop in defaults) { |
| if (defaults.hasOwnProperty(prop)) { |
| config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop]; |
| } |
| } |
| |
| return config; |
| }, |
| |
| format: function (val) { |
| return "" + val; |
| }, |
| |
| defaultConfig: { |
| injectIntoThis: true, |
| injectInto: null, |
| properties: ["spy", "stub", "mock", "clock", "server", "requests"], |
| useFakeTimers: true, |
| useFakeServer: true |
| }, |
| |
| timesInWords: function timesInWords(count) { |
| return count == 1 && "once" || |
| count == 2 && "twice" || |
| count == 3 && "thrice" || |
| (count || 0) + " times"; |
| }, |
| |
| calledInOrder: function (spies) { |
| for (var i = 1, l = spies.length; i < l; i++) { |
| if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) { |
| return false; |
| } |
| } |
| |
| return true; |
| }, |
| |
| orderByFirstCall: function (spies) { |
| return spies.sort(function (a, b) { |
| // uuid, won't ever be equal |
| var aCall = a.getCall(0); |
| var bCall = b.getCall(0); |
| var aId = aCall && aCall.callId || -1; |
| var bId = bCall && bCall.callId || -1; |
| |
| return aId < bId ? -1 : 1; |
| }); |
| }, |
| |
| log: function () {}, |
| |
| logError: function (label, err) { |
| var msg = label + " threw exception: "; |
| sinon.log(msg + "[" + err.name + "] " + err.message); |
| if (err.stack) { sinon.log(err.stack); } |
| |
| setTimeout(function () { |
| err.message = msg + err.message; |
| throw err; |
| }, 0); |
| }, |
| |
| typeOf: function (value) { |
| if (value === null) { |
| return "null"; |
| } |
| else if (value === undefined) { |
| return "undefined"; |
| } |
| var string = Object.prototype.toString.call(value); |
| return string.substring(8, string.length - 1).toLowerCase(); |
| }, |
| |
| createStubInstance: function (constructor) { |
| if (typeof constructor !== "function") { |
| throw new TypeError("The constructor should be a function."); |
| } |
| return sinon.stub(sinon.create(constructor.prototype)); |
| }, |
| |
| restore: function (object) { |
| if (object !== null && typeof object === "object") { |
| for (var prop in object) { |
| if (isRestorable(object[prop])) { |
| object[prop].restore(); |
| } |
| } |
| } |
| else if (isRestorable(object)) { |
| object.restore(); |
| } |
| } |
| }; |
| |
| var isNode = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd; |
| |
| function makePublicAPI(require, exports, module) { |
| module.exports = sinon; |
| sinon.spy = require("./sinon/spy"); |
| sinon.spyCall = require("./sinon/call"); |
| sinon.behavior = require("./sinon/behavior"); |
| sinon.stub = require("./sinon/stub"); |
| sinon.mock = require("./sinon/mock"); |
| sinon.collection = require("./sinon/collection"); |
| sinon.assert = require("./sinon/assert"); |
| sinon.sandbox = require("./sinon/sandbox"); |
| sinon.test = require("./sinon/test"); |
| sinon.testCase = require("./sinon/test_case"); |
| sinon.match = require("./sinon/match"); |
| } |
| |
| if (isAMD) { |
| define(makePublicAPI); |
| } else if (isNode) { |
| try { |
| formatio = require("formatio"); |
| } catch (e) {} |
| makePublicAPI(require, exports, module); |
| } |
| |
| if (formatio) { |
| var formatter = formatio.configure({ quoteStrings: false }); |
| sinon.format = function () { |
| return formatter.ascii.apply(formatter, arguments); |
| }; |
| } else if (isNode) { |
| try { |
| var util = require("util"); |
| sinon.format = function (value) { |
| return typeof value == "object" && value.toString === Object.prototype.toString ? util.inspect(value) : value; |
| }; |
| } catch (e) { |
| /* Node, but no util module - would be very old, but better safe than |
| sorry */ |
| } |
| } |
| |
| return sinon; |
| }(typeof formatio == "object" && formatio)); |
| |
| },{"./sinon/assert":24,"./sinon/behavior":25,"./sinon/call":26,"./sinon/collection":27,"./sinon/match":28,"./sinon/mock":29,"./sinon/sandbox":30,"./sinon/spy":31,"./sinon/stub":32,"./sinon/test":33,"./sinon/test_case":34,"formatio":36,"util":5}],24:[function(require,module,exports){ |
| (function (global){ |
| /** |
| * @depend ../sinon.js |
| * @depend stub.js |
| */ |
| /*jslint eqeqeq: false, onevar: false, nomen: false, plusplus: false*/ |
| /*global module, require, sinon*/ |
| /** |
| * Assertions matching the test spy retrieval interface. |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| (function (sinon, global) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| var slice = Array.prototype.slice; |
| var assert; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| function verifyIsStub() { |
| var method; |
| |
| for (var i = 0, l = arguments.length; i < l; ++i) { |
| method = arguments[i]; |
| |
| if (!method) { |
| assert.fail("fake is not a spy"); |
| } |
| |
| if (typeof method != "function") { |
| assert.fail(method + " is not a function"); |
| } |
| |
| if (typeof method.getCall != "function") { |
| assert.fail(method + " is not stubbed"); |
| } |
| } |
| } |
| |
| function failAssertion(object, msg) { |
| object = object || global; |
| var failMethod = object.fail || assert.fail; |
| failMethod.call(object, msg); |
| } |
| |
| function mirrorPropAsAssertion(name, method, message) { |
| if (arguments.length == 2) { |
| message = method; |
| method = name; |
| } |
| |
| assert[name] = function (fake) { |
| verifyIsStub(fake); |
| |
| var args = slice.call(arguments, 1); |
| var failed = false; |
| |
| if (typeof method == "function") { |
| failed = !method(fake); |
| } else { |
| failed = typeof fake[method] == "function" ? |
| !fake[method].apply(fake, args) : !fake[method]; |
| } |
| |
| if (failed) { |
| failAssertion(this, fake.printf.apply(fake, [message].concat(args))); |
| } else { |
| assert.pass(name); |
| } |
| }; |
| } |
| |
| function exposedName(prefix, prop) { |
| return !prefix || /^fail/.test(prop) ? prop : |
| prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1); |
| } |
| |
| assert = { |
| failException: "AssertError", |
| |
| fail: function fail(message) { |
| var error = new Error(message); |
| error.name = this.failException || assert.failException; |
| |
| throw error; |
| }, |
| |
| pass: function pass(assertion) {}, |
| |
| callOrder: function assertCallOrder() { |
| verifyIsStub.apply(null, arguments); |
| var expected = "", actual = ""; |
| |
| if (!sinon.calledInOrder(arguments)) { |
| try { |
| expected = [].join.call(arguments, ", "); |
| var calls = slice.call(arguments); |
| var i = calls.length; |
| while (i) { |
| if (!calls[--i].called) { |
| calls.splice(i, 1); |
| } |
| } |
| actual = sinon.orderByFirstCall(calls).join(", "); |
| } catch (e) { |
| // If this fails, we'll just fall back to the blank string |
| } |
| |
| failAssertion(this, "expected " + expected + " to be " + |
| "called in order but were called as " + actual); |
| } else { |
| assert.pass("callOrder"); |
| } |
| }, |
| |
| callCount: function assertCallCount(method, count) { |
| verifyIsStub(method); |
| |
| if (method.callCount != count) { |
| var msg = "expected %n to be called " + sinon.timesInWords(count) + |
| " but was called %c%C"; |
| failAssertion(this, method.printf(msg)); |
| } else { |
| assert.pass("callCount"); |
| } |
| }, |
| |
| expose: function expose(target, options) { |
| if (!target) { |
| throw new TypeError("target is null or undefined"); |
| } |
| |
| var o = options || {}; |
| var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix; |
| var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail; |
| |
| for (var method in this) { |
| if (method != "export" && (includeFail || !/^(fail)/.test(method))) { |
| target[exposedName(prefix, method)] = this[method]; |
| } |
| } |
| |
| return target; |
| }, |
| |
| match: function match(actual, expectation) { |
| var matcher = sinon.match(expectation); |
| if (matcher.test(actual)) { |
| assert.pass("match"); |
| } else { |
| var formatted = [ |
| "expected value to match", |
| " expected = " + sinon.format(expectation), |
| " actual = " + sinon.format(actual) |
| ] |
| failAssertion(this, formatted.join("\n")); |
| } |
| } |
| }; |
| |
| mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called"); |
| mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; }, |
| "expected %n to not have been called but was called %c%C"); |
| mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C"); |
| mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C"); |
| mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C"); |
| mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t"); |
| mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t"); |
| mirrorPropAsAssertion("calledWithNew", "expected %n to be called with new"); |
| mirrorPropAsAssertion("alwaysCalledWithNew", "expected %n to always be called with new"); |
| mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C"); |
| mirrorPropAsAssertion("calledWithMatch", "expected %n to be called with match %*%C"); |
| mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C"); |
| mirrorPropAsAssertion("alwaysCalledWithMatch", "expected %n to always be called with match %*%C"); |
| mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C"); |
| mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C"); |
| mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C"); |
| mirrorPropAsAssertion("neverCalledWithMatch", "expected %n to never be called with match %*%C"); |
| mirrorPropAsAssertion("threw", "%n did not throw exception%C"); |
| mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C"); |
| |
| sinon.assert = assert; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = assert; }); |
| } else if (commonJSModule) { |
| module.exports = assert; |
| } |
| }(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global)); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"../sinon":23}],25:[function(require,module,exports){ |
| (function (process){ |
| /** |
| * @depend ../sinon.js |
| */ |
| /*jslint eqeqeq: false, onevar: false*/ |
| /*global module, require, sinon, process, setImmediate, setTimeout*/ |
| /** |
| * Stub behavior |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @author Tim Fischbach (mail@timfischbach.de) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| var slice = Array.prototype.slice; |
| var join = Array.prototype.join; |
| var proto; |
| |
| var nextTick = (function () { |
| if (typeof process === "object" && typeof process.nextTick === "function") { |
| return process.nextTick; |
| } else if (typeof setImmediate === "function") { |
| return setImmediate; |
| } else { |
| return function (callback) { |
| setTimeout(callback, 0); |
| }; |
| } |
| })(); |
| |
| function throwsException(error, message) { |
| if (typeof error == "string") { |
| this.exception = new Error(message || ""); |
| this.exception.name = error; |
| } else if (!error) { |
| this.exception = new Error("Error"); |
| } else { |
| this.exception = error; |
| } |
| |
| return this; |
| } |
| |
| function getCallback(behavior, args) { |
| var callArgAt = behavior.callArgAt; |
| |
| if (callArgAt < 0) { |
| var callArgProp = behavior.callArgProp; |
| |
| for (var i = 0, l = args.length; i < l; ++i) { |
| if (!callArgProp && typeof args[i] == "function") { |
| return args[i]; |
| } |
| |
| if (callArgProp && args[i] && |
| typeof args[i][callArgProp] == "function") { |
| return args[i][callArgProp]; |
| } |
| } |
| |
| return null; |
| } |
| |
| return args[callArgAt]; |
| } |
| |
| function getCallbackError(behavior, func, args) { |
| if (behavior.callArgAt < 0) { |
| var msg; |
| |
| if (behavior.callArgProp) { |
| msg = sinon.functionName(behavior.stub) + |
| " expected to yield to '" + behavior.callArgProp + |
| "', but no object with such a property was passed."; |
| } else { |
| msg = sinon.functionName(behavior.stub) + |
| " expected to yield, but no callback was passed."; |
| } |
| |
| if (args.length > 0) { |
| msg += " Received [" + join.call(args, ", ") + "]"; |
| } |
| |
| return msg; |
| } |
| |
| return "argument at index " + behavior.callArgAt + " is not a function: " + func; |
| } |
| |
| function callCallback(behavior, args) { |
| if (typeof behavior.callArgAt == "number") { |
| var func = getCallback(behavior, args); |
| |
| if (typeof func != "function") { |
| throw new TypeError(getCallbackError(behavior, func, args)); |
| } |
| |
| if (behavior.callbackAsync) { |
| nextTick(function() { |
| func.apply(behavior.callbackContext, behavior.callbackArguments); |
| }); |
| } else { |
| func.apply(behavior.callbackContext, behavior.callbackArguments); |
| } |
| } |
| } |
| |
| proto = { |
| create: function(stub) { |
| var behavior = sinon.extend({}, sinon.behavior); |
| delete behavior.create; |
| behavior.stub = stub; |
| |
| return behavior; |
| }, |
| |
| isPresent: function() { |
| return (typeof this.callArgAt == 'number' || |
| this.exception || |
| typeof this.returnArgAt == 'number' || |
| this.returnThis || |
| this.returnValueDefined); |
| }, |
| |
| invoke: function(context, args) { |
| callCallback(this, args); |
| |
| if (this.exception) { |
| throw this.exception; |
| } else if (typeof this.returnArgAt == 'number') { |
| return args[this.returnArgAt]; |
| } else if (this.returnThis) { |
| return context; |
| } |
| |
| return this.returnValue; |
| }, |
| |
| onCall: function(index) { |
| return this.stub.onCall(index); |
| }, |
| |
| onFirstCall: function() { |
| return this.stub.onFirstCall(); |
| }, |
| |
| onSecondCall: function() { |
| return this.stub.onSecondCall(); |
| }, |
| |
| onThirdCall: function() { |
| return this.stub.onThirdCall(); |
| }, |
| |
| withArgs: function(/* arguments */) { |
| throw new Error('Defining a stub by invoking "stub.onCall(...).withArgs(...)" is not supported. ' + |
| 'Use "stub.withArgs(...).onCall(...)" to define sequential behavior for calls with certain arguments.'); |
| }, |
| |
| callsArg: function callsArg(pos) { |
| if (typeof pos != "number") { |
| throw new TypeError("argument index is not number"); |
| } |
| |
| this.callArgAt = pos; |
| this.callbackArguments = []; |
| this.callbackContext = undefined; |
| this.callArgProp = undefined; |
| this.callbackAsync = false; |
| |
| return this; |
| }, |
| |
| callsArgOn: function callsArgOn(pos, context) { |
| if (typeof pos != "number") { |
| throw new TypeError("argument index is not number"); |
| } |
| if (typeof context != "object") { |
| throw new TypeError("argument context is not an object"); |
| } |
| |
| this.callArgAt = pos; |
| this.callbackArguments = []; |
| this.callbackContext = context; |
| this.callArgProp = undefined; |
| this.callbackAsync = false; |
| |
| return this; |
| }, |
| |
| callsArgWith: function callsArgWith(pos) { |
| if (typeof pos != "number") { |
| throw new TypeError("argument index is not number"); |
| } |
| |
| this.callArgAt = pos; |
| this.callbackArguments = slice.call(arguments, 1); |
| this.callbackContext = undefined; |
| this.callArgProp = undefined; |
| this.callbackAsync = false; |
| |
| return this; |
| }, |
| |
| callsArgOnWith: function callsArgWith(pos, context) { |
| if (typeof pos != "number") { |
| throw new TypeError("argument index is not number"); |
| } |
| if (typeof context != "object") { |
| throw new TypeError("argument context is not an object"); |
| } |
| |
| this.callArgAt = pos; |
| this.callbackArguments = slice.call(arguments, 2); |
| this.callbackContext = context; |
| this.callArgProp = undefined; |
| this.callbackAsync = false; |
| |
| return this; |
| }, |
| |
| yields: function () { |
| this.callArgAt = -1; |
| this.callbackArguments = slice.call(arguments, 0); |
| this.callbackContext = undefined; |
| this.callArgProp = undefined; |
| this.callbackAsync = false; |
| |
| return this; |
| }, |
| |
| yieldsOn: function (context) { |
| if (typeof context != "object") { |
| throw new TypeError("argument context is not an object"); |
| } |
| |
| this.callArgAt = -1; |
| this.callbackArguments = slice.call(arguments, 1); |
| this.callbackContext = context; |
| this.callArgProp = undefined; |
| this.callbackAsync = false; |
| |
| return this; |
| }, |
| |
| yieldsTo: function (prop) { |
| this.callArgAt = -1; |
| this.callbackArguments = slice.call(arguments, 1); |
| this.callbackContext = undefined; |
| this.callArgProp = prop; |
| this.callbackAsync = false; |
| |
| return this; |
| }, |
| |
| yieldsToOn: function (prop, context) { |
| if (typeof context != "object") { |
| throw new TypeError("argument context is not an object"); |
| } |
| |
| this.callArgAt = -1; |
| this.callbackArguments = slice.call(arguments, 2); |
| this.callbackContext = context; |
| this.callArgProp = prop; |
| this.callbackAsync = false; |
| |
| return this; |
| }, |
| |
| |
| "throws": throwsException, |
| throwsException: throwsException, |
| |
| returns: function returns(value) { |
| this.returnValue = value; |
| this.returnValueDefined = true; |
| |
| return this; |
| }, |
| |
| returnsArg: function returnsArg(pos) { |
| if (typeof pos != "number") { |
| throw new TypeError("argument index is not number"); |
| } |
| |
| this.returnArgAt = pos; |
| |
| return this; |
| }, |
| |
| returnsThis: function returnsThis() { |
| this.returnThis = true; |
| |
| return this; |
| } |
| }; |
| |
| // create asynchronous versions of callsArg* and yields* methods |
| for (var method in proto) { |
| // need to avoid creating anotherasync versions of the newly added async methods |
| if (proto.hasOwnProperty(method) && |
| method.match(/^(callsArg|yields)/) && |
| !method.match(/Async/)) { |
| proto[method + 'Async'] = (function (syncFnName) { |
| return function () { |
| var result = this[syncFnName].apply(this, arguments); |
| this.callbackAsync = true; |
| return result; |
| }; |
| })(method); |
| } |
| } |
| |
| sinon.behavior = proto; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = proto; }); |
| } else if (commonJSModule) { |
| module.exports = proto; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| }).call(this,require('_process')) |
| },{"../sinon":23,"_process":3}],26:[function(require,module,exports){ |
| /** |
| * @depend ../sinon.js |
| * @depend match.js |
| */ |
| /*jslint eqeqeq: false, onevar: false, plusplus: false*/ |
| /*global module, require, sinon*/ |
| /** |
| * Spy calls |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @author Maximilian Antoni (mail@maxantoni.de) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| * Copyright (c) 2013 Maximilian Antoni |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| function throwYieldError(proxy, text, args) { |
| var msg = sinon.functionName(proxy) + text; |
| if (args.length) { |
| msg += " Received [" + slice.call(args).join(", ") + "]"; |
| } |
| throw new Error(msg); |
| } |
| |
| var slice = Array.prototype.slice; |
| |
| var callProto = { |
| calledOn: function calledOn(thisValue) { |
| if (sinon.match && sinon.match.isMatcher(thisValue)) { |
| return thisValue.test(this.thisValue); |
| } |
| return this.thisValue === thisValue; |
| }, |
| |
| calledWith: function calledWith() { |
| for (var i = 0, l = arguments.length; i < l; i += 1) { |
| if (!sinon.deepEqual(arguments[i], this.args[i])) { |
| return false; |
| } |
| } |
| |
| return true; |
| }, |
| |
| calledWithMatch: function calledWithMatch() { |
| for (var i = 0, l = arguments.length; i < l; i += 1) { |
| var actual = this.args[i]; |
| var expectation = arguments[i]; |
| if (!sinon.match || !sinon.match(expectation).test(actual)) { |
| return false; |
| } |
| } |
| return true; |
| }, |
| |
| calledWithExactly: function calledWithExactly() { |
| return arguments.length == this.args.length && |
| this.calledWith.apply(this, arguments); |
| }, |
| |
| notCalledWith: function notCalledWith() { |
| return !this.calledWith.apply(this, arguments); |
| }, |
| |
| notCalledWithMatch: function notCalledWithMatch() { |
| return !this.calledWithMatch.apply(this, arguments); |
| }, |
| |
| returned: function returned(value) { |
| return sinon.deepEqual(value, this.returnValue); |
| }, |
| |
| threw: function threw(error) { |
| if (typeof error === "undefined" || !this.exception) { |
| return !!this.exception; |
| } |
| |
| return this.exception === error || this.exception.name === error; |
| }, |
| |
| calledWithNew: function calledWithNew() { |
| return this.proxy.prototype && this.thisValue instanceof this.proxy; |
| }, |
| |
| calledBefore: function (other) { |
| return this.callId < other.callId; |
| }, |
| |
| calledAfter: function (other) { |
| return this.callId > other.callId; |
| }, |
| |
| callArg: function (pos) { |
| this.args[pos](); |
| }, |
| |
| callArgOn: function (pos, thisValue) { |
| this.args[pos].apply(thisValue); |
| }, |
| |
| callArgWith: function (pos) { |
| this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1))); |
| }, |
| |
| callArgOnWith: function (pos, thisValue) { |
| var args = slice.call(arguments, 2); |
| this.args[pos].apply(thisValue, args); |
| }, |
| |
| "yield": function () { |
| this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0))); |
| }, |
| |
| yieldOn: function (thisValue) { |
| var args = this.args; |
| for (var i = 0, l = args.length; i < l; ++i) { |
| if (typeof args[i] === "function") { |
| args[i].apply(thisValue, slice.call(arguments, 1)); |
| return; |
| } |
| } |
| throwYieldError(this.proxy, " cannot yield since no callback was passed.", args); |
| }, |
| |
| yieldTo: function (prop) { |
| this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1))); |
| }, |
| |
| yieldToOn: function (prop, thisValue) { |
| var args = this.args; |
| for (var i = 0, l = args.length; i < l; ++i) { |
| if (args[i] && typeof args[i][prop] === "function") { |
| args[i][prop].apply(thisValue, slice.call(arguments, 2)); |
| return; |
| } |
| } |
| throwYieldError(this.proxy, " cannot yield to '" + prop + |
| "' since no callback was passed.", args); |
| }, |
| |
| toString: function () { |
| var callStr = this.proxy.toString() + "("; |
| var args = []; |
| |
| for (var i = 0, l = this.args.length; i < l; ++i) { |
| args.push(sinon.format(this.args[i])); |
| } |
| |
| callStr = callStr + args.join(", ") + ")"; |
| |
| if (typeof this.returnValue != "undefined") { |
| callStr += " => " + sinon.format(this.returnValue); |
| } |
| |
| if (this.exception) { |
| callStr += " !" + this.exception.name; |
| |
| if (this.exception.message) { |
| callStr += "(" + this.exception.message + ")"; |
| } |
| } |
| |
| return callStr; |
| } |
| }; |
| |
| callProto.invokeCallback = callProto.yield; |
| |
| function createSpyCall(spy, thisValue, args, returnValue, exception, id) { |
| if (typeof id !== "number") { |
| throw new TypeError("Call id is not a number"); |
| } |
| var proxyCall = sinon.create(callProto); |
| proxyCall.proxy = spy; |
| proxyCall.thisValue = thisValue; |
| proxyCall.args = args; |
| proxyCall.returnValue = returnValue; |
| proxyCall.exception = exception; |
| proxyCall.callId = id; |
| |
| return proxyCall; |
| } |
| createSpyCall.toString = callProto.toString; // used by mocks |
| |
| sinon.spyCall = createSpyCall; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = createSpyCall; }); |
| } else if (commonJSModule) { |
| module.exports = createSpyCall; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| |
| },{"../sinon":23}],27:[function(require,module,exports){ |
| /** |
| * @depend ../sinon.js |
| * @depend stub.js |
| * @depend mock.js |
| */ |
| /*jslint eqeqeq: false, onevar: false, forin: true*/ |
| /*global module, require, sinon*/ |
| /** |
| * Collections of stubs, spies and mocks. |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| var push = [].push; |
| var hasOwnProperty = Object.prototype.hasOwnProperty; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| function getFakes(fakeCollection) { |
| if (!fakeCollection.fakes) { |
| fakeCollection.fakes = []; |
| } |
| |
| return fakeCollection.fakes; |
| } |
| |
| function each(fakeCollection, method) { |
| var fakes = getFakes(fakeCollection); |
| |
| for (var i = 0, l = fakes.length; i < l; i += 1) { |
| if (typeof fakes[i][method] == "function") { |
| fakes[i][method](); |
| } |
| } |
| } |
| |
| function compact(fakeCollection) { |
| var fakes = getFakes(fakeCollection); |
| var i = 0; |
| while (i < fakes.length) { |
| fakes.splice(i, 1); |
| } |
| } |
| |
| var collection = { |
| verify: function resolve() { |
| each(this, "verify"); |
| }, |
| |
| restore: function restore() { |
| each(this, "restore"); |
| compact(this); |
| }, |
| |
| verifyAndRestore: function verifyAndRestore() { |
| var exception; |
| |
| try { |
| this.verify(); |
| } catch (e) { |
| exception = e; |
| } |
| |
| this.restore(); |
| |
| if (exception) { |
| throw exception; |
| } |
| }, |
| |
| add: function add(fake) { |
| push.call(getFakes(this), fake); |
| return fake; |
| }, |
| |
| spy: function spy() { |
| return this.add(sinon.spy.apply(sinon, arguments)); |
| }, |
| |
| stub: function stub(object, property, value) { |
| if (property) { |
| var original = object[property]; |
| |
| if (typeof original != "function") { |
| if (!hasOwnProperty.call(object, property)) { |
| throw new TypeError("Cannot stub non-existent own property " + property); |
| } |
| |
| object[property] = value; |
| |
| return this.add({ |
| restore: function () { |
| object[property] = original; |
| } |
| }); |
| } |
| } |
| if (!property && !!object && typeof object == "object") { |
| var stubbedObj = sinon.stub.apply(sinon, arguments); |
| |
| for (var prop in stubbedObj) { |
| if (typeof stubbedObj[prop] === "function") { |
| this.add(stubbedObj[prop]); |
| } |
| } |
| |
| return stubbedObj; |
| } |
| |
| return this.add(sinon.stub.apply(sinon, arguments)); |
| }, |
| |
| mock: function mock() { |
| return this.add(sinon.mock.apply(sinon, arguments)); |
| }, |
| |
| inject: function inject(obj) { |
| var col = this; |
| |
| obj.spy = function () { |
| return col.spy.apply(col, arguments); |
| }; |
| |
| obj.stub = function () { |
| return col.stub.apply(col, arguments); |
| }; |
| |
| obj.mock = function () { |
| return col.mock.apply(col, arguments); |
| }; |
| |
| return obj; |
| } |
| }; |
| |
| sinon.collection = collection; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = collection; }); |
| } else if (commonJSModule) { |
| module.exports = collection; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| },{"../sinon":23}],28:[function(require,module,exports){ |
| /* @depend ../sinon.js */ |
| /*jslint eqeqeq: false, onevar: false, plusplus: false*/ |
| /*global module, require, sinon*/ |
| /** |
| * Match functions |
| * |
| * @author Maximilian Antoni (mail@maxantoni.de) |
| * @license BSD |
| * |
| * Copyright (c) 2012 Maximilian Antoni |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| function assertType(value, type, name) { |
| var actual = sinon.typeOf(value); |
| if (actual !== type) { |
| throw new TypeError("Expected type of " + name + " to be " + |
| type + ", but was " + actual); |
| } |
| } |
| |
| var matcher = { |
| toString: function () { |
| return this.message; |
| } |
| }; |
| |
| function isMatcher(object) { |
| return matcher.isPrototypeOf(object); |
| } |
| |
| function matchObject(expectation, actual) { |
| if (actual === null || actual === undefined) { |
| return false; |
| } |
| for (var key in expectation) { |
| if (expectation.hasOwnProperty(key)) { |
| var exp = expectation[key]; |
| var act = actual[key]; |
| if (match.isMatcher(exp)) { |
| if (!exp.test(act)) { |
| return false; |
| } |
| } else if (sinon.typeOf(exp) === "object") { |
| if (!matchObject(exp, act)) { |
| return false; |
| } |
| } else if (!sinon.deepEqual(exp, act)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| matcher.or = function (m2) { |
| if (!arguments.length) { |
| throw new TypeError("Matcher expected"); |
| } else if (!isMatcher(m2)) { |
| m2 = match(m2); |
| } |
| var m1 = this; |
| var or = sinon.create(matcher); |
| or.test = function (actual) { |
| return m1.test(actual) || m2.test(actual); |
| }; |
| or.message = m1.message + ".or(" + m2.message + ")"; |
| return or; |
| }; |
| |
| matcher.and = function (m2) { |
| if (!arguments.length) { |
| throw new TypeError("Matcher expected"); |
| } else if (!isMatcher(m2)) { |
| m2 = match(m2); |
| } |
| var m1 = this; |
| var and = sinon.create(matcher); |
| and.test = function (actual) { |
| return m1.test(actual) && m2.test(actual); |
| }; |
| and.message = m1.message + ".and(" + m2.message + ")"; |
| return and; |
| }; |
| |
| var match = function (expectation, message) { |
| var m = sinon.create(matcher); |
| var type = sinon.typeOf(expectation); |
| switch (type) { |
| case "object": |
| if (typeof expectation.test === "function") { |
| m.test = function (actual) { |
| return expectation.test(actual) === true; |
| }; |
| m.message = "match(" + sinon.functionName(expectation.test) + ")"; |
| return m; |
| } |
| var str = []; |
| for (var key in expectation) { |
| if (expectation.hasOwnProperty(key)) { |
| str.push(key + ": " + expectation[key]); |
| } |
| } |
| m.test = function (actual) { |
| return matchObject(expectation, actual); |
| }; |
| m.message = "match(" + str.join(", ") + ")"; |
| break; |
| case "number": |
| m.test = function (actual) { |
| return expectation == actual; |
| }; |
| break; |
| case "string": |
| m.test = function (actual) { |
| if (typeof actual !== "string") { |
| return false; |
| } |
| return actual.indexOf(expectation) !== -1; |
| }; |
| m.message = "match(\"" + expectation + "\")"; |
| break; |
| case "regexp": |
| m.test = function (actual) { |
| if (typeof actual !== "string") { |
| return false; |
| } |
| return expectation.test(actual); |
| }; |
| break; |
| case "function": |
| m.test = expectation; |
| if (message) { |
| m.message = message; |
| } else { |
| m.message = "match(" + sinon.functionName(expectation) + ")"; |
| } |
| break; |
| default: |
| m.test = function (actual) { |
| return sinon.deepEqual(expectation, actual); |
| }; |
| } |
| if (!m.message) { |
| m.message = "match(" + expectation + ")"; |
| } |
| return m; |
| }; |
| |
| match.isMatcher = isMatcher; |
| |
| match.any = match(function () { |
| return true; |
| }, "any"); |
| |
| match.defined = match(function (actual) { |
| return actual !== null && actual !== undefined; |
| }, "defined"); |
| |
| match.truthy = match(function (actual) { |
| return !!actual; |
| }, "truthy"); |
| |
| match.falsy = match(function (actual) { |
| return !actual; |
| }, "falsy"); |
| |
| match.same = function (expectation) { |
| return match(function (actual) { |
| return expectation === actual; |
| }, "same(" + expectation + ")"); |
| }; |
| |
| match.typeOf = function (type) { |
| assertType(type, "string", "type"); |
| return match(function (actual) { |
| return sinon.typeOf(actual) === type; |
| }, "typeOf(\"" + type + "\")"); |
| }; |
| |
| match.instanceOf = function (type) { |
| assertType(type, "function", "type"); |
| return match(function (actual) { |
| return actual instanceof type; |
| }, "instanceOf(" + sinon.functionName(type) + ")"); |
| }; |
| |
| function createPropertyMatcher(propertyTest, messagePrefix) { |
| return function (property, value) { |
| assertType(property, "string", "property"); |
| var onlyProperty = arguments.length === 1; |
| var message = messagePrefix + "(\"" + property + "\""; |
| if (!onlyProperty) { |
| message += ", " + value; |
| } |
| message += ")"; |
| return match(function (actual) { |
| if (actual === undefined || actual === null || |
| !propertyTest(actual, property)) { |
| return false; |
| } |
| return onlyProperty || sinon.deepEqual(value, actual[property]); |
| }, message); |
| }; |
| } |
| |
| match.has = createPropertyMatcher(function (actual, property) { |
| if (typeof actual === "object") { |
| return property in actual; |
| } |
| return actual[property] !== undefined; |
| }, "has"); |
| |
| match.hasOwn = createPropertyMatcher(function (actual, property) { |
| return actual.hasOwnProperty(property); |
| }, "hasOwn"); |
| |
| match.bool = match.typeOf("boolean"); |
| match.number = match.typeOf("number"); |
| match.string = match.typeOf("string"); |
| match.object = match.typeOf("object"); |
| match.func = match.typeOf("function"); |
| match.array = match.typeOf("array"); |
| match.regexp = match.typeOf("regexp"); |
| match.date = match.typeOf("date"); |
| |
| sinon.match = match; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = match; }); |
| } else if (commonJSModule) { |
| module.exports = match; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| },{"../sinon":23}],29:[function(require,module,exports){ |
| /** |
| * @depend ../sinon.js |
| * @depend stub.js |
| */ |
| /*jslint eqeqeq: false, onevar: false, nomen: false*/ |
| /*global module, require, sinon*/ |
| /** |
| * Mock functions. |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| var push = [].push; |
| var match; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| match = sinon.match; |
| |
| if (!match && commonJSModule) { |
| match = require("./match"); |
| } |
| |
| function mock(object) { |
| if (!object) { |
| return sinon.expectation.create("Anonymous mock"); |
| } |
| |
| return mock.create(object); |
| } |
| |
| sinon.mock = mock; |
| |
| sinon.extend(mock, (function () { |
| function each(collection, callback) { |
| if (!collection) { |
| return; |
| } |
| |
| for (var i = 0, l = collection.length; i < l; i += 1) { |
| callback(collection[i]); |
| } |
| } |
| |
| return { |
| create: function create(object) { |
| if (!object) { |
| throw new TypeError("object is null"); |
| } |
| |
| var mockObject = sinon.extend({}, mock); |
| mockObject.object = object; |
| delete mockObject.create; |
| |
| return mockObject; |
| }, |
| |
| expects: function expects(method) { |
| if (!method) { |
| throw new TypeError("method is falsy"); |
| } |
| |
| if (!this.expectations) { |
| this.expectations = {}; |
| this.proxies = []; |
| } |
| |
| if (!this.expectations[method]) { |
| this.expectations[method] = []; |
| var mockObject = this; |
| |
| sinon.wrapMethod(this.object, method, function () { |
| return mockObject.invokeMethod(method, this, arguments); |
| }); |
| |
| push.call(this.proxies, method); |
| } |
| |
| var expectation = sinon.expectation.create(method); |
| push.call(this.expectations[method], expectation); |
| |
| return expectation; |
| }, |
| |
| restore: function restore() { |
| var object = this.object; |
| |
| each(this.proxies, function (proxy) { |
| if (typeof object[proxy].restore == "function") { |
| object[proxy].restore(); |
| } |
| }); |
| }, |
| |
| verify: function verify() { |
| var expectations = this.expectations || {}; |
| var messages = [], met = []; |
| |
| each(this.proxies, function (proxy) { |
| each(expectations[proxy], function (expectation) { |
| if (!expectation.met()) { |
| push.call(messages, expectation.toString()); |
| } else { |
| push.call(met, expectation.toString()); |
| } |
| }); |
| }); |
| |
| this.restore(); |
| |
| if (messages.length > 0) { |
| sinon.expectation.fail(messages.concat(met).join("\n")); |
| } else { |
| sinon.expectation.pass(messages.concat(met).join("\n")); |
| } |
| |
| return true; |
| }, |
| |
| invokeMethod: function invokeMethod(method, thisValue, args) { |
| var expectations = this.expectations && this.expectations[method]; |
| var length = expectations && expectations.length || 0, i; |
| |
| for (i = 0; i < length; i += 1) { |
| if (!expectations[i].met() && |
| expectations[i].allowsCall(thisValue, args)) { |
| return expectations[i].apply(thisValue, args); |
| } |
| } |
| |
| var messages = [], available, exhausted = 0; |
| |
| for (i = 0; i < length; i += 1) { |
| if (expectations[i].allowsCall(thisValue, args)) { |
| available = available || expectations[i]; |
| } else { |
| exhausted += 1; |
| } |
| push.call(messages, " " + expectations[i].toString()); |
| } |
| |
| if (exhausted === 0) { |
| return available.apply(thisValue, args); |
| } |
| |
| messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({ |
| proxy: method, |
| args: args |
| })); |
| |
| sinon.expectation.fail(messages.join("\n")); |
| } |
| }; |
| }())); |
| |
| var times = sinon.timesInWords; |
| |
| sinon.expectation = (function () { |
| var slice = Array.prototype.slice; |
| var _invoke = sinon.spy.invoke; |
| |
| function callCountInWords(callCount) { |
| if (callCount == 0) { |
| return "never called"; |
| } else { |
| return "called " + times(callCount); |
| } |
| } |
| |
| function expectedCallCountInWords(expectation) { |
| var min = expectation.minCalls; |
| var max = expectation.maxCalls; |
| |
| if (typeof min == "number" && typeof max == "number") { |
| var str = times(min); |
| |
| if (min != max) { |
| str = "at least " + str + " and at most " + times(max); |
| } |
| |
| return str; |
| } |
| |
| if (typeof min == "number") { |
| return "at least " + times(min); |
| } |
| |
| return "at most " + times(max); |
| } |
| |
| function receivedMinCalls(expectation) { |
| var hasMinLimit = typeof expectation.minCalls == "number"; |
| return !hasMinLimit || expectation.callCount >= expectation.minCalls; |
| } |
| |
| function receivedMaxCalls(expectation) { |
| if (typeof expectation.maxCalls != "number") { |
| return false; |
| } |
| |
| return expectation.callCount == expectation.maxCalls; |
| } |
| |
| function verifyMatcher(possibleMatcher, arg){ |
| if (match && match.isMatcher(possibleMatcher)) { |
| return possibleMatcher.test(arg); |
| } else { |
| return true; |
| } |
| } |
| |
| return { |
| minCalls: 1, |
| maxCalls: 1, |
| |
| create: function create(methodName) { |
| var expectation = sinon.extend(sinon.stub.create(), sinon.expectation); |
| delete expectation.create; |
| expectation.method = methodName; |
| |
| return expectation; |
| }, |
| |
| invoke: function invoke(func, thisValue, args) { |
| this.verifyCallAllowed(thisValue, args); |
| |
| return _invoke.apply(this, arguments); |
| }, |
| |
| atLeast: function atLeast(num) { |
| if (typeof num != "number") { |
| throw new TypeError("'" + num + "' is not number"); |
| } |
| |
| if (!this.limitsSet) { |
| this.maxCalls = null; |
| this.limitsSet = true; |
| } |
| |
| this.minCalls = num; |
| |
| return this; |
| }, |
| |
| atMost: function atMost(num) { |
| if (typeof num != "number") { |
| throw new TypeError("'" + num + "' is not number"); |
| } |
| |
| if (!this.limitsSet) { |
| this.minCalls = null; |
| this.limitsSet = true; |
| } |
| |
| this.maxCalls = num; |
| |
| return this; |
| }, |
| |
| never: function never() { |
| return this.exactly(0); |
| }, |
| |
| once: function once() { |
| return this.exactly(1); |
| }, |
| |
| twice: function twice() { |
| return this.exactly(2); |
| }, |
| |
| thrice: function thrice() { |
| return this.exactly(3); |
| }, |
| |
| exactly: function exactly(num) { |
| if (typeof num != "number") { |
| throw new TypeError("'" + num + "' is not a number"); |
| } |
| |
| this.atLeast(num); |
| return this.atMost(num); |
| }, |
| |
| met: function met() { |
| return !this.failed && receivedMinCalls(this); |
| }, |
| |
| verifyCallAllowed: function verifyCallAllowed(thisValue, args) { |
| if (receivedMaxCalls(this)) { |
| this.failed = true; |
| sinon.expectation.fail(this.method + " already called " + times(this.maxCalls)); |
| } |
| |
| if ("expectedThis" in this && this.expectedThis !== thisValue) { |
| sinon.expectation.fail(this.method + " called with " + thisValue + " as thisValue, expected " + |
| this.expectedThis); |
| } |
| |
| if (!("expectedArguments" in this)) { |
| return; |
| } |
| |
| if (!args) { |
| sinon.expectation.fail(this.method + " received no arguments, expected " + |
| sinon.format(this.expectedArguments)); |
| } |
| |
| if (args.length < this.expectedArguments.length) { |
| sinon.expectation.fail(this.method + " received too few arguments (" + sinon.format(args) + |
| "), expected " + sinon.format(this.expectedArguments)); |
| } |
| |
| if (this.expectsExactArgCount && |
| args.length != this.expectedArguments.length) { |
| sinon.expectation.fail(this.method + " received too many arguments (" + sinon.format(args) + |
| "), expected " + sinon.format(this.expectedArguments)); |
| } |
| |
| for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) { |
| |
| if (!verifyMatcher(this.expectedArguments[i],args[i])) { |
| sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) + |
| ", didn't match " + this.expectedArguments.toString()); |
| } |
| |
| if (!sinon.deepEqual(this.expectedArguments[i], args[i])) { |
| sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) + |
| ", expected " + sinon.format(this.expectedArguments)); |
| } |
| } |
| }, |
| |
| allowsCall: function allowsCall(thisValue, args) { |
| if (this.met() && receivedMaxCalls(this)) { |
| return false; |
| } |
| |
| if ("expectedThis" in this && this.expectedThis !== thisValue) { |
| return false; |
| } |
| |
| if (!("expectedArguments" in this)) { |
| return true; |
| } |
| |
| args = args || []; |
| |
| if (args.length < this.expectedArguments.length) { |
| return false; |
| } |
| |
| if (this.expectsExactArgCount && |
| args.length != this.expectedArguments.length) { |
| return false; |
| } |
| |
| for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) { |
| if (!verifyMatcher(this.expectedArguments[i],args[i])) { |
| return false; |
| } |
| |
| if (!sinon.deepEqual(this.expectedArguments[i], args[i])) { |
| return false; |
| } |
| } |
| |
| return true; |
| }, |
| |
| withArgs: function withArgs() { |
| this.expectedArguments = slice.call(arguments); |
| return this; |
| }, |
| |
| withExactArgs: function withExactArgs() { |
| this.withArgs.apply(this, arguments); |
| this.expectsExactArgCount = true; |
| return this; |
| }, |
| |
| on: function on(thisValue) { |
| this.expectedThis = thisValue; |
| return this; |
| }, |
| |
| toString: function () { |
| var args = (this.expectedArguments || []).slice(); |
| |
| if (!this.expectsExactArgCount) { |
| push.call(args, "[...]"); |
| } |
| |
| var callStr = sinon.spyCall.toString.call({ |
| proxy: this.method || "anonymous mock expectation", |
| args: args |
| }); |
| |
| var message = callStr.replace(", [...", "[, ...") + " " + |
| expectedCallCountInWords(this); |
| |
| if (this.met()) { |
| return "Expectation met: " + message; |
| } |
| |
| return "Expected " + message + " (" + |
| callCountInWords(this.callCount) + ")"; |
| }, |
| |
| verify: function verify() { |
| if (!this.met()) { |
| sinon.expectation.fail(this.toString()); |
| } else { |
| sinon.expectation.pass(this.toString()); |
| } |
| |
| return true; |
| }, |
| |
| pass: function(message) { |
| sinon.assert.pass(message); |
| }, |
| fail: function (message) { |
| var exception = new Error(message); |
| exception.name = "ExpectationError"; |
| |
| throw exception; |
| } |
| }; |
| }()); |
| |
| sinon.mock = mock; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = mock; }); |
| } else if (commonJSModule) { |
| module.exports = mock; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| },{"../sinon":23,"./match":28}],30:[function(require,module,exports){ |
| /** |
| * @depend ../sinon.js |
| * @depend collection.js |
| * @depend util/fake_timers.js |
| * @depend util/fake_server_with_clock.js |
| */ |
| /*jslint eqeqeq: false, onevar: false, plusplus: false*/ |
| /*global require, module*/ |
| /** |
| * Manages fake collections as well as fake utilities such as Sinon's |
| * timers and fake XHR implementation in one convenient object. |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| if (typeof module !== "undefined" && module.exports && typeof require == "function") { |
| var sinon = require("../sinon"); |
| sinon.extend(sinon, require("./util/fake_timers")); |
| } |
| |
| (function () { |
| var push = [].push; |
| |
| function exposeValue(sandbox, config, key, value) { |
| if (!value) { |
| return; |
| } |
| |
| if (config.injectInto && !(key in config.injectInto)) { |
| config.injectInto[key] = value; |
| sandbox.injectedKeys.push(key); |
| } else { |
| push.call(sandbox.args, value); |
| } |
| } |
| |
| function prepareSandboxFromConfig(config) { |
| var sandbox = sinon.create(sinon.sandbox); |
| |
| if (config.useFakeServer) { |
| if (typeof config.useFakeServer == "object") { |
| sandbox.serverPrototype = config.useFakeServer; |
| } |
| |
| sandbox.useFakeServer(); |
| } |
| |
| if (config.useFakeTimers) { |
| if (typeof config.useFakeTimers == "object") { |
| sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers); |
| } else { |
| sandbox.useFakeTimers(); |
| } |
| } |
| |
| return sandbox; |
| } |
| |
| sinon.sandbox = sinon.extend(sinon.create(sinon.collection), { |
| useFakeTimers: function useFakeTimers() { |
| this.clock = sinon.useFakeTimers.apply(sinon, arguments); |
| |
| return this.add(this.clock); |
| }, |
| |
| serverPrototype: sinon.fakeServer, |
| |
| useFakeServer: function useFakeServer() { |
| var proto = this.serverPrototype || sinon.fakeServer; |
| |
| if (!proto || !proto.create) { |
| return null; |
| } |
| |
| this.server = proto.create(); |
| return this.add(this.server); |
| }, |
| |
| inject: function (obj) { |
| sinon.collection.inject.call(this, obj); |
| |
| if (this.clock) { |
| obj.clock = this.clock; |
| } |
| |
| if (this.server) { |
| obj.server = this.server; |
| obj.requests = this.server.requests; |
| } |
| |
| return obj; |
| }, |
| |
| restore: function () { |
| sinon.collection.restore.apply(this, arguments); |
| this.restoreContext(); |
| }, |
| |
| restoreContext: function () { |
| if (this.injectedKeys) { |
| for (var i = 0, j = this.injectedKeys.length; i < j; i++) { |
| delete this.injectInto[this.injectedKeys[i]]; |
| } |
| this.injectedKeys = []; |
| } |
| }, |
| |
| create: function (config) { |
| if (!config) { |
| return sinon.create(sinon.sandbox); |
| } |
| |
| var sandbox = prepareSandboxFromConfig(config); |
| sandbox.args = sandbox.args || []; |
| sandbox.injectedKeys = []; |
| sandbox.injectInto = config.injectInto; |
| var prop, value, exposed = sandbox.inject({}); |
| |
| if (config.properties) { |
| for (var i = 0, l = config.properties.length; i < l; i++) { |
| prop = config.properties[i]; |
| value = exposed[prop] || prop == "sandbox" && sandbox; |
| exposeValue(sandbox, config, prop, value); |
| } |
| } else { |
| exposeValue(sandbox, config, "sandbox", value); |
| } |
| |
| return sandbox; |
| } |
| }); |
| |
| sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = sinon.sandbox; }); |
| } else if (typeof module !== 'undefined' && module.exports) { |
| module.exports = sinon.sandbox; |
| } |
| }()); |
| |
| },{"../sinon":23,"./util/fake_timers":35}],31:[function(require,module,exports){ |
| /** |
| * @depend ../sinon.js |
| * @depend call.js |
| */ |
| /*jslint eqeqeq: false, onevar: false, plusplus: false*/ |
| /*global module, require, sinon*/ |
| /** |
| * Spy functions |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| var push = Array.prototype.push; |
| var slice = Array.prototype.slice; |
| var callId = 0; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| function spy(object, property) { |
| if (!property && typeof object == "function") { |
| return spy.create(object); |
| } |
| |
| if (!object && !property) { |
| return spy.create(function () { }); |
| } |
| |
| var method = object[property]; |
| return sinon.wrapMethod(object, property, spy.create(method)); |
| } |
| |
| function matchingFake(fakes, args, strict) { |
| if (!fakes) { |
| return; |
| } |
| |
| for (var i = 0, l = fakes.length; i < l; i++) { |
| if (fakes[i].matches(args, strict)) { |
| return fakes[i]; |
| } |
| } |
| } |
| |
| function incrementCallCount() { |
| this.called = true; |
| this.callCount += 1; |
| this.notCalled = false; |
| this.calledOnce = this.callCount == 1; |
| this.calledTwice = this.callCount == 2; |
| this.calledThrice = this.callCount == 3; |
| } |
| |
| function createCallProperties() { |
| this.firstCall = this.getCall(0); |
| this.secondCall = this.getCall(1); |
| this.thirdCall = this.getCall(2); |
| this.lastCall = this.getCall(this.callCount - 1); |
| } |
| |
| var vars = "a,b,c,d,e,f,g,h,i,j,k,l"; |
| function createProxy(func) { |
| // Retain the function length: |
| var p; |
| if (func.length) { |
| eval("p = (function proxy(" + vars.substring(0, func.length * 2 - 1) + |
| ") { return p.invoke(func, this, slice.call(arguments)); });"); |
| } |
| else { |
| p = function proxy() { |
| return p.invoke(func, this, slice.call(arguments)); |
| }; |
| } |
| return p; |
| } |
| |
| var uuid = 0; |
| |
| // Public API |
| var spyApi = { |
| reset: function () { |
| this.called = false; |
| this.notCalled = true; |
| this.calledOnce = false; |
| this.calledTwice = false; |
| this.calledThrice = false; |
| this.callCount = 0; |
| this.firstCall = null; |
| this.secondCall = null; |
| this.thirdCall = null; |
| this.lastCall = null; |
| this.args = []; |
| this.returnValues = []; |
| this.thisValues = []; |
| this.exceptions = []; |
| this.callIds = []; |
| if (this.fakes) { |
| for (var i = 0; i < this.fakes.length; i++) { |
| this.fakes[i].reset(); |
| } |
| } |
| }, |
| |
| create: function create(func) { |
| var name; |
| |
| if (typeof func != "function") { |
| func = function () { }; |
| } else { |
| name = sinon.functionName(func); |
| } |
| |
| var proxy = createProxy(func); |
| |
| sinon.extend(proxy, spy); |
| delete proxy.create; |
| sinon.extend(proxy, func); |
| |
| proxy.reset(); |
| proxy.prototype = func.prototype; |
| proxy.displayName = name || "spy"; |
| proxy.toString = sinon.functionToString; |
| proxy._create = sinon.spy.create; |
| proxy.id = "spy#" + uuid++; |
| |
| return proxy; |
| }, |
| |
| invoke: function invoke(func, thisValue, args) { |
| var matching = matchingFake(this.fakes, args); |
| var exception, returnValue; |
| |
| incrementCallCount.call(this); |
| push.call(this.thisValues, thisValue); |
| push.call(this.args, args); |
| push.call(this.callIds, callId++); |
| |
| // Make call properties available from within the spied function: |
| createCallProperties.call(this); |
| |
| try { |
| if (matching) { |
| returnValue = matching.invoke(func, thisValue, args); |
| } else { |
| returnValue = (this.func || func).apply(thisValue, args); |
| } |
| |
| var thisCall = this.getCall(this.callCount - 1); |
| if (thisCall.calledWithNew() && typeof returnValue !== 'object') { |
| returnValue = thisValue; |
| } |
| } catch (e) { |
| exception = e; |
| } |
| |
| push.call(this.exceptions, exception); |
| push.call(this.returnValues, returnValue); |
| |
| // Make return value and exception available in the calls: |
| createCallProperties.call(this); |
| |
| if (exception !== undefined) { |
| throw exception; |
| } |
| |
| return returnValue; |
| }, |
| |
| named: function named(name) { |
| this.displayName = name; |
| return this; |
| }, |
| |
| getCall: function getCall(i) { |
| if (i < 0 || i >= this.callCount) { |
| return null; |
| } |
| |
| return sinon.spyCall(this, this.thisValues[i], this.args[i], |
| this.returnValues[i], this.exceptions[i], |
| this.callIds[i]); |
| }, |
| |
| getCalls: function () { |
| var calls = []; |
| var i; |
| |
| for (i = 0; i < this.callCount; i++) { |
| calls.push(this.getCall(i)); |
| } |
| |
| return calls; |
| }, |
| |
| calledBefore: function calledBefore(spyFn) { |
| if (!this.called) { |
| return false; |
| } |
| |
| if (!spyFn.called) { |
| return true; |
| } |
| |
| return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1]; |
| }, |
| |
| calledAfter: function calledAfter(spyFn) { |
| if (!this.called || !spyFn.called) { |
| return false; |
| } |
| |
| return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1]; |
| }, |
| |
| withArgs: function () { |
| var args = slice.call(arguments); |
| |
| if (this.fakes) { |
| var match = matchingFake(this.fakes, args, true); |
| |
| if (match) { |
| return match; |
| } |
| } else { |
| this.fakes = []; |
| } |
| |
| var original = this; |
| var fake = this._create(); |
| fake.matchingAguments = args; |
| fake.parent = this; |
| push.call(this.fakes, fake); |
| |
| fake.withArgs = function () { |
| return original.withArgs.apply(original, arguments); |
| }; |
| |
| for (var i = 0; i < this.args.length; i++) { |
| if (fake.matches(this.args[i])) { |
| incrementCallCount.call(fake); |
| push.call(fake.thisValues, this.thisValues[i]); |
| push.call(fake.args, this.args[i]); |
| push.call(fake.returnValues, this.returnValues[i]); |
| push.call(fake.exceptions, this.exceptions[i]); |
| push.call(fake.callIds, this.callIds[i]); |
| } |
| } |
| createCallProperties.call(fake); |
| |
| return fake; |
| }, |
| |
| matches: function (args, strict) { |
| var margs = this.matchingAguments; |
| |
| if (margs.length <= args.length && |
| sinon.deepEqual(margs, args.slice(0, margs.length))) { |
| return !strict || margs.length == args.length; |
| } |
| }, |
| |
| printf: function (format) { |
| var spy = this; |
| var args = slice.call(arguments, 1); |
| var formatter; |
| |
| return (format || "").replace(/%(.)/g, function (match, specifyer) { |
| formatter = spyApi.formatters[specifyer]; |
| |
| if (typeof formatter == "function") { |
| return formatter.call(null, spy, args); |
| } else if (!isNaN(parseInt(specifyer, 10))) { |
| return sinon.format(args[specifyer - 1]); |
| } |
| |
| return "%" + specifyer; |
| }); |
| } |
| }; |
| |
| function delegateToCalls(method, matchAny, actual, notCalled) { |
| spyApi[method] = function () { |
| if (!this.called) { |
| if (notCalled) { |
| return notCalled.apply(this, arguments); |
| } |
| return false; |
| } |
| |
| var currentCall; |
| var matches = 0; |
| |
| for (var i = 0, l = this.callCount; i < l; i += 1) { |
| currentCall = this.getCall(i); |
| |
| if (currentCall[actual || method].apply(currentCall, arguments)) { |
| matches += 1; |
| |
| if (matchAny) { |
| return true; |
| } |
| } |
| } |
| |
| return matches === this.callCount; |
| }; |
| } |
| |
| delegateToCalls("calledOn", true); |
| delegateToCalls("alwaysCalledOn", false, "calledOn"); |
| delegateToCalls("calledWith", true); |
| delegateToCalls("calledWithMatch", true); |
| delegateToCalls("alwaysCalledWith", false, "calledWith"); |
| delegateToCalls("alwaysCalledWithMatch", false, "calledWithMatch"); |
| delegateToCalls("calledWithExactly", true); |
| delegateToCalls("alwaysCalledWithExactly", false, "calledWithExactly"); |
| delegateToCalls("neverCalledWith", false, "notCalledWith", |
| function () { return true; }); |
| delegateToCalls("neverCalledWithMatch", false, "notCalledWithMatch", |
| function () { return true; }); |
| delegateToCalls("threw", true); |
| delegateToCalls("alwaysThrew", false, "threw"); |
| delegateToCalls("returned", true); |
| delegateToCalls("alwaysReturned", false, "returned"); |
| delegateToCalls("calledWithNew", true); |
| delegateToCalls("alwaysCalledWithNew", false, "calledWithNew"); |
| delegateToCalls("callArg", false, "callArgWith", function () { |
| throw new Error(this.toString() + " cannot call arg since it was not yet invoked."); |
| }); |
| spyApi.callArgWith = spyApi.callArg; |
| delegateToCalls("callArgOn", false, "callArgOnWith", function () { |
| throw new Error(this.toString() + " cannot call arg since it was not yet invoked."); |
| }); |
| spyApi.callArgOnWith = spyApi.callArgOn; |
| delegateToCalls("yield", false, "yield", function () { |
| throw new Error(this.toString() + " cannot yield since it was not yet invoked."); |
| }); |
| // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode. |
| spyApi.invokeCallback = spyApi.yield; |
| delegateToCalls("yieldOn", false, "yieldOn", function () { |
| throw new Error(this.toString() + " cannot yield since it was not yet invoked."); |
| }); |
| delegateToCalls("yieldTo", false, "yieldTo", function (property) { |
| throw new Error(this.toString() + " cannot yield to '" + property + |
| "' since it was not yet invoked."); |
| }); |
| delegateToCalls("yieldToOn", false, "yieldToOn", function (property) { |
| throw new Error(this.toString() + " cannot yield to '" + property + |
| "' since it was not yet invoked."); |
| }); |
| |
| spyApi.formatters = { |
| "c": function (spy) { |
| return sinon.timesInWords(spy.callCount); |
| }, |
| |
| "n": function (spy) { |
| return spy.toString(); |
| }, |
| |
| "C": function (spy) { |
| var calls = []; |
| |
| for (var i = 0, l = spy.callCount; i < l; ++i) { |
| var stringifiedCall = " " + spy.getCall(i).toString(); |
| if (/\n/.test(calls[i - 1])) { |
| stringifiedCall = "\n" + stringifiedCall; |
| } |
| push.call(calls, stringifiedCall); |
| } |
| |
| return calls.length > 0 ? "\n" + calls.join("\n") : ""; |
| }, |
| |
| "t": function (spy) { |
| var objects = []; |
| |
| for (var i = 0, l = spy.callCount; i < l; ++i) { |
| push.call(objects, sinon.format(spy.thisValues[i])); |
| } |
| |
| return objects.join(", "); |
| }, |
| |
| "*": function (spy, args) { |
| var formatted = []; |
| |
| for (var i = 0, l = args.length; i < l; ++i) { |
| push.call(formatted, sinon.format(args[i])); |
| } |
| |
| return formatted.join(", "); |
| } |
| }; |
| |
| sinon.extend(spy, spyApi); |
| |
| spy.spyCall = sinon.spyCall; |
| sinon.spy = spy; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = spy; }); |
| } else if (commonJSModule) { |
| module.exports = spy; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| },{"../sinon":23}],32:[function(require,module,exports){ |
| /** |
| * @depend ../sinon.js |
| * @depend spy.js |
| * @depend behavior.js |
| */ |
| /*jslint eqeqeq: false, onevar: false*/ |
| /*global module, require, sinon*/ |
| /** |
| * Stub functions |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| function stub(object, property, func) { |
| if (!!func && typeof func != "function") { |
| throw new TypeError("Custom stub should be function"); |
| } |
| |
| var wrapper; |
| |
| if (func) { |
| wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func; |
| } else { |
| wrapper = stub.create(); |
| } |
| |
| if (!object && typeof property === "undefined") { |
| return sinon.stub.create(); |
| } |
| |
| if (typeof property === "undefined" && typeof object == "object") { |
| for (var prop in object) { |
| if (typeof object[prop] === "function") { |
| stub(object, prop); |
| } |
| } |
| |
| return object; |
| } |
| |
| return sinon.wrapMethod(object, property, wrapper); |
| } |
| |
| function getDefaultBehavior(stub) { |
| return stub.defaultBehavior || getParentBehaviour(stub) || sinon.behavior.create(stub); |
| } |
| |
| function getParentBehaviour(stub) { |
| return (stub.parent && getCurrentBehavior(stub.parent)); |
| } |
| |
| function getCurrentBehavior(stub) { |
| var behavior = stub.behaviors[stub.callCount - 1]; |
| return behavior && behavior.isPresent() ? behavior : getDefaultBehavior(stub); |
| } |
| |
| var uuid = 0; |
| |
| sinon.extend(stub, (function () { |
| var proto = { |
| create: function create() { |
| var functionStub = function () { |
| return getCurrentBehavior(functionStub).invoke(this, arguments); |
| }; |
| |
| functionStub.id = "stub#" + uuid++; |
| var orig = functionStub; |
| functionStub = sinon.spy.create(functionStub); |
| functionStub.func = orig; |
| |
| sinon.extend(functionStub, stub); |
| functionStub._create = sinon.stub.create; |
| functionStub.displayName = "stub"; |
| functionStub.toString = sinon.functionToString; |
| |
| functionStub.defaultBehavior = null; |
| functionStub.behaviors = []; |
| |
| return functionStub; |
| }, |
| |
| resetBehavior: function () { |
| var i; |
| |
| this.defaultBehavior = null; |
| this.behaviors = []; |
| |
| delete this.returnValue; |
| delete this.returnArgAt; |
| this.returnThis = false; |
| |
| if (this.fakes) { |
| for (i = 0; i < this.fakes.length; i++) { |
| this.fakes[i].resetBehavior(); |
| } |
| } |
| }, |
| |
| onCall: function(index) { |
| if (!this.behaviors[index]) { |
| this.behaviors[index] = sinon.behavior.create(this); |
| } |
| |
| return this.behaviors[index]; |
| }, |
| |
| onFirstCall: function() { |
| return this.onCall(0); |
| }, |
| |
| onSecondCall: function() { |
| return this.onCall(1); |
| }, |
| |
| onThirdCall: function() { |
| return this.onCall(2); |
| } |
| }; |
| |
| for (var method in sinon.behavior) { |
| if (sinon.behavior.hasOwnProperty(method) && |
| !proto.hasOwnProperty(method) && |
| method != 'create' && |
| method != 'withArgs' && |
| method != 'invoke') { |
| proto[method] = (function(behaviorMethod) { |
| return function() { |
| this.defaultBehavior = this.defaultBehavior || sinon.behavior.create(this); |
| this.defaultBehavior[behaviorMethod].apply(this.defaultBehavior, arguments); |
| return this; |
| }; |
| }(method)); |
| } |
| } |
| |
| return proto; |
| }())); |
| |
| sinon.stub = stub; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = stub; }); |
| } else if (commonJSModule) { |
| module.exports = stub; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| },{"../sinon":23}],33:[function(require,module,exports){ |
| /** |
| * @depend ../sinon.js |
| * @depend stub.js |
| * @depend mock.js |
| * @depend sandbox.js |
| */ |
| /*jslint eqeqeq: false, onevar: false, forin: true, plusplus: false*/ |
| /*global module, require, sinon*/ |
| /** |
| * Test function, sandboxes fakes |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon) { |
| return; |
| } |
| |
| function test(callback) { |
| var type = typeof callback; |
| |
| if (type != "function") { |
| throw new TypeError("sinon.test needs to wrap a test function, got " + type); |
| } |
| |
| function sinonSandboxedTest() { |
| var config = sinon.getConfig(sinon.config); |
| config.injectInto = config.injectIntoThis && this || config.injectInto; |
| var sandbox = sinon.sandbox.create(config); |
| var exception, result; |
| var args = Array.prototype.slice.call(arguments).concat(sandbox.args); |
| |
| try { |
| result = callback.apply(this, args); |
| } catch (e) { |
| exception = e; |
| } |
| |
| if (typeof exception !== "undefined") { |
| sandbox.restore(); |
| throw exception; |
| } |
| else { |
| sandbox.verifyAndRestore(); |
| } |
| |
| return result; |
| }; |
| |
| if (callback.length) { |
| return function sinonAsyncSandboxedTest(callback) { |
| return sinonSandboxedTest.apply(this, arguments); |
| }; |
| } |
| |
| return sinonSandboxedTest; |
| } |
| |
| test.config = { |
| injectIntoThis: true, |
| injectInto: null, |
| properties: ["spy", "stub", "mock", "clock", "server", "requests"], |
| useFakeTimers: true, |
| useFakeServer: true |
| }; |
| |
| sinon.test = test; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = test; }); |
| } else if (commonJSModule) { |
| module.exports = test; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| },{"../sinon":23}],34:[function(require,module,exports){ |
| /** |
| * @depend ../sinon.js |
| * @depend test.js |
| */ |
| /*jslint eqeqeq: false, onevar: false, eqeqeq: false*/ |
| /*global module, require, sinon*/ |
| /** |
| * Test case, sandboxes all test functions |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| (function (sinon) { |
| var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function"; |
| |
| if (!sinon && commonJSModule) { |
| sinon = require("../sinon"); |
| } |
| |
| if (!sinon || !Object.prototype.hasOwnProperty) { |
| return; |
| } |
| |
| function createTest(property, setUp, tearDown) { |
| return function () { |
| if (setUp) { |
| setUp.apply(this, arguments); |
| } |
| |
| var exception, result; |
| |
| try { |
| result = property.apply(this, arguments); |
| } catch (e) { |
| exception = e; |
| } |
| |
| if (tearDown) { |
| tearDown.apply(this, arguments); |
| } |
| |
| if (exception) { |
| throw exception; |
| } |
| |
| return result; |
| }; |
| } |
| |
| function testCase(tests, prefix) { |
| /*jsl:ignore*/ |
| if (!tests || typeof tests != "object") { |
| throw new TypeError("sinon.testCase needs an object with test functions"); |
| } |
| /*jsl:end*/ |
| |
| prefix = prefix || "test"; |
| var rPrefix = new RegExp("^" + prefix); |
| var methods = {}, testName, property, method; |
| var setUp = tests.setUp; |
| var tearDown = tests.tearDown; |
| |
| for (testName in tests) { |
| if (tests.hasOwnProperty(testName)) { |
| property = tests[testName]; |
| |
| if (/^(setUp|tearDown)$/.test(testName)) { |
| continue; |
| } |
| |
| if (typeof property == "function" && rPrefix.test(testName)) { |
| method = property; |
| |
| if (setUp || tearDown) { |
| method = createTest(property, setUp, tearDown); |
| } |
| |
| methods[testName] = sinon.test(method); |
| } else { |
| methods[testName] = tests[testName]; |
| } |
| } |
| } |
| |
| return methods; |
| } |
| |
| sinon.testCase = testCase; |
| |
| if (typeof define === "function" && define.amd) { |
| define(["module"], function(module) { module.exports = testCase; }); |
| } else if (commonJSModule) { |
| module.exports = testCase; |
| } |
| }(typeof sinon == "object" && sinon || null)); |
| |
| },{"../sinon":23}],35:[function(require,module,exports){ |
| (function (global){ |
| /*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/ |
| /*global module, require, window*/ |
| /** |
| * Fake timer API |
| * setTimeout |
| * setInterval |
| * clearTimeout |
| * clearInterval |
| * tick |
| * reset |
| * Date |
| * |
| * Inspired by jsUnitMockTimeOut from JsUnit |
| * |
| * @author Christian Johansen (christian@cjohansen.no) |
| * @license BSD |
| * |
| * Copyright (c) 2010-2013 Christian Johansen |
| */ |
| "use strict"; |
| |
| if (typeof sinon == "undefined") { |
| var sinon = {}; |
| } |
| |
| (function (global) { |
| // node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref() |
| // browsers, a number. |
| // see https://github.com/cjohansen/Sinon.JS/pull/436 |
| var timeoutResult = setTimeout(function() {}, 0); |
| var addTimerReturnsObject = typeof timeoutResult === 'object'; |
| clearTimeout(timeoutResult); |
| |
| var id = 1; |
| |
| function addTimer(args, recurring) { |
| if (args.length === 0) { |
| throw new Error("Function requires at least 1 parameter"); |
| } |
| |
| if (typeof args[0] === "undefined") { |
| throw new Error("Callback must be provided to timer calls"); |
| } |
| |
| var toId = id++; |
| var delay = args[1] || 0; |
| |
| if (!this.timeouts) { |
| this.timeouts = {}; |
| } |
| |
| this.timeouts[toId] = { |
| id: toId, |
| func: args[0], |
| callAt: this.now + delay, |
| invokeArgs: Array.prototype.slice.call(args, 2) |
| }; |
| |
| if (recurring === true) { |
| this.timeouts[toId].interval = delay; |
| } |
| |
| if (addTimerReturnsObject) { |
| return { |
| id: toId, |
| ref: function() {}, |
| unref: function() {} |
| }; |
| } |
| else { |
| return toId; |
| } |
| } |
| |
| function parseTime(str) { |
| if (!str) { |
| return 0; |
| } |
| |
| var strings = str.split(":"); |
| var l = strings.length, i = l; |
| var ms = 0, parsed; |
| |
| if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) { |
| throw new Error("tick only understands numbers and 'h:m:s'"); |
| } |
| |
| while (i--) { |
| parsed = parseInt(strings[i], 10); |
| |
| if (parsed >= 60) { |
| throw new Error("Invalid time " + str); |
| } |
| |
| ms += parsed * Math.pow(60, (l - i - 1)); |
| } |
| |
| return ms * 1000; |
| } |
| |
| function createObject(object) { |
| var newObject; |
| |
| if (Object.create) { |
| newObject = Object.create(object); |
| } else { |
| var F = function () {}; |
| F.prototype = object; |
| newObject = new F(); |
| } |
| |
| newObject.Date.clock = newObject; |
| return newObject; |
| } |
| |
| sinon.clock = { |
| now: 0, |
| |
| create: function create(now) { |
| var clock = createObject(this); |
| |
| if (typeof now == "number") { |
| clock.now = now; |
| } |
| |
| if (!!now && typeof now == "object") { |
| throw new TypeError("now should be milliseconds since UNIX epoch"); |
| } |
| |
| return clock; |
| }, |
| |
| setTimeout: function setTimeout(callback, timeout) { |
| return addTimer.call(this, arguments, false); |
| }, |
| |
| clearTimeout: function clearTimeout(timerId) { |
| if (!timerId) { |
| // null appears to be allowed in most browsers, and appears to be relied upon by some libraries, like Bootstrap carousel |
| return; |
| } |
| if (!this.timeouts) { |
| this.timeouts = []; |
| } |
| // in Node, timerId is an object with .ref()/.unref(), and |
| // its .id field is the actual timer id. |
| if (typeof timerId === 'object') { |
| timerId = timerId.id |
| } |
| if (timerId in this.timeouts) { |
| delete this.timeouts[timerId]; |
| } |
| }, |
| |
| setInterval: function setInterval(callback, timeout) { |
| return addTimer.call(this, arguments, true); |
| }, |
| |
| clearInterval: function clearInterval(timerId) { |
| this.clearTimeout(timerId); |
| }, |
| |
| setImmediate: function setImmediate(callback) { |
| var passThruArgs = Array.prototype.slice.call(arguments, 1); |
| |
| return addTimer.call(this, [callback, 0].concat(passThruArgs), false); |
| }, |
| |
| clearImmediate: function clearImmediate(timerId) { |
| this.clearTimeout(timerId); |
| }, |
| |
| tick: function tick(ms) { |
| ms = typeof ms == "number" ? ms : parseTime(ms); |
| var tickFrom = this.now, tickTo = this.now + ms, previous = this.now; |
| var timer = this.firstTimerInRange(tickFrom, tickTo); |
| |
| var firstException; |
| while (timer && tickFrom <= tickTo) { |
| if (this.timeouts[timer.id]) { |
| tickFrom = this.now = timer.callAt; |
| try { |
| this.callTimer(timer); |
| } catch (e) { |
| firstException = firstException || e; |
| } |
| } |
| |
| timer = this.firstTimerInRange(previous, tickTo); |
| previous = tickFrom; |
| } |
| |
| this.now = tickTo; |
| |
| if (firstException) { |
| throw firstException; |
| } |
| |
| return this.now; |
| }, |
| |
| firstTimerInRange: function (from, to) { |
| var timer, smallest = null, originalTimer; |
| |
| for (var id in this.timeouts) { |
| if (this.timeouts.hasOwnProperty(id)) { |
| if (this.timeouts[id].callAt < from || this.timeouts[id].callAt > to) { |
| continue; |
| } |
| |
| if (smallest === null || this.timeouts[id].callAt < smallest) { |
| originalTimer = this.timeouts[id]; |
| smallest = this.timeouts[id].callAt; |
| |
| timer = { |
| func: this.timeouts[id].func, |
| callAt: this.timeouts[id].callAt, |
| interval: this.timeouts[id].interval, |
| id: this.timeouts[id].id, |
| invokeArgs: this.timeouts[id].invokeArgs |
| }; |
| } |
| } |
| } |
| |
| return timer || null; |
| }, |
| |
| callTimer: function (timer) { |
| if (typeof timer.interval == "number") { |
| this.timeouts[timer.id].callAt += timer.interval; |
| } else { |
| delete this.timeouts[timer.id]; |
| } |
| |
| try { |
| if (typeof timer.func == "function") { |
| timer.func.apply(null, timer.invokeArgs); |
| } else { |
| eval(timer.func); |
| } |
| } catch (e) { |
| var exception = e; |
| } |
| |
| if (!this.timeouts[timer.id]) { |
| if (exception) { |
| throw exception; |
| } |
| return; |
| } |
| |
| if (exception) { |
| throw exception; |
| } |
| }, |
| |
| reset: function reset() { |
| this.timeouts = {}; |
| }, |
| |
| Date: (function () { |
| var NativeDate = Date; |
| |
| function ClockDate(year, month, date, hour, minute, second, ms) { |
| // Defensive and verbose to avoid potential harm in passing |
| // explicit undefined when user does not pass argument |
| switch (arguments.length) { |
| case 0: |
| return new NativeDate(ClockDate.clock.now); |
| case 1: |
| return new NativeDate(year); |
| case 2: |
| return new NativeDate(year, month); |
| case 3: |
| return new NativeDate(year, month, date); |
| case 4: |
| return new NativeDate(year, month, date, hour); |
| case 5: |
| return new NativeDate(year, month, date, hour, minute); |
| case 6: |
| return new NativeDate(year, month, date, hour, minute, second); |
| default: |
| return new NativeDate(year, month, date, hour, minute, second, ms); |
| } |
| } |
| |
| return mirrorDateProperties(ClockDate, NativeDate); |
| }()) |
| }; |
| |
| function mirrorDateProperties(target, source) { |
| if (source.now) { |
| target.now = function now() { |
| return target.clock.now; |
| }; |
| } else { |
| delete target.now; |
| } |
| |
| if (source.toSource) { |
| target.toSource = function toSource() { |
| return source.toSource(); |
| }; |
| } else { |
| delete target.toSource; |
| } |
| |
| target.toString = function toString() { |
| return source.toString(); |
| }; |
| |
| target.prototype = source.prototype; |
| target.parse = source.parse; |
| target.UTC = source.UTC; |
| target.prototype.toUTCString = source.prototype.toUTCString; |
| |
| for (var prop in source) { |
| if (source.hasOwnProperty(prop)) { |
| target[prop] = source[prop]; |
| } |
| } |
| |
| return target; |
| } |
| |
| var methods = ["Date", "setTimeout", "setInterval", |
| "clearTimeout", "clearInterval"]; |
| |
| if (typeof global.setImmediate !== "undefined") { |
| methods.push("setImmediate"); |
| } |
| |
| if (typeof global.clearImmediate !== "undefined") { |
| methods.push("clearImmediate"); |
| } |
| |
| function restore() { |
| var method; |
| |
| for (var i = 0, l = this.methods.length; i < l; i++) { |
| method = this.methods[i]; |
| |
| if (global[method].hadOwnProperty) { |
| global[method] = this["_" + method]; |
| } else { |
| try { |
| delete global[method]; |
| } catch (e) {} |
| } |
| } |
| |
| // Prevent multiple executions which will completely remove these props |
| this.methods = []; |
| } |
| |
| function stubGlobal(method, clock) { |
| clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(global, method); |
| clock["_" + method] = global[method]; |
| |
| if (method == "Date") { |
| var date = mirrorDateProperties(clock[method], global[method]); |
| global[method] = date; |
| } else { |
| global[method] = function () { |
| return clock[method].apply(clock, arguments); |
| }; |
| |
| for (var prop in clock[method]) { |
| if (clock[method].hasOwnProperty(prop)) { |
| global[method][prop] = clock[method][prop]; |
| } |
| } |
| } |
| |
| global[method].clock = clock; |
| } |
| |
| sinon.useFakeTimers = function useFakeTimers(now) { |
| var clock = sinon.clock.create(now); |
| clock.restore = restore; |
| clock.methods = Array.prototype.slice.call(arguments, |
| typeof now == "number" ? 1 : 0); |
| |
| if (clock.methods.length === 0) { |
| clock.methods = methods; |
| } |
| |
| for (var i = 0, l = clock.methods.length; i < l; i++) { |
| stubGlobal(clock.methods[i], clock); |
| } |
| |
| return clock; |
| }; |
| }(typeof global != "undefined" && typeof global !== "function" ? global : this)); |
| |
| sinon.timers = { |
| setTimeout: setTimeout, |
| clearTimeout: clearTimeout, |
| setImmediate: (typeof setImmediate !== "undefined" ? setImmediate : undefined), |
| clearImmediate: (typeof clearImmediate !== "undefined" ? clearImmediate: undefined), |
| setInterval: setInterval, |
| clearInterval: clearInterval, |
| Date: Date |
| }; |
| |
| if (typeof module !== 'undefined' && module.exports) { |
| module.exports = sinon; |
| } |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],36:[function(require,module,exports){ |
| (function (global){ |
| ((typeof define === "function" && define.amd && function (m) { |
| define("formatio", ["samsam"], m); |
| }) || (typeof module === "object" && function (m) { |
| module.exports = m(require("samsam")); |
| }) || function (m) { this.formatio = m(this.samsam); } |
| )(function (samsam) { |
| "use strict"; |
| |
| var formatio = { |
| excludeConstructors: ["Object", /^.$/], |
| quoteStrings: true |
| }; |
| |
| var hasOwn = Object.prototype.hasOwnProperty; |
| |
| var specialObjects = []; |
| if (typeof global !== "undefined") { |
| specialObjects.push({ object: global, value: "[object global]" }); |
| } |
| if (typeof document !== "undefined") { |
| specialObjects.push({ |
| object: document, |
| value: "[object HTMLDocument]" |
| }); |
| } |
| if (typeof window !== "undefined") { |
| specialObjects.push({ object: window, value: "[object Window]" }); |
| } |
| |
| function functionName(func) { |
| if (!func) { return ""; } |
| if (func.displayName) { return func.displayName; } |
| if (func.name) { return func.name; } |
| var matches = func.toString().match(/function\s+([^\(]+)/m); |
| return (matches && matches[1]) || ""; |
| } |
| |
| function constructorName(f, object) { |
| var name = functionName(object && object.constructor); |
| var excludes = f.excludeConstructors || |
| formatio.excludeConstructors || []; |
| |
| var i, l; |
| for (i = 0, l = excludes.length; i < l; ++i) { |
| if (typeof excludes[i] === "string" && excludes[i] === name) { |
| return ""; |
| } else if (excludes[i].test && excludes[i].test(name)) { |
| return ""; |
| } |
| } |
| |
| return name; |
| } |
| |
| function isCircular(object, objects) { |
| if (typeof object !== "object") { return false; } |
| var i, l; |
| for (i = 0, l = objects.length; i < l; ++i) { |
| if (objects[i] === object) { return true; } |
| } |
| return false; |
| } |
| |
| function ascii(f, object, processed, indent) { |
| if (typeof object === "string") { |
| var qs = f.quoteStrings; |
| var quote = typeof qs !== "boolean" || qs; |
| return processed || quote ? '"' + object + '"' : object; |
| } |
| |
| if (typeof object === "function" && !(object instanceof RegExp)) { |
| return ascii.func(object); |
| } |
| |
| processed = processed || []; |
| |
| if (isCircular(object, processed)) { return "[Circular]"; } |
| |
| if (Object.prototype.toString.call(object) === "[object Array]") { |
| return ascii.array.call(f, object, processed); |
| } |
| |
| if (!object) { return String((1/object) === -Infinity ? "-0" : object); } |
| if (samsam.isElement(object)) { return ascii.element(object); } |
| |
| if (typeof object.toString === "function" && |
| object.toString !== Object.prototype.toString) { |
| return object.toString(); |
| } |
| |
| var i, l; |
| for (i = 0, l = specialObjects.length; i < l; i++) { |
| if (object === specialObjects[i].object) { |
| return specialObjects[i].value; |
| } |
| } |
| |
| return ascii.object.call(f, object, processed, indent); |
| } |
| |
| ascii.func = function (func) { |
| return "function " + functionName(func) + "() {}"; |
| }; |
| |
| ascii.array = function (array, processed) { |
| processed = processed || []; |
| processed.push(array); |
| var i, l, pieces = []; |
| for (i = 0, l = array.length; i < l; ++i) { |
| pieces.push(ascii(this, array[i], processed)); |
| } |
| return "[" + pieces.join(", ") + "]"; |
| }; |
| |
| ascii.object = function (object, processed, indent) { |
| processed = processed || []; |
| processed.push(object); |
| indent = indent || 0; |
| var pieces = [], properties = samsam.keys(object).sort(); |
| var length = 3; |
| var prop, str, obj, i, l; |
| |
| for (i = 0, l = properties.length; i < l; ++i) { |
| prop = properties[i]; |
| obj = object[prop]; |
| |
| if (isCircular(obj, processed)) { |
| str = "[Circular]"; |
| } else { |
| str = ascii(this, obj, processed, indent + 2); |
| } |
| |
| str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str; |
| length += str.length; |
| pieces.push(str); |
| } |
| |
| var cons = constructorName(this, object); |
| var prefix = cons ? "[" + cons + "] " : ""; |
| var is = ""; |
| for (i = 0, l = indent; i < l; ++i) { is += " "; } |
| |
| if (length + indent > 80) { |
| return prefix + "{\n " + is + pieces.join(",\n " + is) + "\n" + |
| is + "}"; |
| } |
| return prefix + "{ " + pieces.join(", ") + " }"; |
| }; |
| |
| ascii.element = function (element) { |
| var tagName = element.tagName.toLowerCase(); |
| var attrs = element.attributes, attr, pairs = [], attrName, i, l, val; |
| |
| for (i = 0, l = attrs.length; i < l; ++i) { |
| attr = attrs.item(i); |
| attrName = attr.nodeName.toLowerCase().replace("html:", ""); |
| val = attr.nodeValue; |
| if (attrName !== "contenteditable" || val !== "inherit") { |
| if (!!val) { pairs.push(attrName + "=\"" + val + "\""); } |
| } |
| } |
| |
| var formatted = "<" + tagName + (pairs.length > 0 ? " " : ""); |
| var content = element.innerHTML; |
| |
| if (content.length > 20) { |
| content = content.substr(0, 20) + "[...]"; |
| } |
| |
| var res = formatted + pairs.join(" ") + ">" + content + |
| "</" + tagName + ">"; |
| |
| return res.replace(/ contentEditable="inherit"/, ""); |
| }; |
| |
| function Formatio(options) { |
| for (var opt in options) { |
| this[opt] = options[opt]; |
| } |
| } |
| |
| Formatio.prototype = { |
| functionName: functionName, |
| |
| configure: function (options) { |
| return new Formatio(options); |
| }, |
| |
| constructorName: function (object) { |
| return constructorName(this, object); |
| }, |
| |
| ascii: function (object, processed, indent) { |
| return ascii(this, object, processed, indent); |
| } |
| }; |
| |
| return Formatio.prototype; |
| }); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"samsam":37}],37:[function(require,module,exports){ |
| ((typeof define === "function" && define.amd && function (m) { define("samsam", m); }) || |
| (typeof module === "object" && |
| function (m) { module.exports = m(); }) || // Node |
| function (m) { this.samsam = m(); } // Browser globals |
| )(function () { |
| var o = Object.prototype; |
| var div = typeof document !== "undefined" && document.createElement("div"); |
| |
| function isNaN(value) { |
| // Unlike global isNaN, this avoids type coercion |
| // typeof check avoids IE host object issues, hat tip to |
| // lodash |
| var val = value; // JsLint thinks value !== value is "weird" |
| return typeof value === "number" && value !== val; |
| } |
| |
| function getClass(value) { |
| // Returns the internal [[Class]] by calling Object.prototype.toString |
| // with the provided value as this. Return value is a string, naming the |
| // internal class, e.g. "Array" |
| return o.toString.call(value).split(/[ \]]/)[1]; |
| } |
| |
| /** |
| * @name samsam.isArguments |
| * @param Object object |
| * |
| * Returns ``true`` if ``object`` is an ``arguments`` object, |
| * ``false`` otherwise. |
| */ |
| function isArguments(object) { |
| if (getClass(object) === 'Arguments') { return true; } |
| if (typeof object !== "object" || typeof object.length !== "number" || |
| getClass(object) === "Array") { |
| return false; |
| } |
| if (typeof object.callee == "function") { return true; } |
| try { |
| object[object.length] = 6; |
| delete object[object.length]; |
| } catch (e) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * @name samsam.isElement |
| * @param Object object |
| * |
| * Returns ``true`` if ``object`` is a DOM element node. Unlike |
| * Underscore.js/lodash, this function will return ``false`` if ``object`` |
| * is an *element-like* object, i.e. a regular object with a ``nodeType`` |
| * property that holds the value ``1``. |
| */ |
| function isElement(object) { |
| if (!object || object.nodeType !== 1 || !div) { return false; } |
| try { |
| object.appendChild(div); |
| object.removeChild(div); |
| } catch (e) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * @name samsam.keys |
| * @param Object object |
| * |
| * Return an array of own property names. |
| */ |
| function keys(object) { |
| var ks = [], prop; |
| for (prop in object) { |
| if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); } |
| } |
| return ks; |
| } |
| |
| /** |
| * @name samsam.isDate |
| * @param Object value |
| * |
| * Returns true if the object is a ``Date``, or *date-like*. Duck typing |
| * of date objects work by checking that the object has a ``getTime`` |
| * function whose return value equals the return value from the object's |
| * ``valueOf``. |
| */ |
| function isDate(value) { |
| return typeof value.getTime == "function" && |
| value.getTime() == value.valueOf(); |
| } |
| |
| /** |
| * @name samsam.isNegZero |
| * @param Object value |
| * |
| * Returns ``true`` if ``value`` is ``-0``. |
| */ |
| function isNegZero(value) { |
| return value === 0 && 1 / value === -Infinity; |
| } |
| |
| /** |
| * @name samsam.equal |
| * @param Object obj1 |
| * @param Object obj2 |
| * |
| * Returns ``true`` if two objects are strictly equal. Compared to |
| * ``===`` there are two exceptions: |
| * |
| * - NaN is considered equal to NaN |
| * - -0 and +0 are not considered equal |
| */ |
| function identical(obj1, obj2) { |
| if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) { |
| return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2); |
| } |
| } |
| |
| |
| /** |
| * @name samsam.deepEqual |
| * @param Object obj1 |
| * @param Object obj2 |
| * |
| * Deep equal comparison. Two values are "deep equal" if: |
| * |
| * - They are equal, according to samsam.identical |
| * - They are both date objects representing the same time |
| * - They are both arrays containing elements that are all deepEqual |
| * - They are objects with the same set of properties, and each property |
| * in ``obj1`` is deepEqual to the corresponding property in ``obj2`` |
| * |
| * Supports cyclic objects. |
| */ |
| function deepEqualCyclic(obj1, obj2) { |
| |
| // used for cyclic comparison |
| // contain already visited objects |
| var objects1 = [], |
| objects2 = [], |
| // contain pathes (position in the object structure) |
| // of the already visited objects |
| // indexes same as in objects arrays |
| paths1 = [], |
| paths2 = [], |
| // contains combinations of already compared objects |
| // in the manner: { "$1['ref']$2['ref']": true } |
| compared = {}; |
| |
| /** |
| * used to check, if the value of a property is an object |
| * (cyclic logic is only needed for objects) |
| * only needed for cyclic logic |
| */ |
| function isObject(value) { |
| |
| if (typeof value === 'object' && value !== null && |
| !(value instanceof Boolean) && |
| !(value instanceof Date) && |
| !(value instanceof Number) && |
| !(value instanceof RegExp) && |
| !(value instanceof String)) { |
| |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * returns the index of the given object in the |
| * given objects array, -1 if not contained |
| * only needed for cyclic logic |
| */ |
| function getIndex(objects, obj) { |
| |
| var i; |
| for (i = 0; i < objects.length; i++) { |
| if (objects[i] === obj) { |
| return i; |
| } |
| } |
| |
| return -1; |
| } |
| |
| // does the recursion for the deep equal check |
| return (function deepEqual(obj1, obj2, path1, path2) { |
| var type1 = typeof obj1; |
| var type2 = typeof obj2; |
| |
| // == null also matches undefined |
| if (obj1 === obj2 || |
| isNaN(obj1) || isNaN(obj2) || |
| obj1 == null || obj2 == null || |
| type1 !== "object" || type2 !== "object") { |
| |
| return identical(obj1, obj2); |
| } |
| |
| // Elements are only equal if identical(expected, actual) |
| if (isElement(obj1) || isElement(obj2)) { return false; } |
| |
| var isDate1 = isDate(obj1), isDate2 = isDate(obj2); |
| if (isDate1 || isDate2) { |
| if (!isDate1 || !isDate2 || obj1.getTime() !== obj2.getTime()) { |
| return false; |
| } |
| } |
| |
| if (obj1 instanceof RegExp && obj2 instanceof RegExp) { |
| if (obj1.toString() !== obj2.toString()) { return false; } |
| } |
| |
| var class1 = getClass(obj1); |
| var class2 = getClass(obj2); |
| var keys1 = keys(obj1); |
| var keys2 = keys(obj2); |
| |
| if (isArguments(obj1) || isArguments(obj2)) { |
| if (obj1.length !== obj2.length) { return false; } |
| } else { |
| if (type1 !== type2 || class1 !== class2 || |
| keys1.length !== keys2.length) { |
| return false; |
| } |
| } |
| |
| var key, i, l, |
| // following vars are used for the cyclic logic |
| value1, value2, |
| isObject1, isObject2, |
| index1, index2, |
| newPath1, newPath2; |
| |
| for (i = 0, l = keys1.length; i < l; i++) { |
| key = keys1[i]; |
| if (!o.hasOwnProperty.call(obj2, key)) { |
| return false; |
| } |
| |
| // Start of the cyclic logic |
| |
| value1 = obj1[key]; |
| value2 = obj2[key]; |
| |
| isObject1 = isObject(value1); |
| isObject2 = isObject(value2); |
| |
| // determine, if the objects were already visited |
| // (it's faster to check for isObject first, than to |
| // get -1 from getIndex for non objects) |
| index1 = isObject1 ? getIndex(objects1, value1) : -1; |
| index2 = isObject2 ? getIndex(objects2, value2) : -1; |
| |
| // determine the new pathes of the objects |
| // - for non cyclic objects the current path will be extended |
| // by current property name |
| // - for cyclic objects the stored path is taken |
| newPath1 = index1 !== -1 |
| ? paths1[index1] |
| : path1 + '[' + JSON.stringify(key) + ']'; |
| newPath2 = index2 !== -1 |
| ? paths2[index2] |
| : path2 + '[' + JSON.stringify(key) + ']'; |
| |
| // stop recursion if current objects are already compared |
| if (compared[newPath1 + newPath2]) { |
| return true; |
| } |
| |
| // remember the current objects and their pathes |
| if (index1 === -1 && isObject1) { |
| objects1.push(value1); |
| paths1.push(newPath1); |
| } |
| if (index2 === -1 && isObject2) { |
| objects2.push(value2); |
| paths2.push(newPath2); |
| } |
| |
| // remember that the current objects are already compared |
| if (isObject1 && isObject2) { |
| compared[newPath1 + newPath2] = true; |
| } |
| |
| // End of cyclic logic |
| |
| // neither value1 nor value2 is a cycle |
| // continue with next level |
| if (!deepEqual(value1, value2, newPath1, newPath2)) { |
| return false; |
| } |
| } |
| |
| return true; |
| |
| }(obj1, obj2, '$1', '$2')); |
| } |
| |
| var match; |
| |
| function arrayContains(array, subset) { |
| if (subset.length === 0) { return true; } |
| var i, l, j, k; |
| for (i = 0, l = array.length; i < l; ++i) { |
| if (match(array[i], subset[0])) { |
| for (j = 0, k = subset.length; j < k; ++j) { |
| if (!match(array[i + j], subset[j])) { return false; } |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * @name samsam.match |
| * @param Object object |
| * @param Object matcher |
| * |
| * Compare arbitrary value ``object`` with matcher. |
| */ |
| match = function match(object, matcher) { |
| if (matcher && typeof matcher.test === "function") { |
| return matcher.test(object); |
| } |
| |
| if (typeof matcher === "function") { |
| return matcher(object) === true; |
| } |
| |
| if (typeof matcher === "string") { |
| matcher = matcher.toLowerCase(); |
| var notNull = typeof object === "string" || !!object; |
| return notNull && |
| (String(object)).toLowerCase().indexOf(matcher) >= 0; |
| } |
| |
| if (typeof matcher === "number") { |
| return matcher === object; |
| } |
| |
| if (typeof matcher === "boolean") { |
| return matcher === object; |
| } |
| |
| if (getClass(object) === "Array" && getClass(matcher) === "Array") { |
| return arrayContains(object, matcher); |
| } |
| |
| if (matcher && typeof matcher === "object") { |
| var prop; |
| for (prop in matcher) { |
| var value = object[prop]; |
| if (typeof value === "undefined" && |
| typeof object.getAttribute === "function") { |
| value = object.getAttribute(prop); |
| } |
| if (typeof value === "undefined" || !match(value, matcher[prop])) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| throw new Error("Matcher was not a string, a number, a " + |
| "function, a boolean or an object"); |
| }; |
| |
| return { |
| isArguments: isArguments, |
| isElement: isElement, |
| isDate: isDate, |
| isNegZero: isNegZero, |
| identical: identical, |
| deepEqual: deepEqualCyclic, |
| match: match, |
| keys: keys |
| }; |
| }); |
| |
| },{}]},{},[6]); |
