You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jspwiki.apache.org by br...@apache.org on 2009/09/26 15:22:32 UTC
svn commit: r819134 [1/2] - in /incubator/jspwiki/trunk/tests/javascript: ./
assets/ assets/images/
Author: brushed
Date: Sat Sep 26 13:22:31 2009
New Revision: 819134
URL: http://svn.apache.org/viewvc?rev=819134&view=rev
Log:
Javascript unit-tests based on Jasmine.
Added:
incubator/jspwiki/trunk/tests/javascript/
incubator/jspwiki/trunk/tests/javascript/assets/
incubator/jspwiki/trunk/tests/javascript/assets/TrivialReporter.js (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/
incubator/jspwiki/trunk/tests/javascript/assets/images/fail-16.png (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/fail.png (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/go-16.png (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/go.png (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/pending-16.png (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/pending.png (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/question-bk.png (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/questionbk-16.png (with props)
incubator/jspwiki/trunk/tests/javascript/assets/images/spinner.gif (with props)
incubator/jspwiki/trunk/tests/javascript/assets/jasmine-0.9.0.js (with props)
incubator/jspwiki/trunk/tests/javascript/assets/jasmine-jspwiki.css
incubator/jspwiki/trunk/tests/javascript/assets/jasmine.css (with props)
incubator/jspwiki/trunk/tests/javascript/assets/json2.js (with props)
incubator/jspwiki/trunk/tests/javascript/jasmine-runner.html
incubator/jspwiki/trunk/tests/javascript/spec-dialog.js
incubator/jspwiki/trunk/tests/javascript/spec-documoo.js
incubator/jspwiki/trunk/tests/javascript/spec-jspwiki-common.js
incubator/jspwiki/trunk/tests/javascript/spec-jspwiki-edit.js
Added: incubator/jspwiki/trunk/tests/javascript/assets/TrivialReporter.js
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/TrivialReporter.js?rev=819134&view=auto
==============================================================================
--- incubator/jspwiki/trunk/tests/javascript/assets/TrivialReporter.js (added)
+++ incubator/jspwiki/trunk/tests/javascript/assets/TrivialReporter.js Sat Sep 26 13:22:31 2009
@@ -0,0 +1,134 @@
+jasmine.TrivialReporter = function(doc) {
+ this.document = doc || document;
+ this.suiteDivs = {};
+};
+
+jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
+ var el = document.createElement(type);
+
+ for (var i = 2; i < arguments.length; i++) {
+ var child = arguments[i];
+
+ if (typeof child === 'string') {
+ el.appendChild(document.createTextNode(child));
+ } else {
+ el.appendChild(child);
+ }
+ }
+
+ for (var attr in attrs) {
+ if (attr == 'className') {
+ el.setAttribute('class', attrs[attr]);
+ } else {
+ el[attr] = attrs[attr];
+ }
+ }
+
+ return el;
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
+ var suites = runner.getAllSuites();
+
+ this.runnerDiv = this.createDom(
+ 'div', { className: 'runner running' },
+ "Running...");
+ this.document.body.appendChild(this.runnerDiv);
+
+ for (var i = 0; i < suites.length; i++) {
+ var suite = suites[i];
+ var suiteDiv = this.createDom('div', { className: 'suite' },
+ this.createDom('a', { className: 'runSpec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
+ suite.description);
+ this.suiteDivs[suite.getFullName()] = suiteDiv;
+ var parentDiv = this.document.body;
+ if (suite.parentSuite) {
+ parentDiv = this.suiteDivs[suite.parentSuite.getFullName()];
+ }
+ parentDiv.appendChild(suiteDiv);
+ }
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
+ var results = runner.getResults();
+ var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
+ this.runnerDiv.setAttribute("class", className);
+ var message = results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
+ message += ", "+results.totalCount+" specs run"; //*********
+ message += ", "+results.passedCount+" specs passed"; //********
+
+ this.runnerDiv.replaceChild(this.document.createTextNode(message), this.runnerDiv.firstChild);
+
+ this.runnerDiv.appendChild( //************
+ this.createDom('a', { className: 'runSpec', href: '?' }, "run all")
+ )
+
+};
+
+jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
+ var results = suite.getResults();
+ var status = results.passed() ? 'passed' : 'failed';
+ if (results.totalCount == 0) { // todo: change this to check results.skipped
+ status = 'skipped';
+ }
+ this.suiteDivs[suite.getFullName()].className += " " + status;
+};
+
+jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
+ var results = spec.getResults();
+ var status = results.passed() ? 'passed' : 'failed';
+ if (results.skipped) {
+ status = 'skipped';
+ }
+ var specDiv = this.createDom('div', { className: 'spec ' + status },
+ this.createDom('a', { className: 'runSpec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
+ spec.getFullName());
+
+
+ var resultItems = results.getItems();
+ for (var i = 0; i < resultItems.length; i++) {
+ var result = resultItems[i];
+ if (result.passed && !result.passed()) {
+ var resultMessageDiv = this.createDom('div', {className: 'resultMessage fail'});
+ resultMessageDiv.innerHTML = result.message; // todo: lame; mend
+ specDiv.appendChild(resultMessageDiv);
+
+ if(result.trace.stack){ //******* not supported on safari
+ specDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+ }
+
+ }
+ }
+
+ this.suiteDivs[spec.suite.getFullName()].appendChild(specDiv);
+};
+
+jasmine.TrivialReporter.prototype.log = function() {
+ console.log.apply(console, arguments);
+};
+
+jasmine.TrivialReporter.prototype.getLocation = function() {
+ return this.document.location;
+};
+
+jasmine.TrivialReporter.prototype.specFilter = function(spec) {
+ var paramMap = {};
+ var params = this.getLocation().search.substring(1).split('&');
+ for (var i = 0; i < params.length; i++) {
+ var p = params[i].split('=');
+ paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+ }
+
+ if (!paramMap["spec"]) return true;
+ return spec.getFullName().indexOf(paramMap["spec"]) == 0;
+};
+
+//protect against console.log incidents
+if (!("console" in window) || !("firebug" in console)) {
+ var names = ["log", "debug", "info", "warn", "error", "assert", "dir", "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace", "profile", "profileEnd"];
+ window.console = {};
+ for (var i = 0, len = names.length; i < len; ++i) {
+ window.console[names[i]] = function() {
+ };
+ }
+}
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/TrivialReporter.js
------------------------------------------------------------------------------
svn:executable = *
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/fail-16.png
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/fail-16.png?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/fail-16.png
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/fail-16.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/fail.png
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/fail.png?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/fail.png
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/fail.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/go-16.png
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/go-16.png?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/go-16.png
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/go-16.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/go.png
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/go.png?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/go.png
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/go.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/pending-16.png
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/pending-16.png?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/pending-16.png
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/pending-16.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/pending.png
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/pending.png?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/pending.png
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/pending.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/question-bk.png
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/question-bk.png?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/question-bk.png
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/question-bk.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/questionbk-16.png
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/questionbk-16.png?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/questionbk-16.png
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/questionbk-16.png
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/images/spinner.gif
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/images/spinner.gif?rev=819134&view=auto
==============================================================================
Binary file - no diff available.
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/spinner.gif
------------------------------------------------------------------------------
svn:executable = *
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/images/spinner.gif
------------------------------------------------------------------------------
svn:mime-type = application/octet-stream
Added: incubator/jspwiki/trunk/tests/javascript/assets/jasmine-0.9.0.js
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/jasmine-0.9.0.js?rev=819134&view=auto
==============================================================================
--- incubator/jspwiki/trunk/tests/javascript/assets/jasmine-0.9.0.js (added)
+++ incubator/jspwiki/trunk/tests/javascript/assets/jasmine-0.9.0.js Sat Sep 26 13:22:31 2009
@@ -0,0 +1,2009 @@
+/**
+ * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
+ *
+ * @namespace
+ */
+var jasmine = {};
+
+/**
+ * @private
+ */
+jasmine.unimplementedMethod_ = function() {
+ throw new Error("unimplemented method");
+};
+
+/**
+ * Allows for bound functions to be comapred. Internal use only.
+ *
+ * @ignore
+ * @private
+ * @param base {Object} bound 'this' for the function
+ * @param name {Function} function to find
+ */
+jasmine.bindOriginal_ = function(base, name) {
+ var original = base[name];
+ return function() {
+ return original.apply(base, arguments);
+ };
+};
+
+jasmine.setTimeout = jasmine.bindOriginal_(window, 'setTimeout');
+jasmine.clearTimeout = jasmine.bindOriginal_(window, 'clearTimeout');
+jasmine.setInterval = jasmine.bindOriginal_(window, 'setInterval');
+jasmine.clearInterval = jasmine.bindOriginal_(window, 'clearInterval');
+
+jasmine.MessageResult = function(text) {
+ this.type = 'MessageResult';
+ this.text = text;
+ this.trace = new Error(); // todo: test better
+};
+
+jasmine.ExpectationResult = function(passed, message, details) {
+ this.type = 'ExpectationResult';
+ this.passed_ = passed;
+ this.message = message;
+ this.details = details;
+ this.trace = new Error(message); // todo: test better
+};
+
+jasmine.ExpectationResult.prototype.passed = function () {
+ return this.passed_;
+};
+
+/**
+ * Getter for the Jasmine environment. Ensures one gets created
+ */
+jasmine.getEnv = function() {
+ return jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isArray_ = function(value) {
+ return value &&
+ typeof value === 'object' &&
+ typeof value.length === 'number' &&
+ typeof value.splice === 'function' &&
+ !(value.propertyIsEnumerable('length'));
+};
+
+/**
+ * Pretty printer for expecations. Takes any object and turns it into a human-readable string.
+ *
+ * @param value {Object} an object to be outputted
+ * @returns {String}
+ */
+jasmine.pp = function(value) {
+ var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
+ stringPrettyPrinter.format(value);
+ return stringPrettyPrinter.string;
+};
+
+/**
+ * Returns true if the object is a DOM Node.
+ *
+ * @param {Object} obj object to check
+ * @returns {Boolean}
+ */
+jasmine.isDomNode = function(obj) {
+ return obj['nodeType'] > 0;
+};
+
+/**
+ * Returns a matchable 'generic' object of the class type. For use in expecations of type when values don't matter.
+ *
+ * @example
+ * // don't care about which function is passed in, as long as it's a function
+ * expect(mySpy).wasCalledWith(jasmine.any(Function));
+ *
+ * @param {Class} clazz
+ * @returns matchable object of the type clazz
+ */
+jasmine.any = function(clazz) {
+ return new jasmine.Matchers.Any(clazz);
+};
+
+/**
+ * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
+ *
+ * Spies should be created in test setup, before expectations. They can then be checked, using the standard Jasmine
+ * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
+ *
+ * A Spy has the following mehtod: wasCalled, callCount, mostRecentCall, and argsForCall (see docs)
+ * Spies are torn down at the end of every spec.
+ *
+ * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
+ *
+ * @example
+ * // a stub
+ * var myStub = jasmine.createSpy('myStub'); // can be used anywhere
+ *
+ * // spy example
+ * var foo = {
+ * not: function(bool) { return !bool; }
+ * }
+ *
+ * // actual foo.not will not be called, execution stops
+ * spyOn(foo, 'not');
+
+ // foo.not spied upon, execution will continue to implementation
+ * spyOn(foo, 'not').andCallThrough();
+ *
+ * // fake example
+ * var foo = {
+ * not: function(bool) { return !bool; }
+ * }
+ *
+ * // foo.not(val) will return val
+ * spyOn(foo, 'not').andCallFake(function(value) {return value;});
+ *
+ * // mock example
+ * foo.not(7 == 7);
+ * expect(foo.not).wasCalled();
+ * expect(foo.not).wasCalledWith(true);
+ *
+ * @constructor
+ * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
+ * @param {String} name
+ */
+jasmine.Spy = function(name) {
+ /**
+ * The name of the spy, if provided.
+ */
+ this.identity = name || 'unknown';
+ /**
+ * Is this Object a spy?
+ */
+ this.isSpy = true;
+ /**
+ * The acutal function this spy stubs.
+ */
+ this.plan = function() {};
+ /**
+ * Tracking of the most recent call to the spy.
+ * @example
+ * var mySpy = jasmine.createSpy('foo');
+ * mySpy(1, 2);
+ * mySpy.mostRecentCall.args = [1, 2];
+ */
+ this.mostRecentCall = {};
+
+ /**
+ * Holds arguments for each call to the spy, indexed by call count
+ * @example
+ * var mySpy = jasmine.createSpy('foo');
+ * mySpy(1, 2);
+ * mySpy(7, 8);
+ * mySpy.mostRecentCall.args = [7, 8];
+ * mySpy.argsForCall[0] = [1, 2];
+ * mySpy.argsForCall[1] = [7, 8];
+ */
+ this.argsForCall = [];
+};
+
+/**
+ * Tells a spy to call through to the actual implemenatation.
+ *
+ * @example
+ * var foo = {
+ * bar: function() { // do some stuff }
+ * }
+ *
+ * // defining a spy on an existing property: foo.bar
+ * spyOn(foo, 'bar').andCallThrough();
+ */
+jasmine.Spy.prototype.andCallThrough = function() {
+ this.plan = this.originalValue;
+ return this;
+};
+
+/**
+ * For setting the return value of a spy.
+ *
+ * @example
+ * // defining a spy from scratch: foo() returns 'baz'
+ * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
+ *
+ * // defining a spy on an existing property: foo.bar() returns 'baz'
+ * spyOn(foo, 'bar').andReturn('baz');
+ *
+ * @param {Object} value
+ */
+jasmine.Spy.prototype.andReturn = function(value) {
+ this.plan = function() {
+ return value;
+ };
+ return this;
+};
+
+/**
+ * For throwing an exception when a spy is called.
+ *
+ * @example
+ * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
+ * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
+ *
+ * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
+ * spyOn(foo, 'bar').andThrow('baz');
+ *
+ * @param {String} exceptionMsg
+ */
+jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
+ this.plan = function() {
+ throw exceptionMsg;
+ };
+ return this;
+};
+
+/**
+ * Calls an alternate implementation when a spy is called.
+ *
+ * @example
+ * var baz = function() {
+ * // do some stuff, return something
+ * }
+ * // defining a spy from scratch: foo() calls the function baz
+ * var foo = jasmine.createSpy('spy on foo').andCall(baz);
+ *
+ * // defining a spy on an existing property: foo.bar() calls an anonymnous function
+ * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
+ *
+ * @param {Function} fakeFunc
+ */
+jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
+ this.plan = fakeFunc;
+ return this;
+};
+
+/**
+ * Resets all of a spy's the tracking variables so that it can be used again.
+ *
+ * @example
+ * spyOn(foo, 'bar');
+ *
+ * foo.bar();
+ *
+ * expect(foo.bar.callCount).toEqual(1);
+ *
+ * foo.bar.reset();
+ *
+ * expect(foo.bar.callCount).toEqual(0);
+ */
+jasmine.Spy.prototype.reset = function() {
+ this.wasCalled = false;
+ this.callCount = 0;
+ this.argsForCall = [];
+ this.mostRecentCall = {};
+};
+
+jasmine.createSpy = function(name) {
+
+ var spyObj = function() {
+ spyObj.wasCalled = true;
+ spyObj.callCount++;
+ var args = jasmine.util.argsToArray(arguments);
+ //spyObj.mostRecentCall = {
+ // object: this,
+ // args: args
+ //};
+ spyObj.mostRecentCall.object = this;
+ spyObj.mostRecentCall.args = args;
+ spyObj.argsForCall.push(args);
+ return spyObj.plan.apply(this, arguments);
+ };
+
+ var spy = new jasmine.Spy(name);
+
+ for(var prop in spy) {
+ spyObj[prop] = spy[prop];
+ }
+
+ spyObj.reset();
+
+ return spyObj;
+};
+
+/**
+ * Creates a more complicated spy: an Object that has every property a function that is a spy. Used for stubbing something
+ * large in one call.
+ *
+ * @param {String} baseName name of spy class
+ * @param {Array} methodNames array of names of methods to make spies
+ */
+jasmine.createSpyObj = function(baseName, methodNames) {
+ var obj = {};
+ for (var i = 0; i < methodNames.length; i++) {
+ obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
+ }
+ return obj;
+};
+
+jasmine.log = function(message) {
+ jasmine.getEnv().currentSpec.getResults().log(message);
+};
+
+/**
+ * Function that installs a spy on an existing object's method name. Used within a Spec to create a spy.
+ *
+ * @example
+ * // spy example
+ * var foo = {
+ * not: function(bool) { return !bool; }
+ * }
+ * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops
+ *
+ * @see jasmine.createSpy
+ * @param obj
+ * @param methodName
+ * @returns a Jasmine spy that can be chained with all spy methods
+ */
+var spyOn = function(obj, methodName) {
+ return jasmine.getEnv().currentSpec.spyOn(obj, methodName);
+};
+
+/**
+ * Creates a Jasmine spec that will be added to the current suite.
+ *
+ * // TODO: pending tests
+ *
+ * @example
+ * it('should be true', function() {
+ * expect(true).toEqual(true);
+ * });
+ *
+ * @param {String} desc description of this specification
+ * @param {Function} func defines the preconditions and expectations of the spec
+ */
+var it = function(desc, func) {
+ return jasmine.getEnv().it(desc, func);
+};
+
+/**
+ * Creates a <em>disabled</em> Jasmine spec.
+ *
+ * A convenience method that allows existing specs to be disabled temporarily during development.
+ *
+ * @param {String} desc description of this specification
+ * @param {Function} func defines the preconditions and expectations of the spec
+ */
+var xit = function(desc, func) {
+ return jasmine.getEnv().xit(desc, func);
+};
+
+/**
+ * Starts a chain for a Jasmine expectation.
+ *
+ * It is passed an Object that is the actual value and should chain to one of the many
+ * jasmine.Matchers functions.
+ *
+ * @param {Object} actual Actual value to test against and expected value
+ */
+var expect = function(actual) {
+ return jasmine.getEnv().currentSpec.expect(actual);
+};
+
+/**
+ * Defines part of a jasmine spec. Used in cominbination with waits or waitsFor in asynchrnous specs.
+ *
+ * @param {Function} func Function that defines part of a jasmine spec.
+ */
+var runs = function(func) {
+ jasmine.getEnv().currentSpec.runs(func);
+};
+
+/**
+ * Waits for a timeout before moving to the next runs()-defined block.
+ * @param {Number} timeout
+ */
+var waits = function(timeout) {
+ jasmine.getEnv().currentSpec.waits(timeout);
+};
+
+/**
+ * Waits for the latchFunction to return true before proceeding to the next runs()-defined block.
+ *
+ * @param {Number} timeout
+ * @param {Function} latchFunction
+ * @param {String} message
+ */
+var waitsFor = function(timeout, latchFunction, message) {
+ jasmine.getEnv().currentSpec.waitsFor(timeout, latchFunction, message);
+};
+
+/**
+ * A function that is called before each spec in a suite.
+ *
+ * Used for spec setup, including validating assumptions.
+ *
+ * @param {Function} beforeEachFunction
+ */
+var beforeEach = function(beforeEachFunction) {
+ jasmine.getEnv().beforeEach(beforeEachFunction);
+};
+
+/**
+ * A function that is called after each spec in a suite.
+ *
+ * Used for restoring any state that is hijacked during spec execution.
+ *
+ * @param {Function} afterEachFunction
+ */
+var afterEach = function(afterEachFunction) {
+ jasmine.getEnv().afterEach(afterEachFunction);
+};
+
+/**
+ * Defines a suite of specifications.
+ *
+ * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared
+ * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization
+ * of setup in some tests.
+ *
+ * @example
+ * // TODO: a simple suite
+ *
+ * // TODO: a simple suite with a nested describe block
+ *
+ * @param {String} description A string, usually the class under test.
+ * @param {Function} specDefinitions function that defines several specs.
+ */
+var describe = function(description, specDefinitions) {
+ return jasmine.getEnv().describe(description, specDefinitions);
+};
+
+/**
+ * Disables a suite of specifications. Used to disable some suites in a file, or files, temporarily during development.
+ *
+ * @param {String} description A string, usually the class under test.
+ * @param {Function} specDefinitions function that defines several specs.
+ */
+var xdescribe = function(description, specDefinitions) {
+ return jasmine.getEnv().xdescribe(description, specDefinitions);
+};
+
+
+jasmine.XmlHttpRequest = XMLHttpRequest;
+
+// Provide the XMLHttpRequest class for IE 5.x-6.x:
+if (typeof XMLHttpRequest == "undefined") jasmine.XmlHttpRequest = function() {
+ try {
+ return new ActiveXObject("Msxml2.XMLHTTP.6.0");
+ } catch(e) {
+ }
+ try {
+ return new ActiveXObject("Msxml2.XMLHTTP.3.0");
+ } catch(e) {
+ }
+ try {
+ return new ActiveXObject("Msxml2.XMLHTTP");
+ } catch(e) {
+ }
+ try {
+ return new ActiveXObject("Microsoft.XMLHTTP");
+ } catch(e) {
+ }
+ throw new Error("This browser does not support XMLHttpRequest.");
+};
+
+/**
+ * Adds suite files to an HTML document so that they are executed, thus adding them to the current
+ * Jasmine environment.
+ *
+ * @param {String} url path to the file to include
+ * @param {Boolean} opt_global
+ */
+jasmine.include = function(url, opt_global) {
+ if (opt_global) {
+ document.write('<script type="text/javascript" src="' + url + '"></' + 'script>');
+ } else {
+ var xhr;
+ try {
+ xhr = new jasmine.XmlHttpRequest();
+ xhr.open("GET", url, false);
+ xhr.send(null);
+ } catch(e) {
+ throw new Error("couldn't fetch " + url + ": " + e);
+ }
+
+ return eval(xhr.responseText);
+ }
+};
+
+jasmine.version_= {
+ "major": 0,
+ "minor": 9,
+ "build": 0,
+ "revision": 1
+ };
+/**
+ * @namespace
+ */
+jasmine.util = {};
+
+/**
+ * Declare that a child class inherite it's prototype from the parent class.
+ *
+ * @private
+ * @param {Function} childClass
+ * @param {Function} parentClass
+ */
+jasmine.util.inherit = function(childClass, parentClass) {
+ var subclass = function() {
+ };
+ subclass.prototype = parentClass.prototype;
+ childClass.prototype = new subclass;
+};
+
+jasmine.util.formatException = function(e) {
+ var lineNumber;
+ if (e.line) {
+ lineNumber = e.line;
+ }
+ else if (e.lineNumber) {
+ lineNumber = e.lineNumber;
+ }
+
+ var file;
+
+ if (e.sourceURL) {
+ file = e.sourceURL;
+ }
+ else if (e.fileName) {
+ file = e.fileName;
+ }
+
+ var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();
+
+ if (file && lineNumber) {
+ message += ' in ' + file + ' (line ' + lineNumber + ')';
+ }
+
+ return message;
+};
+
+jasmine.util.htmlEscape = function(str) {
+ if (!str) return str;
+ return str.replace(/&/g, '&')
+ .replace(/</g, '<')
+ .replace(/>/g, '>');
+};
+
+jasmine.util.argsToArray = function(args) {
+ var arrayOfArgs = [];
+ for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);
+ return arrayOfArgs;
+};
+
+/**
+ * Environment for Jasmine
+ *
+ * @constructor
+ */
+jasmine.Env = function() {
+ this.currentSpec = null;
+ this.currentSuite = null;
+ this.currentRunner = new jasmine.Runner(this);
+ this.currentlyRunningTests = false;
+
+ this.reporter = new jasmine.MultiReporter();
+
+ this.updateInterval = 0;
+ this.lastUpdate = 0;
+ this.specFilter = function() {
+ return true;
+ };
+
+ this.nextSpecId_ = 0;
+ this.nextSuiteId_ = 0;
+ this.equalityTesters_ = [];
+};
+
+
+jasmine.Env.prototype.setTimeout = jasmine.setTimeout;
+jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;
+jasmine.Env.prototype.setInterval = jasmine.setInterval;
+jasmine.Env.prototype.clearInterval = jasmine.clearInterval;
+
+jasmine.Env.prototype.version = function () {
+ if (jasmine.version_) {
+ return jasmine.version_;
+ } else {
+ throw new Error('Version not set');
+ }
+};
+
+/**
+ * Register a reporter to receive status updates from Jasmine.
+ * @param {jasmine.Reporter} reporter An object which will receive status updates.
+ */
+jasmine.Env.prototype.addReporter = function(reporter) {
+ this.reporter.addReporter(reporter);
+};
+
+jasmine.Env.prototype.execute = function() {
+ this.currentRunner.execute();
+};
+
+jasmine.Env.prototype.describe = function(description, specDefinitions) {
+ var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);
+
+ var parentSuite = this.currentSuite;
+ if (parentSuite) {
+ parentSuite.add(suite);
+ } else {
+ this.currentRunner.add(suite);
+ }
+
+ this.currentSuite = suite;
+
+ specDefinitions.call(suite);
+
+ this.currentSuite = parentSuite;
+
+ return suite;
+};
+
+jasmine.Env.prototype.beforeEach = function(beforeEachFunction) {
+ this.currentSuite.beforeEach(beforeEachFunction);
+};
+
+jasmine.Env.prototype.afterEach = function(afterEachFunction) {
+ this.currentSuite.afterEach(afterEachFunction);
+};
+
+jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {
+ return {
+ execute: function() {
+ }
+ };
+};
+
+jasmine.Env.prototype.it = function(description, func) {
+ var spec = new jasmine.Spec(this, this.currentSuite, description);
+ this.currentSuite.add(spec);
+ this.currentSpec = spec;
+
+ if (func) {
+ spec.runs(func);
+ }
+
+ return spec;
+};
+
+jasmine.Env.prototype.xit = function(desc, func) {
+ return {
+ id: this.nextSpecId_++,
+ runs: function() {
+ }
+ };
+};
+
+jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
+ if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {
+ return true;
+ }
+
+ a.__Jasmine_been_here_before__ = b;
+ b.__Jasmine_been_here_before__ = a;
+
+ var hasKey = function(obj, keyName) {
+ return obj != null && obj[keyName] !== undefined;
+ };
+
+ for (var property in b) {
+ if (!hasKey(a, property) && hasKey(b, property)) {
+ mismatchKeys.push("expected has key '" + property + "', but missing from <b>actual</b>.");
+ }
+ }
+ for (property in a) {
+ if (!hasKey(b, property) && hasKey(a, property)) {
+ mismatchKeys.push("<b>expected</b> missing key '" + property + "', but present in actual.");
+ }
+ }
+ for (property in b) {
+ if (property == '__Jasmine_been_here_before__') continue;
+ if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {
+ mismatchValues.push("'" + property + "' was<br /><br />'" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "'<br /><br />in expected, but was<br /><br />'" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "'<br /><br />in actual.<br />");
+ }
+ }
+
+ if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {
+ mismatchValues.push("arrays were not the same length");
+ }
+
+ delete a.__Jasmine_been_here_before__;
+ delete b.__Jasmine_been_here_before__;
+ return (mismatchKeys.length == 0 && mismatchValues.length == 0);
+};
+
+jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {
+ mismatchKeys = mismatchKeys || [];
+ mismatchValues = mismatchValues || [];
+
+ if (a === b) return true;
+
+ if (a === undefined || a === null || b === undefined || b === null) {
+ return (a == undefined && b == undefined);
+ }
+
+ if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {
+ return a === b;
+ }
+
+ if (a instanceof Date && b instanceof Date) {
+ return a.getTime() == b.getTime();
+ }
+
+ if (a instanceof jasmine.Matchers.Any) {
+ return a.matches(b);
+ }
+
+ if (b instanceof jasmine.Matchers.Any) {
+ return b.matches(a);
+ }
+
+ if (typeof a === "object" && typeof b === "object") {
+ return this.compareObjects_(a, b, mismatchKeys, mismatchValues);
+ }
+
+ for (var i = 0; i < this.equalityTesters_.length; i++) {
+ var equalityTester = this.equalityTesters_[i];
+ var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);
+ if (result !== undefined) return result;
+ }
+
+ //Straight check
+ return (a === b);
+};
+
+jasmine.Env.prototype.contains_ = function(haystack, needle) {
+ if (jasmine.isArray_(haystack)) {
+ for (var i = 0; i < haystack.length; i++) {
+ if (this.equals_(haystack[i], needle)) return true;
+ }
+ return false;
+ }
+ return haystack.indexOf(needle) >= 0;
+};
+
+jasmine.Env.prototype.addEqualityTester = function(equalityTester) {
+ this.equalityTesters_.push(equalityTester);
+};
+/** No-op base class for Jasmine reporters.
+ *
+ * @constructor
+ */
+jasmine.Reporter = function() {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportRunnerStarting = function(runner) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSpecResults = function(spec) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.log = function(str) {
+};
+
+/**
+ * Blocks are functions with executable code that make up a spec.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {Function} func
+ * @param {jasmine.Spec} spec
+ */
+jasmine.Block = function(env, func, spec) {
+ this.env = env;
+ this.func = func;
+ this.spec = spec;
+};
+
+jasmine.Block.prototype.execute = function(onComplete) {
+ try {
+ this.func.apply(this.spec);
+ } catch (e) {
+ this.fail(e);
+ }
+ onComplete();
+};
+
+jasmine.Block.prototype.fail = function(e) {
+ this.spec.results.addResult(new jasmine.ExpectationResult(false, jasmine.util.formatException(e), null));
+};
+/** JavaScript API reporter.
+ *
+ * @constructor
+ */
+jasmine.JsApiReporter = function() {
+ this.started = false;
+ this.finished = false;
+ this.suites = [];
+ this.results = {};
+};
+
+jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {
+ this.started = true;
+
+ for (var i = 0; i < runner.suites.length; i++) {
+ var suite = runner.suites[i];
+ this.suites.push(this.summarize_(suite));
+ }
+};
+
+jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {
+ var summary = {
+ id: suiteOrSpec.id,
+ name: suiteOrSpec.description,
+ type: suiteOrSpec instanceof jasmine.Suite ? 'suite' : 'spec',
+ children: []
+ };
+
+ if (suiteOrSpec.specs) {
+ for (var i = 0; i < suiteOrSpec.specs.length; i++) {
+ summary.children.push(this.summarize_(suiteOrSpec.specs[i]));
+ }
+ }
+
+ return summary;
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {
+ this.finished = true;
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {
+ this.results[spec.id] = {
+ messages: spec.results.getItems(),
+ result: spec.results.failedCount > 0 ? "failed" : "passed"
+ };
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.log = function(str) {
+};
+
+jasmine.Matchers = function(env, actual, results) {
+ this.env = env;
+ this.actual = actual;
+ this.passing_message = 'Passed.';
+ this.results = results || new jasmine.NestedResults();
+};
+
+jasmine.Matchers.pp = function(str) {
+ return jasmine.util.htmlEscape(jasmine.pp(str));
+};
+
+jasmine.Matchers.prototype.getResults = function() {
+ return this.results;
+};
+
+jasmine.Matchers.prototype.report = function(result, failing_message, details) {
+ this.results.addResult(new jasmine.ExpectationResult(result, result ? this.passing_message : failing_message, details));
+ return result;
+};
+
+/**
+ * Matcher that compares the actual to the expected using ===.
+ *
+ * @param expected
+ */
+jasmine.Matchers.prototype.toBe = function(expected) {
+ return this.report(this.actual === expected, 'Expected<br /><br />' + jasmine.Matchers.pp(expected)
+ + '<br /><br />to be the same object as<br /><br />' + jasmine.Matchers.pp(this.actual)
+ + '<br />');
+};
+
+/**
+ * Matcher that compares the actual to the expected using !==
+ * @param expected
+ */
+jasmine.Matchers.prototype.toNotBe = function(expected) {
+ return this.report(this.actual !== expected, 'Expected<br /><br />' + jasmine.Matchers.pp(expected)
+ + '<br /><br />to be a different object from actual, but they were the same.');
+};
+
+/**
+ * Matcher that compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
+ *
+ * @param expected
+ */
+jasmine.Matchers.prototype.toEqual = function(expected) {
+ var mismatchKeys = [];
+ var mismatchValues = [];
+
+ var formatMismatches = function(name, array) {
+ if (array.length == 0) return '';
+ var errorOutput = '<br /><br />Different ' + name + ':<br />';
+ for (var i = 0; i < array.length; i++) {
+ errorOutput += array[i] + '<br />';
+ }
+ return errorOutput;
+ };
+
+ return this.report(this.env.equals_(this.actual, expected, mismatchKeys, mismatchValues),
+ 'Expected<br /><br />' + jasmine.Matchers.pp(expected)
+ + '<br /><br />but got<br /><br />' + jasmine.Matchers.pp(this.actual)
+ + '<br />'
+ + formatMismatches('Keys', mismatchKeys)
+ + formatMismatches('Values', mismatchValues), {
+ matcherName: 'toEqual', expected: expected, actual: this.actual
+ });
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_equal = jasmine.Matchers.prototype.toEqual;
+
+/**
+ * Matcher that compares the actual to the expected using the ! of jasmine.Matchers.toEqual
+ * @param expected
+ */
+jasmine.Matchers.prototype.toNotEqual = function(expected) {
+ return this.report(!this.env.equals_(this.actual, expected),
+ 'Expected ' + jasmine.Matchers.pp(expected) + ' to not equal ' + jasmine.Matchers.pp(this.actual) + ', but it does.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_not_equal = jasmine.Matchers.prototype.toNotEqual;
+
+/**
+ * Matcher that compares the actual to the expected using a regular expression. Constructs a RegExp, so takes
+ * a pattern or a String.
+ *
+ * @param reg_exp
+ */
+jasmine.Matchers.prototype.toMatch = function(reg_exp) {
+ return this.report((new RegExp(reg_exp).test(this.actual)),
+ 'Expected ' + jasmine.Matchers.pp(this.actual) + ' to match ' + reg_exp + '.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_match = jasmine.Matchers.prototype.toMatch;
+
+/**
+ * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
+ * @param reg_exp
+ */
+jasmine.Matchers.prototype.toNotMatch = function(reg_exp) {
+ return this.report((!new RegExp(reg_exp).test(this.actual)),
+ 'Expected ' + jasmine.Matchers.pp(this.actual) + ' to not match ' + reg_exp + '.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_not_match = jasmine.Matchers.prototype.toNotMatch;
+
+/**
+ * Matcher that compares the acutal to undefined.
+ */
+jasmine.Matchers.prototype.toBeDefined = function() {
+ return this.report((this.actual !== undefined),
+ 'Expected a value to be defined but it was undefined.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_be_defined = jasmine.Matchers.prototype.toBeDefined;
+
+/**
+ * Matcher that compares the actual to null.
+ *
+ */
+jasmine.Matchers.prototype.toBeNull = function() {
+ return this.report((this.actual === null),
+ 'Expected a value to be null but it was ' + jasmine.Matchers.pp(this.actual) + '.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_be_null = jasmine.Matchers.prototype.toBeNull;
+
+/**
+ * Matcher that boolean not-nots the actual.
+ */
+jasmine.Matchers.prototype.toBeTruthy = function() {
+ return this.report(!!this.actual,
+ 'Expected a value to be truthy but it was ' + jasmine.Matchers.pp(this.actual) + '.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_be_truthy = jasmine.Matchers.prototype.toBeTruthy;
+
+/**
+ * Matcher that boolean nots the actual.
+ */
+jasmine.Matchers.prototype.toBeFalsy = function() {
+ return this.report(!this.actual,
+ 'Expected a value to be falsy but it was ' + jasmine.Matchers.pp(this.actual) + '.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_be_falsy = jasmine.Matchers.prototype.toBeFalsy;
+
+/**
+ * Matcher that checks to see if the acutal, a Jasmine spy, was called.
+ */
+jasmine.Matchers.prototype.wasCalled = function() {
+ if (!this.actual || !this.actual.isSpy) {
+ return this.report(false, 'Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.');
+ }
+ if (arguments.length > 0) {
+ return this.report(false, 'wasCalled matcher does not take arguments');
+ }
+ return this.report((this.actual.wasCalled),
+ 'Expected spy "' + this.actual.identity + '" to have been called, but it was not.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.was_called = jasmine.Matchers.prototype.wasCalled;
+
+/**
+ * Matcher that checks to see if the acutal, a Jasmine spy, was not called.
+ */
+jasmine.Matchers.prototype.wasNotCalled = function() {
+ if (!this.actual || !this.actual.isSpy) {
+ return this.report(false, 'Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.');
+ }
+ return this.report((!this.actual.wasCalled),
+ 'Expected spy "' + this.actual.identity + '" to not have been called, but it was.');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.was_not_called = jasmine.Matchers.prototype.wasNotCalled;
+
+/**
+ * Matcher that checks to see if the acutal, a Jasmine spy, was called with a set of parameters.
+ *
+ * @example
+ *
+ */
+jasmine.Matchers.prototype.wasCalledWith = function() {
+ if (!this.actual || !this.actual.isSpy) {
+ return this.report(false, 'Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.', {
+ matcherName: 'wasCalledWith'
+ });
+ }
+
+ var args = jasmine.util.argsToArray(arguments);
+
+ return this.report(this.env.contains_(this.actual.argsForCall, args),
+ 'Expected ' + jasmine.Matchers.pp(this.actual.argsForCall) + ' to contain ' + jasmine.Matchers.pp(args) + ', but it does not.', {
+ matcherName: 'wasCalledWith', expected: args, actual: this.actual.argsForCall
+ });
+};
+
+/**
+ * Matcher that checks that the expected item is an element in the actual Array.
+ *
+ * @param {Object} item
+ */
+jasmine.Matchers.prototype.toContain = function(item) {
+ return this.report(this.env.contains_(this.actual, item),
+ 'Expected ' + jasmine.Matchers.pp(this.actual) + ' to contain ' + jasmine.Matchers.pp(item) + ', but it does not.', {
+ matcherName: 'toContain', expected: item, actual: this.actual
+ });
+};
+
+/**
+ * Matcher that checks that the expected item is NOT an element in the actual Array.
+ *
+ * @param {Object} item
+ */
+jasmine.Matchers.prototype.toNotContain = function(item) {
+ return this.report(!this.env.contains_(this.actual, item),
+ 'Expected ' + jasmine.Matchers.pp(this.actual) + ' not to contain ' + jasmine.Matchers.pp(item) + ', but it does.');
+};
+
+jasmine.Matchers.prototype.toBeLessThan = function(expected) {
+ return this.report(this.actual < expected,
+ 'Expected ' + jasmine.Matchers.pp(this.actual) + ' to be less than ' + jasmine.Matchers.pp(expected) + ', but it was not.');
+};
+
+jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
+ return this.report(this.actual > expected,
+ 'Expected ' + jasmine.Matchers.pp(this.actual) + ' to be greater than ' + jasmine.Matchers.pp(expected) + ', but it was not.');
+};
+
+/**
+ * Matcher that checks that the expected exception was thrown by the actual.
+ *
+ * @param {String} expectedException
+ */
+jasmine.Matchers.prototype.toThrow = function(expectedException) {
+ var exception = null;
+ try {
+ this.actual();
+ } catch (e) {
+ exception = e;
+ }
+ if (expectedException !== undefined) {
+ if (exception == null) {
+ return this.report(false, "Expected function to throw " + jasmine.Matchers.pp(expectedException) + ", but it did not.");
+ }
+ return this.report(
+ this.env.equals_(
+ exception.message || exception,
+ expectedException.message || expectedException),
+ "Expected function to throw " + jasmine.Matchers.pp(expectedException) + ", but it threw " + jasmine.Matchers.pp(exception) + ".");
+ } else {
+ return this.report(exception != null, "Expected function to throw an exception, but it did not.");
+ }
+};
+
+jasmine.Matchers.Any = function(expectedClass) {
+ this.expectedClass = expectedClass;
+};
+
+jasmine.Matchers.Any.prototype.matches = function(other) {
+ if (this.expectedClass == String) {
+ return typeof other == 'string' || other instanceof String;
+ }
+
+ if (this.expectedClass == Number) {
+ return typeof other == 'number' || other instanceof Number;
+ }
+
+ if (this.expectedClass == Function) {
+ return typeof other == 'function' || other instanceof Function;
+ }
+
+ if (this.expectedClass == Object) {
+ return typeof other == 'object';
+ }
+
+ return other instanceof this.expectedClass;
+};
+
+jasmine.Matchers.Any.prototype.toString = function() {
+ return '<jasmine.any(' + this.expectedClass + ')>';
+};
+
+/**
+ * @constructor
+ */
+jasmine.MultiReporter = function() {
+ this.subReporters_ = [];
+};
+jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);
+
+jasmine.MultiReporter.prototype.addReporter = function(reporter) {
+ this.subReporters_.push(reporter);
+};
+
+(function() {
+ var functionNames = ["reportRunnerStarting", "reportRunnerResults", "reportSuiteResults", "reportSpecResults", "log"];
+ for (var i = 0; i < functionNames.length; i++) {
+ var functionName = functionNames[i];
+ jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
+ return function() {
+ for (var j = 0; j < this.subReporters_.length; j++) {
+ var subReporter = this.subReporters_[j];
+ if (subReporter[functionName]) {
+ subReporter[functionName].apply(subReporter, arguments);
+ }
+ }
+ };
+ })(functionName);
+ }
+})();
+/**
+ * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
+ *
+ * @constructor
+ */
+jasmine.NestedResults = function() {
+ /**
+ * The total count of results
+ */
+ this.totalCount = 0;
+ /**
+ * Number of passed results
+ */
+ this.passedCount = 0;
+ /**
+ * Number of failed results
+ */
+ this.failedCount = 0;
+ /**
+ * Was this suite/spec skipped?
+ */
+ this.skipped = false;
+ /**
+ * @ignore
+ */
+ this.items_ = [];
+};
+
+/**
+ * Roll up the result counts.
+ *
+ * @param result
+ */
+jasmine.NestedResults.prototype.rollupCounts = function(result) {
+ this.totalCount += result.totalCount;
+ this.passedCount += result.passedCount;
+ this.failedCount += result.failedCount;
+};
+
+/**
+ * Tracks a result's message.
+ * @param message
+ */
+jasmine.NestedResults.prototype.log = function(message) {
+ this.items_.push(new jasmine.MessageResult(message));
+};
+
+/**
+ * Getter for the results: message & results.
+ */
+jasmine.NestedResults.prototype.getItems = function() {
+ return this.items_;
+};
+
+/**
+ * Adds a result, tracking counts (total, passed, & failed)
+ * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
+ */
+jasmine.NestedResults.prototype.addResult = function(result) {
+ if (result.type != 'MessageResult') {
+ if (result.items_) {
+ this.rollupCounts(result);
+ } else {
+ this.totalCount++;
+ if (result.passed()) {
+ this.passedCount++;
+ } else {
+ this.failedCount++;
+ }
+ }
+ }
+ this.items_.push(result);
+};
+
+/**
+ * @returns {Boolean} True if <b>everything</b> below passed
+ */
+jasmine.NestedResults.prototype.passed = function() {
+ return this.passedCount === this.totalCount;
+};
+/**
+ * Base class for pretty printing for expectation results.
+ */
+jasmine.PrettyPrinter = function() {
+ this.ppNestLevel_ = 0;
+};
+
+/**
+ * Formats a value in a nice, human-readable string.
+ *
+ * @param value
+ * @returns {String}
+ */
+jasmine.PrettyPrinter.prototype.format = function(value) {
+ if (this.ppNestLevel_ > 40) {
+ // return '(jasmine.pp nested too deeply!)';
+ throw new Error('jasmine.PrettyPrinter: format() nested too deeply!');
+ }
+
+ this.ppNestLevel_++;
+ try {
+ if (value === undefined) {
+ this.emitScalar('undefined');
+ } else if (value === null) {
+ this.emitScalar('null');
+ } else if (value.navigator && value.frames && value.setTimeout) {
+ this.emitScalar('<window>');
+ } else if (value instanceof jasmine.Matchers.Any) {
+ this.emitScalar(value.toString());
+ } else if (typeof value === 'string') {
+ this.emitString(value);
+ } else if (typeof value === 'function') {
+ this.emitScalar('Function');
+ } else if (typeof value.nodeType === 'number') {
+ this.emitScalar('HTMLNode');
+ } else if (value instanceof Date) {
+ this.emitScalar('Date(' + value + ')');
+ } else if (value.__Jasmine_been_here_before__) {
+ this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');
+ } else if (jasmine.isArray_(value) || typeof value == 'object') {
+ value.__Jasmine_been_here_before__ = true;
+ if (jasmine.isArray_(value)) {
+ this.emitArray(value);
+ } else {
+ this.emitObject(value);
+ }
+ delete value.__Jasmine_been_here_before__;
+ } else {
+ this.emitScalar(value.toString());
+ }
+ } finally {
+ this.ppNestLevel_--;
+ }
+};
+
+jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {
+ for (var property in obj) {
+ if (property == '__Jasmine_been_here_before__') continue;
+ fn(property, obj.__lookupGetter__(property) != null);
+ }
+};
+
+jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;
+
+jasmine.StringPrettyPrinter = function() {
+ jasmine.PrettyPrinter.call(this);
+
+ this.string = '';
+};
+jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);
+
+jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {
+ this.append(value);
+};
+
+jasmine.StringPrettyPrinter.prototype.emitString = function(value) {
+ this.append("'" + value + "'");
+};
+
+jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {
+ this.append('[ ');
+ for (var i = 0; i < array.length; i++) {
+ if (i > 0) {
+ this.append(', ');
+ }
+ this.format(array[i]);
+ }
+ this.append(' ]');
+};
+
+jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {
+ var self = this;
+ this.append('{ ');
+ var first = true;
+
+ this.iterateObject(obj, function(property, isGetter) {
+ if (first) {
+ first = false;
+ } else {
+ self.append(', ');
+ }
+
+ self.append(property);
+ self.append(' : ');
+ if (isGetter) {
+ self.append('<getter>');
+ } else {
+ self.format(obj[property]);
+ }
+ });
+
+ this.append(' }');
+};
+
+jasmine.StringPrettyPrinter.prototype.append = function(value) {
+ this.string += value;
+};
+jasmine.Queue = function(env) {
+ this.env = env;
+ this.blocks = [];
+ this.running = false;
+ this.index = 0;
+ this.offset = 0;
+};
+
+jasmine.Queue.prototype.addBefore = function (block) {
+ this.blocks.unshift(block);
+};
+
+jasmine.Queue.prototype.add = function(block) {
+ this.blocks.push(block);
+};
+
+jasmine.Queue.prototype.insertNext = function (block) {
+ this.blocks.splice((this.index + this.offset + 1), 0, block);
+ this.offset++;
+};
+
+jasmine.Queue.prototype.start = function(onComplete) {
+ var self = this;
+ self.running = true;
+ self.onComplete = onComplete;
+ if (self.blocks[0]) {
+ self.blocks[0].execute(function () {
+ self._next();
+ });
+ } else {
+ self.finish();
+ }
+};
+
+jasmine.Queue.prototype.isRunning = function () {
+ return this.running;
+};
+
+jasmine.Queue.prototype._next = function () {
+ var self = this;
+ self.env.setTimeout(function () {
+ self.offset = 0;
+ self.index++;
+ if (self.index < self.blocks.length) {
+ self.blocks[self.index].execute(function () {
+ self._next();
+ });
+ } else {
+ self.finish();
+ }
+ }, 0);
+};
+
+jasmine.Queue.prototype.finish = function () {
+ this.running = false;
+ if (this.onComplete) {
+ this.onComplete();
+ }
+};
+
+jasmine.Queue.prototype.getResults = function () {
+ var results = new jasmine.NestedResults();
+ for (var i = 0; i < this.blocks.length; i++) {
+ if (this.blocks[i].getResults) {
+ results.addResult(this.blocks[i].getResults());
+ }
+ }
+ return results;
+};
+
+
+/* JasmineReporters.reporter
+ * Base object that will get called whenever a Spec, Suite, or Runner is done. It is up to
+ * descendants of this object to do something with the results (see json_reporter.js)
+ */
+jasmine.Reporters = {};
+
+jasmine.Reporters.reporter = function(callbacks) {
+ var that = {
+ callbacks: callbacks || {},
+
+ doCallback: function(callback, results) {
+ if (callback) {
+ callback(results);
+ }
+ },
+
+ reportRunnerResults: function(runner) {
+ that.doCallback(that.callbacks.runnerCallback, runner);
+ },
+ reportSuiteResults: function(suite) {
+ that.doCallback(that.callbacks.suiteCallback, suite);
+ },
+ reportSpecResults: function(spec) {
+ that.doCallback(that.callbacks.specCallback, spec);
+ },
+ log: function (str) {
+ if (console && console.log) console.log(str);
+ }
+ };
+
+ return that;
+};
+
+/**
+ * Runner
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ */
+jasmine.Runner = function(env) {
+ var self = this;
+ self.env = env;
+ self.queue = new jasmine.Queue(env);
+ self.suites = [];
+};
+
+jasmine.Runner.prototype.execute = function() {
+ var self = this;
+ if (self.env.reporter.reportRunnerStarting) {
+ self.env.reporter.reportRunnerStarting(this);
+ }
+ self.queue.start(function () {
+ self.finishCallback();
+ });
+};
+
+jasmine.Runner.prototype.finishCallback = function() {
+ this.env.reporter.reportRunnerResults(this);
+};
+
+jasmine.Runner.prototype.addSuite = function(suite) {
+ this.suites.push(suite);
+};
+
+jasmine.Runner.prototype.add = function(block) {
+ if (block instanceof jasmine.Suite) {
+ this.addSuite(block);
+ }
+ this.queue.add(block);
+};
+
+
+jasmine.Runner.prototype.getAllSuites = function() {
+ return this.suites;
+};
+
+jasmine.Runner.prototype.getResults = function() {
+ return this.queue.getResults();
+};
+/**
+ * Internal representation of a Jasmine specification, or test.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {jasmine.Suite} suite
+ * @param {String} description
+ */
+jasmine.Spec = function(env, suite, description) {
+ var spec = this;
+ spec.id = env.nextSpecId_++;
+ spec.env = env;
+ spec.suite = suite;
+ spec.description = description;
+ spec.queue = new jasmine.Queue(env);
+
+ spec.afterCallbacks = [];
+ spec.spies_ = [];
+
+ spec.results = new jasmine.NestedResults();
+ spec.results.description = description;
+ spec.matchersClass = null;
+};
+
+jasmine.Spec.prototype.getFullName = function() {
+ return this.suite.getFullName() + ' ' + this.description + '.';
+};
+
+jasmine.Spec.prototype.getResults = function() {
+ return this.results;
+};
+
+jasmine.Spec.prototype.runs = function (func) {
+ var block = new jasmine.Block(this.env, func, this);
+ this.addToQueue(block);
+ return this;
+};
+
+jasmine.Spec.prototype.addToQueue = function (block) {
+ if (this.queue.isRunning()) {
+ this.queue.insertNext(block);
+ } else {
+ this.queue.add(block);
+ }
+};
+
+/**
+ * @private
+ * @deprecated
+ */
+jasmine.Spec.prototype.expects_that = function(actual) {
+ return this.expect(actual);
+};
+
+/**
+ * @private
+ */
+jasmine.Spec.prototype.expect = function(actual) {
+ return new (this.getMatchersClass_())(this.env, actual, this.results);
+};
+
+jasmine.Spec.prototype.waits = function(timeout) {
+ var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
+ this.addToQueue(waitsFunc);
+ return this;
+};
+
+jasmine.Spec.prototype.waitsFor = function(timeout, latchFunction, timeoutMessage) {
+ var waitsForFunc = new jasmine.WaitsForBlock(this.env, timeout, latchFunction, timeoutMessage, this);
+ this.addToQueue(waitsForFunc);
+ return this;
+};
+
+jasmine.Spec.prototype.failWithException = function (e) {
+ this.results.addResult(new jasmine.ExpectationResult(false, jasmine.util.formatException(e), null));
+};
+
+jasmine.Spec.prototype.getMatchersClass_ = function() {
+ return this.matchersClass || jasmine.Matchers;
+};
+
+jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {
+ var parent = this.getMatchersClass_();
+ var newMatchersClass = function() {
+ parent.apply(this, arguments);
+ };
+ jasmine.util.inherit(newMatchersClass, parent);
+ for (var method in matchersPrototype) {
+ newMatchersClass.prototype[method] = matchersPrototype[method];
+ }
+ this.matchersClass = newMatchersClass;
+};
+
+jasmine.Spec.prototype.finishCallback = function() {
+ this.env.reporter.reportSpecResults(this);
+};
+
+jasmine.Spec.prototype.finish = function(onComplete) {
+ this.removeAllSpies();
+ this.finishCallback();
+ if (onComplete) {
+ onComplete();
+ }
+};
+
+jasmine.Spec.prototype.after = function(doAfter, test) {
+
+ if (this.queue.isRunning()) {
+ this.queue.add(new jasmine.Block(this.env, doAfter, this));
+ } else {
+ this.afterCallbacks.unshift(doAfter);
+ }
+};
+
+jasmine.Spec.prototype.execute = function(onComplete) {
+ var spec = this;
+ if (!spec.env.specFilter(spec)) {
+ spec.results.skipped = true;
+ spec.finish(onComplete);
+ return;
+ }
+ this.env.reporter.log('>> Jasmine Running ' + this.suite.description + ' ' + this.description + '...');
+
+ spec.env.currentSpec = spec;
+ spec.env.currentlyRunningTests = true;
+
+ spec.addBeforesAndAftersToQueue();
+
+ spec.queue.start(function () {
+ spec.finish(onComplete);
+ });
+ spec.env.currentlyRunningTests = false;
+};
+
+jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {
+ for (var suite = this.suite; suite; suite = suite.parentSuite) {
+ if (suite.beforeQueue) {
+ for (var i = 0; i < suite.beforeQueue.length; i++)
+ this.queue.addBefore(new jasmine.Block(this.env, suite.beforeQueue[i], this));
+ }
+ }
+ for (i = 0; i < this.afterCallbacks.length; i++) {
+ this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this));
+ }
+ for (suite = this.suite; suite; suite = suite.parentSuite) {
+ if (suite.afterQueue) {
+ for (var j = 0; j < suite.afterQueue.length; j++)
+ this.queue.add(new jasmine.Block(this.env, suite.afterQueue[j], this));
+ }
+ }
+};
+
+jasmine.Spec.prototype.explodes = function() {
+ throw 'explodes function should not have been called';
+};
+
+jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {
+ if (obj == undefined) {
+ throw "spyOn could not find an object to spy upon for " + methodName + "()";
+ }
+
+ if (!ignoreMethodDoesntExist && obj[methodName] === undefined) {
+ throw methodName + '() method does not exist';
+ }
+
+ if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {
+ throw new Error(methodName + ' has already been spied upon');
+ }
+
+ var spyObj = jasmine.createSpy(methodName);
+
+ this.spies_.push(spyObj);
+ spyObj.baseObj = obj;
+ spyObj.methodName = methodName;
+ spyObj.originalValue = obj[methodName];
+
+ obj[methodName] = spyObj;
+
+ return spyObj;
+};
+
+jasmine.Spec.prototype.removeAllSpies = function() {
+ for (var i = 0; i < this.spies_.length; i++) {
+ var spy = this.spies_[i];
+ spy.baseObj[spy.methodName] = spy.originalValue;
+ }
+ this.spies_ = [];
+};
+
+/**
+ * Internal representation of a Jasmine suite.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {String} description
+ * @param {Function} specDefinitions
+ * @param {jasmine.Suite} parentSuite
+ */
+jasmine.Suite = function(env, description, specDefinitions, parentSuite) {
+ var self = this;
+ self.id = env.nextSuiteId_++;
+ self.description = description;
+ self.queue = new jasmine.Queue(env);
+ self.parentSuite = parentSuite;
+ self.env = env;
+ self.beforeQueue = [];
+ self.afterQueue = [];
+ self.specs = [];
+};
+
+
+jasmine.Suite.prototype.getFullName = function() {
+ var fullName = this.description;
+ for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
+ fullName = parentSuite.description + ' ' + fullName;
+ }
+ return fullName;
+};
+
+jasmine.Suite.prototype.finish = function(onComplete) {
+ this.env.reporter.reportSuiteResults(this);
+ this.finished = true;
+ if (typeof(onComplete) == 'function') {
+ onComplete();
+ }
+};
+
+jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {
+ beforeEachFunction.typeName = 'beforeEach';
+ this.beforeQueue.push(beforeEachFunction);
+};
+
+jasmine.Suite.prototype.afterEach = function(afterEachFunction) {
+ afterEachFunction.typeName = 'afterEach';
+ this.afterQueue.push(afterEachFunction);
+};
+
+jasmine.Suite.prototype.getResults = function() {
+ return this.queue.getResults();
+};
+
+jasmine.Suite.prototype.add = function(block) {
+ if (block instanceof jasmine.Suite) {
+ this.env.currentRunner.addSuite(block);
+ }
+ this.specs.push(block);
+ this.queue.add(block);
+};
+
+jasmine.Suite.prototype.execute = function(onComplete) {
+ var self = this;
+ this.queue.start(function () { self.finish(onComplete); });
+};
+
+jasmine.WaitsBlock = function(env, timeout, spec) {
+ this.timeout = timeout;
+ jasmine.Block.call(this, env, null, spec);
+};
+
+jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);
+
+jasmine.WaitsBlock.prototype.execute = function (onComplete) {
+ this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');
+ this.env.setTimeout(function () {
+ onComplete();
+ }, this.timeout);
+};
+jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
+ this.timeout = timeout;
+ this.latchFunction = latchFunction;
+ this.message = message;
+ this.totalTimeSpentWaitingForLatch = 0;
+ jasmine.Block.call(this, env, null, spec);
+};
+
+jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
+
+jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 100;
+
+jasmine.WaitsForBlock.prototype.execute = function (onComplete) {
+ var self = this;
+ self.env.reporter.log('>> Jasmine waiting for ' + (self.message || 'something to happen'));
+ var latchFunctionResult;
+ try {
+ latchFunctionResult = self.latchFunction.apply(self.spec);
+ } catch (e) {
+ self.fail(e);
+ onComplete();
+ return;
+ }
+
+ if (latchFunctionResult) {
+ onComplete();
+ } else if (self.totalTimeSpentWaitingForLatch >= self.timeout) {
+ var message = 'timed out after ' + self.timeout + ' msec waiting for ' + (self.message || 'something to happen');
+ self.fail({
+ name: 'timeout',
+ message: message
+ });
+ self.spec._next();
+ } else {
+ self.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
+ self.env.setTimeout(function () { self.execute(onComplete); }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
+ }
+};
+// Mock setTimeout, clearTimeout
+// Contributed by Pivotal Computer Systems, www.pivotalsf.com
+
+jasmine.FakeTimer = function() {
+ this.reset();
+
+ var self = this;
+ self.setTimeout = function(funcToCall, millis) {
+ self.timeoutsMade++;
+ self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);
+ return self.timeoutsMade;
+ };
+
+ self.setInterval = function(funcToCall, millis) {
+ self.timeoutsMade++;
+ self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);
+ return self.timeoutsMade;
+ };
+
+ self.clearTimeout = function(timeoutKey) {
+ self.scheduledFunctions[timeoutKey] = undefined;
+ };
+
+ self.clearInterval = function(timeoutKey) {
+ self.scheduledFunctions[timeoutKey] = undefined;
+ };
+
+};
+
+jasmine.FakeTimer.prototype.reset = function() {
+ this.timeoutsMade = 0;
+ this.scheduledFunctions = {};
+ this.nowMillis = 0;
+};
+
+jasmine.FakeTimer.prototype.tick = function(millis) {
+ var oldMillis = this.nowMillis;
+ var newMillis = oldMillis + millis;
+ this.runFunctionsWithinRange(oldMillis, newMillis);
+ this.nowMillis = newMillis;
+};
+
+jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {
+ var scheduledFunc;
+ var funcsToRun = [];
+ for (var timeoutKey in this.scheduledFunctions) {
+ scheduledFunc = this.scheduledFunctions[timeoutKey];
+ if (scheduledFunc != undefined &&
+ scheduledFunc.runAtMillis >= oldMillis &&
+ scheduledFunc.runAtMillis <= nowMillis) {
+ funcsToRun.push(scheduledFunc);
+ this.scheduledFunctions[timeoutKey] = undefined;
+ }
+ }
+
+ if (funcsToRun.length > 0) {
+ funcsToRun.sort(function(a, b) {
+ return a.runAtMillis - b.runAtMillis;
+ });
+ for (var i = 0; i < funcsToRun.length; ++i) {
+ try {
+ var funcToRun = funcsToRun[i];
+ this.nowMillis = funcToRun.runAtMillis;
+ funcToRun.funcToCall();
+ if (funcToRun.recurring) {
+ this.scheduleFunction(funcToRun.timeoutKey,
+ funcToRun.funcToCall,
+ funcToRun.millis,
+ true);
+ }
+ } catch(e) {
+ }
+ }
+ this.runFunctionsWithinRange(oldMillis, nowMillis);
+ }
+};
+
+jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {
+ this.scheduledFunctions[timeoutKey] = {
+ runAtMillis: this.nowMillis + millis,
+ funcToCall: funcToCall,
+ recurring: recurring,
+ timeoutKey: timeoutKey,
+ millis: millis
+ };
+};
+
+
+jasmine.Clock = {
+ defaultFakeTimer: new jasmine.FakeTimer(),
+
+ reset: function() {
+ jasmine.Clock.assertInstalled();
+ jasmine.Clock.defaultFakeTimer.reset();
+ },
+
+ tick: function(millis) {
+ jasmine.Clock.assertInstalled();
+ jasmine.Clock.defaultFakeTimer.tick(millis);
+ },
+
+ runFunctionsWithinRange: function(oldMillis, nowMillis) {
+ jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);
+ },
+
+ scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
+ jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);
+ },
+
+ useMock: function() {
+ var spec = jasmine.getEnv().currentSpec;
+ spec.after(jasmine.Clock.uninstallMock);
+
+ jasmine.Clock.installMock();
+ },
+
+ installMock: function() {
+ jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;
+ },
+
+ uninstallMock: function() {
+ jasmine.Clock.assertInstalled();
+ jasmine.Clock.installed = jasmine.Clock.real;
+ },
+
+ real: {
+ setTimeout: window.setTimeout,
+ clearTimeout: window.clearTimeout,
+ setInterval: window.setInterval,
+ clearInterval: window.clearInterval
+ },
+
+ assertInstalled: function() {
+ if (jasmine.Clock.installed != jasmine.Clock.defaultFakeTimer) {
+ throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
+ }
+ },
+
+ installed: null
+};
+jasmine.Clock.installed = jasmine.Clock.real;
+
+window.setTimeout = function(funcToCall, millis) {
+ return jasmine.Clock.installed.setTimeout.apply(this, arguments);
+};
+
+window.setInterval = function(funcToCall, millis) {
+ return jasmine.Clock.installed.setInterval.apply(this, arguments);
+};
+
+window.clearTimeout = function(timeoutKey) {
+ return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
+};
+
+window.clearInterval = function(timeoutKey) {
+ return jasmine.Clock.installed.clearInterval.apply(this, arguments);
+};
+
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/jasmine-0.9.0.js
------------------------------------------------------------------------------
svn:executable = *
Added: incubator/jspwiki/trunk/tests/javascript/assets/jasmine-jspwiki.css
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/jasmine-jspwiki.css?rev=819134&view=auto
==============================================================================
--- incubator/jspwiki/trunk/tests/javascript/assets/jasmine-jspwiki.css (added)
+++ incubator/jspwiki/trunk/tests/javascript/assets/jasmine-jspwiki.css Sat Sep 26 13:22:31 2009
@@ -0,0 +1,99 @@
+/*
+Jasmine testrunner stylesheet,
+adapted for JSPWiki.
+*/
+body {
+ font:76%/140% Verdana,Arial,Helvetica,sans-serif;
+ margin:0;
+ padding:0;
+}
+
+h1 {
+ margin:5px;
+ padding:5px;
+ background:#41464d;
+ color:#f3f1f1;
+ height:30px;
+ font: 25px/1.1 Arial, sans-serif;
+ font-weight:bolder;
+ text-shadow:0 2px 2px rgba(0,0,0,0.4);
+}
+h1 span {
+ color:#d2e0e6;
+}
+/*
+p {
+ margin-top: 5px;
+ padding-left: 20px;
+}
+.fail {
+ background: url( ../images/fail-16.png ) no-repeat;
+ padding-left: 20px;
+ color: red;
+}
+.failInSummary {
+ color: red;
+}
+*/
+.runner {
+ border: 2px solid #bbb;
+ margin: 5px;
+ padding: 1em 20px;
+ background-position: 2px 1em !important;
+}
+.runner.running {
+ background:#fdfbd0 url(./images/spinner.gif ) no-repeat;
+}
+.suite {
+ border:2px solid #bbb;
+ margin:5px;
+ padding:0.25em 20px;
+ font-weight:bold;
+}
+.suite.passed {
+ background-color: #cfc;
+}
+.suite.failed {
+ background-color: #fdd;
+}
+.spec {
+ -moz-border-radius:3px;
+ -webkit-border-radius:3px;
+ margin: 5px;
+ padding:0.25em 20px;
+ clear: both;
+ font-weight:normal;
+}
+.passed {
+ background:#9f9 url(./images/go-16.png ) 2px 2px no-repeat;
+ color: #41464D;
+}
+.failed {
+ background:pink url(./images/fail-16.png ) 2px 2px no-repeat;
+ color:#c00;
+}
+.skipped {
+ color:#777;
+ xbackground:#e0e0ff;
+}
+.resultMessage {
+ white-space: pre;
+}
+.stackTrace {
+ white-space:pre;
+ margin:0 1em;
+ height:7em;
+ overflow: auto;
+ border: 1px solid #bbb;
+ padding: 0.5em;
+ background: #eef;
+ font:90% Monaco, "Courier New", Courier, monospace;
+}
+.runSpec {
+ margin-left: 5px;
+ float: right;
+}
+#jasmine_content {
+ position:fixed;
+ left: 100%;
+}
Added: incubator/jspwiki/trunk/tests/javascript/assets/jasmine.css
URL: http://svn.apache.org/viewvc/incubator/jspwiki/trunk/tests/javascript/assets/jasmine.css?rev=819134&view=auto
==============================================================================
--- incubator/jspwiki/trunk/tests/javascript/assets/jasmine.css (added)
+++ incubator/jspwiki/trunk/tests/javascript/assets/jasmine.css Sat Sep 26 13:22:31 2009
@@ -0,0 +1,91 @@
+body {
+ font: 14px "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif;
+}
+
+h1 {
+ padding-top: 20px;
+ font-weight: bold;
+ font: 24px; /* "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif; */
+}
+
+p {
+ margin-top: 5px;
+ padding-left: 20px;
+}
+
+.fail {
+ background: url( ../images/fail-16.png ) no-repeat;
+ padding-left: 20px;
+ color: red;
+}
+
+.failInSummary {
+ color: red;
+}
+
+.runner {
+ border: 1px outset gray;
+ margin: 5px;
+ padding-left: 1em;
+}
+
+.runner.running {
+ background-color: yellow;
+}
+
+.suite {
+ border: 1px outset gray;
+ margin: 5px;
+ padding-left: 1em;
+}
+
+.suite.passed {
+ background-color: #cfc;
+}
+
+.suite.failed {
+ background-color: #fdd;
+}
+
+.spec {
+ margin: 5px;
+ clear: both;
+}
+
+.passed {
+ background-color: lightgreen;
+}
+
+.failed {
+ background-color: pink;
+}
+
+.skipped {
+ color: #777;
+ background-color: #eee;
+}
+
+.resultMessage {
+ white-space: pre;
+}
+
+.stackTrace {
+ white-space: pre;
+ font-size: .8em;
+ margin-left: 10px;
+ height: 5em;
+ overflow: auto;
+ border: 1px inset red;
+ padding: 1em;
+ background: #eef;
+}
+
+.runSpec {
+ margin-left: 5px;
+ float: right;
+}
+
+#jasmine_content {
+ position:fixed;
+ left: 100%;
+}
\ No newline at end of file
Propchange: incubator/jspwiki/trunk/tests/javascript/assets/jasmine.css
------------------------------------------------------------------------------
svn:executable = *