☕️ Classic, reliable, trusted test framework for Node.js and the browser
example
TJ Holowaychuk4baf7a8e5879
diff --git a/_mocha.js b/_mocha.jsnew file mode 100644index 00000000..095a2f9a--- /dev/null+++ b/_mocha.js@@ -0,0 +1,4057 @@++// CommonJS require()++function require(p){+ var path = require.resolve(p)+ , mod = require.modules[path];+ if (!mod) throw new Error('failed to require "' + p + '"');+ if (!mod.exports) {+ mod.exports = {};+ mod.call(mod.exports, mod, mod.exports, require.relative(path));+ }+ return mod.exports;+ }++require.modules = {};++require.resolve = function (path){+ var orig = path+ , reg = path + '.js'+ , index = path + '/index.js';+ return require.modules[reg] && reg+ || require.modules[index] && index+ || orig;+ };++require.register = function (path, fn){+ require.modules[path] = fn;+ };++require.relative = function (parent) {+ return function(p){+ if ('.' != p.charAt(0)) return require(p);++ var path = parent.split('/')+ , segs = p.split('/');+ path.pop();++ for (var i = 0; i < segs.length; i++) {+ var seg = segs[i];+ if ('..' == seg) path.pop();+ else if ('.' != seg) path.push(seg);+ }++ return require(path.join('/'));+ };+ };+++require.register("browser/debug.js", function(module, exports, require){++module.exports = function(type){+ return function(){++ }+};+}); // module: browser/debug.js++require.register("browser/diff.js", function(module, exports, require){++}); // module: browser/diff.js++require.register("browser/events.js", function(module, exports, require){++/**+ * Module exports.+ */++exports.EventEmitter = EventEmitter;++/**+ * Check if `obj` is an array.+ */++function isArray(obj) {+ return '[object Array]' == {}.toString.call(obj);+}++/**+ * Event emitter constructor.+ *+ * @api public+ */++function EventEmitter(){};++/**+ * Adds a listener.+ *+ * @api public+ */++EventEmitter.prototype.on = function (name, fn) {+ if (!this.$events) {+ this.$events = {};+ }++ if (!this.$events[name]) {+ this.$events[name] = fn;+ } else if (isArray(this.$events[name])) {+ this.$events[name].push(fn);+ } else {+ this.$events[name] = [this.$events[name], fn];+ }++ return this;+};++EventEmitter.prototype.addListener = EventEmitter.prototype.on;++/**+ * Adds a volatile listener.+ *+ * @api public+ */++EventEmitter.prototype.once = function (name, fn) {+ var self = this;++ function on () {+ self.removeListener(name, on);+ fn.apply(this, arguments);+ };++ on.listener = fn;+ this.on(name, on);++ return this;+};++/**+ * Removes a listener.+ *+ * @api public+ */++EventEmitter.prototype.removeListener = function (name, fn) {+ if (this.$events && this.$events[name]) {+ var list = this.$events[name];++ if (isArray(list)) {+ var pos = -1;++ for (var i = 0, l = list.length; i < l; i++) {+ if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {+ pos = i;+ break;+ }+ }++ if (pos < 0) {+ return this;+ }++ list.splice(pos, 1);++ if (!list.length) {+ delete this.$events[name];+ }+ } else if (list === fn || (list.listener && list.listener === fn)) {+ delete this.$events[name];+ }+ }++ return this;+};++/**+ * Removes all listeners for an event.+ *+ * @api public+ */++EventEmitter.prototype.removeAllListeners = function (name) {+ if (name === undefined) {+ this.$events = {};+ return this;+ }++ if (this.$events && this.$events[name]) {+ this.$events[name] = null;+ }++ return this;+};++/**+ * Gets all listeners for a certain event.+ *+ * @api public+ */++EventEmitter.prototype.listeners = function (name) {+ if (!this.$events) {+ this.$events = {};+ }++ if (!this.$events[name]) {+ this.$events[name] = [];+ }++ if (!isArray(this.$events[name])) {+ this.$events[name] = [this.$events[name]];+ }++ return this.$events[name];+};++/**+ * Emits an event.+ *+ * @api public+ */++EventEmitter.prototype.emit = function (name) {+ if (!this.$events) {+ return false;+ }++ var handler = this.$events[name];++ if (!handler) {+ return false;+ }++ var args = [].slice.call(arguments, 1);++ if ('function' == typeof handler) {+ handler.apply(this, args);+ } else if (isArray(handler)) {+ var listeners = handler.slice();++ for (var i = 0, l = listeners.length; i < l; i++) {+ listeners[i].apply(this, args);+ }+ } else {+ return false;+ }++ return true;+};+}); // module: browser/events.js++require.register("browser/fs.js", function(module, exports, require){++}); // module: browser/fs.js++require.register("browser/path.js", function(module, exports, require){++}); // module: browser/path.js++require.register("browser/progress.js", function(module, exports, require){++/**+ * Expose `Progress`.+ */++module.exports = Progress;++/**+ * Initialize a new `Progress` indicator.+ */++function Progress() {+ this.percent = 0;+ this.size(0);+ this.fontSize(11);+ this.font('helvetica, arial, sans-serif');+}++/**+ * Set progress size to `n`.+ *+ * @param {Number} n+ * @return {Progress} for chaining+ * @api public+ */++Progress.prototype.size = function(n){+ this._size = n;+ return this;+};++/**+ * Set text to `str`.+ *+ * @param {String} str+ * @return {Progress} for chaining+ * @api public+ */++Progress.prototype.text = function(str){+ this._text = str;+ return this;+};++/**+ * Set font size to `n`.+ *+ * @param {Number} n+ * @return {Progress} for chaining+ * @api public+ */++Progress.prototype.fontSize = function(n){+ this._fontSize = n;+ return this;+};++/**+ * Set font `family`.+ *+ * @param {String} family+ * @return {Progress} for chaining+ */++Progress.prototype.font = function(family){+ this._font = family;+ return this;+};++/**+ * Update percentage to `n`.+ *+ * @param {Number} n+ * @return {Progress} for chaining+ */++Progress.prototype.update = function(n){+ this.percent = n;+ return this;+};++/**+ * Draw on `ctx`.+ *+ * @param {CanvasRenderingContext2d} ctx+ * @return {Progress} for chaining+ */++Progress.prototype.draw = function(ctx){+ var percent = Math.min(this.percent, 100)+ , size = this._size+ , half = size / 2+ , x = half+ , y = half+ , rad = half - 1+ , fontSize = this._fontSize;++ ctx.font = fontSize + 'px ' + this._font;++ var angle = Math.PI * 2 * (percent / 100);+ ctx.clearRect(0, 0, size, size);++ // outer circle+ ctx.strokeStyle = '#9f9f9f';+ ctx.beginPath();+ ctx.arc(x, y, rad, 0, angle, false);+ ctx.stroke();++ // inner circle+ ctx.strokeStyle = '#eee';+ ctx.beginPath();+ ctx.arc(x, y, rad - 1, 0, angle, true);+ ctx.stroke();++ // text+ var text = this._text || (percent | 0) + '%'+ , w = ctx.measureText(text).width;++ ctx.fillText(+ text+ , x - w / 2 + 1+ , y + fontSize / 2 - 1);++ return this;+};++}); // module: browser/progress.js++require.register("browser/tty.js", function(module, exports, require){++exports.isatty = function(){+ return true;+};++exports.getWindowSize = function(){+ return [window.innerHeight, window.innerWidth];+};+}); // module: browser/tty.js++require.register("context.js", function(module, exports, require){++/**+ * Expose `Context`.+ */++module.exports = Context;++/**+ * Initialize a new `Context`.+ *+ * @api private+ */++function Context(){}++/**+ * Set the context `Runnable` to `runnable`.+ *+ * @param {Runnable} runnable+ * @return {Context}+ * @api private+ */++Context.prototype.runnable = function(runnable){+ this._runnable = runnable;+ return this;+};++/**+ * Set test timeout `ms`.+ *+ * @param {Number} ms+ * @return {Context} self+ * @api private+ */++Context.prototype.timeout = function(ms){+ this._runnable.timeout(ms);+ return this;+};++/**+ * Inspect the context void of `._runnable`.+ *+ * @return {String}+ * @api private+ */++Context.prototype.inspect = function(){+ return JSON.stringify(this, function(key, val){+ return '_runnable' == key+ ? undefined+ : val;+ }, 2);+};++}); // module: context.js++require.register("hook.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Runnable = require('./runnable');++/**+ * Expose `Hook`.+ */++module.exports = Hook;++/**+ * Initialize a new `Hook` with the given `title` and callback `fn`.+ *+ * @param {String} title+ * @param {Function} fn+ * @api private+ */++function Hook(title, fn) {+ Runnable.call(this, title, fn);+ this.type = 'hook';+}++/**+ * Inherit from `Runnable.prototype`.+ */++Hook.prototype = new Runnable;+Hook.prototype.constructor = Hook;+++}); // module: hook.js++require.register("interfaces/bdd.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Suite = require('../suite')+ , Test = require('../test');++/**+ * BDD-style interface:+ *+ * describe('Array', function(){+ * describe('#indexOf()', function(){+ * it('should return -1 when not present', function(){+ *+ * });+ *+ * it('should return the index when present', function(){+ *+ * });+ * });+ * });+ *+ */++module.exports = function(suite){+ var suites = [suite];++ suite.on('pre-require', function(context){++ // noop variants++ context.xdescribe = function(){};+ context.xit = function(){};++ /**+ * Execute before running tests.+ */++ context.before = function(fn){+ suites[0].beforeAll(fn);+ };++ /**+ * Execute after running tests.+ */++ context.after = function(fn){+ suites[0].afterAll(fn);+ };++ /**+ * Execute before each test case.+ */++ context.beforeEach = function(fn){+ suites[0].beforeEach(fn);+ };++ /**+ * Execute after each test case.+ */++ context.afterEach = function(fn){+ suites[0].afterEach(fn);+ };++ /**+ * Describe a "suite" with the given `title`+ * and callback `fn` containing nested suites+ * and/or tests.+ */++ context.describe = context.context = function(title, fn){+ var suite = Suite.create(suites[0], title);+ suites.unshift(suite);+ fn();+ suites.shift();+ };++ /**+ * Describe a specification or test-case+ * with the given `title` and callback `fn`+ * acting as a thunk.+ */++ context.it = context.specify = function(title, fn){+ suites[0].addTest(new Test(title, fn));+ };+ });+};++}); // module: interfaces/bdd.js++require.register("interfaces/exports.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Suite = require('../suite')+ , Test = require('../test');++/**+ * TDD-style interface:+ *+ * exports.Array = {+ * '#indexOf()': {+ * 'should return -1 when the value is not present': function(){+ *+ * },+ *+ * 'should return the correct index when the value is present': function(){+ *+ * }+ * }+ * };+ *+ */++module.exports = function(suite){+ var suites = [suite];++ suite.on('require', visit);++ function visit(obj) {+ var suite;+ for (var key in obj) {+ if ('function' == typeof obj[key]) {+ var fn = obj[key];+ switch (key) {+ case 'before':+ suites[0].beforeAll(fn);+ break;+ case 'after':+ suites[0].afterAll(fn);+ break;+ case 'beforeEach':+ suites[0].beforeEach(fn);+ break;+ case 'afterEach':+ suites[0].afterEach(fn);+ break;+ default:+ suites[0].addTest(new Test(key, fn));+ }+ } else {+ var suite = Suite.create(suites[0], key);+ suites.unshift(suite);+ visit(obj[key]);+ suites.shift();+ }+ }+ }+};+}); // module: interfaces/exports.js++require.register("interfaces/index.js", function(module, exports, require){++exports.bdd = require('./bdd');+exports.tdd = require('./tdd');+exports.qunit = require('./qunit');+exports.exports = require('./exports');++}); // module: interfaces/index.js++require.register("interfaces/qunit.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Suite = require('../suite')+ , Test = require('../test');++/**+ * QUnit-style interface:+ *+ * suite('Array');+ *+ * test('#length', function(){+ * var arr = [1,2,3];+ * ok(arr.length == 3);+ * });+ *+ * test('#indexOf()', function(){+ * var arr = [1,2,3];+ * ok(arr.indexOf(1) == 0);+ * ok(arr.indexOf(2) == 1);+ * ok(arr.indexOf(3) == 2);+ * });+ *+ * suite('String');+ *+ * test('#length', function(){+ * ok('foo'.length == 3);+ * });+ *+ */++module.exports = function(suite){+ var suites = [suite];++ suite.on('pre-require', function(context){++ /**+ * Execute before running tests.+ */++ context.before = function(fn){+ suites[0].beforeAll(fn);+ };++ /**+ * Execute after running tests.+ */++ context.after = function(fn){+ suites[0].afterAll(fn);+ };++ /**+ * Execute before each test case.+ */++ context.beforeEach = function(fn){+ suites[0].beforeEach(fn);+ };++ /**+ * Execute after each test case.+ */++ context.afterEach = function(fn){+ suites[0].afterEach(fn);+ };++ /**+ * Describe a "suite" with the given `title`.+ */++ context.suite = function(title){+ if (suites.length > 1) suites.shift();+ var suite = Suite.create(suites[0], title);+ suites.unshift(suite);+ };++ /**+ * Describe a specification or test-case+ * with the given `title` and callback `fn`+ * acting as a thunk.+ */++ context.test = function(title, fn){+ suites[0].addTest(new Test(title, fn));+ };+ });+};++}); // module: interfaces/qunit.js++require.register("interfaces/tdd.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Suite = require('../suite')+ , Test = require('../test');++/**+ * TDD-style interface:+ *+ * suite('Array', function(){+ * suite('#indexOf()', function(){+ * suiteSetup(function(){+ *+ * });+ *+ * test('should return -1 when not present', function(){+ *+ * });+ *+ * test('should return the index when present', function(){+ *+ * });+ *+ * suiteTeardown(function(){+ *+ * });+ * });+ * });+ *+ */++module.exports = function(suite){+ var suites = [suite];++ suite.on('pre-require', function(context){++ /**+ * Execute before each test case.+ */++ context.setup = function(fn){+ suites[0].beforeEach(fn);+ };++ /**+ * Execute after each test case.+ */++ context.teardown = function(fn){+ suites[0].afterEach(fn);+ };++ /**+ * Execute before the suite.+ */++ context.suiteSetup = function(fn){+ suites[0].beforeAll(fn);+ };++ /**+ * Execute after the suite.+ */++ context.suiteTeardown = function(fn){+ suites[0].afterAll(fn);+ };++ /**+ * Describe a "suite" with the given `title`+ * and callback `fn` containing nested suites+ * and/or tests.+ */++ context.suite = function(title, fn){+ var suite = Suite.create(suites[0], title);+ suites.unshift(suite);+ fn();+ suites.shift();+ };++ /**+ * Describe a specification or test-case+ * with the given `title` and callback `fn`+ * acting as a thunk.+ */++ context.test = function(title, fn){+ suites[0].addTest(new Test(title, fn));+ };+ });+};++}); // module: interfaces/tdd.js++require.register("mocha.js", function(module, exports, require){+/*!+ * mocha+ * Copyright(c) 2011 TJ Holowaychuk <[email protected]>+ * MIT Licensed+ */++/**+ * Module dependencies.+ */++var path = require('browser/path');++/**+ * Expose `Mocha`.+ */++exports = module.exports = Mocha;++/**+ * Library version.+ */++exports.version = '1.1.0';++/**+ * Expose internals.+ */++exports.utils = require('./utils');+exports.interfaces = require('./interfaces');+exports.reporters = require('./reporters');+exports.Runnable = require('./runnable');+exports.Context = require('./context');+exports.Runner = require('./runner');+exports.Suite = require('./suite');+exports.Hook = require('./hook');+exports.Test = require('./test');++/**+ * Return image `name` path.+ *+ * @param {String} name+ * @return {String}+ * @api private+ */++function image(name) {+ return __dirname + '/../images/' + name + '.png';+}++/**+ * Setup mocha with `options`.+ *+ * Options:+ *+ * - `ui` name "bdd", "tdd", "exports" etc+ * - `reporter` reporter instance, defaults to `mocha.reporters.Dot`+ * - `globals` array of accepted globals+ * - `timeout` timeout in milliseconds+ * - `ignoreLeaks` ignore global leaks+ * - `grep` string or regexp to filter tests with+ *+ * @param {Object} options+ * @api public+ */++function Mocha(options) {+ options = options || {};+ this.files = [];+ this.options = options;+ this.grep(options.grep);+ this.suite = new exports.Suite('', new exports.Context);+ this.ui(options.ui);+ this.reporter(options.reporter);+ if (options.timeout) this.suite.timeout(options.timeout);+}++/**+ * Add test `file`.+ *+ * @param {String} file+ * @api public+ */++Mocha.prototype.addFile = function(file){+ this.files.push(file);+ return this;+};++/**+ * Set reporter to `name`, defaults to "dot".+ *+ * @param {String} name+ * @api public+ */++Mocha.prototype.reporter = function(name){+ name = name || 'dot';+ this._reporter = require('./reporters/' + name);+ if (!this._reporter) throw new Error('invalid reporter "' + name + '"');+ return this;+};++/**+ * Set test UI `name`, defaults to "bdd".+ *+ * @param {String} bdd+ * @api public+ */++Mocha.prototype.ui = function(name){+ name = name || 'bdd';+ this._ui = exports.interfaces[name];+ if (!this._ui) throw new Error('invalid interface "' + name + '"');+ this._ui = this._ui(this.suite);+ return this;+};++/**+ * Load registered files.+ *+ * @api private+ */++Mocha.prototype.loadFiles = function(){+ var suite = this.suite;+ this.files.forEach(function(file){+ file = path.resolve(file);+ suite.emit('pre-require', global, file);+ suite.emit('require', require(file), file);+ suite.emit('post-require', global, file);+ });+};++/**+ * Enable growl support.+ *+ * @api private+ */++Mocha.prototype.growl = function(runner, reporter) {+ var notify = require('growl');++ runner.on('end', function(){+ var stats = reporter.stats;+ if (stats.failures) {+ var msg = stats.failures + ' of ' + runner.total + ' tests failed';+ notify(msg, { name: 'mocha', title: 'Failed', image: image('error') });+ } else {+ notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {+ name: 'mocha'+ , title: 'Passed'+ , image: image('ok')+ });+ }+ });+};++/**+ * Add regexp to grep for to the options object+ *+ * @param {RegExp} or {String} re+ * @return {Mocha}+ * @api public+ */++Mocha.prototype.grep = function(re){+ this.options.grep = 'string' == typeof re+ ? new RegExp(re)+ : re;+ return this;+};++/**+ * Run tests and invoke `fn()` when complete.+ *+ * @param {Function} fn+ * @return {Runner}+ * @api public+ */++Mocha.prototype.run = function(fn){+ this.loadFiles();+ var suite = this.suite;+ var options = this.options;+ var runner = new exports.Runner(suite);+ var reporter = new this._reporter(runner);+ runner.ignoreLeaks = options.ignoreLeaks;+ if (options.grep) runner.grep(options.grep);+ if (options.globals) runner.globals(options.globals);+ if (options.growl) this.growl(runner, reporter);+ return runner.run(fn);+};++}); // module: mocha.js++require.register("reporters/base.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var tty = require('browser/tty')+ , diff = require('browser/diff');++/**+ * Save timer references to avoid Sinon interfering (see GH-237).+ */++var Date = global.Date+ , setTimeout = global.setTimeout+ , setInterval = global.setInterval+ , clearTimeout = global.clearTimeout+ , clearInterval = global.clearInterval;++/**+ * Check if both stdio streams are associated with a tty.+ */++var isatty = tty.isatty(1) && tty.isatty(2);++/**+ * Expose `Base`.+ */++exports = module.exports = Base;++/**+ * Enable coloring by default.+ */++exports.useColors = isatty;++/**+ * Default color map.+ */++exports.colors = {+ 'pass': 90+ , 'fail': 31+ , 'bright pass': 92+ , 'bright fail': 91+ , 'bright yellow': 93+ , 'pending': 36+ , 'suite': 0+ , 'error title': 0+ , 'error message': 31+ , 'error stack': 90+ , 'checkmark': 32+ , 'fast': 90+ , 'medium': 33+ , 'slow': 31+ , 'green': 32+ , 'light': 90+ , 'diff gutter': 90+ , 'diff added': 42+ , 'diff removed': 41+};++/**+ * Color `str` with the given `type`,+ * allowing colors to be disabled,+ * as well as user-defined color+ * schemes.+ *+ * @param {String} type+ * @param {String} str+ * @return {String}+ * @api private+ */++var color = exports.color = function(type, str) {+ if (!exports.useColors) return str;+ return '\033[' + exports.colors[type] + 'm' + str + '\033[0m';+};++/**+ * Expose term window size, with some+ * defaults for when stderr is not a tty.+ */++exports.window = {+ width: isatty+ ? process.stdout.getWindowSize+ ? process.stdout.getWindowSize(1)[0]+ : tty.getWindowSize()[1]+ : 75+};++/**+ * Expose some basic cursor interactions+ * that are common among reporters.+ */++exports.cursor = {+ hide: function(){+ process.stdout.write('\033[?25l');+ },++ show: function(){+ process.stdout.write('\033[?25h');+ },++ deleteLine: function(){+ process.stdout.write('\033[2K');+ },++ beginningOfLine: function(){+ process.stdout.write('\033[0G');+ },++ CR: function(){+ exports.cursor.deleteLine();+ exports.cursor.beginningOfLine();+ }+};++/**+ * A test is considered slow if it+ * exceeds the following value in milliseconds.+ */++exports.slow = 75;++/**+ * Outut the given `failures` as a list.+ *+ * @param {Array} failures+ * @api public+ */++exports.list = function(failures){+ console.error();+ failures.forEach(function(test, i){+ // format+ var fmt = color('error title', ' %s) %s:\n')+ + color('error message', ' %s')+ + color('error stack', '\n%s\n');++ // msg+ var err = test.err+ , message = err.message || ''+ , stack = err.stack || message+ , index = stack.indexOf(message) + message.length+ , msg = stack.slice(0, index)+ , actual = err.actual+ , expected = err.expected;++ // actual / expected diff+ if ('string' == typeof actual && 'string' == typeof expected) {+ var len = Math.max(actual.length, expected.length);++ if (len < 20) msg = errorDiff(err, 'Chars');+ else msg = errorDiff(err, 'Words');++ // linenos+ var lines = msg.split('\n');+ if (lines.length > 4) {+ var width = String(lines.length).length;+ msg = lines.map(function(str, i){+ return pad(++i, width) + ' |' + ' ' + str;+ }).join('\n');+ }++ // legend+ msg = '\n'+ + color('diff removed', 'actual')+ + ' '+ + color('diff added', 'expected')+ + '\n\n'+ + msg+ + '\n';++ // indent+ msg = msg.replace(/^/gm, ' ');++ fmt = color('error title', ' %s) %s:\n%s')+ + color('error stack', '\n%s\n');+ }++ // indent stack trace without msg+ stack = stack.slice(index ? index + 1 : index)+ .replace(/^/gm, ' ');++ console.error(fmt, (i + 1), test.fullTitle(), msg, stack);+ });+};++/**+ * Initialize a new `Base` reporter.+ *+ * All other reporters generally+ * inherit from this reporter, providing+ * stats such as test duration, number+ * of tests passed / failed etc.+ *+ * @param {Runner} runner+ * @api public+ */++function Base(runner) {+ var self = this+ , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 }+ , failures = this.failures = [];++ if (!runner) return;+ this.runner = runner;++ runner.on('start', function(){+ stats.start = new Date;+ });++ runner.on('suite', function(suite){+ stats.suites = stats.suites || 0;+ suite.root || stats.suites++;+ });++ runner.on('test end', function(test){+ stats.tests = stats.tests || 0;+ stats.tests++;+ });++ runner.on('pass', function(test){+ stats.passes = stats.passes || 0;++ var medium = exports.slow / 2;+ test.speed = test.duration > exports.slow+ ? 'slow'+ : test.duration > medium+ ? 'medium'+ : 'fast';++ stats.passes++;+ });++ runner.on('fail', function(test, err){+ stats.failures = stats.failures || 0;+ stats.failures++;+ test.err = err;+ failures.push(test);+ });++ runner.on('end', function(){+ stats.end = new Date;+ stats.duration = new Date - stats.start;+ });++ runner.on('pending', function(){+ stats.pending++;+ });+}++/**+ * Output common epilogue used by many of+ * the bundled reporters.+ *+ * @api public+ */++Base.prototype.epilogue = function(){+ var stats = this.stats+ , fmt+ , tests;++ console.log();++ function pluralize(n) {+ return 1 == n ? 'test' : 'tests';+ }++ // failure+ if (stats.failures) {+ fmt = color('bright fail', ' ✖')+ + color('fail', ' %d of %d %s failed')+ + color('light', ':')++ console.error(fmt,+ stats.failures,+ this.runner.total,+ pluralize(this.runner.total));++ Base.list(this.failures);+ console.error();+ return;+ }++ // pass+ fmt = color('bright pass', ' ✔')+ + color('green', ' %d %s complete')+ + color('light', ' (%dms)');++ console.log(fmt,+ stats.tests || 0,+ pluralize(stats.tests),+ stats.duration);++ // pending+ if (stats.pending) {+ fmt = color('pending', ' •')+ + color('pending', ' %d %s pending');++ console.log(fmt, stats.pending, pluralize(stats.pending));+ }++ console.log();+};++/**+ * Pad the given `str` to `len`.+ *+ * @param {String} str+ * @param {String} len+ * @return {String}+ * @api private+ */++function pad(str, len) {+ str = String(str);+ return Array(len - str.length + 1).join(' ') + str;+}++/**+ * Return a character diff for `err`.+ *+ * @param {Error} err+ * @return {String}+ * @api private+ */++function errorDiff(err, type) {+ return diff['diff' + type](err.actual, err.expected).map(function(str){+ if (/^(\n+)$/.test(str.value)) str.value = Array(++RegExp.$1.length).join('<newline>');+ if (str.added) return colorLines('diff added', str.value);+ if (str.removed) return colorLines('diff removed', str.value);+ return str.value;+ }).join('');+}++/**+ * Color lines for `str`, using the color `name`.+ *+ * @param {String} name+ * @param {String} str+ * @return {String}+ * @api private+ */++function colorLines(name, str) {+ return str.split('\n').map(function(str){+ return color(name, str);+ }).join('\n');+}++}); // module: reporters/base.js++require.register("reporters/doc.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , utils = require('../utils');++/**+ * Expose `Doc`.+ */++exports = module.exports = Doc;++/**+ * Initialize a new `Doc` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Doc(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total+ , indents = 2;++ function indent() {+ return Array(indents).join(' ');+ }++ runner.on('suite', function(suite){+ if (suite.root) return;+ ++indents;+ console.log('%s<section class="suite">', indent());+ ++indents;+ console.log('%s<h1>%s</h1>', indent(), suite.title);+ console.log('%s<dl>', indent());+ });++ runner.on('suite end', function(suite){+ if (suite.root) return;+ console.log('%s</dl>', indent());+ --indents;+ console.log('%s</section>', indent());+ --indents;+ });++ runner.on('pass', function(test){+ console.log('%s <dt>%s</dt>', indent(), test.title);+ var code = utils.escape(utils.clean(test.fn.toString()));+ console.log('%s <dd><pre><code>%s</code></pre></dd>', indent(), code);+ });+}++}); // module: reporters/doc.js++require.register("reporters/dot.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , color = Base.color;++/**+ * Expose `Dot`.+ */++exports = module.exports = Dot;++/**+ * Initialize a new `Dot` matrix test reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Dot(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , width = Base.window.width * .75 | 0+ , n = 0;++ runner.on('start', function(){+ process.stdout.write('\n ');+ });++ runner.on('pending', function(test){+ process.stdout.write(color('pending', '.'));+ });++ runner.on('pass', function(test){+ if (++n % width == 0) process.stdout.write('\n ');+ if ('slow' == test.speed) {+ process.stdout.write(color('bright yellow', '.'));+ } else {+ process.stdout.write(color(test.speed, '.'));+ }+ });++ runner.on('fail', function(test, err){+ if (++n % width == 0) process.stdout.write('\n ');+ process.stdout.write(color('fail', '.'));+ });++ runner.on('end', function(){+ console.log();+ self.epilogue();+ });+}++/**+ * Inherit from `Base.prototype`.+ */++Dot.prototype = new Base;+Dot.prototype.constructor = Dot;++}); // module: reporters/dot.js++require.register("reporters/html-cov.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var JSONCov = require('./json-cov')+ , fs = require('browser/fs');++/**+ * Expose `HTMLCov`.+ */++exports = module.exports = HTMLCov;++/**+ * Initialize a new `JsCoverage` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function HTMLCov(runner) {+ var jade = require('jade')+ , file = __dirname + '/templates/coverage.jade'+ , str = fs.readFileSync(file, 'utf8')+ , fn = jade.compile(str, { filename: file })+ , self = this;++ JSONCov.call(this, runner, false);++ runner.on('end', function(){+ process.stdout.write(fn({+ cov: self.cov+ , coverageClass: coverageClass+ }));+ });+}++/**+ * Return coverage class for `n`.+ *+ * @return {String}+ * @api private+ */++function coverageClass(n) {+ if (n >= 75) return 'high';+ if (n >= 50) return 'medium';+ if (n >= 25) return 'low';+ return 'terrible';+}+}); // module: reporters/html-cov.js++require.register("reporters/html.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , utils = require('../utils')+ , Progress = require('../browser/progress')+ , escape = utils.escape;++/**+ * Save timer references to avoid Sinon interfering (see GH-237).+ */++var Date = global.Date+ , setTimeout = global.setTimeout+ , setInterval = global.setInterval+ , clearTimeout = global.clearTimeout+ , clearInterval = global.clearInterval;++/**+ * Expose `Doc`.+ */++exports = module.exports = HTML;++/**+ * Stats template.+ */++var statsTemplate = '<ul id="stats">'+ + '<li class="progress"><canvas width="40" height="40"></canvas></li>'+ + '<li class="passes">passes: <em>0</em></li>'+ + '<li class="failures">failures: <em>0</em></li>'+ + '<li class="duration">duration: <em>0</em>s</li>'+ + '</ul>';++/**+ * Initialize a new `Doc` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function HTML(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total+ , root = document.getElementById('mocha')+ , stat = fragment(statsTemplate)+ , items = stat.getElementsByTagName('li')+ , passes = items[1].getElementsByTagName('em')[0]+ , failures = items[2].getElementsByTagName('em')[0]+ , duration = items[3].getElementsByTagName('em')[0]+ , canvas = stat.getElementsByTagName('canvas')[0]+ , report = fragment('<ul id="report"></ul>')+ , stack = [report]+ , progress+ , ctx++ if (canvas.getContext) {+ ctx = canvas.getContext('2d');+ progress = new Progress;+ }++ if (!root) return error('#mocha div missing, add it to your document');++ root.appendChild(stat);+ root.appendChild(report);++ if (progress) progress.size(40);++ runner.on('suite', function(suite){+ if (suite.root) return;++ // suite+ var url = location.protocol + '//' + location.host + location.pathname + '?grep=^' + utils.escapeRegexp(suite.fullTitle());+ var el = fragment('<li class="suite"><h1><a href="%s">%s</a></h1></li>', url, suite.title);++ // container+ stack[0].appendChild(el);+ stack.unshift(document.createElement('ul'));+ el.appendChild(stack[0]);+ });++ runner.on('suite end', function(suite){+ if (suite.root) return;+ stack.shift();+ });++ runner.on('fail', function(test, err){+ if ('hook' == test.type || err.uncaught) runner.emit('test end', test);+ });++ runner.on('test end', function(test){+ // TODO: add to stats+ var percent = stats.tests / total * 100 | 0;+ if (progress) progress.update(percent).draw(ctx);++ // update stats+ var ms = new Date - stats.start;+ text(passes, stats.passes);+ text(failures, stats.failures);+ text(duration, (ms / 1000).toFixed(2));++ // test+ if ('passed' == test.state) {+ var el = fragment('<li class="test pass %e"><h2>%e<span class="duration">%ems</span></h2></li>', test.speed, test.title, test.duration);+ } else if (test.pending) {+ var el = fragment('<li class="test pass pending"><h2>%e</h2></li>', test.title);+ } else {+ var el = fragment('<li class="test fail"><h2>%e</h2></li>', test.title);+ var str = test.err.stack || test.err.toString();++ // FF / Opera do not add the message+ if (!~str.indexOf(test.err.message)) {+ str = test.err.message + '\n' + str;+ }++ // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we+ // check for the result of the stringifying.+ if ('[object Error]' == str) str = test.err.message;++ // Safari doesn't give you a stack. Let's at least provide a source line.+ if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {+ str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")";+ }++ el.appendChild(fragment('<pre class="error">%e</pre>', str));+ }++ // toggle code+ var h2 = el.getElementsByTagName('h2')[0];++ on(h2, 'click', function(){+ pre.style.display = 'none' == pre.style.display+ ? 'block'+ : 'none';+ });++ // code+ // TODO: defer+ if (!test.pending) {+ var pre = fragment('<pre><code>%e</code></pre>', utils.clean(test.fn.toString()));+ el.appendChild(pre);+ pre.style.display = 'none';+ }++ stack[0].appendChild(el);+ });+}++/**+ * Display error `msg`.+ */++function error(msg) {+ document.body.appendChild(fragment('<div id="error">%s</div>', msg));+}++/**+ * Return a DOM fragment from `html`.+ */++function fragment(html) {+ var args = arguments+ , div = document.createElement('div')+ , i = 1;++ div.innerHTML = html.replace(/%([se])/g, function(_, type){+ switch (type) {+ case 's': return String(args[i++]);+ case 'e': return escape(args[i++]);+ }+ });++ return div.firstChild;+}++/**+ * Set `el` text to `str`.+ */++function text(el, str) {+ if (el.textContent) {+ el.textContent = str;+ } else {+ el.innerText = str;+ }+}++/**+ * Listen on `event` with callback `fn`.+ */++function on(el, event, fn) {+ if (el.addEventListener) {+ el.addEventListener(event, fn, false);+ } else {+ el.attachEvent('on' + event, fn);+ }+}+}); // module: reporters/html.js++require.register("reporters/index.js", function(module, exports, require){++exports.Base = require('./base');+exports.Dot = require('./dot');+exports.Doc = require('./doc');+exports.TAP = require('./tap');+exports.JSON = require('./json');+exports.HTML = require('./html');+exports.List = require('./list');+exports.Min = require('./min');+exports.Spec = require('./spec');+exports.Progress = require('./progress');+exports.Landing = require('./landing');+exports.JSONCov = require('./json-cov');+exports.HTMLCov = require('./html-cov');+exports.JSONStream = require('./json-stream');+exports.XUnit = require('./xunit')+exports.Teamcity = require('./teamcity')++}); // module: reporters/index.js++require.register("reporters/json-cov.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base');++/**+ * Expose `JSONCov`.+ */++exports = module.exports = JSONCov;++/**+ * Initialize a new `JsCoverage` reporter.+ *+ * @param {Runner} runner+ * @param {Boolean} output+ * @api public+ */++function JSONCov(runner, output) {+ var self = this+ , output = 1 == arguments.length ? true : output;++ Base.call(this, runner);++ var tests = []+ , failures = []+ , passes = [];++ runner.on('test end', function(test){+ tests.push(test);+ });++ runner.on('pass', function(test){+ passes.push(test);+ });++ runner.on('fail', function(test){+ failures.push(test);+ });++ runner.on('end', function(){+ var cov = global._$jscoverage || {};+ var result = self.cov = map(cov);+ result.stats = self.stats;+ result.tests = tests.map(clean);+ result.failures = failures.map(clean);+ result.passes = passes.map(clean);+ if (!output) return;+ process.stdout.write(JSON.stringify(result, null, 2 ));+ });+}++/**+ * Map jscoverage data to a JSON structure+ * suitable for reporting.+ *+ * @param {Object} cov+ * @return {Object}+ * @api private+ */++function map(cov) {+ var ret = {+ instrumentation: 'node-jscoverage'+ , sloc: 0+ , hits: 0+ , misses: 0+ , coverage: 0+ , files: []+ };++ for (var filename in cov) {+ var data = coverage(filename, cov[filename]);+ ret.files.push(data);+ ret.hits += data.hits;+ ret.misses += data.misses;+ ret.sloc += data.sloc;+ }++ if (ret.sloc > 0) {+ ret.coverage = (ret.hits / ret.sloc) * 100;+ }++ return ret;+};++/**+ * Map jscoverage data for a single source file+ * to a JSON structure suitable for reporting.+ *+ * @param {String} filename name of the source file+ * @param {Object} data jscoverage coverage data+ * @return {Object}+ * @api private+ */++function coverage(filename, data) {+ var ret = {+ filename: filename,+ coverage: 0,+ hits: 0,+ misses: 0,+ sloc: 0,+ source: {}+ };++ data.source.forEach(function(line, num){+ num++;++ if (data[num] === 0) {+ ret.misses++;+ ret.sloc++;+ } else if (data[num] !== undefined) {+ ret.hits++;+ ret.sloc++;+ }++ ret.source[num] = {+ source: line+ , coverage: data[num] === undefined+ ? ''+ : data[num]+ };+ });++ ret.coverage = ret.hits / ret.sloc * 100;++ return ret;+}++/**+ * Return a plain-object representation of `test`+ * free of cyclic properties etc.+ *+ * @param {Object} test+ * @return {Object}+ * @api private+ */++function clean(test) {+ return {+ title: test.title+ , fullTitle: test.fullTitle()+ , duration: test.duration+ }+}++}); // module: reporters/json-cov.js++require.register("reporters/json-stream.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , color = Base.color;++/**+ * Expose `List`.+ */++exports = module.exports = List;++/**+ * Initialize a new `List` test reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function List(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total;++ runner.on('start', function(){+ console.log(JSON.stringify(['start', { total: total }]));+ });++ runner.on('pass', function(test){+ console.log(JSON.stringify(['pass', clean(test)]));+ });++ runner.on('fail', function(test, err){+ console.log(JSON.stringify(['fail', clean(test)]));+ });++ runner.on('end', function(){+ process.stdout.write(JSON.stringify(['end', self.stats]));+ });+}++/**+ * Return a plain-object representation of `test`+ * free of cyclic properties etc.+ *+ * @param {Object} test+ * @return {Object}+ * @api private+ */++function clean(test) {+ return {+ title: test.title+ , fullTitle: test.fullTitle()+ , duration: test.duration+ }+}+}); // module: reporters/json-stream.js++require.register("reporters/json.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `JSON`.+ */++exports = module.exports = JSONReporter;++/**+ * Initialize a new `JSON` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function JSONReporter(runner) {+ var self = this;+ Base.call(this, runner);++ var tests = []+ , failures = []+ , passes = [];++ runner.on('test end', function(test){+ tests.push(test);+ });++ runner.on('pass', function(test){+ passes.push(test);+ });++ runner.on('fail', function(test){+ failures.push(test);+ });++ runner.on('end', function(){+ var obj = {+ stats: self.stats+ , tests: tests.map(clean)+ , failures: failures.map(clean)+ , passes: passes.map(clean)+ };++ process.stdout.write(JSON.stringify(obj, null, 2));+ });+}++/**+ * Return a plain-object representation of `test`+ * free of cyclic properties etc.+ *+ * @param {Object} test+ * @return {Object}+ * @api private+ */++function clean(test) {+ return {+ title: test.title+ , fullTitle: test.fullTitle()+ , duration: test.duration+ }+}+}); // module: reporters/json.js++require.register("reporters/landing.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `Landing`.+ */++exports = module.exports = Landing;++/**+ * Airplane color.+ */++Base.colors.plane = 0;++/**+ * Airplane crash color.+ */++Base.colors['plane crash'] = 31;++/**+ * Runway color.+ */++Base.colors.runway = 90;++/**+ * Initialize a new `Landing` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Landing(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , width = Base.window.width * .75 | 0+ , total = runner.total+ , stream = process.stdout+ , plane = color('plane', '✈')+ , crashed = -1+ , n = 0;++ function runway() {+ var buf = Array(width).join('-');+ return ' ' + color('runway', buf);+ }++ runner.on('start', function(){+ stream.write('\n ');+ cursor.hide();+ });++ runner.on('test end', function(test){+ // check if the plane crashed+ var col = -1 == crashed+ ? width * ++n / total | 0+ : crashed;++ // show the crash+ if ('failed' == test.state) {+ plane = color('plane crash', '✈');+ crashed = col;+ }++ // render landing strip+ stream.write('\033[4F\n\n');+ stream.write(runway());+ stream.write('\n ');+ stream.write(color('runway', Array(col).join('⋅')));+ stream.write(plane)+ stream.write(color('runway', Array(width - col).join('⋅') + '\n'));+ stream.write(runway());+ stream.write('\033[0m');+ });++ runner.on('end', function(){+ cursor.show();+ console.log();+ self.epilogue();+ });+}++/**+ * Inherit from `Base.prototype`.+ */++Landing.prototype = new Base;+Landing.prototype.constructor = Landing;++}); // module: reporters/landing.js++require.register("reporters/list.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `List`.+ */++exports = module.exports = List;++/**+ * Initialize a new `List` test reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function List(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , n = 0;++ runner.on('start', function(){+ console.log();+ });++ runner.on('test', function(test){+ process.stdout.write(color('pass', ' ' + test.fullTitle() + ': '));+ });++ runner.on('pending', function(test){+ var fmt = color('checkmark', ' -')+ + color('pending', ' %s');+ console.log(fmt, test.fullTitle());+ });++ runner.on('pass', function(test){+ var fmt = color('checkmark', ' ✓')+ + color('pass', ' %s: ')+ + color(test.speed, '%dms');+ cursor.CR();+ console.log(fmt, test.fullTitle(), test.duration);+ });++ runner.on('fail', function(test, err){+ cursor.CR();+ console.log(color('fail', ' %d) %s'), ++n, test.fullTitle());+ });++ runner.on('end', self.epilogue.bind(self));+}++/**+ * Inherit from `Base.prototype`.+ */++List.prototype = new Base;+List.prototype.constructor = List;+++}); // module: reporters/list.js++require.register("reporters/markdown.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , utils = require('../utils');++/**+ * Expose `Markdown`.+ */++exports = module.exports = Markdown;++/**+ * Initialize a new `Markdown` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Markdown(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total+ , level = 0+ , buf = '';++ function title(str) {+ return Array(level).join('#') + ' ' + str;+ }++ function indent() {+ return Array(level).join(' ');+ }++ function mapTOC(suite, obj) {+ var ret = obj;+ obj = obj[suite.title] = obj[suite.title] || { suite: suite };+ suite.suites.forEach(function(suite){+ mapTOC(suite, obj);+ });+ return ret;+ }++ function stringifyTOC(obj, level) {+ ++level;+ var buf = '';+ var link;+ for (var key in obj) {+ if ('suite' == key) continue;+ if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\n';+ if (key) buf += Array(level).join(' ') + link;+ buf += stringifyTOC(obj[key], level);+ }+ --level;+ return buf;+ }++ function generateTOC(suite) {+ var obj = mapTOC(suite, {});+ return stringifyTOC(obj, 0);+ }++ generateTOC(runner.suite);++ runner.on('suite', function(suite){+ ++level;+ var slug = utils.slug(suite.fullTitle());+ buf += '<a name="' + slug + '" />' + '\n';+ buf += title(suite.title) + '\n';+ });++ runner.on('suite end', function(suite){+ --level;+ });++ runner.on('pass', function(test){+ var code = utils.clean(test.fn.toString());+ buf += test.title + '.\n';+ buf += '\n```js';+ buf += code + '\n';+ buf += '```\n\n';+ });++ runner.on('end', function(){+ process.stdout.write('# TOC\n');+ process.stdout.write(generateTOC(runner.suite));+ process.stdout.write(buf);+ });+}+}); // module: reporters/markdown.js++require.register("reporters/min.js", function(module, exports, require){+/**+ * Module dependencies.+ */++var Base = require('./base');++/**+ * Expose `Min`.+ */++exports = module.exports = Min;++/**+ * Initialize a new `Min` minimal test reporter (best used with --watch).+ *+ * @param {Runner} runner+ * @api public+ */++function Min(runner) {+ Base.call(this, runner);++ runner.on('start', function(){+ // clear screen+ process.stdout.write('\033[2J');+ // set cursor position+ process.stdout.write('\033[1;3H');+ });++ runner.on('end', this.epilogue.bind(this));+}++/**+ * Inherit from `Base.prototype`.+ */++Min.prototype = new Base;+Min.prototype.constructor = Min;++}); // module: reporters/min.js++require.register("reporters/progress.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `Progress`.+ */++exports = module.exports = Progress;++/**+ * General progress bar color.+ */++Base.colors.progress = 90;++/**+ * Initialize a new `Progress` bar test reporter.+ *+ * @param {Runner} runner+ * @param {Object} options+ * @api public+ */++function Progress(runner, options) {+ Base.call(this, runner);++ var self = this+ , options = options || {}+ , stats = this.stats+ , width = Base.window.width * .50 | 0+ , total = runner.total+ , complete = 0+ , max = Math.max;++ // default chars+ options.open = options.open || '[';+ options.complete = options.complete || '▬';+ options.incomplete = options.incomplete || '⋅';+ options.close = options.close || ']';+ options.verbose = false;++ // tests started+ runner.on('start', function(){+ console.log();+ cursor.hide();+ });++ // tests complete+ runner.on('test end', function(){+ complete++;+ var incomplete = total - complete+ , percent = complete / total+ , n = width * percent | 0+ , i = width - n;++ cursor.CR();+ process.stdout.write('\033[J');+ process.stdout.write(color('progress', ' ' + options.open));+ process.stdout.write(Array(n).join(options.complete));+ process.stdout.write(Array(i).join(options.incomplete));+ process.stdout.write(color('progress', options.close));+ if (options.verbose) {+ process.stdout.write(color('progress', ' ' + complete + ' of ' + total));+ }+ });++ // tests are complete, output some stats+ // and the failures if any+ runner.on('end', function(){+ cursor.show();+ console.log();+ self.epilogue();+ });+}++/**+ * Inherit from `Base.prototype`.+ */++Progress.prototype = new Base;+Progress.prototype.constructor = Progress;+++}); // module: reporters/progress.js++require.register("reporters/spec.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `Spec`.+ */++exports = module.exports = Spec;++/**+ * Initialize a new `Spec` test reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Spec(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , indents = 0+ , n = 0;++ function indent() {+ return Array(indents).join(' ')+ }++ runner.on('start', function(){+ console.log();+ });++ runner.on('suite', function(suite){+ ++indents;+ console.log(color('suite', '%s%s'), indent(), suite.title);+ });++ runner.on('suite end', function(suite){+ --indents;+ if (1 == indents) console.log();+ });++ runner.on('test', function(test){+ process.stdout.write(indent() + color('pass', ' ◦ ' + test.title + ': '));+ });++ runner.on('pending', function(test){+ var fmt = indent() + color('pending', ' - %s');+ console.log(fmt, test.title);+ });++ runner.on('pass', function(test){+ if ('fast' == test.speed) {+ var fmt = indent()+ + color('checkmark', ' ✓')+ + color('pass', ' %s ');+ cursor.CR();+ console.log(fmt, test.title);+ } else {+ var fmt = indent()+ + color('checkmark', ' ✓')+ + color('pass', ' %s ')+ + color(test.speed, '(%dms)');+ cursor.CR();+ console.log(fmt, test.title, test.duration);+ }+ });++ runner.on('fail', function(test, err){+ cursor.CR();+ console.log(indent() + color('fail', ' %d) %s'), ++n, test.title);+ });++ runner.on('end', self.epilogue.bind(self));+}++/**+ * Inherit from `Base.prototype`.+ */++Spec.prototype = new Base;+Spec.prototype.constructor = Spec;+++}); // module: reporters/spec.js++require.register("reporters/tap.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `TAP`.+ */++exports = module.exports = TAP;++/**+ * Initialize a new `TAP` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function TAP(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total+ , n = 1;++ runner.on('start', function(){+ console.log('%d..%d', 1, total);+ });++ runner.on('test end', function(){+ ++n;+ });++ runner.on('pending', function(test){+ console.log('ok %d %s # SKIP -', n, title(test));+ });++ runner.on('pass', function(test){+ console.log('ok %d %s', n, title(test));+ });++ runner.on('fail', function(test, err){+ console.log('not ok %d %s', n, title(test));+ console.log(err.stack.replace(/^/gm, ' '));+ });+}++/**+ * Return a TAP-safe title of `test`+ *+ * @param {Object} test+ * @return {String}+ * @api private+ */++function title(test) {+ return test.fullTitle().replace(/#/g, '');+}++}); // module: reporters/tap.js++require.register("reporters/teamcity.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base');++/**+ * Expose `Teamcity`.+ */++exports = module.exports = Teamcity;++/**+ * Initialize a new `Teamcity` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Teamcity(runner) {+ Base.call(this, runner);+ var stats = this.stats;++ runner.on('start', function() {+ console.log("##teamcity[testSuiteStarted name='mocha.suite']");+ });++ runner.on('test', function(test) {+ console.log("##teamcity[testStarted name='" + escape(test.fullTitle()) + "']");+ });++ runner.on('fail', function(test, err) {+ console.log("##teamcity[testFailed name='" + escape(test.fullTitle()) + "' message='" + escape(err.message) + "']");+ });++ runner.on('pending', function(test) {+ console.log("##teamcity[testIgnored name='" + escape(test.fullTitle()) + "' message='pending']");+ });++ runner.on('test end', function(test) {+ console.log("##teamcity[testFinished name='" + escape(test.fullTitle()) + "' duration='" + test.duration + "']");+ });++ runner.on('end', function() {+ console.log("##teamcity[testSuiteFinished name='mocha.suite' duration='" + stats.duration + "']");+ });+}++/**+ * Escape the given `str`.+ */++function escape(str) {+ return str+ .replace(/\|/g, "||")+ .replace(/\n/g, "|n")+ .replace(/\r/g, "|r")+ .replace(/\[/g, "|[")+ .replace(/\]/g, "|]")+ .replace(/\u0085/g, "|x")+ .replace(/\u2028/g, "|l")+ .replace(/\u2029/g, "|p")+ .replace(/'/g, "|'");+}++}); // module: reporters/teamcity.js++require.register("reporters/xunit.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , utils = require('../utils')+ , escape = utils.escape;++/**+ * Save timer references to avoid Sinon interfering (see GH-237).+ */++var Date = global.Date+ , setTimeout = global.setTimeout+ , setInterval = global.setInterval+ , clearTimeout = global.clearTimeout+ , clearInterval = global.clearInterval;++/**+ * Expose `XUnit`.+ */++exports = module.exports = XUnit;++/**+ * Initialize a new `XUnit` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function XUnit(runner) {+ Base.call(this, runner);+ var stats = this.stats+ , tests = []+ , self = this;++ runner.on('test end', function(test){+ tests.push(test);+ });++ runner.on('end', function(){+ console.log(tag('testsuite', {+ name: 'Mocha Tests'+ , tests: stats.tests+ , failures: stats.failures+ , errors: stats.failures+ , skip: stats.tests - stats.failures - stats.passes+ , timestamp: (new Date).toUTCString()+ , time: stats.duration / 1000+ }, false));++ tests.forEach(test);+ console.log('</testsuite>');+ });+}++/**+ * Inherit from `Base.prototype`.+ */++XUnit.prototype = new Base;+XUnit.prototype.constructor = XUnit;+++/**+ * Output tag for the given `test.`+ */++function test(test) {+ var attrs = {+ classname: test.parent.fullTitle()+ , name: test.title+ , time: test.duration / 1000+ };++ if ('failed' == test.state) {+ var err = test.err;+ attrs.message = escape(err.message);+ console.log(tag('testcase', attrs, false, tag('failure', attrs, false, cdata(err.stack))));+ } else if (test.pending) {+ console.log(tag('testcase', attrs, false, tag('skipped', {}, true)));+ } else {+ console.log(tag('testcase', attrs, true) );+ }+}++/**+ * HTML tag helper.+ */++function tag(name, attrs, close, content) {+ var end = close ? '/>' : '>'+ , pairs = []+ , tag;++ for (var key in attrs) {+ pairs.push(key + '="' + escape(attrs[key]) + '"');+ }++ tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end;+ if (content) tag += content + '</' + name + end;+ return tag;+}++/**+ * Return cdata escaped CDATA `str`.+ */++function cdata(str) {+ return '<![CDATA[' + escape(str) + ']]>';+}++}); // module: reporters/xunit.js++require.register("runnable.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var EventEmitter = require('browser/events').EventEmitter+ , debug = require('browser/debug')('runnable');++/**+ * Save timer references to avoid Sinon interfering (see GH-237).+ */++var Date = global.Date+ , setTimeout = global.setTimeout+ , setInterval = global.setInterval+ , clearTimeout = global.clearTimeout+ , clearInterval = global.clearInterval;++/**+ * Expose `Runnable`.+ */++module.exports = Runnable;++/**+ * Initialize a new `Runnable` with the given `title` and callback `fn`.+ *+ * @param {String} title+ * @param {Function} fn+ * @api private+ */++function Runnable(title, fn) {+ this.title = title;+ this.fn = fn;+ this.async = fn && fn.length;+ this.sync = ! this.async;+ this._timeout = 2000;+ this.timedOut = false;+}++/**+ * Inherit from `EventEmitter.prototype`.+ */++Runnable.prototype = new EventEmitter;+Runnable.prototype.constructor = Runnable;+++/**+ * Set & get timeout `ms`.+ *+ * @param {Number} ms+ * @return {Runnable|Number} ms or self+ * @api private+ */++Runnable.prototype.timeout = function(ms){+ if (0 == arguments.length) return this._timeout;+ debug('timeout %d', ms);+ this._timeout = ms;+ if (this.timer) this.resetTimeout();+ return this;+};++/**+ * Return the full title generated by recursively+ * concatenating the parent's full title.+ *+ * @return {String}+ * @api public+ */++Runnable.prototype.fullTitle = function(){+ return this.parent.fullTitle() + ' ' + this.title;+};++/**+ * Clear the timeout.+ *+ * @api private+ */++Runnable.prototype.clearTimeout = function(){+ clearTimeout(this.timer);+};++/**+ * Reset the timeout.+ *+ * @api private+ */++Runnable.prototype.resetTimeout = function(){+ var self = this+ , ms = this.timeout();++ this.clearTimeout();+ if (ms) {+ this.timer = setTimeout(function(){+ self.callback(new Error('timeout of ' + ms + 'ms exceeded'));+ self.timedOut = true;+ }, ms);+ }+};++/**+ * Run the test and invoke `fn(err)`.+ *+ * @param {Function} fn+ * @api private+ */++Runnable.prototype.run = function(fn){+ var self = this+ , ms = this.timeout()+ , start = new Date+ , ctx = this.ctx+ , finished+ , emitted;++ if (ctx) ctx.runnable(this);++ // timeout+ if (this.async) {+ if (ms) {+ this.timer = setTimeout(function(){+ done(new Error('timeout of ' + ms + 'ms exceeded'));+ self.timedOut = true;+ }, ms);+ }+ }++ // called multiple times+ function multiple() {+ if (emitted) return;+ emitted = true;+ self.emit('error', new Error('done() called multiple times'));+ }++ // finished+ function done(err) {+ if (self.timedOut) return;+ if (finished) return multiple();+ self.clearTimeout();+ self.duration = new Date - start;+ finished = true;+ fn(err);+ }++ // for .resetTimeout()+ this.callback = done;++ // async+ if (this.async) {+ try {+ this.fn.call(ctx, function(err){+ if (err instanceof Error) return done(err);+ if (null != err) return done(new Error('done() invoked with non-Error: ' + err));+ done();+ });+ } catch (err) {+ done(err);+ }+ return;+ }++ // sync+ try {+ if (!this.pending) this.fn.call(ctx);+ this.duration = new Date - start;+ fn();+ } catch (err) {+ fn(err);+ }+};++}); // module: runnable.js++require.register("runner.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var EventEmitter = require('browser/events').EventEmitter+ , debug = require('browser/debug')('runner')+ , Test = require('./test')+ , utils = require('./utils')+ , filter = utils.filter+ , keys = utils.keys+ , noop = function(){};++/**+ * Expose `Runner`.+ */++module.exports = Runner;++/**+ * Initialize a `Runner` for the given `suite`.+ *+ * Events:+ *+ * - `start` execution started+ * - `end` execution complete+ * - `suite` (suite) test suite execution started+ * - `suite end` (suite) all tests (and sub-suites) have finished+ * - `test` (test) test execution started+ * - `test end` (test) test completed+ * - `hook` (hook) hook execution started+ * - `hook end` (hook) hook complete+ * - `pass` (test) test passed+ * - `fail` (test, err) test failed+ *+ * @api public+ */++function Runner(suite) {+ var self = this;+ this._globals = [];+ this.suite = suite;+ this.total = suite.total();+ this.failures = 0;+ this.on('test end', function(test){ self.checkGlobals(test); });+ this.on('hook end', function(hook){ self.checkGlobals(hook); });+ this.grep(/.*/);+ this.globals(utils.keys(global).concat(['errno']));+}++/**+ * Inherit from `EventEmitter.prototype`.+ */++Runner.prototype = new EventEmitter;+Runner.prototype.constructor = Runner;+++/**+ * Run tests with full titles matching `re`. Updates runner.total+ * with number of tests matched.+ *+ * @param {RegExp} re+ * @return {Runner} for chaining+ * @api public+ */++Runner.prototype.grep = function(re){+ debug('grep %s', re);+ this._grep = re;+ this.total = this.grepTotal(this.suite);+ return this;+};++/**+ * Returns the number of tests matching the grep search for the+ * given suite.+ *+ * @param {Suite} suite+ * @return {Number}+ * @api public+ */++Runner.prototype.grepTotal = function(suite) {+ var self = this;+ var total = 0;++ suite.eachTest(function(test){+ if (self._grep.test(test.fullTitle())) total++;+ });++ return total;+};++/**+ * Allow the given `arr` of globals.+ *+ * @param {Array} arr+ * @return {Runner} for chaining+ * @api public+ */++Runner.prototype.globals = function(arr){+ if (0 == arguments.length) return this._globals;+ debug('globals %j', arr);+ utils.forEach(arr, function(arr){+ this._globals.push(arr);+ }, this);+ return this;+};++/**+ * Check for global variable leaks.+ *+ * @api private+ */++Runner.prototype.checkGlobals = function(test){+ if (this.ignoreLeaks) return;+ var leaks = filterLeaks(this._globals);++ this._globals = this._globals.concat(leaks);++ if (leaks.length > 1) {+ this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));+ } else if (leaks.length) {+ this.fail(test, new Error('global leak detected: ' + leaks[0]));+ }+};++/**+ * Fail the given `test`.+ *+ * @param {Test} test+ * @param {Error} err+ * @api private+ */++Runner.prototype.fail = function(test, err){+ ++this.failures;+ test.state = 'failed';+ if ('string' == typeof err) {+ err = new Error('the string "' + err + '" was thrown, throw an Error :)');+ }+ this.emit('fail', test, err);+};++/**+ * Fail the given `hook` with `err`.+ *+ * Hook failures (currently) hard-end due+ * to that fact that a failing hook will+ * surely cause subsequent tests to fail,+ * causing jumbled reporting.+ *+ * @param {Hook} hook+ * @param {Error} err+ * @api private+ */++Runner.prototype.failHook = function(hook, err){+ this.fail(hook, err);+ this.emit('end');+};++/**+ * Run hook `name` callbacks and then invoke `fn()`.+ *+ * @param {String} name+ * @param {Function} function+ * @api private+ */++Runner.prototype.hook = function(name, fn){+ var suite = this.suite+ , hooks = suite['_' + name]+ , ms = suite._timeout+ , self = this+ , timer;++ function next(i) {+ var hook = hooks[i];+ if (!hook) return fn();+ self.currentRunnable = hook;++ self.emit('hook', hook);++ hook.on('error', function(err){+ self.failHook(hook, err);+ });++ hook.run(function(err){+ hook.removeAllListeners('error');+ if (err) return self.failHook(hook, err);+ self.emit('hook end', hook);+ next(++i);+ });+ }++ process.nextTick(function(){+ next(0);+ });+};++/**+ * Run hook `name` for the given array of `suites`+ * in order, and callback `fn(err)`.+ *+ * @param {String} name+ * @param {Array} suites+ * @param {Function} fn+ * @api private+ */++Runner.prototype.hooks = function(name, suites, fn){+ var self = this+ , orig = this.suite;++ function next(suite) {+ self.suite = suite;++ if (!suite) {+ self.suite = orig;+ return fn();+ }++ self.hook(name, function(err){+ if (err) {+ self.suite = orig;+ return fn(err);+ }++ next(suites.pop());+ });+ }++ next(suites.pop());+};++/**+ * Run hooks from the top level down.+ *+ * @param {String} name+ * @param {Function} fn+ * @api private+ */++Runner.prototype.hookUp = function(name, fn){+ var suites = [this.suite].concat(this.parents()).reverse();+ this.hooks(name, suites, fn);+};++/**+ * Run hooks from the bottom up.+ *+ * @param {String} name+ * @param {Function} fn+ * @api private+ */++Runner.prototype.hookDown = function(name, fn){+ var suites = [this.suite].concat(this.parents());+ this.hooks(name, suites, fn);+};++/**+ * Return an array of parent Suites from+ * closest to furthest.+ *+ * @return {Array}+ * @api private+ */++Runner.prototype.parents = function(){+ var suite = this.suite+ , suites = [];+ while (suite = suite.parent) suites.push(suite);+ return suites;+};++/**+ * Run the current test and callback `fn(err)`.+ *+ * @param {Function} fn+ * @api private+ */++Runner.prototype.runTest = function(fn){+ var test = this.test+ , self = this;++ try {+ test.on('error', function(err){+ self.fail(test, err);+ });+ test.run(fn);+ } catch (err) {+ fn(err);+ }+};++/**+ * Run tests in the given `suite` and invoke+ * the callback `fn()` when complete.+ *+ * @param {Suite} suite+ * @param {Function} fn+ * @api private+ */++Runner.prototype.runTests = function(suite, fn){+ var self = this+ , tests = suite.tests+ , test;++ function next(err) {+ // if we bail after first err+ if (self.failures && suite._bail) return fn();++ // next test+ test = tests.shift();++ // all done+ if (!test) return fn();++ // grep+ if (!self._grep.test(test.fullTitle())) return next();++ // pending+ if (test.pending) {+ self.emit('pending', test);+ self.emit('test end', test);+ return next();+ }++ // execute test and hook(s)+ self.emit('test', self.test = test);+ self.hookDown('beforeEach', function(){+ self.currentRunnable = self.test;+ self.runTest(function(err){+ test = self.test;++ if (err) {+ self.fail(test, err);+ self.emit('test end', test);+ return self.hookUp('afterEach', next);+ }++ test.state = 'passed';+ self.emit('pass', test);+ self.emit('test end', test);+ self.hookUp('afterEach', next);+ });+ });+ }++ this.next = next;+ next();+};++/**+ * Run the given `suite` and invoke the+ * callback `fn()` when complete.+ *+ * @param {Suite} suite+ * @param {Function} fn+ * @api private+ */++Runner.prototype.runSuite = function(suite, fn){+ var total = this.grepTotal(suite)+ , self = this+ , i = 0;++ debug('run suite %s', suite.fullTitle());++ if (!total) return fn();++ this.emit('suite', this.suite = suite);++ function next() {+ var curr = suite.suites[i++];+ if (!curr) return done();+ self.runSuite(curr, next);+ }++ function done() {+ self.suite = suite;+ self.hook('afterAll', function(){+ self.emit('suite end', suite);+ fn();+ });+ }++ this.hook('beforeAll', function(){+ self.runTests(suite, next);+ });+};++/**+ * Handle uncaught exceptions.+ *+ * @param {Error} err+ * @api private+ */++Runner.prototype.uncaught = function(err){+ debug('uncaught exception');+ var runnable = this.currentRunnable;+ if ('failed' == runnable.state) return;+ runnable.clearTimeout();+ err.uncaught = true;+ this.fail(runnable, err);++ // recover from test+ if ('test' == runnable.type) {+ this.emit('test end', runnable);+ this.hookUp('afterEach', this.next);+ return;+ }++ // bail on hooks+ this.emit('end');+};++/**+ * Run the root suite and invoke `fn(failures)`+ * on completion.+ *+ * @param {Function} fn+ * @return {Runner} for chaining+ * @api public+ */++Runner.prototype.run = function(fn){+ var self = this+ , fn = fn || function(){};++ debug('start');++ // callback+ this.on('end', function(){+ debug('end');+ process.removeListener('uncaughtException', this.uncaught);+ fn(self.failures);+ });++ // run suites+ this.emit('start');+ this.runSuite(this.suite, function(){+ debug('finished running');+ self.emit('end');+ });++ // uncaught exception+ process.on('uncaughtException', function(err){+ self.uncaught(err);+ });++ return this;+};++/**+ * Filter leaks with the given globals flagged as `ok`.+ *+ * @param {Array} ok+ * @return {Array}+ * @api private+ */++function filterLeaks(ok) {+ return filter(keys(global), function(key){+ var matched = filter(ok, function(ok){+ return 0 == key.indexOf(ok.split('*')[0]);+ });+ return matched.length == 0 && (!global.navigator || 'onerror' !== key);+ });+}+}); // module: runner.js++require.register("suite.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var EventEmitter = require('browser/events').EventEmitter+ , debug = require('browser/debug')('suite')+ , utils = require('./utils')+ , Hook = require('./hook');++/**+ * Expose `Suite`.+ */++exports = module.exports = Suite;++/**+ * Create a new `Suite` with the given `title`+ * and parent `Suite`. When a suite with the+ * same title is already present, that suite+ * is returned to provide nicer reporter+ * and more flexible meta-testing.+ *+ * @param {Suite} parent+ * @param {String} title+ * @return {Suite}+ * @api public+ */++exports.create = function(parent, title){+ var suite = new Suite(title, parent.ctx);+ suite.parent = parent;+ title = suite.fullTitle();+ parent.addSuite(suite);+ return suite;+};++/**+ * Initialize a new `Suite` with the given+ * `title` and `ctx`.+ *+ * @param {String} title+ * @param {Context} ctx+ * @api private+ */++function Suite(title, ctx) {+ this.title = title;+ this.ctx = ctx;+ this.suites = [];+ this.tests = [];+ this._beforeEach = [];+ this._beforeAll = [];+ this._afterEach = [];+ this._afterAll = [];+ this.root = !title;+ this._timeout = 2000;+ this._bail = false;+}++/**+ * Inherit from `EventEmitter.prototype`.+ */++Suite.prototype = new EventEmitter;+Suite.prototype.constructor = Suite;+++/**+ * Return a clone of this `Suite`.+ *+ * @return {Suite}+ * @api private+ */++Suite.prototype.clone = function(){+ var suite = new Suite(this.title);+ debug('clone');+ suite.ctx = this.ctx;+ suite.timeout(this.timeout());+ suite.bail(this.bail());+ return suite;+};++/**+ * Set timeout `ms` or short-hand such as "2s".+ *+ * @param {Number|String} ms+ * @return {Suite|Number} for chaining+ * @api private+ */++Suite.prototype.timeout = function(ms){+ if (0 == arguments.length) return this._timeout;+ if (String(ms).match(/s$/)) ms = parseFloat(ms) * 1000;+ debug('timeout %d', ms);+ this._timeout = parseInt(ms, 10);+ return this;+};++/**+ * Sets whether to bail after first error.+ *+ * @parma {Boolean} bail+ * @return {Suite|Number} for chaining+ * @api private+ */++Suite.prototype.bail = function(bail){+ if (0 == arguments.length) return this._bail;+ debug('bail %s', bail);+ this._bail = bail;+ return this;+};++/**+ * Run `fn(test[, done])` before running tests.+ *+ * @param {Function} fn+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.beforeAll = function(fn){+ var hook = new Hook('"before all" hook', fn);+ hook.parent = this;+ hook.timeout(this.timeout());+ hook.ctx = this.ctx;+ this._beforeAll.push(hook);+ this.emit('beforeAll', hook);+ return this;+};++/**+ * Run `fn(test[, done])` after running tests.+ *+ * @param {Function} fn+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.afterAll = function(fn){+ var hook = new Hook('"after all" hook', fn);+ hook.parent = this;+ hook.timeout(this.timeout());+ hook.ctx = this.ctx;+ this._afterAll.push(hook);+ this.emit('afterAll', hook);+ return this;+};++/**+ * Run `fn(test[, done])` before each test case.+ *+ * @param {Function} fn+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.beforeEach = function(fn){+ var hook = new Hook('"before each" hook', fn);+ hook.parent = this;+ hook.timeout(this.timeout());+ hook.ctx = this.ctx;+ this._beforeEach.push(hook);+ this.emit('beforeEach', hook);+ return this;+};++/**+ * Run `fn(test[, done])` after each test case.+ *+ * @param {Function} fn+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.afterEach = function(fn){+ var hook = new Hook('"after each" hook', fn);+ hook.parent = this;+ hook.timeout(this.timeout());+ hook.ctx = this.ctx;+ this._afterEach.push(hook);+ this.emit('afterEach', hook);+ return this;+};++/**+ * Add a test `suite`.+ *+ * @param {Suite} suite+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.addSuite = function(suite){+ suite.parent = this;+ suite.timeout(this.timeout());+ suite.bail(this.bail());+ this.suites.push(suite);+ this.emit('suite', suite);+ return this;+};++/**+ * Add a `test` to this suite.+ *+ * @param {Test} test+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.addTest = function(test){+ test.parent = this;+ test.timeout(this.timeout());+ test.ctx = this.ctx;+ this.tests.push(test);+ this.emit('test', test);+ return this;+};++/**+ * Return the full title generated by recursively+ * concatenating the parent's full title.+ *+ * @return {String}+ * @api public+ */++Suite.prototype.fullTitle = function(){+ if (this.parent) {+ var full = this.parent.fullTitle();+ if (full) return full + ' ' + this.title;+ }+ return this.title;+};++/**+ * Return the total number of tests.+ *+ * @return {Number}+ * @api public+ */++Suite.prototype.total = function(){+ return utils.reduce(this.suites, function(sum, suite){+ return sum + suite.total();+ }, 0) + this.tests.length;+};++/**+ * Iterates through each suite recursively to find+ * all tests. Applies a function in the format+ * `fn(test)`.+ *+ * @param {Function} fn+ * @return {Suite}+ * @api private+ */++Suite.prototype.eachTest = function(fn){+ utils.forEach(this.tests, fn);+ utils.forEach(this.suites, function(suite){+ suite.eachTest(fn);+ });+ return this;+};++}); // module: suite.js++require.register("test.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Runnable = require('./runnable');++/**+ * Expose `Test`.+ */++module.exports = Test;++/**+ * Initialize a new `Test` with the given `title` and callback `fn`.+ *+ * @param {String} title+ * @param {Function} fn+ * @api private+ */++function Test(title, fn) {+ Runnable.call(this, title, fn);+ this.pending = !fn;+ this.type = 'test';+}++/**+ * Inherit from `Runnable.prototype`.+ */++Test.prototype = new Runnable;+Test.prototype.constructor = Test;+++/**+ * Inspect the context void of private properties.+ *+ * @return {String}+ * @api private+ */++Test.prototype.inspect = function(){+ return JSON.stringify(this, function(key, val){+ return '_' == key[0]+ ? undefined+ : 'parent' == key+ ? '#<Suite>'+ : val;+ }, 2);+};+}); // module: test.js++require.register("utils.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var fs = require('browser/fs')+ , path = require('browser/path')+ , join = path.join+ , debug = require('browser/debug')('watch');++/**+ * Ignored directories.+ */++var ignore = ['node_modules', '.git'];++/**+ * Escape special characters in the given string of html.+ *+ * @param {String} html+ * @return {String}+ * @api private+ */++exports.escape = function(html) {+ return String(html)+ .replace(/&/g, '&')+ .replace(/"/g, '"')+ .replace(/</g, '<')+ .replace(/>/g, '>');+};++/**+ * Array#forEach (<=IE8)+ *+ * @param {Array} array+ * @param {Function} fn+ * @param {Object} scope+ * @api private+ */++exports.forEach = function(arr, fn, scope) {+ for (var i = 0, l = arr.length; i < l; i++)+ fn.call(scope, arr[i], i);+};++/**+ * Array#indexOf (<=IE8)+ *+ * @parma {Array} arr+ * @param {Object} obj to find index of+ * @param {Number} start+ * @api private+ */++exports.indexOf = function (arr, obj, start) {+ for (var i = start || 0, l = arr.length; i < l; i++) {+ if (arr[i] === obj)+ return i;+ }+ return -1;+};++/**+ * Array#reduce (<=IE8)+ *+ * @param {Array} array+ * @param {Function} fn+ * @param {Object} initial value+ * @param {Object} scope+ * @api private+ */++exports.reduce = function(arr, fn, val, scope) {+ var rval = val;++ for (var i = 0, l = arr.length; i < l; i++) {+ rval = fn.call(scope, rval, arr[i], i, arr);+ }++ return rval;+};++/**+ * Array#filter (<=IE8)+ *+ * @param {Array} array+ * @param {Function} fn+ * @param {Object} scope+ * @api private+ */++exports.filter = function(arr, fn, scope) {+ var ret = [];++ for (var i = 0, l = arr.length; i < l; i++) {+ var val = arr[i];+ if (fn.call(scope, val, i, arr))+ ret.push(val);+ }++ return ret;+};++/**+ * Object.keys (<=IE8)+ *+ * @param {Object} obj+ * @return {Array} keys+ * @api private+ */++exports.keys = Object.keys || function(obj) {+ var keys = []+ , has = Object.prototype.hasOwnProperty // for `window` on <=IE8++ for (var key in obj) {+ if (has.call(obj, key)) {+ keys.push(key);+ }+ }++ return keys;+};++/**+ * Watch the given `files` for changes+ * and invoke `fn(file)` on modification.+ *+ * @param {Array} files+ * @param {Function} fn+ * @api private+ */++exports.watch = function(files, fn){+ var options = { interval: 100 };+ files.forEach(function(file){+ debug('file %s', file);+ fs.watchFile(file, options, function(curr, prev){+ if (prev.mtime < curr.mtime) fn(file);+ });+ });+};++/**+ * Ignored files.+ */++function ignored(path){+ return !~ignore.indexOf(path);+}++/**+ * Lookup files in the given `dir`.+ *+ * @return {Array}+ * @api private+ */++exports.files = function(dir, ret){+ ret = ret || [];++ fs.readdirSync(dir)+ .filter(ignored)+ .forEach(function(path){+ path = join(dir, path);+ if (fs.statSync(path).isDirectory()) {+ exports.files(path, ret);+ } else if (path.match(/\.(js|coffee)$/)) {+ ret.push(path);+ }+ });++ return ret;+};++/**+ * Compute a slug from the given `str`.+ *+ * @param {String} str+ * @return {String}+ * @api private+ */++exports.slug = function(str){+ return str+ .toLowerCase()+ .replace(/ +/g, '-')+ .replace(/[^-\w]/g, '');+};++/**+ * Strip the function definition from `str`,+ * and re-indent for pre whitespace.+ */++exports.clean = function(str) {+ str = str+ .replace(/^function *\(.*\) *{/, '')+ .replace(/\s+\}$/, '');++ var spaces = str.match(/^\n?( *)/)[1].length+ , re = new RegExp('^ {' + spaces + '}', 'gm');++ str = str.replace(re, '');++ return str.trim();+};++/**+ * Escape regular expression characters in `str`.+ *+ * @param {String} str+ * @return {String}+ * @api private+ */++exports.escapeRegexp = function(str){+ return str.replace(/[-\\^$*+?.()|[\]{}]/g, "\\$&");+};+}); // module: utils.jsdiff --git a/example/Array.js b/example/Array.jsnew file mode 100644index 00000000..67ed6183--- /dev/null+++ b/example/Array.js@@ -0,0 +1,38 @@++describe('Array', function(){+ describe('.push()', function(){+ it('should add the values', function(){+ var arr = [];+ arr.push('foo');+ arr.push('bar');+ expect(arr[0]).to.equal('foo');+ expect(arr[1]).to.equal('bar');+ })++ it('should return the length', function(){+ var arr = [];+ var n = arr.push('foo');+ expect(n).to.equal(1);+ var n = arr.push('bar');+ expect(n).to.equal(2);+ })++ describe('with many arguments', function(){+ it('should add the values', function(){+ var arr = [];+ arr.push('foo', 'bar');+ expect(arr[0]).to.equal('foo');+ expect(arr[1]).to.equal('bar');+ })+ })+ })++ describe('.shift()', function(){+ it('should remove and return the first value', function(){+ var arr = [1,2,3];+ expect(arr.shift()).to.equal(1);+ expect(arr.shift()).to.equal(2);+ expect(arr.length).to.equal(1);+ })+ })+})\ No newline at end of filediff --git a/example/String.js b/example/String.jsnew file mode 100644index 00000000..66f5741a--- /dev/null+++ b/example/String.js@@ -0,0 +1,15 @@++describe('String', function(){+ describe('.trim()', function(){+ it('should remove leading and trailing whitespace', function(){+ expect(' foo '.trim()).to.equal('foo');+ })+ })++ describe('.replace(substr, str)', function(){+ it('should replace the first occurrence of substr', function(){+ var str = 'foobar'.replace('foo', 'bar');+ expect(str).to.equal('barbar');+ })+ })+})\ No newline at end of filediff --git a/example/chai.js b/example/chai.jsnew file mode 100644index 00000000..43fbf644--- /dev/null+++ b/example/chai.js@@ -0,0 +1,3403 @@+!function (name, definition) {+ if (typeof define == 'function' && typeof define.amd == 'object') define(definition);+ else this[name] = definition();+}('chai', function () {++// CommonJS require()++function require(p){+ var path = require.resolve(p)+ , mod = require.modules[path];+ if (!mod) throw new Error('failed to require "' + p + '"');+ if (!mod.exports) {+ mod.exports = {};+ mod.call(mod.exports, mod, mod.exports, require.relative(path));+ }+ return mod.exports;+ }++require.modules = {};++require.resolve = function (path){+ var orig = path+ , reg = path + '.js'+ , index = path + '/index.js';+ return require.modules[reg] && reg+ || require.modules[index] && index+ || orig;+ };++require.register = function (path, fn){+ require.modules[path] = fn;+ };++require.relative = function (parent) {+ return function(p){+ if ('.' != p[0]) return require(p);++ var path = parent.split('/')+ , segs = p.split('/');+ path.pop();++ for (var i = 0; i < segs.length; i++) {+ var seg = segs[i];+ if ('..' == seg) path.pop();+ else if ('.' != seg) path.push(seg);+ }++ return require(path.join('/'));+ };+ };+++require.register("assertion.js", function(module, exports, require){+/*!+ * chai+ * http://chaijs.com+ * Copyright(c) 2011-2012 Jake Luer <[email protected]>+ * MIT Licensed+ */+++/*!+ * Module dependencies.+ */++var AssertionError = require('./browser/error')+ , toString = Object.prototype.toString+ , util = require('./utils')+ , flag = util.flag;++/*!+ * Module export.+ */++module.exports = Assertion;+++/*!+ * Assertion Constructor+ *+ * Creates object for chaining.+ *+ * @api private+ */++function Assertion (obj, msg, stack) {+ flag(this, 'ssfi', stack || arguments.callee);+ flag(this, 'object', obj);+ flag(this, 'message', msg);+}++/*!+ * ### Assertion.includeStack+ *+ * User configurable property, influences whether stack trace+ * is included in Assertion error message. Default of false+ * suppresses stack trace in the error message+ *+ * Assertion.includeStack = true; // enable stack on error+ *+ * @api public+ */++Assertion.includeStack = false;++Assertion.addProperty = function (name, fn) {+ util.addProperty(this.prototype, name, fn);+};++Assertion.addMethod = function (name, fn) {+ util.addMethod(this.prototype, name, fn);+};++Assertion.addChainableMethod = function (name, fn, chainingBehavior) {+ util.addChainableMethod(this.prototype, name, fn, chainingBehavior);+};++Assertion.overwriteProperty = function (name, fn) {+ util.overwriteProperty(this.prototype, name, fn);+};++Assertion.overwriteMethod = function (name, fn) {+ util.overwriteMethod(this.prototype, name, fn);+};++/*!+ * ### .assert(expression, message, negateMessage, expected, actual)+ *+ * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.+ *+ * @name assert+ * @param {Philosophical} expression to be tested+ * @param {String} message to display if fails+ * @param {String} negatedMessage to display if negated expression fails+ * @param {Mixed} expected value (remember to check for negation)+ * @param {Mixed} actual (optional) will default to `this.obj`+ * @api private+ */++Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual) {+ var msg = util.getMessage(this, arguments)+ , actual = util.getActual(this, arguments)+ , ok = util.test(this, arguments);++ if (!ok) {+ throw new AssertionError({+ message: msg+ , actual: actual+ , expected: expected+ , stackStartFunction: (Assertion.includeStack) ? this.assert : flag(this, 'ssfi')+ });+ }+};++/*!+ *+ * ### ._obj+ *+ * Quick reference to stored `actual` value for plugin developers.+ *+ * @api private+ */++Object.defineProperty(Assertion.prototype, '_obj',+ { get: function () {+ return flag(this, 'object');+ }+ , set: function (val) {+ flag(this, 'object', val);+ }+});++/**+ * ### Language Chains+ *+ * The following are provide as chainable getters to+ * improve the readability of your assertions. They+ * do not provide an testing capability unless they+ * have been overwritten by a plugin.+ *+ * **Chains**+ *+ * - to+ * - be+ * - been+ * - is+ * - and+ * - have+ * - with+ *+ * @name language chains+ * @api public+ */++[ 'to', 'be', 'been'+, 'is', 'and', 'have'+, 'with' ].forEach(function (chain) {+ Object.defineProperty(Assertion.prototype, chain,+ { get: function () {+ return this;+ }+ , configurable: true+ });+});++/**+ * ### .not+ *+ * Negates any of assertions following in the chain.+ *+ * expect(foo).to.not.equal('bar');+ * expect(goodFn).to.not.throw(Error);+ * expect({ foo: 'baz' }).to.have.property('foo')+ * .and.not.equal('bar');+ *+ * @name not+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'not',+ { get: function () {+ flag(this, 'negate', true);+ return this;+ }+ , configurable: true+});++/**+ * ### .deep+ *+ * Sets the `deep` flag, later used by the `equal` and+ * `property` assertions.+ *+ * expect(foo).to.deep.equal({ bar: 'baz' });+ * expect({ foo: { bar: { baz: 'quux' } } })+ * .to.have.deep.property('foo.bar.baz', 'quux');+ *+ * @name deep+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'deep',+ { get: function () {+ flag(this, 'deep', true);+ return this;+ }+ , configurable: true+});++/**+ * ### .a(type)+ *+ * The `a` and `an` assertions are aliases that can be+ * used either as language chains or to assert a value's+ * type (as revealed by `Object.prototype.toString`).+ *+ * // typeof+ * expect('test').to.be.a('string');+ * expect({ foo: 'bar' }).to.be.an('object');+ * expect(null).to.be.a('null');+ * expect(undefined).to.be.an('undefined');+ *+ * // language chain+ * expect(foo).to.be.an.instanceof(Foo);+ *+ * @name a+ * @alias an+ * @param {String} type+ * @api public+ */++function an(type) {+ var obj = flag(this, 'object')+ , klassStart = type.charAt(0).toUpperCase()+ , klass = klassStart + type.slice(1)+ , article = ~[ 'A', 'E', 'I', 'O', 'U' ].indexOf(klassStart) ? 'an ' : 'a ';++ this.assert(+ '[object ' + klass + ']' === toString.call(obj)+ , 'expected #{this} to be ' + article + type+ , 'expected #{this} not to be ' + article + type+ , '[object ' + klass + ']'+ , toString.call(obj)+ );+}++Assertion.addChainableMethod('an', an);+Assertion.addChainableMethod('a', an);++/**+ * ### .include(value)+ *+ * The `include` and `contain` assertions can be used as either property+ * based language chains or as methods to assert the inclusion of an object+ * in an array or a substring in a string. When used as language chains,+ * they toggle the `contain` flag for the `keys` assertion.+ *+ * expect([1,2,3]).to.include(2);+ * expect('foobar').to.contain('foo');+ * expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');+ *+ * @name include+ * @alias contain+ * @param {Object|String|Number} obj+ * @api public+ */++function includeChainingBehavior () {+ flag(this, 'contains', true);+}++function include (val) {+ var obj = flag(this, 'object')+ this.assert(+ ~obj.indexOf(val)+ , 'expected #{this} to include ' + util.inspect(val)+ , 'expected #{this} to not include ' + util.inspect(val));+}++Assertion.addChainableMethod('include', include, includeChainingBehavior);+Assertion.addChainableMethod('contain', include, includeChainingBehavior);++/**+ * ### .ok+ *+ * Asserts that the target is truthy.+ *+ * expect('everthing').to.be.ok;+ * expect(1).to.be.ok;+ * expect(false).to.not.be.ok;+ * expect(undefined).to.not.be.ok;+ * expect(null).to.not.be.ok;+ *+ * @name ok+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'ok',+ { get: function () {+ this.assert(+ flag(this, 'object')+ , 'expected #{this} to be truthy'+ , 'expected #{this} to be falsy');++ return this;+ }+ , configurable: true+});++/**+ * ### .true+ *+ * Asserts that the target is `true`.+ *+ * expect(true).to.be.true;+ * expect(1).to.not.be.true;+ *+ * @name true+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'true',+ { get: function () {+ this.assert(+ true === flag(this, 'object')+ , 'expected #{this} to be true'+ , 'expected #{this} to be false'+ , this.negate ? false : true+ );++ return this;+ }+ , configurable: true+});++/**+ * ### .false+ *+ * Asserts that the target is `false`.+ *+ * expect(false).to.be.false;+ * expect(0).to.not.be.false;+ *+ * @name false+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'false',+ { get: function () {+ this.assert(+ false === flag(this, 'object')+ , 'expected #{this} to be false'+ , 'expected #{this} to be true'+ , this.negate ? true : false+ );++ return this;+ }+ , configurable: true+});++/**+ * ### .null+ *+ * Asserts that the target is `null`.+ *+ * expect(null).to.be.null;+ * expect(undefined).not.to.be.null;+ *+ * @name null+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'null',+ { get: function () {+ this.assert(+ null === flag(this, 'object')+ , 'expected #{this} to be null'+ , 'expected #{this} not to be null'+ , this.negate ? false : true+ );++ return this;+ }+ , configurable: true+});++/**+ * ### .undefined+ *+ * Asserts that the target is `undefined`.+ *+ * expect(undefined).to.be.undefined;+ * expect(null).to.not.be.undefined;+ *+ * @name undefined+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'undefined',+ { get: function () {+ this.assert(+ undefined === flag(this, 'object')+ , 'expected #{this} to be undefined'+ , 'expected #{this} not to be undefined'+ , this.negate ? false : true+ );++ return this;+ }+ , configurable: true+});++/**+ * ### .exist+ *+ * Asserts that the target is neither `null` nor `undefined`.+ *+ * var foo = 'hi'+ * , bar = null+ * , baz;+ *+ * expect(foo).to.exist;+ * expect(bar).to.not.exist;+ * expect(baz).to.not.exist;+ *+ * @name exist+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'exist',+ { get: function () {+ this.assert(+ null != flag(this, 'object')+ , 'expected #{this} to exist'+ , 'expected #{this} to not exist'+ );++ return this;+ }+ , configurable: true+});++/**+ * ### .empty+ *+ * Asserts that the target's length is `0`. For arrays, it checks+ * the `length` property. For objects, it gets the count of+ * enumerable keys.+ *+ * expect([]).to.be.empty;+ * expect('').to.be.empty;+ * expect({}).to.be.empty;+ *+ * @name empty+ * @api public+ */++Object.defineProperty(Assertion.prototype, 'empty',+ { get: function () {+ var obj = flag(this, 'object')+ , expected = obj;++ if (Array.isArray(obj) || 'string' === typeof object) {+ expected = obj.length;+ } else if (typeof obj === 'object') {+ expected = Object.keys(obj).length;+ }++ this.assert(+ !expected+ , 'expected #{this} to be empty'+ , 'expected #{this} not to be empty');++ return this;+ }+ , configurable: true+});++/**+ * ### .arguments+ *+ * Asserts that the target is an arguments object.+ *+ * function test () {+ * expect(arguments).to.be.arguments;+ * }+ *+ * @name arguments+ * @alias Arguments+ * @api public+ */++function checkArguments () {+ var obj = flag(this, 'object')+ , type = Object.prototype.toString.call(obj);+ this.assert(+ '[object Arguments]' === type+ , 'expected #{this} to be arguments but got ' + type+ , 'expected #{this} to not be arguments'+ );+}++Assertion.addProperty('arguments', checkArguments);+Assertion.addProperty('Arguments', checkArguments);++/**+ * ### .equal(value)+ *+ * Asserts that the target is strictly equal (`===`) to `value`.+ * Alternately, if the `deep` flag is set, asserts that+ * the target is deeply equal to `value`.+ *+ * expect('hello').to.equal('hello');+ * expect(42).to.equal(42);+ * expect(1).to.not.equal(true);+ * expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });+ * expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });+ *+ * @name equal+ * @param {Mixed} value+ * @api public+ */++Assertion.prototype.equal = function (val) {+ var obj = flag(this, 'object');+ if (flag(this, 'deep')) {+ return this.eql(val);+ } else {+ this.assert(+ val === obj+ , 'expected #{this} to equal #{exp}'+ , 'expected #{this} to not equal #{exp}'+ , val);+ }++ return this;+};++/**+ * ### .eql(value)+ *+ * Asserts that the target is deeply equal to `value`.+ *+ * expect({ foo: 'bar' }).to.eql({ foo: 'bar' });+ * expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);+ *+ * @name eql+ * @param {Mixed} value+ * @api public+ */++Assertion.prototype.eql = function (obj) {+ this.assert(+ util.eql(obj, flag(this, 'object'))+ , 'expected #{this} to deeply equal #{exp}'+ , 'expected #{this} to not deeply equal #{exp}'+ , obj );++ return this;+};++/**+ * ### .above(value)+ *+ * Asserts that the target is greater than `value`.+ *+ * expect(10).to.be.above(5);+ *+ * @name above+ * @alias gt+ * @param {Number} value+ * @api public+ */++Assertion.prototype.above = function (val) {+ this.assert(+ flag(this, 'object') > val+ , 'expected #{this} to be above ' + val+ , 'expected #{this} to be below ' + val);++ return this;+};++/**+ * ### .below(value)+ *+ * Asserts that the target is less than `value`.+ *+ * expect(5).to.be.below(10);+ *+ * @name below+ * @alias lt+ * @param {Number} value+ * @api public+ */++Assertion.prototype.below = function (val) {+ this.assert(+ flag(this, 'object') < val+ , 'expected #{this} to be below ' + val+ , 'expected #{this} to be above ' + val);++ return this;+};++/**+ * ### .within(start, finish)+ *+ * Asserts that the target is within a range.+ *+ * expect(7).to.be.within(5,10);+ *+ * @name within+ * @param {Number} start lowerbound inclusive+ * @param {Number} finish upperbound inclusive+ * @api public+ */++Assertion.prototype.within = function (start, finish) {+ var obj = flag(this, 'object')+ , range = start + '..' + finish;++ this.assert(+ obj >= start && obj <= finish+ , 'expected #{this} to be within ' + range+ , 'expected #{this} to not be within ' + range);++ return this;+};++/**+ * ### .instanceof(constructor)+ *+ * Asserts that the target is an instance of `constructor`.+ *+ * var Tea = function (name) { this.name = name; }+ * , Chai = new Tea('chai');+ *+ * expect(Chai).to.be.an.instanceof(Tea);+ * expect([ 1, 2, 3 ]).to.be.instanceof(Array);+ *+ * @name instanceof+ * @param {Constructor} constructor+ * @alias instanceOf+ * @api public+ */++Assertion.prototype.instanceOf = function (constructor) {+ var name = util.getName(constructor);+ this.assert(+ flag(this, 'object') instanceof constructor+ , 'expected #{this} to be an instance of ' + name+ , 'expected #{this} to not be an instance of ' + name);++ return this;+};++/**+ * ### .property(name, [value])+ *+ * Asserts that the target has a property `name`, optionally asserting that+ * the value of that property is strictly equal to `value`.+ * If the `deep` flag is set, you can use dot- and bracket-notation for deep+ * references into objects and arrays.+ *+ * // simple referencing+ * var obj = { foo: 'bar' };+ * expect(obj).to.have.property('foo');+ * expect(obj).to.have.property('foo', 'bar');+ * expect(obj).to.have.property('foo').to.be.a('string');+ *+ * // deep referencing+ * var deepObj = {+ * green: { tea: 'matcha' }+ * , teas: [ 'chai', 'matcha', { tea: 'konacha' } ]+ * };++ * expect(deepObj).to.have.deep.property('green.tea', 'matcha');+ * expect(deepObj).to.have.deep.property('teas[1]', 'matcha');+ * expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha');+ *+ * @name property+ * @param {String} name+ * @param {Mixed} value (optional)+ * @returns value of property for chaining+ * @api public+ */++Assertion.prototype.property = function (name, val) {+ var obj = flag(this, 'object')+ , value = flag(this, 'deep') ? util.getPathValue(name, obj) : obj[name]+ , descriptor = flag(this, 'deep') ? 'deep property ' : 'property '+ , negate = flag(this, 'negate');++ if (negate && undefined !== val) {+ if (undefined === value) {+ throw new Error(util.inspect(obj) + ' has no ' + descriptor + util.inspect(name));+ }+ } else {+ this.assert(+ undefined !== value+ , 'expected #{this} to have a ' + descriptor + util.inspect(name)+ , 'expected #{this} to not have ' + descriptor + util.inspect(name));+ }++ if (undefined !== val) {+ this.assert(+ val === value+ , 'expected #{this} to have a ' + descriptor + util.inspect(name) + ' of #{exp}, but got #{act}'+ , 'expected #{this} to not have a ' + descriptor + util.inspect(name) + ' of #{act}'+ , val+ , value+ );+ }++ flag(this, 'object', value);+ return this;+};++/**+ * ### .ownProperty(name)+ *+ * Asserts that the target has an own property `name`.+ *+ * expect('test').to.have.ownProperty('length');+ *+ * @name ownProperty+ * @alias haveOwnProperty+ * @param {String} name+ * @api public+ */++Assertion.prototype.ownProperty = function (name) {+ var obj = flag(this, 'object');+ this.assert(+ obj.hasOwnProperty(name)+ , 'expected #{this} to have own property ' + util.inspect(name)+ , 'expected #{this} to not have own property ' + util.inspect(name));+ return this;+};++/**+ * ### .length(value)+ *+ * Asserts that the target's `length` property has the expected value.+ *+ * expect([1,2,3]).to.have.length(3);+ * expect('foobar').to.have.length(6);+ *+ * @name length+ * @alias lengthOf+ * @param {Number} length+ * @api public+ */++Assertion.prototype.length = function (n) {+ var obj = flag(this, 'object');+ new Assertion(obj).to.have.property('length');+ var len = obj.length;++ this.assert(+ len == n+ , 'expected #{this} to have a length of #{exp} but got #{act}'+ , 'expected #{this} to not have a length of #{act}'+ , n+ , len+ );++ return this;+};++/**+ * ### .match(regexp)+ *+ * Asserts that the target matches a regular expression.+ *+ * expect('foobar').to.match(/^foo/);+ *+ * @name match+ * @param {RegExp} RegularExpression+ * @api public+ */++Assertion.prototype.match = function (re) {+ var obj = flag(this, 'object');+ this.assert(+ re.exec(obj)+ , 'expected #{this} to match ' + re+ , 'expected #{this} not to match ' + re);++ return this;+};+++/**+ * ### .string(string)+ *+ * Asserts that the string target contains another string.+ *+ * expect('foobar').to.have.string('bar');+ *+ * @name string+ * @param {String} string+ * @api public+ */++Assertion.prototype.string = function (str) {+ var obj = flag(this, 'object');+ new Assertion(obj).is.a('string');++ this.assert(+ ~obj.indexOf(str)+ , 'expected #{this} to contain ' + util.inspect(str)+ , 'expected #{this} to not contain ' + util.inspect(str));++ return this;+};++/**+ * ### .keys(key1, [key2], [...])+ *+ * Asserts that the target has exactly the given keys, or+ * asserts the inclusion of some keys when using the+ * `include` or `contain` modifiers.+ *+ * expect({ foo: 1, bar: 2 }).to.have.keys(['foo', 'bar']);+ * expect({ foo: 1, bar: 2, baz: 3 }).to.contain.keys('foo', 'bar');+ *+ * @name keys+ * @alias key+ * @param {String...|Array} keys+ * @api public+ */++Assertion.prototype.keys = function(keys) {+ var obj = flag(this, 'object')+ , str+ , ok = true;++ keys = keys instanceof Array+ ? keys+ : Array.prototype.slice.call(arguments);++ if (!keys.length) throw new Error('keys required');++ var actual = Object.keys(obj)+ , len = keys.length;++ // Inclusion+ ok = keys.every(function(key){+ return ~actual.indexOf(key);+ });++ // Strict+ if (!flag(this, 'negate') && !flag(this, 'contains')) {+ ok = ok && keys.length == actual.length;+ }++ // Key string+ if (len > 1) {+ keys = keys.map(function(key){+ return util.inspect(key);+ });+ var last = keys.pop();+ str = keys.join(', ') + ', and ' + last;+ } else {+ str = util.inspect(keys[0]);+ }++ // Form+ str = (len > 1 ? 'keys ' : 'key ') + str;++ // Have / include+ str = (flag(this, 'contains') ? 'contain ' : 'have ') + str;++ // Assertion+ this.assert(+ ok+ , 'expected #{this} to ' + str+ , 'expected #{this} to not ' + str+ , keys+ , Object.keys(obj)+ );++ return this;+}++/**+ * ### .throw(constructor)+ *+ * Asserts that the function target will throw a specific error, or specific type of error+ * (as determined using `instanceof`), optionally with a RegExp or string inclusion test+ * for the error's message.+ *+ * var err = new ReferenceError('This is a bad function.');+ * var fn = function () { throw err; }+ * expect(fn).to.throw(ReferenceError);+ * expect(fn).to.throw(Error);+ * expect(fn).to.throw(/bad function/);+ * expect(fn).to.not.throw('good function');+ * expect(fn).to.throw(ReferenceError, /bad function/);+ * expect(fn).to.throw(err);+ * expect(fn).to.not.throw(new RangeError('Out of range.'));+ *+ * Please note that when a throw expectation is negated, it will check each+ * parameter independently, starting with error constructor type. The appropriate way+ * to check for the existence of a type of error but for a message that does not match+ * is to use `and`.+ *+ * expect(fn).to.throw(ReferenceError)+ * .and.not.throw(/good function/);+ *+ * @name throw+ * @alias throws+ * @alias Throw+ * @param {ErrorConstructor} constructor+ * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types+ * @api public+ */++Assertion.prototype.Throw = function (constructor, msg) {+ var obj = flag(this, 'object');+ new Assertion(obj).is.a('function');++ var thrown = false+ , desiredError = null+ , name = null;++ if (arguments.length === 0) {+ msg = null;+ constructor = null;+ } else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) {+ msg = constructor;+ constructor = null;+ } else if (constructor && constructor instanceof Error) {+ desiredError = constructor;+ constructor = null;+ msg = null;+ } else if (typeof constructor === 'function') {+ name = (new constructor()).name;+ } else {+ constructor = null;+ }++ try {+ obj();+ } catch (err) {+ // first, check desired error+ if (desiredError) {+ this.assert(+ err === desiredError+ , 'expected #{this} to throw ' + util.inspect(desiredError) + ' but ' + util.inspect(err) + ' was thrown'+ , 'expected #{this} to not throw ' + util.inspect(desiredError)+ );+ return this;+ }+ // next, check constructor+ if (constructor) {+ this.assert(+ err instanceof constructor+ , 'expected #{this} to throw ' + name + ' but a ' + err.name + ' was thrown'+ , 'expected #{this} to not throw ' + name );+ if (!msg) return this;+ }+ // next, check message+ if (err.message && msg && msg instanceof RegExp) {+ this.assert(+ msg.exec(err.message)+ , 'expected #{this} to throw error matching ' + msg + ' but got ' + util.inspect(err.message)+ , 'expected #{this} to throw error not matching ' + msg+ );+ return this;+ } else if (err.message && msg && 'string' === typeof msg) {+ this.assert(+ ~err.message.indexOf(msg)+ , 'expected #{this} to throw error including #{exp} but got #{act}'+ , 'expected #{this} to throw error not including #{act}'+ , msg+ , err.message+ );+ return this;+ } else {+ thrown = true;+ }+ }++ var expectedThrown = name ? name : desiredError ? util.inspect(desiredError) : 'an error';++ this.assert(+ thrown === true+ , 'expected #{this} to throw ' + expectedThrown+ , 'expected #{this} to not throw ' + expectedThrown);++ return this;+};++/**+ * ### .respondTo(method)+ *+ * Asserts that the object or class target will respond to a method.+ *+ * Klass.prototype.bar = function(){};+ * expect(Klass).to.respondTo('bar');+ * expect(obj).to.respondTo('bar');+ *+ * To check if a constructor will respond to a static function,+ * set the `itself` flag.+ *+ * Klass.baz = function(){};+ * expect(Klass).itself.to.respondTo('baz');+ *+ * @name respondTo+ * @param {String} method+ * @api public+ */++Assertion.prototype.respondTo = function (method) {+ var obj = flag(this, 'object')+ , itself = flag(this, 'itself')+ , context = ('function' === typeof obj && !itself)+ ? obj.prototype[method]+ : obj[method];++ this.assert(+ 'function' === typeof context+ , 'expected #{this} to respond to ' + util.inspect(method)+ , 'expected #{this} to not respond to ' + util.inspect(method)+ , 'function'+ , typeof context+ );++ return this;+};++/**+ * ### .itself+ *+ * Sets the `itself` flag, later used by the `respondTo` assertion.+ *+ * function Foo() {}+ * Foo.bar = function() {}+ * Foo.prototype.baz = function() {}+ *+ * expect(Foo).itself.to.respondTo('bar');+ * expect(Foo).itself.not.to.respondTo('baz');+ *+ * @name itself+ * @api public+ */+Object.defineProperty(Assertion.prototype, 'itself',+ { get: function () {+ flag(this, 'itself', true);+ return this;+ }+ , configurable: true+});++/**+ * ### .satisfy(method)+ *+ * Asserts that the target passes a given truth test.+ *+ * expect(1).to.satisfy(function(num) { return num > 0; });+ *+ * @name satisfy+ * @param {Function} matcher+ * @api public+ */++Assertion.prototype.satisfy = function (matcher) {+ var obj = flag(this, 'object');+ this.assert(+ matcher(obj)+ , 'expected #{this} to satisfy ' + util.inspect(matcher)+ , 'expected #{this} to not satisfy' + util.inspect(matcher)+ , this.negate ? false : true+ , matcher(obj)+ );++ return this;+};++/**+ * ### .closeTo(expected, delta)+ *+ * Asserts that the target is equal `expected`, to within a +/- `delta` range.+ *+ * expect(1.5).to.be.closeTo(1, 0.5);+ *+ * @name closeTo+ * @param {Number} expected+ * @param {Number} delta+ * @api public+ */++Assertion.prototype.closeTo = function (expected, delta) {+ var obj = flag(this, 'object');+ this.assert(+ (obj - delta === expected) || (obj + delta === expected)+ , 'expected #{this} to be close to ' + expected + ' +/- ' + delta+ , 'expected #{this} not to be close to ' + expected + ' +/- ' + delta);++ return this;+};++/*!+ * Aliases.+ */++(function alias(name, as){+ Assertion.prototype[as] = Assertion.prototype[name];+ return alias;+})+('equal', 'eq')+('above', 'gt')+('below', 'lt')+('length', 'lengthOf')+('keys', 'key')+('ownProperty', 'haveOwnProperty')+('above', 'greaterThan')+('below', 'lessThan')+('Throw', 'throws')+('Throw', 'throw')+('instanceOf', 'instanceof');++}); // module: assertion.js++require.register("browser/error.js", function(module, exports, require){+/*!+ * chai+ * Copyright(c) 2011-2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++module.exports = AssertionError;++function AssertionError (options) {+ options = options || {};+ this.message = options.message;+ this.actual = options.actual;+ this.expected = options.expected;+ this.operator = options.operator;++ if (options.stackStartFunction && Error.captureStackTrace) {+ var stackStartFunction = options.stackStartFunction;+ Error.captureStackTrace(this, stackStartFunction);+ }+}++AssertionError.prototype = Object.create(Error.prototype);+AssertionError.prototype.name = 'AssertionError';+AssertionError.prototype.constructor = AssertionError;++AssertionError.prototype.toString = function() {+ return this.message;+};++}); // module: browser/error.js++require.register("chai.js", function(module, exports, require){+/*!+ * chai+ * Copyright(c) 2011-2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++var used = []+ , exports = module.exports = {};++/*!+ * Chai version+ */++exports.version = '1.0.4';++/*!+ * Primary `Assertion` prototype+ */++exports.Assertion = require('./assertion');++/*!+ * Assertion Error+ */++exports.AssertionError = require('./browser/error');++/*!+ * Utils for plugins (not exported)+ */++var util = require('./utils');++/**+ * # .use(function)+ *+ * Provides a way to extend the internals of Chai+ *+ * @param {Function}+ * @returns {this} for chaining+ * @api public+ */++exports.use = function (fn) {+ if (!~used.indexOf(fn)) {+ fn(this, util);+ used.push(fn);+ }++ return this;+};++/*!+ * Expect interface+ */++var expect = require('./interface/expect');+exports.use(expect);++/*!+ * Should interface+ */++var should = require('./interface/should');+exports.use(should);++/*!+ * Assert interface+ */++var assert = require('./interface/assert');+exports.use(assert);++}); // module: chai.js++require.register("interface/assert.js", function(module, exports, require){+/*!+ * chai+ * Copyright(c) 2011-2012 Jake Luer <[email protected]>+ * MIT Licensed+ */+++module.exports = function (chai, util) {++ /*!+ * Chai dependencies.+ */++ var Assertion = chai.Assertion+ , flag = util.flag;++ /*!+ * Module export.+ */++ /**+ * ### assert(expression, message)+ *+ * Write your own test expressions.+ *+ * assert('foo' !== 'bar', 'foo is not bar');+ * assert(Array.isArray([]), 'empty arrays are arrays');+ *+ * @param {Mixed} expression to test for truthiness+ * @param {String} message to display on error+ * @name assert+ * @api public+ */++ var assert = chai.assert = function (express, errmsg) {+ var test = new Assertion(null);+ test.assert(+ express+ , errmsg+ , '[ negation message unavailable ]'+ );+ };++ /**+ * ### .fail(actual, expected, [message], [operator])+ *+ * Throw a failure. Node.js `assert` module-compatible.+ *+ * @name fail+ * @param {Mixed} actual+ * @param {Mixed} expected+ * @param {String} message+ * @param {String} operator+ * @api public+ */++ assert.fail = function (actual, expected, message, operator) {+ throw new chai.AssertionError({+ actual: actual+ , expected: expected+ , message: message+ , operator: operator+ , stackStartFunction: assert.fail+ });+ };++ /**+ * ### .ok(object, [message])+ *+ * Asserts that `object` is truthy.+ *+ * assert.ok('everything', 'everything is ok');+ * assert.ok(false, 'this will fail');+ *+ * @name ok+ * @param {Mixed} object to test+ * @param {String} message+ * @api public+ */++ assert.ok = function (val, msg) {+ new Assertion(val, msg).is.ok;+ };++ /**+ * ### .equal(actual, expected, [message])+ *+ * Asserts non-strict equality (`==`) of `actual` and `expected`.+ *+ * assert.equal(3, '3', '== coerces values to strings');+ *+ * @name equal+ * @param {Mixed} actual+ * @param {Mixed} expected+ * @param {String} message+ * @api public+ */++ assert.equal = function (act, exp, msg) {+ var test = new Assertion(act, msg);++ test.assert(+ exp == flag(test, 'object')+ , 'expected #{this} to equal #{exp}'+ , 'expected #{this} to not equal #{act}'+ , exp+ , act+ );+ };++ /**+ * ### .notEqual(actual, expected, [message])+ *+ * Asserts non-strict inequality (`!=`) of `actual` and `expected`.+ *+ * assert.notEqual(3, 4, 'these numbers are not equal');+ *+ * @name notEqual+ * @param {Mixed} actual+ * @param {Mixed} expected+ * @param {String} message+ * @api public+ */++ assert.notEqual = function (act, exp, msg) {+ var test = new Assertion(act, msg);++ test.assert(+ exp != flag(test, 'object')+ , 'expected #{this} to not equal #{exp}'+ , 'expected #{this} to equal #{act}'+ , exp+ , act+ );+ };++ /**+ * ### .strictEqual(actual, expected, [message])+ *+ * Asserts strict equality (`===`) of `actual` and `expected`.+ *+ * assert.strictEqual(true, true, 'these booleans are strictly equal');+ *+ * @name strictEqual+ * @param {Mixed} actual+ * @param {Mixed} expected+ * @param {String} message+ * @api public+ */++ assert.strictEqual = function (act, exp, msg) {+ new Assertion(act, msg).to.equal(exp);+ };++ /**+ * ### .notStrictEqual(actual, expected, [message])+ *+ * Asserts strict inequality (`!==`) of `actual` and `expected`.+ *+ * assert.notStrictEqual(3, '3', 'no coercion for strict equality');+ *+ * @name notStrictEqual+ * @param {Mixed} actual+ * @param {Mixed} expected+ * @param {String} message+ * @api public+ */++ assert.notStrictEqual = function (act, exp, msg) {+ new Assertion(act, msg).to.not.equal(exp);+ };++ /**+ * ### .deepEqual(actual, expected, [message])+ *+ * Asserts that `actual` is deeply equal to `expected`.+ *+ * assert.deepEqual({ tea: 'green' }, { tea: 'green' });+ *+ * @name deepEqual+ * @param {Mixed} actual+ * @param {Mixed} expected+ * @param {String} message+ * @api public+ */++ assert.deepEqual = function (act, exp, msg) {+ new Assertion(act, msg).to.eql(exp);+ };++ /**+ * ### .notDeepEqual(actual, expected, [message])+ *+ * Assert that `actual` is not deeply equal to `expected`.+ *+ * assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });+ *+ * @name notDeepEqual+ * @param {Mixed} actual+ * @param {Mixed} expected+ * @param {String} message+ * @api public+ */++ assert.notDeepEqual = function (act, exp, msg) {+ new Assertion(act, msg).to.not.eql(exp);+ };++ /**+ * ### .isTrue(value, [message])+ *+ * Asserts that `value` is true.+ *+ * var teaServed = true;+ * assert.isTrue(teaServed, 'the tea has been served');+ *+ * @name isTrue+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isTrue = function (val, msg) {+ new Assertion(val, msg).is['true'];+ };++ /**+ * ### .isFalse(value, [message])+ *+ * Asserts that `value` is false.+ *+ * var teaServed = false;+ * assert.isFalse(teaServed, 'no tea yet? hmm...');+ *+ * @name isFalse+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isFalse = function (val, msg) {+ new Assertion(val, msg).is['false'];+ };++ /**+ * ### .isNull(value, [message])+ *+ * Asserts that `value` is null.+ *+ * assert.isNull(err, 'there was no error');+ *+ * @name isNull+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isNull = function (val, msg) {+ new Assertion(val, msg).to.equal(null);+ };++ /**+ * ### .isNotNull(value, [message])+ *+ * Asserts that `value` is not null.+ *+ * var tea = 'tasty chai';+ * assert.isNotNull(tea, 'great, time for tea!');+ *+ * @name isNotNull+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isNotNull = function (val, msg) {+ new Assertion(val, msg).to.not.equal(null);+ };++ /**+ * ### .isUndefined(value, [message])+ *+ * Asserts that `value` is `undefined`.+ *+ * var tea;+ * assert.isUndefined(tea, 'no tea defined');+ *+ * @name isUndefined+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isUndefined = function (val, msg) {+ new Assertion(val, msg).to.equal(undefined);+ };++ /**+ * ### .isDefined(value, [message])+ *+ * Asserts that `value` is not `undefined`.+ *+ * var tea = 'cup of chai';+ * assert.isDefined(tea, 'tea has been defined');+ *+ * @name isUndefined+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isDefined = function (val, msg) {+ new Assertion(val, msg).to.not.equal(undefined);+ };++ /**+ * ### .isFunction(value, [message])+ *+ * Asserts that `value` is a function.+ *+ * function serveTea() { return 'cup of tea'; };+ * assert.isFunction(serveTea, 'great, we can have tea now');+ *+ * @name isFunction+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isFunction = function (val, msg) {+ new Assertion(val, msg).to.be.a('function');+ };++ /**+ * ### .isNotFunction(value, [message])+ *+ * Asserts that `value` is _not_ a function.+ *+ * var serveTea = [ 'heat', 'pour', 'sip' ];+ * assert.isNotFunction(serveTea, 'great, we have listed the steps');+ *+ * @name isNotFunction+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isNotFunction = function (val, msg) {+ new Assertion(val, msg).to.not.be.a('function');+ };++ /**+ * ### .isObject(value, [message])+ *+ * Asserts that `value` is an object (as revealed by+ * `Object.prototype.toString`).+ *+ * var selection = { name: 'Chai', serve: 'with spices' };+ * assert.isObject(selection, 'tea selection is an object');+ *+ * @name isObject+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isObject = function (val, msg) {+ new Assertion(val, msg).to.be.a('object');+ };++ /**+ * ### .isNotObject(value, [message])+ *+ * Asserts that `value` is _not_ an object.+ *+ * var selection = 'chai'+ * assert.isObject(selection, 'tea selection is not an object');+ * assert.isObject(null, 'null is not an object');+ *+ * @name isNotObject+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isNotObject = function (val, msg) {+ new Assertion(val, msg).to.not.be.a('object');+ };++ /**+ * ### .isArray(value, [message])+ *+ * Asserts that `value` is an array.+ *+ * var menu = [ 'green', 'chai', 'oolong' ];+ * assert.isArray(menu, 'what kind of tea do we want?');+ *+ * @name isArray+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isArray = function (val, msg) {+ new Assertion(val, msg).to.be.an('array');+ };++ /**+ * ### .isNotArray(value, [message])+ *+ * Asserts that `value` is _not_ an array.+ *+ * var menu = 'green|chai|oolong';+ * assert.isNotArray(menu, 'what kind of tea do we want?');+ *+ * @name isNotArray+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isNotArray = function (val, msg) {+ new Assertion(val, msg).to.not.be.an('array');+ };++ /**+ * ### .isString(value, [message])+ *+ * Asserts that `value` is a string.+ *+ * var teaOrder = 'chai';+ * assert.isString(teaOrder, 'order placed');+ *+ * @name isString+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isString = function (val, msg) {+ new Assertion(val, msg).to.be.a('string');+ };++ /**+ * ### .isNotString(value, [message])+ *+ * Asserts that `value` is _not_ a string.+ *+ * var teaOrder = 4;+ * assert.isNotString(teaOrder, 'order placed');+ *+ * @name isNotString+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isNotString = function (val, msg) {+ new Assertion(val, msg).to.not.be.a('string');+ };++ /**+ * ### .isNumber(value, [message])+ *+ * Asserts that `value` is a number.+ *+ * var cups = 2;+ * assert.isNumber(cups, 'how many cups');+ *+ * @name isNumber+ * @param {Number} value+ * @param {String} message+ * @api public+ */++ assert.isNumber = function (val, msg) {+ new Assertion(val, msg).to.be.a('number');+ };++ /**+ * ### .isNotNumber(value, [message])+ *+ * Asserts that `value` is _not_ a number.+ *+ * var cups = '2 cups please';+ * assert.isNotNumber(cups, 'how many cups');+ *+ * @name isNotNumber+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isNotNumber = function (val, msg) {+ new Assertion(val, msg).to.not.be.a('number');+ };++ /**+ * ### .isBoolean(value, [message])+ *+ * Asserts that `value` is a boolean.+ *+ * var teaReady = true+ * , teaServed = false;+ *+ * assert.isBoolean(teaReady, 'is the tea ready');+ * assert.isBoolean(teaServed, 'has tea been served');+ *+ * @name isBoolean+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isBoolean = function (val, msg) {+ new Assertion(val, msg).to.be.a('boolean');+ };++ /**+ * ### .isNotBoolean(value, [message])+ *+ * Asserts that `value` is _not_ a boolean.+ *+ * var teaReady = 'yep'+ * , teaServed = 'nope';+ *+ * assert.isNotBoolean(teaReady, 'is the tea ready');+ * assert.isNotBoolean(teaServed, 'has tea been served');+ *+ * @name isNotBoolean+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.isNotBoolean = function (val, msg) {+ new Assertion(val, msg).to.not.be.a('boolean');+ };++ /**+ * ### .typeOf(value, name, [message])+ *+ * Asserts that `value`'s type is `name`, as determined by+ * `Object.prototype.toString`.+ *+ * assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');+ * assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');+ * assert.typeOf('tea', 'string', 'we have a string');+ * assert.typeOf(/tea/, 'regexp', 'we have a regular expression');+ * assert.typeOf(null, 'null', 'we have a null');+ * assert.typeOf(undefined, 'undefined', 'we have an undefined');+ *+ * @name typeOf+ * @param {Mixed} value+ * @param {String} name+ * @param {String} message+ * @api public+ */++ assert.typeOf = function (val, type, msg) {+ new Assertion(val, msg).to.be.a(type);+ };++ /**+ * ### .notTypeOf(value, name, [message])+ *+ * Asserts that `value`'s type is _not_ `name`, as determined by+ * `Object.prototype.toString`.+ *+ * assert.notTypeOf('tea', 'number', 'strings are not numbers');+ *+ * @name notTypeOf+ * @param {Mixed} value+ * @param {String} typeof name+ * @param {String} message+ * @api public+ */++ assert.notTypeOf = function (val, type, msg) {+ new Assertion(val, msg).to.not.be.a(type);+ };++ /**+ * ### .instanceOf(object, constructor, [message])+ *+ * Asserts that `value` is an instance of `constructor`.+ *+ * var Tea = function (name) { this.name = name; }+ * , chai = new Tea('chai');+ *+ * assert.instanceOf(chai, Tea, 'chai is an instance of tea');+ *+ * @name instanceOf+ * @param {Object} object+ * @param {Constructor} constructor+ * @param {String} message+ * @api public+ */++ assert.instanceOf = function (val, type, msg) {+ new Assertion(val, msg).to.be.instanceOf(type);+ };++ /**+ * ### .notInstanceOf(object, constructor, [message])+ *+ * Asserts `value` is not an instance of `constructor`.+ *+ * var Tea = function (name) { this.name = name; }+ * , chai = new String('chai');+ *+ * assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');+ *+ * @name notInstanceOf+ * @param {Object} object+ * @param {Constructor} constructor+ * @param {String} message+ * @api public+ */++ assert.notInstanceOf = function (val, type, msg) {+ new Assertion(val, msg).to.not.be.instanceOf(type);+ };++ /**+ * ### .include(haystack, needle, [message])+ *+ * Asserts that `haystack` includes `needle`. Works+ * for strings and arrays.+ *+ * assert.include('foobar', 'bar', 'foobar contains string "bar"');+ * assert.include([ 1, 2, 3 ], 3, 'array contains value');+ *+ * @name include+ * @param {Array|String} haystack+ * @param {Mixed} needle+ * @param {String} message+ * @api public+ */++ assert.include = function (exp, inc, msg) {+ var obj = new Assertion(exp, msg);++ if (Array.isArray(exp)) {+ obj.to.include(inc);+ } else if ('string' === typeof exp) {+ obj.to.contain.string(inc);+ }+ };++ /**+ * ### .match(value, regexp, [message])+ *+ * Asserts that `value` matches the regular expression `regexp`.+ *+ * assert.match('foobar', /^foo/, 'regexp matches');+ *+ * @name match+ * @param {Mixed} value+ * @param {RegExp} regexp+ * @param {String} message+ * @api public+ */++ assert.match = function (exp, re, msg) {+ new Assertion(exp, msg).to.match(re);+ };++ /**+ * ### .notMatch(value, regexp, [message])+ *+ * Asserts that `value` does not match the regular expression `regexp`.+ *+ * assert.notMatch('foobar', /^foo/, 'regexp does not match');+ *+ * @name notMatch+ * @param {Mixed} value+ * @param {RegExp} regexp+ * @param {String} message+ * @api public+ */++ assert.notMatch = function (exp, re, msg) {+ new Assertion(exp, msg).to.not.match(re);+ };++ /**+ * ### .property(object, property, [message])+ *+ * Asserts that `object` has a property named by `property`.+ *+ * assert.property({ tea: { green: 'matcha' }}, 'tea');+ *+ * @name property+ * @param {Object} object+ * @param {String} property+ * @param {String} message+ * @api public+ */++ assert.property = function (obj, prop, msg) {+ new Assertion(obj, msg).to.have.property(prop);+ };++ /**+ * ### .notProperty(object, property, [message])+ *+ * Asserts that `object` does _not_ have a property named by `property`.+ *+ * assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');+ *+ * @name notProperty+ * @param {Object} object+ * @param {String} property+ * @param {String} message+ * @api public+ */++ assert.notProperty = function (obj, prop, msg) {+ new Assertion(obj, msg).to.not.have.property(prop);+ };++ /**+ * ### .deepProperty(object, property, [message])+ *+ * Asserts that `object` has a property named by `property`, which can be a+ * string using dot- and bracket-notation for deep reference.+ *+ * assert.deepProperty({ tea: { green: 'matcha' }}, 'tea.green');+ *+ * @name deepProperty+ * @param {Object} object+ * @param {String} property+ * @param {String} message+ * @api public+ */++ assert.deepProperty = function (obj, prop, msg) {+ new Assertion(obj, msg).to.have.deep.property(prop);+ };++ /**+ * ### .notDeepProperty(object, property, [message])+ *+ * Asserts that `object` does _not_ have a property named by `property`, which+ * can be a string using dot- and bracket-notation for deep reference.+ *+ * assert.notDeepProperty({ tea: { green: 'matcha' }}, 'tea.oolong');+ *+ * @name notDeepProperty+ * @param {Object} object+ * @param {String} property+ * @param {String} message+ * @api public+ */++ assert.notDeepProperty = function (obj, prop, msg) {+ new Assertion(obj, msg).to.not.have.deep.property(prop);+ };++ /**+ * ### .propertyVal(object, property, value, [message])+ *+ * Asserts that `object` has a property named by `property` with value given+ * by `value`.+ *+ * assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');+ *+ * @name propertyVal+ * @param {Object} object+ * @param {String} property+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.propertyVal = function (obj, prop, val, msg) {+ new Assertion(obj, msg).to.have.property(prop, val);+ };++ /**+ * ### .propertyNotVal(object, property, value, [message])+ *+ * Asserts that `object` has a property named by `property`, but with a value+ * different from that given by `value`.+ *+ * assert.propertyNotVal({ tea: 'is good' }, 'tea', 'is bad');+ *+ * @name propertyNotVal+ * @param {Object} object+ * @param {String} property+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.propertyNotVal = function (obj, prop, val, msg) {+ new Assertion(obj, msg).to.not.have.property(prop, val);+ };++ /**+ * ### .deepPropertyVal(object, property, value, [message])+ *+ * Asserts that `object` has a property named by `property` with value given+ * by `value`. `property` can use dot- and bracket-notation for deep+ * reference.+ *+ * assert.deepPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');+ *+ * @name deepPropertyVal+ * @param {Object} object+ * @param {String} property+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.deepPropertyVal = function (obj, prop, val, msg) {+ new Assertion(obj, msg).to.have.deep.property(prop, val);+ };++ /**+ * ### .deepPropertyNotVal(object, property, value, [message])+ *+ * Asserts that `object` has a property named by `property`, but with a value+ * different from that given by `value`. `property` can use dot- and+ * bracket-notation for deep reference.+ *+ * assert.deepPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');+ *+ * @name deepPropertyNotVal+ * @param {Object} object+ * @param {String} property+ * @param {Mixed} value+ * @param {String} message+ * @api public+ */++ assert.deepPropertyNotVal = function (obj, prop, val, msg) {+ new Assertion(obj, msg).to.not.have.deep.property(prop, val);+ };++ /**+ * ### .lengthOf(object, length, [message])+ *+ * Asserts that `object` has a `length` property with the expected value.+ *+ * assert.lengthOf([1,2,3], 3, 'array has length of 3');+ * assert.lengthOf('foobar', 5, 'string has length of 6');+ *+ * @name lengthOf+ * @param {Mixed} object+ * @param {Number} length+ * @param {String} message+ * @api public+ */++ assert.lengthOf = function (exp, len, msg) {+ new Assertion(exp, msg).to.have.length(len);+ };++ /**+ * ### .throws(function, [constructor/regexp], [message])+ *+ * Asserts that `function` will throw an error that is an instance of+ * `constructor`, or alternately that it will throw an error with message+ * matching `regexp`.+ *+ * assert.throw(fn, ReferenceError, 'function throws a reference error');+ *+ * @name throws+ * @alias throw+ * @alias Throw+ * @param {Function} function+ * @param {ErrorConstructor} constructor+ * @param {RegExp} regexp+ * @param {String} message+ * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types+ * @api public+ */++ assert.Throw = function (fn, type, msg) {+ if ('string' === typeof type) {+ msg = type;+ type = null;+ }++ new Assertion(fn, msg).to.Throw(type);+ };++ /**+ * ### .doesNotThrow(function, [constructor/regexp], [message])+ *+ * Asserts that `function` will _not_ throw an error that is an instance of+ * `constructor`, or alternately that it will not throw an error with message+ * matching `regexp`.+ *+ * assert.doesNotThrow(fn, Error, 'function does not throw');+ *+ * @name doesNotThrow+ * @param {Function} function+ * @param {ErrorConstructor} constructor+ * @param {RegExp} regexp+ * @param {String} message+ * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types+ * @api public+ */++ assert.doesNotThrow = function (fn, type, msg) {+ if ('string' === typeof type) {+ msg = type;+ type = null;+ }++ new Assertion(fn, msg).to.not.Throw(type);+ };++ /**+ * ### .operator(val1, operator, val2, [message])+ *+ * Compares two values using `operator`.+ *+ * assert.operator(1, '<', 2, 'everything is ok');+ * assert.operator(1, '>', 2, 'this will fail');+ *+ * @name operator+ * @param {Mixed} val1+ * @param {String} operator+ * @param {Mixed} val2+ * @param {String} message+ * @api public+ */++ assert.operator = function (val, operator, val2, msg) {+ if (!~['==', '===', '>', '>=', '<', '<=', '!=', '!=='].indexOf(operator)) {+ throw new Error('Invalid operator "' + operator + '"');+ }+ var test = new Assertion(eval(val + operator + val2), msg);+ test.assert(+ true === flag(test, 'object')+ , 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2)+ , 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2) );+ };++ /*!+ * Undocumented / untested+ */++ assert.ifError = function (val, msg) {+ new Assertion(val, msg).to.not.be.ok;+ };++ /*!+ * Aliases.+ */++ (function alias(name, as){+ assert[as] = assert[name];+ return alias;+ })+ ('Throw', 'throw')+ ('Throw', 'throws');+};++}); // module: interface/assert.js++require.register("interface/expect.js", function(module, exports, require){+/*!+ * chai+ * Copyright(c) 2011-2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++module.exports = function (chai, util) {+ chai.expect = function (val, message) {+ return new chai.Assertion(val, message);+ };+};+++}); // module: interface/expect.js++require.register("interface/should.js", function(module, exports, require){+/*!+ * chai+ * Copyright(c) 2011-2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++module.exports = function (chai, util) {+ var Assertion = chai.Assertion;++ function loadShould () {+ // modify Object.prototype to have `should`+ Object.defineProperty(Object.prototype, 'should',+ { set: function () {}+ , get: function(){+ if (this instanceof String || this instanceof Number) {+ return new Assertion(this.constructor(this));+ } else if (this instanceof Boolean) {+ return new Assertion(this == true);+ }+ return new Assertion(this);+ }+ , configurable: true+ });++ var should = {};++ should.equal = function (val1, val2) {+ new Assertion(val1).to.equal(val2);+ };++ should.Throw = function (fn, errt, errs) {+ new Assertion(fn).to.Throw(errt, errs);+ };++ should.exist = function (val) {+ new Assertion(val).to.exist;+ }++ // negation+ should.not = {}++ should.not.equal = function (val1, val2) {+ new Assertion(val1).to.not.equal(val2);+ };++ should.not.Throw = function (fn, errt, errs) {+ new Assertion(fn).to.not.Throw(errt, errs);+ };++ should.not.exist = function (val) {+ new Assertion(val).to.not.exist;+ }++ should['throw'] = should['Throw'];+ should.not['throw'] = should.not['Throw'];++ return should;+ };++ chai.should = loadShould;+ chai.Should = loadShould;+};++}); // module: interface/should.js++require.register("utils/addChainableMethod.js", function(module, exports, require){+/*!+ * Chai - addChainingMethod utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/*!+ * Module dependencies+ */++var transferFlags = require('./transferFlags');++/**+ * ### addChainableMethod (ctx, name, method, chainingBehavior)+ *+ * Adds a method to an object, such that the method can also be chained.+ *+ * utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {+ * var obj = utils.flag(this, 'object');+ * new chai.Assertion(obj).to.be.equal(str);+ * });+ *+ * Can also be accessed directly from `chai.Assertion`.+ *+ * chai.Assertion.addChainableMethod('foo', fn, chainingBehavior);+ *+ * The result can then be used as both a method assertion, executing both `method` and+ * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.+ *+ * expect(fooStr).to.be.foo('bar');+ * expect(fooStr).to.be.foo.equal('foo');+ *+ * @param {Object} ctx object to which the method is added+ * @param {String} name of method to add+ * @param {Function} method function to be used for `name`, when called+ * @param {Function} chainingBehavior function to be called every time the property is accessed+ * @name addChainableMethod+ * @api public+ */++module.exports = function (ctx, name, method, chainingBehavior) {+ if (typeof chainingBehavior !== 'function')+ chainingBehavior = function () { };++ Object.defineProperty(ctx, name,+ { get: function () {+ chainingBehavior.call(this);++ var assert = function () {+ var result = method.apply(this, arguments);+ return result === undefined ? this : result;+ };++ // Re-enumerate every time to better accomodate plugins.+ var asserterNames = Object.getOwnPropertyNames(ctx);+ asserterNames.forEach(function (asserterName) {+ var pd = Object.getOwnPropertyDescriptor(ctx, asserterName)+ , functionProtoPD = Object.getOwnPropertyDescriptor(Function.prototype, asserterName);+ // Avoid trying to overwrite things that we can't, like `length` and `arguments`.+ if (functionProtoPD && !functionProtoPD.configurable) return;+ if (asserterName === 'arguments') return; // @see chaijs/chai/issues/69+ Object.defineProperty(assert, asserterName, pd);+ });++ transferFlags(this, assert);+ return assert;+ }+ , configurable: true+ });+};++}); // module: utils/addChainableMethod.js++require.register("utils/addMethod.js", function(module, exports, require){+/*!+ * Chai - addMethod utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/**+ * ### addMethod (ctx, name, method)+ *+ * Adds a method to the prototype of an object.+ *+ * utils.addMethod(chai.Assertion.prototype, 'foo', function (str) {+ * var obj = utils.flag(this, 'object');+ * new chai.Assertion(obj).to.be.equal(str);+ * });+ *+ * Can also be accessed directly from `chai.Assertion`.+ *+ * chai.Assertion.addMethod('foo', fn);+ *+ * Then can be used as any other assertion.+ *+ * expect(fooStr).to.be.foo('bar');+ *+ * @param {Object} ctx object to which the method is added+ * @param {String} name of method to add+ * @param {Function} method function to be used for name+ * @name addMethod+ * @api public+ */++module.exports = function (ctx, name, method) {+ ctx[name] = function () {+ var result = method.apply(this, arguments);+ return result === undefined ? this : result;+ };+};++}); // module: utils/addMethod.js++require.register("utils/addProperty.js", function(module, exports, require){+/*!+ * Chai - addProperty utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/**+ * ### addProperty (ctx, name, getter)+ *+ * Adds a property to the prototype of an object.+ *+ * utils.addProperty(chai.Assertion.prototype, 'foo', function () {+ * var obj = utils.flag(this, 'object');+ * new chai.Assertion(obj).to.be.instanceof(Foo);+ * });+ *+ * Can also be accessed directly from `chai.Assertion`.+ *+ * chai.Assertion.addProperty('foo', fn);+ *+ * Then can be used as any other assertion.+ *+ * expect(myFoo).to.be.foo;+ *+ * @param {Object} ctx object to which the property is added+ * @param {String} name of property to add+ * @param {Function} getter function to be used for name+ * @name addProperty+ * @api public+ */++module.exports = function (ctx, name, getter) {+ Object.defineProperty(ctx, name,+ { get: function () {+ var result = getter.call(this);+ return result === undefined ? this : result;+ }+ , configurable: true+ });+};++}); // module: utils/addProperty.js++require.register("utils/eql.js", function(module, exports, require){+// This is directly from Node.js assert+// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/assert.js+++module.exports = _deepEqual;++// For browser implementation+if (!Buffer) {+ var Buffer = {+ isBuffer: function () {+ return false;+ }+ };+}++function _deepEqual(actual, expected) {+ // 7.1. All identical values are equivalent, as determined by ===.+ if (actual === expected) {+ return true;++ } else if (Buffer.isBuffer(actual) && Buffer.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 (actual instanceof Date && expected instanceof Date) {+ return actual.getTime() === expected.getTime();++ // 7.3. Other pairs that do not both pass typeof value == 'object',+ // equivalence is determined by ==.+ } else if (typeof actual != 'object' && typeof expected != 'object') {+ return actual === expected;++ // 7.4. 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 isUndefinedOrNull(value) {+ return value === null || value === undefined;+}++function isArguments(object) {+ return Object.prototype.toString.call(object) == '[object Arguments]';+}++function objEquiv(a, b) {+ if (isUndefinedOrNull(a) || isUndefinedOrNull(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 = Object.keys(a),+ kb = Object.keys(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;+}+}); // module: utils/eql.js++require.register("utils/flag.js", function(module, exports, require){+/*!+ * Chai - flag utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/**+ * ### flag(object ,key, [value])+ *+ * Get or set a flag value on an object. If a+ * value is provided it will be set, else it will+ * return the currently set value or `undefined` if+ * the value is not set.+ *+ * utils.flag(this, 'foo', 'bar'); // setter+ * utils.flag(this, 'foo'); // getter, returns `bar`+ *+ * @param {Object} object (constructed Assertion+ * @param {String} key+ * @param {Mixed} value (optional)+ * @name flag+ * @api private+ */++module.exports = function (obj, key, value) {+ var flags = obj.__flags || (obj.__flags = Object.create(null));+ if (arguments.length === 3) {+ flags[key] = value;+ } else {+ return flags[key];+ }+};++}); // module: utils/flag.js++require.register("utils/getActual.js", function(module, exports, require){+/*!+ * Chai - getActual utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/**+ * # getActual(object, [actual])+ *+ * Returns the `actual` value for an Assertion+ *+ * @param {Object} object (constructed Assertion)+ * @param {Arguments} chai.Assertion.prototype.assert arguments+ */++module.exports = function (obj, args) {+ var actual = args[4];+ return 'undefined' !== actual ? actual : obj.obj;+};++}); // module: utils/getActual.js++require.register("utils/getMessage.js", function(module, exports, require){+/*!+ * Chai - message composition utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/*!+ * Module dependancies+ */++var flag = require('./flag')+ , getActual = require('./getActual')+ , inspect = require('./inspect');++/**+ * # getMessage(object, message, negateMessage)+ *+ * Construct the error message based on flags+ * and template tags. Template tags will return+ * a stringified inspection of the object referenced.+ *+ * Messsage template tags:+ * - `#{this}` current asserted object+ * - `#{act}` actual value+ * - `#{exp}` expected value+ *+ * @param {Object} object (constructed Assertion)+ * @param {Arguments} chai.Assertion.prototype.assert arguments+ */++module.exports = function (obj, args) {+ var negate = flag(obj, 'negate')+ , val = flag(obj, 'object')+ , expected = args[3]+ , actual = getActual(obj, args)+ , msg = negate ? args[2] : args[1]+ , flagMsg = flag(obj, 'message');++ msg = msg || '';+ msg = msg+ .replace(/#{this}/g, inspect(val))+ .replace(/#{act}/g, inspect(actual))+ .replace(/#{exp}/g, inspect(expected));++ return flagMsg ? flagMsg + ': ' + msg : msg;+};++}); // module: utils/getMessage.js++require.register("utils/getName.js", function(module, exports, require){+/*!+ * Chai - getName utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/**+ * # getName(func)+ *+ * Gets the name of a function, in a cross-browser way.+ *+ * @param {Function} a function (usually a constructor)+ */++module.exports = function (func) {+ if (func.name) return func.name;++ var match = /^\s?function ([^(]*)\(/.exec(func);+ return match && match[1] ? match[1] : "";+};++}); // module: utils/getName.js++require.register("utils/getPathValue.js", function(module, exports, require){+/*!+ * Chai - getPathValue utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * @see https://github.com/logicalparadox/filtr+ * MIT Licensed+ */++/**+ * ### .getPathValue(path, object)+ *+ * This allows the retrieval of values in an+ * object given a string path.+ *+ * var obj = {+ * prop1: {+ * arr: ['a', 'b', 'c']+ * , str: 'Hello'+ * }+ * , prop2: {+ * arr: [ { nested: 'Universe' } ]+ * , str: 'Hello again!'+ * }+ * }+ *+ * The following would be the results.+ *+ * getPathValue('prop1.str', obj); // Hello+ * getPathValue('prop1.att[2]', obj); // b+ * getPathValue('prop2.arr[0].nested', obj); // Universe+ *+ * @param {String} path+ * @param {Object} object+ * @returns {Object} value or `undefined`+ * @name getPathValue+ * @api public+ */++var getPathValue = module.exports = function (path, obj) {+ var parsed = parsePath(path);+ return _getPathValue(parsed, obj);+};++/*!+ * ## parsePath(path)+ *+ * Helper function used to parse string object+ * paths. Use in conjunction with `_getPathValue`.+ *+ * var parsed = parsePath('myobject.property.subprop');+ *+ * ### Paths:+ *+ * * Can be as near infinitely deep and nested+ * * Arrays are also valid using the formal `myobject.document[3].property`.+ *+ * @param {String} path+ * @returns {Object} parsed+ * @api private+ */++function parsePath (path) {+ var parts = path.split('.').filter(Boolean);+ return parts.map(function (value) {+ var re = /([A-Za-z0-9]+)\[(\d+)\]$/+ , mArr = re.exec(value)+ , val;+ if (mArr) val = { p: mArr[1], i: parseFloat(mArr[2]) };+ return val || value;+ });+};++/*!+ * ## _getPathValue(parsed, obj)+ *+ * Helper companion function for `.parsePath` that returns+ * the value located at the parsed address.+ *+ * var value = getPathValue(parsed, obj);+ *+ * @param {Object} parsed definition from `parsePath`.+ * @param {Object} object to search against+ * @returns {Object|Undefined} value+ * @api private+ */++function _getPathValue (parsed, obj) {+ var tmp = obj+ , res;+ for (var i = 0, l = parsed.length; i < l; i++) {+ var part = parsed[i];+ if (tmp) {+ if ('object' === typeof part && tmp[part.p]) {+ tmp = tmp[part.p][part.i];+ } else {+ tmp = tmp[part];+ }+ if (i == (l - 1)) res = tmp;+ } else {+ res = undefined;+ }+ }+ return res;+};++}); // module: utils/getPathValue.js++require.register("utils/index.js", function(module, exports, require){+/*!+ * chai+ * Copyright(c) 2011 Jake Luer <[email protected]>+ * MIT Licensed+ */++/*!+ * Main exports+ */++var exports = module.exports = {};++/*!+ * test utility+ */++exports.test = require('./test');++/*!+ * message utility+ */++exports.getMessage = require('./getMessage');++/*!+ * actual utility+ */++exports.getActual = require('./getActual');++/*!+ * Inspect util+ */++exports.inspect = require('./inspect');++/*!+ * Flag utility+ */++exports.flag = require('./flag');++/*!+ * Flag transferring utility+ */++exports.transferFlags = require('./transferFlags');++/*!+ * Deep equal utility+ */++exports.eql = require('./eql');++/*!+ * Deep path value+ */++exports.getPathValue = require('./getPathValue');++/*!+ * Function name+ */++exports.getName = require('./getName');++/*!+ * add Property+ */++exports.addProperty = require('./addProperty');++/*!+ * add Method+ */++exports.addMethod = require('./addMethod');++/*!+ * overwrite Property+ */++exports.overwriteProperty = require('./overwriteProperty');++/*!+ * overwrite Method+ */++exports.overwriteMethod = require('./overwriteMethod');++/*!+ * Add a chainable method+ */++exports.addChainableMethod = require('./addChainableMethod');+++}); // module: utils/index.js++require.register("utils/inspect.js", function(module, exports, require){+// This is (almost) directly from Node.js utils+// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js++var getName = require('./getName');++module.exports = inspect;++/**+ * 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 {Boolean} showHidden Flag that shows hidden (not enumerable)+ * properties of objects.+ * @param {Number} depth Depth in which to descend in object. Default is 2.+ * @param {Boolean} colors Flag to turn on ANSI escape codes to color the+ * output. Default is false (no coloring).+ */+function inspect(obj, showHidden, depth, colors) {+ var ctx = {+ showHidden: showHidden,+ seen: [],+ stylize: function (str) { return str; }+ };+ return formatValue(ctx, obj, (typeof depth === 'undefined' ? 2 : depth));+}++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 (value && typeof value.inspect === 'function' &&+ // 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)) {+ return value.inspect(recurseTimes);+ }++ // Primitive types cannot have properties+ var primitive = formatPrimitive(ctx, value);+ if (primitive) {+ return primitive;+ }++ // Look up the keys of the object.+ var visibleKeys = Object.keys(value);+ var keys = ctx.showHidden ? Object.getOwnPropertyNames(value) : visibleKeys;++ // Some type of object without properties can be shortcutted.+ // In IE, errors have a single `stack` property, or if they are vanilla `Error`,+ // a `stack` plus `description` property; ignore those for consistency.+ if (keys.length === 0 || (isError(value) && (+ (keys.length === 1 && keys[0] === 'stack') ||+ (keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack')+ ))) {+ if (typeof value === 'function') {+ var name = getName(value);+ var nameSuffix = name ? ': ' + name : '';+ return ctx.stylize('[Function' + nameSuffix + ']', 'special');+ }+ if (isRegExp(value)) {+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');+ }+ if (isDate(value)) {+ return ctx.stylize(Date.prototype.toUTCString.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 (typeof value === 'function') {+ 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)) {+ return 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) {+ switch (typeof value) {+ case 'undefined':+ return ctx.stylize('undefined', 'undefined');++ case 'string':+ var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')+ .replace(/'/g, "\\'")+ .replace(/\\"/g, '"') + '\'';+ return ctx.stylize(simple, 'string');++ case 'number':+ return ctx.stylize('' + value, 'number');++ case 'boolean':+ return ctx.stylize('' + value, 'boolean');+ }+ // For some reason typeof null is "object", so special case here.+ if (value === null) {+ 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 (Object.prototype.hasOwnProperty.call(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;+ if (value.__lookupGetter__) {+ if (value.__lookupGetter__(key)) {+ if (value.__lookupSetter__(key)) {+ str = ctx.stylize('[Getter/Setter]', 'special');+ } else {+ str = ctx.stylize('[Getter]', 'special');+ }+ } else {+ if (value.__lookupSetter__(key)) {+ str = ctx.stylize('[Setter]', 'special');+ }+ }+ }+ if (visibleKeys.indexOf(key) < 0) {+ name = '[' + key + ']';+ }+ if (!str) {+ if (ctx.seen.indexOf(value[key]) < 0) {+ if (recurseTimes === null) {+ str = formatValue(ctx, value[key], null);+ } else {+ str = formatValue(ctx, value[key], 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 (typeof name === 'undefined') {+ 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.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];+}++function isArray(ar) {+ return Array.isArray(ar) ||+ (typeof ar === 'object' && objectToString(ar) === '[object Array]');+}++function isRegExp(re) {+ return typeof re === 'object' && objectToString(re) === '[object RegExp]';+}++function isDate(d) {+ return typeof d === 'object' && objectToString(d) === '[object Date]';+}++function isError(e) {+ return typeof e === 'object' && objectToString(e) === '[object Error]';+}++function objectToString(o) {+ return Object.prototype.toString.call(o);+}++}); // module: utils/inspect.js++require.register("utils/overwriteMethod.js", function(module, exports, require){+/*!+ * Chai - overwriteMethod utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/**+ * ### overwriteMethod (ctx, name, fn)+ *+ * Overwites an already existing method and provides+ * access to previous function. Must return function+ * to be used for name.+ *+ * utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) {+ * return function (str) {+ * var obj = utils.flag(this, 'object');+ * if (obj instanceof Foo) {+ * new chai.Assertion(obj.value).to.equal(str);+ * } else {+ * _super.apply(this, arguments);+ * }+ * }+ * });+ *+ * Can also be accessed directly from `chai.Assertion`.+ *+ * chai.Assertion.overwriteMethod('foo', fn);+ *+ * Then can be used as any other assertion.+ *+ * expect(myFoo).to.equal('bar');+ *+ * @param {Object} ctx object whose method is to be overwritten+ * @param {String} name of method to overwrite+ * @param {Function} method function that returns a function to be used for name+ * @name overwriteMethod+ * @api public+ */++module.exports = function (ctx, name, method) {+ var _method = ctx[name]+ , _super = function () { return this; };++ if (_method && 'function' === typeof _method)+ _super = _method;++ ctx[name] = function () {+ var result = method(_super).apply(this, arguments);+ return result === undefined ? this : result;+ }+};++}); // module: utils/overwriteMethod.js++require.register("utils/overwriteProperty.js", function(module, exports, require){+/*!+ * Chai - overwriteProperty utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/**+ * ### overwriteProperty (ctx, name, fn)+ *+ * Overwites an already existing property getter and provides+ * access to previous value. Must return function to use as getter.+ *+ * utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) {+ * return function () {+ * var obj = utils.flag(this, 'object');+ * if (obj instanceof Foo) {+ * new chai.Assertion(obj.name).to.equal('bar');+ * } else {+ * _super.call(this);+ * }+ * }+ * });+ *+ *+ * Can also be accessed directly from `chai.Assertion`.+ *+ * chai.Assertion.overwriteProperty('foo', fn);+ *+ * Then can be used as any other assertion.+ *+ * expect(myFoo).to.be.ok;+ *+ * @param {Object} ctx object whose property is to be overwritten+ * @param {String} name of property to overwrite+ * @param {Function} getter function that returns a getter function to be used for name+ * @name overwriteProperty+ * @api public+ */++module.exports = function (ctx, name, getter) {+ var _get = Object.getOwnPropertyDescriptor(ctx, name)+ , _super = function () {};++ if (_get && 'function' === typeof _get.get)+ _super = _get.get++ Object.defineProperty(ctx, name,+ { get: function () {+ var result = getter(_super).call(this);+ return result === undefined ? this : result;+ }+ , configurable: true+ });+};++}); // module: utils/overwriteProperty.js++require.register("utils/test.js", function(module, exports, require){+/*!+ * Chai - test utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/*!+ * Module dependancies+ */++var flag = require('./flag');++/**+ * # test(object, expression)+ *+ * Test and object for expression.+ *+ * @param {Object} object (constructed Assertion)+ * @param {Arguments} chai.Assertion.prototype.assert arguments+ */++module.exports = function (obj, args) {+ var negate = flag(obj, 'negate')+ , expr = args[0];+ return negate ? !expr : expr;+};++}); // module: utils/test.js++require.register("utils/transferFlags.js", function(module, exports, require){+/*!+ * Chai - transferFlags utility+ * Copyright(c) 2012 Jake Luer <[email protected]>+ * MIT Licensed+ */++/**+ * ### transferFlags(assertion, object, includeAll = true)+ *+ * Transfer all the flags for `assertion` to `object`. If+ * `includeAll` is set to `false`, then the base Chai+ * assertion flags (namely `object`, `ssfi`, and `message`)+ * will not be transferred.+ *+ *+ * var newAssertion = new Assertion();+ * utils.transferFlags(assertion, newAssertion);+ *+ * var anotherAsseriton = new Assertion(myObj);+ * utils.transferFlags(assertion, anotherAssertion, false);+ *+ * @param {Assertion} assertion the assertion to transfer the flags from+ * @param {Object} object the object to transfer the flags too; usually a new assertion+ * @param {Boolean} includeAll+ * @name getAllFlags+ * @api private+ */++module.exports = function (assertion, object, includeAll) {+ var flags = assertion.__flags || (assertion.__flags = Object.create(null));++ if (!object.__flags) {+ object.__flags = Object.create(null);+ }++ includeAll = arguments.length === 3 ? includeAll : true;++ for (var flag in flags) {+ if (includeAll ||+ (flag !== 'object' && flag !== 'ssfi' && flag != 'message')) {+ object.__flags[flag] = flags[flag];+ }+ }+};++}); // module: utils/transferFlags.js+++ return require('chai');+});\ No newline at end of filediff --git a/example/mocha.css b/example/mocha.cssnew file mode 100644index 00000000..cdfea1a2--- /dev/null+++ b/example/mocha.css@@ -0,0 +1,182 @@++body {+ font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;+ padding: 60px 50px;+}++#mocha ul, #mocha li {+ margin: 0;+ padding: 0;+}++#mocha ul {+ list-style: none;+}++#mocha h1, #mocha h2 {+ margin: 0;+}++#mocha h1 {+ margin-top: 15px;+ font-size: 1em;+ font-weight: 200;+}++#mocha h1 a {+ text-decoration: none;+ color: inherit;+}++#mocha h1 a:hover {+ text-decoration: underline;+}++#mocha .suite .suite h1 {+ margin-top: 0;+ font-size: .8em;+}++#mocha h2 {+ font-size: 12px;+ font-weight: normal;+ cursor: pointer;+}++#mocha .suite {+ margin-left: 15px;+}++#mocha .test {+ margin-left: 15px;+}++#mocha .test:hover h2::after {+ position: relative;+ top: 0;+ right: -10px;+ content: '(view source)';+ font-size: 12px;+ font-family: arial;+ color: #888;+}++#mocha .test.pending:hover h2::after {+ content: '(pending)';+ font-family: arial;+}++#mocha .test.pass.medium .duration {+ background: #C09853;+}++#mocha .test.pass.slow .duration {+ background: #B94A48;+}++#mocha .test.pass::before {+ content: '✓';+ font-size: 12px;+ display: block;+ float: left;+ margin-right: 5px;+ color: #00d6b2;+}++#mocha .test.pass .duration {+ font-size: 9px;+ margin-left: 5px;+ padding: 2px 5px;+ color: white;+ -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);+ -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);+ box-shadow: inset 0 1px 1px rgba(0,0,0,.2);+ -webkit-border-radius: 5px;+ -moz-border-radius: 5px;+ -ms-border-radius: 5px;+ -o-border-radius: 5px;+ border-radius: 5px;+}++#mocha .test.pass.fast .duration {+ display: none;+}++#mocha .test.pending {+ color: #0b97c4;+}++#mocha .test.pending::before {+ content: '◦';+ color: #0b97c4;+}++#mocha .test.fail {+ color: #c00;+}++#mocha .test.fail pre {+ color: black;+}++#mocha .test.fail::before {+ content: '✖';+ font-size: 12px;+ display: block;+ float: left;+ margin-right: 5px;+ color: #c00;+}++#mocha .test pre.error {+ color: #c00;+}++#mocha .test pre {+ display: inline-block;+ font: 12px/1.5 monaco, monospace;+ margin: 5px;+ padding: 15px;+ border: 1px solid #eee;+ border-bottom-color: #ddd;+ -webkit-border-radius: 3px;+ -webkit-box-shadow: 0 1px 3px #eee;+}++#error {+ color: #c00;+ font-size: 1.5 em;+ font-weight: 100;+ letter-spacing: 1px;+}++#stats {+ position: fixed;+ top: 15px;+ right: 10px;+ font-size: 12px;+ margin: 0;+ color: #888;+}++#stats .progress {+ float: right;+ padding-top: 0;+}++#stats em {+ color: black;+}++#stats li {+ display: inline-block;+ margin: 0 5px;+ list-style: none;+ padding-top: 11px;+}++code .comment { color: #ddd }+code .init { color: #2F6FAD }+code .string { color: #5890AD }+code .keyword { color: #8A6343 }+code .number { color: #2F6FAD }diff --git a/example/mocha.js b/example/mocha.jsnew file mode 100644index 00000000..e0c3856f--- /dev/null+++ b/example/mocha.js@@ -0,0 +1,4226 @@+;(function(){+++// CommonJS require()++function require(p){+ var path = require.resolve(p)+ , mod = require.modules[path];+ if (!mod) throw new Error('failed to require "' + p + '"');+ if (!mod.exports) {+ mod.exports = {};+ mod.call(mod.exports, mod, mod.exports, require.relative(path));+ }+ return mod.exports;+ }++require.modules = {};++require.resolve = function (path){+ var orig = path+ , reg = path + '.js'+ , index = path + '/index.js';+ return require.modules[reg] && reg+ || require.modules[index] && index+ || orig;+ };++require.register = function (path, fn){+ require.modules[path] = fn;+ };++require.relative = function (parent) {+ return function(p){+ if ('.' != p.charAt(0)) return require(p);++ var path = parent.split('/')+ , segs = p.split('/');+ path.pop();++ for (var i = 0; i < segs.length; i++) {+ var seg = segs[i];+ if ('..' == seg) path.pop();+ else if ('.' != seg) path.push(seg);+ }++ return require(path.join('/'));+ };+ };+++require.register("browser/debug.js", function(module, exports, require){++module.exports = function(type){+ return function(){++ }+};+}); // module: browser/debug.js++require.register("browser/diff.js", function(module, exports, require){++}); // module: browser/diff.js++require.register("browser/events.js", function(module, exports, require){++/**+ * Module exports.+ */++exports.EventEmitter = EventEmitter;++/**+ * Check if `obj` is an array.+ */++function isArray(obj) {+ return '[object Array]' == {}.toString.call(obj);+}++/**+ * Event emitter constructor.+ *+ * @api public+ */++function EventEmitter(){};++/**+ * Adds a listener.+ *+ * @api public+ */++EventEmitter.prototype.on = function (name, fn) {+ if (!this.$events) {+ this.$events = {};+ }++ if (!this.$events[name]) {+ this.$events[name] = fn;+ } else if (isArray(this.$events[name])) {+ this.$events[name].push(fn);+ } else {+ this.$events[name] = [this.$events[name], fn];+ }++ return this;+};++EventEmitter.prototype.addListener = EventEmitter.prototype.on;++/**+ * Adds a volatile listener.+ *+ * @api public+ */++EventEmitter.prototype.once = function (name, fn) {+ var self = this;++ function on () {+ self.removeListener(name, on);+ fn.apply(this, arguments);+ };++ on.listener = fn;+ this.on(name, on);++ return this;+};++/**+ * Removes a listener.+ *+ * @api public+ */++EventEmitter.prototype.removeListener = function (name, fn) {+ if (this.$events && this.$events[name]) {+ var list = this.$events[name];++ if (isArray(list)) {+ var pos = -1;++ for (var i = 0, l = list.length; i < l; i++) {+ if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {+ pos = i;+ break;+ }+ }++ if (pos < 0) {+ return this;+ }++ list.splice(pos, 1);++ if (!list.length) {+ delete this.$events[name];+ }+ } else if (list === fn || (list.listener && list.listener === fn)) {+ delete this.$events[name];+ }+ }++ return this;+};++/**+ * Removes all listeners for an event.+ *+ * @api public+ */++EventEmitter.prototype.removeAllListeners = function (name) {+ if (name === undefined) {+ this.$events = {};+ return this;+ }++ if (this.$events && this.$events[name]) {+ this.$events[name] = null;+ }++ return this;+};++/**+ * Gets all listeners for a certain event.+ *+ * @api public+ */++EventEmitter.prototype.listeners = function (name) {+ if (!this.$events) {+ this.$events = {};+ }++ if (!this.$events[name]) {+ this.$events[name] = [];+ }++ if (!isArray(this.$events[name])) {+ this.$events[name] = [this.$events[name]];+ }++ return this.$events[name];+};++/**+ * Emits an event.+ *+ * @api public+ */++EventEmitter.prototype.emit = function (name) {+ if (!this.$events) {+ return false;+ }++ var handler = this.$events[name];++ if (!handler) {+ return false;+ }++ var args = [].slice.call(arguments, 1);++ if ('function' == typeof handler) {+ handler.apply(this, args);+ } else if (isArray(handler)) {+ var listeners = handler.slice();++ for (var i = 0, l = listeners.length; i < l; i++) {+ listeners[i].apply(this, args);+ }+ } else {+ return false;+ }++ return true;+};+}); // module: browser/events.js++require.register("browser/fs.js", function(module, exports, require){++}); // module: browser/fs.js++require.register("browser/path.js", function(module, exports, require){++}); // module: browser/path.js++require.register("browser/progress.js", function(module, exports, require){++/**+ * Expose `Progress`.+ */++module.exports = Progress;++/**+ * Initialize a new `Progress` indicator.+ */++function Progress() {+ this.percent = 0;+ this.size(0);+ this.fontSize(11);+ this.font('helvetica, arial, sans-serif');+}++/**+ * Set progress size to `n`.+ *+ * @param {Number} n+ * @return {Progress} for chaining+ * @api public+ */++Progress.prototype.size = function(n){+ this._size = n;+ return this;+};++/**+ * Set text to `str`.+ *+ * @param {String} str+ * @return {Progress} for chaining+ * @api public+ */++Progress.prototype.text = function(str){+ this._text = str;+ return this;+};++/**+ * Set font size to `n`.+ *+ * @param {Number} n+ * @return {Progress} for chaining+ * @api public+ */++Progress.prototype.fontSize = function(n){+ this._fontSize = n;+ return this;+};++/**+ * Set font `family`.+ *+ * @param {String} family+ * @return {Progress} for chaining+ */++Progress.prototype.font = function(family){+ this._font = family;+ return this;+};++/**+ * Update percentage to `n`.+ *+ * @param {Number} n+ * @return {Progress} for chaining+ */++Progress.prototype.update = function(n){+ this.percent = n;+ return this;+};++/**+ * Draw on `ctx`.+ *+ * @param {CanvasRenderingContext2d} ctx+ * @return {Progress} for chaining+ */++Progress.prototype.draw = function(ctx){+ var percent = Math.min(this.percent, 100)+ , size = this._size+ , half = size / 2+ , x = half+ , y = half+ , rad = half - 1+ , fontSize = this._fontSize;++ ctx.font = fontSize + 'px ' + this._font;++ var angle = Math.PI * 2 * (percent / 100);+ ctx.clearRect(0, 0, size, size);++ // outer circle+ ctx.strokeStyle = '#9f9f9f';+ ctx.beginPath();+ ctx.arc(x, y, rad, 0, angle, false);+ ctx.stroke();++ // inner circle+ ctx.strokeStyle = '#eee';+ ctx.beginPath();+ ctx.arc(x, y, rad - 1, 0, angle, true);+ ctx.stroke();++ // text+ var text = this._text || (percent | 0) + '%'+ , w = ctx.measureText(text).width;++ ctx.fillText(+ text+ , x - w / 2 + 1+ , y + fontSize / 2 - 1);++ return this;+};++}); // module: browser/progress.js++require.register("browser/tty.js", function(module, exports, require){++exports.isatty = function(){+ return true;+};++exports.getWindowSize = function(){+ return [window.innerHeight, window.innerWidth];+};+}); // module: browser/tty.js++require.register("context.js", function(module, exports, require){++/**+ * Expose `Context`.+ */++module.exports = Context;++/**+ * Initialize a new `Context`.+ *+ * @api private+ */++function Context(){}++/**+ * Set the context `Runnable` to `runnable`.+ *+ * @param {Runnable} runnable+ * @return {Context}+ * @api private+ */++Context.prototype.runnable = function(runnable){+ this._runnable = runnable;+ return this;+};++/**+ * Set test timeout `ms`.+ *+ * @param {Number} ms+ * @return {Context} self+ * @api private+ */++Context.prototype.timeout = function(ms){+ this._runnable.timeout(ms);+ return this;+};++/**+ * Inspect the context void of `._runnable`.+ *+ * @return {String}+ * @api private+ */++Context.prototype.inspect = function(){+ return JSON.stringify(this, function(key, val){+ return '_runnable' == key+ ? undefined+ : val;+ }, 2);+};++}); // module: context.js++require.register("hook.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Runnable = require('./runnable');++/**+ * Expose `Hook`.+ */++module.exports = Hook;++/**+ * Initialize a new `Hook` with the given `title` and callback `fn`.+ *+ * @param {String} title+ * @param {Function} fn+ * @api private+ */++function Hook(title, fn) {+ Runnable.call(this, title, fn);+ this.type = 'hook';+}++/**+ * Inherit from `Runnable.prototype`.+ */++Hook.prototype = new Runnable;+Hook.prototype.constructor = Hook;+++}); // module: hook.js++require.register("interfaces/bdd.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Suite = require('../suite')+ , Test = require('../test');++/**+ * BDD-style interface:+ *+ * describe('Array', function(){+ * describe('#indexOf()', function(){+ * it('should return -1 when not present', function(){+ *+ * });+ *+ * it('should return the index when present', function(){+ *+ * });+ * });+ * });+ *+ */++module.exports = function(suite){+ var suites = [suite];++ suite.on('pre-require', function(context){++ // noop variants++ context.xdescribe = function(){};+ context.xit = function(){};++ /**+ * Execute before running tests.+ */++ context.before = function(fn){+ suites[0].beforeAll(fn);+ };++ /**+ * Execute after running tests.+ */++ context.after = function(fn){+ suites[0].afterAll(fn);+ };++ /**+ * Execute before each test case.+ */++ context.beforeEach = function(fn){+ suites[0].beforeEach(fn);+ };++ /**+ * Execute after each test case.+ */++ context.afterEach = function(fn){+ suites[0].afterEach(fn);+ };++ /**+ * Describe a "suite" with the given `title`+ * and callback `fn` containing nested suites+ * and/or tests.+ */++ context.describe = context.context = function(title, fn){+ var suite = Suite.create(suites[0], title);+ suites.unshift(suite);+ fn();+ suites.shift();+ };++ /**+ * Describe a specification or test-case+ * with the given `title` and callback `fn`+ * acting as a thunk.+ */++ context.it = function(title, fn){+ suites[0].addTest(new Test(title, fn));+ };+ });+};++}); // module: interfaces/bdd.js++require.register("interfaces/exports.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Suite = require('../suite')+ , Test = require('../test');++/**+ * TDD-style interface:+ *+ * exports.Array = {+ * '#indexOf()': {+ * 'should return -1 when the value is not present': function(){+ *+ * },+ *+ * 'should return the correct index when the value is present': function(){+ *+ * }+ * }+ * };+ *+ */++module.exports = function(suite){+ var suites = [suite];++ suite.on('require', visit);++ function visit(obj) {+ var suite;+ for (var key in obj) {+ if ('function' == typeof obj[key]) {+ var fn = obj[key];+ switch (key) {+ case 'before':+ suites[0].beforeAll(fn);+ break;+ case 'after':+ suites[0].afterAll(fn);+ break;+ case 'beforeEach':+ suites[0].beforeEach(fn);+ break;+ case 'afterEach':+ suites[0].afterEach(fn);+ break;+ default:+ suites[0].addTest(new Test(key, fn));+ }+ } else {+ var suite = Suite.create(suites[0], key);+ suites.unshift(suite);+ visit(obj[key]);+ suites.shift();+ }+ }+ }+};+}); // module: interfaces/exports.js++require.register("interfaces/index.js", function(module, exports, require){++exports.bdd = require('./bdd');+exports.tdd = require('./tdd');+exports.qunit = require('./qunit');+exports.exports = require('./exports');++}); // module: interfaces/index.js++require.register("interfaces/qunit.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Suite = require('../suite')+ , Test = require('../test');++/**+ * QUnit-style interface:+ *+ * suite('Array');+ *+ * test('#length', function(){+ * var arr = [1,2,3];+ * ok(arr.length == 3);+ * });+ *+ * test('#indexOf()', function(){+ * var arr = [1,2,3];+ * ok(arr.indexOf(1) == 0);+ * ok(arr.indexOf(2) == 1);+ * ok(arr.indexOf(3) == 2);+ * });+ *+ * suite('String');+ *+ * test('#length', function(){+ * ok('foo'.length == 3);+ * });+ *+ */++module.exports = function(suite){+ var suites = [suite];++ suite.on('pre-require', function(context){++ /**+ * Execute before running tests.+ */++ context.before = function(fn){+ suites[0].beforeAll(fn);+ };++ /**+ * Execute after running tests.+ */++ context.after = function(fn){+ suites[0].afterAll(fn);+ };++ /**+ * Execute before each test case.+ */++ context.beforeEach = function(fn){+ suites[0].beforeEach(fn);+ };++ /**+ * Execute after each test case.+ */++ context.afterEach = function(fn){+ suites[0].afterEach(fn);+ };++ /**+ * Describe a "suite" with the given `title`.+ */++ context.suite = function(title){+ if (suites.length > 1) suites.shift();+ var suite = Suite.create(suites[0], title);+ suites.unshift(suite);+ };++ /**+ * Describe a specification or test-case+ * with the given `title` and callback `fn`+ * acting as a thunk.+ */++ context.test = function(title, fn){+ suites[0].addTest(new Test(title, fn));+ };+ });+};++}); // module: interfaces/qunit.js++require.register("interfaces/tdd.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Suite = require('../suite')+ , Test = require('../test');++/**+ * TDD-style interface:+ *+ * suite('Array', function(){+ * suite('#indexOf()', function(){+ * suiteSetup(function(){+ *+ * });+ *+ * test('should return -1 when not present', function(){+ *+ * });+ *+ * test('should return the index when present', function(){+ *+ * });+ *+ * suiteTeardown(function(){+ *+ * });+ * });+ * });+ *+ */++module.exports = function(suite){+ var suites = [suite];++ suite.on('pre-require', function(context){++ /**+ * Execute before each test case.+ */++ context.setup = function(fn){+ suites[0].beforeEach(fn);+ };++ /**+ * Execute after each test case.+ */++ context.teardown = function(fn){+ suites[0].afterEach(fn);+ };++ /**+ * Execute before the suite.+ */++ context.suiteSetup = function(fn){+ suites[0].beforeAll(fn);+ };++ /**+ * Execute after the suite.+ */++ context.suiteTeardown = function(fn){+ suites[0].afterAll(fn);+ };++ /**+ * Describe a "suite" with the given `title`+ * and callback `fn` containing nested suites+ * and/or tests.+ */++ context.suite = function(title, fn){+ var suite = Suite.create(suites[0], title);+ suites.unshift(suite);+ fn();+ suites.shift();+ };++ /**+ * Describe a specification or test-case+ * with the given `title` and callback `fn`+ * acting as a thunk.+ */++ context.test = function(title, fn){+ suites[0].addTest(new Test(title, fn));+ };+ });+};++}); // module: interfaces/tdd.js++require.register("mocha.js", function(module, exports, require){++/*!+ * mocha+ * Copyright(c) 2011 TJ Holowaychuk <[email protected]>+ * MIT Licensed+ */++/**+ * Module dependencies.+ */++var path = require('browser/path');++/**+ * Expose `Mocha`.+ */++exports = module.exports = Mocha;++/**+ * Library version.+ */++exports.version = '1.1.0';++/**+ * Expose internals.+ */++exports.utils = require('./utils');+exports.interfaces = require('./interfaces');+exports.reporters = require('./reporters');+exports.Runnable = require('./runnable');+exports.Context = require('./context');+exports.Runner = require('./runner');+exports.Suite = require('./suite');+exports.Hook = require('./hook');+exports.Test = require('./test');++/**+ * Return image `name` path.+ *+ * @param {String} name+ * @return {String}+ * @api private+ */++function image(name) {+ return __dirname + '/../images/' + name + '.png';+}++/**+ * Setup mocha with `options`.+ *+ * Options:+ *+ * - `ui` name "bdd", "tdd", "exports" etc+ * - `reporter` reporter instance, defaults to `mocha.reporters.Dot`+ * - `globals` array of accepted globals+ * - `timeout` timeout in milliseconds+ * - `ignoreLeaks` ignore global leaks+ * - `grep` string or regexp to filter tests with+ *+ * @param {Object} options+ * @api public+ */++function Mocha(options) {+ options = options || {};+ this.files = [];+ this.options = options;+ this.grep(options.grep);+ this.suite = new exports.Suite('', new exports.Context);+ this.ui(options.ui);+ this.reporter(options.reporter);+ if (options.timeout) this.suite.timeout(options.timeout);+}++/**+ * Add test `file`.+ *+ * @param {String} file+ * @api public+ */++Mocha.prototype.addFile = function(file){+ this.files.push(file);+ return this;+};++/**+ * Set reporter to `name`, defaults to "dot".+ *+ * @param {String} name+ * @api public+ */++Mocha.prototype.reporter = function(name){+ name = name || 'dot';+ this._reporter = require('./reporters/' + name);+ if (!this._reporter) throw new Error('invalid reporter "' + name + '"');+ return this;+};++/**+ * Set test UI `name`, defaults to "bdd".+ *+ * @param {String} bdd+ * @api public+ */++Mocha.prototype.ui = function(name){+ name = name || 'bdd';+ this._ui = exports.interfaces[name];+ if (!this._ui) throw new Error('invalid interface "' + name + '"');+ this._ui = this._ui(this.suite);+ return this;+};++/**+ * Load registered files.+ *+ * @api private+ */++Mocha.prototype.loadFiles = function(){+ var suite = this.suite;+ this.files.forEach(function(file){+ file = path.resolve(file);+ suite.emit('pre-require', global, file);+ suite.emit('require', require(file), file);+ suite.emit('post-require', global, file);+ });+};++/**+ * Enable growl support.+ *+ * @api private+ */++Mocha.prototype.growl = function(runner, reporter) {+ var notify = require('growl');++ runner.on('end', function(){+ var stats = reporter.stats;+ if (stats.failures) {+ var msg = stats.failures + ' of ' + runner.total + ' tests failed';+ notify(msg, { title: 'Failed', image: image('fail') });+ } else {+ notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {+ title: 'Passed'+ , image: image('pass')+ });+ }+ });+};++/**+ * Add regexp to grep for to the options object+ *+ * @param {RegExp} or {String} re+ * @return {Mocha}+ * @api public+ */++Mocha.prototype.grep = function(re){+ this.options.grep = 'string' == typeof re+ ? new RegExp(re)+ : re;+ return this;+};++/**+ * Run tests and invoke `fn()` when complete.+ *+ * @param {Function} fn+ * @return {Runner}+ * @api public+ */++Mocha.prototype.run = function(fn){+ this.loadFiles();+ var suite = this.suite;+ var options = this.options;+ var runner = new exports.Runner(suite);+ var reporter = new this._reporter(runner);+ runner.ignoreLeaks = options.ignoreLeaks;+ if (options.grep) runner.grep(options.grep);+ if (options.globals) runner.globals(options.globals);+ if (options.growl) this.growl(runner, reporter);+ return runner.run(fn);+};+}); // module: mocha.js++require.register("reporters/base.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var tty = require('browser/tty')+ , diff = require('browser/diff');++/**+ * Save timer references to avoid Sinon interfering (see GH-237).+ */++var Date = global.Date+ , setTimeout = global.setTimeout+ , setInterval = global.setInterval+ , clearTimeout = global.clearTimeout+ , clearInterval = global.clearInterval;++/**+ * Check if both stdio streams are associated with a tty.+ */++var isatty = tty.isatty(1) && tty.isatty(2);++/**+ * Expose `Base`.+ */++exports = module.exports = Base;++/**+ * Enable coloring by default.+ */++exports.useColors = isatty;++/**+ * Default color map.+ */++exports.colors = {+ 'pass': 90+ , 'fail': 31+ , 'bright pass': 92+ , 'bright fail': 91+ , 'bright yellow': 93+ , 'pending': 36+ , 'suite': 0+ , 'error title': 0+ , 'error message': 31+ , 'error stack': 90+ , 'checkmark': 32+ , 'fast': 90+ , 'medium': 33+ , 'slow': 31+ , 'green': 32+ , 'light': 90+ , 'diff gutter': 90+ , 'diff added': 42+ , 'diff removed': 41+};++/**+ * Color `str` with the given `type`,+ * allowing colors to be disabled,+ * as well as user-defined color+ * schemes.+ *+ * @param {String} type+ * @param {String} str+ * @return {String}+ * @api private+ */++var color = exports.color = function(type, str) {+ if (!exports.useColors) return str;+ return '\033[' + exports.colors[type] + 'm' + str + '\033[0m';+};++/**+ * Expose term window size, with some+ * defaults for when stderr is not a tty.+ */++exports.window = {+ width: isatty+ ? process.stdout.getWindowSize+ ? process.stdout.getWindowSize(1)[0]+ : tty.getWindowSize()[1]+ : 75+};++/**+ * Expose some basic cursor interactions+ * that are common among reporters.+ */++exports.cursor = {+ hide: function(){+ process.stdout.write('\033[?25l');+ },++ show: function(){+ process.stdout.write('\033[?25h');+ },++ deleteLine: function(){+ process.stdout.write('\033[2K');+ },++ beginningOfLine: function(){+ process.stdout.write('\033[0G');+ },++ CR: function(){+ exports.cursor.deleteLine();+ exports.cursor.beginningOfLine();+ }+};++/**+ * A test is considered slow if it+ * exceeds the following value in milliseconds.+ */++exports.slow = 75;++/**+ * Outut the given `failures` as a list.+ *+ * @param {Array} failures+ * @api public+ */++exports.list = function(failures){+ console.error();+ failures.forEach(function(test, i){+ // format+ var fmt = color('error title', ' %s) %s:\n')+ + color('error message', ' %s')+ + color('error stack', '\n%s\n');++ // msg+ var err = test.err+ , message = err.message || ''+ , stack = err.stack || message+ , index = stack.indexOf(message) + message.length+ , msg = stack.slice(0, index)+ , actual = err.actual+ , expected = err.expected;++ // actual / expected diff+ if ('string' == typeof actual && 'string' == typeof expected) {+ var len = Math.max(actual.length, expected.length);++ if (len < 20) msg = errorDiff(err, 'Chars');+ else msg = errorDiff(err, 'Words');++ // linenos+ var lines = msg.split('\n');+ if (lines.length > 4) {+ var width = String(lines.length).length;+ msg = lines.map(function(str, i){+ return pad(++i, width) + ' |' + ' ' + str;+ }).join('\n');+ }++ // legend+ msg = '\n'+ + color('diff removed', 'actual')+ + ' '+ + color('diff added', 'expected')+ + '\n\n'+ + msg+ + '\n';++ // indent+ msg = msg.replace(/^/gm, ' ');++ fmt = color('error title', ' %s) %s:\n%s')+ + color('error stack', '\n%s\n');+ }++ // indent stack trace without msg+ stack = stack.slice(index ? index + 1 : index)+ .replace(/^/gm, ' ');++ console.error(fmt, (i + 1), test.fullTitle(), msg, stack);+ });+};++/**+ * Initialize a new `Base` reporter.+ *+ * All other reporters generally+ * inherit from this reporter, providing+ * stats such as test duration, number+ * of tests passed / failed etc.+ *+ * @param {Runner} runner+ * @api public+ */++function Base(runner) {+ var self = this+ , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 }+ , failures = this.failures = [];++ if (!runner) return;+ this.runner = runner;++ runner.on('start', function(){+ stats.start = new Date;+ });++ runner.on('suite', function(suite){+ stats.suites = stats.suites || 0;+ suite.root || stats.suites++;+ });++ runner.on('test end', function(test){+ stats.tests = stats.tests || 0;+ stats.tests++;+ });++ runner.on('pass', function(test){+ stats.passes = stats.passes || 0;++ var medium = exports.slow / 2;+ test.speed = test.duration > exports.slow+ ? 'slow'+ : test.duration > medium+ ? 'medium'+ : 'fast';++ stats.passes++;+ });++ runner.on('fail', function(test, err){+ stats.failures = stats.failures || 0;+ stats.failures++;+ test.err = err;+ failures.push(test);+ });++ runner.on('end', function(){+ stats.end = new Date;+ stats.duration = new Date - stats.start;+ });++ runner.on('pending', function(){+ stats.pending++;+ });+}++/**+ * Output common epilogue used by many of+ * the bundled reporters.+ *+ * @api public+ */++Base.prototype.epilogue = function(){+ var stats = this.stats+ , fmt+ , tests;++ console.log();++ function pluralize(n) {+ return 1 == n ? 'test' : 'tests';+ }++ // failure+ if (stats.failures) {+ fmt = color('bright fail', ' ✖')+ + color('fail', ' %d of %d %s failed')+ + color('light', ':')++ console.error(fmt,+ stats.failures,+ this.runner.total,+ pluralize(this.runner.total));++ Base.list(this.failures);+ console.error();+ return;+ }++ // pass+ fmt = color('bright pass', ' ✔')+ + color('green', ' %d %s complete')+ + color('light', ' (%dms)');++ console.log(fmt,+ stats.tests || 0,+ pluralize(stats.tests),+ stats.duration);++ // pending+ if (stats.pending) {+ fmt = color('pending', ' •')+ + color('pending', ' %d %s pending');++ console.log(fmt, stats.pending, pluralize(stats.pending));+ }++ console.log();+};++/**+ * Pad the given `str` to `len`.+ *+ * @param {String} str+ * @param {String} len+ * @return {String}+ * @api private+ */++function pad(str, len) {+ str = String(str);+ return Array(len - str.length + 1).join(' ') + str;+}++/**+ * Return a character diff for `err`.+ *+ * @param {Error} err+ * @return {String}+ * @api private+ */++function errorDiff(err, type) {+ return diff['diff' + type](err.actual, err.expected).map(function(str){+ if (/^(\n+)$/.test(str.value)) str.value = Array(++RegExp.$1.length).join('<newline>');+ if (str.added) return colorLines('diff added', str.value);+ if (str.removed) return colorLines('diff removed', str.value);+ return str.value;+ }).join('');+}++/**+ * Color lines for `str`, using the color `name`.+ *+ * @param {String} name+ * @param {String} str+ * @return {String}+ * @api private+ */++function colorLines(name, str) {+ return str.split('\n').map(function(str){+ return color(name, str);+ }).join('\n');+}++}); // module: reporters/base.js++require.register("reporters/doc.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , utils = require('../utils');++/**+ * Expose `Doc`.+ */++exports = module.exports = Doc;++/**+ * Initialize a new `Doc` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Doc(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total+ , indents = 2;++ function indent() {+ return Array(indents).join(' ');+ }++ runner.on('suite', function(suite){+ if (suite.root) return;+ ++indents;+ console.log('%s<section class="suite">', indent());+ ++indents;+ console.log('%s<h1>%s</h1>', indent(), suite.title);+ console.log('%s<dl>', indent());+ });++ runner.on('suite end', function(suite){+ if (suite.root) return;+ console.log('%s</dl>', indent());+ --indents;+ console.log('%s</section>', indent());+ --indents;+ });++ runner.on('pass', function(test){+ console.log('%s <dt>%s</dt>', indent(), test.title);+ var code = utils.escape(clean(test.fn.toString()));+ console.log('%s <dd><pre><code>%s</code></pre></dd>', indent(), code);+ });+}++/**+ * Strip the function definition from `str`,+ * and re-indent for pre whitespace.+ */++function clean(str) {+ str = str+ .replace(/^function *\(.*\) *{/, '')+ .replace(/\s+\}$/, '');++ var spaces = str.match(/^\n?( *)/)[1].length+ , re = new RegExp('^ {' + spaces + '}', 'gm');++ str = str.replace(re, '');++ return str;+}+}); // module: reporters/doc.js++require.register("reporters/dot.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , color = Base.color;++/**+ * Expose `Dot`.+ */++exports = module.exports = Dot;++/**+ * Initialize a new `Dot` matrix test reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Dot(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , width = Base.window.width * .75 | 0+ , n = 0;++ runner.on('start', function(){+ process.stdout.write('\n ');+ });++ runner.on('pending', function(test){+ process.stdout.write(color('pending', '.'));+ });++ runner.on('pass', function(test){+ if (++n % width == 0) process.stdout.write('\n ');+ if ('slow' == test.speed) {+ process.stdout.write(color('bright yellow', '.'));+ } else {+ process.stdout.write(color(test.speed, '.'));+ }+ });++ runner.on('fail', function(test, err){+ if (++n % width == 0) process.stdout.write('\n ');+ process.stdout.write(color('fail', '.'));+ });++ runner.on('end', function(){+ console.log();+ self.epilogue();+ });+}++/**+ * Inherit from `Base.prototype`.+ */++Dot.prototype = new Base;+Dot.prototype.constructor = Dot;++}); // module: reporters/dot.js++require.register("reporters/html-cov.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var JSONCov = require('./json-cov')+ , fs = require('browser/fs');++/**+ * Expose `HTMLCov`.+ */++exports = module.exports = HTMLCov;++/**+ * Initialize a new `JsCoverage` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function HTMLCov(runner) {+ var jade = require('jade')+ , file = __dirname + '/templates/coverage.jade'+ , str = fs.readFileSync(file, 'utf8')+ , fn = jade.compile(str, { filename: file })+ , self = this;++ JSONCov.call(this, runner, false);++ runner.on('end', function(){+ process.stdout.write(fn({+ cov: self.cov+ , coverageClass: coverageClass+ }));+ });+}++function coverageClass(n) {+ if (n >= 75) return 'high';+ if (n >= 50) return 'medium';+ if (n >= 25) return 'low';+ return 'terrible';+}+}); // module: reporters/html-cov.js++require.register("reporters/html.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , utils = require('../utils')+ , Progress = require('../browser/progress')+ , escape = utils.escape;++/**+ * Save timer references to avoid Sinon interfering (see GH-237).+ */++var Date = global.Date+ , setTimeout = global.setTimeout+ , setInterval = global.setInterval+ , clearTimeout = global.clearTimeout+ , clearInterval = global.clearInterval;++/**+ * Expose `Doc`.+ */++exports = module.exports = HTML;++/**+ * Stats template.+ */++var statsTemplate = '<ul id="stats">'+ + '<li class="progress"><canvas width="40" height="40"></canvas></li>'+ + '<li class="passes">passes: <em>0</em></li>'+ + '<li class="failures">failures: <em>0</em></li>'+ + '<li class="duration">duration: <em>0</em>s</li>'+ + '</ul>';++/**+ * Initialize a new `Doc` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function HTML(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total+ , root = document.getElementById('mocha')+ , stat = fragment(statsTemplate)+ , items = stat.getElementsByTagName('li')+ , passes = items[1].getElementsByTagName('em')[0]+ , failures = items[2].getElementsByTagName('em')[0]+ , duration = items[3].getElementsByTagName('em')[0]+ , canvas = stat.getElementsByTagName('canvas')[0]+ , report = fragment('<ul id="report"></ul>')+ , stack = [report]+ , progress+ , ctx++ if (canvas.getContext) {+ ctx = canvas.getContext('2d');+ progress = new Progress;+ }++ if (!root) return error('#mocha div missing, add it to your document');++ root.appendChild(stat);+ root.appendChild(report);++ if (progress) progress.size(40);++ runner.on('suite', function(suite){+ if (suite.root) return;++ // suite+ var url = location.protocol + '//' + location.host + location.pathname + '?grep=^' + utils.escapeRegexp(suite.fullTitle());+ var el = fragment('<li class="suite"><h1><a href="%s">%s</a></h1></li>', url, suite.title);++ // container+ stack[0].appendChild(el);+ stack.unshift(document.createElement('ul'));+ el.appendChild(stack[0]);+ });++ runner.on('suite end', function(suite){+ if (suite.root) return;+ stack.shift();+ });++ runner.on('fail', function(test, err){+ if ('hook' == test.type || err.uncaught) runner.emit('test end', test);+ });++ runner.on('test end', function(test){+ // TODO: add to stats+ var percent = stats.tests / total * 100 | 0;+ if (progress) progress.update(percent).draw(ctx);++ // update stats+ var ms = new Date - stats.start;+ text(passes, stats.passes);+ text(failures, stats.failures);+ text(duration, (ms / 1000).toFixed(2));++ // test+ if ('passed' == test.state) {+ var el = fragment('<li class="test pass %e"><h2>%e<span class="duration">%ems</span></h2></li>', test.speed, test.title, test.duration);+ } else if (test.pending) {+ var el = fragment('<li class="test pass pending"><h2>%e</h2></li>', test.title);+ } else {+ var el = fragment('<li class="test fail"><h2>%e</h2></li>', test.title);+ var str = test.err.stack || test.err.toString();++ // FF / Opera do not add the message+ if (!~str.indexOf(test.err.message)) {+ str = test.err.message + '\n' + str;+ }++ // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we+ // check for the result of the stringifying.+ if ('[object Error]' == str) str = test.err.message;++ // Safari doesn't give you a stack. Let's at least provide a source line.+ if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {+ str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")";+ }++ el.appendChild(fragment('<pre class="error">%e</pre>', str));+ }++ // toggle code+ var h2 = el.getElementsByTagName('h2')[0];++ on(h2, 'click', function(){+ pre.style.display = 'none' == pre.style.display+ ? 'block'+ : 'none';+ });++ // code+ // TODO: defer+ if (!test.pending) {+ var pre = fragment('<pre><code>%e</code></pre>', clean(test.fn.toString()));+ el.appendChild(pre);+ pre.style.display = 'none';+ }++ stack[0].appendChild(el);+ });+}++/**+ * Display error `msg`.+ */++function error(msg) {+ document.body.appendChild(fragment('<div id="error">%s</div>', msg));+}++/**+ * Return a DOM fragment from `html`.+ */++function fragment(html) {+ var args = arguments+ , div = document.createElement('div')+ , i = 1;++ div.innerHTML = html.replace(/%([se])/g, function(_, type){+ switch (type) {+ case 's': return String(args[i++]);+ case 'e': return escape(args[i++]);+ }+ });++ return div.firstChild;+}++/**+ * Set `el` text to `str`.+ */++function text(el, str) {+ if (el.textContent) {+ el.textContent = str;+ } else {+ el.innerText = str;+ }+}++/**+ * Listen on `event` with callback `fn`.+ */++function on(el, event, fn) {+ if (el.addEventListener) {+ el.addEventListener(event, fn, false);+ } else {+ el.attachEvent('on' + event, fn);+ }+}++/**+ * Strip the function definition from `str`,+ * and re-indent for pre whitespace.+ */++function clean(str) {+ str = str+ .replace(/^function *\(.*\) *{/, '')+ .replace(/\s+\}$/, '');++ var spaces = str.match(/^\n?( *)/)[1].length+ , re = new RegExp('^ {' + spaces + '}', 'gm');++ str = str+ .replace(re, '')+ .replace(/^\s+/, '');++ return str;+}++}); // module: reporters/html.js++require.register("reporters/index.js", function(module, exports, require){++exports.Base = require('./base');+exports.Dot = require('./dot');+exports.Doc = require('./doc');+exports.TAP = require('./tap');+exports.JSON = require('./json');+exports.HTML = require('./html');+exports.List = require('./list');+exports.Min = require('./min');+exports.Spec = require('./spec');+exports.Progress = require('./progress');+exports.Landing = require('./landing');+exports.JSONCov = require('./json-cov');+exports.HTMLCov = require('./html-cov');+exports.JSONStream = require('./json-stream');+exports.XUnit = require('./xunit')+exports.Teamcity = require('./teamcity')++}); // module: reporters/index.js++require.register("reporters/json-cov.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base');++/**+ * Expose `JSONCov`.+ */++exports = module.exports = JSONCov;++/**+ * Initialize a new `JsCoverage` reporter.+ *+ * @param {Runner} runner+ * @param {Boolean} output+ * @api public+ */++function JSONCov(runner, output) {+ var self = this+ , output = 1 == arguments.length ? true : output;++ Base.call(this, runner);++ var tests = []+ , failures = []+ , passes = [];++ runner.on('test end', function(test){+ tests.push(test);+ });++ runner.on('pass', function(test){+ passes.push(test);+ });++ runner.on('fail', function(test){+ failures.push(test);+ });++ runner.on('end', function(){+ var cov = global._$jscoverage || {};+ var result = self.cov = map(cov);+ result.stats = self.stats;+ result.tests = tests.map(clean);+ result.failures = failures.map(clean);+ result.passes = passes.map(clean);+ if (!output) return;+ process.stdout.write(JSON.stringify(result, null, 2 ));+ });+}++/**+ * Map jscoverage data to a JSON structure+ * suitable for reporting.+ *+ * @param {Object} cov+ * @return {Object}+ * @api private+ */++function map(cov) {+ var ret = {+ instrumentation: 'node-jscoverage'+ , sloc: 0+ , hits: 0+ , misses: 0+ , coverage: 0+ , files: []+ };++ for (var filename in cov) {+ var data = coverage(filename, cov[filename]);+ ret.files.push(data);+ ret.hits += data.hits;+ ret.misses += data.misses;+ ret.sloc += data.sloc;+ }++ if (ret.sloc > 0) {+ ret.coverage = (ret.hits / ret.sloc) * 100;+ }++ return ret;+};++/**+ * Map jscoverage data for a single source file+ * to a JSON structure suitable for reporting.+ *+ * @param {String} filename name of the source file+ * @param {Object} data jscoverage coverage data+ * @return {Object}+ * @api private+ */++function coverage(filename, data) {+ var ret = {+ filename: filename,+ coverage: 0,+ hits: 0,+ misses: 0,+ sloc: 0,+ source: {}+ };++ data.source.forEach(function(line, num){+ num++;++ if (data[num] === 0) {+ ret.misses++;+ ret.sloc++;+ } else if (data[num] !== undefined) {+ ret.hits++;+ ret.sloc++;+ }++ ret.source[num] = {+ source: line+ , coverage: data[num] === undefined+ ? ''+ : data[num]+ };+ });++ ret.coverage = ret.hits / ret.sloc * 100;++ return ret;+}++/**+ * Return a plain-object representation of `test`+ * free of cyclic properties etc.+ *+ * @param {Object} test+ * @return {Object}+ * @api private+ */++function clean(test) {+ return {+ title: test.title+ , fullTitle: test.fullTitle()+ , duration: test.duration+ }+}++}); // module: reporters/json-cov.js++require.register("reporters/json-stream.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , color = Base.color;++/**+ * Expose `List`.+ */++exports = module.exports = List;++/**+ * Initialize a new `List` test reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function List(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total;++ runner.on('start', function(){+ console.log(JSON.stringify(['start', { total: total }]));+ });++ runner.on('pass', function(test){+ console.log(JSON.stringify(['pass', clean(test)]));+ });++ runner.on('fail', function(test, err){+ console.log(JSON.stringify(['fail', clean(test)]));+ });++ runner.on('end', function(){+ process.stdout.write(JSON.stringify(['end', self.stats]));+ });+}++/**+ * Return a plain-object representation of `test`+ * free of cyclic properties etc.+ *+ * @param {Object} test+ * @return {Object}+ * @api private+ */++function clean(test) {+ return {+ title: test.title+ , fullTitle: test.fullTitle()+ , duration: test.duration+ }+}+}); // module: reporters/json-stream.js++require.register("reporters/json.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `JSON`.+ */++exports = module.exports = JSONReporter;++/**+ * Initialize a new `JSON` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function JSONReporter(runner) {+ var self = this;+ Base.call(this, runner);++ var tests = []+ , failures = []+ , passes = [];++ runner.on('test end', function(test){+ tests.push(test);+ });++ runner.on('pass', function(test){+ passes.push(test);+ });++ runner.on('fail', function(test){+ failures.push(test);+ });++ runner.on('end', function(){+ var obj = {+ stats: self.stats+ , tests: tests.map(clean)+ , failures: failures.map(clean)+ , passes: passes.map(clean)+ };++ process.stdout.write(JSON.stringify(obj, null, 2));+ });+}++/**+ * Return a plain-object representation of `test`+ * free of cyclic properties etc.+ *+ * @param {Object} test+ * @return {Object}+ * @api private+ */++function clean(test) {+ return {+ title: test.title+ , fullTitle: test.fullTitle()+ , duration: test.duration+ }+}+}); // module: reporters/json.js++require.register("reporters/landing.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `Landing`.+ */++exports = module.exports = Landing;++/**+ * Airplane color.+ */++Base.colors.plane = 0;++/**+ * Airplane crash color.+ */++Base.colors['plane crash'] = 31;++/**+ * Runway color.+ */++Base.colors.runway = 90;++/**+ * Initialize a new `Landing` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Landing(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , width = Base.window.width * .75 | 0+ , total = runner.total+ , stream = process.stdout+ , plane = color('plane', '✈')+ , crashed = -1+ , n = 0;++ function runway() {+ var buf = Array(width).join('-');+ return ' ' + color('runway', buf);+ }++ runner.on('start', function(){+ stream.write('\n ');+ cursor.hide();+ });++ runner.on('test end', function(test){+ // check if the plane crashed+ var col = -1 == crashed+ ? width * ++n / total | 0+ : crashed;++ // show the crash+ if ('failed' == test.state) {+ plane = color('plane crash', '✈');+ crashed = col;+ }++ // render landing strip+ stream.write('\033[4F\n\n');+ stream.write(runway());+ stream.write('\n ');+ stream.write(color('runway', Array(col).join('⋅')));+ stream.write(plane)+ stream.write(color('runway', Array(width - col).join('⋅') + '\n'));+ stream.write(runway());+ stream.write('\033[0m');+ });++ runner.on('end', function(){+ cursor.show();+ console.log();+ self.epilogue();+ });+}++/**+ * Inherit from `Base.prototype`.+ */++Landing.prototype = new Base;+Landing.prototype.constructor = Landing;++}); // module: reporters/landing.js++require.register("reporters/list.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `List`.+ */++exports = module.exports = List;++/**+ * Initialize a new `List` test reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function List(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , n = 0;++ runner.on('start', function(){+ console.log();+ });++ runner.on('test', function(test){+ process.stdout.write(color('pass', ' ' + test.fullTitle() + ': '));+ });++ runner.on('pending', function(test){+ var fmt = color('checkmark', ' -')+ + color('pending', ' %s');+ console.log(fmt, test.fullTitle());+ });++ runner.on('pass', function(test){+ var fmt = color('checkmark', ' ✓')+ + color('pass', ' %s: ')+ + color(test.speed, '%dms');+ cursor.CR();+ console.log(fmt, test.fullTitle(), test.duration);+ });++ runner.on('fail', function(test, err){+ cursor.CR();+ console.log(color('fail', ' %d) %s'), ++n, test.fullTitle());+ });++ runner.on('end', self.epilogue.bind(self));+}++/**+ * Inherit from `Base.prototype`.+ */++List.prototype = new Base;+List.prototype.constructor = List;+++}); // module: reporters/list.js++require.register("reporters/markdown.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , utils = require('../utils');++/**+ * Expose `Markdown`.+ */++exports = module.exports = Markdown;++/**+ * Initialize a new `Markdown` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Markdown(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total+ , level = 0+ , buf = '';++ function title(str) {+ return Array(level).join('#') + ' ' + str;+ }++ function indent() {+ return Array(level).join(' ');+ }++ function mapTOC(suite, obj) {+ var ret = obj;+ obj = obj[suite.title] = obj[suite.title] || { suite: suite };+ suite.suites.forEach(function(suite){+ mapTOC(suite, obj);+ });+ return ret;+ }++ function stringifyTOC(obj, level) {+ ++level;+ var buf = '';+ var link;+ for (var key in obj) {+ if ('suite' == key) continue;+ if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\n';+ if (key) buf += Array(level).join(' ') + link;+ buf += stringifyTOC(obj[key], level);+ }+ --level;+ return buf;+ }++ function generateTOC(suite) {+ var obj = mapTOC(suite, {});+ return stringifyTOC(obj, 0);+ }++ generateTOC(runner.suite);++ runner.on('suite', function(suite){+ ++level;+ var slug = utils.slug(suite.fullTitle());+ buf += '<a name="' + slug + '" />' + '\n';+ buf += title(suite.title) + '\n';+ });++ runner.on('suite end', function(suite){+ --level;+ });++ runner.on('pass', function(test){+ var code = clean(test.fn.toString());+ buf += test.title + '.\n';+ buf += '\n```js';+ buf += code + '\n';+ buf += '```\n\n';+ });++ runner.on('end', function(){+ process.stdout.write('# TOC\n');+ process.stdout.write(generateTOC(runner.suite));+ process.stdout.write(buf);+ });+}++/**+ * Strip the function definition from `str`,+ * and re-indent for pre whitespace.+ */++function clean(str) {+ str = str+ .replace(/^function *\(.*\) *{/, '')+ .replace(/\s+\}$/, '');++ var spaces = str.match(/^\n?( *)/)[1].length+ , re = new RegExp('^ {' + spaces + '}', 'gm');++ str = str.replace(re, '');++ return str;+}+}); // module: reporters/markdown.js++require.register("reporters/min.js", function(module, exports, require){+/**+ * Module dependencies.+ */++var Base = require('./base');++/**+ * Expose `Min`.+ */++exports = module.exports = Min;++/**+ * Initialize a new `Min` minimal test reporter (best used with --watch).+ *+ * @param {Runner} runner+ * @api public+ */++function Min(runner) {+ Base.call(this, runner);++ runner.on('start', function(){+ // clear screen+ process.stdout.write('\033[2J');+ // set cursor position+ process.stdout.write('\033[1;3H');+ });++ runner.on('end', this.epilogue.bind(this));+}++/**+ * Inherit from `Base.prototype`.+ */++Min.prototype = new Base;+Min.prototype.constructor = Min;++}); // module: reporters/min.js++require.register("reporters/progress.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `Progress`.+ */++exports = module.exports = Progress;++/**+ * General progress bar color.+ */++Base.colors.progress = 90;++/**+ * Initialize a new `Progress` bar test reporter.+ *+ * @param {Runner} runner+ * @param {Object} options+ * @api public+ */++function Progress(runner, options) {+ Base.call(this, runner);++ var self = this+ , options = options || {}+ , stats = this.stats+ , width = Base.window.width * .50 | 0+ , total = runner.total+ , complete = 0+ , max = Math.max;++ // default chars+ options.open = options.open || '[';+ options.complete = options.complete || '▬';+ options.incomplete = options.incomplete || '⋅';+ options.close = options.close || ']';+ options.verbose = false;++ // tests started+ runner.on('start', function(){+ console.log();+ cursor.hide();+ });++ // tests complete+ runner.on('test end', function(){+ complete++;+ var incomplete = total - complete+ , percent = complete / total+ , n = width * percent | 0+ , i = width - n;++ cursor.CR();+ process.stdout.write('\033[J');+ process.stdout.write(color('progress', ' ' + options.open));+ process.stdout.write(Array(n).join(options.complete));+ process.stdout.write(Array(i).join(options.incomplete));+ process.stdout.write(color('progress', options.close));+ if (options.verbose) {+ process.stdout.write(color('progress', ' ' + complete + ' of ' + total));+ }+ });++ // tests are complete, output some stats+ // and the failures if any+ runner.on('end', function(){+ cursor.show();+ console.log();+ self.epilogue();+ });+}++/**+ * Inherit from `Base.prototype`.+ */++Progress.prototype = new Base;+Progress.prototype.constructor = Progress;+++}); // module: reporters/progress.js++require.register("reporters/spec.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `Spec`.+ */++exports = module.exports = Spec;++/**+ * Initialize a new `Spec` test reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Spec(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , indents = 0+ , n = 0;++ function indent() {+ return Array(indents).join(' ')+ }++ runner.on('start', function(){+ console.log();+ });++ runner.on('suite', function(suite){+ ++indents;+ console.log(color('suite', '%s%s'), indent(), suite.title);+ });++ runner.on('suite end', function(suite){+ --indents;+ if (1 == indents) console.log();+ });++ runner.on('test', function(test){+ process.stdout.write(indent() + color('pass', ' ◦ ' + test.title + ': '));+ });++ runner.on('pending', function(test){+ var fmt = indent() + color('pending', ' - %s');+ console.log(fmt, test.title);+ });++ runner.on('pass', function(test){+ if ('fast' == test.speed) {+ var fmt = indent()+ + color('checkmark', ' ✓')+ + color('pass', ' %s ');+ cursor.CR();+ console.log(fmt, test.title);+ } else {+ var fmt = indent()+ + color('checkmark', ' ✓')+ + color('pass', ' %s ')+ + color(test.speed, '(%dms)');+ cursor.CR();+ console.log(fmt, test.title, test.duration);+ }+ });++ runner.on('fail', function(test, err){+ cursor.CR();+ console.log(indent() + color('fail', ' %d) %s'), ++n, test.title);+ });++ runner.on('end', self.epilogue.bind(self));+}++/**+ * Inherit from `Base.prototype`.+ */++Spec.prototype = new Base;+Spec.prototype.constructor = Spec;+++}); // module: reporters/spec.js++require.register("reporters/tap.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , cursor = Base.cursor+ , color = Base.color;++/**+ * Expose `TAP`.+ */++exports = module.exports = TAP;++/**+ * Initialize a new `TAP` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function TAP(runner) {+ Base.call(this, runner);++ var self = this+ , stats = this.stats+ , total = runner.total+ , n = 1;++ runner.on('start', function(){+ console.log('%d..%d', 1, total);+ });++ runner.on('test end', function(){+ ++n;+ });++ runner.on('pending', function(test){+ console.log('ok %d %s # SKIP -', n, title(test));+ });++ runner.on('pass', function(test){+ console.log('ok %d %s', n, title(test));+ });++ runner.on('fail', function(test, err){+ console.log('not ok %d %s', n, title(test));+ console.log(err.stack.replace(/^/gm, ' '));+ });+}++/**+ * Return a TAP-safe title of `test`+ *+ * @param {Object} test+ * @return {String}+ * @api private+ */++function title(test) {+ return test.fullTitle().replace(/#/g, '');+}++}); // module: reporters/tap.js++require.register("reporters/teamcity.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base');++/**+ * Expose `Teamcity`.+ */++exports = module.exports = Teamcity;++/**+ * Initialize a new `Teamcity` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function Teamcity(runner) {+ Base.call(this, runner);+ var stats = this.stats;++ runner.on('start', function() {+ console.log("##teamcity[testSuiteStarted name='mocha.suite']");+ });++ runner.on('test', function(test) {+ console.log("##teamcity[testStarted name='" + escape(test.fullTitle()) + "']");+ });++ runner.on('fail', function(test, err) {+ console.log("##teamcity[testFailed name='" + escape(test.fullTitle()) + "' message='" + escape(err.message) + "']");+ });++ runner.on('pending', function(test) {+ console.log("##teamcity[testIgnored name='" + escape(test.fullTitle()) + "' message='pending']");+ });++ runner.on('test end', function(test) {+ console.log("##teamcity[testFinished name='" + escape(test.fullTitle()) + "' duration='" + test.duration + "']");+ });++ runner.on('end', function() {+ console.log("##teamcity[testSuiteFinished name='mocha.suite' duration='" + stats.duration + "']");+ });+}++/**+ * Escape the given `str`.+ */++function escape(str) {+ return str+ .replace(/\|/g, "||")+ .replace(/\n/g, "|n")+ .replace(/\r/g, "|r")+ .replace(/\[/g, "|[")+ .replace(/\]/g, "|]")+ .replace(/\u0085/g, "|x")+ .replace(/\u2028/g, "|l")+ .replace(/\u2029/g, "|p")+ .replace(/'/g, "|'");+}++}); // module: reporters/teamcity.js++require.register("reporters/xunit.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Base = require('./base')+ , utils = require('../utils')+ , escape = utils.escape;++/**+ * Save timer references to avoid Sinon interfering (see GH-237).+ */++var Date = global.Date+ , setTimeout = global.setTimeout+ , setInterval = global.setInterval+ , clearTimeout = global.clearTimeout+ , clearInterval = global.clearInterval;++/**+ * Expose `XUnit`.+ */++exports = module.exports = XUnit;++/**+ * Initialize a new `XUnit` reporter.+ *+ * @param {Runner} runner+ * @api public+ */++function XUnit(runner) {+ Base.call(this, runner);+ var stats = this.stats+ , tests = []+ , self = this;++ runner.on('test end', function(test){+ tests.push(test);+ });++ runner.on('end', function(){+ console.log(tag('testsuite', {+ name: 'Mocha Tests'+ , tests: stats.tests+ , failures: stats.failures+ , errors: stats.failures+ , skip: stats.tests - stats.failures - stats.passes+ , timestamp: (new Date).toUTCString()+ , time: stats.duration / 1000+ }, false));++ tests.forEach(test);+ console.log('</testsuite>');+ });+}++/**+ * Inherit from `Base.prototype`.+ */++XUnit.prototype = new Base;+XUnit.prototype.constructor = XUnit;+++/**+ * Output tag for the given `test.`+ */++function test(test) {+ var attrs = {+ classname: test.parent.fullTitle()+ , name: test.title+ , time: test.duration / 1000+ };++ if ('failed' == test.state) {+ var err = test.err;+ attrs.message = escape(err.message);+ console.log(tag('testcase', attrs, false, tag('failure', attrs, false, cdata(err.stack))));+ } else if (test.pending) {+ console.log(tag('testcase', attrs, false, tag('skipped', {}, true)));+ } else {+ console.log(tag('testcase', attrs, true) );+ }+}++/**+ * HTML tag helper.+ */++function tag(name, attrs, close, content) {+ var end = close ? '/>' : '>'+ , pairs = []+ , tag;++ for (var key in attrs) {+ pairs.push(key + '="' + escape(attrs[key]) + '"');+ }++ tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end;+ if (content) tag += content + '</' + name + end;+ return tag;+}++/**+ * Return cdata escaped CDATA `str`.+ */++function cdata(str) {+ return '<![CDATA[' + escape(str) + ']]>';+}++}); // module: reporters/xunit.js++require.register("runnable.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var EventEmitter = require('browser/events').EventEmitter+ , debug = require('browser/debug')('runnable');++/**+ * Save timer references to avoid Sinon interfering (see GH-237).+ */++var Date = global.Date+ , setTimeout = global.setTimeout+ , setInterval = global.setInterval+ , clearTimeout = global.clearTimeout+ , clearInterval = global.clearInterval;++/**+ * Expose `Runnable`.+ */++module.exports = Runnable;++/**+ * Initialize a new `Runnable` with the given `title` and callback `fn`.+ *+ * @param {String} title+ * @param {Function} fn+ * @api private+ */++function Runnable(title, fn) {+ this.title = title;+ this.fn = fn;+ this.async = fn && fn.length;+ this.sync = ! this.async;+ this._timeout = 2000;+ this.timedOut = false;+}++/**+ * Inherit from `EventEmitter.prototype`.+ */++Runnable.prototype = new EventEmitter;+Runnable.prototype.constructor = Runnable;+++/**+ * Set & get timeout `ms`.+ *+ * @param {Number} ms+ * @return {Runnable|Number} ms or self+ * @api private+ */++Runnable.prototype.timeout = function(ms){+ if (0 == arguments.length) return this._timeout;+ debug('timeout %d', ms);+ this._timeout = ms;+ if (this.timer) this.resetTimeout();+ return this;+};++/**+ * Return the full title generated by recursively+ * concatenating the parent's full title.+ *+ * @return {String}+ * @api public+ */++Runnable.prototype.fullTitle = function(){+ return this.parent.fullTitle() + ' ' + this.title;+};++/**+ * Clear the timeout.+ *+ * @api private+ */++Runnable.prototype.clearTimeout = function(){+ clearTimeout(this.timer);+};++/**+ * Reset the timeout.+ *+ * @api private+ */++Runnable.prototype.resetTimeout = function(){+ var self = this+ , ms = this.timeout();++ this.clearTimeout();+ if (ms) {+ this.timer = setTimeout(function(){+ self.callback(new Error('timeout of ' + ms + 'ms exceeded'));+ self.timedOut = true;+ }, ms);+ }+};++/**+ * Run the test and invoke `fn(err)`.+ *+ * @param {Function} fn+ * @api private+ */++Runnable.prototype.run = function(fn){+ var self = this+ , ms = this.timeout()+ , start = new Date+ , ctx = this.ctx+ , finished+ , emitted;++ if (ctx) ctx.runnable(this);++ // timeout+ if (this.async) {+ if (ms) {+ this.timer = setTimeout(function(){+ done(new Error('timeout of ' + ms + 'ms exceeded'));+ self.timedOut = true;+ }, ms);+ }+ }++ // called multiple times+ function multiple() {+ if (emitted) return;+ emitted = true;+ self.emit('error', new Error('done() called multiple times'));+ }++ // finished+ function done(err) {+ if (self.timedOut) return;+ if (finished) return multiple();+ self.clearTimeout();+ self.duration = new Date - start;+ finished = true;+ fn(err);+ }++ // for .resetTimeout()+ this.callback = done;++ // async+ if (this.async) {+ try {+ this.fn.call(ctx, function(err){+ if (err instanceof Error) return done(err);+ if (null != err) return done(new Error('done() invoked with non-Error: ' + err));+ done();+ });+ } catch (err) {+ done(err);+ }+ return;+ }++ // sync+ try {+ if (!this.pending) this.fn.call(ctx);+ this.duration = new Date - start;+ fn();+ } catch (err) {+ fn(err);+ }+};++}); // module: runnable.js++require.register("runner.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var EventEmitter = require('browser/events').EventEmitter+ , debug = require('browser/debug')('runner')+ , Test = require('./test')+ , utils = require('./utils')+ , noop = function(){};++/**+ * Expose `Runner`.+ */++module.exports = Runner;++/**+ * Initialize a `Runner` for the given `suite`.+ *+ * Events:+ *+ * - `start` execution started+ * - `end` execution complete+ * - `suite` (suite) test suite execution started+ * - `suite end` (suite) all tests (and sub-suites) have finished+ * - `test` (test) test execution started+ * - `test end` (test) test completed+ * - `hook` (hook) hook execution started+ * - `hook end` (hook) hook complete+ * - `pass` (test) test passed+ * - `fail` (test, err) test failed+ *+ * @api public+ */++function Runner(suite) {+ var self = this;+ this._globals = [];+ this.suite = suite;+ this.total = suite.total();+ this.failures = 0;+ this.on('test end', function(test){ self.checkGlobals(test); });+ this.on('hook end', function(hook){ self.checkGlobals(hook); });+ this.grep(/.*/);+ this.globals(utils.keys(global).concat(['errno']));+}++/**+ * Inherit from `EventEmitter.prototype`.+ */++Runner.prototype = new EventEmitter;+Runner.prototype.constructor = Runner;+++/**+ * Run tests with full titles matching `re`. Updates runner.total+ * with number of tests matched.+ *+ * @param {RegExp} re+ * @return {Runner} for chaining+ * @api public+ */++Runner.prototype.grep = function(re){+ debug('grep %s', re);+ this._grep = re;+ this.total = this.grepTotal(this.suite);+ return this;+};++/**+ * Returns the number of tests matching the grep search for the+ * given suite.+ *+ * @param {Suite} suite+ * @return {Number}+ * @api public+ */++Runner.prototype.grepTotal = function(suite) {+ var self = this;+ var total = 0;++ suite.eachTest(function(test){+ if (self._grep.test(test.fullTitle())) total++;+ });++ return total;+};++/**+ * Allow the given `arr` of globals.+ *+ * @param {Array} arr+ * @return {Runner} for chaining+ * @api public+ */++Runner.prototype.globals = function(arr){+ if (0 == arguments.length) return this._globals;+ debug('globals %j', arr);+ utils.forEach(arr, function(arr){+ this._globals.push(arr);+ }, this);+ return this;+};++/**+ * Check for global variable leaks.+ *+ * @api private+ */++Runner.prototype.checkGlobals = function(test){+ if (this.ignoreLeaks) return;+ var leaks = utils.filter(utils.keys(global), function(key){+ var matched = utils.filter(this._globals, function(allowed){+ return allowed == key || key.lastIndexOf(allowed.split('*')[0], 0) == 0;+ });+ return matched.length == 0 && (!global.navigator || 'onerror' !== key);+ }, this);++ this._globals = this._globals.concat(leaks);++ if (leaks.length > 1) {+ this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));+ } else if (leaks.length) {+ this.fail(test, new Error('global leak detected: ' + leaks[0]));+ }+};++/**+ * Fail the given `test`.+ *+ * @param {Test} test+ * @param {Error} err+ * @api private+ */++Runner.prototype.fail = function(test, err){+ ++this.failures;+ test.state = 'failed';+ if ('string' == typeof err) {+ err = new Error('the string "' + err + '" was thrown, throw an Error :)');+ }+ this.emit('fail', test, err);+};++/**+ * Fail the given `hook` with `err`.+ *+ * Hook failures (currently) hard-end due+ * to that fact that a failing hook will+ * surely cause subsequent tests to fail,+ * causing jumbled reporting.+ *+ * @param {Hook} hook+ * @param {Error} err+ * @api private+ */++Runner.prototype.failHook = function(hook, err){+ this.fail(hook, err);+ this.emit('end');+};++/**+ * Run hook `name` callbacks and then invoke `fn()`.+ *+ * @param {String} name+ * @param {Function} function+ * @api private+ */++Runner.prototype.hook = function(name, fn){+ var suite = this.suite+ , hooks = suite['_' + name]+ , ms = suite._timeout+ , self = this+ , timer;++ function next(i) {+ var hook = hooks[i];+ if (!hook) return fn();+ self.currentRunnable = hook;++ self.emit('hook', hook);++ hook.on('error', function(err){+ self.failHook(hook, err);+ });++ hook.run(function(err){+ hook.removeAllListeners('error');+ if (err) return self.failHook(hook, err);+ self.emit('hook end', hook);+ next(++i);+ });+ }++ process.nextTick(function(){+ next(0);+ });+};++/**+ * Run hook `name` for the given array of `suites`+ * in order, and callback `fn(err)`.+ *+ * @param {String} name+ * @param {Array} suites+ * @param {Function} fn+ * @api private+ */++Runner.prototype.hooks = function(name, suites, fn){+ var self = this+ , orig = this.suite;++ function next(suite) {+ self.suite = suite;++ if (!suite) {+ self.suite = orig;+ return fn();+ }++ self.hook(name, function(err){+ if (err) {+ self.suite = orig;+ return fn(err);+ }++ next(suites.pop());+ });+ }++ next(suites.pop());+};++/**+ * Run hooks from the top level down.+ *+ * @param {String} name+ * @param {Function} fn+ * @api private+ */++Runner.prototype.hookUp = function(name, fn){+ var suites = [this.suite].concat(this.parents()).reverse();+ this.hooks(name, suites, fn);+};++/**+ * Run hooks from the bottom up.+ *+ * @param {String} name+ * @param {Function} fn+ * @api private+ */++Runner.prototype.hookDown = function(name, fn){+ var suites = [this.suite].concat(this.parents());+ this.hooks(name, suites, fn);+};++/**+ * Return an array of parent Suites from+ * closest to furthest.+ *+ * @return {Array}+ * @api private+ */++Runner.prototype.parents = function(){+ var suite = this.suite+ , suites = [];+ while (suite = suite.parent) suites.push(suite);+ return suites;+};++/**+ * Run the current test and callback `fn(err)`.+ *+ * @param {Function} fn+ * @api private+ */++Runner.prototype.runTest = function(fn){+ var test = this.test+ , self = this;++ try {+ test.on('error', function(err){+ self.fail(test, err);+ });+ test.run(fn);+ } catch (err) {+ fn(err);+ }+};++/**+ * Run tests in the given `suite` and invoke+ * the callback `fn()` when complete.+ *+ * @param {Suite} suite+ * @param {Function} fn+ * @api private+ */++Runner.prototype.runTests = function(suite, fn){+ var self = this+ , tests = suite.tests+ , test;++ function next(err) {+ // if we bail after first err+ if (self.failures && suite._bail) return fn();++ // next test+ test = tests.shift();++ // all done+ if (!test) return fn();++ // grep+ if (!self._grep.test(test.fullTitle())) return next();++ // pending+ if (test.pending) {+ self.emit('pending', test);+ self.emit('test end', test);+ return next();+ }++ // execute test and hook(s)+ self.emit('test', self.test = test);+ self.hookDown('beforeEach', function(){+ self.currentRunnable = self.test;+ self.runTest(function(err){+ test = self.test;++ if (err) {+ self.fail(test, err);+ self.emit('test end', test);+ return self.hookUp('afterEach', next);+ }++ test.state = 'passed';+ self.emit('pass', test);+ self.emit('test end', test);+ self.hookUp('afterEach', next);+ });+ });+ }++ this.next = next;+ next();+};++/**+ * Run the given `suite` and invoke the+ * callback `fn()` when complete.+ *+ * @param {Suite} suite+ * @param {Function} fn+ * @api private+ */++Runner.prototype.runSuite = function(suite, fn){+ var total = this.grepTotal(suite)+ , self = this+ , i = 0;++ debug('run suite %s', suite.fullTitle());++ if (!total) return fn();++ this.emit('suite', this.suite = suite);++ function next() {+ var curr = suite.suites[i++];+ if (!curr) return done();+ self.runSuite(curr, next);+ }++ function done() {+ self.suite = suite;+ self.hook('afterAll', function(){+ self.emit('suite end', suite);+ fn();+ });+ }++ this.hook('beforeAll', function(){+ self.runTests(suite, next);+ });+};++/**+ * Handle uncaught exceptions.+ *+ * @param {Error} err+ * @api private+ */++Runner.prototype.uncaught = function(err){+ debug('uncaught exception');+ var runnable = this.currentRunnable;+ if ('failed' == runnable.state) return;+ runnable.clearTimeout();+ err.uncaught = true;+ this.fail(runnable, err);++ // recover from test+ if ('test' == runnable.type) {+ this.emit('test end', runnable);+ this.hookUp('afterEach', this.next);+ return;+ }++ // bail on hooks+ this.emit('end');+};++/**+ * Run the root suite and invoke `fn(failures)`+ * on completion.+ *+ * @param {Function} fn+ * @return {Runner} for chaining+ * @api public+ */++Runner.prototype.run = function(fn){+ var self = this+ , fn = fn || function(){};++ debug('start');++ // callback+ this.on('end', function(){+ debug('end');+ process.removeListener('uncaughtException', this.uncaught);+ fn(self.failures);+ });++ // run suites+ this.emit('start');+ this.runSuite(this.suite, function(){+ debug('finished running');+ self.emit('end');+ });++ // uncaught exception+ process.on('uncaughtException', function(err){+ self.uncaught(err);+ });++ return this;+};++}); // module: runner.js++require.register("suite.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var EventEmitter = require('browser/events').EventEmitter+ , debug = require('browser/debug')('suite')+ , utils = require('./utils')+ , Hook = require('./hook');++/**+ * Expose `Suite`.+ */++exports = module.exports = Suite;++/**+ * Create a new `Suite` with the given `title`+ * and parent `Suite`. When a suite with the+ * same title is already present, that suite+ * is returned to provide nicer reporter+ * and more flexible meta-testing.+ *+ * @param {Suite} parent+ * @param {String} title+ * @return {Suite}+ * @api public+ */++exports.create = function(parent, title){+ var suite = new Suite(title, parent.ctx);+ suite.parent = parent;+ title = suite.fullTitle();+ parent.addSuite(suite);+ return suite;+};++/**+ * Initialize a new `Suite` with the given+ * `title` and `ctx`.+ *+ * @param {String} title+ * @param {Context} ctx+ * @api private+ */++function Suite(title, ctx) {+ this.title = title;+ this.ctx = ctx;+ this.suites = [];+ this.tests = [];+ this._beforeEach = [];+ this._beforeAll = [];+ this._afterEach = [];+ this._afterAll = [];+ this.root = !title;+ this._timeout = 2000;+ this._bail = false;+}++/**+ * Inherit from `EventEmitter.prototype`.+ */++Suite.prototype = new EventEmitter;+Suite.prototype.constructor = Suite;+++/**+ * Return a clone of this `Suite`.+ *+ * @return {Suite}+ * @api private+ */++Suite.prototype.clone = function(){+ var suite = new Suite(this.title);+ debug('clone');+ suite.ctx = this.ctx;+ suite.timeout(this.timeout());+ suite.bail(this.bail());+ return suite;+};++/**+ * Set timeout `ms` or short-hand such as "2s".+ *+ * @param {Number|String} ms+ * @return {Suite|Number} for chaining+ * @api private+ */++Suite.prototype.timeout = function(ms){+ if (0 == arguments.length) return this._timeout;+ if (String(ms).match(/s$/)) ms = parseFloat(ms) * 1000;+ debug('timeout %d', ms);+ this._timeout = parseInt(ms, 10);+ return this;+};++/**+ * Sets whether to bail after first error.+ *+ * @parma {Boolean} bail+ * @return {Suite|Number} for chaining+ * @api private+ */++Suite.prototype.bail = function(bail){+ if (0 == arguments.length) return this._bail;+ debug('bail %s', bail);+ this._bail = bail;+ return this;+};++/**+ * Run `fn(test[, done])` before running tests.+ *+ * @param {Function} fn+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.beforeAll = function(fn){+ var hook = new Hook('"before all" hook', fn);+ hook.parent = this;+ hook.timeout(this.timeout());+ hook.ctx = this.ctx;+ this._beforeAll.push(hook);+ this.emit('beforeAll', hook);+ return this;+};++/**+ * Run `fn(test[, done])` after running tests.+ *+ * @param {Function} fn+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.afterAll = function(fn){+ var hook = new Hook('"after all" hook', fn);+ hook.parent = this;+ hook.timeout(this.timeout());+ hook.ctx = this.ctx;+ this._afterAll.push(hook);+ this.emit('afterAll', hook);+ return this;+};++/**+ * Run `fn(test[, done])` before each test case.+ *+ * @param {Function} fn+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.beforeEach = function(fn){+ var hook = new Hook('"before each" hook', fn);+ hook.parent = this;+ hook.timeout(this.timeout());+ hook.ctx = this.ctx;+ this._beforeEach.push(hook);+ this.emit('beforeEach', hook);+ return this;+};++/**+ * Run `fn(test[, done])` after each test case.+ *+ * @param {Function} fn+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.afterEach = function(fn){+ var hook = new Hook('"after each" hook', fn);+ hook.parent = this;+ hook.timeout(this.timeout());+ hook.ctx = this.ctx;+ this._afterEach.push(hook);+ this.emit('afterEach', hook);+ return this;+};++/**+ * Add a test `suite`.+ *+ * @param {Suite} suite+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.addSuite = function(suite){+ suite.parent = this;+ suite.timeout(this.timeout());+ suite.bail(this.bail());+ this.suites.push(suite);+ this.emit('suite', suite);+ return this;+};++/**+ * Add a `test` to this suite.+ *+ * @param {Test} test+ * @return {Suite} for chaining+ * @api private+ */++Suite.prototype.addTest = function(test){+ test.parent = this;+ test.timeout(this.timeout());+ test.ctx = this.ctx;+ this.tests.push(test);+ this.emit('test', test);+ return this;+};++/**+ * Return the full title generated by recursively+ * concatenating the parent's full title.+ *+ * @return {String}+ * @api public+ */++Suite.prototype.fullTitle = function(){+ if (this.parent) {+ var full = this.parent.fullTitle();+ if (full) return full + ' ' + this.title;+ }+ return this.title;+};++/**+ * Return the total number of tests.+ *+ * @return {Number}+ * @api public+ */++Suite.prototype.total = function(){+ return utils.reduce(this.suites, function(sum, suite){+ return sum + suite.total();+ }, 0) + this.tests.length;+};++/**+ * Iterates through each suite recursively to find+ * all tests. Applies a function in the format+ * `fn(test)`.+ *+ * @param {Function} fn+ * @return {Suite}+ * @api private+ */++Suite.prototype.eachTest = function(fn){+ utils.forEach(this.tests, fn);+ utils.forEach(this.suites, function(suite){+ suite.eachTest(fn);+ });+ return this;+};++}); // module: suite.js++require.register("test.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var Runnable = require('./runnable');++/**+ * Expose `Test`.+ */++module.exports = Test;++/**+ * Initialize a new `Test` with the given `title` and callback `fn`.+ *+ * @param {String} title+ * @param {Function} fn+ * @api private+ */++function Test(title, fn) {+ Runnable.call(this, title, fn);+ this.pending = !fn;+ this.type = 'test';+}++/**+ * Inherit from `Runnable.prototype`.+ */++Test.prototype = new Runnable;+Test.prototype.constructor = Test;+++/**+ * Inspect the context void of private properties.+ *+ * @return {String}+ * @api private+ */++Test.prototype.inspect = function(){+ return JSON.stringify(this, function(key, val){+ return '_' == key[0]+ ? undefined+ : 'parent' == key+ ? '#<Suite>'+ : val;+ }, 2);+};+}); // module: test.js++require.register("utils.js", function(module, exports, require){++/**+ * Module dependencies.+ */++var fs = require('browser/fs')+ , path = require('browser/path')+ , join = path.join+ , debug = require('browser/debug')('watch');++/**+ * Ignored directories.+ */++var ignore = ['node_modules', '.git'];++/**+ * Escape special characters in the given string of html.+ *+ * @param {String} html+ * @return {String}+ * @api private+ */++exports.escape = function(html) {+ return String(html)+ .replace(/&/g, '&')+ .replace(/"/g, '"')+ .replace(/</g, '<')+ .replace(/>/g, '>');+};++/**+ * Array#forEach (<=IE8)+ *+ * @param {Array} array+ * @param {Function} fn+ * @param {Object} scope+ * @api private+ */++exports.forEach = function(arr, fn, scope) {+ for (var i = 0, l = arr.length; i < l; i++)+ fn.call(scope, arr[i], i);+};++/**+ * Array#indexOf (<=IE8)+ *+ * @parma {Array} arr+ * @param {Object} obj to find index of+ * @param {Number} start+ * @api private+ */++exports.indexOf = function (arr, obj, start) {+ for (var i = start || 0, l = arr.length; i < l; i++) {+ if (arr[i] === obj)+ return i;+ }+ return -1;+};++/**+ * Array#reduce (<=IE8)+ *+ * @param {Array} array+ * @param {Function} fn+ * @param {Object} initial value+ * @param {Object} scope+ * @api private+ */++exports.reduce = function(arr, fn, val, scope) {+ var rval = val;++ for (var i = 0, l = arr.length; i < l; i++) {+ rval = fn.call(scope, rval, arr[i], i, arr);+ }++ return rval;+};++/**+ * Array#filter (<=IE8)+ *+ * @param {Array} array+ * @param {Function} fn+ * @param {Object} scope+ * @api private+ */++exports.filter = function(arr, fn, scope) {+ var ret = [];++ for (var i = 0, l = arr.length; i < l; i++) {+ var val = arr[i];+ if (fn.call(scope, val, i, arr))+ ret.push(val);+ }++ return ret;+};++/**+ * Object.keys (<=IE8)+ *+ * @param {Object} obj+ * @return {Array} keys+ * @api private+ */++exports.keys = Object.keys || function(obj) {+ var keys = []+ , has = Object.prototype.hasOwnProperty // for `window` on <=IE8++ for (var key in obj) {+ if (has.call(obj, key)) {+ keys.push(key);+ }+ }++ return keys;+};++/**+ * Watch the given `files` for changes+ * and invoke `fn(file)` on modification.+ *+ * @param {Array} files+ * @param {Function} fn+ * @api private+ */++exports.watch = function(files, fn){+ var options = { interval: 100 };+ files.forEach(function(file){+ debug('file %s', file);+ fs.watchFile(file, options, function(curr, prev){+ if (prev.mtime < curr.mtime) fn(file);+ });+ });+};++/**+ * Ignored files.+ */++function ignored(path){+ return !~ignore.indexOf(path);+}++/**+ * Lookup files in the given `dir`.+ *+ * @return {Array}+ * @api private+ */++exports.files = function(dir, ret){+ ret = ret || [];++ fs.readdirSync(dir)+ .filter(ignored)+ .forEach(function(path){+ path = join(dir, path);+ if (fs.statSync(path).isDirectory()) {+ exports.files(path, ret);+ } else if (path.match(/\.(js|coffee)$/)) {+ ret.push(path);+ }+ });++ return ret;+};++/**+ * Compute a slug from the given `str`.+ *+ * @param {String} str+ * @return {String}+ * @api private+ */++exports.slug = function(str){+ return str+ .toLowerCase()+ .replace(/ +/g, '-')+ .replace(/[^-\w]/g, '');+};++/**+ * Escape regular expression characters in `str`.+ *+ * @param {String} str+ * @return {String}+ * @api private+ */++exports.escapeRegexp = function(str){+ return str.replace(/[-\\^$*+?.()|[\]{}]/g, "\\$&");+};+}); // module: utils.js+/**+ * Node shims.+ *+ * These are meant only to allow+ * mocha.js to run untouched, not+ * to allow running node code in+ * the browser.+ */++process = {};+process.exit = function(status){};+process.stdout = {};+global = window;++/**+ * next tick implementation.+ */++process.nextTick = (function(){+ // postMessage behaves badly on IE8+ if (window.ActiveXObject || !window.postMessage) {+ return function(fn){ fn() };+ }++ // based on setZeroTimeout by David Baron+ // - http://dbaron.org/log/20100309-faster-timeouts+ var timeouts = []+ , name = 'mocha-zero-timeout'++ window.addEventListener('message', function(e){+ if (e.source == window && e.data == name) {+ if (e.stopPropagation) e.stopPropagation();+ if (timeouts.length) timeouts.shift()();+ }+ }, true);++ return function(fn){+ timeouts.push(fn);+ window.postMessage(name, '*');+ }+})();++/**+ * Remove uncaughtException listener.+ */++process.removeListener = function(e){+ if ('uncaughtException' == e) {+ window.onerror = null;+ }+};++/**+ * Implements uncaughtException listener.+ */++process.on = function(e, fn){+ if ('uncaughtException' == e) {+ window.onerror = fn;+ }+};++/**+ * Expose mocha.+ */++window.mocha = require('mocha');++// boot+;(function(){+ var suite = new mocha.Suite('', new mocha.Context)+ , utils = mocha.utils+ , options = {}++ /**+ * Highlight the given string of `js`.+ */++ function highlight(js) {+ return js+ .replace(/</g, '<')+ .replace(/>/g, '>')+ .replace(/\/\/(.*)/gm, '<span class="comment">//$1</span>')+ .replace(/('.*?')/gm, '<span class="string">$1</span>')+ .replace(/(\d+\.\d+)/gm, '<span class="number">$1</span>')+ .replace(/(\d+)/gm, '<span class="number">$1</span>')+ .replace(/\bnew *(\w+)/gm, '<span class="keyword">new</span> <span class="init">$1</span>')+ .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '<span class="keyword">$1</span>')+ }++ /**+ * Highlight code contents.+ */++ function highlightCode() {+ var code = document.getElementsByTagName('code');+ for (var i = 0, len = code.length; i < len; ++i) {+ code[i].innerHTML = highlight(code[i].innerHTML);+ }+ }++ /**+ * Parse the given `qs`.+ */++ function parse(qs) {+ return utils.reduce(qs.replace('?', '').split('&'), function(obj, pair){+ var i = pair.indexOf('=')+ , key = pair.slice(0, i)+ , val = pair.slice(++i);++ obj[key] = decodeURIComponent(val);+ return obj;+ }, {});+ }++ /**+ * Setup mocha with the given setting options.+ */++ mocha.setup = function(opts){+ if ('string' === typeof opts) options.ui = opts;+ else options = opts;++ ui = mocha.interfaces[options.ui];+ if (!ui) throw new Error('invalid mocha interface "' + ui + '"');+ if (options.timeout) suite.timeout(options.timeout);+ ui(suite);+ suite.emit('pre-require', window);+ };++ /**+ * Run mocha, returning the Runner.+ */++ mocha.run = function(fn){+ suite.emit('run');+ var runner = new mocha.Runner(suite);+ var Reporter = options.reporter || mocha.reporters.HTML;+ var reporter = new Reporter(runner);+ var query = parse(window.location.search || "");+ if (query.grep) runner.grep(new RegExp(query.grep));+ if (options.ignoreLeaks) runner.ignoreLeaks = true;+ if (options.globals) runner.globals(options.globals);+ runner.globals(['location']);+ runner.on('end', highlightCode);+ return runner.run(fn);+ };+})();+})();\ No newline at end of filediff --git a/example/tests.html b/example/tests.htmlnew file mode 100644index 00000000..72a0da60--- /dev/null+++ b/example/tests.html@@ -0,0 +1,19 @@+<html>+ <head>+ <title>Mocha</title>+ <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">+ <link rel="stylesheet" href="mocha.css" />+ </head>+ <body>+ <div id="mocha"></div>+ <script src="mocha.js"></script>+ <script src="chai.js"></script>+ <script>mocha.setup('bdd')</script>+ <script>expect = chai.expect</script>+ <script src="Array.js"></script>+ <script src="String.js"></script>+ <script>+ mocha.run();+ </script>+ </body>+</html>