{"body":"","parents":["5640d641d6066a85439d7027b960ebc2cebd37de"],"patch":"diff --git a\/build\/jasmine.js b\/build\/jasmine.js\nnew file mode 100644\nindex 0000000000..74b6dd64e2\n--- \/dev\/null\n+++ b\/build\/jasmine.js\n@@ -0,0 +1,74 @@\n+\/\/# sourceURL=populist\/loader.js\n+(function(entries, sources) {\n+ var modules = {};\n+ var hasOwn = modules.hasOwnProperty;\n+ var global = Function(\"return this\")();\n+ var doc = global.document;\n+ var head = doc.documentElement.firstChild;\n+\n+ function internalRequire(id) {\n+ var module = getModule(id);\n+ if (module && !hasOwn.call(module, \"exports\")) {\n+ module(function(rid) {\n+ return internalRequire(absolutize(id, rid));\n+ }, module.exports = {}, module, global);\n+\n+ \/\/ If the module id has a non-null value in the entries object,\n+ \/\/ define a global reference to its exports object.\n+ var globalName = entries[id];\n+ if (globalName && hasOwn.call(entries, id))\n+ global[globalName] = module.exports;\n+ }\n+\n+ return module.exports;\n+ }\n+\n+ function getModule(id) {\n+ if (!hasOwn.call(modules, id)) {\n+ if (hasOwn.call(sources, id)) {\n+ var name = \"module$\" + Math.random().toString(36).slice(2);\n+ var script = doc.createElement(\"script\");\n+ var code = \"function \" + name + \"(require,exports,module,global){\" +\n+ sources[id] + \"\\n}\\n\/\/# sourceURL=\" + id + \".js\\n\";\n+ script.setAttribute(\"type\", \"text\/javascript\");\n+ script.setAttribute(\"encoding\", \"utf8\");\n+ script.appendChild(doc.createTextNode(code));\n+ head.appendChild(script);\n+ modules[id] = global[name];\n+ } else {\n+ throw new Error(\"Missing module: \" + id);\n+ }\n+ }\n+\n+ return modules[id];\n+ }\n+\n+ var pathNormExp = \/\\\/(\\.?|[^\\\/]+\\\/\\.\\.)\\\/\/;\n+ function absolutize(id, rid) {\n+ if (rid.charAt(0) === \".\") {\n+ rid = \"\/\" + id + \"\/..\/\" + rid;\n+ while (rid != (id = rid.replace(pathNormExp, \"\/\")))\n+ rid = id;\n+ rid = rid.replace(\/^\\\/\/, \"\");\n+ }\n+ return rid;\n+ }\n+\n+ \/\/ Eagerly require all identifiers that are keys of the entries object.\n+ for (var id in entries)\n+ if (hasOwn.call(entries, id))\n+ internalRequire(id);\n+})({\"jasmine\":\"jasmine\",\"all\":null},{\n+\"jasmine\":\"\/**\\n * Top level namespace for Jasmine, a lightweight JavaScript BDD\/spec\/testing framework.\\n *\\n * @namespace\\n *\/\\nvar jasmine = {};\\nexports = module.exports = jasmine;\\n\/**\\n * @private\\n *\/\\njasmine.unimplementedMethod_ = function() {\\n throw new Error(\\\"unimplemented method\\\");\\n};\\n\\n\/**\\n * Use
jasmine.undefined<\/code> instead of undefined<\/code>, since undefined<\/code> is just\\n * a plain old variable and may be redefined by somebody else.\\n *\\n * @private\\n *\/\\njasmine.undefined = jasmine.___undefined___;\\n\\n\/**\\n * Show diagnostic messages in the console if set to true\\n *\\n *\/\\njasmine.VERBOSE = false;\\n\\n\/**\\n * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.\\n *\\n *\/\\njasmine.DEFAULT_UPDATE_INTERVAL = 250;\\n\\n\/**\\n * Maximum levels of nesting that will be included when an object is pretty-printed\\n *\/\\njasmine.MAX_PRETTY_PRINT_DEPTH = 40;\\n\\n\/**\\n * Default timeout interval in milliseconds for waitsFor() blocks.\\n *\/\\njasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;\\n\\n\/**\\n * By default exceptions thrown in the context of a test are caught by jasmine so that it can run the remaining tests in the suite.\\n * Set to false to let the exception bubble up in the browser.\\n *\\n *\/\\njasmine.CATCH_EXCEPTIONS = true;\\n\\njasmine.getGlobal = function() {\\n  function getGlobal() {\\n    return this;\\n  }\\n\\n  return getGlobal();\\n};\\n\\n\/**\\n * Allows for bound functions to be compared.  Internal use only.\\n *\\n * @ignore\\n * @private\\n * @param base {Object} bound 'this' for the function\\n * @param name {Function} function to find\\n *\/\\njasmine.bindOriginal_ = function(base, name) {\\n  var original = base[name];\\n  if (original.apply) {\\n    return function() {\\n      return original.apply(base, arguments);\\n    };\\n  } else {\\n    \/\/ IE support\\n    return jasmine.getGlobal()[name];\\n  }\\n};\\n\\njasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');\\njasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');\\njasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');\\njasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');\\n\\njasmine.MessageResult = function(values) {\\n  this.type = 'log';\\n  this.values = values;\\n  this.trace = new Error(); \/\/ todo: test better\\n};\\n\\njasmine.MessageResult.prototype.toString = function() {\\n  var text = \\\"\\\";\\n  for (var i = 0; i < this.values.length; i++) {\\n    if (i > 0) text += \\\" \\\";\\n    if (jasmine.isString_(this.values[i])) {\\n      text += this.values[i];\\n    } else {\\n      text += jasmine.pp(this.values[i]);\\n    }\\n  }\\n  return text;\\n};\\n\\njasmine.ExpectationResult = function(params) {\\n  this.type = 'expect';\\n  this.matcherName = params.matcherName;\\n  this.passed_ = params.passed;\\n  this.expected = params.expected;\\n  this.actual = params.actual;\\n  this.message = this.passed_ ? 'Passed.' : params.message;\\n\\n  var trace = (params.trace || new Error(this.message));\\n  this.trace = this.passed_ ? '' : trace;\\n};\\n\\njasmine.ExpectationResult.prototype.toString = function () {\\n  return this.message;\\n};\\n\\njasmine.ExpectationResult.prototype.passed = function () {\\n  return this.passed_;\\n};\\n\\n\/**\\n * Getter for the Jasmine environment. Ensures one gets created\\n *\/\\njasmine.getEnv = function() {\\n  var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();\\n  return env;\\n};\\n\\n\/**\\n * @ignore\\n * @private\\n * @param value\\n * @returns {Boolean}\\n *\/\\njasmine.isArray_ = function(value) {\\n  return jasmine.isA_(\\\"Array\\\", value);\\n};\\n\\n\/**\\n * @ignore\\n * @private\\n * @param value\\n * @returns {Boolean}\\n *\/\\njasmine.isString_ = function(value) {\\n  return jasmine.isA_(\\\"String\\\", value);\\n};\\n\\n\/**\\n * @ignore\\n * @private\\n * @param value\\n * @returns {Boolean}\\n *\/\\njasmine.isNumber_ = function(value) {\\n  return jasmine.isA_(\\\"Number\\\", value);\\n};\\n\\n\/**\\n * @ignore\\n * @private\\n * @param {String} typeName\\n * @param value\\n * @returns {Boolean}\\n *\/\\njasmine.isA_ = function(typeName, value) {\\n  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';\\n};\\n\\n\/**\\n * Pretty printer for expecations.  Takes any object and turns it into a human-readable string.\\n *\\n * @param value {Object} an object to be outputted\\n * @returns {String}\\n *\/\\njasmine.pp = function(value) {\\n  var stringPrettyPrinter = new jasmine.StringPrettyPrinter();\\n  stringPrettyPrinter.format(value);\\n  return stringPrettyPrinter.string;\\n};\\n\\n\/**\\n * Returns true if the object is a DOM Node.\\n *\\n * @param {Object} obj object to check\\n * @returns {Boolean}\\n *\/\\njasmine.isDomNode = function(obj) {\\n  return obj.nodeType > 0;\\n};\\n\\n\/**\\n * Returns a matchable 'generic' object of the class type.  For use in expecations of type when values don't matter.\\n *\\n * @example\\n * \/\/ don't care about which function is passed in, as long as it's a function\\n * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));\\n *\\n * @param {Class} clazz\\n * @returns matchable object of the type clazz\\n *\/\\njasmine.any = function(clazz) {\\n  return new jasmine.Matchers.Any(clazz);\\n};\\n\\n\/**\\n * Returns a matchable subset of a JSON object. For use in expectations when you don't care about all of the\\n * attributes on the object.\\n *\\n * @example\\n * \/\/ don't care about any other attributes than foo.\\n * expect(mySpy).toHaveBeenCalledWith(jasmine.objectContaining({foo: \\\"bar\\\"});\\n *\\n * @param sample {Object} sample\\n * @returns matchable object for the sample\\n *\/\\njasmine.objectContaining = function (sample) {\\n    return new jasmine.Matchers.ObjectContaining(sample);\\n};\\n\\n\/**\\n * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.\\n *\\n * Spies should be created in test setup, before expectations.  They can then be checked, using the standard Jasmine\\n * expectation syntax. Spies can be checked if they were called or not and what the calling params were.\\n *\\n * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).\\n *\\n * Spies are torn down at the end of every spec.\\n *\\n * Note: Do not<\/b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.\\n *\\n * @example\\n * \/\/ a stub\\n * var myStub = jasmine.createSpy('myStub');  \/\/ can be used anywhere\\n *\\n * \/\/ spy example\\n * var foo = {\\n *   not: function(bool) { return !bool; }\\n * }\\n *\\n * \/\/ actual foo.not will not be called, execution stops\\n * spyOn(foo, 'not');\\n\\n \/\/ foo.not spied upon, execution will continue to implementation\\n * spyOn(foo, 'not').andCallThrough();\\n *\\n * \/\/ fake example\\n * var foo = {\\n *   not: function(bool) { return !bool; }\\n * }\\n *\\n * \/\/ foo.not(val) will return val\\n * spyOn(foo, 'not').andCallFake(function(value) {return value;});\\n *\\n * \/\/ mock example\\n * foo.not(7 == 7);\\n * expect(foo.not).toHaveBeenCalled();\\n * expect(foo.not).toHaveBeenCalledWith(true);\\n *\\n * @constructor\\n * @see spyOn, jasmine.createSpy, jasmine.createSpyObj\\n * @param {String} name\\n *\/\\njasmine.Spy = function(name) {\\n  \/**\\n   * The name of the spy, if provided.\\n   *\/\\n  this.identity = name || 'unknown';\\n  \/**\\n   *  Is this Object a spy?\\n   *\/\\n  this.isSpy = true;\\n  \/**\\n   * The actual function this spy stubs.\\n   *\/\\n  this.plan = function() {\\n  };\\n  \/**\\n   * Tracking of the most recent call to the spy.\\n   * @example\\n   * var mySpy = jasmine.createSpy('foo');\\n   * mySpy(1, 2);\\n   * mySpy.mostRecentCall.args = [1, 2];\\n   *\/\\n  this.mostRecentCall = {};\\n\\n  \/**\\n   * Holds arguments for each call to the spy, indexed by call count\\n   * @example\\n   * var mySpy = jasmine.createSpy('foo');\\n   * mySpy(1, 2);\\n   * mySpy(7, 8);\\n   * mySpy.mostRecentCall.args = [7, 8];\\n   * mySpy.argsForCall[0] = [1, 2];\\n   * mySpy.argsForCall[1] = [7, 8];\\n   *\/\\n  this.argsForCall = [];\\n  this.calls = [];\\n};\\n\\n\/**\\n * Tells a spy to call through to the actual implemenatation.\\n *\\n * @example\\n * var foo = {\\n *   bar: function() { \/\/ do some stuff }\\n * }\\n *\\n * \/\/ defining a spy on an existing property: foo.bar\\n * spyOn(foo, 'bar').andCallThrough();\\n *\/\\njasmine.Spy.prototype.andCallThrough = function() {\\n  this.plan = this.originalValue;\\n  return this;\\n};\\n\\n\/**\\n * For setting the return value of a spy.\\n *\\n * @example\\n * \/\/ defining a spy from scratch: foo() returns 'baz'\\n * var foo = jasmine.createSpy('spy on foo').andReturn('baz');\\n *\\n * \/\/ defining a spy on an existing property: foo.bar() returns 'baz'\\n * spyOn(foo, 'bar').andReturn('baz');\\n *\\n * @param {Object} value\\n *\/\\njasmine.Spy.prototype.andReturn = function(value) {\\n  this.plan = function() {\\n    return value;\\n  };\\n  return this;\\n};\\n\\n\/**\\n * For throwing an exception when a spy is called.\\n *\\n * @example\\n * \/\/ defining a spy from scratch: foo() throws an exception w\/ message 'ouch'\\n * var foo = jasmine.createSpy('spy on foo').andThrow('baz');\\n *\\n * \/\/ defining a spy on an existing property: foo.bar() throws an exception w\/ message 'ouch'\\n * spyOn(foo, 'bar').andThrow('baz');\\n *\\n * @param {String} exceptionMsg\\n *\/\\njasmine.Spy.prototype.andThrow = function(exceptionMsg) {\\n  this.plan = function() {\\n    throw exceptionMsg;\\n  };\\n  return this;\\n};\\n\\n\/**\\n * Calls an alternate implementation when a spy is called.\\n *\\n * @example\\n * var baz = function() {\\n *   \/\/ do some stuff, return something\\n * }\\n * \/\/ defining a spy from scratch: foo() calls the function baz\\n * var foo = jasmine.createSpy('spy on foo').andCall(baz);\\n *\\n * \/\/ defining a spy on an existing property: foo.bar() calls an anonymnous function\\n * spyOn(foo, 'bar').andCall(function() { return 'baz';} );\\n *\\n * @param {Function} fakeFunc\\n *\/\\njasmine.Spy.prototype.andCallFake = function(fakeFunc) {\\n  this.plan = fakeFunc;\\n  return this;\\n};\\n\\n\/**\\n * Resets all of a spy's the tracking variables so that it can be used again.\\n *\\n * @example\\n * spyOn(foo, 'bar');\\n *\\n * foo.bar();\\n *\\n * expect(foo.bar.callCount).toEqual(1);\\n *\\n * foo.bar.reset();\\n *\\n * expect(foo.bar.callCount).toEqual(0);\\n *\/\\njasmine.Spy.prototype.reset = function() {\\n  this.wasCalled = false;\\n  this.callCount = 0;\\n  this.argsForCall = [];\\n  this.calls = [];\\n  this.mostRecentCall = {};\\n};\\n\\njasmine.createSpy = function(name) {\\n\\n  var spyObj = function() {\\n    spyObj.wasCalled = true;\\n    spyObj.callCount++;\\n    var args = jasmine.util.argsToArray(arguments);\\n    spyObj.mostRecentCall.object = this;\\n    spyObj.mostRecentCall.args = args;\\n    spyObj.argsForCall.push(args);\\n    spyObj.calls.push({object: this, args: args});\\n    return spyObj.plan.apply(this, arguments);\\n  };\\n\\n  var spy = new jasmine.Spy(name);\\n\\n  for (var prop in spy) {\\n    spyObj[prop] = spy[prop];\\n  }\\n\\n  spyObj.reset();\\n\\n  return spyObj;\\n};\\n\\n\/**\\n * Determines whether an object is a spy.\\n *\\n * @param {jasmine.Spy|Object} putativeSpy\\n * @returns {Boolean}\\n *\/\\njasmine.isSpy = function(putativeSpy) {\\n  return putativeSpy && putativeSpy.isSpy;\\n};\\n\\n\/**\\n * Creates a more complicated spy: an Object that has every property a function that is a spy.  Used for stubbing something\\n * large in one call.\\n *\\n * @param {String} baseName name of spy class\\n * @param {Array} methodNames array of names of methods to make spies\\n *\/\\njasmine.createSpyObj = function(baseName, methodNames) {\\n  if (!jasmine.isArray_(methodNames) || methodNames.length === 0) {\\n    throw new Error('createSpyObj requires a non-empty array of method names to create spies for');\\n  }\\n  var obj = {};\\n  for (var i = 0; i < methodNames.length; i++) {\\n    obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);\\n  }\\n  return obj;\\n};\\n\\n\/**\\n * All parameters are pretty-printed and concatenated together, then written to the current spec's output.\\n *\\n * Be careful not to leave calls to jasmine.log<\/code> in production code.\\n *\/\\njasmine.log = function() {\\n  var spec = jasmine.getEnv().currentSpec;\\n  spec.log.apply(spec, arguments);\\n};\\n\\n\/**\\n * Function that installs a spy on an existing object's method name.  Used within a Spec to create a spy.\\n *\\n * @example\\n * \/\/ spy example\\n * var foo = {\\n *   not: function(bool) { return !bool; }\\n * }\\n * spyOn(foo, 'not'); \/\/ actual foo.not will not be called, execution stops\\n *\\n * @see jasmine.createSpy\\n * @param obj\\n * @param methodName\\n * @return {jasmine.Spy} a Jasmine spy that can be chained with all spy methods\\n *\/\\nvar spyOn = function(obj, methodName) {\\n  return jasmine.getEnv().currentSpec.spyOn(obj, methodName);\\n};\\nexports.spyOn = spyOn;\\n\\n\/**\\n * Creates a Jasmine spec that will be added to the current suite.\\n *\\n * \/\/ TODO: pending tests\\n *\\n * @example\\n * it('should be true', function() {\\n *   expect(true).toEqual(true);\\n * });\\n *\\n * @param {String} desc description of this specification\\n * @param {Function} func defines the preconditions and expectations of the spec\\n *\/\\nvar it = function(desc, func) {\\n  return jasmine.getEnv().it(desc, func);\\n};\\nexports.it = it;\\n\\n\/**\\n * Creates a disabled<\/em> Jasmine spec.\\n *\\n * A convenience method that allows existing specs to be disabled temporarily during development.\\n *\\n * @param {String} desc description of this specification\\n * @param {Function} func defines the preconditions and expectations of the spec\\n *\/\\nvar xit = function(desc, func) {\\n  return jasmine.getEnv().xit(desc, func);\\n};\\nexports.xit = xit;\\n\\n\/**\\n * Starts a chain for a Jasmine expectation.\\n *\\n * It is passed an Object that is the actual value and should chain to one of the many\\n * jasmine.Matchers functions.\\n *\\n * @param {Object} actual Actual value to test against and expected value\\n * @return {jasmine.Matchers}\\n *\/\\nvar expect = function(actual) {\\n  return jasmine.getEnv().currentSpec.expect(actual);\\n};\\nexports.expect = expect;\\n\\n\/**\\n * Defines part of a jasmine spec.  Used in cominbination with waits or waitsFor in asynchrnous specs.\\n *\\n * @param {Function} func Function that defines part of a jasmine spec.\\n *\/\\nvar runs = function(func) {\\n  jasmine.getEnv().currentSpec.runs(func);\\n};\\nexports.runs = runs;\\n\\n\/**\\n * Waits a fixed time period before moving to the next block.\\n *\\n * @deprecated Use waitsFor() instead\\n * @param {Number} timeout milliseconds to wait\\n *\/\\nvar waits = function(timeout) {\\n  jasmine.getEnv().currentSpec.waits(timeout);\\n};\\nexports.waits = waits;\\n\\n\/**\\n * Waits for the latchFunction to return true before proceeding to the next block.\\n *\\n * @param {Function} latchFunction\\n * @param {String} optional_timeoutMessage\\n * @param {Number} optional_timeout\\n *\/\\nvar waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {\\n  jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);\\n};\\nexports.waitsFor = waitsFor;\\n\\n\/**\\n * A function that is called before each spec in a suite.\\n *\\n * Used for spec setup, including validating assumptions.\\n *\\n * @param {Function} beforeEachFunction\\n *\/\\nvar beforeEach = function(beforeEachFunction) {\\n  jasmine.getEnv().beforeEach(beforeEachFunction);\\n};\\nexports.beforeEach = beforeEach;\\n\\n\/**\\n * A function that is called after each spec in a suite.\\n *\\n * Used for restoring any state that is hijacked during spec execution.\\n *\\n * @param {Function} afterEachFunction\\n *\/\\nvar afterEach = function(afterEachFunction) {\\n  jasmine.getEnv().afterEach(afterEachFunction);\\n};\\nexports.afterEach = afterEach;\\n\\n\/**\\n * Defines a suite of specifications.\\n *\\n * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared\\n * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization\\n * of setup in some tests.\\n *\\n * @example\\n * \/\/ TODO: a simple suite\\n *\\n * \/\/ TODO: a simple suite with a nested describe block\\n *\\n * @param {String} description A string, usually the class under test.\\n * @param {Function} specDefinitions function that defines several specs.\\n *\/\\nvar describe = function(description, specDefinitions) {\\n  return jasmine.getEnv().describe(description, specDefinitions);\\n};\\nexports.describe = describe;\\n\\n\/**\\n * Disables a suite of specifications.  Used to disable some suites in a file, or files, temporarily during development.\\n *\\n * @param {String} description A string, usually the class under test.\\n * @param {Function} specDefinitions function that defines several specs.\\n *\/\\nvar xdescribe = function(description, specDefinitions) {\\n  return jasmine.getEnv().xdescribe(description, specDefinitions);\\n};\\nexports.xdescribe = xdescribe;\\n\\n\\n\/\/ Provide the XMLHttpRequest class for IE 5.x-6.x:\\njasmine.XmlHttpRequest = (typeof XMLHttpRequest == \\\"undefined\\\") ? function() {\\n  function tryIt(f) {\\n    try {\\n      return f();\\n    } catch(e) {\\n    }\\n    return null;\\n  }\\n\\n  var xhr = tryIt(function() {\\n    return new ActiveXObject(\\\"Msxml2.XMLHTTP.6.0\\\");\\n  }) ||\\n    tryIt(function() {\\n      return new ActiveXObject(\\\"Msxml2.XMLHTTP.3.0\\\");\\n    }) ||\\n    tryIt(function() {\\n      return new ActiveXObject(\\\"Msxml2.XMLHTTP\\\");\\n    }) ||\\n    tryIt(function() {\\n      return new ActiveXObject(\\\"Microsoft.XMLHTTP\\\");\\n    });\\n\\n  if (!xhr) throw new Error(\\\"This browser does not support XMLHttpRequest.\\\");\\n\\n  return xhr;\\n} : XMLHttpRequest;\\n\/**\\n * @namespace\\n *\/\\njasmine.util = {};\\n\\n\/**\\n * Declare that a child class inherit it's prototype from the parent class.\\n *\\n * @private\\n * @param {Function} childClass\\n * @param {Function} parentClass\\n *\/\\njasmine.util.inherit = function(childClass, parentClass) {\\n  \/**\\n   * @private\\n   *\/\\n  var subclass = function() {\\n  };\\n  subclass.prototype = parentClass.prototype;\\n  childClass.prototype = new subclass();\\n};\\n\\njasmine.util.formatException = function(e) {\\n  var lineNumber;\\n  if (e.line) {\\n    lineNumber = e.line;\\n  }\\n  else if (e.lineNumber) {\\n    lineNumber = e.lineNumber;\\n  }\\n\\n  var file;\\n\\n  if (e.sourceURL) {\\n    file = e.sourceURL;\\n  }\\n  else if (e.fileName) {\\n    file = e.fileName;\\n  }\\n\\n  var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();\\n\\n  if (file && lineNumber) {\\n    message += ' in ' + file + ' (line ' + lineNumber + ')';\\n  }\\n\\n  return message;\\n};\\n\\njasmine.util.htmlEscape = function(str) {\\n  if (!str) return str;\\n  return str.replace(\/&\/g, '&')\\n    .replace(\/<\/g, '<')\\n    .replace(\/>\/g, '>');\\n};\\n\\njasmine.util.argsToArray = function(args) {\\n  var arrayOfArgs = [];\\n  for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);\\n  return arrayOfArgs;\\n};\\n\\njasmine.util.extend = function(destination, source) {\\n  for (var property in source) destination[property] = source[property];\\n  return destination;\\n};\\n\\n\/**\\n * Environment for Jasmine\\n *\\n * @constructor\\n *\/\\njasmine.Env = function() {\\n  this.currentSpec = null;\\n  this.currentSuite = null;\\n  this.currentRunner_ = new jasmine.Runner(this);\\n\\n  this.reporter = new jasmine.MultiReporter();\\n\\n  this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;\\n  this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;\\n  this.lastUpdate = 0;\\n  this.specFilter = function() {\\n    return true;\\n  };\\n\\n  this.nextSpecId_ = 0;\\n  this.nextSuiteId_ = 0;\\n  this.equalityTesters_ = [];\\n\\n  \/\/ wrap matchers\\n  this.matchersClass = function() {\\n    jasmine.Matchers.apply(this, arguments);\\n  };\\n  jasmine.util.inherit(this.matchersClass, jasmine.Matchers);\\n\\n  jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass);\\n};\\n\\n\\njasmine.Env.prototype.setTimeout = jasmine.setTimeout;\\njasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;\\njasmine.Env.prototype.setInterval = jasmine.setInterval;\\njasmine.Env.prototype.clearInterval = jasmine.clearInterval;\\n\\n\/**\\n * @returns an object containing jasmine version build info, if set.\\n *\/\\njasmine.Env.prototype.version = function () {\\n  if (jasmine.version_) {\\n    return jasmine.version_;\\n  } else {\\n    throw new Error('Version not set');\\n  }\\n};\\n\\n\/**\\n * @returns string containing jasmine version build info, if set.\\n *\/\\njasmine.Env.prototype.versionString = function() {\\n  if (!jasmine.version_) {\\n    return \\\"version unknown\\\";\\n  }\\n\\n  var version = this.version();\\n  var versionString = version.major + \\\".\\\" + version.minor + \\\".\\\" + version.build;\\n  if (version.release_candidate) {\\n    versionString += \\\".rc\\\" + version.release_candidate;\\n  }\\n  versionString += \\\" revision \\\" + version.revision;\\n  return versionString;\\n};\\n\\n\/**\\n * @returns a sequential integer starting at 0\\n *\/\\njasmine.Env.prototype.nextSpecId = function () {\\n  return this.nextSpecId_++;\\n};\\n\\n\/**\\n * @returns a sequential integer starting at 0\\n *\/\\njasmine.Env.prototype.nextSuiteId = function () {\\n  return this.nextSuiteId_++;\\n};\\n\\n\/**\\n * Register a reporter to receive status updates from Jasmine.\\n * @param {jasmine.Reporter} reporter An object which will receive status updates.\\n *\/\\njasmine.Env.prototype.addReporter = function(reporter) {\\n  this.reporter.addReporter(reporter);\\n};\\n\\njasmine.Env.prototype.execute = function() {\\n  this.currentRunner_.execute();\\n};\\n\\njasmine.Env.prototype.describe = function(description, specDefinitions) {\\n  var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);\\n\\n  var parentSuite = this.currentSuite;\\n  if (parentSuite) {\\n    parentSuite.add(suite);\\n  } else {\\n    this.currentRunner_.add(suite);\\n  }\\n\\n  this.currentSuite = suite;\\n\\n  var declarationError = null;\\n  try {\\n    specDefinitions.call(suite);\\n  } catch(e) {\\n    declarationError = e;\\n  }\\n\\n  if (declarationError) {\\n    this.it(\\\"encountered a declaration exception\\\", function() {\\n      throw declarationError;\\n    });\\n  }\\n\\n  this.currentSuite = parentSuite;\\n\\n  return suite;\\n};\\n\\njasmine.Env.prototype.beforeEach = function(beforeEachFunction) {\\n  if (this.currentSuite) {\\n    this.currentSuite.beforeEach(beforeEachFunction);\\n  } else {\\n    this.currentRunner_.beforeEach(beforeEachFunction);\\n  }\\n};\\n\\njasmine.Env.prototype.currentRunner = function () {\\n  return this.currentRunner_;\\n};\\n\\njasmine.Env.prototype.afterEach = function(afterEachFunction) {\\n  if (this.currentSuite) {\\n    this.currentSuite.afterEach(afterEachFunction);\\n  } else {\\n    this.currentRunner_.afterEach(afterEachFunction);\\n  }\\n\\n};\\n\\njasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {\\n  return {\\n    execute: function() {\\n    }\\n  };\\n};\\n\\njasmine.Env.prototype.it = function(description, func) {\\n  var spec = new jasmine.Spec(this, this.currentSuite, description);\\n  this.currentSuite.add(spec);\\n  this.currentSpec = spec;\\n\\n  if (func) {\\n    spec.runs(func);\\n  }\\n\\n  return spec;\\n};\\n\\njasmine.Env.prototype.xit = function(desc, func) {\\n  var spec = this.it(desc, func);\\n  spec.results_.skipped = true;\\n  spec.runs = function() {};\\n  return spec;\\n};\\n\\njasmine.Env.prototype.compareRegExps_ = function(a, b, mismatchKeys, mismatchValues) {\\n  if (a.source != b.source)\\n    mismatchValues.push(\\\"expected pattern \/\\\" + b.source + \\\"\/ is not equal to the pattern \/\\\" + a.source + \\\"\/\\\");\\n\\n  if (a.ignoreCase != b.ignoreCase)\\n    mismatchValues.push(\\\"expected modifier i was\\\" + (b.ignoreCase ? \\\" \\\" : \\\" not \\\") + \\\"set and does not equal the origin modifier\\\");\\n\\n  if (a.global != b.global)\\n    mismatchValues.push(\\\"expected modifier g was\\\" + (b.global ? \\\" \\\" : \\\" not \\\") + \\\"set and does not equal the origin modifier\\\");\\n\\n  if (a.multiline != b.multiline)\\n    mismatchValues.push(\\\"expected modifier m was\\\" + (b.multiline ? \\\" \\\" : \\\" not \\\") + \\\"set and does not equal the origin modifier\\\");\\n\\n  if (a.sticky != b.sticky)\\n    mismatchValues.push(\\\"expected modifier y was\\\" + (b.sticky ? \\\" \\\" : \\\" not \\\") + \\\"set and does not equal the origin modifier\\\");\\n\\n  return (mismatchValues.length === 0);\\n};\\n\\njasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {\\n  if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {\\n    return true;\\n  }\\n\\n  a.__Jasmine_been_here_before__ = b;\\n  b.__Jasmine_been_here_before__ = a;\\n\\n  var hasKey = function(obj, keyName) {\\n    return obj !== null && obj[keyName] !== jasmine.undefined;\\n  };\\n\\n  for (var property in b) {\\n    if (!hasKey(a, property) && hasKey(b, property)) {\\n      mismatchKeys.push(\\\"expected has key '\\\" + property + \\\"', but missing from actual.\\\");\\n    }\\n  }\\n  for (property in a) {\\n    if (!hasKey(b, property) && hasKey(a, property)) {\\n      mismatchKeys.push(\\\"expected missing key '\\\" + property + \\\"', but present in actual.\\\");\\n    }\\n  }\\n  for (property in b) {\\n    if (property == '__Jasmine_been_here_before__') continue;\\n    if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {\\n      mismatchValues.push(\\\"'\\\" + property + \\\"' was '\\\" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + \\\"' in expected, but was '\\\" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + \\\"' in actual.\\\");\\n    }\\n  }\\n\\n  if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {\\n    mismatchValues.push(\\\"arrays were not the same length\\\");\\n  }\\n\\n  delete a.__Jasmine_been_here_before__;\\n  delete b.__Jasmine_been_here_before__;\\n  return (mismatchKeys.length === 0 && mismatchValues.length === 0);\\n};\\n\\njasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {\\n  mismatchKeys = mismatchKeys || [];\\n  mismatchValues = mismatchValues || [];\\n\\n  for (var i = 0; i < this.equalityTesters_.length; i++) {\\n    var equalityTester = this.equalityTesters_[i];\\n    var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);\\n    if (result !== jasmine.undefined) return result;\\n  }\\n\\n  if (a === b) return true;\\n\\n  if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) {\\n    return (a == jasmine.undefined && b == jasmine.undefined);\\n  }\\n\\n  if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {\\n    return a === b;\\n  }\\n\\n  if (a instanceof Date && b instanceof Date) {\\n    return a.getTime() == b.getTime();\\n  }\\n\\n  if (a.jasmineMatches) {\\n    return a.jasmineMatches(b);\\n  }\\n\\n  if (b.jasmineMatches) {\\n    return b.jasmineMatches(a);\\n  }\\n\\n  if (a instanceof jasmine.Matchers.ObjectContaining) {\\n    return a.matches(b);\\n  }\\n\\n  if (b instanceof jasmine.Matchers.ObjectContaining) {\\n    return b.matches(a);\\n  }\\n\\n  if (jasmine.isString_(a) && jasmine.isString_(b)) {\\n    return (a == b);\\n  }\\n\\n  if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) {\\n    return (a == b);\\n  }\\n\\n  if (a instanceof RegExp && b instanceof RegExp) {\\n    return this.compareRegExps_(a, b, mismatchKeys, mismatchValues);\\n  }\\n\\n  if (typeof a === \\\"object\\\" && typeof b === \\\"object\\\") {\\n    return this.compareObjects_(a, b, mismatchKeys, mismatchValues);\\n  }\\n\\n  \/\/Straight check\\n  return (a === b);\\n};\\n\\njasmine.Env.prototype.contains_ = function(haystack, needle) {\\n  if (jasmine.isArray_(haystack)) {\\n    for (var i = 0; i < haystack.length; i++) {\\n      if (this.equals_(haystack[i], needle)) return true;\\n    }\\n    return false;\\n  }\\n  return haystack.indexOf(needle) >= 0;\\n};\\n\\njasmine.Env.prototype.addEqualityTester = function(equalityTester) {\\n  this.equalityTesters_.push(equalityTester);\\n};\\n\/** No-op base class for Jasmine reporters.\\n *\\n * @constructor\\n *\/\\njasmine.Reporter = function() {\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.Reporter.prototype.reportRunnerStarting = function(runner) {\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.Reporter.prototype.reportRunnerResults = function(runner) {\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.Reporter.prototype.reportSuiteResults = function(suite) {\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.Reporter.prototype.reportSpecStarting = function(spec) {\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.Reporter.prototype.reportSpecResults = function(spec) {\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.Reporter.prototype.log = function(str) {\\n};\\n\\n\/**\\n * Blocks are functions with executable code that make up a spec.\\n *\\n * @constructor\\n * @param {jasmine.Env} env\\n * @param {Function} func\\n * @param {jasmine.Spec} spec\\n *\/\\njasmine.Block = function(env, func, spec) {\\n  this.env = env;\\n  this.func = func;\\n  this.spec = spec;\\n};\\n\\njasmine.Block.prototype.execute = function(onComplete) {\\n  if (!jasmine.CATCH_EXCEPTIONS) {\\n    this.func.apply(this.spec);\\n  }\\n  else {\\n    try {\\n      this.func.apply(this.spec);\\n    } catch (e) {\\n      this.spec.fail(e);\\n    }\\n  }\\n  onComplete();\\n};\\n\/** JavaScript API reporter.\\n *\\n * @constructor\\n *\/\\njasmine.JsApiReporter = function() {\\n  this.started = false;\\n  this.finished = false;\\n  this.suites_ = [];\\n  this.results_ = {};\\n};\\n\\njasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {\\n  this.started = true;\\n  var suites = runner.topLevelSuites();\\n  for (var i = 0; i < suites.length; i++) {\\n    var suite = suites[i];\\n    this.suites_.push(this.summarize_(suite));\\n  }\\n};\\n\\njasmine.JsApiReporter.prototype.suites = function() {\\n  return this.suites_;\\n};\\n\\njasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {\\n  var isSuite = suiteOrSpec instanceof jasmine.Suite;\\n  var summary = {\\n    id: suiteOrSpec.id,\\n    name: suiteOrSpec.description,\\n    type: isSuite ? 'suite' : 'spec',\\n    children: []\\n  };\\n  \\n  if (isSuite) {\\n    var children = suiteOrSpec.children();\\n    for (var i = 0; i < children.length; i++) {\\n      summary.children.push(this.summarize_(children[i]));\\n    }\\n  }\\n  return summary;\\n};\\n\\njasmine.JsApiReporter.prototype.results = function() {\\n  return this.results_;\\n};\\n\\njasmine.JsApiReporter.prototype.resultsForSpec = function(specId) {\\n  return this.results_[specId];\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {\\n  this.finished = true;\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {\\n  this.results_[spec.id] = {\\n    messages: spec.results().getItems(),\\n    result: spec.results().failedCount > 0 ? \\\"failed\\\" : \\\"passed\\\"\\n  };\\n};\\n\\n\/\/noinspection JSUnusedLocalSymbols\\njasmine.JsApiReporter.prototype.log = function(str) {\\n};\\n\\njasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){\\n  var results = {};\\n  for (var i = 0; i < specIds.length; i++) {\\n    var specId = specIds[i];\\n    results[specId] = this.summarizeResult_(this.results_[specId]);\\n  }\\n  return results;\\n};\\n\\njasmine.JsApiReporter.prototype.summarizeResult_ = function(result){\\n  var summaryMessages = [];\\n  var messagesLength = result.messages.length;\\n  for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {\\n    var resultMessage = result.messages[messageIndex];\\n    summaryMessages.push({\\n      text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,\\n      passed: resultMessage.passed ? resultMessage.passed() : true,\\n      type: resultMessage.type,\\n      message: resultMessage.message,\\n      trace: {\\n        stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined\\n      }\\n    });\\n  }\\n\\n  return {\\n    result : result.result,\\n    messages : summaryMessages\\n  };\\n};\\n\\n\/**\\n * @constructor\\n * @param {jasmine.Env} env\\n * @param actual\\n * @param {jasmine.Spec} spec\\n *\/\\njasmine.Matchers = function(env, actual, spec, opt_isNot) {\\n  this.env = env;\\n  this.actual = actual;\\n  this.spec = spec;\\n  this.isNot = opt_isNot || false;\\n  this.reportWasCalled_ = false;\\n};\\n\\n\/\/ todo: @deprecated as of Jasmine 0.11, remove soon [xw]\\njasmine.Matchers.pp = function(str) {\\n  throw new Error(\\\"jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!\\\");\\n};\\n\\n\/\/ todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]\\njasmine.Matchers.prototype.report = function(result, failing_message, details) {\\n  throw new Error(\\\"As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs\\\");\\n};\\n\\njasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {\\n  for (var methodName in prototype) {\\n    if (methodName == 'report') continue;\\n    var orig = prototype[methodName];\\n    matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);\\n  }\\n};\\n\\njasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {\\n  return function() {\\n    var matcherArgs = jasmine.util.argsToArray(arguments);\\n    var result = matcherFunction.apply(this, arguments);\\n\\n    if (this.isNot) {\\n      result = !result;\\n    }\\n\\n    if (this.reportWasCalled_) return result;\\n\\n    var message;\\n    if (!result) {\\n      if (this.message) {\\n        message = this.message.apply(this, arguments);\\n        if (jasmine.isArray_(message)) {\\n          message = message[this.isNot ? 1 : 0];\\n        }\\n      } else {\\n        var englishyPredicate = matcherName.replace(\/[A-Z]\/g, function(s) { return ' ' + s.toLowerCase(); });\\n        message = \\\"Expected \\\" + jasmine.pp(this.actual) + (this.isNot ? \\\" not \\\" : \\\" \\\") + englishyPredicate;\\n        if (matcherArgs.length > 0) {\\n          for (var i = 0; i < matcherArgs.length; i++) {\\n            if (i > 0) message += \\\",\\\";\\n            message += \\\" \\\" + jasmine.pp(matcherArgs[i]);\\n          }\\n        }\\n        message += \\\".\\\";\\n      }\\n    }\\n    var expectationResult = new jasmine.ExpectationResult({\\n      matcherName: matcherName,\\n      passed: result,\\n      expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0],\\n      actual: this.actual,\\n      message: message\\n    });\\n    this.spec.addMatcherResult(expectationResult);\\n    return jasmine.undefined;\\n  };\\n};\\n\\n\\n\\n\\n\/**\\n * toBe: compares the actual to the expected using ===\\n * @param expected\\n *\/\\njasmine.Matchers.prototype.toBe = function(expected) {\\n  return this.actual === expected;\\n};\\n\\n\/**\\n * toNotBe: compares the actual to the expected using !==\\n * @param expected\\n * @deprecated as of 1.0. Use not.toBe() instead.\\n *\/\\njasmine.Matchers.prototype.toNotBe = function(expected) {\\n  return this.actual !== expected;\\n};\\n\\n\/**\\n * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.\\n *\\n * @param expected\\n *\/\\njasmine.Matchers.prototype.toEqual = function(expected) {\\n  return this.env.equals_(this.actual, expected);\\n};\\n\\n\/**\\n * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual\\n * @param expected\\n * @deprecated as of 1.0. Use not.toEqual() instead.\\n *\/\\njasmine.Matchers.prototype.toNotEqual = function(expected) {\\n  return !this.env.equals_(this.actual, expected);\\n};\\n\\n\/**\\n * Matcher that compares the actual to the expected using a regular expression.  Constructs a RegExp, so takes\\n * a pattern or a String.\\n *\\n * @param expected\\n *\/\\njasmine.Matchers.prototype.toMatch = function(expected) {\\n  return new RegExp(expected).test(this.actual);\\n};\\n\\n\/**\\n * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch\\n * @param expected\\n * @deprecated as of 1.0. Use not.toMatch() instead.\\n *\/\\njasmine.Matchers.prototype.toNotMatch = function(expected) {\\n  return !(new RegExp(expected).test(this.actual));\\n};\\n\\n\/**\\n * Matcher that compares the actual to jasmine.undefined.\\n *\/\\njasmine.Matchers.prototype.toBeDefined = function() {\\n  return (this.actual !== jasmine.undefined);\\n};\\n\\n\/**\\n * Matcher that compares the actual to jasmine.undefined.\\n *\/\\njasmine.Matchers.prototype.toBeUndefined = function() {\\n  return (this.actual === jasmine.undefined);\\n};\\n\\n\/**\\n * Matcher that compares the actual to null.\\n *\/\\njasmine.Matchers.prototype.toBeNull = function() {\\n  return (this.actual === null);\\n};\\n\\n\/**\\n * Matcher that compares the actual to NaN.\\n *\/\\njasmine.Matchers.prototype.toBeNaN = function() {\\n\\tthis.message = function() {\\n\\t\\treturn [ \\\"Expected \\\" + jasmine.pp(this.actual) + \\\" to be NaN.\\\" ];\\n\\t};\\n\\n\\treturn (this.actual !== this.actual);\\n};\\n\\n\/**\\n * Matcher that boolean not-nots the actual.\\n *\/\\njasmine.Matchers.prototype.toBeTruthy = function() {\\n  return !!this.actual;\\n};\\n\\n\\n\/**\\n * Matcher that boolean nots the actual.\\n *\/\\njasmine.Matchers.prototype.toBeFalsy = function() {\\n  return !this.actual;\\n};\\n\\n\\n\/**\\n * Matcher that checks to see if the actual, a Jasmine spy, was called.\\n *\/\\njasmine.Matchers.prototype.toHaveBeenCalled = function() {\\n  if (arguments.length > 0) {\\n    throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');\\n  }\\n\\n  if (!jasmine.isSpy(this.actual)) {\\n    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');\\n  }\\n\\n  this.message = function() {\\n    return [\\n      \\\"Expected spy \\\" + this.actual.identity + \\\" to have been called.\\\",\\n      \\\"Expected spy \\\" + this.actual.identity + \\\" not to have been called.\\\"\\n    ];\\n  };\\n\\n  return this.actual.wasCalled;\\n};\\n\\n\/** @deprecated Use expect(xxx).toHaveBeenCalled() instead *\/\\njasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled;\\n\\n\/**\\n * Matcher that checks to see if the actual, a Jasmine spy, was not called.\\n *\\n * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead\\n *\/\\njasmine.Matchers.prototype.wasNotCalled = function() {\\n  if (arguments.length > 0) {\\n    throw new Error('wasNotCalled does not take arguments');\\n  }\\n\\n  if (!jasmine.isSpy(this.actual)) {\\n    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');\\n  }\\n\\n  this.message = function() {\\n    return [\\n      \\\"Expected spy \\\" + this.actual.identity + \\\" to not have been called.\\\",\\n      \\\"Expected spy \\\" + this.actual.identity + \\\" to have been called.\\\"\\n    ];\\n  };\\n\\n  return !this.actual.wasCalled;\\n};\\n\\n\/**\\n * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.\\n *\\n * @example\\n *\\n *\/\\njasmine.Matchers.prototype.toHaveBeenCalledWith = function() {\\n  var expectedArgs = jasmine.util.argsToArray(arguments);\\n  if (!jasmine.isSpy(this.actual)) {\\n    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');\\n  }\\n  this.message = function() {\\n    var invertedMessage = \\\"Expected spy \\\" + this.actual.identity + \\\" not to have been called with \\\" + jasmine.pp(expectedArgs) + \\\" but it was.\\\";\\n    var positiveMessage = \\\"\\\";\\n    if (this.actual.callCount === 0) {\\n      positiveMessage = \\\"Expected spy \\\" + this.actual.identity + \\\" to have been called with \\\" + jasmine.pp(expectedArgs) + \\\" but it was never called.\\\";\\n    } else {\\n      positiveMessage = \\\"Expected spy \\\" + this.actual.identity + \\\" to have been called with \\\" + jasmine.pp(expectedArgs) + \\\" but actual calls were \\\" + jasmine.pp(this.actual.argsForCall).replace(\/^\\\\[ | \\\\]$\/g, '')\\n    }\\n    return [positiveMessage, invertedMessage];\\n  };\\n\\n  return this.env.contains_(this.actual.argsForCall, expectedArgs);\\n};\\n\\n\/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead *\/\\njasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith;\\n\\n\/** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead *\/\\njasmine.Matchers.prototype.wasNotCalledWith = function() {\\n  var expectedArgs = jasmine.util.argsToArray(arguments);\\n  if (!jasmine.isSpy(this.actual)) {\\n    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');\\n  }\\n\\n  this.message = function() {\\n    return [\\n      \\\"Expected spy not to have been called with \\\" + jasmine.pp(expectedArgs) + \\\" but it was\\\",\\n      \\\"Expected spy to have been called with \\\" + jasmine.pp(expectedArgs) + \\\" but it was\\\"\\n    ];\\n  };\\n\\n  return !this.env.contains_(this.actual.argsForCall, expectedArgs);\\n};\\n\\n\/**\\n * Matcher that checks that the expected item is an element in the actual Array.\\n *\\n * @param {Object} expected\\n *\/\\njasmine.Matchers.prototype.toContain = function(expected) {\\n  return this.env.contains_(this.actual, expected);\\n};\\n\\n\/**\\n * Matcher that checks that the expected item is NOT an element in the actual Array.\\n *\\n * @param {Object} expected\\n * @deprecated as of 1.0. Use not.toContain() instead.\\n *\/\\njasmine.Matchers.prototype.toNotContain = function(expected) {\\n  return !this.env.contains_(this.actual, expected);\\n};\\n\\njasmine.Matchers.prototype.toBeLessThan = function(expected) {\\n  return this.actual < expected;\\n};\\n\\njasmine.Matchers.prototype.toBeGreaterThan = function(expected) {\\n  return this.actual > expected;\\n};\\n\\n\/**\\n * Matcher that checks that the expected item is equal to the actual item\\n * up to a given level of decimal precision (default 2).\\n *\\n * @param {Number} expected\\n * @param {Number} precision, as number of decimal places\\n *\/\\njasmine.Matchers.prototype.toBeCloseTo = function(expected, precision) {\\n  if (!(precision === 0)) {\\n    precision = precision || 2;\\n  }\\n  return Math.abs(expected - this.actual) < (Math.pow(10, -precision) \/ 2);\\n};\\n\\n\/**\\n * Matcher that checks that the expected exception was thrown by the actual.\\n *\\n * @param {String} [expected]\\n *\/\\njasmine.Matchers.prototype.toThrow = function(expected) {\\n  var result = false;\\n  var exception;\\n  if (typeof this.actual != 'function') {\\n    throw new Error('Actual is not a function');\\n  }\\n  try {\\n    this.actual();\\n  } catch (e) {\\n    exception = e;\\n  }\\n  if (exception) {\\n    result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));\\n  }\\n\\n  var not = this.isNot ? \\\"not \\\" : \\\"\\\";\\n\\n  this.message = function() {\\n    if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {\\n      return [\\\"Expected function \\\" + not + \\\"to throw\\\", expected ? expected.message || expected : \\\"an exception\\\", \\\", but it threw\\\", exception.message || exception].join(' ');\\n    } else {\\n      return \\\"Expected function to throw an exception.\\\";\\n    }\\n  };\\n\\n  return result;\\n};\\n\\njasmine.Matchers.Any = function(expectedClass) {\\n  this.expectedClass = expectedClass;\\n};\\n\\njasmine.Matchers.Any.prototype.jasmineMatches = function(other) {\\n  if (this.expectedClass == String) {\\n    return typeof other == 'string' || other instanceof String;\\n  }\\n\\n  if (this.expectedClass == Number) {\\n    return typeof other == 'number' || other instanceof Number;\\n  }\\n\\n  if (this.expectedClass == Function) {\\n    return typeof other == 'function' || other instanceof Function;\\n  }\\n\\n  if (this.expectedClass == Object) {\\n    return typeof other == 'object';\\n  }\\n\\n  return other instanceof this.expectedClass;\\n};\\n\\njasmine.Matchers.Any.prototype.jasmineToString = function() {\\n  return '';\\n};\\n\\njasmine.Matchers.ObjectContaining = function (sample) {\\n  this.sample = sample;\\n};\\n\\njasmine.Matchers.ObjectContaining.prototype.jasmineMatches = function(other, mismatchKeys, mismatchValues) {\\n  mismatchKeys = mismatchKeys || [];\\n  mismatchValues = mismatchValues || [];\\n\\n  var env = jasmine.getEnv();\\n\\n  var hasKey = function(obj, keyName) {\\n    return obj != null && obj[keyName] !== jasmine.undefined;\\n  };\\n\\n  for (var property in this.sample) {\\n    if (!hasKey(other, property) && hasKey(this.sample, property)) {\\n      mismatchKeys.push(\\\"expected has key '\\\" + property + \\\"', but missing from actual.\\\");\\n    }\\n    else if (!env.equals_(this.sample[property], other[property], mismatchKeys, mismatchValues)) {\\n      mismatchValues.push(\\\"'\\\" + property + \\\"' was '\\\" + (other[property] ? jasmine.util.htmlEscape(other[property].toString()) : other[property]) + \\\"' in expected, but was '\\\" + (this.sample[property] ? jasmine.util.htmlEscape(this.sample[property].toString()) : this.sample[property]) + \\\"' in actual.\\\");\\n    }\\n  }\\n\\n  return (mismatchKeys.length === 0 && mismatchValues.length === 0);\\n};\\n\\njasmine.Matchers.ObjectContaining.prototype.jasmineToString = function () {\\n  return \\\"\\\";\\n};\\n\/\/ Mock setTimeout, clearTimeout\\n\/\/ Contributed by Pivotal Computer Systems, www.pivotalsf.com\\n\\njasmine.FakeTimer = function() {\\n  this.reset();\\n\\n  var self = this;\\n  self.setTimeout = function(funcToCall, millis) {\\n    self.timeoutsMade++;\\n    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);\\n    return self.timeoutsMade;\\n  };\\n\\n  self.setInterval = function(funcToCall, millis) {\\n    self.timeoutsMade++;\\n    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);\\n    return self.timeoutsMade;\\n  };\\n\\n  self.clearTimeout = function(timeoutKey) {\\n    self.scheduledFunctions[timeoutKey] = jasmine.undefined;\\n  };\\n\\n  self.clearInterval = function(timeoutKey) {\\n    self.scheduledFunctions[timeoutKey] = jasmine.undefined;\\n  };\\n\\n};\\n\\njasmine.FakeTimer.prototype.reset = function() {\\n  this.timeoutsMade = 0;\\n  this.scheduledFunctions = {};\\n  this.nowMillis = 0;\\n};\\n\\njasmine.FakeTimer.prototype.tick = function(millis) {\\n  var oldMillis = this.nowMillis;\\n  var newMillis = oldMillis + millis;\\n  this.runFunctionsWithinRange(oldMillis, newMillis);\\n  this.nowMillis = newMillis;\\n};\\n\\njasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {\\n  var scheduledFunc;\\n  var funcsToRun = [];\\n  for (var timeoutKey in this.scheduledFunctions) {\\n    scheduledFunc = this.scheduledFunctions[timeoutKey];\\n    if (scheduledFunc != jasmine.undefined &&\\n        scheduledFunc.runAtMillis >= oldMillis &&\\n        scheduledFunc.runAtMillis <= nowMillis) {\\n      funcsToRun.push(scheduledFunc);\\n      this.scheduledFunctions[timeoutKey] = jasmine.undefined;\\n    }\\n  }\\n\\n  if (funcsToRun.length > 0) {\\n    funcsToRun.sort(function(a, b) {\\n      return a.runAtMillis - b.runAtMillis;\\n    });\\n    for (var i = 0; i < funcsToRun.length; ++i) {\\n      try {\\n        var funcToRun = funcsToRun[i];\\n        this.nowMillis = funcToRun.runAtMillis;\\n        funcToRun.funcToCall();\\n        if (funcToRun.recurring) {\\n          this.scheduleFunction(funcToRun.timeoutKey,\\n              funcToRun.funcToCall,\\n              funcToRun.millis,\\n              true);\\n        }\\n      } catch(e) {\\n      }\\n    }\\n    this.runFunctionsWithinRange(oldMillis, nowMillis);\\n  }\\n};\\n\\njasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {\\n  this.scheduledFunctions[timeoutKey] = {\\n    runAtMillis: this.nowMillis + millis,\\n    funcToCall: funcToCall,\\n    recurring: recurring,\\n    timeoutKey: timeoutKey,\\n    millis: millis\\n  };\\n};\\n\\n\/**\\n * @namespace\\n *\/\\njasmine.Clock = {\\n  defaultFakeTimer: new jasmine.FakeTimer(),\\n\\n  reset: function() {\\n    jasmine.Clock.assertInstalled();\\n    jasmine.Clock.defaultFakeTimer.reset();\\n  },\\n\\n  tick: function(millis) {\\n    jasmine.Clock.assertInstalled();\\n    jasmine.Clock.defaultFakeTimer.tick(millis);\\n  },\\n\\n  runFunctionsWithinRange: function(oldMillis, nowMillis) {\\n    jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);\\n  },\\n\\n  scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {\\n    jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);\\n  },\\n\\n  useMock: function() {\\n    if (!jasmine.Clock.isInstalled()) {\\n      var spec = jasmine.getEnv().currentSpec;\\n      spec.after(jasmine.Clock.uninstallMock);\\n\\n      jasmine.Clock.installMock();\\n    }\\n  },\\n\\n  installMock: function() {\\n    jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;\\n  },\\n\\n  uninstallMock: function() {\\n    jasmine.Clock.assertInstalled();\\n    jasmine.Clock.installed = jasmine.Clock.real;\\n  },\\n\\n  real: {\\n    setTimeout: jasmine.getGlobal().setTimeout,\\n    clearTimeout: jasmine.getGlobal().clearTimeout,\\n    setInterval: jasmine.getGlobal().setInterval,\\n    clearInterval: jasmine.getGlobal().clearInterval\\n  },\\n\\n  assertInstalled: function() {\\n    if (!jasmine.Clock.isInstalled()) {\\n      throw new Error(\\\"Mock clock is not installed, use jasmine.Clock.useMock()\\\");\\n    }\\n  },\\n\\n  isInstalled: function() {\\n    return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;\\n  },\\n\\n  installed: null\\n};\\njasmine.Clock.installed = jasmine.Clock.real;\\n\\n\/\/else for IE support\\njasmine.getGlobal().setTimeout = function(funcToCall, millis) {\\n  if (jasmine.Clock.installed.setTimeout.apply) {\\n    return jasmine.Clock.installed.setTimeout.apply(this, arguments);\\n  } else {\\n    return jasmine.Clock.installed.setTimeout(funcToCall, millis);\\n  }\\n};\\n\\njasmine.getGlobal().setInterval = function(funcToCall, millis) {\\n  if (jasmine.Clock.installed.setInterval.apply) {\\n    return jasmine.Clock.installed.setInterval.apply(this, arguments);\\n  } else {\\n    return jasmine.Clock.installed.setInterval(funcToCall, millis);\\n  }\\n};\\n\\njasmine.getGlobal().clearTimeout = function(timeoutKey) {\\n  if (jasmine.Clock.installed.clearTimeout.apply) {\\n    return jasmine.Clock.installed.clearTimeout.apply(this, arguments);\\n  } else {\\n    return jasmine.Clock.installed.clearTimeout(timeoutKey);\\n  }\\n};\\n\\njasmine.getGlobal().clearInterval = function(timeoutKey) {\\n  if (jasmine.Clock.installed.clearTimeout.apply) {\\n    return jasmine.Clock.installed.clearInterval.apply(this, arguments);\\n  } else {\\n    return jasmine.Clock.installed.clearInterval(timeoutKey);\\n  }\\n};\\n\\n\/**\\n * @constructor\\n *\/\\njasmine.MultiReporter = function() {\\n  this.subReporters_ = [];\\n};\\njasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);\\n\\njasmine.MultiReporter.prototype.addReporter = function(reporter) {\\n  this.subReporters_.push(reporter);\\n};\\n\\n(function() {\\n  var functionNames = [\\n    \\\"reportRunnerStarting\\\",\\n    \\\"reportRunnerResults\\\",\\n    \\\"reportSuiteResults\\\",\\n    \\\"reportSpecStarting\\\",\\n    \\\"reportSpecResults\\\",\\n    \\\"log\\\"\\n  ];\\n  for (var i = 0; i < functionNames.length; i++) {\\n    var functionName = functionNames[i];\\n    jasmine.MultiReporter.prototype[functionName] = (function(functionName) {\\n      return function() {\\n        for (var j = 0; j < this.subReporters_.length; j++) {\\n          var subReporter = this.subReporters_[j];\\n          if (subReporter[functionName]) {\\n            subReporter[functionName].apply(subReporter, arguments);\\n          }\\n        }\\n      };\\n    })(functionName);\\n  }\\n})();\\n\/**\\n * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults\\n *\\n * @constructor\\n *\/\\njasmine.NestedResults = function() {\\n  \/**\\n   * The total count of results\\n   *\/\\n  this.totalCount = 0;\\n  \/**\\n   * Number of passed results\\n   *\/\\n  this.passedCount = 0;\\n  \/**\\n   * Number of failed results\\n   *\/\\n  this.failedCount = 0;\\n  \/**\\n   * Was this suite\/spec skipped?\\n   *\/\\n  this.skipped = false;\\n  \/**\\n   * @ignore\\n   *\/\\n  this.items_ = [];\\n};\\n\\n\/**\\n * Roll up the result counts.\\n *\\n * @param result\\n *\/\\njasmine.NestedResults.prototype.rollupCounts = function(result) {\\n  this.totalCount += result.totalCount;\\n  this.passedCount += result.passedCount;\\n  this.failedCount += result.failedCount;\\n};\\n\\n\/**\\n * Adds a log message.\\n * @param values Array of message parts which will be concatenated later.\\n *\/\\njasmine.NestedResults.prototype.log = function(values) {\\n  this.items_.push(new jasmine.MessageResult(values));\\n};\\n\\n\/**\\n * Getter for the results: message & results.\\n *\/\\njasmine.NestedResults.prototype.getItems = function() {\\n  return this.items_;\\n};\\n\\n\/**\\n * Adds a result, tracking counts (total, passed, & failed)\\n * @param {jasmine.ExpectationResult|jasmine.NestedResults} result\\n *\/\\njasmine.NestedResults.prototype.addResult = function(result) {\\n  if (result.type != 'log') {\\n    if (result.items_) {\\n      this.rollupCounts(result);\\n    } else {\\n      this.totalCount++;\\n      if (result.passed()) {\\n        this.passedCount++;\\n      } else {\\n        this.failedCount++;\\n      }\\n    }\\n  }\\n  this.items_.push(result);\\n};\\n\\n\/**\\n * @returns {Boolean} True if everything<\/b> below passed\\n *\/\\njasmine.NestedResults.prototype.passed = function() {\\n  return this.passedCount === this.totalCount;\\n};\\n\/**\\n * Base class for pretty printing for expectation results.\\n *\/\\njasmine.PrettyPrinter = function() {\\n  this.ppNestLevel_ = 0;\\n};\\n\\n\/**\\n * Formats a value in a nice, human-readable string.\\n *\\n * @param value\\n *\/\\njasmine.PrettyPrinter.prototype.format = function(value) {\\n  this.ppNestLevel_++;\\n  try {\\n    if (value === jasmine.undefined) {\\n      this.emitScalar('undefined');\\n    } else if (value === null) {\\n      this.emitScalar('null');\\n    } else if (value === jasmine.getGlobal()) {\\n      this.emitScalar('');\\n    } else if (value.jasmineToString) {\\n      this.emitScalar(value.jasmineToString());\\n    } else if (typeof value === 'string') {\\n      this.emitString(value);\\n    } else if (jasmine.isSpy(value)) {\\n      this.emitScalar(\\\"spy on \\\" + value.identity);\\n    } else if (value instanceof RegExp) {\\n      this.emitScalar(value.toString());\\n    } else if (typeof value === 'function') {\\n      this.emitScalar('Function');\\n    } else if (typeof value.nodeType === 'number') {\\n      this.emitScalar('HTMLNode');\\n    } else if (value instanceof Date) {\\n      this.emitScalar('Date(' + value + ')');\\n    } else if (value.__Jasmine_been_here_before__) {\\n      this.emitScalar('');\\n    } else if (jasmine.isArray_(value) || typeof value == 'object') {\\n      value.__Jasmine_been_here_before__ = true;\\n      if (jasmine.isArray_(value)) {\\n        this.emitArray(value);\\n      } else {\\n        this.emitObject(value);\\n      }\\n      delete value.__Jasmine_been_here_before__;\\n    } else {\\n      this.emitScalar(value.toString());\\n    }\\n  } finally {\\n    this.ppNestLevel_--;\\n  }\\n};\\n\\njasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {\\n  for (var property in obj) {\\n    if (!obj.hasOwnProperty(property)) continue;\\n    if (property == '__Jasmine_been_here_before__') continue;\\n    fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) !== jasmine.undefined && \\n                                         obj.__lookupGetter__(property) !== null) : false);\\n  }\\n};\\n\\njasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;\\njasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;\\njasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;\\njasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;\\n\\njasmine.StringPrettyPrinter = function() {\\n  jasmine.PrettyPrinter.call(this);\\n\\n  this.string = '';\\n};\\njasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);\\n\\njasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {\\n  this.append(value);\\n};\\n\\njasmine.StringPrettyPrinter.prototype.emitString = function(value) {\\n  this.append(\\\"'\\\" + value + \\\"'\\\");\\n};\\n\\njasmine.StringPrettyPrinter.prototype.emitArray = function(array) {\\n  if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) {\\n    this.append(\\\"Array\\\");\\n    return;\\n  }\\n\\n  this.append('[ ');\\n  for (var i = 0; i < array.length; i++) {\\n    if (i > 0) {\\n      this.append(', ');\\n    }\\n    this.format(array[i]);\\n  }\\n  this.append(' ]');\\n};\\n\\njasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {\\n  if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) {\\n    this.append(\\\"Object\\\");\\n    return;\\n  }\\n\\n  var self = this;\\n  this.append('{ ');\\n  var first = true;\\n\\n  this.iterateObject(obj, function(property, isGetter) {\\n    if (first) {\\n      first = false;\\n    } else {\\n      self.append(', ');\\n    }\\n\\n    self.append(property);\\n    self.append(' : ');\\n    if (isGetter) {\\n      self.append('');\\n    } else {\\n      self.format(obj[property]);\\n    }\\n  });\\n\\n  this.append(' }');\\n};\\n\\njasmine.StringPrettyPrinter.prototype.append = function(value) {\\n  this.string += value;\\n};\\njasmine.Queue = function(env) {\\n  this.env = env;\\n\\n  \/\/ parallel to blocks. each true value in this array means the block will\\n  \/\/ get executed even if we abort\\n  this.ensured = [];\\n  this.blocks = [];\\n  this.running = false;\\n  this.index = 0;\\n  this.offset = 0;\\n  this.abort = false;\\n};\\n\\njasmine.Queue.prototype.addBefore = function(block, ensure) {\\n  if (ensure === jasmine.undefined) {\\n    ensure = false;\\n  }\\n\\n  this.blocks.unshift(block);\\n  this.ensured.unshift(ensure);\\n};\\n\\njasmine.Queue.prototype.add = function(block, ensure) {\\n  if (ensure === jasmine.undefined) {\\n    ensure = false;\\n  }\\n\\n  this.blocks.push(block);\\n  this.ensured.push(ensure);\\n};\\n\\njasmine.Queue.prototype.insertNext = function(block, ensure) {\\n  if (ensure === jasmine.undefined) {\\n    ensure = false;\\n  }\\n\\n  this.ensured.splice((this.index + this.offset + 1), 0, ensure);\\n  this.blocks.splice((this.index + this.offset + 1), 0, block);\\n  this.offset++;\\n};\\n\\njasmine.Queue.prototype.start = function(onComplete) {\\n  this.running = true;\\n  this.onComplete = onComplete;\\n  this.next_();\\n};\\n\\njasmine.Queue.prototype.isRunning = function() {\\n  return this.running;\\n};\\n\\njasmine.Queue.LOOP_DONT_RECURSE = true;\\n\\njasmine.Queue.prototype.next_ = function() {\\n  var self = this;\\n  var goAgain = true;\\n\\n  while (goAgain) {\\n    goAgain = false;\\n    \\n    if (self.index < self.blocks.length && !(this.abort && !this.ensured[self.index])) {\\n      var calledSynchronously = true;\\n      var completedSynchronously = false;\\n\\n      var onComplete = function () {\\n        if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {\\n          completedSynchronously = true;\\n          return;\\n        }\\n\\n        if (self.blocks[self.index].abort) {\\n          self.abort = true;\\n        }\\n\\n        self.offset = 0;\\n        self.index++;\\n\\n        var now = new Date().getTime();\\n        if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {\\n          self.env.lastUpdate = now;\\n          self.env.setTimeout(function() {\\n            self.next_();\\n          }, 0);\\n        } else {\\n          if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {\\n            goAgain = true;\\n          } else {\\n            self.next_();\\n          }\\n        }\\n      };\\n      self.blocks[self.index].execute(onComplete);\\n\\n      calledSynchronously = false;\\n      if (completedSynchronously) {\\n        onComplete();\\n      }\\n      \\n    } else {\\n      self.running = false;\\n      if (self.onComplete) {\\n        self.onComplete();\\n      }\\n    }\\n  }\\n};\\n\\njasmine.Queue.prototype.results = function() {\\n  var results = new jasmine.NestedResults();\\n  for (var i = 0; i < this.blocks.length; i++) {\\n    if (this.blocks[i].results) {\\n      results.addResult(this.blocks[i].results());\\n    }\\n  }\\n  return results;\\n};\\n\\n\\n\/**\\n * Runner\\n *\\n * @constructor\\n * @param {jasmine.Env} env\\n *\/\\njasmine.Runner = function(env) {\\n  var self = this;\\n  self.env = env;\\n  self.queue = new jasmine.Queue(env);\\n  self.before_ = [];\\n  self.after_ = [];\\n  self.suites_ = [];\\n};\\n\\njasmine.Runner.prototype.execute = function() {\\n  var self = this;\\n  if (self.env.reporter.reportRunnerStarting) {\\n    self.env.reporter.reportRunnerStarting(this);\\n  }\\n  self.queue.start(function () {\\n    self.finishCallback();\\n  });\\n};\\n\\njasmine.Runner.prototype.beforeEach = function(beforeEachFunction) {\\n  beforeEachFunction.typeName = 'beforeEach';\\n  this.before_.splice(0,0,beforeEachFunction);\\n};\\n\\njasmine.Runner.prototype.afterEach = function(afterEachFunction) {\\n  afterEachFunction.typeName = 'afterEach';\\n  this.after_.splice(0,0,afterEachFunction);\\n};\\n\\n\\njasmine.Runner.prototype.finishCallback = function() {\\n  this.env.reporter.reportRunnerResults(this);\\n};\\n\\njasmine.Runner.prototype.addSuite = function(suite) {\\n  this.suites_.push(suite);\\n};\\n\\njasmine.Runner.prototype.add = function(block) {\\n  if (block instanceof jasmine.Suite) {\\n    this.addSuite(block);\\n  }\\n  this.queue.add(block);\\n};\\n\\njasmine.Runner.prototype.specs = function () {\\n  var suites = this.suites();\\n  var specs = [];\\n  for (var i = 0; i < suites.length; i++) {\\n    specs = specs.concat(suites[i].specs());\\n  }\\n  return specs;\\n};\\n\\njasmine.Runner.prototype.suites = function() {\\n  return this.suites_;\\n};\\n\\njasmine.Runner.prototype.topLevelSuites = function() {\\n  var topLevelSuites = [];\\n  for (var i = 0; i < this.suites_.length; i++) {\\n    if (!this.suites_[i].parentSuite) {\\n      topLevelSuites.push(this.suites_[i]);\\n    }\\n  }\\n  return topLevelSuites;\\n};\\n\\njasmine.Runner.prototype.results = function() {\\n  return this.queue.results();\\n};\\n\/**\\n * Internal representation of a Jasmine specification, or test.\\n *\\n * @constructor\\n * @param {jasmine.Env} env\\n * @param {jasmine.Suite} suite\\n * @param {String} description\\n *\/\\njasmine.Spec = function(env, suite, description) {\\n  if (!env) {\\n    throw new Error('jasmine.Env() required');\\n  }\\n  if (!suite) {\\n    throw new Error('jasmine.Suite() required');\\n  }\\n  var spec = this;\\n  spec.id = env.nextSpecId ? env.nextSpecId() : null;\\n  spec.env = env;\\n  spec.suite = suite;\\n  spec.description = description;\\n  spec.queue = new jasmine.Queue(env);\\n\\n  spec.afterCallbacks = [];\\n  spec.spies_ = [];\\n\\n  spec.results_ = new jasmine.NestedResults();\\n  spec.results_.description = description;\\n  spec.matchersClass = null;\\n};\\n\\njasmine.Spec.prototype.getFullName = function() {\\n  return this.suite.getFullName() + ' ' + this.description + '.';\\n};\\n\\n\\njasmine.Spec.prototype.results = function() {\\n  return this.results_;\\n};\\n\\n\/**\\n * All parameters are pretty-printed and concatenated together, then written to the spec's output.\\n *\\n * Be careful not to leave calls to jasmine.log<\/code> in production code.\\n *\/\\njasmine.Spec.prototype.log = function() {\\n  return this.results_.log(arguments);\\n};\\n\\njasmine.Spec.prototype.runs = function (func) {\\n  var block = new jasmine.Block(this.env, func, this);\\n  this.addToQueue(block);\\n  return this;\\n};\\n\\njasmine.Spec.prototype.addToQueue = function (block) {\\n  if (this.queue.isRunning()) {\\n    this.queue.insertNext(block);\\n  } else {\\n    this.queue.add(block);\\n  }\\n};\\n\\n\/**\\n * @param {jasmine.ExpectationResult} result\\n *\/\\njasmine.Spec.prototype.addMatcherResult = function(result) {\\n  this.results_.addResult(result);\\n};\\n\\njasmine.Spec.prototype.expect = function(actual) {\\n  var positive = new (this.getMatchersClass_())(this.env, actual, this);\\n  positive.not = new (this.getMatchersClass_())(this.env, actual, this, true);\\n  return positive;\\n};\\n\\n\/**\\n * Waits a fixed time period before moving to the next block.\\n *\\n * @deprecated Use waitsFor() instead\\n * @param {Number} timeout milliseconds to wait\\n *\/\\njasmine.Spec.prototype.waits = function(timeout) {\\n  var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);\\n  this.addToQueue(waitsFunc);\\n  return this;\\n};\\n\\n\/**\\n * Waits for the latchFunction to return true before proceeding to the next block.\\n *\\n * @param {Function} latchFunction\\n * @param {String} optional_timeoutMessage\\n * @param {Number} optional_timeout\\n *\/\\njasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {\\n  var latchFunction_ = null;\\n  var optional_timeoutMessage_ = null;\\n  var optional_timeout_ = null;\\n\\n  for (var i = 0; i < arguments.length; i++) {\\n    var arg = arguments[i];\\n    switch (typeof arg) {\\n      case 'function':\\n        latchFunction_ = arg;\\n        break;\\n      case 'string':\\n        optional_timeoutMessage_ = arg;\\n        break;\\n      case 'number':\\n        optional_timeout_ = arg;\\n        break;\\n    }\\n  }\\n\\n  var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);\\n  this.addToQueue(waitsForFunc);\\n  return this;\\n};\\n\\njasmine.Spec.prototype.fail = function (e) {\\n  var expectationResult = new jasmine.ExpectationResult({\\n    passed: false,\\n    message: e ? jasmine.util.formatException(e) : 'Exception',\\n    trace: { stack: e.stack }\\n  });\\n  this.results_.addResult(expectationResult);\\n};\\n\\njasmine.Spec.prototype.getMatchersClass_ = function() {\\n  return this.matchersClass || this.env.matchersClass;\\n};\\n\\njasmine.Spec.prototype.addMatchers = function(matchersPrototype) {\\n  var parent = this.getMatchersClass_();\\n  var newMatchersClass = function() {\\n    parent.apply(this, arguments);\\n  };\\n  jasmine.util.inherit(newMatchersClass, parent);\\n  jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass);\\n  this.matchersClass = newMatchersClass;\\n};\\n\\njasmine.Spec.prototype.finishCallback = function() {\\n  this.env.reporter.reportSpecResults(this);\\n};\\n\\njasmine.Spec.prototype.finish = function(onComplete) {\\n  this.removeAllSpies();\\n  this.finishCallback();\\n  if (onComplete) {\\n    onComplete();\\n  }\\n};\\n\\njasmine.Spec.prototype.after = function(doAfter) {\\n  if (this.queue.isRunning()) {\\n    this.queue.add(new jasmine.Block(this.env, doAfter, this), true);\\n  } else {\\n    this.afterCallbacks.unshift(doAfter);\\n  }\\n};\\n\\njasmine.Spec.prototype.execute = function(onComplete) {\\n  var spec = this;\\n  if (!spec.env.specFilter(spec)) {\\n    spec.results_.skipped = true;\\n    spec.finish(onComplete);\\n    return;\\n  }\\n\\n  this.env.reporter.reportSpecStarting(this);\\n\\n  spec.env.currentSpec = spec;\\n\\n  spec.addBeforesAndAftersToQueue();\\n\\n  spec.queue.start(function () {\\n    spec.finish(onComplete);\\n  });\\n};\\n\\njasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {\\n  var runner = this.env.currentRunner();\\n  var i;\\n\\n  for (var suite = this.suite; suite; suite = suite.parentSuite) {\\n    for (i = 0; i < suite.before_.length; i++) {\\n      this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this));\\n    }\\n  }\\n  for (i = 0; i < runner.before_.length; i++) {\\n    this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this));\\n  }\\n  for (i = 0; i < this.afterCallbacks.length; i++) {\\n    this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this), true);\\n  }\\n  for (suite = this.suite; suite; suite = suite.parentSuite) {\\n    for (i = 0; i < suite.after_.length; i++) {\\n      this.queue.add(new jasmine.Block(this.env, suite.after_[i], this), true);\\n    }\\n  }\\n  for (i = 0; i < runner.after_.length; i++) {\\n    this.queue.add(new jasmine.Block(this.env, runner.after_[i], this), true);\\n  }\\n};\\n\\njasmine.Spec.prototype.explodes = function() {\\n  throw 'explodes function should not have been called';\\n};\\n\\njasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {\\n  if (obj == jasmine.undefined) {\\n    throw \\\"spyOn could not find an object to spy upon for \\\" + methodName + \\\"()\\\";\\n  }\\n\\n  if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) {\\n    throw methodName + '() method does not exist';\\n  }\\n\\n  if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {\\n    throw new Error(methodName + ' has already been spied upon');\\n  }\\n\\n  var spyObj = jasmine.createSpy(methodName);\\n\\n  this.spies_.push(spyObj);\\n  spyObj.baseObj = obj;\\n  spyObj.methodName = methodName;\\n  spyObj.originalValue = obj[methodName];\\n\\n  obj[methodName] = spyObj;\\n\\n  return spyObj;\\n};\\n\\njasmine.Spec.prototype.removeAllSpies = function() {\\n  for (var i = 0; i < this.spies_.length; i++) {\\n    var spy = this.spies_[i];\\n    spy.baseObj[spy.methodName] = spy.originalValue;\\n  }\\n  this.spies_ = [];\\n};\\n\\n\/**\\n * Internal representation of a Jasmine suite.\\n *\\n * @constructor\\n * @param {jasmine.Env} env\\n * @param {String} description\\n * @param {Function} specDefinitions\\n * @param {jasmine.Suite} parentSuite\\n *\/\\njasmine.Suite = function(env, description, specDefinitions, parentSuite) {\\n  var self = this;\\n  self.id = env.nextSuiteId ? env.nextSuiteId() : null;\\n  self.description = description;\\n  self.queue = new jasmine.Queue(env);\\n  self.parentSuite = parentSuite;\\n  self.env = env;\\n  self.before_ = [];\\n  self.after_ = [];\\n  self.children_ = [];\\n  self.suites_ = [];\\n  self.specs_ = [];\\n};\\n\\njasmine.Suite.prototype.getFullName = function() {\\n  var fullName = this.description;\\n  for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {\\n    fullName = parentSuite.description + ' ' + fullName;\\n  }\\n  return fullName;\\n};\\n\\njasmine.Suite.prototype.finish = function(onComplete) {\\n  this.env.reporter.reportSuiteResults(this);\\n  this.finished = true;\\n  if (typeof(onComplete) == 'function') {\\n    onComplete();\\n  }\\n};\\n\\njasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {\\n  beforeEachFunction.typeName = 'beforeEach';\\n  this.before_.unshift(beforeEachFunction);\\n};\\n\\njasmine.Suite.prototype.afterEach = function(afterEachFunction) {\\n  afterEachFunction.typeName = 'afterEach';\\n  this.after_.unshift(afterEachFunction);\\n};\\n\\njasmine.Suite.prototype.results = function() {\\n  return this.queue.results();\\n};\\n\\njasmine.Suite.prototype.add = function(suiteOrSpec) {\\n  this.children_.push(suiteOrSpec);\\n  if (suiteOrSpec instanceof jasmine.Suite) {\\n    this.suites_.push(suiteOrSpec);\\n    this.env.currentRunner().addSuite(suiteOrSpec);\\n  } else {\\n    this.specs_.push(suiteOrSpec);\\n  }\\n  this.queue.add(suiteOrSpec);\\n};\\n\\njasmine.Suite.prototype.specs = function() {\\n  return this.specs_;\\n};\\n\\njasmine.Suite.prototype.suites = function() {\\n  return this.suites_;\\n};\\n\\njasmine.Suite.prototype.children = function() {\\n  return this.children_;\\n};\\n\\njasmine.Suite.prototype.execute = function(onComplete) {\\n  var self = this;\\n  this.queue.start(function () {\\n    self.finish(onComplete);\\n  });\\n};\\njasmine.WaitsBlock = function(env, timeout, spec) {\\n  this.timeout = timeout;\\n  jasmine.Block.call(this, env, null, spec);\\n};\\n\\njasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);\\n\\njasmine.WaitsBlock.prototype.execute = function (onComplete) {\\n  if (jasmine.VERBOSE) {\\n    this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');\\n  }\\n  this.env.setTimeout(function () {\\n    onComplete();\\n  }, this.timeout);\\n};\\n\/**\\n * A block which waits for some condition to become true, with timeout.\\n *\\n * @constructor\\n * @extends jasmine.Block\\n * @param {jasmine.Env} env The Jasmine environment.\\n * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.\\n * @param {Function} latchFunction A function which returns true when the desired condition has been met.\\n * @param {String} message The message to display if the desired condition hasn't been met within the given time period.\\n * @param {jasmine.Spec} spec The Jasmine spec.\\n *\/\\njasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {\\n  this.timeout = timeout || env.defaultTimeoutInterval;\\n  this.latchFunction = latchFunction;\\n  this.message = message;\\n  this.totalTimeSpentWaitingForLatch = 0;\\n  jasmine.Block.call(this, env, null, spec);\\n};\\njasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);\\n\\njasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;\\n\\njasmine.WaitsForBlock.prototype.execute = function(onComplete) {\\n  if (jasmine.VERBOSE) {\\n    this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));\\n  }\\n  var latchFunctionResult;\\n  try {\\n    latchFunctionResult = this.latchFunction.apply(this.spec);\\n  } catch (e) {\\n    this.spec.fail(e);\\n    onComplete();\\n    return;\\n  }\\n\\n  if (latchFunctionResult) {\\n    onComplete();\\n  } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {\\n    var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');\\n    this.spec.fail({\\n      name: 'timeout',\\n      message: message\\n    });\\n\\n    this.abort = true;\\n    onComplete();\\n  } else {\\n    this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;\\n    var self = this;\\n    this.env.setTimeout(function() {\\n      self.execute(onComplete);\\n    }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);\\n  }\\n};\\n\\njasmine.version_= {\\n  \\\"major\\\": 1,\\n  \\\"minor\\\": 3,\\n  \\\"build\\\": 1,\\n  \\\"revision\\\": 1354556913\\n};\\n\",\n+\"all\":\"require(\\\".\/phantom\\\");\\nrequire(\\\".\/console\\\");\\n\\n\/\/ TODO Also bundle jasmine.css here.\\nvar jasmine = require(\\\".\/jasmine\\\");\\nrequire(\\\".\/jasmine-html\\\");\\nrequire(\\\".\/jasmine-support\\\");\\n\\nrequire(\\\".\/HtmlReporter\\\");\\nrequire(\\\".\/PrintReporter\\\");\\nrequire(\\\".\/ReporterView\\\");\\nrequire(\\\".\/SpecView\\\");\\nrequire(\\\".\/SuiteView\\\");\\n\\nvar env = jasmine.getEnv();\\nenv.addReporter(new jasmine.HtmlReporter);\\nenv.addReporter(new jasmine.PrintReporter);\\n\\nfunction exposeFrom(obj) {\\n  obj.spyOn = jasmine.spyOn;\\n  obj.it = jasmine.it;\\n  obj.xit = jasmine.xit;\\n  obj.expect = jasmine.expect;\\n  obj.runs = jasmine.runs;\\n  obj.waits = jasmine.waits;\\n  obj.waitsFor = jasmine.waitsFor;\\n  obj.beforeEach = jasmine.beforeEach;\\n  obj.afterEach = jasmine.afterEach;\\n  obj.describe = jasmine.describe;\\n  obj.xdescribe = jasmine.xdescribe;\\n  obj.jasmine = jasmine;\\n  return obj;\\n}\\njasmine.exposeFrom = exposeFrom;\\nvar global = Function(\\\"return this\\\")();\\nexposeFrom(global);\\n\\nmodule.exports = jasmine;\\n\",\n+\"phantom\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * This module provides a bridge from content-land to phantom-land via the\\n * window.callPhantom interface.\\n *\/\\n\\nvar console = require(\\\".\/console\\\");\\nvar global = Function(\\\"return this\\\")();\\n\\nif (global.callPhantom) {\\n    \/\/ Phantom's onConsoleMessage support is lacking (only one argument\\n    \/\/ supported, and it must be a string), so we use callPhantom to\\n    \/\/ forward console messages instead.\\n    console.addListener(function(method, args) {\\n        global.callPhantom({\\n            type: \\\"console\\\",\\n            method: method,\\n            args: args\\n        });\\n    });\\n\\n    exports.exit = function(code) {\\n        global.callPhantom({\\n            type: \\\"exit\\\",\\n            code: code\\n        });\\n    };\\n\\n} else {\\n    exports.exit = function() {};\\n}\\n\",\n+\"console\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * This module allows interception of console.* method calls, so that\\n * listeners other than the native console object can consume logged\\n * messages.\\n *\/\\n\\nvar global = Function(\\\"return this\\\")();\\nvar Ap = Array.prototype;\\nvar slice = Ap.slice;\\n\\nvar nativeConsole;\\nif (\\\"console\\\" in global) {\\n    var gc = global.console;\\n    try { delete global.console } catch (ignored) {}\\n    nativeConsole = global.console || gc;\\n    global.console = gc;\\n}\\n\\n\/\/ Provide a reliable console interface in all browsers.\\nglobal.console = exports;\\n\\nfunction makeLogger(method) {\\n    var logger = exports[method] = function() {\\n        var args = slice.call(arguments);\\n        listeners.forEach(function(listener) {\\n            listener(method, args, logger);\\n        });\\n    };\\n}\\n\\nmakeLogger(\\\"info\\\");\\nmakeLogger(\\\"log\\\");\\nmakeLogger(\\\"debug\\\");\\nmakeLogger(\\\"warn\\\");\\nmakeLogger(\\\"error\\\");\\nmakeLogger(\\\"dir\\\");\\nmakeLogger(\\\"dirxml\\\");\\nmakeLogger(\\\"trace\\\");\\nmakeLogger(\\\"assert\\\");\\nmakeLogger(\\\"count\\\");\\nmakeLogger(\\\"markTimeline\\\");\\nmakeLogger(\\\"profile\\\");\\nmakeLogger(\\\"profileEnd\\\");\\nmakeLogger(\\\"time\\\");\\nmakeLogger(\\\"timeEnd\\\");\\nmakeLogger(\\\"timeStamp\\\");\\nmakeLogger(\\\"group\\\");\\nmakeLogger(\\\"groupCollapsed\\\");\\nmakeLogger(\\\"groupEnd\\\");\\nmakeLogger(\\\"clear\\\");\\n\\nvar listeners = [];\\nfunction addListener(listener) {\\n    listeners.push(listener);\\n}\\nexports.addListener = addListener\\n\\nfunction clean(arg) {\\n    if (typeof arg === \\\"string\\\") {\\n        \/\/ Remove any xterm-color escape sequences.\\n        \/\/ TODO Display colors in console if possible.\\n        arg = arg.replace(\/\\\\033\\\\[\\\\d+m\/g, \\\"\\\");\\n    }\\n    return arg;\\n}\\n\\nif (nativeConsole) {\\n    \/\/ If present, the native console object becomes a listener just like\\n    \/\/ any other.\\n    addListener(function(method, args) {\\n        var method = nativeConsole[method];\\n        if (method) {\\n            method.apply(nativeConsole, args.map(clean));\\n        } else {\\n            \/\/ Ignore this call.\\n        }\\n    });\\n}\\n\",\n+\"jasmine-html\":\"var jasmine = require(\\\".\/jasmine\\\");\\n\\njasmine.HtmlReporterHelpers = {};\\n\\njasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {\\n  var el = document.createElement(type);\\n\\n  for (var i = 2; i < arguments.length; i++) {\\n    var child = arguments[i];\\n\\n    if (typeof child === 'string') {\\n      el.appendChild(document.createTextNode(child));\\n    } else {\\n      if (child) {\\n        el.appendChild(child);\\n      }\\n    }\\n  }\\n\\n  for (var attr in attrs) {\\n    if (attr == \\\"className\\\") {\\n      el[attr] = attrs[attr];\\n    } else {\\n      el.setAttribute(attr, attrs[attr]);\\n    }\\n  }\\n\\n  return el;\\n};\\n\\njasmine.HtmlReporterHelpers.getSpecStatus = function(child) {\\n  var results = child.results();\\n  var status = results.passed() ? 'passed' : 'failed';\\n  if (results.skipped) {\\n    status = 'skipped';\\n  }\\n\\n  return status;\\n};\\n\\njasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {\\n  var parentDiv = this.dom.summary;\\n  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';\\n  var parent = child[parentSuite];\\n\\n  if (parent) {\\n    if (typeof this.views.suites[parent.id] == 'undefined') {\\n      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);\\n    }\\n    parentDiv = this.views.suites[parent.id].element;\\n  }\\n\\n  parentDiv.appendChild(childElement);\\n};\\n\\n\\njasmine.HtmlReporterHelpers.addHelpers = function(ctor) {\\n  for(var fn in jasmine.HtmlReporterHelpers) {\\n    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];\\n  }\\n};\\n\\njasmine.HtmlReporter = function(_doc) {\\n  var self = this;\\n  var doc = _doc || window.document;\\n\\n  var reporterView;\\n\\n  var dom = {};\\n\\n  \/\/ Jasmine Reporter Public Interface\\n  self.logRunningSpecs = false;\\n\\n  self.reportRunnerStarting = function(runner) {\\n    var specs = runner.specs() || [];\\n\\n    if (specs.length == 0) {\\n      return;\\n    }\\n\\n    createReporterDom(runner.env.versionString());\\n    doc.body.appendChild(dom.reporter);\\n    setExceptionHandling();\\n\\n    reporterView = new jasmine.HtmlReporter.ReporterView(dom);\\n    reporterView.addSpecs(specs, self.specFilter);\\n  };\\n\\n  self.reportRunnerResults = function(runner) {\\n    reporterView && reporterView.complete();\\n  };\\n\\n  self.reportSuiteResults = function(suite) {\\n    reporterView.suiteComplete(suite);\\n  };\\n\\n  self.reportSpecStarting = function(spec) {\\n    if (self.logRunningSpecs) {\\n      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');\\n    }\\n  };\\n\\n  self.reportSpecResults = function(spec) {\\n    reporterView.specComplete(spec);\\n  };\\n\\n  self.log = function() {\\n    var console = jasmine.getGlobal().console;\\n    if (console && console.log) {\\n      if (console.log.apply) {\\n        console.log.apply(console, arguments);\\n      } else {\\n        console.log(arguments); \/\/ ie fix: console.log.apply doesn't exist on ie\\n      }\\n    }\\n  };\\n\\n  self.specFilter = function(spec) {\\n    if (!focusedSpecName()) {\\n      return true;\\n    }\\n\\n    return spec.getFullName().indexOf(focusedSpecName()) === 0;\\n  };\\n\\n  return self;\\n\\n  function focusedSpecName() {\\n    var specName;\\n\\n    (function memoizeFocusedSpec() {\\n      if (specName) {\\n        return;\\n      }\\n\\n      var paramMap = [];\\n      var params = jasmine.HtmlReporter.parameters(doc);\\n\\n      for (var i = 0; i < params.length; i++) {\\n        var p = params[i].split('=');\\n        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);\\n      }\\n\\n      specName = paramMap.spec;\\n    })();\\n\\n    return specName;\\n  }\\n\\n  function createReporterDom(version) {\\n    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },\\n      dom.banner = self.createDom('div', { className: 'banner' },\\n        self.createDom('span', { className: 'title' }, \\\"Jasmine \\\"),\\n        self.createDom('span', { className: 'version' }, version)),\\n\\n      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),\\n      dom.alert = self.createDom('div', {className: 'alert'},\\n        self.createDom('span', { className: 'exceptions' },\\n          self.createDom('label', { className: 'label', 'for': 'no_try_catch' }, 'No try\/catch'),\\n          self.createDom('input', { id: 'no_try_catch', type: 'checkbox' }))),\\n      dom.results = self.createDom('div', {className: 'results'},\\n        dom.summary = self.createDom('div', { className: 'summary' }),\\n        dom.details = self.createDom('div', { id: 'details' }))\\n    );\\n  }\\n\\n  function noTryCatch() {\\n    return window.location.search.match(\/catch=false\/);\\n  }\\n\\n  function searchWithCatch() {\\n    var params = jasmine.HtmlReporter.parameters(window.document);\\n    var removed = false;\\n    var i = 0;\\n\\n    while (!removed && i < params.length) {\\n      if (params[i].match(\/catch=\/)) {\\n        params.splice(i, 1);\\n        removed = true;\\n      }\\n      i++;\\n    }\\n    if (jasmine.CATCH_EXCEPTIONS) {\\n      params.push(\\\"catch=false\\\");\\n    }\\n\\n    return params.join(\\\"&\\\");\\n  }\\n\\n  function setExceptionHandling() {\\n    var chxCatch = document.getElementById('no_try_catch');\\n\\n    if (noTryCatch()) {\\n      chxCatch.setAttribute('checked', true);\\n      jasmine.CATCH_EXCEPTIONS = false;\\n    }\\n    chxCatch.onclick = function() {\\n      window.location.search = searchWithCatch();\\n    };\\n  }\\n};\\njasmine.HtmlReporter.parameters = function(doc) {\\n  var paramStr = doc.location.search.substring(1);\\n  var params = [];\\n\\n  if (paramStr.length > 0) {\\n    params = paramStr.split('&');\\n  }\\n  return params;\\n}\\njasmine.HtmlReporter.sectionLink = function(sectionName) {\\n  var link = '?';\\n  var params = [];\\n\\n  if (sectionName) {\\n    params.push('spec=' + encodeURIComponent(sectionName));\\n  }\\n  if (!jasmine.CATCH_EXCEPTIONS) {\\n    params.push(\\\"catch=false\\\");\\n  }\\n  if (params.length > 0) {\\n    link += params.join(\\\"&\\\");\\n  }\\n\\n  return link;\\n};\\njasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);\\njasmine.HtmlReporter.ReporterView = function(dom) {\\n  this.startedAt = new Date();\\n  this.runningSpecCount = 0;\\n  this.completeSpecCount = 0;\\n  this.passedCount = 0;\\n  this.failedCount = 0;\\n  this.skippedCount = 0;\\n\\n  this.createResultsMenu = function() {\\n    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},\\n      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: \\\"#\\\"}, '0 specs'),\\n      ' | ',\\n      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: \\\"#\\\"}, '0 failing'));\\n\\n    this.summaryMenuItem.onclick = function() {\\n      dom.reporter.className = dom.reporter.className.replace(\/ showDetails\/g, '');\\n    };\\n\\n    this.detailsMenuItem.onclick = function() {\\n      showDetails();\\n    };\\n  };\\n\\n  this.addSpecs = function(specs, specFilter) {\\n    this.totalSpecCount = specs.length;\\n\\n    this.views = {\\n      specs: {},\\n      suites: {}\\n    };\\n\\n    for (var i = 0; i < specs.length; i++) {\\n      var spec = specs[i];\\n      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);\\n      if (specFilter(spec)) {\\n        this.runningSpecCount++;\\n      }\\n    }\\n  };\\n\\n  this.specComplete = function(spec) {\\n    this.completeSpecCount++;\\n\\n    if (isUndefined(this.views.specs[spec.id])) {\\n      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);\\n    }\\n\\n    var specView = this.views.specs[spec.id];\\n\\n    switch (specView.status()) {\\n      case 'passed':\\n        this.passedCount++;\\n        break;\\n\\n      case 'failed':\\n        this.failedCount++;\\n        break;\\n\\n      case 'skipped':\\n        this.skippedCount++;\\n        break;\\n    }\\n\\n    specView.refresh();\\n    this.refresh();\\n  };\\n\\n  this.suiteComplete = function(suite) {\\n    var suiteView = this.views.suites[suite.id];\\n    if (isUndefined(suiteView)) {\\n      return;\\n    }\\n    suiteView.refresh();\\n  };\\n\\n  this.refresh = function() {\\n\\n    if (isUndefined(this.resultsMenu)) {\\n      this.createResultsMenu();\\n    }\\n\\n    \/\/ currently running UI\\n    if (isUndefined(this.runningAlert)) {\\n      this.runningAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: \\\"runningAlert bar\\\" });\\n      dom.alert.appendChild(this.runningAlert);\\n    }\\n    this.runningAlert.innerHTML = \\\"Running \\\" + this.completeSpecCount + \\\" of \\\" + specPluralizedFor(this.totalSpecCount);\\n\\n    \/\/ skipped specs UI\\n    if (isUndefined(this.skippedAlert)) {\\n      this.skippedAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: \\\"skippedAlert bar\\\" });\\n    }\\n\\n    this.skippedAlert.innerHTML = \\\"Skipping \\\" + this.skippedCount + \\\" of \\\" + specPluralizedFor(this.totalSpecCount) + \\\" - run all\\\";\\n\\n    if (this.skippedCount === 1 && isDefined(dom.alert)) {\\n      dom.alert.appendChild(this.skippedAlert);\\n    }\\n\\n    \/\/ passing specs UI\\n    if (isUndefined(this.passedAlert)) {\\n      this.passedAlert = this.createDom('span', { href: jasmine.HtmlReporter.sectionLink(), className: \\\"passingAlert bar\\\" });\\n    }\\n    this.passedAlert.innerHTML = \\\"Passing \\\" + specPluralizedFor(this.passedCount);\\n\\n    \/\/ failing specs UI\\n    if (isUndefined(this.failedAlert)) {\\n      this.failedAlert = this.createDom('span', {href: \\\"?\\\", className: \\\"failingAlert bar\\\"});\\n    }\\n    this.failedAlert.innerHTML = \\\"Failing \\\" + specPluralizedFor(this.failedCount);\\n\\n    if (this.failedCount === 1 && isDefined(dom.alert)) {\\n      dom.alert.appendChild(this.failedAlert);\\n      dom.alert.appendChild(this.resultsMenu);\\n    }\\n\\n    \/\/ summary info\\n    this.summaryMenuItem.innerHTML = \\\"\\\" + specPluralizedFor(this.runningSpecCount);\\n    this.detailsMenuItem.innerHTML = \\\"\\\" + this.failedCount + \\\" failing\\\";\\n  };\\n\\n  this.complete = function() {\\n    dom.alert.removeChild(this.runningAlert);\\n\\n    this.skippedAlert.innerHTML = \\\"Ran \\\" + this.runningSpecCount + \\\" of \\\" + specPluralizedFor(this.totalSpecCount) + \\\" - run all\\\";\\n\\n    if (this.failedCount === 0) {\\n      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, \\\"Passing \\\" + specPluralizedFor(this.passedCount)));\\n    } else {\\n      showDetails();\\n    }\\n\\n    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, \\\"finished in \\\" + ((new Date().getTime() - this.startedAt.getTime()) \/ 1000) + \\\"s\\\"));\\n  };\\n\\n  return this;\\n\\n  function showDetails() {\\n    if (dom.reporter.className.search(\/showDetails\/) === -1) {\\n      dom.reporter.className += \\\" showDetails\\\";\\n    }\\n  }\\n\\n  function isUndefined(obj) {\\n    return typeof obj === 'undefined';\\n  }\\n\\n  function isDefined(obj) {\\n    return !isUndefined(obj);\\n  }\\n\\n  function specPluralizedFor(count) {\\n    var str = count + \\\" spec\\\";\\n    if (count > 1) {\\n      str += \\\"s\\\"\\n    }\\n    return str;\\n  }\\n\\n};\\n\\njasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);\\n\\n\\njasmine.HtmlReporter.SpecView = function(spec, dom, views) {\\n  this.spec = spec;\\n  this.dom = dom;\\n  this.views = views;\\n\\n  this.symbol = this.createDom('li', { className: 'pending' });\\n  this.dom.symbolSummary.appendChild(this.symbol);\\n\\n  this.summary = this.createDom('div', { className: 'specSummary' },\\n    this.createDom('a', {\\n      className: 'description',\\n      href: jasmine.HtmlReporter.sectionLink(this.spec.getFullName()),\\n      title: this.spec.getFullName()\\n    }, this.spec.description)\\n  );\\n\\n  this.detail = this.createDom('div', { className: 'specDetail' },\\n      this.createDom('a', {\\n        className: 'description',\\n        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),\\n        title: this.spec.getFullName()\\n      }, this.spec.getFullName())\\n  );\\n};\\n\\njasmine.HtmlReporter.SpecView.prototype.status = function() {\\n  return this.getSpecStatus(this.spec);\\n};\\n\\njasmine.HtmlReporter.SpecView.prototype.refresh = function() {\\n  this.symbol.className = this.status();\\n\\n  switch (this.status()) {\\n    case 'skipped':\\n      break;\\n\\n    case 'passed':\\n      this.appendSummaryToSuiteDiv();\\n      break;\\n\\n    case 'failed':\\n      this.appendSummaryToSuiteDiv();\\n      this.appendFailureDetail();\\n      break;\\n  }\\n};\\n\\njasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {\\n  this.summary.className += ' ' + this.status();\\n  this.appendToSummary(this.spec, this.summary);\\n};\\n\\njasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {\\n  this.detail.className += ' ' + this.status();\\n\\n  var resultItems = this.spec.results().getItems();\\n  var messagesDiv = this.createDom('div', { className: 'messages' });\\n\\n  for (var i = 0; i < resultItems.length; i++) {\\n    var result = resultItems[i];\\n\\n    if (result.type == 'log') {\\n      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));\\n    } else if (result.type == 'expect' && result.passed && !result.passed()) {\\n      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));\\n\\n      if (result.trace.stack) {\\n        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));\\n      }\\n    }\\n  }\\n\\n  if (messagesDiv.childNodes.length > 0) {\\n    this.detail.appendChild(messagesDiv);\\n    this.dom.details.appendChild(this.detail);\\n  }\\n};\\n\\njasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {\\n  this.suite = suite;\\n  this.dom = dom;\\n  this.views = views;\\n\\n  this.element = this.createDom('div', { className: 'suite' },\\n    this.createDom('a', { className: 'description', href: jasmine.HtmlReporter.sectionLink(this.suite.getFullName()) }, this.suite.description)\\n  );\\n\\n  this.appendToSummary(this.suite, this.element);\\n};\\n\\njasmine.HtmlReporter.SuiteView.prototype.status = function() {\\n  return this.getSpecStatus(this.suite);\\n};\\n\\njasmine.HtmlReporter.SuiteView.prototype.refresh = function() {\\n  this.element.className += \\\" \\\" + this.status();\\n};\\n\\njasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);\\n\\n\/* @deprecated Use jasmine.HtmlReporter instead\\n *\/\\njasmine.TrivialReporter = function(doc) {\\n  this.document = doc || document;\\n  this.suiteDivs = {};\\n  this.logRunningSpecs = false;\\n};\\n\\njasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {\\n  var el = document.createElement(type);\\n\\n  for (var i = 2; i < arguments.length; i++) {\\n    var child = arguments[i];\\n\\n    if (typeof child === 'string') {\\n      el.appendChild(document.createTextNode(child));\\n    } else {\\n      if (child) { el.appendChild(child); }\\n    }\\n  }\\n\\n  for (var attr in attrs) {\\n    if (attr == \\\"className\\\") {\\n      el[attr] = attrs[attr];\\n    } else {\\n      el.setAttribute(attr, attrs[attr]);\\n    }\\n  }\\n\\n  return el;\\n};\\n\\njasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {\\n  var showPassed, showSkipped;\\n\\n  this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' },\\n      this.createDom('div', { className: 'banner' },\\n        this.createDom('div', { className: 'logo' },\\n            this.createDom('span', { className: 'title' }, \\\"Jasmine\\\"),\\n            this.createDom('span', { className: 'version' }, runner.env.versionString())),\\n        this.createDom('div', { className: 'options' },\\n            \\\"Show \\\",\\n            showPassed = this.createDom('input', { id: \\\"__jasmine_TrivialReporter_showPassed__\\\", type: 'checkbox' }),\\n            this.createDom('label', { \\\"for\\\": \\\"__jasmine_TrivialReporter_showPassed__\\\" }, \\\" passed \\\"),\\n            showSkipped = this.createDom('input', { id: \\\"__jasmine_TrivialReporter_showSkipped__\\\", type: 'checkbox' }),\\n            this.createDom('label', { \\\"for\\\": \\\"__jasmine_TrivialReporter_showSkipped__\\\" }, \\\" skipped\\\")\\n            )\\n          ),\\n\\n      this.runnerDiv = this.createDom('div', { className: 'runner running' },\\n          this.createDom('a', { className: 'run_spec', href: '?' }, \\\"run all\\\"),\\n          this.runnerMessageSpan = this.createDom('span', {}, \\\"Running...\\\"),\\n          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, \\\"\\\"))\\n      );\\n\\n  this.document.body.appendChild(this.outerDiv);\\n\\n  var suites = runner.suites();\\n  for (var i = 0; i < suites.length; i++) {\\n    var suite = suites[i];\\n    var suiteDiv = this.createDom('div', { className: 'suite' },\\n        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, \\\"run\\\"),\\n        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));\\n    this.suiteDivs[suite.id] = suiteDiv;\\n    var parentDiv = this.outerDiv;\\n    if (suite.parentSuite) {\\n      parentDiv = this.suiteDivs[suite.parentSuite.id];\\n    }\\n    parentDiv.appendChild(suiteDiv);\\n  }\\n\\n  this.startedAt = new Date();\\n\\n  var self = this;\\n  showPassed.onclick = function(evt) {\\n    if (showPassed.checked) {\\n      self.outerDiv.className += ' show-passed';\\n    } else {\\n      self.outerDiv.className = self.outerDiv.className.replace(\/ show-passed\/, '');\\n    }\\n  };\\n\\n  showSkipped.onclick = function(evt) {\\n    if (showSkipped.checked) {\\n      self.outerDiv.className += ' show-skipped';\\n    } else {\\n      self.outerDiv.className = self.outerDiv.className.replace(\/ show-skipped\/, '');\\n    }\\n  };\\n};\\n\\njasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {\\n  var results = runner.results();\\n  var className = (results.failedCount > 0) ? \\\"runner failed\\\" : \\\"runner passed\\\";\\n  this.runnerDiv.setAttribute(\\\"class\\\", className);\\n  \/\/do it twice for IE\\n  this.runnerDiv.setAttribute(\\\"className\\\", className);\\n  var specs = runner.specs();\\n  var specCount = 0;\\n  for (var i = 0; i < specs.length; i++) {\\n    if (this.specFilter(specs[i])) {\\n      specCount++;\\n    }\\n  }\\n  var message = \\\"\\\" + specCount + \\\" spec\\\" + (specCount == 1 ? \\\"\\\" : \\\"s\\\" ) + \\\", \\\" + results.failedCount + \\\" failure\\\" + ((results.failedCount == 1) ? \\\"\\\" : \\\"s\\\");\\n  message += \\\" in \\\" + ((new Date().getTime() - this.startedAt.getTime()) \/ 1000) + \\\"s\\\";\\n  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);\\n\\n  this.finishedAtSpan.appendChild(document.createTextNode(\\\"Finished at \\\" + new Date().toString()));\\n};\\n\\njasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {\\n  var results = suite.results();\\n  var status = results.passed() ? 'passed' : 'failed';\\n  if (results.totalCount === 0) { \/\/ todo: change this to check results.skipped\\n    status = 'skipped';\\n  }\\n  this.suiteDivs[suite.id].className += \\\" \\\" + status;\\n};\\n\\njasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {\\n  if (this.logRunningSpecs) {\\n    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');\\n  }\\n};\\n\\njasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {\\n  var results = spec.results();\\n  var status = results.passed() ? 'passed' : 'failed';\\n  if (results.skipped) {\\n    status = 'skipped';\\n  }\\n  var specDiv = this.createDom('div', { className: 'spec '  + status },\\n      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, \\\"run\\\"),\\n      this.createDom('a', {\\n        className: 'description',\\n        href: '?spec=' + encodeURIComponent(spec.getFullName()),\\n        title: spec.getFullName()\\n      }, spec.description));\\n\\n\\n  var resultItems = results.getItems();\\n  var messagesDiv = this.createDom('div', { className: 'messages' });\\n  for (var i = 0; i < resultItems.length; i++) {\\n    var result = resultItems[i];\\n\\n    if (result.type == 'log') {\\n      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));\\n    } else if (result.type == 'expect' && result.passed && !result.passed()) {\\n      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));\\n\\n      if (result.trace.stack) {\\n        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));\\n      }\\n    }\\n  }\\n\\n  if (messagesDiv.childNodes.length > 0) {\\n    specDiv.appendChild(messagesDiv);\\n  }\\n\\n  this.suiteDivs[spec.suite.id].appendChild(specDiv);\\n};\\n\\njasmine.TrivialReporter.prototype.log = function() {\\n  var console = jasmine.getGlobal().console;\\n  if (console && console.log) {\\n    if (console.log.apply) {\\n      console.log.apply(console, arguments);\\n    } else {\\n      console.log(arguments); \/\/ ie fix: console.log.apply doesn't exist on ie\\n    }\\n  }\\n};\\n\\njasmine.TrivialReporter.prototype.getLocation = function() {\\n  return this.document.location;\\n};\\n\\njasmine.TrivialReporter.prototype.specFilter = function(spec) {\\n  var paramMap = {};\\n  var params = this.getLocation().search.substring(1).split('&');\\n  for (var i = 0; i < params.length; i++) {\\n    var p = params[i].split('=');\\n    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);\\n  }\\n\\n  if (!paramMap.spec) {\\n    return true;\\n  }\\n  return spec.getFullName().indexOf(paramMap.spec) === 0;\\n};\\n\",\n+\"jasmine-support\":\"var jasmine = require(\\\".\/jasmine\\\");\\nvar spec = false; \/\/ TODO\\n\\n\/\/ Add some matcher for mock functions\\njasmine.getEnv().beforeEach(function() {\\n  this.addMatchers({\\n    toBeCalled: function() {\\n      if (this.actual.mock === undefined) {\\n        throw Error('toBeCalled() should be used on a mock function');\\n      }\\n      return this.actual.mock.calls.length !== 0;\\n    },\\n\\n    lastCalledWith: function() {\\n      if (this.actual.mock === undefined) {\\n        throw Error('toBeCalled() should be used on a mock function');\\n      }\\n      var calls = this.actual.mock.calls;\\n      var args = Array.prototype.slice.call(arguments);\\n      return this.env.equals_(calls[calls.length - 1], args);\\n    },\\n\\n    toBeCalledWith: function() {\\n      if (this.actual.mock === undefined) {\\n        throw Error('toBeCalled() should be used on a mock function');\\n      }\\n      var args = Array.prototype.slice.call(arguments);\\n      return this.actual.mock.calls.some(function(call) {\\n        return this.env.equals_(call, args);\\n      }.bind(this));\\n    }\\n  });\\n});\\n\\nvar _it = jasmine.Env.prototype.it;\\nvar _xit = jasmine.Env.prototype.xit;\\njasmine.Env.prototype.it = function(desc, func) {\\n  \/\/ If spec is provided, only run matching specs\\n  if (!spec || desc.match(new RegExp(spec, 'i'))) {\\n    return _it.call(this, desc, func);\\n  } else {\\n    return this.xit(desc, func);\\n  }\\n};\\njasmine.Env.prototype.xit = function(desc, func) {\\n  if (typeof func == 'function') {\\n    var matches = func.toString().match(\/.*\\\\W?expect\\\\(\/g);\\n    if (matches) {\\n      this.reporter.subReporters_[0].skipCount += matches.length;\\n      this.reporter.subReporters_[0].totalCount += matches.length;\\n    }\\n  }\\n  return _xit.call(this, desc, func);\\n}\\n\\n\/\/ Mainline Jasmine sets __Jasmine_been_here_before__ on each object to detect\\n\/\/ cycles, but that doesn't work on frozen objects so we use a WeakMap instead.\\n\/\/ We can only do this if if WeakMap is available, but if WeakMap is\\n\/\/ unavailable, then objects probably can't be frozen anyway.\\n\\nif (typeof WeakMap !== \\\"undefined\\\") {\\n  var _comparedObjects = new WeakMap;\\n\\n  jasmine.Env.prototype.compareObjects_ =\\n  function(a, b, mismatchKeys, mismatchValues) {\\n    if (_comparedObjects.get(a) === b && _comparedObjects.get(b) === a) {\\n      return true;\\n    }\\n    var areArrays = jasmine.isArray_(a) && jasmine.isArray_(b);\\n\\n    _comparedObjects.set(a, b);\\n    _comparedObjects.set(b, a);\\n\\n    var hasKey = function(obj, keyName) {\\n      return obj != null && obj[keyName] !== jasmine.undefined;\\n    };\\n\\n    for (var property in b) {\\n      if (areArrays && typeof b[property] == 'function') {\\n        continue;\\n      }\\n      if (!hasKey(a, property) && hasKey(b, property)) {\\n        mismatchKeys.push(\\n          \\\"expected has key '\\\" + property + \\\"', but missing from actual.\\\"\\n        );\\n      }\\n    }\\n    for (property in a) {\\n      if (areArrays && typeof a[property] == 'function') {\\n        continue;\\n      }\\n      if (!hasKey(b, property) && hasKey(a, property)) {\\n        mismatchKeys.push(\\n          \\\"expected missing key '\\\" + property + \\\"', but present in actual.\\\"\\n        );\\n      }\\n    }\\n    for (property in b) {\\n      \/\/ The only different implementation from the original jasmine\\n      if (areArrays &&\\n          (typeof a[property] == 'function' ||\\n           typeof b[property] == 'function')) {\\n        continue;\\n      }\\n      if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues))\\n      {\\n        mismatchValues.push(\\n          \\\"'\\\" + property + \\\"' was '\\\" + (b[property] ?\\n            jasmine.util.htmlEscape(b[property].toString()) :\\n            b[property]) +\\n          \\\"' in expected, but was '\\\" + (a[property] ?\\n            jasmine.util.htmlEscape(a[property].toString()) :\\n            a[property]) + \\\"' in actual.\\\"\\n        );\\n      }\\n    }\\n\\n    if (areArrays &&\\n        a.length != b.length) {\\n      mismatchValues.push(\\\"arrays were not the same length\\\");\\n    }\\n\\n    _comparedObjects.delete(a);\\n    _comparedObjects.delete(b);\\n    return (mismatchKeys.length == 0 && mismatchValues.length == 0);\\n  };\\n}\\n\",\n+\"HtmlReporter\":\"var jasmine = require(\\\".\/jasmine\\\");\\n\\nexports.HtmlReporter =\\njasmine.HtmlReporter = function(_doc) {\\n  var self = this;\\n  var doc = _doc || window.document;\\n\\n  var reporterView;\\n\\n  var dom = {};\\n\\n  \/\/ Jasmine Reporter Public Interface\\n  self.logRunningSpecs = false;\\n\\n  self.reportRunnerStarting = function(runner) {\\n    var specs = runner.specs() || [];\\n\\n    if (specs.length == 0) {\\n      return;\\n    }\\n\\n    createReporterDom(runner.env.versionString());\\n    doc.body.appendChild(dom.reporter);\\n    setExceptionHandling();\\n\\n    reporterView = new jasmine.HtmlReporter.ReporterView(dom);\\n    reporterView.addSpecs(specs, self.specFilter);\\n  };\\n\\n  self.reportRunnerResults = function(runner) {\\n    reporterView && reporterView.complete();\\n  };\\n\\n  self.reportSuiteResults = function(suite) {\\n    reporterView.suiteComplete(suite);\\n  };\\n\\n  self.reportSpecStarting = function(spec) {\\n    if (self.logRunningSpecs) {\\n      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');\\n    }\\n  };\\n\\n  self.reportSpecResults = function(spec) {\\n    reporterView.specComplete(spec);\\n  };\\n\\n  self.log = function() {\\n    var console = jasmine.getGlobal().console;\\n    if (console && console.log) {\\n      if (console.log.apply) {\\n        console.log.apply(console, arguments);\\n      } else {\\n        console.log(arguments); \/\/ ie fix: console.log.apply doesn't exist on ie\\n      }\\n    }\\n  };\\n\\n  self.specFilter = function(spec) {\\n    if (!focusedSpecName()) {\\n      return true;\\n    }\\n\\n    return spec.getFullName().indexOf(focusedSpecName()) === 0;\\n  };\\n\\n  return self;\\n\\n  function focusedSpecName() {\\n    var specName;\\n\\n    (function memoizeFocusedSpec() {\\n      if (specName) {\\n        return;\\n      }\\n\\n      var paramMap = [];\\n      var params = jasmine.HtmlReporter.parameters(doc);\\n\\n      for (var i = 0; i < params.length; i++) {\\n        var p = params[i].split('=');\\n        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);\\n      }\\n\\n      specName = paramMap.spec;\\n    })();\\n\\n    return specName;\\n  }\\n\\n  function createReporterDom(version) {\\n    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },\\n      dom.banner = self.createDom('div', { className: 'banner' },\\n        self.createDom('span', { className: 'title' }, \\\"Jasmine \\\"),\\n        self.createDom('span', { className: 'version' }, version)),\\n\\n      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),\\n      dom.alert = self.createDom('div', {className: 'alert'},\\n        self.createDom('span', { className: 'exceptions' },\\n          self.createDom('label', { className: 'label', 'for': 'no_try_catch' }, 'No try\/catch'),\\n          self.createDom('input', { id: 'no_try_catch', type: 'checkbox' }))),\\n      dom.results = self.createDom('div', {className: 'results'},\\n        dom.summary = self.createDom('div', { className: 'summary' }),\\n        dom.details = self.createDom('div', { id: 'details' }))\\n    );\\n  }\\n\\n  function noTryCatch() {\\n    return window.location.search.match(\/catch=false\/);\\n  }\\n\\n  function searchWithCatch() {\\n    var params = jasmine.HtmlReporter.parameters(window.document);\\n    var removed = false;\\n    var i = 0;\\n\\n    while (!removed && i < params.length) {\\n      if (params[i].match(\/catch=\/)) {\\n        params.splice(i, 1);\\n        removed = true;\\n      }\\n      i++;\\n    }\\n    if (jasmine.CATCH_EXCEPTIONS) {\\n      params.push(\\\"catch=false\\\");\\n    }\\n\\n    return params.join(\\\"&\\\");\\n  }\\n\\n  function setExceptionHandling() {\\n    var chxCatch = document.getElementById('no_try_catch');\\n\\n    if (noTryCatch()) {\\n      chxCatch.setAttribute('checked', true);\\n      jasmine.CATCH_EXCEPTIONS = false;\\n    }\\n    chxCatch.onclick = function() {\\n      window.location.search = searchWithCatch();\\n    };\\n  }\\n};\\njasmine.HtmlReporter.parameters = function(doc) {\\n  var paramStr = doc.location.search.substring(1);\\n  var params = [];\\n\\n  if (paramStr.length > 0) {\\n    params = paramStr.split('&');\\n  }\\n  return params;\\n}\\njasmine.HtmlReporter.sectionLink = function(sectionName) {\\n  var link = '?';\\n  var params = [];\\n\\n  if (sectionName) {\\n    params.push('spec=' + encodeURIComponent(sectionName));\\n  }\\n  if (!jasmine.CATCH_EXCEPTIONS) {\\n    params.push(\\\"catch=false\\\");\\n  }\\n  if (params.length > 0) {\\n    link += params.join(\\\"&\\\");\\n  }\\n\\n  return link;\\n};\\njasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);\\n\",\n+\"PrintReporter\":\"var jasmine = require(\\\".\/jasmine\\\");\\nvar diff = require('.\/diff');\\n\\nvar red = '\\\\u001b[1;41m';\\nvar reset = '\\\\u001b[0m';\\n\\nfunction highlightDifferences(a, b) {\\n  var changes = diff.diffChars(a, b);\\n\\n  var ret = {a: '', b: ''};\\n  var change;\\n  for (var i = 0, il = changes.length; i < il; i++) {\\n    change = changes[i];\\n    if (change.added) {\\n      ret.b += red + change.value + reset;\\n    } else if (change.removed) {\\n      ret.a += red + change.value + reset;\\n    } else {\\n      ret.a += change.value;\\n      ret.b += change.value;\\n    }\\n  }\\n  return ret;\\n}\\n\\nfunction PrintReporter(name, root_directory) {\\n  this.skipCount = 0;\\n  this.failCount = 0;\\n  this.expectCount = 0;\\n  this.specCount = 0;\\n  this.name = name;\\n  this.rootDirectory = root_directory;\\n}\\nexports.PrintReporter =\\njasmine.PrintReporter = PrintReporter;\\n\\nPrintReporter.prototype = new jasmine.Reporter();\\n\/\/ Set verbose=true on the test instance to enable additional logging\\nPrintReporter.prototype.verbose = false;\\nPrintReporter.prototype._didSpecName = false;\\n\\nPrintReporter.prototype.reportSpecStarting = function(spec) {\\n  this._didSpecName = false;\\n  this._spec = spec;\\n};\\n\\nPrintReporter.prototype.reportRunnerResults = function(runner) {\\n  \/\/ Don't print out the spec name at the end\\n  this._didSpecName = true;\\n\\n  this.log([\\n    this.specCount + \\\" spec\\\",\\n    this.expectCount + \\\" expect\\\",\\n    this.skipCount + \\\" skip\\\",\\n    this.failCount + \\\" fail\\\"\\n  ].join(\\\"  \\\"));\\n\\n  require(\\\".\/phantom\\\").exit(this.failCount);\\n};\\n\\n\\nPrintReporter.prototype.reportSuiteResults = function(suite) {\\n  var results = suite.results();\\n  if (this.verbose) {\\n    this.log('Suite \\\"' + suite.description + '\\\": ' +\\n      results.passedCount + '\/' + results.totalCount + ' passed.');\\n  }\\n\\n  \/\/ If suite is nested, only count the root suite\\n  if (!suite.parentSuite) {\\n    this.failCount += results.totalCount - results.passedCount;\\n    this.expectCount += results.totalCount;\\n  }\\n};\\n\\nPrintReporter.prototype.reportSpecResults = function(spec) {\\n  if (this.verbose) {\\n    this.log('it... ' +\\n      spec.description + ': ' + (spec.results().passed() ? 'pass' : 'fail'));\\n  }\\n\\n  var self = this;\\n  var results = spec.results();\\n\\n  this.specCount += 1;\\n\\n  if (results.skipped)\\n    this.skipCount += 1;\\n\\n  results.getItems().forEach(function(result) {\\n    if (result.type == 'log') {\\n      self.log(result.toString());\\n    } else if (result.type == 'expect' && result.passed && !result.passed()) {\\n      var ppActual = jasmine.pp(result.actual);\\n      var ppExpected = jasmine.pp(result.expected);\\n\\n      var colorDiff = highlightDifferences(ppActual, ppExpected);\\n\\n      var message = result.message;\\n      message = message.replace(ppActual, colorDiff.a);\\n      message = message.replace(ppExpected, colorDiff.b);\\n\\n      self.log(message);\\n      if (result.trace.stack) {\\n        self.log();\\n        result.trace.stack.split('\\\\n').forEach(function(stackFrame) {\\n          if (stackFrame.indexOf('\/jasmine\/lib\/jasmine-core') > -1) {\\n            return;\\n          }\\n          if (this.rootDirectory) {\\n            stackFrame = stackFrame.replace(this.rootDirectory + '\/', '');\\n          }\\n          self.log('  ' + stackFrame);\\n        }.bind(this));\\n      }\\n    }\\n  });\\n};\\n\\nPrintReporter.prototype.log = function(str) {\\n  if (!this._didSpecName) {\\n    console.log('');\\n    console.log(\\n      this._spec.suite.description + ': it ' + this._spec.description);\\n    this._didSpecName = true;\\n  }\\n  console.log(str || '');\\n};\\n\",\n+\"ReporterView\":\"var jasmine = require(\\\".\/jasmine\\\");\\n\\njasmine.HtmlReporter.ReporterView = function(dom) {\\n  this.startedAt = new Date();\\n  this.runningSpecCount = 0;\\n  this.completeSpecCount = 0;\\n  this.passedCount = 0;\\n  this.failedCount = 0;\\n  this.skippedCount = 0;\\n\\n  this.createResultsMenu = function() {\\n    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},\\n      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: \\\"#\\\"}, '0 specs'),\\n      ' | ',\\n      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: \\\"#\\\"}, '0 failing'));\\n\\n    this.summaryMenuItem.onclick = function() {\\n      dom.reporter.className = dom.reporter.className.replace(\/ showDetails\/g, '');\\n    };\\n\\n    this.detailsMenuItem.onclick = function() {\\n      showDetails();\\n    };\\n  };\\n\\n  this.addSpecs = function(specs, specFilter) {\\n    this.totalSpecCount = specs.length;\\n\\n    this.views = {\\n      specs: {},\\n      suites: {}\\n    };\\n\\n    for (var i = 0; i < specs.length; i++) {\\n      var spec = specs[i];\\n      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);\\n      if (specFilter(spec)) {\\n        this.runningSpecCount++;\\n      }\\n    }\\n  };\\n\\n  this.specComplete = function(spec) {\\n    this.completeSpecCount++;\\n\\n    if (isUndefined(this.views.specs[spec.id])) {\\n      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);\\n    }\\n\\n    var specView = this.views.specs[spec.id];\\n\\n    switch (specView.status()) {\\n      case 'passed':\\n        this.passedCount++;\\n        break;\\n\\n      case 'failed':\\n        this.failedCount++;\\n        break;\\n\\n      case 'skipped':\\n        this.skippedCount++;\\n        break;\\n    }\\n\\n    specView.refresh();\\n    this.refresh();\\n  };\\n\\n  this.suiteComplete = function(suite) {\\n    var suiteView = this.views.suites[suite.id];\\n    if (isUndefined(suiteView)) {\\n      return;\\n    }\\n    suiteView.refresh();\\n  };\\n\\n  this.refresh = function() {\\n\\n    if (isUndefined(this.resultsMenu)) {\\n      this.createResultsMenu();\\n    }\\n\\n    \/\/ currently running UI\\n    if (isUndefined(this.runningAlert)) {\\n      this.runningAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: \\\"runningAlert bar\\\" });\\n      dom.alert.appendChild(this.runningAlert);\\n    }\\n    this.runningAlert.innerHTML = \\\"Running \\\" + this.completeSpecCount + \\\" of \\\" + specPluralizedFor(this.totalSpecCount);\\n\\n    \/\/ skipped specs UI\\n    if (isUndefined(this.skippedAlert)) {\\n      this.skippedAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: \\\"skippedAlert bar\\\" });\\n    }\\n\\n    this.skippedAlert.innerHTML = \\\"Skipping \\\" + this.skippedCount + \\\" of \\\" + specPluralizedFor(this.totalSpecCount) + \\\" - run all\\\";\\n\\n    if (this.skippedCount === 1 && isDefined(dom.alert)) {\\n      dom.alert.appendChild(this.skippedAlert);\\n    }\\n\\n    \/\/ passing specs UI\\n    if (isUndefined(this.passedAlert)) {\\n      this.passedAlert = this.createDom('span', { href: jasmine.HtmlReporter.sectionLink(), className: \\\"passingAlert bar\\\" });\\n    }\\n    this.passedAlert.innerHTML = \\\"Passing \\\" + specPluralizedFor(this.passedCount);\\n\\n    \/\/ failing specs UI\\n    if (isUndefined(this.failedAlert)) {\\n      this.failedAlert = this.createDom('span', {href: \\\"?\\\", className: \\\"failingAlert bar\\\"});\\n    }\\n    this.failedAlert.innerHTML = \\\"Failing \\\" + specPluralizedFor(this.failedCount);\\n\\n    if (this.failedCount === 1 && isDefined(dom.alert)) {\\n      dom.alert.appendChild(this.failedAlert);\\n      dom.alert.appendChild(this.resultsMenu);\\n    }\\n\\n    \/\/ summary info\\n    this.summaryMenuItem.innerHTML = \\\"\\\" + specPluralizedFor(this.runningSpecCount);\\n    this.detailsMenuItem.innerHTML = \\\"\\\" + this.failedCount + \\\" failing\\\";\\n  };\\n\\n  this.complete = function() {\\n    dom.alert.removeChild(this.runningAlert);\\n\\n    this.skippedAlert.innerHTML = \\\"Ran \\\" + this.runningSpecCount + \\\" of \\\" + specPluralizedFor(this.totalSpecCount) + \\\" - run all\\\";\\n\\n    if (this.failedCount === 0) {\\n      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, \\\"Passing \\\" + specPluralizedFor(this.passedCount)));\\n    } else {\\n      showDetails();\\n    }\\n\\n    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, \\\"finished in \\\" + ((new Date().getTime() - this.startedAt.getTime()) \/ 1000) + \\\"s\\\"));\\n  };\\n\\n  return this;\\n\\n  function showDetails() {\\n    if (dom.reporter.className.search(\/showDetails\/) === -1) {\\n      dom.reporter.className += \\\" showDetails\\\";\\n    }\\n  }\\n\\n  function isUndefined(obj) {\\n    return typeof obj === 'undefined';\\n  }\\n\\n  function isDefined(obj) {\\n    return !isUndefined(obj);\\n  }\\n\\n  function specPluralizedFor(count) {\\n    var str = count + \\\" spec\\\";\\n    if (count > 1) {\\n      str += \\\"s\\\"\\n    }\\n    return str;\\n  }\\n\\n};\\n\\njasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);\\n\\n\\n\",\n+\"SpecView\":\"var jasmine = require(\\\".\/jasmine\\\");\\n\\njasmine.HtmlReporter.SpecView = function(spec, dom, views) {\\n  this.spec = spec;\\n  this.dom = dom;\\n  this.views = views;\\n\\n  this.symbol = this.createDom('li', { className: 'pending' });\\n  this.dom.symbolSummary.appendChild(this.symbol);\\n\\n  this.summary = this.createDom('div', { className: 'specSummary' },\\n    this.createDom('a', {\\n      className: 'description',\\n      href: jasmine.HtmlReporter.sectionLink(this.spec.getFullName()),\\n      title: this.spec.getFullName()\\n    }, this.spec.description)\\n  );\\n\\n  this.detail = this.createDom('div', { className: 'specDetail' },\\n      this.createDom('a', {\\n        className: 'description',\\n        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),\\n        title: this.spec.getFullName()\\n      }, this.spec.getFullName())\\n  );\\n};\\n\\njasmine.HtmlReporter.SpecView.prototype.status = function() {\\n  return this.getSpecStatus(this.spec);\\n};\\n\\njasmine.HtmlReporter.SpecView.prototype.refresh = function() {\\n  this.symbol.className = this.status();\\n\\n  switch (this.status()) {\\n    case 'skipped':\\n      break;\\n\\n    case 'passed':\\n      this.appendSummaryToSuiteDiv();\\n      break;\\n\\n    case 'failed':\\n      this.appendSummaryToSuiteDiv();\\n      this.appendFailureDetail();\\n      break;\\n  }\\n};\\n\\njasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {\\n  this.summary.className += ' ' + this.status();\\n  this.appendToSummary(this.spec, this.summary);\\n};\\n\\njasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {\\n  this.detail.className += ' ' + this.status();\\n\\n  var resultItems = this.spec.results().getItems();\\n  var messagesDiv = this.createDom('div', { className: 'messages' });\\n\\n  for (var i = 0; i < resultItems.length; i++) {\\n    var result = resultItems[i];\\n\\n    if (result.type == 'log') {\\n      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));\\n    } else if (result.type == 'expect' && result.passed && !result.passed()) {\\n      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));\\n\\n      if (result.trace.stack) {\\n        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));\\n      }\\n    }\\n  }\\n\\n  if (messagesDiv.childNodes.length > 0) {\\n    this.detail.appendChild(messagesDiv);\\n    this.dom.details.appendChild(this.detail);\\n  }\\n};\\n\\njasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);\",\n+\"SuiteView\":\"var jasmine = require(\\\".\/jasmine\\\");\\n\\njasmine.HtmlReporter.SuiteView = function(suite, dom, views) {\\n  this.suite = suite;\\n  this.dom = dom;\\n  this.views = views;\\n\\n  this.element = this.createDom('div', { className: 'suite' },\\n    this.createDom('a', { className: 'description', href: jasmine.HtmlReporter.sectionLink(this.suite.getFullName()) }, this.suite.description)\\n  );\\n\\n  this.appendToSummary(this.suite, this.element);\\n};\\n\\njasmine.HtmlReporter.SuiteView.prototype.status = function() {\\n  return this.getSpecStatus(this.suite);\\n};\\n\\njasmine.HtmlReporter.SuiteView.prototype.refresh = function() {\\n  this.element.className += \\\" \\\" + this.status();\\n};\\n\\njasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);\\n\\n\",\n+\"diff\":\"\/* See LICENSE file for terms of use *\/\\n\\n\/*\\n * Text diff implementation.\\n * \\n * This library supports the following APIS:\\n * JsDiff.diffChars: Character by character diff\\n * JsDiff.diffWords: Word (as defined by \\\\b regex) diff which ignores whitespace\\n * JsDiff.diffLines: Line based diff\\n * \\n * JsDiff.diffCss: Diff targeted at CSS content\\n * \\n * These methods are based on the implementation proposed in\\n * \\\"An O(ND) Difference Algorithm and its Variations\\\" (Myers, 1986).\\n * http:\/\/citeseerx.ist.psu.edu\/viewdoc\/summary?doi=10.1.1.4.6927\\n *\/\\nvar JsDiff = (function() {\\n  function clonePath(path) {\\n    return { newPos: path.newPos, components: path.components.slice(0) };\\n  }\\n  function removeEmpty(array) {\\n    var ret = [];\\n    for (var i = 0; i < array.length; i++) {\\n      if (array[i]) {\\n        ret.push(array[i]);\\n      }\\n    }\\n    return ret;\\n  }\\n  function escapeHTML(s) {\\n    var n = s;\\n    n = n.replace(\/&\/g, \\\"&\\\");\\n    n = n.replace(\/<\/g, \\\"<\\\");\\n    n = n.replace(\/>\/g, \\\">\\\");\\n    n = n.replace(\/\\\"\/g, \\\""\\\");\\n\\n    return n;\\n  }\\n\\n  var fbDiff = function(ignoreWhitespace) {\\n    this.ignoreWhitespace = ignoreWhitespace;\\n  };\\n  fbDiff.prototype = {\\n      diff: function(oldString, newString) {\\n        \/\/ Handle the identity case (this is due to unrolling editLength == 0\\n        if (newString == oldString) {\\n          return [{ value: newString }];\\n        }\\n        if (!newString) {\\n          return [{ value: oldString, removed: true }];\\n        }\\n        if (!oldString) {\\n          return [{ value: newString, added: true }];\\n        }\\n\\n        newString = this.tokenize(newString);\\n        oldString = this.tokenize(oldString);\\n\\n        var newLen = newString.length, oldLen = oldString.length;\\n        var maxEditLength = newLen + oldLen;\\n        var bestPath = [{ newPos: -1, components: [] }];\\n\\n        \/\/ Seed editLength = 0\\n        var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);\\n        if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) {\\n          return bestPath[0].components;\\n        }\\n\\n        for (var editLength = 1; editLength <= maxEditLength; editLength++) {\\n          for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) {\\n            var basePath;\\n            var addPath = bestPath[diagonalPath-1],\\n                removePath = bestPath[diagonalPath+1];\\n            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;\\n            if (addPath) {\\n              \/\/ No one else is going to attempt to use this value, clear it\\n              bestPath[diagonalPath-1] = undefined;\\n            }\\n\\n            var canAdd = addPath && addPath.newPos+1 < newLen;\\n            var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;\\n            if (!canAdd && !canRemove) {\\n              bestPath[diagonalPath] = undefined;\\n              continue;\\n            }\\n\\n            \/\/ Select the diagonal that we want to branch from. We select the prior\\n            \/\/ path whose position in the new string is the farthest from the origin\\n            \/\/ and does not pass the bounds of the diff graph\\n            if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {\\n              basePath = clonePath(removePath);\\n              this.pushComponent(basePath.components, oldString[oldPos], undefined, true);\\n            } else {\\n              basePath = clonePath(addPath);\\n              basePath.newPos++;\\n              this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined);\\n            }\\n\\n            var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath);\\n\\n            if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) {\\n              return basePath.components;\\n            } else {\\n              bestPath[diagonalPath] = basePath;\\n            }\\n          }\\n        }\\n      },\\n\\n      pushComponent: function(components, value, added, removed) {\\n        var last = components[components.length-1];\\n        if (last && last.added === added && last.removed === removed) {\\n          \/\/ We need to clone here as the component clone operation is just\\n          \/\/ as shallow array clone\\n          components[components.length-1] =\\n            {value: this.join(last.value, value), added: added, removed: removed };\\n        } else {\\n          components.push({value: value, added: added, removed: removed });\\n        }\\n      },\\n      extractCommon: function(basePath, newString, oldString, diagonalPath) {\\n        var newLen = newString.length,\\n            oldLen = oldString.length,\\n            newPos = basePath.newPos,\\n            oldPos = newPos - diagonalPath;\\n        while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {\\n          newPos++;\\n          oldPos++;\\n\\n          this.pushComponent(basePath.components, newString[newPos], undefined, undefined);\\n        }\\n        basePath.newPos = newPos;\\n        return oldPos;\\n      },\\n\\n      equals: function(left, right) {\\n        var reWhitespace = \/\\\\S\/;\\n        if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) {\\n          return true;\\n        } else {\\n          return left == right;\\n        }\\n      },\\n      join: function(left, right) {\\n        return left + right;\\n      },\\n      tokenize: function(value) {\\n        return value;\\n      }\\n  };\\n\\n  var CharDiff = new fbDiff();\\n\\n  var WordDiff = new fbDiff(true);\\n  WordDiff.tokenize = function(value) {\\n    return removeEmpty(value.split(\/(\\\\s+|\\\\b)\/));\\n  };\\n\\n  var CssDiff = new fbDiff(true);\\n  CssDiff.tokenize = function(value) {\\n    return removeEmpty(value.split(\/([{}:;,]|\\\\s+)\/));\\n  };\\n\\n  var LineDiff = new fbDiff();\\n  LineDiff.tokenize = function(value) {\\n    return value.split(\/^\/m);\\n  };\\n\\n  return {\\n    diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },\\n    diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); },\\n    diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },\\n\\n    diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },\\n\\n    createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {\\n      var ret = [];\\n\\n      ret.push(\\\"Index: \\\" + fileName);\\n      ret.push(\\\"===================================================================\\\");\\n      ret.push(\\\"--- \\\" + fileName + (typeof oldHeader === \\\"undefined\\\" ? \\\"\\\" : \\\"\\\\t\\\" + oldHeader));\\n      ret.push(\\\"+++ \\\" + fileName + (typeof newHeader === \\\"undefined\\\" ? \\\"\\\" : \\\"\\\\t\\\" + newHeader));\\n\\n      var diff = LineDiff.diff(oldStr, newStr);\\n      if (!diff[diff.length-1].value) {\\n        diff.pop();   \/\/ Remove trailing newline add\\n      }\\n      diff.push({value: \\\"\\\", lines: []});   \/\/ Append an empty value to make cleanup easier\\n\\n      function contextLines(lines) {\\n        return lines.map(function(entry) { return ' ' + entry; });\\n      }\\n      function eofNL(curRange, i, current) {\\n        var last = diff[diff.length-2],\\n            isLast = i === diff.length-2,\\n            isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed);\\n\\n        \/\/ Figure out if this is the last line for the given file and missing NL\\n        if (!\/\\\\n$\/.test(current.value) && (isLast || isLastOfType)) {\\n          curRange.push('\\\\\\\\ No newline at end of file');\\n        }\\n      }\\n\\n      var oldRangeStart = 0, newRangeStart = 0, curRange = [],\\n          oldLine = 1, newLine = 1;\\n      for (var i = 0; i < diff.length; i++) {\\n        var current = diff[i],\\n            lines = current.lines || current.value.replace(\/\\\\n$\/, \\\"\\\").split(\\\"\\\\n\\\");\\n        current.lines = lines;\\n\\n        if (current.added || current.removed) {\\n          if (!oldRangeStart) {\\n            var prev = diff[i-1];\\n            oldRangeStart = oldLine;\\n            newRangeStart = newLine;\\n\\n            if (prev) {\\n              curRange = contextLines(prev.lines.slice(-4));\\n              oldRangeStart -= curRange.length;\\n              newRangeStart -= curRange.length;\\n            }\\n          }\\n          curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?\\\"+\\\":\\\"-\\\") + entry; }));\\n          eofNL(curRange, i, current);\\n\\n          if (current.added) {\\n            newLine += lines.length;\\n          } else {\\n            oldLine += lines.length;\\n          }\\n        } else {\\n          if (oldRangeStart) {\\n            \/\/ Close out any changes that have been output (or join overlapping)\\n            if (lines.length <= 8 && i < diff.length-2) {\\n              \/\/ Overlapping\\n              curRange.push.apply(curRange, contextLines(lines));\\n            } else {\\n              \/\/ end the range and output\\n              var contextSize = Math.min(lines.length, 4);\\n              ret.push(\\n                  \\\"@@ -\\\" + oldRangeStart + \\\",\\\" + (oldLine-oldRangeStart+contextSize)\\n                  + \\\" +\\\" + newRangeStart + \\\",\\\" + (newLine-newRangeStart+contextSize)\\n                  + \\\" @@\\\");\\n              ret.push.apply(ret, curRange);\\n              ret.push.apply(ret, contextLines(lines.slice(0, contextSize)));\\n              if (lines.length <= 4) {\\n                eofNL(ret, i, current);\\n              }\\n\\n              oldRangeStart = 0;  newRangeStart = 0; curRange = [];\\n            }\\n          }\\n          oldLine += lines.length;\\n          newLine += lines.length;\\n        }\\n      }\\n\\n      return ret.join('\\\\n') + '\\\\n';\\n    },\\n\\n    applyPatch: function(oldStr, uniDiff) {\\n      var diffstr = uniDiff.split(\\\"\\\\n\\\");\\n      var diff = [];\\n      var remEOFNL = false,\\n          addEOFNL = false;\\n\\n      for (var i = (diffstr[0][0]==\\\"I\\\"?4:0); i < diffstr.length; i++) {\\n        if(diffstr[i][0] == \\\"@\\\") {\\n          var meh = diffstr[i].split(\/@@ -(\\\\d+),(\\\\d+) \\\\+(\\\\d+),(\\\\d+) @@\/);\\n          diff.unshift({\\n            start:meh[3],\\n            oldlength:meh[2],\\n            oldlines:[],\\n            newlength:meh[4],\\n            newlines:[]\\n          });\\n        } else if(diffstr[i][0] == '+') {\\n          diff[0].newlines.push(diffstr[i].substr(1));\\n        } else if(diffstr[i][0] == '-') {\\n          diff[0].oldlines.push(diffstr[i].substr(1));\\n        } else if(diffstr[i][0] == ' ') {\\n          diff[0].newlines.push(diffstr[i].substr(1));\\n          diff[0].oldlines.push(diffstr[i].substr(1));\\n        } else if(diffstr[i][0] == '\\\\\\\\') {\\n          if (diffstr[i-1][0] == '+') {\\n            remEOFNL = true;\\n          } else if(diffstr[i-1][0] == '-') {\\n            addEOFNL = true;\\n          }\\n        }\\n      }\\n\\n      var str = oldStr.split(\\\"\\\\n\\\");\\n      for (var i = diff.length - 1; i >= 0; i--) {\\n        var d = diff[i];\\n        for (var j = 0; j < d.oldlength; j++) {\\n          if(str[d.start-1+j] != d.oldlines[j]) {\\n            return false;\\n          }\\n        }\\n        Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines));\\n      }\\n\\n      if (remEOFNL) {\\n        while (!str[str.length-1]) {\\n          str.pop();\\n        }\\n      } else if (addEOFNL) {\\n        str.push('');\\n      }\\n      return str.join('\\\\n');\\n    },\\n\\n    convertChangesToXML: function(changes){\\n      var ret = [];\\n      for ( var i = 0; i < changes.length; i++) {\\n        var change = changes[i];\\n        if (change.added) {\\n          ret.push(\\\"\\\");\\n        } else if (change.removed) {\\n          ret.push(\\\"\\\");\\n        }\\n\\n        ret.push(escapeHTML(change.value));\\n\\n        if (change.added) {\\n          ret.push(\\\"<\/ins>\\\");\\n        } else if (change.removed) {\\n          ret.push(\\\"<\/del>\\\");\\n        }\\n      }\\n      return ret.join(\\\"\\\");\\n    },\\n\\n    \/\/ See: http:\/\/code.google.com\/p\/google-diff-match-patch\/wiki\/API\\n    convertChangesToDMP: function(changes){\\n      var ret = [], change;\\n      for ( var i = 0; i < changes.length; i++) {\\n        change = changes[i];\\n        ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]);\\n      }\\n      return ret;\\n    }\\n  };\\n})();\\n\\nif (typeof module !== \\\"undefined\\\") {\\n    module.exports = JsDiff;\\n}\\n\"\n+});\ndiff --git a\/build\/react-test.js b\/build\/react-test.js\nnew file mode 100644\nindex 0000000000..69e8742c21\n--- \/dev\/null\n+++ b\/build\/react-test.js\n@@ -0,0 +1,266 @@\n+\/\/# sourceURL=populist\/loader.js\n+(function(entries, sources) {\n+  var modules = {};\n+  var hasOwn = modules.hasOwnProperty;\n+  var global = Function(\"return this\")();\n+  var doc = global.document;\n+  var head = doc.documentElement.firstChild;\n+\n+  function internalRequire(id) {\n+    var module = getModule(id);\n+    if (module && !hasOwn.call(module, \"exports\")) {\n+      module(function(rid) {\n+        return internalRequire(absolutize(id, rid));\n+      }, module.exports = {}, module, global);\n+\n+      \/\/ If the module id has a non-null value in the entries object,\n+      \/\/ define a global reference to its exports object.\n+      var globalName = entries[id];\n+      if (globalName && hasOwn.call(entries, id))\n+        global[globalName] = module.exports;\n+    }\n+\n+    return module.exports;\n+  }\n+\n+  function getModule(id) {\n+    if (!hasOwn.call(modules, id)) {\n+      if (hasOwn.call(sources, id)) {\n+        var name = \"module$\" + Math.random().toString(36).slice(2);\n+        var script = doc.createElement(\"script\");\n+        var code = \"function \" + name + \"(require,exports,module,global){\" +\n+          sources[id] + \"\\n}\\n\/\/# sourceURL=\" + id + \".js\\n\";\n+        script.setAttribute(\"type\", \"text\/javascript\");\n+        script.setAttribute(\"encoding\", \"utf8\");\n+        script.appendChild(doc.createTextNode(code));\n+        head.appendChild(script);\n+        modules[id] = global[name];\n+      } else {\n+        throw new Error(\"Missing module: \" + id);\n+      }\n+    }\n+\n+    return modules[id];\n+  }\n+\n+  var pathNormExp = \/\\\/(\\.?|[^\\\/]+\\\/\\.\\.)\\\/\/;\n+  function absolutize(id, rid) {\n+    if (rid.charAt(0) === \".\") {\n+      rid = \"\/\" + id + \"\/..\/\" + rid;\n+      while (rid != (id = rid.replace(pathNormExp, \"\/\")))\n+        rid = id;\n+      rid = rid.replace(\/^\\\/\/, \"\");\n+    }\n+    return rid;\n+  }\n+\n+  \/\/ Eagerly require all identifiers that are keys of the entries object.\n+  for (var id in entries)\n+    if (hasOwn.call(entries, id))\n+      internalRequire(id);\n+})({\"test\/all\":\"harness\"},{\n+\"test\/all\":\"\/\/ This file exists both to give a single entry point for all the utility\\n\/\/ modules in src\/test and to specify an ordering on those modules, since\\n\/\/ some still have implicit dependencies on others.\\n\\nrequire(\\\".\/phantomjs-shims\\\");\\nrequire(\\\"..\/ReactTestUtils\\\");\\nrequire(\\\"..\/reactComponentExpect\\\");\\nrequire(\\\"..\/mocks\\\");\\nrequire(\\\"..\/mock-modules\\\");\\nrequire(\\\".\/mock-timers\\\");\\n\\nexports.enableTest = function(testID) {\\n  require(\\\"..\/\\\" + testID);\\n};\\n\\nexports.removeNextSiblings = function(node) {\\n  var parent = node && node.parentNode;\\n  if (parent) {\\n    while (node.nextSibling) {\\n      parent.removeChild(node.nextSibling);\\n    }\\n  }\\n};\\n\",\n+\"addons\/link\/__tests__\/LinkedStateMixin-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\n\/*jshint evil:true *\/\\n\\ndescribe('LinkedStateMixin', function() {\\n  var LinkedStateMixin;\\n  var React;\\n  var ReactLink;\\n\\n  beforeEach(function() {\\n    LinkedStateMixin = require(\\\"..\/..\/..\/LinkedStateMixin\\\");\\n    React = require(\\\"..\/..\/..\/React\\\");\\n    ReactLink = require(\\\"..\/..\/..\/ReactLink\\\");\\n  });\\n\\n  it('should create a ReactLink for state', function() {\\n    var Component = React.createClass({displayName: 'Component',\\n      mixins: [LinkedStateMixin],\\n\\n      getInitialState: function() {\\n        return {value: 'initial value'};\\n      },\\n\\n      render: function() {\\n        return React.DOM.span(null, \\\"value is \\\", this.state.value);\\n      }\\n    });\\n    var container = document.createElement('div');\\n    var component = React.renderComponent(Component(null ), container);\\n    var link = component.linkState('value');\\n    expect(component.state.value).toBe('initial value');\\n    expect(link.value).toBe('initial value');\\n    link.requestChange('new value');\\n    expect(component.state.value).toBe('new value');\\n    expect(component.linkState('value').value).toBe('new value');\\n  });\\n});\\n\\nrequire(\\\"..\/..\/..\/mock-modules\\\").register(\\\"addons\/link\/__tests__\/LinkedStateMixin-test\\\", module);\\n\",\n+\"addons\/transitions\/__tests__\/ReactTransitionGroup-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar React;\\nvar ReactTransitionGroup;\\nvar mocks;\\n\\n\/\/ Most of the real functionality is covered in other unit tests, this just\\n\/\/ makes sure we're wired up correctly.\\ndescribe('ReactTransitionGroup', function() {\\n  beforeEach(function() {\\n    React = require(\\\"..\/..\/..\/React\\\");\\n    ReactTransitionGroup = require(\\\"..\/..\/..\/ReactTransitionGroup\\\");\\n    mocks = require(\\\"..\/..\/..\/mocks\\\");\\n  });\\n\\n  it('should warn after time with no transitionend', function() {\\n    var container;\\n    var a;\\n\\n    container = document.createElement('div');\\n    a = React.renderComponent(\\n      ReactTransitionGroup( {transitionName:\\\"yolo\\\"}, \\n        React.DOM.span( {key:\\\"one\\\", id:\\\"one\\\"} )\\n      ),\\n      container\\n    );\\n    expect(a.getDOMNode().childNodes.length).toBe(1);\\n\\n    setTimeout.mock.calls.length = 0;\\n\\n    React.renderComponent(\\n      ReactTransitionGroup( {transitionName:\\\"yolo\\\"}, \\n        React.DOM.span( {key:\\\"two\\\", id:\\\"two\\\"} )\\n      ),\\n      container\\n    );\\n    expect(a.getDOMNode().childNodes.length).toBe(2);\\n    expect(a.getDOMNode().childNodes[0].id).toBe('two');\\n    expect(a.getDOMNode().childNodes[1].id).toBe('one');\\n\\n    console.warn = mocks.getMockFunction();\\n    setTimeout.mock.calls[2][0]();\\n\\n    expect(a.getDOMNode().childNodes.length).toBe(2);\\n    expect(console.warn.mock.calls.length).toBe(1);\\n  });\\n\\n  it('should keep both sets of DOM nodes around', function() {\\n    var container = document.createElement('div');\\n    var a = React.renderComponent(\\n      ReactTransitionGroup( {transitionName:\\\"yolo\\\"}, \\n        React.DOM.span( {key:\\\"one\\\", id:\\\"one\\\"} )\\n      ),\\n      container\\n    );\\n    expect(a.getDOMNode().childNodes.length).toBe(1);\\n    React.renderComponent(\\n      ReactTransitionGroup( {transitionName:\\\"yolo\\\"}, \\n        React.DOM.span( {key:\\\"two\\\", id:\\\"two\\\"} )\\n      ),\\n      container\\n    );\\n    expect(a.getDOMNode().childNodes.length).toBe(2);\\n    expect(a.getDOMNode().childNodes[0].id).toBe('two');\\n    expect(a.getDOMNode().childNodes[1].id).toBe('one');\\n  });\\n});\\n\\nrequire(\\\"..\/..\/..\/mock-modules\\\").register(\\\"addons\/transitions\/__tests__\/ReactTransitionGroup-test\\\", module);\\n\",\n+\"addons\/transitions\/__tests__\/ReactTransitionKeySet-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar React;\\nvar ReactTransitionKeySet;\\n\\ndescribe('ReactTransitionKeySet', function() {\\n  beforeEach(function() {\\n    React = require(\\\"..\/..\/..\/React\\\");\\n    ReactTransitionKeySet = require(\\\"..\/..\/..\/ReactTransitionKeySet\\\");\\n  });\\n\\n  it('should support getChildMapping', function() {\\n    var oneone = React.DOM.div( {key:\\\"oneone\\\"} );\\n    var onetwo = React.DOM.div( {key:\\\"onetwo\\\"} );\\n    var one = React.DOM.div( {key:\\\"one\\\"}, oneone,onetwo);\\n    var two = React.DOM.div( {key:\\\"two\\\"} );\\n    var component = React.DOM.div(null, one,two);\\n    expect(ReactTransitionKeySet.getChildMapping(component.props.children))\\n      .toEqual({\\n        '{one}': one,\\n        '{two}': two\\n      });\\n  });\\n\\n  it('should support getKeySet', function() {\\n    var oneone = React.DOM.div( {key:\\\"oneone\\\"} );\\n    var onetwo = React.DOM.div( {key:\\\"onetwo\\\"} );\\n    var one = React.DOM.div( {key:\\\"one\\\"}, oneone,onetwo);\\n    var two = React.DOM.div( {key:\\\"two\\\"} );\\n    var component = React.DOM.div(null, one,two);\\n    expect(ReactTransitionKeySet.getKeySet(component.props.children)).toEqual({\\n      '{one}': true,\\n      '{two}': true\\n    });\\n  });\\n\\n  it('should support mergeKeySets for adding keys', function() {\\n    var prev = {\\n      one: true,\\n      two: true\\n    };\\n    var next = {\\n      one: true,\\n      two: true,\\n      three: true\\n    };\\n    expect(ReactTransitionKeySet.mergeKeySets(prev, next)).toEqual({\\n      one: true,\\n      two: true,\\n      three: true\\n    });\\n  });\\n\\n  it('should support mergeKeySets for removing keys', function() {\\n    var prev = {\\n      one: true,\\n      two: true,\\n      three: true\\n    };\\n    var next = {\\n      one: true,\\n      two: true\\n    };\\n    expect(ReactTransitionKeySet.mergeKeySets(prev, next)).toEqual({\\n      one: true,\\n      two: true,\\n      three: true\\n    });\\n  });\\n\\n  it('should support mergeKeySets for adding and removing', function() {\\n    var prev = {\\n      one: true,\\n      two: true,\\n      three: true\\n    };\\n    var next = {\\n      one: true,\\n      two: true,\\n      four: true\\n    };\\n    expect(ReactTransitionKeySet.mergeKeySets(prev, next)).toEqual({\\n      one: true,\\n      two: true,\\n      three: true,\\n      four: true\\n    });\\n  });\\n\\n  it('should reconcile overlapping insertions and deletions', function() {\\n    var prev = {\\n      one: true,\\n      two: true,\\n      four: true,\\n      five: true\\n    };\\n    var next = {\\n      one: true,\\n      two: true,\\n      three: true,\\n      five: true\\n    };\\n    expect(ReactTransitionKeySet.mergeKeySets(prev, next)).toEqual({\\n      one: true,\\n      two: true,\\n      three: true,\\n      four: true,\\n      five: true\\n    });\\n  });\\n});\\n\\nrequire(\\\"..\/..\/..\/mock-modules\\\").register(\\\"addons\/transitions\/__tests__\/ReactTransitionKeySet-test\\\", module);\\n\",\n+\"addons\/transitions\/__tests__\/ReactTransitionableChild-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar React;\\nvar ReactTransitionableChild;\\n\\nvar mocks = require(\\\"..\/..\/..\/mocks\\\");\\n\\ndescribe('ReactTransitionableChild', function() {\\n  beforeEach(function() {\\n    React = require(\\\"..\/..\/..\/React\\\");\\n    ReactTransitionableChild = require(\\\"..\/..\/..\/ReactTransitionableChild\\\");\\n  });\\n\\n  it('should keep the DOM node around', function() {\\n    var container = document.createElement('div');\\n    var ac = React.renderComponent(\\n      ReactTransitionableChild(null, React.DOM.span( {id:\\\"test\\\"} )),\\n      container\\n    );\\n    expect(ac.getDOMNode().id).toBe('test');\\n    ac = React.renderComponent(ReactTransitionableChild(null ), container);\\n    expect(ac.getDOMNode().id).toBe('test');\\n  });\\n\\n  it('should manage enter css classes correctly', function() {\\n    var runNextTick = mocks.getMockFunction();\\n    var container = document.createElement('div');\\n    var ac = React.renderComponent(\\n      ReactTransitionableChild(\\n        {runNextTick:runNextTick,\\n        name:\\\"myanim\\\",\\n        enter:true}, \\n        React.DOM.span( {id:\\\"test\\\"} )\\n      ),\\n      container\\n    );\\n    expect(ac.getDOMNode().id).toBe('test');\\n    expect(ac.getDOMNode().className.trim()).toBe('myanim-enter');\\n    expect(runNextTick.mock.calls.length).toBe(1);\\n    runNextTick.mock.calls[0][0]();\\n    expect(ac.getDOMNode().className.trim()).toBe(\\n      'myanim-enter myanim-enter-active'\\n    );\\n    expect(runNextTick.mock.calls.length).toBe(1);\\n  });\\n\\n  it('should manage leave css classes correctly', function() {\\n    var runNextTick = mocks.getMockFunction();\\n    var container = document.createElement('div');\\n    var ac = React.renderComponent(\\n      ReactTransitionableChild(\\n        {runNextTick:runNextTick,\\n        name:\\\"myanim\\\",\\n        enter:true,\\n        leave:true}, \\n        React.DOM.span( {id:\\\"test\\\"} )\\n      ),\\n      container\\n    );\\n    runNextTick.mock.calls[0][0]();\\n    expect(ac.getDOMNode().className.trim()).toBe(\\n      'myanim-enter myanim-enter-active'\\n    );\\n\\n    \/\/ TODO: we should just trigger the CSS animation end event to\\n    \/\/ clean these up\\n    ac.getDOMNode().className = '';\\n    React.renderComponent(\\n      ReactTransitionableChild(\\n        {runNextTick:runNextTick,\\n        name:\\\"myanim\\\",\\n        enter:true,\\n        leave:true}\\n      ),\\n      container\\n    );\\n    expect(ac.getDOMNode().className.trim()).toBe('myanim-leave');\\n    expect(runNextTick.mock.calls.length).toBe(2);\\n    runNextTick.mock.calls[1][0]();\\n    expect(ac.getDOMNode().className.trim()).toBe(\\n      'myanim-leave myanim-leave-active'\\n    );\\n    expect(runNextTick.mock.calls.length).toBe(2);\\n  });\\n});\\n\\nrequire(\\\"..\/..\/..\/mock-modules\\\").register(\\\"addons\/transitions\/__tests__\/ReactTransitionableChild-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactBind-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\/*global global:true*\/\\n\\\"use strict\\\";\\n\\nvar mocks = require(\\\"..\/..\/mocks\\\");\\nvar React = require(\\\"..\/..\/React\\\");\\nvar ReactDoNotBindDeprecated = require(\\\"..\/..\/ReactDoNotBindDeprecated\\\");\\nvar ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\nvar reactComponentExpect = require(\\\"..\/..\/reactComponentExpect\\\");\\n\\n\/\/ TODO: Test render and all stock methods.\\ndescribe('autobinding', function() {\\n\\n  it('Holds reference to instance', function() {\\n\\n    var mouseDidEnter = mocks.getMockFunction();\\n    var mouseDidLeave = mocks.getMockFunction();\\n    var mouseDidClick = mocks.getMockFunction();\\n\\n    var TestBindComponent = React.createClass({displayName: 'TestBindComponent',\\n      getInitialState: function() {\\n        return {something: 'hi'};\\n      },\\n      onMouseEnter: ReactDoNotBindDeprecated.doNotBind(mouseDidEnter),\\n      onMouseLeave: ReactDoNotBindDeprecated.doNotBind(mouseDidLeave),\\n      onClick: mouseDidClick,\\n\\n      \/\/ auto binding only occurs on top level functions in class defs.\\n      badIdeas: {\\n        badBind: function() {\\n          this.state.something;\\n        }\\n      },\\n\\n      render: function() {\\n        return (\\n          React.DOM.div(\\n            {onMouseEnter:this.onMouseEnter.bind(this),\\n            onMouseLeave:this.onMouseLeave,\\n            onClick:this.onClick}\\n          )\\n        );\\n      }\\n    });\\n\\n    var instance1 = TestBindComponent(null );\\n    ReactTestUtils.renderIntoDocument(instance1);\\n    var rendered1 = reactComponentExpect(instance1)\\n      .expectRenderedChild()\\n      .instance();\\n\\n    var instance2 = TestBindComponent(null );\\n    ReactTestUtils.renderIntoDocument(instance2);\\n    var rendered2 = reactComponentExpect(instance2)\\n      .expectRenderedChild()\\n      .instance();\\n\\n    expect(function() {\\n      var badIdea = instance1.badIdeas.badBind;\\n      badIdea();\\n    }).toThrow();\\n\\n    expect(instance1.onMouseEnter).toBe(instance2.onMouseEnter);\\n    expect(instance1.onMouseLeave).toBe(instance2.onMouseLeave);\\n    expect(instance1.onClick).not.toBe(instance2.onClick);\\n\\n    ReactTestUtils.Simulate.click(rendered1);\\n    expect(mouseDidClick.mock.instances.length).toBe(1);\\n    expect(mouseDidClick.mock.instances[0]).toBe(instance1);\\n\\n    ReactTestUtils.Simulate.click(rendered2);\\n    expect(mouseDidClick.mock.instances.length).toBe(2);\\n    expect(mouseDidClick.mock.instances[1]).toBe(instance2);\\n\\n    ReactTestUtils.Simulate.mouseOver(rendered1);\\n    expect(mouseDidEnter.mock.instances.length).toBe(1);\\n    expect(mouseDidEnter.mock.instances[0]).toBe(instance1);\\n\\n    ReactTestUtils.Simulate.mouseOver(rendered2);\\n    expect(mouseDidEnter.mock.instances.length).toBe(2);\\n    expect(mouseDidEnter.mock.instances[1]).toBe(instance2);\\n\\n    ReactTestUtils.Simulate.mouseOut(rendered1);\\n    expect(mouseDidLeave.mock.instances.length).toBe(1);\\n    expect(mouseDidLeave.mock.instances[0]).toBe(global);\\n\\n    ReactTestUtils.Simulate.mouseOut(rendered2);\\n    expect(mouseDidLeave.mock.instances.length).toBe(2);\\n    expect(mouseDidLeave.mock.instances[1]).toBe(global);\\n  });\\n\\n  it('works with mixins', function() {\\n    var mouseDidClick = mocks.getMockFunction();\\n\\n    var TestMixin = {\\n      onClick: mouseDidClick\\n    };\\n\\n    var TestBindComponent = React.createClass({displayName: 'TestBindComponent',\\n      mixins: [TestMixin],\\n\\n      render: function() {\\n        return React.DOM.div( {onClick:this.onClick} );\\n      }\\n    });\\n\\n    var instance1 = TestBindComponent(null );\\n    ReactTestUtils.renderIntoDocument(instance1);\\n    var rendered1 = reactComponentExpect(instance1)\\n      .expectRenderedChild()\\n      .instance();\\n\\n    ReactTestUtils.Simulate.click(rendered1);\\n    expect(mouseDidClick.mock.instances.length).toBe(1);\\n    expect(mouseDidClick.mock.instances[0]).toBe(instance1);\\n  });\\n\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactBind-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactComponent-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar React;\\nvar ReactTestUtils;\\n\\nvar reactComponentExpect;\\n\\ndescribe('ReactComponent', function() {\\n  beforeEach(function() {\\n    React = require(\\\"..\/..\/React\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n    reactComponentExpect = require(\\\"..\/..\/reactComponentExpect\\\");\\n  });\\n\\n  it('should throw on invalid render targets', function() {\\n    var container = document.createElement('div');\\n    \/\/ jQuery objects are basically arrays; people often pass them in by mistake\\n    expect(function() {\\n      React.renderComponent(React.DOM.div(null), [container]);\\n    }).toThrow(\\n      'Invariant Violation: prepareEnvironmentForDOM(...): Target container ' +\\n      'is not a DOM element.'\\n    );\\n\\n    expect(function() {\\n      React.renderComponent(React.DOM.div(null), null);\\n    }).toThrow(\\n      'Invariant Violation: prepareEnvironmentForDOM(...): Target container ' +\\n      'is not a DOM element.'\\n    );\\n  });\\n\\n  it('should throw when supplying a ref outside of render method', function() {\\n    var instance = React.DOM.div( {ref:\\\"badDiv\\\"} );\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).toThrow();\\n  });\\n\\n  it('should throw when attempting to hijack a ref', function() {\\n    var Component = React.createClass({displayName: 'Component',\\n      render: function() {\\n        var child = this.props.child;\\n        this.attachRef('test', child);\\n        return child;\\n      }\\n    });\\n\\n    var instance = Component( {child:React.DOM.span(null )} );\\n\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).toThrow(\\n      'Invariant Violation: attachRef(test, ...): Only a component\\\\'s owner ' +\\n      'can store a ref to it.'\\n    );\\n  });\\n\\n  it('should support refs on owned components', function() {\\n    var inner, outer;\\n\\n    var Component = React.createClass({displayName: 'Component',\\n      render: function() {\\n        inner = React.DOM.div( {ref:\\\"inner\\\"} );\\n        outer = React.DOM.div( {ref:\\\"outer\\\"}, inner);\\n        return outer;\\n      },\\n      componentDidMount: function() {\\n        expect(this.refs.inner).toEqual(inner);\\n        expect(this.refs.outer).toEqual(outer);\\n      }\\n    });\\n\\n    var instance = Component( {child:React.DOM.span(null )} );\\n    ReactTestUtils.renderIntoDocument(instance);\\n  });\\n\\n  it('should not have refs on unmounted components', function() {\\n    var Parent = React.createClass({displayName: 'Parent',\\n      render: function() {\\n        return Child(null, React.DOM.div( {ref:\\\"test\\\"} ));\\n      },\\n      componentDidMount: function() {\\n        expect(this.refs && this.refs.test).toEqual(undefined);\\n      }\\n    });\\n    var Child = React.createClass({displayName: 'Child',\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n\\n    var instance = Parent( {child:React.DOM.span(null )} );\\n    ReactTestUtils.renderIntoDocument(instance);\\n  });\\n\\n  it('should correctly determine if a component is mounted', function() {\\n    var Component = React.createClass({displayName: 'Component',\\n      componentWillMount: function() {\\n        expect(this.isMounted()).toBeFalsy();\\n      },\\n      componentDidMount: function() {\\n        expect(this.isMounted()).toBeTruthy();\\n      },\\n      render: function() {\\n        return React.DOM.div(null);\\n      }\\n    });\\n\\n    var instance = Component(null );\\n\\n    expect(instance.isMounted()).toBeFalsy();\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expect(instance.isMounted()).toBeTruthy();\\n  });\\n\\n  it('should know its simple mount depth', function() {\\n    var Owner = React.createClass({displayName: 'Owner',\\n      render: function() {\\n        return Child( {ref:\\\"child\\\"} );\\n      }\\n    });\\n\\n    var Child = React.createClass({displayName: 'Child',\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n\\n    var instance = Owner(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expect(instance._mountDepth).toBe(0);\\n    expect(instance.refs.child._mountDepth).toBe(1);\\n  });\\n\\n  it('should know its (complicated) mount depth', function() {\\n    var Box = React.createClass({displayName: 'Box',\\n      render: function() {\\n        return React.DOM.div( {ref:\\\"boxDiv\\\"}, this.props.children);\\n      }\\n    });\\n\\n    var Child = React.createClass({displayName: 'Child',\\n      render: function() {\\n        return React.DOM.span( {ref:\\\"span\\\"}, \\\"child\\\");\\n      }\\n    });\\n\\n    var Switcher = React.createClass({displayName: 'Switcher',\\n      getInitialState: function() {\\n        return {tabKey: 'hello'};\\n      },\\n\\n      render: function() {\\n        var child = this.props.children;\\n\\n        return (\\n          Box( {ref:\\\"box\\\"}, \\n            React.DOM.div(\\n              {ref:\\\"switcherDiv\\\",\\n              style:{\\n                display: this.state.tabKey === child.key ? '' : 'none'\\n            }}, \\n              child\\n            )\\n          )\\n        );\\n      }\\n    });\\n\\n    var App = React.createClass({displayName: 'App',\\n      render: function() {\\n        return (\\n          Switcher( {ref:\\\"switcher\\\"}, \\n            Child( {key:\\\"hello\\\", ref:\\\"child\\\"} )\\n          )\\n        );\\n      }\\n    });\\n\\n    var root = App(null );\\n    ReactTestUtils.renderIntoDocument(root);\\n\\n    expect(root._mountDepth).toBe(0);\\n    expect(root.refs.switcher._mountDepth).toBe(1);\\n    expect(root.refs.switcher.refs.box._mountDepth).toBe(2);\\n    expect(root.refs.switcher.refs.switcherDiv._mountDepth).toBe(4);\\n    expect(root.refs.child._mountDepth).toBe(5);\\n    expect(root.refs.switcher.refs.box.refs.boxDiv._mountDepth).toBe(3);\\n    expect(root.refs.child.refs.span._mountDepth).toBe(6);\\n  });\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactComponent-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactComponentLifeCycle-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar React;\\nvar ReactTestUtils;\\nvar ReactComponent;\\nvar ReactCompositeComponent;\\nvar ComponentLifeCycle;\\nvar CompositeComponentLifeCycle;\\n\\nvar clone = function(o) {\\n  return JSON.parse(JSON.stringify(o));\\n};\\n\\n\\nvar GET_INIT_STATE_RETURN_VAL = {\\n  hasWillMountCompleted: false,\\n  hasRenderCompleted: false,\\n  hasDidMountCompleted: false,\\n  hasWillUnmountCompleted: false\\n};\\n\\nvar INIT_RENDER_STATE = {\\n  hasWillMountCompleted: true,\\n  hasRenderCompleted: false,\\n  hasDidMountCompleted: false,\\n  hasWillUnmountCompleted: false\\n};\\n\\nvar DID_MOUNT_STATE = {\\n  hasWillMountCompleted: true,\\n  hasRenderCompleted: true,\\n  hasDidMountCompleted: false,\\n  hasWillUnmountCompleted: false\\n};\\n\\nvar NEXT_RENDER_STATE = {\\n  hasWillMountCompleted: true,\\n  hasRenderCompleted: true,\\n  hasDidMountCompleted: true,\\n  hasWillUnmountCompleted: false\\n};\\n\\nvar WILL_UNMOUNT_STATE = {\\n  hasWillMountCompleted: true,\\n  hasDidMountCompleted: true,\\n  hasRenderCompleted: true,\\n  hasWillUnmountCompleted: false\\n};\\n\\nvar POST_WILL_UNMOUNT_STATE = {\\n  hasWillMountCompleted: true,\\n  hasDidMountCompleted: true,\\n  hasRenderCompleted: true,\\n  hasWillUnmountCompleted: true\\n};\\n\\n\/**\\n * TODO: We should make any setState calls fail in\\n * `getInitialState` and `componentWillMount`. They will usually fail\\n * anyways because `this._renderedComponent` is empty, however, if a component\\n * is *reused*, then that won't be the case and things will appear to work in\\n * some cases. Better to just block all updates in initialization.\\n *\/\\ndescribe('ReactComponentLifeCycle', function() {\\n  beforeEach(function() {\\n    require(\\\"..\/..\/mock-modules\\\").dumpCache();\\n    React = require(\\\"..\/..\/React\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n    ReactComponent = require(\\\"..\/..\/ReactComponent\\\");\\n    ReactCompositeComponent = require(\\\"..\/..\/ReactCompositeComponent\\\");\\n    ComponentLifeCycle = ReactComponent.LifeCycle;\\n    CompositeComponentLifeCycle = ReactCompositeComponent.LifeCycle;\\n  });\\n\\n  it('should scrub state when reinitialized using getInitialState', function() {\\n    var StatefulComponent = React.createClass({displayName: 'StatefulComponent',\\n      getInitialState: function() {\\n        return { };\\n      },\\n      addAnotherField: function() {\\n        this.setState({\\n          aField: 'asdf'\\n        });\\n      },\\n      render: function() {\\n        return (\\n          React.DOM.div(null )\\n        );\\n      }\\n    });\\n    var instance = StatefulComponent(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    instance.addAnotherField();\\n    expect(instance.state.aField).toBe('asdf');\\n    instance.unmountComponent();\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expect(typeof instance.state.aField).toBe('undefined');\\n  });\\n\\n  \/**\\n   * If a state update triggers rerendering that in turn fires an onDOMReady,\\n   * that second onDOMReady should not fail.\\n   *\/\\n  it('it should fire onDOMReady when already in onDOMReady', function() {\\n\\n    var _testJournal = [];\\n\\n    var Child = React.createClass({displayName: 'Child',\\n      componentDidMount: function() {\\n        _testJournal.push('Child:onDOMReady');\\n      },\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n\\n    var SwitcherParent = React.createClass({displayName: 'SwitcherParent',\\n      getInitialState: function() {\\n        _testJournal.push('SwitcherParent:getInitialState');\\n        return {showHasOnDOMReadyComponent: false};\\n      },\\n      componentDidMount: function() {\\n        _testJournal.push('SwitcherParent:onDOMReady');\\n        this.switchIt();\\n      },\\n      switchIt: function() {\\n        this.setState({showHasOnDOMReadyComponent: true});\\n      },\\n      render: function() {\\n        return (\\n          React.DOM.div(null, \\n            this.state.showHasOnDOMReadyComponent ?\\n            Child(null ) :\\n            React.DOM.div(null )\\n          )\\n        );\\n      }\\n    });\\n\\n    var instance = SwitcherParent(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expect(_testJournal).toEqual([\\n      'SwitcherParent:getInitialState',\\n      'SwitcherParent:onDOMReady',\\n      'Child:onDOMReady'\\n    ]);\\n  });\\n\\n\\n  it('should scrub state when re-initialized', function() {\\n    var StatefulComponent = React.createClass({displayName: 'StatefulComponent',\\n      addAnotherField: function() {\\n        this.setState({\\n          aField: 'asdf'\\n        });\\n      },\\n      render: function() {\\n        return (\\n          React.DOM.div(null )\\n        );\\n      }\\n    });\\n    var instance = StatefulComponent(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    instance.addAnotherField();\\n    expect(instance.state.aField).toBe('asdf');\\n    instance.unmountComponent();\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expect(instance.state).toBe(null);\\n  });\\n\\n  \/\/ You could assign state here, but not access members of it, unless you\\n  \/\/ had provided a getInitialState method.\\n  it('throws when accessing state in componentWillMount', function() {\\n    var StatefulComponent = React.createClass({displayName: 'StatefulComponent',\\n      componentWillMount: function() {\\n        this.state.yada;\\n      },\\n      render: function() {\\n        return (\\n          React.DOM.div(null )\\n        );\\n      }\\n    });\\n    var instance = StatefulComponent(null );\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).toThrow();\\n  });\\n\\n  it('should allow update state inside of componentWillMount', function() {\\n    var StatefulComponent = React.createClass({displayName: 'StatefulComponent',\\n      componentWillMount: function() {\\n        this.setState({stateField: 'something'});\\n      },\\n      render: function() {\\n        return (\\n          React.DOM.div(null )\\n        );\\n      }\\n    });\\n    var instance = StatefulComponent(null );\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).not.toThrow();\\n  });\\n\\n  it('should allow update state inside of getInitialState', function() {\\n    var StatefulComponent = React.createClass({displayName: 'StatefulComponent',\\n      getInitialState: function() {\\n        this.setState({stateField: 'something'});\\n\\n        return {stateField: 'somethingelse'};\\n      },\\n      render: function() {\\n        return (\\n          React.DOM.div(null )\\n        );\\n      }\\n    });\\n    var instance = StatefulComponent(null );\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).not.toThrow();\\n\\n    \/\/ The return value of getInitialState overrides anything from setState\\n    expect(instance.state.stateField).toEqual('somethingelse');\\n  });\\n\\n\\n  it('should carry through each of the phases of setup', function() {\\n    var LifeCycleComponent = React.createClass({displayName: 'LifeCycleComponent',\\n      getInitialState: function() {\\n        this._testJournal = {};\\n        var initState = {\\n          hasWillMountCompleted: false,\\n          hasDidMountCompleted: false,\\n          hasRenderCompleted: false,\\n          hasWillUnmountCompleted: false\\n        };\\n        this._testJournal.returnedFromGetInitialState = clone(initState);\\n        this._testJournal.lifeCycleAtStartOfGetInitialState =\\n          this._lifeCycleState;\\n        this._testJournal.compositeLifeCycleAtStartOfGetInitialState =\\n          this._compositeLifeCycleState;\\n        return initState;\\n      },\\n\\n      componentWillMount: function() {\\n        this._testJournal.stateAtStartOfWillMount = clone(this.state);\\n        this._testJournal.lifeCycleAtStartOfWillMount =\\n          this._lifeCycleState;\\n        this._testJournal.compositeLifeCycleAtStartOfWillMount =\\n          this._compositeLifeCycleState;\\n        this.state.hasWillMountCompleted = true;\\n      },\\n\\n      componentDidMount: function() {\\n        this._testJournal.stateAtStartOfDidMount = clone(this.state);\\n        this._testJournal.lifeCycleAtStartOfDidMount =\\n          this._lifeCycleState;\\n        this.setState({hasDidMountCompleted: true});\\n      },\\n\\n      render: function() {\\n        var isInitialRender = !this.state.hasRenderCompleted;\\n        if (isInitialRender) {\\n          this._testJournal.stateInInitialRender = clone(this.state);\\n          this._testJournal.lifeCycleInInitialRender = this._lifeCycleState;\\n          this._testJournal.compositeLifeCycleInInitialRender =\\n            this._compositeLifeCycleState;\\n        } else {\\n          this._testJournal.stateInLaterRender = clone(this.state);\\n          this._testJournal.lifeCycleInLaterRender = this._lifeCycleState;\\n        }\\n        \/\/ you would *NEVER* do anything like this in real code!\\n        this.state.hasRenderCompleted = true;\\n        return (\\n          React.DOM.div( {ref:\\\"theDiv\\\"}, \\n            \\\" I am the inner DIV \\\"\\n          )\\n        );\\n      },\\n\\n      componentWillUnmount: function() {\\n        this._testJournal.stateAtStartOfWillUnmount = clone(this.state);\\n        this._testJournal.lifeCycleAtStartOfWillUnmount =\\n          this._lifeCycleState;\\n        this.state.hasWillUnmountCompleted = true;\\n      }\\n    });\\n\\n    \/\/ A component that is merely \\\"constructed\\\" (as in \\\"constructor\\\") but not\\n    \/\/ yet initialized, or rendered.\\n    \/\/\\n    var instance = LifeCycleComponent(null );\\n    expect(instance._lifeCycleState).toBe(ComponentLifeCycle.UNMOUNTED);\\n    ReactTestUtils.renderIntoDocument(instance);\\n\\n    \/\/ getInitialState\\n    expect(instance._testJournal.returnedFromGetInitialState).toEqual(\\n      GET_INIT_STATE_RETURN_VAL\\n    );\\n    expect(instance._testJournal.lifeCycleAtStartOfGetInitialState)\\n      .toBe(ComponentLifeCycle.MOUNTED);\\n    expect(instance._testJournal.compositeLifeCycleAtStartOfGetInitialState)\\n      .toBe(CompositeComponentLifeCycle.MOUNTING);\\n\\n    \/\/ componentWillMount\\n    expect(instance._testJournal.stateAtStartOfWillMount).toEqual(\\n      instance._testJournal.returnedFromGetInitialState\\n    );\\n    expect(instance._testJournal.lifeCycleAtStartOfWillMount)\\n      .toBe(ComponentLifeCycle.MOUNTED);\\n    expect(instance._testJournal.compositeLifeCycleAtStartOfWillMount)\\n      .toBe(CompositeComponentLifeCycle.MOUNTING);\\n\\n    \/\/ componentDidMount\\n    expect(instance._testJournal.stateAtStartOfDidMount)\\n      .toEqual(DID_MOUNT_STATE);\\n    expect(instance._testJournal.lifeCycleAtStartOfDidMount).toBe(\\n      ComponentLifeCycle.MOUNTED\\n    );\\n\\n    \/\/ render\\n    expect(instance._testJournal.stateInInitialRender)\\n      .toEqual(INIT_RENDER_STATE);\\n    expect(instance._testJournal.lifeCycleInInitialRender).toBe(\\n      ComponentLifeCycle.MOUNTED\\n    );\\n    expect(instance._testJournal.compositeLifeCycleInInitialRender).toBe(\\n      CompositeComponentLifeCycle.MOUNTING\\n    );\\n\\n    expect(instance._lifeCycleState).toBe(ComponentLifeCycle.MOUNTED);\\n\\n    \/\/ Now *update the component*\\n    instance.forceUpdate();\\n\\n    \/\/ render 2nd time\\n    expect(instance._testJournal.stateInLaterRender)\\n      .toEqual(NEXT_RENDER_STATE);\\n    expect(instance._testJournal.lifeCycleInLaterRender).toBe(\\n      ComponentLifeCycle.MOUNTED\\n    );\\n\\n    expect(instance._lifeCycleState).toBe(ComponentLifeCycle.MOUNTED);\\n\\n    \/\/ Now *unmountComponent*\\n    instance.unmountComponent();\\n\\n    expect(instance._testJournal.stateAtStartOfWillUnmount)\\n      .toEqual(WILL_UNMOUNT_STATE);\\n    \/\/ componentWillUnmount called right before unmount.\\n    expect(instance._testJournal.lifeCycleAtStartOfWillUnmount).toBe(\\n      ComponentLifeCycle.MOUNTED\\n    );\\n\\n    \/\/ But the current lifecycle of the component is unmounted.\\n    expect(instance._lifeCycleState).toBe(ComponentLifeCycle.UNMOUNTED);\\n    expect(instance.state).toEqual(POST_WILL_UNMOUNT_STATE);\\n  });\\n\\n  it('should throw when calling setProps() on an owned component', function() {\\n    \/**\\n     * calls setProps in an componentDidMount.\\n     *\/\\n    var PropsUpdaterInOnDOMReady = React.createClass({displayName: 'PropsUpdaterInOnDOMReady',\\n      componentDidMount: function() {\\n        this.refs.theSimpleComponent.setProps({\\n          value: this.props.valueToUseInOnDOMReady\\n        });\\n      },\\n      render: function() {\\n        return (\\n          React.DOM.input(\\n            {value:this.props.valueToUseInitially,\\n            ref:\\\"theSimpleComponent\\\"}\\n          )\\n        );\\n      }\\n    });\\n    var instance =\\n      PropsUpdaterInOnDOMReady(\\n        {valueToUseInitially:\\\"hello\\\",\\n        valueToUseInOnDOMReady:\\\"goodbye\\\"}\\n      );\\n    expect(ReactTestUtils.renderIntoDocument.bind(ReactTestUtils, instance))\\n      .toThrow();\\n  });\\n\\n  it('should throw when calling setProps() on an unmounted component',\\n     function() {\\n    var PropsToUpdate = React.createClass({displayName: 'PropsToUpdate',\\n      render: function() {\\n        return (\\n          React.DOM.input(\\n            {value:this.props.value,\\n            ref:\\\"theSimpleComponent\\\"}\\n          )\\n        );\\n      }\\n    });\\n    var instance = PropsToUpdate( {value:\\\"hello\\\"} );\\n    expect(function() {\\n      instance.setProps({value: \\\"goodbye\\\"});\\n    }).toThrow(\\n      'Invariant Violation: replaceProps(...): Can only update a ' +\\n      'mounted component.'\\n    );\\n  });\\n\\n  it('should allow state updates in componentDidMount', function() {\\n    \/**\\n     * calls setState in an componentDidMount.\\n     *\/\\n    var SetStateInComponentDidMount = React.createClass({displayName: 'SetStateInComponentDidMount',\\n      getInitialState: function() {\\n        return {\\n          stateField: this.props.valueToUseInitially\\n        };\\n      },\\n      componentDidMount: function() {\\n        this.setState({stateField: this.props.valueToUseInOnDOMReady});\\n      },\\n      render: function() {\\n        return (React.DOM.div(null));\\n      }\\n    });\\n    var instance =\\n      SetStateInComponentDidMount(\\n        {valueToUseInitially:\\\"hello\\\",\\n        valueToUseInOnDOMReady:\\\"goodbye\\\"}\\n      );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expect(instance.state.stateField).toBe('goodbye');\\n  });\\n\\n  it('should call nested lifecycle methods in the right order', function() {\\n    var log;\\n    var logger = function(msg) {\\n      return function() {\\n        \/\/ return true for shouldComponentUpdate\\n        log.push(msg);\\n        return true;\\n      };\\n    };\\n    var Outer = React.createClass({displayName: 'Outer',\\n      render: function() {\\n        return React.DOM.div(null, Inner( {x:this.props.x} ));\\n      },\\n      componentWillMount: logger('outer componentWillMount'),\\n      componentDidMount: logger('outer componentDidMount'),\\n      componentWillReceiveProps: logger('outer componentWillReceiveProps'),\\n      shouldComponentUpdate: logger('outer shouldComponentUpdate'),\\n      componentWillUpdate: logger('outer componentWillUpdate'),\\n      componentDidUpdate: logger('outer componentDidUpdate'),\\n      componentWillUnmount: logger('outer componentWillUnmount')\\n    });\\n    var Inner = React.createClass({displayName: 'Inner',\\n      render: function() {\\n        return React.DOM.span(null, this.props.x);\\n      },\\n      componentWillMount: logger('inner componentWillMount'),\\n      componentDidMount: logger('inner componentDidMount'),\\n      componentWillReceiveProps: logger('inner componentWillReceiveProps'),\\n      shouldComponentUpdate: logger('inner shouldComponentUpdate'),\\n      componentWillUpdate: logger('inner componentWillUpdate'),\\n      componentDidUpdate: logger('inner componentDidUpdate'),\\n      componentWillUnmount: logger('inner componentWillUnmount')\\n    });\\n    var instance;\\n\\n    log = [];\\n    instance = ReactTestUtils.renderIntoDocument(Outer( {x:17} ));\\n    expect(log).toEqual([\\n      'outer componentWillMount',\\n      'inner componentWillMount',\\n      'inner componentDidMount',\\n      'outer componentDidMount'\\n    ]);\\n\\n    log = [];\\n    instance.setProps({x: 42});\\n    expect(log).toEqual([\\n      'outer componentWillReceiveProps',\\n      'outer shouldComponentUpdate',\\n      'outer componentWillUpdate',\\n      'inner componentWillReceiveProps',\\n      'inner shouldComponentUpdate',\\n      'inner componentWillUpdate',\\n      'inner componentDidUpdate',\\n      'outer componentDidUpdate'\\n    ]);\\n\\n    log = [];\\n    instance.unmountComponent();\\n    expect(log).toEqual([\\n      'outer componentWillUnmount',\\n      'inner componentWillUnmount'\\n    ]);\\n  });\\n});\\n\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactComponentLifeCycle-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactCompositeComponent-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar MorphingComponent;\\nvar ChildUpdates;\\nvar React;\\nvar ReactCurrentOwner;\\nvar ReactPropTypes;\\nvar ReactTestUtils;\\nvar ReactMount;\\nvar ReactDoNotBindDeprecated;\\n\\nvar cx;\\nvar reactComponentExpect;\\nvar mocks;\\n\\ndescribe('ReactCompositeComponent', function() {\\n\\n  beforeEach(function() {\\n    cx = require(\\\"..\/..\/cx\\\");\\n    mocks = require(\\\"..\/..\/mocks\\\");\\n\\n    reactComponentExpect = require(\\\"..\/..\/reactComponentExpect\\\");\\n    React = require(\\\"..\/..\/React\\\");\\n    ReactCurrentOwner = require(\\\"..\/..\/ReactCurrentOwner\\\");\\n    ReactDoNotBindDeprecated = require(\\\"..\/..\/ReactDoNotBindDeprecated\\\");\\n    ReactPropTypes = require(\\\"..\/..\/ReactPropTypes\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n    ReactMount = require(\\\"..\/..\/ReactMount\\\");\\n\\n    MorphingComponent = React.createClass({\\n      getInitialState: function() {\\n        return {activated: false};\\n      },\\n\\n      _toggleActivatedState: function() {\\n        this.setState({activated: !this.state.activated});\\n      },\\n\\n      render: function() {\\n        var toggleActivatedState = this._toggleActivatedState;\\n        return !this.state.activated ?\\n          React.DOM.a( {ref:\\\"x\\\", onClick:toggleActivatedState} ) :\\n          React.DOM.b( {ref:\\\"x\\\", onClick:toggleActivatedState} );\\n      }\\n    });\\n\\n    \/**\\n     * We'll use this to ensure that an old version is not cached when it is\\n     * reallocated again.\\n     *\/\\n    ChildUpdates = React.createClass({\\n      getAnchorID: function() {\\n        return this.refs.anch._rootNodeID;\\n      },\\n      render: function() {\\n        var className = cx({'anchorClass': this.props.anchorClassOn});\\n        return this.props.renderAnchor ?\\n          React.DOM.a( {ref:\\\"anch\\\", className:className}) :\\n          React.DOM.b(null);\\n      }\\n    });\\n  });\\n\\n  it('should support rendering to different child types over time', function() {\\n    var instance = MorphingComponent(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n\\n    reactComponentExpect(instance)\\n      .expectRenderedChild()\\n      .toBeDOMComponentWithTag('a');\\n\\n    instance._toggleActivatedState();\\n    reactComponentExpect(instance)\\n      .expectRenderedChild()\\n      .toBeDOMComponentWithTag('b');\\n\\n    instance._toggleActivatedState();\\n    reactComponentExpect(instance)\\n      .expectRenderedChild()\\n      .toBeDOMComponentWithTag('a');\\n  });\\n\\n  it('should react to state changes from callbacks', function() {\\n    var instance = MorphingComponent(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n\\n    var renderedChild = reactComponentExpect(instance)\\n      .expectRenderedChild()\\n      .instance();\\n\\n    ReactTestUtils.Simulate.click(renderedChild);\\n    reactComponentExpect(instance)\\n      .expectRenderedChild()\\n      .toBeDOMComponentWithTag('b');\\n  });\\n\\n  it('should rewire refs when rendering to different child types', function() {\\n    var instance = MorphingComponent(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n\\n    reactComponentExpect(instance.refs.x).toBeDOMComponentWithTag('a');\\n    instance._toggleActivatedState();\\n    reactComponentExpect(instance.refs.x).toBeDOMComponentWithTag('b');\\n    instance._toggleActivatedState();\\n    reactComponentExpect(instance.refs.x).toBeDOMComponentWithTag('a');\\n  });\\n\\n  it('should not cache old DOM nodes when switching constructors', function() {\\n    var instance = ChildUpdates( {renderAnchor:true, anchorClassOn:false});\\n    ReactTestUtils.renderIntoDocument(instance);\\n    instance.setProps({anchorClassOn: true});  \/\/ Warm any cache\\n    instance.setProps({renderAnchor: false});  \/\/ Clear out the anchor\\n    \/\/ rerender\\n    instance.setProps({renderAnchor: true, anchorClassOn: false});\\n    var anchorID = instance.getAnchorID();\\n    var actualDOMAnchorNode = ReactMount.getNode(anchorID);\\n    expect(actualDOMAnchorNode.className).toBe('');\\n  });\\n\\n  it('should auto bind methods and values correctly', function() {\\n    spyOn(console, 'warn');\\n\\n    var ComponentClass = React.createClass({displayName: 'ComponentClass',\\n      getInitialState: function() {\\n        return {valueToReturn: 'hi'};\\n      },\\n      methodToBeExplicitlyBound: function() {\\n        return this;\\n      },\\n      methodAutoBound: function() {\\n        return this;\\n      },\\n      methodExplicitlyNotBound: ReactDoNotBindDeprecated.doNotBind(function() {\\n        return this;\\n      }),\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n    var instance = ComponentClass(null );\\n\\n    \/\/ These are controversial assertions for now, they just exist\\n    \/\/ because existing code depends on these assumptions.\\n    expect(function() {\\n      instance.methodToBeExplicitlyBound.bind(instance)();\\n    }).not.toThrow();\\n    expect(function() {\\n      instance.methodAutoBound();\\n    }).not.toThrow();\\n    expect(function() {\\n      instance.methodExplicitlyNotBound();\\n    }).not.toThrow();\\n\\n    \/\/ Next, prove that once mounted, the scope is bound correctly to the actual\\n    \/\/ component.\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expect(console.warn.argsForCall.length).toBe(0);\\n    var explicitlyBound = instance.methodToBeExplicitlyBound.bind(instance);\\n    expect(console.warn.argsForCall.length).toBe(1);\\n    var autoBound = instance.methodAutoBound;\\n    var explicitlyNotBound = instance.methodExplicitlyNotBound;\\n\\n    var context = {};\\n    expect(explicitlyBound.call(context)).toBe(instance);\\n    expect(autoBound.call(context)).toBe(instance);\\n    expect(explicitlyNotBound.call(context)).toBe(context);\\n\\n    expect(explicitlyBound.call(instance)).toBe(instance);\\n    expect(autoBound.call(instance)).toBe(instance);\\n    expect(explicitlyNotBound.call(instance)).toBe(instance);\\n\\n  });\\n\\n  it('should use default values for undefined props', function() {\\n    var Component = React.createClass({displayName: 'Component',\\n      getDefaultProps: function() {\\n        return {key: 'testKey'};\\n      },\\n      render: function() {\\n        return React.DOM.span(null );\\n      }\\n    });\\n\\n    var instance1 = Component(null );\\n    ReactTestUtils.renderIntoDocument(instance1);\\n    reactComponentExpect(instance1).scalarPropsEqual({key: 'testKey'});\\n\\n    var instance2 = Component( {key:undefined} );\\n    ReactTestUtils.renderIntoDocument(instance2);\\n    reactComponentExpect(instance2).scalarPropsEqual({key: 'testKey'});\\n\\n    var instance3 = Component( {key:null} );\\n    ReactTestUtils.renderIntoDocument(instance3);\\n    reactComponentExpect(instance3).scalarPropsEqual({key: null});\\n  });\\n\\n  it('should normalize props with default values', function() {\\n    var Component = React.createClass({displayName: 'Component',\\n      propTypes: {key: ReactPropTypes.string.isRequired},\\n      getDefaultProps: function() {\\n        return {key: 'testKey'};\\n      },\\n      getInitialState: function() {\\n        return {key: this.props.key + 'State'};\\n      },\\n      render: function() {\\n        return React.DOM.span(null, this.props.key);\\n      }\\n    });\\n\\n    var instance = Component(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    reactComponentExpect(instance).scalarPropsEqual({key: 'testKey'});\\n    reactComponentExpect(instance).scalarStateEqual({key: 'testKeyState'});\\n\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(Component( {key:null} ));\\n    }).toThrow(\\n      'Invariant Violation: Required prop `key` was not specified in ' +\\n      '`Component`.'\\n    );\\n  });\\n\\n  it('should check default prop values', function() {\\n    var Component = React.createClass({displayName: 'Component',\\n      propTypes: {key: ReactPropTypes.string.isRequired},\\n      getDefaultProps: function() {\\n        return {key: null};\\n      },\\n      render: function() {\\n        return React.DOM.span(null, this.props.key);\\n      }\\n    });\\n\\n    var instance = Component(null );\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).toThrow(\\n      'Invariant Violation: Required prop `key` was not specified in ' +\\n      '`Component`.'\\n    );\\n  });\\n\\n  it('should check declared prop types', function() {\\n    var Component = React.createClass({displayName: 'Component',\\n      propTypes: {\\n        key: ReactPropTypes.string.isRequired\\n      },\\n      render: function() {\\n        return React.DOM.span(null, this.props.key);\\n      }\\n    });\\n\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(Component(null ));\\n    }).toThrow(\\n      'Invariant Violation: Required prop `key` was not specified in ' +\\n      '`Component`.'\\n    );\\n\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(Component( {key:42} ));\\n    }).toThrow(\\n      'Invariant Violation: Invalid prop `key` of type `number` supplied to ' +\\n      '`Component`, expected `string`.'\\n    );\\n\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(Component( {key:\\\"string\\\"} ));\\n    }).not.toThrow();\\n  });\\n\\n  it('should not allow `forceUpdate` on unmounted components', function() {\\n    var container = document.createElement('div');\\n    document.documentElement.appendChild(container);\\n\\n    var Component = React.createClass({displayName: 'Component',\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n\\n    var instance = Component(null );\\n    expect(function() {\\n      instance.forceUpdate();\\n    }).toThrow(\\n      'Invariant Violation: forceUpdate(...): Can only force an update on ' +\\n      'mounted or mounting components.'\\n    );\\n\\n    React.renderComponent(instance, container);\\n    expect(function() {\\n      instance.forceUpdate();\\n    }).not.toThrow();\\n\\n    React.unmountComponentAtNode(container);\\n    expect(function() {\\n      instance.forceUpdate();\\n    }).toThrow(\\n      'Invariant Violation: forceUpdate(...): Can only force an update on ' +\\n      'mounted or mounting components.'\\n    );\\n  });\\n\\n  it('should cleanup even if render() fatals', function() {\\n    var BadComponent = React.createClass({displayName: 'BadComponent',\\n      render: function() {\\n        throw new Error();\\n      }\\n    });\\n    var instance = BadComponent(null );\\n\\n    expect(ReactCurrentOwner.current).toBe(null);\\n\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).toThrow();\\n\\n    expect(ReactCurrentOwner.current).toBe(null);\\n  });\\n\\n  it('should support mixins with getInitialState()', function() {\\n    var Mixin = {\\n      getInitialState: function() {\\n        return {mixin: true};\\n      }\\n    };\\n    var Component = React.createClass({displayName: 'Component',\\n      mixins: [Mixin],\\n      getInitialState: function() {\\n        return {component: true};\\n      },\\n      render: function() {\\n        return React.DOM.span(null );\\n      }\\n    });\\n    var instance = Component(null );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expect(instance.state.component).toBe(true);\\n    expect(instance.state.mixin).toBe(true);\\n  });\\n\\n  it('should throw with conflicting getInitialState() methods', function() {\\n    var Mixin = {\\n      getInitialState: function() {\\n        return {x: true};\\n      }\\n    };\\n    var Component = React.createClass({displayName: 'Component',\\n      mixins: [Mixin],\\n      getInitialState: function() {\\n        return {x: true};\\n      },\\n      render: function() {\\n        return React.DOM.span(null );\\n      }\\n    });\\n    var instance = Component(null );\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).toThrow(\\n      'Invariant Violation: mergeObjectsWithNoDuplicateKeys(): ' +\\n      'Tried to merge two objects with the same key: x'\\n    );\\n  });\\n\\n  it('should throw with bad getInitialState() return values', function() {\\n    var Mixin = {\\n      getInitialState: function() {\\n        return null;\\n      }\\n    };\\n    var Component = React.createClass({displayName: 'Component',\\n      mixins: [Mixin],\\n      getInitialState: function() {\\n        return {x: true};\\n      },\\n      render: function() {\\n        return React.DOM.span(null );\\n      }\\n    });\\n    var instance = Component(null );\\n    expect(function() {\\n      ReactTestUtils.renderIntoDocument(instance);\\n    }).toThrow(\\n      'Invariant Violation: mergeObjectsWithNoDuplicateKeys(): ' +\\n      'Cannot merge non-objects'\\n    );\\n  });\\n\\n  it('should detect valid CompositeComponent classes', function() {\\n    var Component = React.createClass({displayName: 'Component',\\n      render: function() {\\n        return React.DOM.div(null);\\n      }\\n    });\\n\\n    expect(React.isValidClass(Component)).toBe(true);\\n  });\\n\\n  it('should detect invalid CompositeComponent classes', function() {\\n    var FnComponent = function() {\\n      return false;\\n    };\\n\\n    var NullComponent = null;\\n\\n    var TrickFnComponent = function() {\\n      return true;\\n    };\\n    TrickFnComponent.componentConstructor = true;\\n\\n    expect(React.isValidClass(FnComponent)).toBe(false);\\n    expect(React.isValidClass(NullComponent)).toBe(false);\\n    expect(React.isValidClass(TrickFnComponent)).toBe(false);\\n  });\\n\\n  it('should warn when mispelling shouldComponentUpdate', function() {\\n    var warn = console.warn;\\n    console.warn = mocks.getMockFunction();\\n\\n    try {\\n      React.createClass({\\n        componentShouldUpdate: function() {\\n          return false;\\n        },\\n        render: function() {\\n          return React.DOM.div(null );\\n        }\\n      });\\n      expect(console.warn.mock.calls.length).toBe(1);\\n      expect(console.warn.mock.calls[0][0]).toBe(\\n        'A component has a method called componentShouldUpdate(). Did you ' +\\n        'mean shouldComponentUpdate()? The name is phrased as a question ' +\\n        'because the function is expected to return a value.'\\n      );\\n\\n      var NamedComponent = React.createClass({displayName: 'NamedComponent',\\n        componentShouldUpdate: function() {\\n          return false;\\n        },\\n        render: function() {\\n          return React.DOM.div(null );\\n        }\\n      });\\n      expect(console.warn.mock.calls.length).toBe(2);\\n      expect(console.warn.mock.calls[1][0]).toBe(\\n        'NamedComponent has a method called componentShouldUpdate(). Did you ' +\\n        'mean shouldComponentUpdate()? The name is phrased as a question ' +\\n        'because the function is expected to return a value.'\\n      );\\n\\n      NamedComponent(); \/\/ Shut up lint\\n    } catch (e) {\\n      throw e;\\n    } finally {\\n      console.warn = warn;\\n    }\\n  });\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactCompositeComponent-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactCompositeComponentDOMMinimalism-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\n\/\/ Requires\\nvar React;\\nvar ReactTestUtils;\\nvar reactComponentExpect;\\n\\n\/\/ Test components\\nvar LowerLevelComposite;\\nvar MyCompositeComponent;\\n\\nvar expectSingleChildlessDiv;\\n\\n\/**\\n * Integration test, testing the combination of JSX with our unit of\\n * abstraction, `ReactCompositeComponent` does not ever add superfluous DOM\\n * nodes.\\n *\/\\ndescribe('ReactCompositeComponentDOMMinimalism', function() {\\n\\n  beforeEach(function() {\\n    reactComponentExpect = require(\\\"..\/..\/reactComponentExpect\\\");\\n    React = require(\\\"..\/..\/React\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n\\n    LowerLevelComposite = React.createClass({\\n      render: function() {\\n        return (\\n          React.DOM.div(null, \\n            this.props.children\\n          )\\n        );\\n      }\\n    });\\n\\n    MyCompositeComponent = React.createClass({\\n      render: function() {\\n        return (\\n          LowerLevelComposite(null, \\n            this.props.children\\n          )\\n        );\\n      }\\n    });\\n\\n    expectSingleChildlessDiv = function(instance) {\\n      reactComponentExpect(instance)\\n        .expectRenderedChild()\\n        .toBeCompositeComponentWithType(LowerLevelComposite)\\n          .expectRenderedChild()\\n          .toBeDOMComponentWithTag('div')\\n          .toBeDOMComponentWithNoChildren();\\n    };\\n  });\\n\\n  it('should not render extra nodes for non-interpolated text', function() {\\n    var instance = (\\n      MyCompositeComponent(null, \\n        \\\" A string child \\\"\\n      )\\n    );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expectSingleChildlessDiv(instance);\\n  });\\n\\n  it('should not render extra nodes for non-interpolated text', function() {\\n    var instance = (\\n      MyCompositeComponent(null, \\n        'Interpolated String Child'\\n      )\\n    );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    expectSingleChildlessDiv(instance);\\n  });\\n\\n  it('should not render extra nodes for non-interpolated text', function() {\\n    var instance = (\\n      MyCompositeComponent(null, \\n        React.DOM.ul(null, \\n          \\\" This text causes no children in ul, just innerHTML \\\"\\n        )\\n      )\\n    );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    reactComponentExpect(instance)\\n      .expectRenderedChild()\\n      .toBeCompositeComponentWithType(LowerLevelComposite)\\n        .expectRenderedChild()\\n        .toBeDOMComponentWithTag('div')\\n        .toBeDOMComponentWithChildCount(1)\\n        .expectRenderedChildAt(0)\\n          .toBeDOMComponentWithTag('ul')\\n          .toBeDOMComponentWithNoChildren();\\n  });\\n\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactCompositeComponentDOMMinimalism-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactCompositeComponentMixin-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar mocks = require(\\\"..\/..\/mocks\\\");\\n\\nvar React;\\nvar ReactTestUtils;\\nvar reactComponentExpect;\\n\\nvar TestComponent;\\nvar TestComponentWithPropTypes;\\nvar mixinPropValidator;\\nvar componentPropValidator;\\n\\ndescribe('ReactCompositeComponent-mixin', function() {\\n\\n  beforeEach(function() {\\n    React = require(\\\"..\/..\/React\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n    reactComponentExpect = require(\\\"..\/..\/reactComponentExpect\\\");\\n    mixinPropValidator = mocks.getMockFunction();\\n    componentPropValidator = mocks.getMockFunction();\\n\\n    var MixinA = {\\n      componentDidMount: function() {\\n        this.props.listener('MixinA didMount');\\n      }\\n    };\\n\\n    var MixinB = {\\n      mixins: [MixinA],\\n      componentDidMount: function() {\\n        this.props.listener('MixinB didMount');\\n      }\\n    };\\n\\n    var MixinC = {\\n      componentDidMount: function() {\\n        this.props.listener('MixinC didMount');\\n      }\\n    };\\n\\n    var MixinD = {\\n      propTypes: {\\n        value: mixinPropValidator\\n      }\\n    };\\n\\n    TestComponent = React.createClass({\\n      mixins: [MixinB, MixinC, MixinD],\\n\\n      componentDidMount: function() {\\n        this.props.listener('Component didMount');\\n      },\\n\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n\\n    TestComponentWithPropTypes = React.createClass({\\n      mixins: [MixinD],\\n      propTypes: {\\n        value: componentPropValidator\\n      },\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n  });\\n\\n  it('should support chaining delegate functions', function() {\\n    var listener = mocks.getMockFunction();\\n    var instance = TestComponent( {listener:listener} );\\n    ReactTestUtils.renderIntoDocument(instance);\\n\\n    expect(listener.mock.calls).toEqual([\\n      ['MixinA didMount'],\\n      ['MixinB didMount'],\\n      ['MixinC didMount'],\\n      ['Component didMount']\\n    ]);\\n  });\\n\\n  it('should validate prop types via mixins', function() {\\n    expect(TestComponent.componentConstructor.propTypes).toBeDefined();\\n    expect(TestComponent.componentConstructor.propTypes.value)\\n      .toBe(mixinPropValidator);\\n  });\\n\\n  it('should override mixin prop types with class prop types', function() {\\n    \/\/ Sanity check...\\n    expect(componentPropValidator).toNotBe(mixinPropValidator);\\n    \/\/ Actually check...\\n    expect(TestComponentWithPropTypes.componentConstructor.propTypes)\\n      .toBeDefined();\\n    expect(TestComponentWithPropTypes.componentConstructor.propTypes.value)\\n      .toNotBe(mixinPropValidator);\\n    expect(TestComponentWithPropTypes.componentConstructor.propTypes.value)\\n      .toBe(componentPropValidator);\\n  });\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactCompositeComponentMixin-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactCompositeComponentSpec-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar mocks = require(\\\"..\/..\/mocks\\\");\\n\\nvar React;\\nvar ReactTestUtils;\\nvar reactComponentExpect;\\n\\ndescribe('ReactCompositeComponent-spec', function() {\\n\\n  beforeEach(function() {\\n    React = require(\\\"..\/..\/React\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n    reactComponentExpect = require(\\\"..\/..\/reactComponentExpect\\\");\\n  });\\n\\n  it('should throw when `render` is not specified', function() {\\n    expect(function() {\\n      React.createClass({});\\n    }).toThrow(\\n      'Invariant Violation: createClass(...): Class specification must ' +\\n      'implement a `render` method.'\\n    );\\n  });\\n\\n  it('should copy `displayName` onto the Constructor', function() {\\n    var TestComponent = React.createClass({displayName: 'TestComponent',\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n\\n    expect(TestComponent.componentConstructor.displayName)\\n      .toBe('TestComponent');\\n  });\\n\\n  it('should copy prop types onto the Constructor', function() {\\n    var propValidator = mocks.getMockFunction();\\n    var TestComponent = React.createClass({displayName: 'TestComponent',\\n      propTypes: {\\n        value: propValidator\\n      },\\n      render: function() {\\n        return React.DOM.div(null );\\n      }\\n    });\\n\\n    expect(TestComponent.componentConstructor.propTypes).toBeDefined();\\n    expect(TestComponent.componentConstructor.propTypes.value)\\n      .toBe(propValidator);\\n  });\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactCompositeComponentSpec-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactCompositeComponentState-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar mocks = require(\\\"..\/..\/mocks\\\");\\n\\nvar React;\\nvar ReactTestUtils;\\nvar reactComponentExpect;\\n\\nvar TestComponent;\\n\\ndescribe('ReactCompositeComponent-state', function() {\\n\\n  beforeEach(function() {\\n    React = require(\\\"..\/..\/React\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n    reactComponentExpect = require(\\\"..\/..\/reactComponentExpect\\\");\\n\\n    TestComponent = React.createClass({\\n      peekAtState: function(from, state) {\\n        if (state) {\\n          this.props.stateListener(from, state && state.color);\\n        } else {\\n          this.props.stateListener(\\n            from,\\n            this.state && this.state.color,\\n            this._pendingState && this._pendingState.color\\n          );\\n        }\\n      },\\n\\n      setFavoriteColor: function(nextColor) {\\n        this.setState({color: nextColor});\\n      },\\n\\n      getInitialState: function() {\\n        this.peekAtState('getInitialState');\\n        return {color: 'red'};\\n      },\\n\\n      render: function() {\\n        this.peekAtState('render');\\n        return React.DOM.div(null, this.state.color);\\n      },\\n\\n      componentWillMount: function() {\\n        this.peekAtState('componentWillMount-start');\\n        this.setState({color: 'sunrise'});\\n        this.peekAtState('componentWillMount-after-sunrise');\\n        this.setState({color: 'orange'});\\n        this.peekAtState('componentWillMount-end');\\n      },\\n\\n      componentDidMount: function() {\\n        this.peekAtState('componentDidMount-start');\\n        this.setState({color: 'yellow'});\\n        this.peekAtState('componentDidMount-end');\\n      },\\n\\n      componentWillReceiveProps: function(newProps) {\\n        this.peekAtState('componentWillReceiveProps-start');\\n        if (newProps.nextColor) {\\n          this.setState({color: newProps.nextColor});\\n        }\\n        this.peekAtState('componentWillReceiveProps-end');\\n      },\\n\\n      shouldComponentUpdate: function(nextProps, nextState) {\\n        this.peekAtState('shouldComponentUpdate-currentState');\\n        this.peekAtState('shouldComponentUpdate-nextState', nextState);\\n        return true;\\n      },\\n\\n      componentWillUpdate: function(nextProps, nextState) {\\n        this.peekAtState('componentWillUpdate-currentState');\\n        this.peekAtState('componentWillUpdate-nextState', nextState);\\n      },\\n\\n      componentDidUpdate: function(prevProps, prevState) {\\n        this.peekAtState('componentDidUpdate-currentState');\\n        this.peekAtState('componentDidUpdate-prevState', prevState);\\n      },\\n\\n      componentWillUnmount: function() {\\n        this.peekAtState('componentWillUnmount');\\n      }\\n    });\\n\\n  });\\n\\n  it('should support setting state', function() {\\n    var stateListener = mocks.getMockFunction();\\n    var instance = TestComponent( {stateListener:stateListener} );\\n    ReactTestUtils.renderIntoDocument(instance);\\n    instance.setProps({nextColor: 'green'});\\n    instance.setFavoriteColor('blue');\\n    instance.forceUpdate();\\n    instance.unmountComponent();\\n\\n    expect(stateListener.mock.calls).toEqual([\\n      \/\/ there is no state when getInitialState() is called\\n      [ 'getInitialState', null, null ],\\n      [ 'componentWillMount-start', 'red', null ],\\n      \/\/ setState() only enqueues a pending state.\\n      [ 'componentWillMount-after-sunrise', 'red', 'sunrise' ],\\n      [ 'componentWillMount-end', 'red', 'orange' ],\\n      \/\/ pending state has been applied\\n      [ 'render', 'orange', null ],\\n      [ 'componentDidMount-start', 'orange', null ],\\n      \/\/ componentDidMount() called setState({color:'yellow'}), currently this\\n      \/\/ occurs inline.\\n      \/\/ In a future where setState() is async, this test result will change.\\n      [ 'shouldComponentUpdate-currentState', 'orange', null ],\\n      [ 'shouldComponentUpdate-nextState', 'yellow' ],\\n      [ 'componentWillUpdate-currentState', 'orange', null ],\\n      [ 'componentWillUpdate-nextState', 'yellow' ],\\n      [ 'render', 'yellow', null ],\\n      [ 'componentDidUpdate-currentState', 'yellow', null ],\\n      [ 'componentDidUpdate-prevState', 'orange' ],\\n      \/\/ componentDidMount() finally closes.\\n      [ 'componentDidMount-end', 'yellow', null ],\\n      [ 'componentWillReceiveProps-start', 'yellow', null ],\\n      \/\/ setState({color:'green'}) only enqueues a pending state.\\n      [ 'componentWillReceiveProps-end', 'yellow', 'green' ],\\n      [ 'shouldComponentUpdate-currentState', 'yellow', null ],\\n      [ 'shouldComponentUpdate-nextState', 'green' ],\\n      [ 'componentWillUpdate-currentState', 'yellow', null ],\\n      [ 'componentWillUpdate-nextState', 'green' ],\\n      [ 'render', 'green', null ],\\n      [ 'componentDidUpdate-currentState', 'green', null ],\\n      [ 'componentDidUpdate-prevState', 'yellow' ],\\n      \/\/ setFavoriteColor('blue')\\n      [ 'shouldComponentUpdate-currentState', 'green', null ],\\n      [ 'shouldComponentUpdate-nextState', 'blue' ],\\n      [ 'componentWillUpdate-currentState', 'green', null ],\\n      [ 'componentWillUpdate-nextState', 'blue' ],\\n      [ 'render', 'blue', null ],\\n      [ 'componentDidUpdate-currentState', 'blue', null ],\\n      [ 'componentDidUpdate-prevState', 'green' ],\\n      \/\/ forceUpdate()\\n      [ 'componentWillUpdate-currentState', 'blue', null ],\\n      [ 'componentWillUpdate-nextState', 'blue' ],\\n      [ 'render', 'blue', null ],\\n      [ 'componentDidUpdate-currentState', 'blue', null ],\\n      [ 'componentDidUpdate-prevState', 'blue' ],\\n      \/\/ unmountComponent()\\n      \/\/ state is available within `componentWillUnmount()`\\n      [ 'componentWillUnmount', 'blue', null ]\\n    ]);\\n  });\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactCompositeComponentState-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactDOM-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\/*jslint evil: true *\/\\n\\n\\\"use strict\\\";\\n\\nvar React = require(\\\"..\/..\/React\\\");\\nvar ReactDOM = require(\\\"..\/..\/ReactDOM\\\");\\nvar ReactMount = require(\\\"..\/..\/ReactMount\\\");\\nvar ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n\\ndescribe('ReactDOM', function() {\\n  \/\/ TODO: uncomment this test once we can run in phantom, which\\n  \/\/ supports real submit events.\\n  \/*\\n  it('should bubble onSubmit', function() {\\n    var count = 0;\\n    var form;\\n    var Parent = React.createClass({\\n      handleSubmit: function() {\\n        count++;\\n        return false;\\n      },\\n      render: function() {\\n        return ;\\n      }\\n    });\\n    var Child = React.createClass({\\n      render: function() {\\n        return <\/form>;\\n      },\\n      componentDidMount: function(node) {\\n        form = node;\\n      }\\n    });\\n    var instance = ReactTestUtils.renderIntoDocument();\\n    form.submit();\\n    expect(count).toEqual(1);\\n  });\\n  *\/\\n\\n  it(\\\"should allow children to be passed as an argument\\\", function() {\\n    var argDiv = ReactTestUtils.renderIntoDocument(\\n      ReactDOM.div(null, 'child')\\n    );\\n    var argNode = ReactMount.getNode(argDiv._rootNodeID);\\n    expect(argNode.innerHTML).toBe('child');\\n  });\\n\\n  it(\\\"should overwrite props.children with children argument\\\", function() {\\n    var conflictDiv = ReactTestUtils.renderIntoDocument(\\n      ReactDOM.div({children: 'fakechild'}, 'child')\\n    );\\n    var conflictNode = ReactMount.getNode(conflictDiv._rootNodeID);\\n    expect(conflictNode.innerHTML).toBe('child');\\n  });\\n\\n  \/**\\n   * We need to make sure that updates occur to the actual node that's in the\\n   * DOM, instead of a stale cache.\\n   *\/\\n  it(\\\"should purge the DOM cache when removing nodes\\\", function() {\\n    var myDiv = ReactTestUtils.renderIntoDocument(\\n      React.DOM.div(null, {\\n        theDog: React.DOM.div( {className:\\\"dog\\\"} ),\\n        theBird: React.DOM.div( {className:\\\"bird\\\"} )\\n      })\\n    );\\n    \/\/ Warm the cache with theDog\\n    myDiv.setProps({\\n      children: {\\n        theDog: React.DOM.div( {className:\\\"dogbeforedelete\\\"} ),\\n        theBird: React.DOM.div( {className:\\\"bird\\\"} )\\n      }\\n    });\\n    \/\/ Remove theDog - this should purge the cache\\n    myDiv.setProps({\\n      children: {\\n        theBird: React.DOM.div( {className:\\\"bird\\\"} )\\n      }\\n    });\\n    \/\/ Now, put theDog back. It's now a different DOM node.\\n    myDiv.setProps({\\n      children: {\\n        theDog: React.DOM.div( {className:\\\"dog\\\"} ),\\n        theBird: React.DOM.div( {className:\\\"bird\\\"} )\\n      }\\n    });\\n    \/\/ Change the className of theDog. It will use the same element\\n    myDiv.setProps({\\n      children: {\\n        theDog: React.DOM.div( {className:\\\"bigdog\\\"} ),\\n        theBird: React.DOM.div( {className:\\\"bird\\\"} )\\n      }\\n    });\\n    var root = ReactMount.getNode(myDiv._rootNodeID);\\n    var dog = root.childNodes[0];\\n    expect(dog.className).toBe('bigdog');\\n  });\\n\\n  it('should be a valid class', function() {\\n    expect(React.isValidClass(ReactDOM.div)).toBe(true);\\n  });\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactDOM-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactDOMComponent-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\/*jslint evil: true *\/\\n\\n\\\"use strict\\\";\\n\\nvar mocks = require(\\\"..\/..\/mocks\\\");\\n\\ndescribe('ReactDOMComponent', function() {\\n\\n  describe('updateDOM', function() {\\n    var React;\\n    var ReactTestUtils;\\n    var transaction;\\n\\n    beforeEach(function() {\\n      React = require(\\\"..\/..\/React\\\");\\n      ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n\\n      var ReactReconcileTransaction = require(\\\"..\/..\/ReactReconcileTransaction\\\");\\n      transaction = new ReactReconcileTransaction();\\n    });\\n\\n    it(\\\"should handle className\\\", function() {\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:{}} ));\\n\\n      stub.receiveProps({ className: 'foo' }, transaction);\\n      expect(stub.getDOMNode().className).toEqual('foo');\\n      stub.receiveProps({ className: 'bar' }, transaction);\\n      expect(stub.getDOMNode().className).toEqual('bar');\\n      stub.receiveProps({ className: null }, transaction);\\n      expect(stub.getDOMNode().className).toEqual('');\\n    });\\n\\n    it(\\\"should gracefully handle various style value types\\\", function() {\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:{}} ));\\n      var stubStyle = stub.getDOMNode().style;\\n\\n      \/\/ set initial style\\n      var setup = { display: 'block', left: '1', top: 2, fontFamily: 'Arial' };\\n      stub.receiveProps({ style: setup }, transaction);\\n      expect(stubStyle.display).toEqual('block');\\n      expect(stubStyle.left).toEqual('1px');\\n      expect(stubStyle.fontFamily).toEqual('Arial');\\n\\n      \/\/ reset the style to their default state\\n      var reset = { display: '', left: null, top: false, fontFamily: true };\\n      stub.receiveProps({ style: reset }, transaction);\\n      expect(stubStyle.display).toEqual('');\\n      expect(stubStyle.left).toEqual('');\\n      expect(stubStyle.top).toEqual('');\\n      expect(stubStyle.fontFamily).toEqual('');\\n    });\\n\\n    it(\\\"should update styles when mutating style object\\\", function() {\\n      var styles = { display: 'none', fontFamily: 'Arial', opacity: 0 };\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:styles} ));\\n\\n      var stubStyle = stub.getDOMNode().style;\\n      stubStyle.display = styles.display;\\n      stubStyle.fontFamily = styles.fontFamily;\\n\\n      styles.display = 'block';\\n\\n      stub.receiveProps({ style: styles }, transaction);\\n      expect(stubStyle.display).toEqual('block');\\n      expect(stubStyle.fontFamily).toEqual('Arial');\\n      expect(stubStyle.opacity).toEqual('0');\\n\\n      styles.fontFamily = 'Helvetica';\\n\\n      stub.receiveProps({ style: styles }, transaction);\\n      expect(stubStyle.display).toEqual('block');\\n      expect(stubStyle.fontFamily).toEqual('Helvetica');\\n      expect(stubStyle.opacity).toEqual('0');\\n\\n      styles.opacity = 0.5;\\n\\n      stub.receiveProps({ style: styles }, transaction);\\n      expect(stubStyle.display).toEqual('block');\\n      expect(stubStyle.fontFamily).toEqual('Helvetica');\\n      expect(stubStyle.opacity).toEqual('0.5');\\n    });\\n\\n    it(\\\"should update styles if initially null\\\", function() {\\n      var styles = null;\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:styles} ));\\n\\n      var stubStyle = stub.getDOMNode().style;\\n\\n      styles = {display: 'block'};\\n\\n      stub.receiveProps({ style: styles }, transaction);\\n      expect(stubStyle.display).toEqual('block');\\n    });\\n\\n    it(\\\"should remove attributes\\\", function() {\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.img( {height:\\\"17\\\"} ));\\n\\n      expect(stub.getDOMNode().hasAttribute('height')).toBe(true);\\n      stub.receiveProps({}, transaction);\\n      expect(stub.getDOMNode().hasAttribute('height')).toBe(false);\\n    });\\n\\n    it(\\\"should remove properties\\\", function() {\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {className:\\\"monkey\\\"} ));\\n\\n      expect(stub.getDOMNode().className).toEqual('monkey');\\n      stub.receiveProps({}, transaction);\\n      expect(stub.getDOMNode().className).toEqual('');\\n    });\\n\\n    it(\\\"should clear a single style prop when changing 'style'\\\", function() {\\n      var styles = {display: 'none', color: 'red'};\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:styles} ));\\n\\n      var stubStyle = stub.getDOMNode().style;\\n\\n      styles = {color: 'green'};\\n      stub.receiveProps({ style: styles }, transaction);\\n      expect(stubStyle.display).toEqual('');\\n      expect(stubStyle.color).toEqual('green');\\n    });\\n\\n    it(\\\"should clear all the styles when removing 'style'\\\", function() {\\n      var styles = {display: 'none', color: 'red'};\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:styles} ));\\n\\n      var stubStyle = stub.getDOMNode().style;\\n\\n      stub.receiveProps({}, transaction);\\n      expect(stubStyle.display).toEqual('');\\n      expect(stubStyle.color).toEqual('');\\n    });\\n\\n    it(\\\"should empty element when removing innerHTML\\\", function() {\\n      var stub = ReactTestUtils.renderIntoDocument(\\n        React.DOM.div( {dangerouslySetInnerHTML:{__html: ':)'}} )\\n      );\\n\\n      expect(stub.getDOMNode().innerHTML).toEqual(':)');\\n      stub.receiveProps({}, transaction);\\n      expect(stub.getDOMNode().innerHTML).toEqual('');\\n    });\\n\\n    it(\\\"should transition from string content to innerHTML\\\", function() {\\n      var stub = ReactTestUtils.renderIntoDocument(\\n        React.DOM.div(null, \\\"hello\\\")\\n      );\\n\\n      expect(stub.getDOMNode().innerHTML).toEqual('hello');\\n      stub.receiveProps(\\n        {dangerouslySetInnerHTML: {__html: 'goodbye'}},\\n        transaction\\n      );\\n      expect(stub.getDOMNode().innerHTML).toEqual('goodbye');\\n    });\\n\\n    it(\\\"should transition from innerHTML to string content\\\", function() {\\n      var stub = ReactTestUtils.renderIntoDocument(\\n        React.DOM.div( {dangerouslySetInnerHTML:{__html: 'bonjour'}} )\\n      );\\n\\n      expect(stub.getDOMNode().innerHTML).toEqual('bonjour');\\n      stub.receiveProps({children: 'adieu'}, transaction);\\n      expect(stub.getDOMNode().innerHTML).toEqual('adieu');\\n    });\\n\\n    it(\\\"should not incur unnecessary DOM mutations\\\", function() {\\n      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {value:\\\"\\\"} ));\\n\\n      var node = stub.getDOMNode();\\n      var nodeValue = node.value;\\n      var nodeValueSetter = mocks.getMockFunction();\\n      Object.defineProperty(node, 'value', {\\n        get: function() {\\n          return nodeValue;\\n        },\\n        set: nodeValueSetter.mockImplementation(function(newValue) {\\n          nodeValue = newValue;\\n        })\\n      });\\n\\n      stub.receiveProps({value: ''}, transaction);\\n      expect(nodeValueSetter.mock.calls.length).toBe(0);\\n\\n      stub.receiveProps({}, transaction);\\n      expect(nodeValueSetter.mock.calls.length).toBe(1);\\n    });\\n  });\\n\\n  describe('createOpenTagMarkup', function() {\\n    var genMarkup;\\n\\n    function quoteRegexp(str) {\\n      return (str+'').replace(\/([.?*+\\\\^$\\\\[\\\\]\\\\\\\\(){}|-])\/g, \\\"\\\\\\\\$1\\\");\\n    }\\n\\n    beforeEach(function() {\\n      require(\\\"..\/..\/mock-modules\\\").dumpCache();\\n\\n      var ReactDefaultInjection = require(\\\"..\/..\/ReactDefaultInjection\\\");\\n      ReactDefaultInjection.inject();\\n\\n      var mixInto = require(\\\"..\/..\/mixInto\\\");\\n      var ReactDOMComponent = require(\\\"..\/..\/ReactDOMComponent\\\");\\n\\n      var NodeStub = function(initialProps) {\\n        this.props = initialProps || {};\\n        this._rootNodeID = 'test';\\n      };\\n      mixInto(NodeStub, ReactDOMComponent.Mixin);\\n\\n      genMarkup = function(props) {\\n        return (new NodeStub(props))._createOpenTagMarkup();\\n      };\\n\\n      this.addMatchers({\\n        toHaveAttribute: function(attr, value) {\\n          var expected = '(?:^|\\\\\\\\s)' + attr + '=[\\\\\\\\\\\\'\\\"]';\\n          if (typeof value != 'undefined') {\\n            expected += quoteRegexp(value) + '[\\\\\\\\\\\\'\\\"]';\\n          }\\n          return this.actual.match(new RegExp(expected));\\n        }\\n      });\\n    });\\n\\n    it(\\\"should generate the correct markup with className\\\", function() {\\n      expect(genMarkup({ className: 'a' })).toHaveAttribute('class', 'a');\\n      expect(genMarkup({ className: 'a b' })).toHaveAttribute('class', 'a b');\\n      expect(genMarkup({ className: '' })).toHaveAttribute('class', '');\\n    });\\n  });\\n\\n  describe('createContentMarkup', function() {\\n    var genMarkup;\\n\\n    function quoteRegexp(str) {\\n      return (str+'').replace(\/([.?*+\\\\^$\\\\[\\\\]\\\\\\\\(){}|-])\/g, \\\"\\\\\\\\$1\\\");\\n    }\\n\\n    beforeEach(function() {\\n      require(\\\"..\/..\/mock-modules\\\").dumpCache();\\n\\n      var mixInto = require(\\\"..\/..\/mixInto\\\");\\n      var ReactDOMComponent = require(\\\"..\/..\/ReactDOMComponent\\\");\\n      var ReactReconcileTransaction = require(\\\"..\/..\/ReactReconcileTransaction\\\");\\n\\n      var NodeStub = function(initialProps) {\\n        this.props = initialProps || {};\\n        this._rootNodeID = 'test';\\n      };\\n      mixInto(NodeStub, ReactDOMComponent.Mixin);\\n\\n      genMarkup = function(props) {\\n        var transaction = new ReactReconcileTransaction();\\n        return (new NodeStub(props))._createContentMarkup(transaction);\\n      };\\n\\n      this.addMatchers({\\n        toHaveInnerhtml: function(html) {\\n          var expected = '^' + quoteRegexp(html) + '$';\\n          return this.actual.match(new RegExp(expected));\\n        }\\n      });\\n    });\\n\\n    it(\\\"should handle dangerouslySetInnerHTML\\\", function() {\\n      var innerHTML = {__html: 'testContent'};\\n      expect(\\n        genMarkup({ dangerouslySetInnerHTML: innerHTML })\\n      ).toHaveInnerhtml('testContent');\\n    });\\n  });\\n\\n  describe('mountComponent', function() {\\n    var mountComponent;\\n\\n    beforeEach(function() {\\n      require(\\\"..\/..\/mock-modules\\\").dumpCache();\\n\\n      var mixInto = require(\\\"..\/..\/mixInto\\\");\\n      var ReactComponent = require(\\\"..\/..\/ReactComponent\\\");\\n      var ReactMultiChild = require(\\\"..\/..\/ReactMultiChild\\\");\\n      var ReactDOMComponent = require(\\\"..\/..\/ReactDOMComponent\\\");\\n      var ReactReconcileTransaction = require(\\\"..\/..\/ReactReconcileTransaction\\\");\\n\\n      var StubNativeComponent = function(initialProps) {\\n        ReactComponent.Mixin.construct.call(this, initialProps);\\n      };\\n      mixInto(StubNativeComponent, ReactComponent.Mixin);\\n      mixInto(StubNativeComponent, ReactDOMComponent.Mixin);\\n      mixInto(StubNativeComponent, ReactMultiChild.Mixin);\\n\\n      mountComponent = function(props) {\\n        var transaction = new ReactReconcileTransaction();\\n        var stubComponent = new StubNativeComponent(props);\\n        return stubComponent.mountComponent('test', transaction, 0);\\n      };\\n    });\\n\\n    it(\\\"should validate against multiple children props\\\", function() {\\n      expect(function() {\\n        mountComponent({ children: '', dangerouslySetInnerHTML: '' });\\n      }).toThrow(\\n        'Invariant Violation: Can only set one of `children` or ' +\\n        '`props.dangerouslySetInnerHTML`.'\\n      );\\n    });\\n\\n    it(\\\"should validate against invalid styles\\\", function() {\\n      expect(function() {\\n        mountComponent({ style: 'display: none' });\\n      }).toThrow(\\n        'Invariant Violation: The `style` prop expects a mapping from style ' +\\n        'properties to values, not a string.'\\n      );\\n    });\\n  });\\n\\n  describe('unmountComponent', function() {\\n    it(\\\"should clean up listeners\\\", function() {\\n      var React = require(\\\"..\/..\/React\\\");\\n      var ReactEventEmitter = require(\\\"..\/..\/ReactEventEmitter\\\");\\n      var ReactMount = require(\\\"..\/..\/ReactMount\\\");\\n\\n      var container = document.createElement('div');\\n      document.documentElement.appendChild(container);\\n\\n      var callback = function() {};\\n      var instance = React.DOM.div( {onClick:callback} );\\n      React.renderComponent(instance, container);\\n\\n      var rootNode = instance.getDOMNode();\\n      var rootNodeID = ReactMount.getID(rootNode);\\n      expect(\\n        ReactEventEmitter.getListener(rootNodeID, 'onClick')\\n      ).toBe(callback);\\n\\n      React.unmountComponentAtNode(container);\\n\\n      expect(\\n        ReactEventEmitter.getListener(rootNodeID, 'onClick')\\n      ).toBe(undefined);\\n    });\\n  });\\n\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactDOMComponent-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactDOMIDOperations-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @emails react-core\\n *\/\\n\\n\/*jslint evil: true *\/\\n\\n\\\"use strict\\\";\\n\\ndescribe('ReactDOMIDOperations', function() {\\n  var DOMPropertyOperations = require(\\\"..\/..\/DOMPropertyOperations\\\");\\n  var ReactDOMIDOperations = require(\\\"..\/..\/ReactDOMIDOperations\\\");\\n  var ReactMount = require(\\\"..\/..\/ReactMount\\\");\\n  var keyOf = require(\\\"..\/..\/keyOf\\\");\\n\\n  it('should disallow updating special properties', function() {\\n    spyOn(ReactMount, \\\"getNode\\\");\\n    spyOn(DOMPropertyOperations, \\\"setValueForProperty\\\");\\n\\n    expect(function() {\\n      ReactDOMIDOperations.updatePropertyByID(\\n        'testID',\\n        keyOf({dangerouslySetInnerHTML: null}),\\n        {__html: 'testContent'}\\n      );\\n    }).toThrow();\\n\\n    expect(\\n      ReactMount.getNode.argsForCall[0][0]\\n    ).toBe('testID');\\n\\n    expect(\\n      DOMPropertyOperations.setValueForProperty.callCount\\n    ).toBe(0);\\n  });\\n\\n  it('should update innerHTML and special-case whitespace', function() {\\n    var stubNode = document.createElement('div');\\n    spyOn(ReactMount, \\\"getNode\\\").andReturn(stubNode);\\n\\n    ReactDOMIDOperations.updateInnerHTMLByID(\\n      'testID',\\n      ' testContent'\\n    );\\n\\n    expect(\\n      ReactMount.getNode.argsForCall[0][0]\\n    ).toBe('testID');\\n\\n    expect(stubNode.innerHTML).toBe(' testContent');\\n  });\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactDOMIDOperations-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactEventEmitter-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nrequire(\\\"..\/..\/mock-modules\\\")\\n    .dontMock('BrowserScroll')\\n    .dontMock('CallbackRegistry')\\n    .dontMock('EventPluginHub')\\n    .dontMock('ReactMount')\\n    .dontMock('ReactEventEmitter')\\n    .dontMock('ReactInstanceHandles')\\n    .dontMock('EventPluginHub')\\n    .dontMock('TapEventPlugin')\\n    .dontMock('TouchEventUtils')\\n    .dontMock('keyOf');\\n\\n\\nvar keyOf = require(\\\"..\/..\/keyOf\\\");\\nvar mocks = require(\\\"..\/..\/mocks\\\");\\n\\nvar EventPluginHub;\\nvar ReactMount = require(\\\"..\/..\/ReactMount\\\");\\nvar getID = ReactMount.getID;\\nvar setID = ReactMount.setID;\\nvar ReactEventEmitter;\\nvar ReactTestUtils;\\nvar TapEventPlugin;\\n\\nvar tapMoveThreshold;\\nvar idCallOrder = [];\\nvar recordID = function(id) {\\n  idCallOrder.push(id);\\n};\\nvar recordIDAndStopPropagation = function(id, event) {\\n  recordID(id);\\n  event.stopPropagation();\\n};\\nvar recordIDAndReturnFalse = function(id, event) {\\n  recordID(id);\\n  return false;\\n};\\nvar LISTENER = mocks.getMockFunction();\\nvar ON_CLICK_KEY = keyOf({onClick: null});\\nvar ON_TOUCH_TAP_KEY = keyOf({onTouchTap: null});\\n\\n\\n\/**\\n * Since `ReactEventEmitter` is fairly well separated from the DOM, we can test\\n * almost all of `ReactEventEmitter` without ever rendering anything in the DOM.\\n * As long as we provide IDs that follow `React's` conventional id namespace\\n * hierarchy. The only reason why we create these DOM nodes, is so that when we\\n * feed them into `ReactEventEmitter` (through `ReactTestUtils`), the event\\n * handlers may receive a DOM node to inspect.\\n *\/\\nvar CHILD = document.createElement('div');\\nvar PARENT = document.createElement('div');\\nvar GRANDPARENT = document.createElement('div');\\nsetID(CHILD, '.reactRoot.[0].[0].[0]');\\nsetID(PARENT, '.reactRoot.[0].[0]');\\nsetID(GRANDPARENT, '.reactRoot.[0]');\\n\\nfunction registerSimpleTestHandler() {\\n  ReactEventEmitter.putListener(getID(CHILD), ON_CLICK_KEY, LISTENER);\\n  var listener = ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);\\n  expect(listener).toEqual(LISTENER);\\n  return ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);\\n}\\n\\n\\ndescribe('ReactEventEmitter', function() {\\n  beforeEach(function() {\\n    require(\\\"..\/..\/mock-modules\\\").dumpCache();\\n    EventPluginHub = require(\\\"..\/..\/EventPluginHub\\\");\\n    TapEventPlugin = require(\\\"..\/..\/TapEventPlugin\\\");\\n    ReactMount = require(\\\"..\/..\/ReactMount\\\");\\n    getID = ReactMount.getID;\\n    setID = ReactMount.setID;\\n    ReactEventEmitter = require(\\\"..\/..\/ReactEventEmitter\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n    idCallOrder = [];\\n    tapMoveThreshold = TapEventPlugin.tapMoveThreshold;\\n    ReactEventEmitter.ensureListening(false, document);\\n    EventPluginHub.injection.injectEventPluginsByName({\\n      TapEventPlugin: TapEventPlugin\\n    });\\n  });\\n\\n  it('should store a listener correctly', function() {\\n    registerSimpleTestHandler();\\n    var listener = ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);\\n    expect(listener).toBe(LISTENER);\\n  });\\n\\n  it('should retrieve a listener correctly', function() {\\n    registerSimpleTestHandler();\\n    var listener = ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);\\n    expect(listener).toEqual(LISTENER);\\n  });\\n\\n  it('should clear all handlers when asked to', function() {\\n    registerSimpleTestHandler();\\n    ReactEventEmitter.deleteAllListeners(getID(CHILD));\\n    var listener = ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);\\n    expect(listener).toBe(undefined);\\n  });\\n\\n  it('should invoke a simple handler registered on a node', function() {\\n    registerSimpleTestHandler();\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(LISTENER.mock.calls.length).toBe(1);\\n  });\\n\\n  it('should not invoke handlers if ReactEventEmitter is disabled', function() {\\n    registerSimpleTestHandler();\\n    ReactEventEmitter.setEnabled(false);\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(LISTENER.mock.calls.length).toBe(0);\\n    ReactEventEmitter.setEnabled(true);\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(LISTENER.mock.calls.length).toBe(1);\\n  });\\n\\n  it('should bubble simply', function() {\\n    ReactEventEmitter.putListener(\\n      getID(CHILD),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(CHILD))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(PARENT),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(PARENT))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(GRANDPARENT),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(GRANDPARENT))\\n    );\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(idCallOrder.length).toBe(3);\\n    expect(idCallOrder[0]).toBe(getID(CHILD));\\n    expect(idCallOrder[1]).toBe(getID(PARENT));\\n    expect(idCallOrder[2]).toBe(getID(GRANDPARENT));\\n  });\\n\\n  it('should support stopPropagation()', function() {\\n    ReactEventEmitter.putListener(\\n      getID(CHILD),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(CHILD))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(PARENT),\\n      ON_CLICK_KEY,\\n      recordIDAndStopPropagation.bind(null, getID(PARENT))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(GRANDPARENT),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(GRANDPARENT))\\n    );\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(idCallOrder.length).toBe(2);\\n    expect(idCallOrder[0]).toBe(getID(CHILD));\\n    expect(idCallOrder[1]).toBe(getID(PARENT));\\n  });\\n\\n  it('should stop after first dispatch if stopPropagation', function() {\\n    ReactEventEmitter.putListener(\\n      getID(CHILD),\\n      ON_CLICK_KEY,\\n      recordIDAndStopPropagation.bind(null, getID(CHILD))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(PARENT),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(PARENT))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(GRANDPARENT),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(GRANDPARENT))\\n    );\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(idCallOrder.length).toBe(1);\\n    expect(idCallOrder[0]).toBe(getID(CHILD));\\n  });\\n\\n  it('should stopPropagation if false is returned', function() {\\n    ReactEventEmitter.putListener(\\n      getID(CHILD),\\n      ON_CLICK_KEY,\\n      recordIDAndReturnFalse.bind(null, getID(CHILD))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(PARENT),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(PARENT))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(GRANDPARENT),\\n      ON_CLICK_KEY,\\n      recordID.bind(null, getID(GRANDPARENT))\\n    );\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(idCallOrder.length).toBe(1);\\n    expect(idCallOrder[0]).toBe(getID(CHILD));\\n  });\\n\\n  \/**\\n   * The entire event registration state of the world should be \\\"locked-in\\\" at\\n   * the time the event occurs. This is to resolve many edge cases that come\\n   * about from a listener on a lower-in-DOM node causing structural changes at\\n   * places higher in the DOM. If this lower-in-DOM node causes new content to\\n   * be rendered at a place higher-in-DOM, we need to be careful not to invoke\\n   * these new listeners.\\n   *\/\\n\\n  it('should invoke handlers that were removed while bubbling', function() {\\n    var handleParentClick = mocks.getMockFunction();\\n    var handleChildClick = function(event) {\\n      ReactEventEmitter.deleteAllListeners(getID(PARENT));\\n    };\\n    ReactEventEmitter.putListener(getID(CHILD), ON_CLICK_KEY, handleChildClick);\\n    ReactEventEmitter.putListener(\\n      getID(PARENT),\\n      ON_CLICK_KEY,\\n      handleParentClick\\n    );\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(handleParentClick.mock.calls.length).toBe(1);\\n  });\\n\\n  it('should not invoke newly inserted handlers while bubbling', function() {\\n    var handleParentClick = mocks.getMockFunction();\\n    var handleChildClick = function(event) {\\n      ReactEventEmitter.putListener(\\n        getID(PARENT),\\n        ON_CLICK_KEY,\\n        handleParentClick\\n      );\\n    };\\n    ReactEventEmitter.putListener(getID(CHILD), ON_CLICK_KEY, handleChildClick);\\n    ReactTestUtils.Simulate.click(CHILD);\\n    expect(handleParentClick.mock.calls.length).toBe(0);\\n  });\\n\\n  it('should infer onTouchTap from a touchStart\/End', function() {\\n    ReactEventEmitter.putListener(\\n      getID(CHILD),\\n      ON_TOUCH_TAP_KEY,\\n      recordID.bind(null, getID(CHILD))\\n    );\\n    ReactTestUtils.Simulate.touchStart(\\n      CHILD,\\n      ReactTestUtils.nativeTouchData(0, 0)\\n    );\\n    ReactTestUtils.Simulate.touchEnd(\\n      CHILD,\\n      ReactTestUtils.nativeTouchData(0, 0)\\n    );\\n    expect(idCallOrder.length).toBe(1);\\n    expect(idCallOrder[0]).toBe(getID(CHILD));\\n  });\\n\\n  it('should infer onTouchTap from when dragging below threshold', function() {\\n    ReactEventEmitter.putListener(\\n      getID(CHILD),\\n      ON_TOUCH_TAP_KEY,\\n      recordID.bind(null, getID(CHILD))\\n    );\\n    ReactTestUtils.Simulate.touchStart(\\n      CHILD,\\n      ReactTestUtils.nativeTouchData(0, 0)\\n    );\\n    ReactTestUtils.Simulate.touchEnd(\\n      CHILD,\\n      ReactTestUtils.nativeTouchData(0, tapMoveThreshold - 1)\\n    );\\n    expect(idCallOrder.length).toBe(1);\\n    expect(idCallOrder[0]).toBe(getID(CHILD));\\n  });\\n\\n  it('should not onTouchTap from when dragging beyond threshold', function() {\\n    ReactEventEmitter.putListener(\\n      getID(CHILD),\\n      ON_TOUCH_TAP_KEY,\\n      recordID.bind(null, getID(CHILD))\\n    );\\n    ReactTestUtils.Simulate.touchStart(\\n      CHILD,\\n      ReactTestUtils.nativeTouchData(0, 0)\\n    );\\n    ReactTestUtils.Simulate.touchEnd(\\n      CHILD,\\n      ReactTestUtils.nativeTouchData(0, tapMoveThreshold + 1)\\n    );\\n    expect(idCallOrder.length).toBe(0);\\n  });\\n\\n\\n  it('should bubble onTouchTap', function() {\\n    ReactEventEmitter.putListener(\\n      getID(CHILD),\\n      ON_TOUCH_TAP_KEY,\\n      recordID.bind(null, getID(CHILD))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(PARENT),\\n      ON_TOUCH_TAP_KEY,\\n      recordID.bind(null, getID(PARENT))\\n    );\\n    ReactEventEmitter.putListener(\\n      getID(GRANDPARENT),\\n      ON_TOUCH_TAP_KEY,\\n      recordID.bind(null, getID(GRANDPARENT))\\n    );\\n    ReactTestUtils.Simulate.touchStart(\\n      CHILD,\\n      ReactTestUtils.nativeTouchData(0, 0)\\n    );\\n    ReactTestUtils.Simulate.touchEnd(\\n      CHILD,\\n      ReactTestUtils.nativeTouchData(0, 0)\\n    );\\n    expect(idCallOrder.length).toBe(3);\\n    expect(idCallOrder[0]).toBe(getID(CHILD));\\n    expect(idCallOrder[1]).toBe(getID(PARENT));\\n    expect(idCallOrder[2]).toBe(getID(GRANDPARENT));\\n  });\\n\\n});\\n\\nrequire(\\\"..\/..\/mock-modules\\\").register(\\\"core\/__tests__\/ReactEventEmitter-test\\\", module);\\n\",\n+\"core\/__tests__\/ReactIdentity-test\":\"\/**\\n * Copyright 2013 Facebook, Inc.\\n *\\n * Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n * you may not use this file except in compliance with the License.\\n * You may obtain a copy of the License at\\n *\\n * http:\/\/www.apache.org\/licenses\/LICENSE-2.0\\n *\\n * Unless required by applicable law or agreed to in writing, software\\n * distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n * See the License for the specific language governing permissions and\\n * limitations under the License.\\n *\\n * @jsx React.DOM\\n * @emails react-core\\n *\/\\n\\n\\\"use strict\\\";\\n\\nvar React;\\nvar ReactTestUtils;\\nvar reactComponentExpect;\\nvar ReactMount;\\n\\ndescribe('ReactIdentity', function() {\\n\\n  beforeEach(function() {\\n    require(\\\"..\/..\/mock-modules\\\").dumpCache();\\n    React = require(\\\"..\/..\/React\\\");\\n    ReactTestUtils = require(\\\"..\/..\/ReactTestUtils\\\");\\n    reactComponentExpect = require(\\\"..\/..\/reactComponentExpect\\\");\\n    ReactMount = require(\\\"..\/..\/ReactMount\\\");\\n  });\\n\\n  var idExp = \/^\\\\.r\\\\[.+?\\\\](.*)$\/;\\n  function checkId(child, expectedId) {\\n    var actual = idExp.exec(ReactMount.getID(child));\\n    var expected = idExp.exec(expectedId);\\n    expect(actual).toBeTruthy();\\n    expect(expected).toBeTruthy();\\n    expect(actual[1]).toEqual(expected[1]);\\n  }\\n\\n  it('should allow keyed objects to express identity', function() {\\n    var instance =\\n      React.DOM.div(null, \\n        {\\n          first: React.DOM.div(null ),\\n          second: React.DOM.div(null )\\n        }\\n      );\\n\\n    React.renderComponent(instance, document.createElement('div'));\\n    var node = instance.getDOMNode();\\n    reactComponentExpect(instance).toBeDOMComponentWithChildCount(2);\\n    checkId(node.childNodes[0], '.r[0].{first}');\\n    checkId(node.childNodes[1], '.r[0].{second}');\\n  });\\n\\n  it('should allow key property to express identity', function() {\\n    var instance =\\n      React.DOM.div(null, \\n        React.DOM.div( {key:\\\"apple\\\"} ),\\n        React.DOM.div( {key:\\\"banana\\\"} ),\\n        React.DOM.div( {key:0} ),\\n        React.DOM.div( {key:123} )\\n      );\\n\\n    React.renderComponent(instance, document.createElement('div'));\\n    var node = instance.getDOMNode();\\n    reactComponentExpect(instance).toBeDOMComponentWithChildCount(4);\\n    checkId(node.childNodes[0], '.r[0].{apple}');\\n    checkId(node.childNodes[1], '.r[0].{banana}');\\n    checkId(node.childNodes[2], '.r[0].{0}');\\n    checkId(node.childNodes[3], '.r[0].{123}');\\n  });\\n\\n  it('should use instance identity', function() {\\n\\n    var Wrapper = React.createClass({displayName: 'Wrapper',\\n      render: function() {\\n        return React.DOM.a( {key:\\\"i_get_overwritten\\\"}, this.props.children);\\n      }\\n    });\\n\\n    var instance =\\n      React.DOM.div(null, \\n        Wrapper( {key:\\\"wrap1\\\"}, React.DOM.span( {key:\\\"squirrel\\\"} )),\\n        Wrapper( {key:\\\"wrap2\\\"}, React.DOM.span( {key:\\\"bunny\\\"} )),\\n        Wrapper(null, React.DOM.span( {key:\\\"chipmunk\\\"} ))\\n      );\\n\\n    React.renderComponent(instance, document.createElement('div'));\\n    var node = instance.getDOMNode();\\n    reactComponentExpect(instance).toBeDOMComponentWithChildCount(3);\\n\\n    checkId(node.childNodes[0], '.r[0].{wrap1}');\\n    checkId(node.childNodes[0].firstChild, '.r[0].{wrap1}.{squirrel}');\\n    checkId(node.childNodes[1], '.r[0].{wrap2}');\\n    checkId(node.childNodes[1].firstChild, '.r[0].{wrap2}.{bunny}');\\n    checkId(node.childNodes[2], '.r[0].[2]');\\n    checkId(node.childNodes[2].firstChild, '.r[0].[2].{chipmunk}');\\n  });\\n\\n  function renderAComponentWithKeyIntoContainer(key, container) {\\n    var span1 = React.DOM.span( {key:key} );\\n    var span2 = React.DOM.span(null );\\n\\n    var map = {};\\n    map[key] = span2;\\n\\n    React.renderComponent(React.DOM.div(null, [span1, map]), container);\\n\\n    expect(span1.getDOMNode()).not.toBe(null);\\n    expect(span2.getDOMNode()).not.toBe(null);\\n\\n    checkId(span1.getDOMNode(), '.r[0].{' + key + '}');\\n    checkId(span2.getDOMNode(), '.r[0].[1]{' + key + '}');\\n  }\\n\\n  it('should allow any character as a key, in a detached parent', function() {\\n    var detachedContainer = document.createElement('div');\\n    renderAComponentWithKeyIntoContainer(\\\"<'WEIRD\/&\\\\\\\\key'>\\\", detachedContainer);\\n  });\\n\\n  it('should allow any character as a key, in an attached parent', function() {\\n    \/\/ This test exists to protect against implementation details that\\n    \/\/ incorrectly query escaped IDs using DOM tools like getElementById.\\n    var attachedContainer = document.createElement('div');\\n    document.body.appendChild(attachedContainer);\\n\\n    renderAComponentWithKeyIntoContainer(\\\"<'WEIRD\/&\\\\\\\\key'>\\\", attachedContainer);\\n\\n    document.body.removeChild(attachedContainer);\\n  });\\n\\n  it('should not allow scripts in keys to execute', function() {\\n    var h4x0rKey = '\\\">
dillon1000/react

Files changed
